All-Purpose Mat

An ad blocker for Discord implemented as a CSS theme. Hides all Nitro/Boost upsells.

I update this one regularly to keep up with the latest changes from Discord.

This very website! I learned quite a bit of HTML, CSS, and JS making it. I also learned about sysadmin and Apache2 (at first) and NGINX (now).

It's hosted on my own infrastructure and never requires JS to be usable. I focused lately on using semantic HTML and trying to design around accessibility.

NixOS is a Linux distribution where you declare everything—programs, services, Neovim plugins, users, status bars...—in a programming language called Nix. This has many benefits, the main ones being a perfectly reproducible system (reinstalling gives me my exact desktop back) and the ability to version control every change via Git. Every time I make a functional change to my computer, I push it to this repository.

This is super useful for developer teams as it totally eliminates "it works on my machine" and makes these kinds of issues debuggable. Nix can also work without the OS and just configure things like shells with the exact needed C++ library setup or compiler, and I am willing and happy to deploy Nix for my next team project.

I wrote a small engine as a way to play with the Vulkan API. It can render standard PBR materials as well as other shaders (I made a water shader I quite like!).

It is integrated with the Jolt physics engine via an abstraction, which makes it easy to plug in any other library.

A two-player physics-based cooking game made in a team of four over the course of ~6 months. I worked with an amazing team composed of two programmers and two artists.

We used Perforce for version control (which was new to me as I usually use Git) and maintained a devlog. We used a tech doc, a Kanban board for issue tracking, and held weekly meetings that were all documented internally.

We also submitted our game to the Rookie Awards 2024.

A viewer for the Super Mario Maker Database written in <12h with C# and Avalonia, following the MVVM design pattern.

The name is a pun on "New Souper Mario Bros. Wii", but it sounded funnier in my head.

This is a version of the engine used at DAE (my university) for Programming 2, which I modified and partly rewrote to add Linux and web (WASM) support. My game "The Dozen-Year Door" uses this engine.

To add certain features such as shaders and proper web support, I wrote a an OpenGL 3 backend for the OpenGL 2 commands that were taught in class. This allows it to support shaders, but keep existing student games working regardless of the backend used. Several students used my engine's backend to port their existing games to web.

I rewrote the .NET Framework 4 program used in the DAE course Programming 4 to check student submission .ZIP files in Python, adding many quality-of-life features and importantly Linux support.

It was used by myself and fellow students to accelerate the weekly submission process via its auto-packing mode that generates a valid .ZIP file given the source tree, and its checking mode was useful to me as I could not run the .NET Framework checker on my Linux laptop.

For a certain DAE course, I was required to watch playlists of multiple videos. I learned some JavaScript and reverse engineered part of the platform used by the university, and made this userscript that does a few things:

• Auto-plays the next video instantly;
• Saves and sets the playback speed across pages;
• Allows for continual fullscreen mode;

Over the course of a week, I wrote a small engine to learn WebGPU basics, then I gathered a team for an upcoming game jam and we made a game with it. We were the only team with a custom engine, and presented our game in person in front of various companies.

On a self-hosted wiki, I documented several challenges and workarounds I encountered in my journey to do my university degree on Linux. There's pages explaining how to use tools I wrote, and others explaining things to watch out for when handing assignments in.

The wiki is mostly complete with the needed info, and has been useful to some students in the year after me who are looking to do something similar to what I did.

Before making CMakinator, I still needed a way to build & run projects given in class as .sln. I wrote this Python script which parses the .sln format and its accompannying .vcxproj files and composes a clang invocation to cross-compile it for Windows. All the Windows-only APIs still work as it targets a .exe Windows binary, but I can now build it from Linux.

I wrote a blog post about the tech!

A graphics programming assignment required writing a PBR viewer in DirectX, so I wrote a system to build it on Linux via a Vulkan translation layer called DXVK, and also added a Wii+GameCube backend as an excuse to bring a Wii to my exam. It was a great success and I am very happy with my cross-graphics-API (and input!) viewer.

I wrote my most popular blog post about the DirectX part, and my favorite blog post about the Wii part!

