🖼️ Generai 🖼️

AI image generation before it was cool

With Kyrill Hux, Nicolas Muntwyler, Jan Schnyder
Try it out!
Visit the gallery

In early 2022, Jan shared with me some AI image generation models he had found. It took me by storm; I was already impressed by the results of DALL-E at the time, but those models seemed a step up. So we decided to try and make them even better.

At the time, there was no Stable Diffusion, and only one version of DALL-E. We trained a pipeline consisting of language & image models and the results were really impressive; before the AI hype, the competition was kinda dog, and our model gave state-of-the-art outputs (which, at the time, was Midjourney). We were also the first to generate (decent) 4K+ images.

So we built a platform around it. We got in touch with Stability AI and got pre-beta access for what would later become Stable Diffusion, were featured at the Zurich PopCon 2022, and got the chance to take the project to Y Combinator's W23 batch, starting what would later become nunu.ai. We never managed to make Generai pay our rent because we realized we don't really have any of the skills that B2C needs, and after a few months Stable Diffusion created a lot of strong competition in the space, but it was fun to try.

Prompt engineering was what people called the (at the time fairly hard) task of translating human thoughts into a prompt the machine does well on. Alongside parameter tuning, this was a significant blocker to getting good results. By analyzing over 3000 prompts submitted by our users, we built a collection of UX tricks and language models to get the prompts a professional prompt engineer would've made.

Sadly, we were broke students, and didn't get to buy our own A100 GPU clusters. So we had to stick to 3090s that we rented off of Ethereum miners (a bubble that coincidentally just popped). It was painful! Turns out that crypto miners are not generally good server admins (we were seeing a server failure more than once a day on average), but it taught us how to build a resilient system that can handle a lot of crashing. This way, we reduced our hardware costs from ~$2-8 per image on the big cloud providers to about 10c. At peak usage, we had over one hundred 3090s running at the same time.

The platform was built on Firebase, with Next.js, in TypeScript and a Python backend. We used Google Cloud & Vercel for deployments, Shopify for our print store, and Stripe for payments.

⛰️ Eternal Sunset ⛰️

Basically Cube World but roguelike and (kinda) not dead

With Patrick Eppensteiner, Jannik Gartmann, Rasmus Lüscher, Moritz Schneider, Kaan Sentürk
Watch the trailer

For many eternities
the sun rose as it set,
Until some day much later
Apopis put it to rest.

Awakened by Ra
There is only one chance
To travel through time
And return to old strength.

Follow the cats
To dig up Khafre's throne
And turn into blood
What turns you into stone.

We made this for the Game Programming Lab course at ETH, but we basically ended up making this a 200% full-time job. Eternal Sunset is a two-player co-op roguelike voxel adventure game. It's procedurally generated and features a progression system on infinite terrain.

At the core is the time mechanic. When the hourglass runs out of sand, the player will travel back in time right back to their spawn, but the world that they know will remain the same. As they explore more and more, they have to find a route to kill the final boss within the time limit. If they succeed, their run and the time they needed will be registered in the weekly leaderboard; at the beginning of the next week, a whole new world will be procedurally generated, meaning there is always fresh competition.

By the time the course ended, we had four different biomes with unique generation, seven dungeon types (each of which can create many variations using procedural generation), 9 unique enemies & NPCs (25 total variants), 71 items with unique behaviour, 13 of which being weapons split up into 4 classes with 3 attacks each, and over 1000 commits on our Git repo.

The game is written in C#, but not using Unity, instead we built our own engine on MonoGame (everything from voxel rendering to 3D physics is custom-made, though MonoGame provides us with some low-level rendering primitives). The world is divided into small chunks which are generated and loaded individually. This happens separately from the main thread, so it won't freeze the game; in fact, it can leverage as many CPU cores as available, resulting in a satisfying experience even when exploring a large world. This, plus the fact that we use advanced rendering techniques, allows us to render millions and millions of blocks with ease, far more than even established voxel games like Minecraft (which was developed with single-core systems in mind).

