Description

FSR is AMD's upscaling, frame generation and denoising technology, integrated in hundreds of games.
On the FSR team I work on the SDK's foundations: build infrastructure and toolchain, shader compiler performance, portability, and hardening of the codebase.

Information

Duration: December 2025 - present
Role: Software Engineer, FSR team
Skills: C++, HLSL, Python, DXIL/SPIR-V, shader toolchains, build systems
Tools: Visual Studio, VS Code, ninja, clang/clang-cl, AddressSanitizer, PIX, RGP, Git
Team members: AMD FSR team

Contributions

• Modernized the SDK's build infrastructure across all FSR components (upscaler, frame generation, denoiser)
• Ported the build scripts from batch to Python for portability
• Added ninja and VS Code support; implemented clang/clang-cl builds
• Implemented AddressSanitizer builds to catch memory and ABI issues early
• Fixed build dependency tracking so shaders and sources rebuild when scripts, includes or generated headers change
• Sped up shader compilation ~2x on average in one module, across DXIL and SPIR-V
• Reworked hex-in-header shader embedding into resource-linked binaries, cutting incremental build times 2-5x in one module
• R&D on unifying duplicate shader code (push constants, globals, link-time constants/flags) to cut compile time and binary size
• Implemented GPU crash breadcrumbs; helped debug and implement a driver fix
• Found and fixed latent issues such as misaligned memory loads

Description

Lumion is a widely-used real-time architectural visualization tool. At Lumion (Act-3D), I contributed to modernizing its legacy Effects11 rasterizer into a pathtracer using DirectX 12 Raytracing.
My work focused on raytracing integration, porting, GPU performance & debugging tools, shader tooling, and R&D features.

Information

Duration: September 2019 - October 2025
Role: Intern → Junior → Senior Graphics Programmer
Skills: C++, HLSL, DirectX12, DXR, Shader/GPU tooling
Tools: Visual Studio, PIX, NSight, Git, CMake, Jira, RenderDoc
Team members: Act-3D graphics and engine teams

Contributions

• Integrated DXR 1.1: BLAS/TLAS, SBT, inline RT, and RT collections
• Unified raster + raytracing: bindless rendering, V-Buffer, and instance management
• Implemented denoising: NRD (ReLAX, ReBLUR, Sigma), OIDN/OIDN2
• Developed features: raytraced water, grass, glass, shadows, GI, and fake caustics
• Prototyped GPU kD-tree building (photon mapping/caustics), advanced RT grass, and RT characters
• Created shader tooling: SM4/5 to SM6+ HLSL migration, reflection, and shader includes
• Improved offline + runtime shader pipelines with multi-threading and shader variants
• Tooling: (debug/perf) markers, crash diagnostics, memory allocations exporter
• Open-source contributions: DXC, HlslTools, DirectX-Headers

Trailers

Watch official Lumion 2024 trailer – © Act-3D B.V.
Features I contributed to in this version include
(real-time) denoising, RT glass, and fake caustics.

Watch official Lumion 2023 trailer – © Act-3D B.V.
Features I contributed to in this version include reflections, shadows, and GI.

Description

Wisp was a real-time raytracing library that could've been integrated into your favorite engine or tool, made by a team of nine students. It was used in a Maya extension that allowed you to view a deferred, full raytracing, hybrid and path traced preview of the current scene.
The goal of the project was to allow artists to have a quick overview of what their end-product would look like; saving time and improving their workflow. Maya didn't provide that in the regular viewport, so the deferred preview was a step up to view the effects of modeling real-time. Previewing the reflections, global illumination and shadows is a nice bonus for RTX and GTX Pascal cards.

Information

Duration: October 2018 - December 2019
Role: Graphics/Optimization programmer
Skills: C++, HLSL, DirectX12, DXR, Raytracing
Tools: GitHub/Git, Sourcetree, CMake, Visual Studio, Jira, PIX, Nsight
Team members: 8 graphics programmers, 1 engine programmer

Contributions

