Pimp My IDE / garage dispatch
Back to garage
September 30, 2026 | GPU text / atlases / glyph outlines

Choose the text path after you measure the text.

Bitmap atlases, signed distance fields, multi-channel signed distance fields, tessellation, and direct outline rendering solve different workloads. The right question is not which screenshot looks sharpest. It is what changes at runtime.

Record scale, glyph churn, script coverage, transform, and target hardware before choosing a renderer.

A glyph is an outline before it is a texture.

TrueType and OpenType fonts describe glyph outlines with line and curve segments. A renderer must shape text, select glyphs, place them, and turn those outlines into covered pixels. The rendering technique changes the last part. It does not remove shaping, fallback, line breaking, or font licensing.

AlphaPixel's recent comparison is useful because it puts five GPU paths beside one another. It also comes from the maker of Slughorn, an implementation built around the Slug technique. Treat its method descriptions as engineering guidance and its product judgments as vendor claims.[1]

An atlas trades change for speed.

A bitmap atlas rasterizes glyphs into a shared texture and draws each character as a textured quad. It is simple and fast when sizes and glyph sets are known. Large magnification exposes the baked resolution. New sizes, scripts, or glyphs require more texture space or runtime atlas work.[1]

A signed distance field stores distance to the nearest edge instead of final coverage. The shader reconstructs the edge at draw time. A multi-channel signed distance field stores several edge distances so sharp corners survive better than they do in a single channel. The msdfgen project documents this goal and ships an MIT-licensed generator and library.[2]

A sharper sample is not a workload decision.

Outline methods move cost instead of deleting it.

Eric Lengyel's 2017 JCGT paper describes GPU-centered rendering directly from glyph outlines. The paper includes downloadable shader source and explains its winding and curve-intersection method.[3] AlphaPixel's Slughorn repository is a current MIT-licensed implementation with CMake, Python bindings, examples, tests, and active work items. This pass inspected the repository and its current status. It did not build or benchmark it.[4]

Tessellation-based renderers turn paths into geometry or coverage work that the GPU can draw. Rive's current C++ runtime includes GPU backends for Metal, Vulkan, Direct3D, OpenGL, and WebGL. That makes it relevant to animated vector graphics. It does not make it the automatic choice for a terminal or code editor.[5]

Test the ugly edges.

  1. Use the smallest text that must remain readable.
  2. Use the largest scale and hardest perspective transform.
  3. Load the real scripts, fallback fonts, and glyph churn.
  4. Measure texture memory, generation time, frame time, and cache misses on target hardware.
  5. Inspect hinting, kerning, shaping, selection, accessibility, and copy behavior outside the shader.
Interactive makeover / glyph raster selector

Load the workload first

Traditional purpose replaced: a static comparison table. Better version: choose the text workload, see which cost moves into texture, generation, or shader work, then copy a test card with missing evidence left open.

Choose the workload

The selector offers a starting route. It does not rank visual quality or predict frame time.

Text workload
Test-card sections
Test card draft0 of 4 sections selected
Workload routing diagram

Glyph raster selector

Slot 2 / 4: MSDF atlas candidate

Start with an MSDF atlas candidate.

Repeated glyphs and wide scale changes can justify the extra atlas channels. Test the smallest size and the hardest corner before committing.

Selecting every section means the test-card structure is ready. It does not prove image quality, performance, script coverage, or implementation fitness.

Cost map / starting points

Every route keeps a bill.

01 / BITMAP

Bake final pixels

Simple draw path. Scaling, glyph coverage, and extra sizes consume texture space.

02 / MSDF

Bake edge distance

Sharp scalable edges from an atlas. Generation and multi-channel texture storage remain.

03 / OUTLINE

Solve curves in the shader

Changing glyph sets avoid a baked atlas. Shader work and implementation complexity move forward.

04 / TESSELLATE

Turn paths into draw work

Useful for changing vector geometry. Geometry processing and backend support become part of the test.

Sources read

Source log and evidence boundary
  1. AlphaPixel, "SDF vs MSDF vs Slug vs Rive vs Texture Atlas", published September 23 and read September 30, 2026. This comparison supplies the current survey and implementation framing. AlphaPixel also develops Slughorn, so its preferences are treated as vendor judgment.
  2. Viktor Chlumsky, msdfgen repository, read September 30, 2026. The project describes multi-channel distance fields, sharp-corner reconstruction, its generator and library layout, and MIT license.
  3. Eric Lengyel, "GPU-Centered Font Rendering Directly from Glyph Outlines," JCGT 6(2), 2017. The journal page provides the paper, citation, and shader source.
  4. AlphaPixel Slughorn repository, inspected September 30, 2026. The public repository has an MIT license, CMake build files, Python packaging, examples, tests, and an active status table. This pass did not build it.
  5. Rive C++ runtime and renderer repository, inspected September 30, 2026. Its README lists Metal, Vulkan, Direct3D 11 and 12, OpenGL, and WebGL backends and describes the runtime's vector-rendering role.
  6. Hacker News discussion, exact item 49908962, checked September 30, 2026. It led to the AlphaPixel article. It is reader reaction, not evidence for renderer behavior.

Evidence boundary: this page compares documented techniques and proposes a review card. It did not run a renderer, inspect output pixels, or measure frame time. The specimen changes are illustrative CSS only. Test the real font corpus and target hardware before choosing a production path.