Animations in a block world are considerably different from what we know from real life. We built our own animation framework to facilitate this; it allows us to express complex transitions with just a few lines of code. We interpolate animations independently from game ticks, something that is required because time is our central mechanic and there are items which allow players to mess with tick duration & behaviour. This meant we had to scrap a large part of the MonoGame update loop, but the results are incredibly smooth 120FPS+ movements.

I could go on, but there's only so much space on this website. If you're interested, please don't be shy and reach out. And if you'd like to play the game, we do want to put it on Steam eventually :)

🃏 card-game 🃏

Playing card games in your web browser

With Jannik Gartmann
Play it online!
Source on GitHub

Jass is a card game in the Bézique family, originally played in the Netherlands but since then it has quickly gained popularity throughout the entirety of Switzerland. Today, Jass is considered Switzerland's national card game, so understandably demand for a digital version is huge. However, unfortunately we were very unsatisfied with the choices we had as many online-Jass portals run on Adobe Flash, while others are hidden behind a paywall or tons of ads, so we figured it would be our best bet to start work on our own engine. This way, we can also implement variants of the game that are popular in only small parts of Switzerland that many other apps don't support.

card-game is written in TypeScript and uses a modern, ES6-based coding style. One of our design goals was to make it easily adaptable to new game modes, meaning with just a few lines of code you can implement entirely new variants of Jass. In fact, because everything is modular, it could be easily transformed into an engine for any other card game.

✅ multiple-choices ✅

Assisting my students in passing the first year

Try it online!
Source on GitHub

Discrete Mathematics is often considered one of the most challenging subjects in the first year of the Computer Science Bachelor at ETH Zurich. I had the chance to be a teaching assistant during the autumn semester of 2018, leading a group of 25 Discrete Maths students through their first semester. multiple-choices is a tool that uses gamification and a simple and intuitive interface to motivate students to test their knowledge using multiple choice exercises. It turned out the tool spread a tad bit, so people outside my exercise class got the chance to use it, too! :D

multiple-choices is a frontend vanilla HTML/CSS/JS web app. It runs entirely in the user's browser and its only external dependency is KaTeX, a JavaScript LaTeX renderer.

🖥 mips-sim 🖥

A MIPS assembler and emulator

With Moritz Schneider
Try it online!
Source on GitHub

I don't think MIPS needs an introduction – 40 years old and some people still use it in production! (For better or worse.) It's interesting because it survived the test of time, and also because it's one of the (if not the one) most idiomatic reduced ISAs out there.

Containing only a small set of instructions, MIPS is much simpler to implement than CISCs like x86. So, Moritz and I decided to work on a MIPS editor, assembler and emulator for the browser. We spent a lot of time planning the software infrastructure so implementing our interface for a different architecture would be no harder than translating the specification document to source code. This resulted in a modular design where adding, removing and modifying opcodes is trivial.

♟ bobby-trawler ♟

A somewhat stupid chess computer

Fight me online!
Source on GitHub

In 1996, Deep Blue was the first chess computer to defeat the then world champion, Garry Kasparov. In 2019, Bobby Trawler was the first chess computer to defeat me, Stan Wohlwend. Granted, that is not quite true given I've already lost to a good bunch of chess computers before that and it also doesn't say much given I'm a terrible chess player, but it makes for a good introductory line.

Bobby Trawler consists of two engines, namely Tanner and Daedrian. Tanner is a brute-force engine that simply runs a search on all possible chess moves, using various techniques such as memoization to speed up the process. Daedrian uses a min-max algorithm, allowing it to have more elaborate game plans, but that also means it is less consistent. Because my chess knowledge is limited, the board valuation method is very basic, and also neither of the two engines use an opening book, making Bobby Trawler very vulnerable in the early game. However, if you can not get a decent lead against the computer early on, it becomes hard to defeat in the later stages of the game.

I've made a lot of optimizations on the assembly level to improve performance. By using benchmarking tools and analyzing compiler output, I found out which parts of the program can be improved by inlining critical functions and making the program less vulnerable to low-level issues like cache misses.

🚩 Evil Inc. 🚩

A somewhat sophisticated beginner CTF

