Every PC game talks to the graphics card through a graphics API, a shared language for asking it to draw. OpenGL is the old one, born in 1992. It is easy to speak because the graphics driver fills in what you leave out, guessing what you meant. Vulkan, from 2016, is the opposite: the program says exactly what it wants, when, and with which part of the card, and the driver guesses nothing.
OpenGOAL draws all its games with OpenGL 4.3. Until September, so did Phaethon.
The reason was the hardware
The decision was written down on September 17th in one line: ray tracing is the requirement.
Ray tracing follows light through the real scene, so a building can cast a shadow on a car the way the sun would. Modern graphics cards have hardware built for exactly that, and OpenGL cannot reach it. The same was true of the other features worth having: NVIDIA's DLSS, called directly through NVIDIA's own library with no wrapper in between, and the tensor cores that run small neural networks on the card. Vulkan reaches all of them.
Two other routes were weighed and turned down. SDL's GPU layer has no ray tracing. DirectX 12 has ray tracing but only runs on Windows, while Vulkan keeps Linux open, and macOS through a translation layer.
What the measurements said
Speed came out even. Replayed race frames cost the same on both renderers within the noise, with Vulkan the steadier of the two. The graphics card sat near 45 percent busy at 3840 by 2400, so raw speed had headroom to spare.
The biggest slowdown found along the way had nothing to do with Vulkan. A guard in the OpenGL renderer that saved and restored the card's state around every draw ate 61 to 71 percent of an OpenGL frame. Taking it out cut a busy city frame from 32.4 to 12.7 milliseconds on replay.
Checking every pixel
Moving a renderer this size by hand is how games end up with a shadow that is slightly wrong forever. So the first thing built was not Vulkan at all. It was a frame oracle: a tool that plays the same moment of the game on both renderers and compares the two pictures pixel by pixel.
The OpenGL renderer took the first step: on September 17th it moved from OpenGL 4.3 to 4.6, a transition on the way to Vulkan.
With the oracle in place, the first Vulkan device came up on the evening of September 18th. Whole frames matched OpenGL's about twelve hours later. On September 22nd Vulkan became the default for every game, with OpenGL behind it in case Vulkan failed to start, and the first release candidate shipped that way.
Two renderers, then one
For three weeks both renderers lived side by side. That got expensive. The traced shadows, the upscalers and the compute passes ran only on Vulkan, and every other effect had to be written twice and judged twice.
The two could never be proven identical: a few hundred pixels out of two million always differed somewhere in a frame. So on October 13th the decision was made the other way round. Vulkan's frame became the reference that every change is checked against. On October 14th the OpenGL device came out, then its shaders and the build option that could leave Vulkan out. Asking for OpenGL now stops with a message saying why.
What one renderer buys
Even before OpenGL left, the Vulkan frame was reorganized around what Vulkan allows. Each pass now declares what it reads and writes, and the renderer works out the order and the waits between passes itself; 23 waits that had been placed by hand came out. One renderer means one set of passes to measure, one place to make faster, and no work done twice.
Alex (maintainer, and a mechanical engineer by trade)