• Raytraced reflections
• Variable roughness; filtering reflections (spatial reconstruction)
• Optimizations, refactoring and bug fixing
• Frustum culling
• Basic deferred rendering
• Scene graph parenting

Description

Oxsomi Core 3 is a cross-platform C11 framework (with a generated C++20 layer) that abstracts graphics and platform APIs: Vulkan and DirectX 12 backends with raytracing, mesh shaders and bindless, loadable side by side and selected at runtime, plus a statically linked DXC-based shader pipeline targeting DXIL and SPIR‑V.
It builds and runs on Windows, Linux (Wayland), macOS, SteamOS, Android and Web (wasm64), on x64 and ARM64, with CI for every platform, alternate toolchains (clang, clang-cl) and nightly ASan/UBSan runs.
Built entirely from scratch, it includes memory management, SIMD math, containers, file I/O, encryption and hashing, and the oiXX family of file formats.
Core 3 evolved from Core 1, which had a Vulkan-only renderer and supported Android and Windows.

Information

Duration: December 2017 - present
Role: Sole developer
APIs: Vulkan, D3D12
Architectures: x86_64, aarch64, wasm64
Platforms: Windows, Linux, macOS, SteamOS, Android, Web
Languages: C, C++, HLSL, Python
Tools: Git/GitHub Actions, CMake, Conan, ninja, Visual Studio, VS Code, Android NDK, NSight, Renderdoc, PIX, RGP
Libraries (Only if compiler is enabled): forked dxc, spirv-reflect, spirv-tools, amdllpc

Contributions

• Designed the cross-platform abstraction layer (file system, windowing incl. Wayland, threading, processes)
• Implemented Vulkan + DirectX 12 backends with raytracing, mesh shaders, VRS and bindless; both loadable at runtime
• Shader toolchain: forked, statically linked DXC targeting DXIL + SPIR-V, custom [[oxc::...]] annotations, multithreaded batch compiles, include tracking for incremental builds and hot reload
• ISA inspection tooling: SPIR-V/DXIL to GPU ISA, offline via amdllpc and live via VK_KHR_pipeline_executable_properties and AMD's D3D12 extension, with ISA goldens in CI
• File formats: oiCA archives, oiDL, oiSH shader containers, oiSR reflection (types, inheritance, go-to-definition), oiSP pipeline state and oiPL pipeline layouts
• Runtime reflection system using custom annotation syntax, spirv-reflect and a forked d3d12shader.h
• Found and fixed a DXC heap-corruption bug in reflection (missing thread allocator) in my DXC fork, plus a multi-entrypoint binding bug in the Vulkan backend; reported further issues upstream (DXC, Vulkan validation layers)
• Vector math & container libraries, tracked allocators (leaks, double frees) with per-allocation stack traces
• AES-GCM encryption and SHA256/CRC32C/MD5 hashing with hardware paths (AES-NI, ARM crypto)
• CI matrix across all platforms: default + alternate toolchains, dynamic linking, Android emulator runs, nightly ASan/UBSan (surfaced memory-safety bugs in SPIRV-Reflect, two fixed upstream)

Description

Switchbait was a custom voxel engine, created for a top-down shooter and mainly meant as a learning opportunity for everyone in the team. We each had our goals set (optimization, serialization, etc.) and improved the engine with these points.
Unfortunately, the game's direction wasn't aligned with the engine's capabilities and the producers pushed the game to areas the engine wasn't built for.

Information

Duration: May 2018 - June 2018
Role: Graphics, optimization and gameplay programmer
Skills: OpenGL, GLSL, C++, Nintendo switch and Windows development
Tools: Perforce, Jira, Visual Studio
Team members: 18 people

Contributions

• Spawning and maintaining particles through compute shaders
• Creating a particle editing tool useable for artists
• Implementing a batching system (multi draw indirect) to prevent draw call overhead
• Basic mesh culling and instancing

Description

