Rendering • Tools • Real-Time Graphics

Low-level graphics and engine systems. Vulkan, D3D12, the stuff underneath.

I'm Nikhil Chouhan, a BTech'25 graduate from IIT Roorkee focused on rendering, graphics programming, and GPU-oriented systems. I like building engines and tools that turn low-level graphics concepts into something tangible on screen.

See selected work Email me

Primary focus: Graphics programming
Main stack: C++, Vulkan, D3D12
Interests: Renderers, shaders, GPU architecture

Focus

What my work tends to orbit around

Rendering APIs

Working across the graphics stack

I've built projects in OpenGL, D3D11, Vulkan, and D3D12 to understand the tradeoffs each API exposes.

Systems Thinking

Architecture over polish

Frame flow, synchronization, resource lifetimes, memory layout. I'm very much interested in how a renderer is structured than how it looks in a screenshot. The payoff with proper architecture is insane, they don't realise

GPU Architecture

Hardware shapes the code

RDNA, Ampere, occupancy, wavefronts, bandwidth. Understanding what the hardware actually does changes how you write shaders and structure pipelines.

Selected Work

A few projects worth opening

D3D12

Luma

A Direct3D 12 renderer exploring modern graphics concepts through explicit resource and pipeline management.

C++ D3D12 Real-Time

Source Video

Vulkan

Cravillac

A Vulkan renderer built to get comfortable with explicit graphics programming and renderer structure.

C++ Vulkan Renderer

Source Video

Geometry/Physics

GJK Collision Visualizer

A visualizer for collision detection ideas, built to make the algorithm easier to reason about and inspect.

C++ GJK Visualization

Source Video

Offline Rendering

Parallel CPU Ray Tracer

A multithreaded ray tracer focused on fundamentals, performance awareness, and understanding light transport from the ground up.

C++ Multithreading Ray Tracing

Source

About

My path into graphics started with curiosity and broken Linux.

Around 2017, I broke my Linux desktop and ended up discovering the Mesa graphics stack. I didn't fully understand the code at the time, but the userspace drivers were enough to make graphics programming feel mysterious in a good way.

Later at IIT Roorkee, I moved through Unity, Unreal Engine, and graphics communities on campus before writing my first renderer through LearnOpenGL. That was the turning point where the subject stopped feeling distant and started feeling buildable.

Since then, I've kept circling back to the same question: how do modern graphics systems actually fit together? That question keeps pulling me into APIs, engines, shaders, and GPU architecture.

Gfx API stronghold

OpenGL, D3D11, Vulkan, and D3D12.

Interests

Renderers

Shader workflows, engine internals, and GPU-facing systems.

Currently reading

GPU Arch

RDNA and Ampere microarchitecture docs. Understanding the silicon informs the code.