Approximate rendering techniques exist on borrowed time. Signed distance fields, baked ambient occlusion, reflection captures: each of these represents a compromise made when exact computation was too expensive, and each has eventually been pressured by hardware that grew to afford the real thing. Eric Lengyel’s Slug library is ten years old now, and his decade retrospective is most interesting read as a hardware story: a library built on the premise that exact GPU font rendering was affordable before the industry’s dominant techniques assumed it could be.
Why 2007 Produced Distance Fields Instead
The timing of Chris Green’s SDF paper matters. His 2007 SIGGRAPH work on alpha-tested magnification for vector textures arrived at a specific moment in GPU hardware history. Shader Model 4.0 had just shipped with the GeForce 8800, bringing geometry shaders and true integer arithmetic, but general-purpose buffer access from fragment shaders was still limited. You could sample textures; you could not cleanly load from an arbitrary variable-length array of per-glyph curve data.
Rendering a font outline analytically requires, at minimum, a way to look up the curve segments for a particular glyph from a fragment shader, then iterate over them with branching logic. In 2007, that pattern was awkward. Shader Storage Buffer Objects, available in GLSL 4.3, did not exist until 2012. Direct3D 11 structured buffers arrived in 2009. Before these, packing glyph outline data into textures was possible but cumbersome, and iterating over a variable-length data list in a fragment shader had poor performance characteristics on the hardware of that era.
SDF sidesteps these constraints entirely. Precompute offline, store in a standard texture, sample with a single fetch at runtime. The fragment shader has no loops, no variable-length data access, no branching over curve geometry. It was precisely the program shape that 2007 GPU hardware was designed to run efficiently.
By 2015, the hardware environment was different. GLSL 4.3 SSBOs existed. Compute shaders were available across APIs. Fragment shader arithmetic throughput had improved substantially, and the GPU memory model had gained enough flexibility to make per-fragment curve evaluation a practical proposition. Slug launched into this changed environment. The algorithm it implements was not theoretically novel in 2015; the hardware had finally grown into it.
The Winding Number as a Rendering Primitive
The mathematical core of Slug is the winding number. For a closed curve and a point, the winding number counts how many times the curve winds around that point, with sign reflecting direction. A point with a non-zero winding number is inside the glyph under the nonzero fill rule.
Computing this per-fragment means, for each pixel center, casting a ray and counting signed crossings with each Bezier segment. For a quadratic Bezier P(t) = (1-t)^2 * P0 + 2t(1-t) * P1 + t^2 * P2, finding where the y component equals the sample y requires solving a quadratic:
float a = P0.y - 2.0 * P1.y + P2.y;
float b = 2.0 * (P1.y - P0.y);
float c = P0.y - y_sample;
float disc = b * b - 4.0 * a * c;
if (disc >= 0.0) {
float t1 = (-b - sqrt(disc)) / (2.0 * a);
float t2 = (-b + sqrt(disc)) / (2.0 * a);
// For each t in [0,1]: evaluate x crossing, accumulate signed winding
}For OpenType CFF fonts using cubic Bezier curves, each intersection requires solving a cubic polynomial, more expensive but still analytical. The derivative at each crossing gives winding direction. Coverage comes from integrating the winding number over the fragment area rather than evaluating at a single point, producing a value between 0.0 and 1.0 representing the fraction of the fragment inside the glyph. Lengyel published the formal algorithm in the Journal of Computer Graphics Techniques as “GPU-Centered Font Rendering Directly from Glyph Outlines” in 2017, providing a peer-reviewed basis for what the library claims to compute.
The quality difference from SDF is structural. An SDF texture encodes distance to the nearest outline edge. A sharp corner is two edges meeting at a point, and the distance field near that corner is governed by the angle bisector rather than the actual geometry. The information about corner sharpness is not in the data. Viktor Chlumský’s multi-channel SDF improves this by encoding directional information across color channels, but it remains an approximation with failure modes at extreme scales. The winding number approach retains the corner because it uses actual Bezier control points, where corners are exactly representable as two segments meeting with discontinuous tangents.
A spatial acceleration structure is what makes the per-fragment iteration cost practical. Slug culls curve segments to only those whose y-intervals overlap the current fragment row, bounding the expected iteration count to local glyph complexity rather than total outline length. This keeps the per-fragment cost proportional to the rendering task at hand.
Variable Fonts and What Exact Composition Buys
Variable fonts, standardized in OpenType 1.8 in 2016, store a single font file encoding a continuous design space across named axes: weight, width, slant, and arbitrary parameters defined by the type designer. A weight axis stores control points for extreme masters, with interpolation rules for positions between them.
For precomputed approaches, this creates a combinatorial problem. SDF atlases need to be generated at each point in the design space you want to support, or regenerated live when a weight or width value changes. Atlas generation pipelines designed for static fonts become latency problems when the font design space is dynamic.
For Slug, the adaptation is mechanical. Interpolating between two sets of Bezier control points is a linear operation on the coordinates:
P_interp = (1 - w) * P_master0 + w * P_master1The curve topology, which segments connect to which, remains constant; only the control point positions change. The interpolated curves are valid Bezier curves that the shader evaluates with the same algorithm as any static glyph. When you commit to using actual curve geometry at render time, format extensions that modify that geometry compose cleanly. When you commit to a precomputed approximation, format extensions that require re-approximating become pipeline engineering problems.
The Raytracing Arc
Real-time raytracing follows the same pattern. The algorithm predates GPUs; the question was always when hardware would afford it. Rasterization with precomputed baked lighting, approximate global illumination, screen-space reflection: each technique occupied the gap between what exact computation required and what hardware could deliver. Hardware raytracing, available since the RTX 20 series, made portions of the exact approach real-time and is steadily displacing the approximations it rendered obsolete.
Slug’s position is structurally analogous. Exact GPU font rendering was theoretically possible before 2015 in the same way global illumination raytracing was possible before RT cores existed. The limiting factor was cost, and the answer changed when the relevant hardware crossed a threshold. The library was a bet on that threshold arriving, placed before the industry acknowledged it had.
The difference is scale of adoption. RT cores went into consumer hardware with vendor marketing behind them; analytical font rendering is a niche technique in a commercial SDK. The commercial model creates sustainability and maintenance accountability that open source alternatives do not automatically provide, but it also limits the adoption trajectory compared to techniques embedded in open standards and engine defaults.
Ten Years of Platform Churn Around a Stable Algorithm
Lengyel’s retrospective covers a decade of graphics API evolution: from OpenGL and DirectX 11 in 2015 to Vulkan, Metal, DirectX 12, and SPIR-V by 2026. Three distinct shader languages. Mobile GPU architectures with tiling renderers and bandwidth constraints that matter for shader design. Console platforms with their own requirements. The algorithm required no changes across this period; the surrounding integration required sustained engineering work.
The OpenType specification also kept moving. Color fonts, COLRv1, glyph compositing rules, variable font interpolation refinements: the spec is not a document that freezes while you implement against it. A library committed to exact rendering has to track each of these because there is no margin for error to absorb specification changes. An approximate renderer can sometimes stay within its approximation tolerance while the spec drifts; an exact renderer has to track the spec exactly.
The JCGT paper formalization matters here. Commercial SDK customers integrating Slug into a production pipeline can read the mathematics, reproduce the reasoning, and understand what they are licensing. Peer-reviewed algorithmic documentation is not common in commercial graphics middleware. It represents a different standard of accountability than benchmarks and screenshots, and it separates the correctness claim from the implementation details in a way that makes the library auditable.
After ten years, Slug occupies a clear position in the GPU text rendering landscape. When text must be correct at arbitrary scales without a preprocessing pipeline, when offline atlas generation is impractical, when SDF quality is visibly inadequate at the scales or viewing angles your application requires: this is the library built for that case. That niche is narrower than what SDF was designed to cover, but it is real, and a decade of maintenance means the library is production-ready in a way that a technically sound algorithm alone cannot guarantee.