Source on GitHub

SPOILER WARNING! If you're planning on trying this challenge yourself, stop reading right now.

Oh no! Evil Inc., a secretive organisation with the sole goal of total annihilation is about to destroy the universe and no one can stop them! No one? No, not quite! There is still hope, as there is a smart hacker on their mission to break into Evil Inc.'s systems and save the world! (That smart hacker is you.)

Yea, that's cheesy. But I need to hype it up somehow. Computer security is all about breaking into things, and in Evil Inc. your goal is to break into a server and steal a secret flag given just their website.

The player starts by doing simple attacks like SQL injection and directory traversal to gain read access over the user folder. But then, things become much more complicated. The player is presented with a Discord bot and a Minecraft server which were set up by unexperienced server admins, allowing the player to attack it. A combination of multiple vulnerabilities to first open a reverse shell, then gain root access over the system is needed to open the secret flag file.

Evil Inc. runs as a Docker container and is written in HTML/CSS/JS, Python, and Java. It requires no prior experience in computer security, though programming skills are important.

📈 uncharted 📈

A code-driven data visualization tool

Try it online!
Source on GitHub

Hah, usually it's the other way around, coding being data-driven and stuff, isn't it? Anyways, a vast majority of my plotting needs are "I have a (possibly complex) function and want to see how it looks like with different parameters". Sure, there are ways to do that (matplotlib, Mathematica, etc.), but I figured I spend most of my time not on the function but on making the plots look nice. I mean, do I really have to care about step size just to watch two lines intersect? And I wanna share the plots, too. I'm not gonna teach my friends Octave to show them how gas emissions affect the climate.

Uncharted is an opinionated charting tool with "reasonable" defaults. It takes a TypeScript function and a bunch of parameter values and does exactly one thing, plot that. Utilizing inferred parameter & result types from TypeScript's compiler, it presents a UI to let you tweak the values as you wish. The app is built with SvelteKit and uses a cutting-edge web stack.

⚔ Deep Duel ⚔

A 2D multiplayer browser game

With Kyrill Hux
Source on GitHub

While we initially started Deep Duel with the goal of making an AI learn to play a simple fighting game, we never ended up doing that and instead just emphasized on the fighting game part. Deep Duel is a fast-paced multiplayer duel game where you try to out-maneuver your opponent by hitting, dashing and shooting them on a two-dimensional plane.

Deep Duel is written in HTML, CSS, and JavaScript, using React for the UX elements, PixiJS for rendering and lance.gg as a multiplayer engine.

📚 Contest Library 📚

Reusing algorithms at a low performance cost

Source on GitHub

When participating in competitive programming contests, you often end up using the same algorithms over and over again. For this purpose, I've started putting them into a library where I can re-use them whenever. Being competitive by heart, this library now contains thousands of lines of code and many algorithms and data structures, such as sparse matrices, segment trees, range lists, primitive collections, multimaps, graphs, coloring, cycle detection, flow algorithms, tree traversal, prime factorization, modular arithmetic, string utilities, histograms, fast I/O, genetic optimization, and many more. Note that I can't just use third-party libraries as these are forbidden in most contests.

The number one goal is to learn more about the algorithms I'm implementing, which is why I'm always trying to find common ancestors of algorithms and data structures. For example, an adjacency list graph is equivalent to an adjacency matrix graph using a row-list sparse matrix, and Prim's algorithm is really just a special case of A* with a certain heuristics function. This kind of code re-use means that any performance improvement or heuristic I implement on the A* algorithm will subsequently also speed up Prim's.

It turns out that most competitive programmers use C++, and the exercises sometimes even expect you to. Java usually is slower, and the fact that I'm using an abstraction above everything does not help. Even though you'd expect constants to not matter in these contests, it turns out they do, and especially in Java where boxing and unboxing primitives is the default when working with generic types cache misses will generally do a huge difference. The library uses several tricks (eg. primitive collections) and heuristics (eg. using a linear search list instead of a hash map for small maps) to combat this.

