High-Performance Software Rasterization

Rendition is a CPU-based Direct3D 12 graphics device under active development, built with the goal of running existing games without changes to their code. Its Windows driver compiles application shaders into native CPU code through LLVM and runs them on a software rasterizer written in C++ and ISPC. A tile-based architecture, multithreaded execution, and SIMD—including AVX2 and AVX-512—bring GPU-style parallelism to the CPU, with no GPU acceleration.

And there’s more to come.

Watch the demos

A Real Game: Forza Horizon 3

Forza Horizon 3 is a Direct3D 12 racing game from 2016. In this recording it runs on Rendition without modification. The driver installs in Windows like a hardware driver, with kernel-mode and user-mode components, and Windows lists it as a Direct3D 12 adapter. The game’s shaders are compiled to native CPU code, and every frame is rendered on the CPU.

The recording runs at roughly 6 frames per second. This is a research prototype, not a playable experience: a proof of concept that a shipping Direct3D 12 game can run on a CPU-based device. Some features the game uses are not supported yet, and performance work continues.

Gameplay recording · About 4 minutes · Rendition Direct3D 12 driver

Forza Horizon 3 rendered by Rendition on the CPU: cars parked on a city street
Software Rendering with AVX-512: Forza Horizon 3 Watch on YouTube ↗

Try It Yourself: Sunset Coast

Watching a video is one thing. Sunset Coast runs on your own machine: a real-time flight along a rocky coastline, with every pixel computed by your processor. The graphics card only displays the finished frames.

The demo picks the best instruction set your CPU supports, from AVX-512 and AVX2 down to plain x64, and puts every core to work. A live readout shows how fast your machine is rendering. Hold the right mouse button to fly with W, A, S and D, and press F12 to save a 4K screenshot.

Windows 10/11 x64 · 4.9 MiB · Portable, no installer

Sunset Coast at dusk: a sea inlet between rocky cliffs, the sun setting behind the mountains, rendered on the CPU
Sunset Coast Rendered in real time on the CPU

OpenGL Driver

Rendition began in 2002 as a personal research project to learn SSE and MMX programming in C++, during a period between jobs after a layoff from Microsoft. By 2003, it had developed into a software renderer with an OpenGL driver capable of running Quake II entirely on the CPU. That original, single-threaded driver still runs on modern Windows systems with Intel and AMD processors.

In 2026, after the renderer was rebuilt around modern SIMD, multithreading, and tile-based rendering, it returned to Quake II. The new OpenGL driver was a proof of concept: could the modern architecture run an existing game through its graphics API? Its success provided the confidence to pursue a Direct3D 12 driver and a much broader range of games. The video shows the modern driver.

Modern and original drivers · Portable launcher · Windows 10/11 x64

Quake II software rendering with AVX-512
Software Rendering with AVX-512: Quake II — views · Watch on YouTube ↗

A Real Direct3D Device. Powered by the CPU.

Applications select Rendition’s adapter through the standard Direct3D interfaces. They create resources, submit drawing commands, and present frames through a normal windowed swap chain, just as they would with a hardware-backed device. The driver executes the rendering on the CPU, and Windows composites the finished image on the desktop.

The shader compiler translates supported HLSL/DXIL vertex and pixel shaders into native CPU code through LLVM. That code works alongside ISPC routines for triangle processing, rasterization, and texture sampling. Sampling runs on Rendition’s extensively optimized sampler, which pairs high-quality filtering with fast CPU execution.

Development is focused on what existing games need: broader shader and resource support, more texture formats and sampling modes, compute shaders, and the synchronization and command behavior real titles depend on. Captured game workloads guide that work. Forza Horizon 3 now runs on the driver; broader game compatibility and speed are the next challenges.

High Performance

Rendition pairs parallel execution with techniques that avoid unnecessary work. Rendering is divided into tiles that are dynamically distributed across CPU cores to balance the load, with each tile processed by one worker at a time. Early Z and hierarchical Z reject hidden surfaces and fully occluded blocks before pixel shading, just as a GPU would, and variable rate shading reduces work further by varying shading frequency across the image.

The Menger Sponge demonstration shows the renderer in action.

Menger Sponge Rendered on the CPU

SIMD-Enhanced

Rendition uses AVX2 and AVX-512 to execute pixel-shading calculations across multiple SIMD lanes. Rather than evaluating each pixel separately, it applies the same operations to groups of pixels, with each lane carrying its own data.

This is the second level of parallelism in the renderer: tiles spread the work across CPU cores, and SIMD processes groups of pixels within each core.

Cellular Tiling SIMD in action

C++ Meets SIMD

Vectorized is Rendition’s C++ SIMD library. It expresses parallel operations through vector types and familiar arithmetic, keeping compiler intrinsics out of the shader code. The result reads much like GLSL: the code describes the shading calculation, while the underlying types apply it across multiple pixels.

These vector operations fit directly into ordinary C++ code, alongside objects and control flow, without requiring a separate kernel. This approach powered Rendition’s early shader demonstrations. The renderer later moved to ISPC, carrying its shaders, texture sampling, and rendering architecture forward into a dedicated parallel programming model.

Rendition C++ template code for SIMD operations in Visual Studio
Familiar C++. Parallel execution.

Rendering Capabilities

What Rendition supports today, from the shader compiler to the Windows driver.

Demonstration Videos

This is software rendering. See it for yourself.

Torus Intersection
Entangled Vines
Fractal Spaceship
Abstract Terrain
Canyon
Dry Rocky Gorge
Transport Facility
Protean Clouds
Mandelbrot