Local-first is not a luxury

Vision & direction August 2026 · Mansour Ayouni

In much of the software industry, "offline support" is a feature — something added late, tested rarely, and quietly dropped when the deadline arrives. The applications that led to RingScript were built the other way around, because they had no choice.

Software with real users, in real places

The applications came first, and they were never demos: in Niger, for a bank and for a high school; in France, for a restaurant. Different countries, different trades, one shared reality — the rules of the business matter, the connection is not guaranteed, and the software has to keep working long after the excitement of building it has passed.

A teacher entering grades does not care whether the fibre link to the capital is up. A branch clerk recording a deposit cannot tell a customer to come back when the network does. In these settings, an application that needs the cloud to think is not an application — it is a promise that breaks at the worst moment.

The local-first shape. A tablet labelled "The device" contains
          two things joined to each other: the app, drawn as a phone screen, and
          the data, drawn as a database cylinder marked "Local Database
          (persistent)". The app works; the data answers. A visitor stands on
          the device. Outside it, across the widest gap in the picture, a cloud
          labelled "The server" offers sync, backup and share — and it is
          reached by a dashed line, the only dashed thing here, labelled "when
          the connection allows". The connection is a guest, not a foundation:
          when it visits, you synchronise; when it leaves, nothing stops.

The tontine test

A good way to check whether software respects its users is to ask whether it could run a tontine — the rotating savings circle that finances real life across Africa and well beyond it. A tontine has strict rules (who paid, which round, whose turn), real money, and members who meet in places with no promise of coverage. It has run flawlessly for centuries on a notebook and trust.

Digitising it is only an improvement if the digital version is as dependable as the notebook. That is a high bar: the notebook never shows a spinner. This is why the data application on this site is a savings-circle register and not a to-do list — it is the honest test.

Why the browser, then?

It may seem contradictory to preach local-first and then build for the browser, the most connected place there is. But the browser has quietly become the best local runtime we have: it is already installed on every device, it runs the same everywhere, it needs no administrator to deploy into, and — with WebAssembly — it executes real compiled code. A page loaded once from a local file or a tiny local server keeps running with the network cable out of the wall.

The browser is not the cloud. It is the last universally available computer, and it works offline if the software is built to.

What was missing was the language. The applications above are written in Ring; their server side is Ring; their rules are Ring. Only the page demanded a second language and a second way of thinking. Putting the Ring VM itself in the browser — the actual virtual machine, verified program by program against native Ring — closed the gap. That is RingScript.

One stack, one set of ideas

RingScript is one piece of a deliberately small stack, all of it built under the Softanza project: Softanza gives Ring code its expressiveness; StzWeb, coming soon, is an opinionated, deliberately simple web framework for business applications built on plain web standards and made to run offline; RingScript is the runtime that lets the whole thing live in a page. The goal is that a desktop programmer — the kind who builds the bank's and the school's software today — can build for the web and mobile using Ring, Softanza, and the strict minimum of the target platform's concepts. No build pipelines, no framework treadmill, no second language.

What this asks of us

Local-first is not a slogan here; it is a set of engineering obligations this project tries to honour visibly:

Reliability over benchmarks. The runtime is soak-tested across tens of thousands of evaluations and fuzzed with thousands of hostile inputs, because an application that must run for years cannot leak by a little. Verification over claims. Every Ring program the runtime ships is checked byte-for-byte against native Ring. Smallness over features. The whole runtime is ~380 KB, loads in milliseconds, and carries no dependencies — because every dependency is a promise someone else has to keep.

If you write software for people who need it to work — offline, predictably, for years — this stack is being built for you, and you can start with one folder and one click.