Additionally, it performs some other jobs that can be useful during a contest; it has a built-in (disk) caching feature for large pre-processed data, reads input and output files, automatically off-loads work onto multiple threads, bundles and compresses multiple source code files into one big file, and eliminates unneeded classes.

🧠 Machine Learning and Artifical Neural Networks 🧠

Helping Rachel on her quest to world domination

Read the paper
Source on GitHub
Try the Q-Learning visualizer

I've been coding for a long time. Both my high school term papers were about artificial intelligence, one in philosophy and one in computer science. The latter is about helping Rachel, an artificial intelligence running on my computer, learn to play a simple card game so that she can finally take over the world.

To achieve her goal, Rachel uses Q-learning to understand the concept of a game state. For this purpose, I've created a visualization tool in Processing (using Java) which helps readers understand the concept of Q-learning. You can try this tool online using the link above.

Furthermore, I've implemented a simple feed-forward neural network in Java which can be used in conjunction with the Q-Learner, in a very similar (but heavily simplified!) fashion to what Google's DeepMind is doing with AlphaGo. It features several different activation functions and error propagation mechanisms. Combining the two allows Rachel to learn a very simple card game. For more information, please take a look at the paper! :D

🔥 fractal-flames 🔥

Generating nice pictures

Source and gallery on GitHub

Invented by Scott Draves in 1992, Fractal Flames build the basis for programs like Electric Sheep and Apophysis. The algorithm procedurally creates nice-looking pictures from only a single initial seed. This technique is now commonly used in computer graphics to generate flame-like or chaotic structures.

What initially was just supposed to be a high school project for computer science class is now a fully working implementation of the original Fractal Flames algorithm, with a bunch of optional tweaks. It's both less efficient and less powerful than modern implementations like those mentioned above – yet still, it can serve as a reference implementation of the algorithm in Processing.

🎮 SBServer and SBAPI 🎮

Developing a Minecraft minigame server with friends

With Jannik Gartmann (and others)

During high school, gaming after school has bonded our class together. One of the video games we played is called Minecraft, famous for many things; amongst them the countless modding and minigame communities. In a group of friends, we had been building a Minecraft minigame server – for this, Jannik and I have coded the required mods in Java.

The architecture is split into two mods. The first is SBAPI, a minigame API. Minecraft is a sandbox game and not a minigame toolkit, and as such creating minigame mods is a hassle. To make this a little easier, we built an entire abstraction layer on top of Minecraft, allowing you to build customizable minigames using only our API in a few lines of code, while leaving all the world generation, match-making, glitch prevention etc. to the API.

The other mod is SBServer. It contains the actual game logic and concepts of our server. Minigames include KitPvP (players choose one of many kits each unique with abilities, then fight in an arena), Bedwars (players defend their own bed whilst trying to destroy other players' beds), One in the Quiver (everyone gets a bow, every hit is a kill), Lobby Hockey (ice hockey, but in Minecraft), and many more. Most of these are popular games on many Minecraft servers among the community, but all our games always have unique features and twists which make them somewhat different.

The programming was done by Jannik and me, whereas various other friends worked with us on level building and game design/balance. We've also had several game testing sessions with a broader circle of friends to make sure our games are fair. SBServer had been a pet project for all of us for a very long time; in fact, I don't think there's any other project I've contributed as much code to as this one.

...and there's always more!

Throughout the past few years, I've almost always been working on at least one coding project. While some of them I will gladly show to the world, a vast majority have either never seen the daylight or just aren't big enough to be an entry here. After all, who finishes every side project they start? :)

Some examples:

• a food delivery app
• TV box software written for personal use on my Raspberry Pi
• a graphical IDE for making Minecraft modifications without programming experience
• a tool that can be used to crack LCGs (most notably java.util.Random)
• a minimalistic Connect-Four game with multiplayer and singleplayer (vs. computer) support
• a less polished linear algebra version of multiple-choices
• a biased betting simulator
• a Discord bot using Markov chains to learn from my conversations
• countless game prototypes
• a generative poem visualizer
• a Minecraft magic mod with spells, wands, and adventures

and more.

If you have any questions, drop me a message on n2d4xc@gmail.com :D