Qt, GTK, Flutter, Electron? No: a graphics engine from scratch, entirely in Rust

Sergio Velásquez Zeballos — Wed, 14 Oct 2026 20:09:37 +0000

Llimphi draws every pixel of tawasuyu, even inside an operating system that boots with no Linux underneath. Why it exists, how it works and how true that “from scratch” really is.

Every time you open an application, something has to draw every button, every letter and every window on your screen, dozens of times per second. That something is a graphics engine, and almost nobody builds their own: most of the world’s software is painted with Qt, GTK, Flutter or Electron. Tawasuyu, the software suite with Quechua names being written in the Gioser workshop, chose not to borrow one.

Its engine is called Llimphi, which in Quechua means color, shine, pigment. It draws the whole suite: the desktop, the editor, the video player, the control panels and the interface of the project’s own operating system. Today 276 pieces of the suite are painted with Llimphi.

Fifteen and a half seconds of Llimphi. Everything on screen is drawn by the engine, frame by frame: the controls, the cosmos sky, the supay corridor, the infinite voxel world and the hand.
Why not use one that already exists

Until May 2026, tawasuyu was drawn with GPUI, the engine behind the Zed editor. On May 26 it was removed entirely, and not on a whim: the project has its own operating system, wawa, which boots straight on the hardware, with no Linux underneath. No existing engine knows how to draw there.

Qt, GTK and Flutter take a conventional operating system for granted, with its window manager, its installed fonts and its memory management. Llimphi was designed from day one to paint both in a desktop window and in the video memory of a kernel that has just powered on. That requirement forced it to be written from scratch.
What “from scratch” means

It is worth being precise, because it is the question every programmer asks. Llimphi did not reinvent every piece. Just as Flutter relies on Skia and GTK on Cairo, Llimphi uses four free projects from the Rust community for the most specialized jobs. Everything else is its own: the way an application describes its screen, how it reacts to each click, the components and the paths that lead to the pixels.

Talking to the graphics card: wgpu · community
Drawing curves and fills with antialiasing: vello · community
Working out where each box goes (flexbox and grid): taffy · community
Shaping text: Arabic, Chinese, emoji, ligatures: parley · community
The life cycle of each application: Llimphi
Components, themes, animation, accessibility: Llimphi
Painting without a graphics card, inside the kernel: Llimphi
Isolating an application and painting its drawing from outside: Llimphi

The four community pieces are written in Rust too. That is why the headline says “entirely in Rust”, and stands by it.
How a Llimphi application thinks

Llimphi follows the Elm architecture, named after a language known for applications that almost never crash. The idea is simple: the application does not modify the screen, it describes it. Every time something happens, the engine goes through six steps:

input: A click, a key or a gesture arrives.
update: The application computes its new state.
view: It describes how it should look in that state.
layout: The engine works out the position of each box.
raster: It turns that description into pixels.
present: It shows the finished frame.

Since nothing touches the screen directly, no two parts of the program fight over the same button. It is the same reason this style became popular on the web with React, except here it runs natively, with no browser in between.
One brush, four paths to your screen

The most unusual part of Llimphi is that the same drawing can reach the screen by completely different paths, depending on where the application runs. “Looks about the same” was not good enough: each path was put side by side with the others and the pixels were counted.
With a graphics card

The everyday path on the desktop. It is the reference everything else is measured against.
CPU only

The one the wawa kernel uses, since it has no video driver.
Subscribe to the Medium newsletter

Fills and layers identical bit for bit. Accented text may differ, because the kernel only ships three fonts.
By message

An isolated application doesn’t touch the screen: it sends its drawing as a message and the system paints it on its behalf.

0 pixels of difference across the four test scenes.
For phones

A path that works on mobile graphics chips without general-purpose compute, such as the Mali-G57.

No pixel differs by more than 1/255 out of 19,200.

The “by message” path coming out with zero difference has a practical consequence: an application can live locked away, with no permission at all to touch the screen, and still look exactly the same. Security that costs nothing in appearance.
What it already ships

Close to eighty components: buttons, tables, text editors with multiple cursors, node graphs, panel splitters, calendars and more.
Eleven modules that combine components into complete application pieces.
Real text: right-to-left writing, Chinese characters, emoji, ligatures and input methods for Asian languages.
Accessibility: every element can declare what it is and what it is called, and the tests query it the way a screen reader would.
Image-based tests: a screen is compared with its approved version, and any unexpected change makes the test fail.
A 3D voxel engine that mounts inside the same interface, as just another component.

What it doesn’t do yet

An engine that promises too much loses the trust of whoever tries it, so it is worth saying what is missing too:

The phone path has been tested on real hardware, but no published application uses it yet. The current Android builds take another path that doesn’t work on every chip.
Outside its three built-in fonts, text may look different in the kernel and on the desktop. The cause is known: with no operating system underneath, there is nowhere to get more fonts from.
Part of Llimphi is already published on crates.io, Rust’s official registry, but the release is incomplete and some recent pieces haven’t been uploaded yet.

How to try it

For Rust programmers, the way in is a single package:

cargo add llimphi

The package bundles the core, the themes and the 3D engine. For the rest, the best demonstration is tawasuyu itself: every window in the suite is a Llimphi application.

Originally published at https://gioser.net on October 12, 2026.

DEV Community: Sergio Velásquez Zeballos

Qt, GTK, Flutter, Electron? No: a graphics engine from scratch, entirely in Rust