GPU research renderers

Compute you can diff.

Five sibling agents asked the same question: what would it take to reach a real GPU from pure C#, and is the answer worth a NuGet dependency? Each built a runnable prototype and cross-checked it against the CPU renderer the fleet already ships. Every image below was rendered fresh on 2026-07-13 - four on an NVIDIA RTX 2080 SUPER (Vulkan and OpenGL), one on 32 CPU threads - and the two Mandelbrots agree to 99.71% of pixels.

Vulkan 1.4 compute Vulkan graphics pipeline OpenGL 3.3 core Parallel.For CPU reference

Mandelbrot set rendered by a Vulkan compute shader, red-to-black cosine palette

Mandelbrot set - real Vulkan compute dispatch

agent2 - 1024x1024, maxIter 1000, vkCmdDispatch on RTX 2080 SUPER: 36.0 ms

A hand-written GLSL kernel compiled to SPIR-V and dispatched through the raw VkInstance -> VkDevice -> VkPipeline path, no windowing. The same kernel run as a 32-core Parallel.For matches it on 1,045,496 of 1,048,576 pixels; the 0.29% that differ sit on the fractal boundary (49x the local gradient), i.e. float chaos, not a bug.

The same Mandelbrot set computed on the CPU with Parallel.For

Mandelbrot - CPU reference

agent2 - Parallel.For, 32 logical cores: 40.4 ms

The renderer the fleet actually ships. Pixel-diffed against the GPU dispatch to prove the two agree.

An RGB-interpolated triangle rotating, rendered frame by frame by the Vulkan graphics pipeline

Spinning triangle - graphics pipeline loop

agent5 - 36 frames, push-constant angle, one GPU submit each

Record -> submit -> read back -> next frame: the real per-frame loop a game would run, one full rotation.

A single Gouraud-shaded triangle, red top, green and blue base, on a dark field

Gouraud triangle - offscreen raster

agent5 - vertex -> hardware rasterizer -> fragment, 512x512 target

Not a compute trick: the actual graphics stages interpolating vertex colors across the triangle interior.

A depth-tested 3D cube, magenta top face and dark-red front face, rendered by native OpenGL

Lit cube - native OpenGL

agent4 / agent1 - GL 3.3 core via GLFW, depth-tested, NVIDIA driver 591.86

MVP math from OnlyCSharp's OcMat4; glReadPixels round-tripped back out through OnlyCSharp's own PNG encoder.

How these were made

The doctrine for the library is BCL-only, zero-NuGet - so none of this belongs in the engine. It lives in the Applications layer, where a browser or a Silk.NET binding is a fair dependency. The point was never to replace the CPU rasterizer; it is the portable default. The GPU path is an opt-in for the scenes that actually need it, and the way you earn trust in it is to render both and subtract.

Two of the five agents (a four-act physics game and a computed solar world) render only in-browser through WebGL2 and WebGPU; with no headless browser on this box they are not pictured here. Their shared native-OpenGL cube is - it is the same scene as agent4's, so it stands in for both. The three Vulkan prototypes and the OpenGL cube each ran in under a second of GPU time; the slowest single step was Vulkan's one-time instance and pipeline setup at 478 ms.

Hardware this pass: NVIDIA GeForce RTX 2080 SUPER (discrete) alongside an AMD Radeon integrated GPU; Vulkan auto-selected the discrete device. All images are self-hosted; the page loads no fonts, scripts, or assets from anywhere off this host.