🚧 Currently work in progress! 🚧

A from-scratch written Vulkan renderer. Currently features:

• each material rendered with a single indirect draw;
• the most primitive render graph;
• basic PBR shading;
• cascaded shadow maps with PCF;
• tiled-based light culling in compute;
• Nishita inspired atmosphere;
• parallax occlussion mapping with binary search optimisation;
• SSR;
• bloom using Dual Kawase Blur;
• etc.

OpenGL (4.0) renderer written from scratch in C++. Uses tiled-deferred rendering pipeline and supports various different methods of transparency:

• forward transparency;
• depth peeling;
• dual depth peeling;
• order-independent transparency;
• A-buffer (per-pixel linked list) transparency.

XPBD simulation based on famous Matthias Müller papers: PBD, XPBD, Small Steps in Physics Simulation, etc. The goal of this project is to have a wide range of physics entities (cloth, bodies, fluids, etc.) interacting with each other.

Currently features basic soft-bodies and cloth. Working on rigidbodies and fluids (based on Position Based Fluids a method leveraging SPH fluid simulation I have implemented in the past) and better collisions.

Visualization is done with basic shapes in a renderer written in Vulkan. Eventually physics calculations will be transfered to compute.

Software pathtracer written in Zig (wonderful language!). Still a lot of features missing, but having a CPU pathtracer enables testing various ideas without having to involve the GPU. Since it has the potential of introducing oh-so-fun seizure inducing debugging sessions.

Gave a 2 day lecture to high-school students where they were tasked with writing their own software renderer. The idea builds on top of the software renderer I wrote back in 2020 or so.

They were provided a Raylib based skeleton where they had to implement line drawing (mostly Bresenham’s algorithm), triangle drawing (line sweep and barycentric approaches) and finally add their own shading (Gouraud and Phong models).

Most students managed to achieve a result shown in the picture.

An experimental ELF/DWARF debugger drawing inspiration from reverse engineering tools. Mostly experimental to try out innovative debugger functionality like:

• Inline stacks (demo in the video).
• Multi-context watch window.
• Basic-block like view for program flow inspection / codepath-sensitive breakpoints.
• etc.

Software rasterizer written in C++. Draws directly to Linux framebuffer without having to involve any graphics API whatsoever. Served as a great introduction to graphics programming – there’s no better way of learning how things work but implementing them yourself.

Smoothed Particle Hydrodynamics fluid simulation using compute shaders. Based on this whitepaper. Served as an intro to compute shaders. This uses a rather old technique by presented by Simon Green (NVIDIA) at GDC 2010 called screen-space fluids.

In fairness to the authors, I did not do the screen-space fluids technique justice. However, that was not the goal of the project - learning about compute shaders was.

A cycle-accurate NES emulator written in C. Features debug widgets for:

• decompiled code;
• CPU / PPU state;
• palette and pattern table;
• RAM.

A multiplayer mobile game that won 2nd place at Hacker Games Vilnius 2017 hackathon.

The game requires people to join the same “game room” and then gives participants 30 seconds to collect the most points by shaking their phones vigorously.

Game app was made with Unity and backend was websocket based golang service.

After getting really frustrated with a frankly ridiculous undebuggability of a quest system on a certain project I decided to see if I can do better in a few evenings. It ended up having 90% of the features (+ some additional ones), better extensibility and a better editor. Not to mention it being 1/20th of the size.