Levien's JIT emits custom ARM code to draw each character, keeping the RP2350 within its tight pixel budget.
JIT BITMAP TEXT RENDERING BREAKS PERFORMANCE BARRIERS ON RP2350
*Raph Levien's vic-2350 project demonstrates a just‑in‑time approach that squeezes text rendering into a 6‑cycle‑per‑pixel budget. The technique revives bitmap fonts for ultra‑low‑power microcontrollers while preserving crisp, proportional typography.*
Raph Levien has been rebuilding an 80s‑era home computer on the RP2350 microcontroller board, a project he calls vic‑2350. Text rendering is the linchpin: the system must draw crisp characters while racing each scanline, leaving only about six CPU cycles per pixel. Levien rejected modern antialiased fonts, opting for bitmap fonts that deliver a sharp, low‑resolution aesthetic and consume far less processing power. To push the limits, he added a just‑in‑time compiler that emits custom ARM code for every string, turning a traditionally heavyweight task into a micro‑second operation. The result is a rendering pipeline that fits inside the RP2350's 520 kB SRAM and meets the demanding latency of his race‑the‑beam video output.
How does the JIT rendering technique work on the RP2350?
Levien embeds a JIT that emits highly optimized ARM code for each string at runtime. The renderer treats text as a display object containing the string, a font pointer, and colour data. When a scanline reaches the object's start, the JIT‑generated routine draws the bitmap glyphs directly into the video buffer. Because the code is crafted for the exact characters and layout, it eliminates generic loops and branches, staying within the tight budget of roughly six cycles per pixel. The same approach can be applied to any framebuffer write, not just the race‑the‑beam pipeline.
Why bitmap fonts survive on microcontrollers
Levien chose bitmap fonts for two reasons: raw efficiency and aesthetic control at low resolution. Bitmap glyphs occupy fixed bytes per character and avoid the heavy calculations of antialiasing. At the RP2350's 520 kB SRAM limit, this saves precious memory for the double‑buffered display list. Moreover, the crisp, intentionally designed look matches the early Macintosh style Levien admires, offering a visual quality that blurred, antialiased fonts cannot deliver on tiny screens.
What forced the shift from Rust to hand‑written assembly?
The RP2350 can output DVI video via the HSTX peripheral, but filling the buffer is entirely software‑driven. Levien measured a hard ceiling of about six CPU cycles per pixel. Rust's abstraction overhead could not meet that limit, prompting a move to raw ARM assembly written in his custom language, symbolasm. Assembly lets him hand‑craft the inner loops, shave cycles, and keep the renderer within budget while still supporting the JIT's dynamic code generation.
What does this mean for future low‑power graphics?
By proving that a JIT can generate per‑string machine code within microcontroller constraints, Levien opens a path for richer UI on devices previously limited to fixed‑cell text. The technique scales to any display object, suggesting that future hobbyist and commercial boards could adopt proportional, kerning‑aware fonts without sacrificing performance. As SRAM remains scarce, the double‑buffered display list and deterministic bitmap allocator become a template for memory‑efficient graphics pipelines on similar Cortex‑M33 chips.
Frequently asked questions
What is the pixel budget for text rendering on the RP2350?
The renderer must stay within approximately six CPU cycles per pixel to meet performance constraints.
Why did the author choose bitmap fonts over antialiased fonts?
Bitmap fonts are more efficient and provide a crisp, intentionally designed look at low resolutions, which aligns with the aesthetic of early Macintosh systems.
How does the JIT improve rendering speed on the RP2350?
The JIT generates highly optimized ARM code on the fly for each string, eliminating generic loops and fitting the rendering work within the tight cycle budget.
Levien's JIT bitmap renderer shows that microcontrollers can host sophisticated, proportional text without compromising speed or memory. By marrying assembly‑level efficiency with on‑the‑fly code generation, the vic‑2350 project challenges the notion that low‑cost hardware must settle for monospaced, static fonts. As developers chase richer interfaces on constrained devices, this approach may become a new standard for ultra‑lean graphics pipelines.
Sources: [Hacker News: JIT bitmap text rendering for microcontrollers (Linebender blog)]