Sega Saturn emulator Erings hits 1.0 with GPU upscaling

Developer John Schember has released version 1.0 of erings, an open-source Sega Saturn emulator for Windows, macOS, and Linux. The update introduces GPU rendering via compute shaders and supports internal resolution upscaling up to 16x.

The Sega Saturn is notoriously difficult to emulate. The 1994 console used a complex architecture featuring dual Hitachi SH-2 processors alongside two custom video processors, the VDP1 and VDP2. The biggest hurdle for modern emulation is the VDP1, which renders graphics using quadrilaterals instead of the standard triangles used by modern GPUs.

Other Saturn emulators like SSF, Mednafen, and Kronos have historically had to choose between two compromised paths. They can use software rendering, which is highly accurate but computationally expensive at higher resolutions. Alternatively, they can use hardware rendering that breaks the original quads into triangles, which often introduces visual seams and geometry errors.

Schember bypasses this problem entirely by using compute shaders. Instead of pushing quads through a traditional graphics pipeline, the emulator uses the graphics card as a massively parallel processor. The GPU renders each pixel exactly like a software renderer would, maintaining perfect quad geometry while offloading the heavy lifting from the CPU.

Shaders written in Go

The compute shaders in erings are written in Go, the same programming language used for the rest of the emulator. The code is compiled into an intermediate representation before being translated for the specific platform backend. That means Metal for macOS, Vulkan for Linux, and DirectX 12 for Windows.

Because the GPU and software renderers share the same base code, accuracy remains consistent across both methods. The GPU renderer processes scanlines in batches, recording memory deltas to ensure it sees the exact same state as the software renderer.

The GPU renderer parallelizes the VDP1 operation list by grouping drawing commands that can run together. It splits these operations into chunks and processes them across three pipeline stages: tag, write, and resolve. It's a lock-free approach that determines pixel ownership before writing to the frame buffer, ensuring accurate blending and shadows. The VDP2 background layers are also processed in parallel, with the emulator handling nearly every pixel of every layer simultaneously.

It preserves the accuracy of software rendering, and it doesn't require a massive desktop processor just to hit full speed.

Performance and upscaling

The 1.0 update allows internal resolution scaling from native 1x up to 16x. That's because the upscaling maintains native placement, making 3D geometry smooth and straight. 2D sprites retain their original jagged edges, since the emulator doesn't add new information to the textures.

Testing detailed by Schember shows significant performance gains. NiGHTS into Dreams.., a game that heavily stresses the Saturn's VDP processors with 3D flight paths over 2D backgrounds, runs at full speed at 4x resolution on a laptop with an RTX 5060. It also maintains 60 frames per second at 2x resolution on an M4 MacBook Air.

Sprite-heavy 2D games like Waku Waku 7 don't benefit much visually from the upscaling, but they run with lower CPU overhead thanks to the GPU offloading. The update also includes major allocation optimizations, reducing the garbage collection stutters that can plague Go-based applications.

The emulator includes several quality-of-life features alongside the rendering upgrades. It supports RetroAchievements, controller rumble, and MPEG video card emulation out of the box. The project is free and open-source under the GPL-3.0 license.