Hi, I'm Mat. All-Purpose Mat.
I'm a cross-platform engine programmer passionate about Linux and C++
Matias (he/him)
Fluent: English, Spanish, French
Beginner: German
Some of the environments I've worked in include:
Writing custom C and C++ game engines from scratch;
Graphics programming with OpenGL, Vulkan, and WebGPU;
Build systems (CMake) and CI/CD (push actions, webhooks);
Tool development for both CLI and GUI (Qt C++. Avalonia C#, Java Swing);
Linux server setup and administration (like this one!);
Lua/C++ integration;
App development in Flutter;
Web dev with HTML, CSS, JavaScript, and WebAssembly;
Embedded operating systems in C;
Check out my blog !
I don't put photos of myself online so here is my cat Athos instead :)
As a personal challenge I literally rewrote my university's Windows stack to also support Linux. What's next?
As a personal challenge I literally rewrote my university's Windows stack to also support Linux. What's next?
As a personal challenge I literally rewrote my university's Windows stack to also support Linux. What's next?
My favorite blog posts
Let's explore the unique challenges of porting a DirectX model viewer to an entirely different graphics architecture.
Setting up a Linux-native toolchain to develop a DirectX graphics app via DXVK-Native's Vulkan translation.
In my journey to do all of my degree on Linux, I set up a build system to allow Win32 development with full IDE support.
Using some insane C, compiler, linker, executable, and binary patching trickery, I fit a playable raymarched version of Minecraft entirely into a QR code.
Click for lots more posts!
Featured projects
A custom-engine remake of the battle system from the original game.
Solo project, with a custom animation system driving sprites and multiple graphics backends.
Playable online!
Play in
browser!
How to play
Press A and D on your keyboard to cycle through options.
Press Space to accept the option.
Jumping
Press Space as you land to double-jump and deal max damage !
Press Space at the apex of either jump to impress the crowd with a
Stylish trick.
Hammer
Hold A to charge the hammer up, and release when the big circle lights up to
deal max damage !
Press Space as your hammer lands to impress the crowd with a Stylish
trick.
Summary
After playing through Paper Mario: The Thousand Year Door, I was very impressed with how they
pulled off the artstyle. This is why, when given the assignment to recreate a "2D" "retro" game
in my first year of university, I opted for this one.
I had a lot of fun reverse engineering the formats the game uses. Each character in the game is
an intricate collection of small sprites acting as a fully articulated armature, and I got to
re-create this system from scratch for my demake. I ended up designing a custom YAML-based
format to store the scene graph and all the animations for each character (click
to see an example ).
I also enjoyed simulating a 3D effect within the 2D limitations of the engine, which I did by
remaking parts of the stage in Blender and rendering out layers, then writing a parallax effect
to really sell the effect when moving the camera. I am very proud of how well this turned out.
As I use Linux, I undertook porting
the entire engine we were given,
as well as its build system, from a Windows-only Visual Studio .sln project to a cross-platform
CMake system. With that I also brought support for Emscripten and other platforms, which allowed
the final game to be playable online!
Another large part of my engine work went to writing a custom OpenGL 2.1 driver on top of OpenGL
3.3. This allowed me to better debug the various systems at play (the de-facto graphics debugger
RenderDoc does not support the older API), while keeping compatibility with existing code. I
made my engine modifications available to other students, and others have been able to benefit
without changing almost any code thanks to my compatibility layer.
Tech Used
C++
Custom OpenGL engine
CMake
SDL2
Emscripten
Things Learned
Hierarchical State Machines
Graphics API implementation
Particle systems
Data-driven animation
Armature animation
My role
This project was made entirely by me.
The art however is all from Nintendo's game The Thousand-Year Door and belongs to them.
A C demake that fits inside 3000 bytes via some insane tricks.
Solo project, raymarched voxel renderer on the GPU with no stdlib and custom build steps to save every single byte.
Has a blog post!
Summary
In 2010, Notch remade Minecraft for a jam in a very limited form, using the now-defunct Java
Applets framework.
Additionally, performance was limited by the single-threaded sequential CPU raymarcher which
Notch implemented.
I fully reverse engineered the game, and multi-threaded the raymarcher. However, this was not
fast enough to run at a reasonable resolution.
I decided to remake it fully in a fully custom GPU-accelerated ray-marched C++ engine.
My cross-platform engine uses a suite of methods to finagle a lower storage footprint, as was the
objective of the original Java game.
Rather than storing them as space-costly PNG files, the textures are generated through
unique procedural algorithms at runtime;
In place of using a large library, the raymarcher is specifically implemented in compact and
efficient GLSL;
Rather than dynamically linking entire DLL files, the build selectively strips unused
functions and statically links libraries;
The accurate fixed-step physics engine is contrived in a single short function;
Shadows are inexpensively yet precisely calculated through reflecting rays towards the light
source and shading accordingly;
However, this was not yet as small as the original. I made it my goal over several years to fit
a playable, hardware-accelerated version of Minecraft into a QR code.
That gives me 2953 bytes to work with, which is smaller than the original Java app.
I have fully docummented the journey in a blog post ,
this was one of the projects I found the most fun.
Tech Used
C
Voxel raymarching
Manual dynamic linking
OpenGL compute shaders
Inline x86 assembly
GNU Makefiles
Custom linker scripts
Executable self-decompression
Things Learned
Data compressibility optimization
OpenGL performance profiling
3D texture handling and generation
Procedural texture algorithms
Complex build environments
Code size profiling
My role
This project was made entirely by me, with support and ideas from friends.
Puzzle game made with one of my existing custom engines in 48h for a game jam.
I worked with a game designer and artist; all the code is by me.
Playable online!
Play in
browser!
How to play
Right click an octopus eye on the right .
Then, click a control on the left to bind it .
Finally, click the eye to execute the bound controls in order !
Summary
My first finished game! Octopuzzler is a puzzle game about managing constraints
and saving your files into a floppy disk before the octopus's ink covers your computer.
The game was rated 82nd out of 5800 entries in the Originality
ranking on the 2021 GMTK Game Jam.
I wrote its custom C++ and OpenGL game engine as a way to learn both, and what started as a 3D
engine with custom physics (I plan to revisit this!) ended up as a very extensible 2D engine
which I used for a few other games.
I have since ported it to the web, and updated Octopuzzler post-release to work in it.
Tech Used
C++
CMake
Custom engine called "Outrospection"
OpenGL 3.3 and WebGL 2
Emscripten
GLFW
SoLoud audio engine
JSON parsing
Things Learned
Input binding
Functional programming
Event bus
UI layer stack and event propagation
Resource management and registry
Platform abstractions (macOS, Android, Linux, Windows, web)
My Role
I wrote the custom engine for this game from scratch, as well as all the gameplay scripting.
The art was drawn by my good friend Smudge, and the score was made by OrchidWolf.
Research paper about fast parallelizable infinite world generation.
Reference implementation in Godot with online demo.
Godotcraft (2024)
Play in
browser (new tab)!
How to play
Right click an octopus eye on the right .
Then, click a control on the left to bind it .
Finally, click the eye to execute the bound controls in order !
Summary
I'm always looking to learn new things, and when I read about Godot Engine after the
Unity pricing fiasco, I knew I had to try it. To familiarize myself with the engine, I wrote an
exploratory research paper on voxel world generation which, unlike Minecraft's, is extendable
infinitely in any direction. To achieve this, all logic is (almost) purely based on its location
in the world, rather than neighboring blocks. I had a lot of fun working on this!
Click here to view the
paper.
The final demo features three different biomes (hills, plains, mountains) seamlessly blended,
overhangs and cliffs, infinite depth-attenuated caves, tree and grass generation, and unbounded
build height and depth.
Tech Used
Godot Engine
GDScript scripting
Fractal brownian motion and Worley algorithms
Voxel Tools C++ module
Things Learned
Noise layering
Thread-safety via thread-local resources
Deterministic algorithms
Chunked worlds
Optimization through caching
Reverse Abduction Simulator
Game made in 48h in one of my custom engines designed around deferred tasks.
All code is by me, while art and design are by my teammate.
Playable online!
Play in
browser!
How to play
Click the arrows to change the human's look.
Press the UFO to send them to Earth.
Do not send humans with alien traits (or dynamite)! They will blow up
the others and lower your score!
This is my second original game! Using my own handmade C++ and OpenGL game engine supporting
desktop, web, and mobile platforms, Reverse Abduction Simulator is a short
game which puts the fun challenge of paying extra attention while letting people accross a
border of "Papers, Please!" and combines it with the endless character customization
possibilities of the Wii's "Mii Maker" into a frenzied rush to repopulate Earth before your
alien boss gets back from his coffee break and notices you accidentally deleted all the humans.
We ranked 283rd out of 6200 entries in the Presentation criterion of the
2022 GMTK Game Jam.
Tech Used
C++
Custom game engine
CMake
SDL2
Emscripten
Things Learned
Z-ordered 2D drawing
Deferred async tasks
Cutscene system (see the ending!)
Web integration with C++
My role
I wrote the game engine used in this game from scratch, and did the rest of the programming.
The art was done by my good friend Smudge, and the audio design and score is by my friend
OrchidWolf.
Fast implementation of volumetrics raymarching, mixed with a CPU raytracer.
Raytracer supports PBR shading, reflections, and shadows.
Has online demo!
View in
browser!
How to use
You can use the imgui controls to change scene.
The raytraced volumetrics are in the Volumetrics scene, but do note it has performance
issues on web! It runs smoothly on Linux :)
Summary
As a research project, I expanded a university assignment where we write a CPU raytracer to also
support volumetric smoke. I used a raymarching technique to step through voxels of smoke, and
cast reflection rays to calculate lighting via Beer's law.
Tech Used
C++
CMake
OpenMP and std::execution (multithreading)
Worley noise
Things Learned
Generalized lighting equation
Beer's law
Tracey live profiling
Acceleration structures
Heap profiling and cache coherence
Polished Sudoku app for Android.
Published on F-Droid!
Summary
As I set up my de-Googled phone, one app I could not find a satisfying FOSS replacement for was
my Sudoku app.
I decided to instead write this one both as a way to learn Flutter/Dart and as a surprise
present for a friend.
It turned out very polished, and I am really happy with it! It is published on the free and open
source F-Droid app store.
Tech Used
Flutter
Dart pub.dev packages
Android Studio
Things learned
Android app workflow
Fastlane metadata setup (for F-Droid)
Performant UI code design
Async APIs with futures and promises
My Role
I wrote this whole project myself.
Beat Saber demake on the Wii.
Solo project, an experiment on unusual input methods.
Parses maps from the original game!
Biit Saber (2021)
This project aims to “demake” the Virtual Reality game Beat Saber on the Nintendo Wii
console.
I used the ideas from this
writeup in order to
achieve accurate 6DOF
tracking on the Wiimote.
I learned to use the Wii's GX GPU API to render sabers and blocks, the JSON format to parse
user-generated maps,
and the wiiuse library to interface with the
Wiimotes.
Tech Used
C++
Wii Homebrew toolchain
KDevelop
wiiuse
nlohmann json
Things Learned
Euler's method of integration
Low-pass filtering
Rapid development on alien platforms
Embedding files into code at build-time
My Role
I made this project entirely myself.
3D game made in a custom engine built on-the-fly in <1 week.
Worked with a programmer and four artists, using a novel technology (WebGPU) and dynamically molding the engine around the team's needs.
Wreckage Runner (2024)
For the DAE Unwrap 2024 game jam, I decided to challenge myself and learn something
totally new. I had heard about the WebGPU graphics API, which is a next-generation API
that works not only on web but on desktop platforms with high performance.
Its complexity is akin to Vulkan but it is compatible with far more platforms, as it
can use many different backends under-the-hood.
I wrote the game engine in two days right before the jam, and we put together a team with fellow
DAE students brave enough to try something new.
Tech Used
C++
GLFW
WebGPU
SoLoud Audio Engine
Forgejo Git Forge
Skills Learned
Working in a team
Learning new APIs on-the-fly
Git + Kanban board workflow
My Role
I made the entire engine and some of the gameplay logic for this game.
The sound integration and rest of gameplay is written by my friend Yarno,
and the art was done by fellow DAE students Luiz, Oskars, Giorgio, and Pelakauskas.
More about me
My life has involved a lot of travelling: I've lived in Spain, the USA, France, and Belgium. I am now in my third year of game development studies at DAE (Howest) , though I'm spending this semester on an exchange at Abertay University in Scotland. I am 19 years old.
I have completed the International Baccalaureate Diploma Programme , which is a rigorous high school diploma focused on worldwide collaboration. I chose to specialize in Mathematics (Higher Level) as well as Physics (Higher Level) as they connect with my interest of game programming in both physics and graphics.
Working with other people is a large part of what makes development interesting for me. Almost all of my projects involved working with others across the world.
I believe strongly in Free and Open Source Software (FOSS). I use FOSS pretty much exclusively, and no devices I use run proprietary code within possibility. I contribute to FOSS projects that I find useful, such as when I added trackpad gestures to my Wayland compositor of choice Hyprland .