What tawasuyu is

tawasuyu is a vertical software suite written in Rust. Among its pieces there is an operating system that boots straight on the hardware, with no Linux underneath; its own graphics engine, Llimphi; a desktop with its window manager; a web browser with its own engine, without Chromium or WebKit; a writing environment where the same text lives in several languages and tones; an ERP, an astronomy engine, mail, music, video and a medical record.

The odd part isn’t the quantity. It’s that none of it rents its foundations: everything rests on the same format, the same identity and the same engine that draws, and none of them has an owner other than you.

Sovereignty, layer by layer

The word has been worn thin by speeches, so it’s worth bringing it down to something that can be checked. On an ordinary computer, every layer has an owner who isn’t the person using it. In tawasuyu, each one has a piece of its own that replaces it:

And the rule behind the table is a single one: what comes from outside enters through a bridge, never into the centre. A PDF opens, a spreadsheet gets imported, a website gets visited; but inside, everything works in the native format, and if tomorrow the maker of that format disappears, what is yours stays readable.

Survival doesn’t belong to the individual alone

So far, this could be the dream of someone who wants to lock themselves inside their machine. But individual sovereignty has a well-known limit: one person alone doesn’t sustain a road, a record or a decision. And that is where the project looks to the Andes.

For thousands of years, Andean peoples sustained roads that crossed a continent and terraces that still yield harvests, without money or alphabetic writing. What sustained them wasn’t a technical device but a way of organizing: ayni, exact and measurable reciprocity; minka, voluntary work for the common good; and the ayllu, the sovereign community as the unit, instead of the isolated individual.

tawasuyu translates that idea into cryptography. A file named by its content has no central index anyone can seize. An identity that is a key doesn’t need a master registry to authorize it or cancel it. And a community that decides by a signature threshold —so many of its members have to agree— doesn’t depend on who owns the server. It’s the same premise, written this time in Rust.

Four regions, one cycle

The name is the blueprint. Tawa is four in Quechua and suyu is region: tawasuyu means four regions. The whole repository is split in four, and each part corresponds to a phase of what happens to information: it is perceived, known, acted upon and sustained.

Yachay is knowing and ruway is doing. Unanchay is related to the signal and to noticing it. Uku pacha is, in the Andean worldview, the inner world, the one below: the place of roots. It’s no accident that sovereignty starts there: whoever doesn’t own the root owns nothing of what grows on top of it.

And it isn’t an administrative division. Moving a program to another region changes what it is. tawasuyu has two programs that work with news: watuy harvests claims and puts them side by side, and lives in perceive; iniy (in Quechua, to believe) verifies them, and lives in know. Collecting a claim isn’t taking it as true, and the code doesn’t let the two be confused.

The chakana: everything goes through the bridge

The logo is a chakana, the Andean stepped cross with a circular hole in its centre. It has been carved in stone since Chavín and Tiwanaku, and it still appears in textiles someone weaves today. Its name comes from chaka, bridge.

In tawasuyu the chakana isn’t an ornament: it’s the diagram. The four regions are its four arms, and at the centre is the bridge. The rule it draws is strict: nothing communicates by skipping ahead; everything goes through the middle. It’s the same rule as foreign formats, seen from above: whatever crosses, crosses at a declared place, where it can be looked at.

Apps woven together like an ayllu

tawasuyu’s applications aren’t conceived as standalone programs. The project’s documentation says it in one line: they are Andean institutions written as software. And almost all of them do the same thing to a different institution: they remove the middleman.

And they are woven together as in an ayllu: work recorded in tampu becomes credit in ayni, the tantanakuy assembly signs its minutes as a community, and those minutes go into a public record. None of those steps needs to ask a company for permission.

Agora and the seal of the ayllu

That idea has its own place in agora, the plaza of identity. A community has its constitution and its own seal, which is only stamped when the members it set itself have signed. The person is sovereign and the community can sign as one, without anyone signing on someone else’s behalf. Agora deserves an article of its own, and it will get one.

A tribute

When the conquest banned the assemblies and persecuted the language, the Andean way of organizing was not lost: Quechua is still spoken and the stepped cross is still woven. In its own way, it is the longest proof of sovereignty there is: what a community sustains outlives whoever tried to take it away.

tawasuyu is a tribute to that architecture. It isn’t a flag: Quechua is the language of many peoples and crosses borders, and the project speaks on behalf of none of them. It learns from them. It takes the idea that resisted the longest —that what endures isn’t what an owner keeps on their server, but what a community sustains— and writes it in the place where today it’s decided who rules: software.

What isn’t there yet

• The operating system of its own doesn’t replace Linux in daily use yet. Today tawasuyu’s desktop runs on a Linux kernel and its drivers; the root of its own exists and boots, but it doesn’t carry everything yet.
• The browser of its own doesn’t open the whole web yet. Its JavaScript engine passes 13.1% of the language’s official test suite (Test262), and the browser 22.1% of the web platform subtests (WPT) already run against it. It grows every week, and the numbers are published as they come out.
• The hardware isn’t sovereign. The processor, the graphics card and their firmware still belong to whoever made them. tawasuyu starts where the silicon ends.
• The names take some getting used to. A newcomer doesn’t know what nakui or kamachiq is without reading its description, and the Quechua on some screens hasn’t been reviewed by a speaker yet. Reviews are welcome.

How to see it

The code is at git.tawasuyu.net —on a server of its own, not on someone else’s platform— and the full map, at tawasuyu.net. To check what this article says, just open the root of the repository: the four regions are the first thing you see.

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.

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.

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:

1. inputA click, a key or a gesture arrives.
2. updateThe application computes its new state.
3. viewIt describes how it should look in that state.
4. layoutThe engine works out the position of each box.
5. rasterIt turns that description into pixels.
6. presentIt 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.

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.