I am a passionate software engineer deeply fascinated by the intersection of high-performance computing, hardware-adjacent systems, and scalable infrastructure. Whether I'm micro-optimizing memory layouts, rendering real-time scenes, or architecting robust backend services, I love building software that is fast, reliable, and elegant from the metal all the way up to the cloud.

I build software that lives as close to the metal as possible. My day-to-day involves:

• Memory layout optimization — Designing cache-friendly data structures, minimizing allocations, and eliminating false sharing in multi-threaded contexts. I profile cache miss rates and redesign layouts to maximize L1/L2 utilization.
• Concurrency & parallelism — Lock-free algorithms, thread pools, work-stealing schedulers, and NUMA-aware task distribution. I reason about memory ordering, atomics, and cache coherency protocols.
• Zero-cost abstractions — Heavy use of C++20/23 concepts, constexpr evaluation, and compile-time polymorphism to push as much work as possible to compile-time. If it doesn't optimize away, it doesn't ship.
• Performance profiling — Intel VTune, perf, Tracy, and custom instrumentation to find and eliminate bottlenecks at the instruction level. I read assembly to verify the compiler did what I asked.
• Hardware integration — Writing kernel modules and userspace drivers, interfacing with DMA engines, and understanding microarchitectural behavior: branch prediction, prefetching, out-of-order execution, and SIMD utilization.

Real-time rendering is where math meets the GPU. Here's what that looks like in practice:

• Graphics API mastery — Vulkan is my primary API. I write render passes, manage descriptor sets, optimize command buffer submission, and handle synchronization with semaphores and fences. OpenGL for legacy and rapid prototyping.
• Shader development — GLSL/HLSL for vertex, fragment, compute, and ray-tracing pipelines. I write physically-based shading models (Cook-Torrance, GGX), custom lighting equations, and procedural texture generation.
• Pipeline architecture — Deferred rendering, clustered forward shading, bindless resource management, and multi-pass post-processing chains (bloom, SSAO, tone mapping, FXAA/TAA).
• GPU optimization — Reducing render state changes, batching draw calls, GPU-driven rendering with indirect draws, and profiling with RenderDoc & Nsight. I optimize for occupancy and memory bandwidth, not just ALU throughput.
• Cross-platform — Ensuring consistent behavior across Linux (Wayland/X11), Windows, and embedded targets. Handling swapchain recreation, surface formats, and platform-specific quirks.

On the other end of the stack, I design services that handle thousands of concurrent connections without breaking a sweat:

• High-throughput services — Building async I/O servers using epoll/kqueue/io_uring in C++ and Python. Handling 100k+ concurrent connections with minimal memory overhead per connection.
• Container orchestration — Docker for reproducible builds, multi-stage images for minimal attack surface, and efficient layer caching. CI/CD pipelines with GitHub Actions for automated testing and deployment.
• API design — RESTful and gRPC APIs with strict versioning, OpenAPI specs, comprehensive load testing (k6, Locust), and backward compatibility guarantees.
• Observability — Structured logging (JSON), distributed tracing with OpenTelemetry, and metrics dashboards (Prometheus/Grafana). I believe you can't optimize what you can't measure.
• Resilience patterns — Circuit breakers, rate limiting, backpressure handling, and graceful degradation under load. Services that fail gracefully, not catastrophically.

Beyond application code, I invest heavily in the developer experience:

• Custom toolchains — Clang/LLVM plugins for static analysis, source-to-source transformation tools, and custom compiler passes for domain-specific optimizations.
• Build systems — CMake power-user (modern target-based approach), Bazel migration expert for hermetic builds, and custom build graph optimizers to reduce incremental build times.
• Language experimentation — Designing small DSLs and toy compilers to explore type systems, IR generation (LLVM IR, SPIR-V), and optimization passes. Understanding how high-level code maps to machine code.
• Scripting & automation — Python and Bash for build orchestration, code generation, deployment pipelines, and infrastructure-as-code.