Rail recon is a twin stick shooter with a neon theme based on a few old arcade games, made by a twelve student team. It was created as a concept within 2 weeks, it was then developed further for 6 weeks.
It started as a three person team, two weeks later became a six person team and finally six more people joined in. I was among the six who joined in at the last four weeks of development until release. The game is released on steam and has had a few thousand downloads and has several positive reviews.

Information

Duration: May 2017 - January 2018
Role: Gameplay programmer
Skills: Unreal, C++, Blueprints
Tools: Perforce, Visual Studio, Hacknplan
Team members: 4 programmers, 4 artists, 2 designers, 1 producer, 1 audio designer

Contributions

• Implementation and communication of mechanics:
•   Energy; shield & charge system
•   Gameplay elements such as triggerable buttons, doors, rotators, exit door
• Implementation of graphical effects and gameplay:
•   Charging station animation and logic
•   Door animations and logic
• Communication with designers, artist and producers

Description

Harpoon was a project that was used in Shiploader; a modloader for the game Raft. This API was intended to be used by the modding community as an alternative. This was due to the existing modding tool using the source code of the game and distributing it and mods being very version dependent.
The alternative was code injection and not just patching a dll; where an executable requests Unity to load mods, which use a library for wrapping the low-level code.
This is accomplished by loading a C DLL into memory, which calls functions provided onto a heap; these functions are Unity mono functions, which load a C# dll and execute it. The C# dll is then able to access everything in Unity through C# reflection and Harmony through patching functions (More info here).

Information

Duration: August 2018 - February 2019
Role: Programmer
Skills: C, C++, C#, Unity, Harmony, Code injection, Mono injection, Reflection, Reverse engineering
Tools: GitHub, Sourcetree, Visual Studio
Team members: Solo project, but used in team project

Contributions

• Getting an understanding of how the Windows API works with multiple processes
• Being able to call functions in other programs through the WinApi
• Loading and executing a payload in a different address space (defeating ASLR)
• Using mono to load dlls into C#
• Using C# reflection and patching an already existing program

Description

A combined suite of tools for reverse engineering NDS games.
NFSU is a modular ROM editor that supports viewing and editing palettes, tilemaps, archives, and other formats common in DS games.
Armulator is a custom ARM9/7 emulator written in C++ to step through compiled DS game code. Together, they enable modding, visualization, and runtime code analysis of DS binaries.

Information

Duration: On & Off during November 2017 - September 2021
Role: UI, tool and emulation programmer
Languages: Qt, C++, GLSL, OpenGL, ARM/Thumb assembly
Tools: Perforce, Trello, GitHub, CMake, Visual Studio
Team members: Solo project, with feedback from friends & colleagues and help on creating icons

Contributions

• Built GUI editor for parsing NDS formats (palette, tilemap, archive)
• Created custom struct parser using C++ templates and dynamic type layouts
• Wrote shaders for BGR5-tiled image previews with OpenGL
• Built archive/tree view for dynamic loading of NARC and other DS-specific formats
• Developed custom ARM7TDMI/ARM9 (Thumb + ARM) emulator in C++
• Implemented instruction decoder, memory mapper, and simple CPU pipeline
• Added disassembler, step-through debugger, and assembler

Description

Mineblowers was a marmalade game made in 3 weeks, which utilises a custom controller. The idea was to create a unique user experience with an unexpected controller.
We chose for a bike pump as a controller, because it was easy to obtain and it fit in with our minecart-style game.
The faster you pump, the faster you travel. If you travel too fast, you fall off and have to start over. The fastest score wins, this was implemented with a simple leaderboard. Since one of my team members had worked on this at Rail Recon before, I spoke to him and implemented it with a tool in our project.

Information

Duration: November 2017 - January 2018
Role: Gameplay/tools programmer
Skills: Unreal, Blueprints
Tools: Perforce, Trello
Team members: 2 programmers, 3 artists, 3 designers

Contributions

• Implementation of the spline system of the cart and procedural generation of the rails.
• Worked together with designers to get the spline editing system to be more user-friendly.
• Worked on the death system alongside another programmer.