I build software close to the metal — systems, performance, and deep understanding of how things actually work. Everything I ship is optimized, intentional, and built to last.
High-performance ELO ranking system in Go and PostgreSQL, handling real-time match submissions with live leaderboards and historical data.
Problem: The 42 Heilbronn community needed a competitive ranking system to track student tournament matches.
Solution: I built a complete ELO ranking system in Go with PostgreSQL, optimized from the ground up for performance. Go's concurrency primitives made it natural to handle simultaneous match submissions and API requests, while careful database optimization techniques ensured queries stayed fast even as the dataset grew. The backend processes real-time match updates and serves a React frontend with live leaderboards, detailed player profiles, and historical match data.
Technical Approach: Composite indexes on frequently-queried columns, optimized join patterns to reduce query execution time, and Redis for cached ranking calculations. Go's goroutines handle concurrent request processing cleanly — each match update is processed independently. I applied profiling throughout development to identify and eliminate bottlenecks. Similar optimization patterns appear in other systems projects like the raytracer, where every algorithmic decision has direct performance implications.
Results & Learnings: The system achieves 30ms average response times and maintains 99.9% uptime across tournament seasons. Query optimization and profiling-driven development are non-negotiable for systems that prioritize performance.
120+ FPS raytracer built on SIMD vectorization, cache-efficient data structures, and tile-based multi-threaded rendering.
Problem: I started building a basic raytracer in C to understand computer graphics fundamentals. The initial naive implementation achieved only 1–5 FPS when rendering complex scenes with multiple light sources.
Solution: I rebuilt the core rendering loop with C systems programming principles at its foundation. The approach combined SIMD vectorization using SSE/AVX intrinsics for batch vector operations, cache-efficient data structures using structure-of-arrays layouts instead of array-of-structures, and multi-threaded tile-based rendering to leverage multiple CPU cores.
Technical Approach: Three pillars: vectorization, memory hierarchy, parallelism. SSE intrinsics process 4 floats in parallel, AVX handles 8. I restructured data to exploit CPU cache locality by storing all X-coordinates contiguously, then Y, then Z. The renderer divides the framebuffer into tiles, with each thread processing one tile independently. Profiling with perf and cycle-accurate analysis revealed that the ray-primitive intersection test was the hottest code path.
Results & Learnings: The optimized raytracer renders at 120+ FPS — an 80× improvement over the baseline. Systems programming at the graphics layer isn't just about algorithms; it's about respecting CPU cache behavior, instruction pipelines, and memory bandwidth.
Unix shell from scratch — process management, file descriptors, pipes, I/O redirection, environment expansion, signal handling.
Problem: Understanding how a Unix shell works requires deep knowledge of operating system fundamentals. Building a shell from scratch meant confronting these abstraction layers directly.
Solution: A POSIX-compliant shell in C that replicates bash's core functionality. The shell handles the complete command execution pipeline: lexical analysis and parsing transform user input into an abstract syntax tree, and an execution engine processes these tokens using genuine Unix system calls.
Technical Approach: Three critical systems programming concepts. First, process management via fork and exec. Second, file descriptor manipulation through dup2() for pipes and I/O redirection. Third, signal handling with sigaction() to prevent zombie processes. The parsing phase uses recursive descent techniques.
Results & Learnings: Building minishell transformed my understanding of Unix architecture — shells are orchestrators of the OS, not autonomous entities. Hands-on exploration of process management, file descriptors, and IPC deepened my appreciation for why low-level programming discipline matters.
I'm at 42 Heilbronn, a peer-to-peer programming school where we learn by building real things.
My passion is systems programming — where software meets hardware. There's something satisfying about understanding how things work at the deepest level: memory, scheduling, protocols, performance.
