Jean-Louis Voiseux

Personal projects

The list below contains various personal projects whose codebase I have published over the years. Most of these projects were started with an educational and/or exploratory outlook. They can be grouped in the following categories, reflective of my interests:

Engineering tools

Waveguide: A simple 3D FDTD implementation in C

FDTD (Finite-Difference Time-Domain) is a numerical method frequently used in computational electromagnetics. This basic package was written in C, with the ambition of later porting computationally intensive segments to CUDA. The main reference material used to learn the method and validate the code was Pr. John B. Schneider's excellent book "Understanding the FDTD method".

Lucyna: A CUDA C Llama 3.2 inference engine

What was initially supposed to be a simple learning experiment focusing on model tuning devolved into a full inference engine for Llama large language models (with a focus on the small 1B variant). It implements a transformer architecture with rotary positional embeddings, a model loader, and a simple tokenizer. Computationally intensive tensor operations are implemented in CUDA.

Boundary: A simple polygonal BRep CAD kernel written in C

There is a certain elegance in the boundary representation of solids. A relatively small set of basic topological elements (edges, faces, vertices), together with a compact kernel of basic operations, allows for accurate representation of a wide range of 3D shapes. This kernel implements the set of fundamental operations described in Martti Mäntylä's "Introduction to Solid Modelling" in C, with a basic ImGui + Raylib user interface.

Britten: A C compiler written in Rust

This compiler was started as an exercise while following along Nora Sandler's "Writing a C compiler". The book provides a language-agnostic walkthrough of the main building blocks of a compiler. This project puts a spin on the compiler described in the book by using LLVM as an intermediate representation, and by expanding on the provided test suite. It is still a work in progress, as only basic operators are implemented for now.

Rendering and computer graphics

Quack: A fast software renderer written in C

A graphics project focusing on trying to rasterize a scene as quickly as possible on a CPU with a combination of algorithmic (usage of scanlines, culling), data-driven (memory layout) and SIMD approaches. It is written in C, and the final texture is rendered using a SDL3 render target.

A simple CPU-based path tracer in Unreal Engine 5

In computer graphics, path tracing is a method that models light transport as a series of stochastic rays and allows for rendering photorealistic images. It is used in many applications, ranging from offline rendering, to real-time graphics. The core idea behind this project was to implement a naive offline path tracer (akin to the one described in Peter Shirley's Ray Tracing in a Week-end) in Unreal Engine 5, in order to benefit from the scene edition capabilities of the latter.

A DirectX12 viewer for the m3d model format, written in C++

This tool is a M3D viewer. M3D (Model 3D) is an application and engine neutral, universal 3D model format to store CAD models, meshes, skeletal animations and voxel images - it is notably used by the popular video game framework raylib. It allows for the embedding of animations and textures. This project started as an initiative to get more familiar with DirectX12 using the DirectX12 toolkit.

Anima: A simple animation pipeline written in C++

This project is an application of the concepts and code presented in Gabor Szauer's Hands-On C++ Game Animation Programming. It supports loading a glTF model and rendering blended skinned animations, with the skinning logic being run on the GPU or on the CPU depending on the configuration. It is written in C++, with OpenGL being used for rendering and glfw for the window context.

Master Thesis: Blind de-rendering, or how to turn a wall into a mirror

The rendering equation sums all the inbound light for a given surface, applies a function to those light contributions and returns the outbound light for that surface. In essence, ray-tracing is a direct implementation of that equation. The function applied depends on the material (for example, a mirror will not affect the inbound light, such that the outbound light will be similar to the inbound light). The goal of this master thesis was the explore the possibilities of recovering inbound light data, given outbound light data.

Game engines and game tech

Aerial: A C++ OpenUSD game engine based on Hydra 2.0 and Vulkan

Pixar's Universal Scene Description is becoming an established scene representation standard in computer graphics. OpenUSD, the reference implementation, provides a lot of adjacent utilities, including Hydra, a rendering engine geared towards taking advantage of USD. This project is an end-to-end implementation of a real-time scene renderer using Hydra's Vulkan backend to render a USD scene. It supports USD hot-reload, as well as Lua scripting for gameplay.

Perlin Rover: A ray-traced real-time simulation of a four-wheeled vehicle, written in C++

This C++ project is an experiment in heightmap-based terrain generation, physics simulation of a four-wheeled vehicle and real-time ray tracing using Nvidia RTX. This is achieved through the combination of Jolt, an open-source real-time physics engine, and Falcor, an experimental renderer from Nvidia. The result is a simple interactive application where a ray-traced four-wheeled vehicle can be moved around a procedurally generated landscape.

Birdsong: A dialogue system for the Bevy game engine

Birdsong is a dialogue box system for the ECS-based Bevy game engine. It initially started as an entry for Ludum Dare 52, then devolved into a fully fledged tool. What started as a simple dialogue box is now a simple interpreter that allows Bevy users to build narrative games. The following demo shows how the tool generates a game from a fairly straightforward script.

Video games

Orbital Mayhem: An educational VR game about the Kepler laws

Orbital Mayhem is a VR educational game about Kepler Laws. It was built with Unity and was designed to be played on a stand during the belgian music festival "Les Ardentes" in 2017. The experience is composed of two parts: an interactive tutorial and a game, where the player must use their newly acquired knowledge and modify the orbit of a planet in order to hit as many targets as possible in a limited time.

Game Jam entries

I regularly take part in game jams, short event whose participants attempts to build a game in a limited time frame, ranging from 48 hours to several weeks. The entries linked below are a selection of the ones most representative of the types of games I make, and were built using a variety of tools/engines (Unity, Godot, Blender, Aseprite, ...).

Other content creation tools

A markdown resume builder, written in Go

I write and update my resume using Markdown. The final document is created using a custom resume builder written in Go. It generates a HTML or PDF resume from a markdown file, is usable through both GUI or CLI, supports including a FontAwesome kit to include icons and also supports appending a picture.

Dust Speck: A procedural planet generation add-on for Blender

This project was started upon discovering Toni Sagristà's blog post on procedural generation of planetary surfaces. The outcome is a Blender plugin that allows users to procedurally generate textured planets. Random elevation is generated using simplex noise. The results can then be exported to any major game engine.