I designed a brain to possess the player character in a zombie survival game, taking its surrounding geometry and enemies as stimuli and responding to them via actions. I used a pushdown automaton (click to see the code to allow it to switch to high-priority tasks (like shooting at a zombie) but still remember what it was previously doing (searching a village for loot).

As this was a university challenge, a leaderboard was set up to track who survived the longest. I wrote a client for the API which is now archived here. You can see my design ended up in third place overall for points.

I wanted to challenge myself to make a type of game I haven't made before, as a way to also learn to use UE5. I chose the horror genre, and made an allegedly pretty scary game based around the "weeping angels" of Doctor Who, which are creatures that turn into solid stone when you look at them. And you can't kill a stone. Of course, it can't kill you either, but then you turn your head away. Then you blink. And oh yes it can.

This was my first time using Git LFS to store and version the large assets from this game, and it went quite well. I also compiled Unreal Engine from source to make some patches so it would run nicer on my computer.

As an excuse to learn Godot, I wrote a research paper about voxel world generation (like Minecraft) that expands infinitely in all dimensions (including height). I was able to do that because I kept the function context-free, meaning each cubic chunk is fully independent from others.

To fully understand the modern 3D rendering pipeline, I implemented all the steps to draw a PBR scene on the CPU. Additionally, I hooked up a volumetrics/smoke raymarcher that uses the existing rasterized geometry's depth for culling, thus integrating well into the scene.

I added an SDL_Renderer + imgui backend to a pure Win32 engine, basically rewriting it entirely while maintaining the same API and behavior. I made sure to obtain the same exact results than the Win32 backend, so I could be confident that something I make on Linux will look and work the same on a grader's computer.

I did my exam in this engine and was graded based on its Win32 behavior, which was a resounding success.

For the 2010 Java 4KB jam, the creator of Minecraft submitted a version of the game that fits in the size limit. However, it has become unplayable over time, and I wanted to learn about how it works. Alongside two friends, we reverse engineered the entire game's algorithms and systems to understand it, and then I extended it via extra UI, better worldgen, and multithreading its CPU renderer.

Unfortunately, the final version was very high above the original's 4KB limit and I was hitting performance limitations of raytracing on the CPU in Java, so I started over in C++ with compute shaders. This again ended up too big, so I finally rewrote it in C and ended up optimizing it all the way down to 2952 bytes, which is barely small enough to fit inside a QR code. I wrote a blog post detailing the process and the madness that this was.

I fixed a bug in my favorite Matrix client FluffyChat, patching permissions and code issues with the calling feature (it was previously entirely unusable!). It was merged and is now a part of FluffyChat, which I use every day!

Another merge request I made adds a feature to search for an emoji you want to type by name. Before, you had to go through the categories and try to spot the ✨ (seriously I still don't know where it is!).

I made a third MR which fixes a bug where the emoji autocomplete was inaccurate. I switched it to use the same search algorithm as my other MR.

These last two are fully functional and one is approved by a project member, so they are ready for merging. They likely haven't been merged yet because FluffyChat was going through some organizational changes at the time I made the MRs.

After setting up this proxy myself to try out the new Element X client and running into issues, I decided to help the next person(s) along and document my steps in the official repository's README. My contribution remains there to this day!

Using my GameDevEngine2 shaders backend, I made this game with my good friend Jean for the Game Maker's Toolkit 2023 game jam. The theme was "roles reversed", and we decided to make a farm simulator where you play as the pests that steal the crops rather than the farmer trying to control them.

A recreation of the battle system from Paper Mario: TTYD. I wrote the engine for this based off of my GameDevEngine2, adding support for a complex skeletal animation system for sprites defined as a YAML file. Every character is composed of many small sprites that move in a data-driven way based on the current animation.

You can read more about this on my main page!

I wrote a C program that prints hello world without ever having a single line of C, or containing the string "Hello world". In fact, main is not even a function here, but rather a int[] containing the bytecode of self-referencing assembly instructions that use the UNIX write syscall to print characters to the console.

Please see the README for a full explanation.

I guided a friend through making a Minecraft clone as a way for them to motivate them to learn programming and Git. We succeeded, and implemented a functional demo in less than two weeks.

The color picker I use with Hyprland didn't have a way to cancel selecting a pixel, so I added a keyboard event listener to it and exit the program if escape was pressed. This MR was merged and is still a part of this popular program.

Based on the fun effect in KDE Plasma called "Wobbly Windows", I implemented a slime simulation which applies to windows moved in my compositor of choice, Hyprland. Although the simulation works, university requirements meant I did not have time to hook it into the renderer, so the pull request never moved on from being a draft. I plan to revisit it as a plugin eventually.

This is a valid Python program that also compiles and runs with a C++ compiler. I made this to explore the possibilities of the C preprocessor, and I typed my process up in a blog post.

I implemented my own feature request for the Linux compositor I use (Hyprland), which is to allow changing workspaces by dragging multiple fingers on the trackpad, and having the motion onscreen follow the fingers exactly. I successfully implemented this despite being new to the codebase, and the gestures have now become a signature feature of Hyprland (which I use all the time!).

Note that although the MR itself was closed, a rewritten version of my code ended up in Hyprland.

My first foray into programming was game modding, and specifically working on the level editor for the games I grew up with: Super Mario Galaxy 1 and 2. I forked the level editor Whitehole after its development stagnated and fixed most of the outstanding bugs. I then focused on adding features I wanted to see, some of them being:

• A What-You-See-Is-What-You-Get editor for the game's rich text format;
• Various editors for formats that were not yet documented, to aid in reverse engineering them;
• Create and preview camera angles in the 3D view (before this, you had to input values in radians and hope);
• An editor for the bezier-based intro cutscenes at the start of each level;
• An OS-integrated viewer and editor for the game's archive format (like .zip files);
• Editor commands such as copy-paste and undo/redo;

A fork of my Whitehole version is still used by hundreds of people in the modding community to this day, so I guess it was pretty successful.

As its codebase was getting harder and harder to maintain, I attempted the huge task of rewriting the Whitehole level editor in C++. This was my first time working with Qt, and I was very happy to learn to play with its own library features that deviate from the C++ standard library. I implemented binary file parsing for plenty of file formats used in Mario Galaxy, such as textures, models with skeletal animations, file archives, compression formats, and shader generation for the complex material system that drives the renderer.

Although I never got the editing part to a working state, it does successfully parse most levels in the game and can dump data such as textures. It was very interesting to learn to work with a new framework and design a healthy codebase to replace Whitehole's aging design. I'd like to eventually go back to this project and finish it.

I rewrote the build system and fixed the nonstandard C++ code included in this framework given to first-year DAE students. This allows it to run on Linux, and improves performance.

This is a game for the 2022 Game Maker's Toolkit 48h jam, made in my game engine with my friends Jean and OrchidWolf targeting Linux, Windows, web, and Android. We ranked 283^rd out of 6200 entries in the Presentation criterion.

I learned a lot about deferred/async tasks, integrating with unusual platforms such as Android and web, and writing performant graphics code. This is the last game I made in this engine, as I felt that I learned enough C++ to start from scratch and design something even better.

As a birthday gift for a friend who's really into Sudoku, I made them a clean Sudoku app with sleek animations. I implemented the game itself with an intuitive UI, and also some features which I was frustrated to see locked behind ads/microtransactions in other Sudoku Android apps.

I am particularly happy with the fully custom themes implementation, the leaderboard, and the (so far) unbreakable save system.

My first jam game, I worked on this with my friends Jean and OrchidWolf. It uses my first game engine and I later added web support to make it playable online.

I am really happy with how this game turned out, and it was a lot of fun to work on. After the jam, we added an official modding API and a speedrun mode to support the small community that grew around it. There's an Octopuzzler speedrun world record and there are custom maps available for it.

This tool takes as input function names mangled by a specific linker (CodeWarrior) and outputs de-mangled names and their argument/return types. I ported this out of a Ghidra extension and into a standalone CLI tool that is able to batch process names, which is useful for reverse engineering efforts of Wii games (CodeWarrior was the toolchain they used).

Over the course of multiple livestreams, I developed a "demake" of the VR game Beat Saber. I was able to parse real maps from the game and display the notes in the right place, but unfortunately I was unable to get the required motion data from the Wiimote to be able to track their position and rotation with a satisfactory accuracy. Although the project isn't finished, I still learned a lot about how a workflow with a separate device works, and its API design.

My development setup allowed building the binary and sending it to the Wii over Wi-Fi, which massively sped up iteration over the usual homebrew cycle of copying files to the SD card and loading them from the Homebrew Launcher manually every time a change needs testing.

A supporting app to my paper Rendering 3D Cross-Sections of 4D Fractals, this is a simple GLFW wrapper for calling a fragment shader on a quad that covers the viewport, thus allowing the shader to render an image driven by math. In the paper, I used the derivative of the Mandelbrot set's formula (extended to 4D hypercomplex numbers) to produce a distance estimator, and raymarch the resulting shape.

I learned about optimizing shader code, and also lots of calculus through this paper.

As I have a lot of fun building my own Linux desktops by picking and matching different parts, sometimes there are features missing or less well integrated. Using the Polybar status bar, I didn't find a satisfactory module that allows controlling the currently playing song on Spotify, so I made this. It's a Python script that by default sends out updates to display when the song changes, and optionally takes an argument to play/pause or skip a song.

Although I no longer use this script in my NixOS setup, it was very helpful up until I switched off of Arch!

This is a fork of Paperview, which is a Linux app that sets an animated wallpaper by rapidly switching between a bunch of images. This works fine on desktops, but unfortunately uses a ton of power on laptops. As the wallpaper I wanted (a scene from the game Celeste) does not need that much movement, I made my own version that simply takes a sprite and animates its position to float up and down.

Although I no longer use this app in my NixOS setup, it was very helpful up until I switched off of Arch!

As a research project, I designed a custom CPU architecture with a friend, for which I wrote an emulator. To test the emulator, I also wrote an assembler and a full compiler for a language with constructs such as for loops, if statements, and variables. We built a semi-functional version of the CPU together on a breadboard, but due to COVID-19 we were unable to finish the physical part.

With one of my friends, we began documenting the functions, variable names, and code organization of the official online port of Minecraft Classic. I learned a lot of JS through this, and we reverse engineered nearlt the entire world generation code, as well as some of the player controller.

The code is self-hostable and is still fully functional, however the multiplayer servers appear to be down.