3D puzzle game built with Unity at KubiCorp, where I handle visual feedback, custom shaders, VFX, gameplay systems and optimization inside a small production team.

This is the indie counterpart to my consulting work: fast iteration, tight scope, tool pragmatism and visual decisions that must survive real production constraints.

3 years as Engine Programmer at Asobo Studio on one of the most visually ambitious real-time applications ever shipped, working on a custom in-house engine and delivering to millions of players worldwide across PC, Xbox and PS5.

Worked on graphics features, custom artist tools, cross-platform support and game optimization in a large production environment where every change had to respect performance, maintainability and platform risk.

The experience of shipping at this level is what makes the difference between knowing rendering theory and understanding what actually breaks in production, at scale, across platforms, under hard performance constraints.

Built from scratch to understand the fundamentals of raytracing, a technique becoming increasingly relevant in real-time rendering.

The initial CPU-only implementation was unusably slow: even with multithreading, a single frame took hours. Implementing CUDA moved the entire computation to the GPU, reducing render time from hours to seconds, the same principle behind modern hardware-accelerated renderers.

A foundational project for understanding GPU parallelism, light transport math and why performance work has to match the underlying execution model instead of only the source code.

After working with DirectX11, I wanted to understand what the graphics API was actually doing beneath the abstraction. The answer was to build a complete software rasterizer in C, no GPU, no API, just the CPU and math.

Implemented every step of the 3D rendering pipeline manually: vertex transformation, perspective projection, triangle rasterization, depth testing, texture mapping and basic lighting. This is depth proof: knowing what modern engines hide makes engine-level debugging much less mysterious.

Custom 3D engine built in C++ using DirectX11. Built after OpenGL to understand how different graphics APIs approach state, resources, pipeline setup and driver-level constraints.

First low-level graphics API project, built in C++ with OpenGL. It became the entry point into GPU programming and the start of a series of renderer projects that each went deeper into pipeline behavior.

Full Custom Scriptable Render Pipeline built from scratch in Unity, not a modification of the default pipeline, but a complete replacement written in C# and HLSL, replicating the visual identity of the music video LORN — ANVIL.

Working at the pipeline level meant implementing native rendering effects and stripping unnecessary overhead, exactly the approach used in production to build a specific visual identity while hitting performance targets. This project was a turning point: the render pipeline is not a black box, it is a programmable system you can shape to serve any visual goal.