Complicated on Purpose
“There are two ways of constructing a software design: one way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult.” — C. A. R. Hoare, Turing Award lecture, 1980
Complexity is what people reach for when they lose sight of the underlying value. More than the 2008 mortgage crisis (CDOs and credit-default swaps), the modern web is the paramount example of that vice: a page whose one honest task is to hand you a document, now buried under machinery built to take something from you while you read.
What follows shows how simple the web should be: a real website, yours alone and reachable from anywhere, served from a chip that costs ninety-nine cents.
Simplicity is honesty
A simple thing wears its purpose on its face. You can see what it is for and, what matters more, confirm that it is so; nothing stands between you and the truth of it. Simplicity is not the absence of sophistication but the absence of anywhere to hide.
It follows that when a thing grows too elaborate for an ordinary person to follow, the elaboration is worth a second glance. Now and then the task really is that hard. Far more often, the complication is not depth but distance: the thing has drifted from the good it once delivered, and all that machinery is the wrapping drawn over the gap. Unwrap an honest object and you find a clean narrative within: a purpose, the end it was built to serve. Unwrap a dishonest one and you find nothing at all, because the wrapping was the object, there from the first to keep you from noticing that the purpose had quietly slipped away.
The vice is older than the web. Aristotle drew a line between a craft turned to its proper end and one turned merely to making money from money, and called the second the unnatural art: a genuine skill cut loose from the good that once gave it meaning. Complexity is how that cutting-loose conceals itself, for it seldom adds value; far more often it stands in for value’s absence.
This is what has happened to the web. The apparatus stacked on a modern page is not incompetent; it is some of the most accomplished engineering on the planet, but it has been turned toward an end that is no longer yours, and the surest sign of the turning is that you can no longer see, or even follow, what happens in the second after you click.
Which brings us to the rule we keep returning to. When a thing is far more complicated than its task requires, ask whom the extra machinery is for. Complexity is a receipt; read it, and you learn who it was you were paying.
“Simplicity is a great virtue but it requires hard work to achieve it and education to appreciate it. And to make matters worse: complexity sells better.” — Edsger W. Dijkstra
The path of a single page
It is worth reading one such receipt in full. You click a link, meaning only to read a page. Here is where that single click in fact goes:
a single page view
You came for a document; nineteen companies came for you. Not one of them is the thing you wanted, and every one of them is the machinery, which, tallied up, is the honest answer to what all the complexity is for. None of it is precisely hidden. It is merely far too involved to see, which in daily practice comes to the same thing. The page you actually asked for is a single quiet line on a long and itemized bill.
The honest version is small
What, then, would a website with nothing to conceal look like? It would be small enough to take in at a glance, and small enough to hold in the head entire. It would look, more or less, like this chip.
The part is an ESP32-C3: a single 32-bit RISC-V core at 160 MHz, 400 KB of fast memory, Wi-Fi and Bluetooth 5. The price is the detail nobody quite believes: a finished development board, with chip and antenna and regulator and a USB port already soldered in place, can be had for about ninety-nine cents. Not the bare die, but the whole of it, ready to plug in, for a fraction of the coffee.
It is plenty. The honest job was always small; we forgot only because the bill for the complicated version was settled in a currency we never watched leave our pockets. By the end of this you will be able to hold the entire arrangement, the site and the server and the way in, in your mind at once.
Two doors
A server is no server at all until you can reach it, and so, before a line of code, the architecture. There is no middleman anywhere within it, and the door you actually live behind is the private one.
The private door: WireGuard
This is the one that matters, and the one Virtues itself is built on: a private internet of your own. The chip is a WireGuard peer, WireGuard being a small, modern, almost embarrassingly simple encrypted tunnel, a few hundred lines of the good kind of code. The chip keeps a private key; your laptop and your phone keep theirs. From anywhere on earth your own devices can reach it, and everyone else cannot so much as find the door. At home it answers as well to a friendly esp32.local over mDNS, so you type the name and you have arrived. No account, no third party, no company in the middle to read the traffic, log it, throttle it, or be served a subpoena for it. The only people who can open this door are the ones to whom you handed a key. That is the whole of it: not a site flung at the world, but a place on the internet that is simply, only, yours.
The public door, if you ever want it
You can open the chip to the whole web, of course, and IPv6 makes it nearly trivial: every device can hold its own globally routable address, so you point a domain at it and you are live (reachability was never the hard part, whatever the rental trade told us). But a public address is a public one, and anyone who looks up the name learns roughly where you live and who carries your traffic. So for anything that is yours, the door to the world stays shut. For the rare thing you do want public, the honest move is to front it with a small relay you own, so the address the world sees is the relay’s and never your home’s. Our own demo at esp32.virtues.world is served exactly that way: the chip, behind a door we control.
The build
The whole of it, in plain terms: turn the website into static files, copy them onto the chip, and switch on the two doors. The full project, firmware and all, lives in the repo; what follows is only its shape.
The site is built the ordinary way. SvelteKit’s static adapter (npm run build) turns it into a folder of plain, pre-compressed files, and those files are flashed into a LittleFS partition that the firmware mounts as a perfectly ordinary filesystem.
The firmware is Rust, on esp-idf-svc. The entire web server is a single handler: it maps a URL to a file, prefers the gzipped twin the build already made, and streams it back.
fn serve(req: Request<&mut EspHttpConnection>) -> anyhow::Result<()> {
let path = resolve(req.uri()); // "/" -> /littlefs/index.html
// Prefer the gzipped twin the build already made.
let (mut file, encoding) = match File::open(format!("{path}.gz")) {
Ok(f) => (f, Some("gzip")),
Err(_) => (File::open(&path)?, None),
};
let mut headers = vec![("Content-Type", mime_for(&path))];
if let Some(enc) = encoding {
headers.push(("Content-Encoding", enc));
}
let mut res = req.into_response(200, None, &headers)?;
let mut buf = [0u8; 2048];
loop {
let n = file.read(&mut buf)?;
if n == 0 { break; }
res.write_all(&buf[..n])?;
}
Ok(())
}That is essentially all of it: a complete web server, in less code than most sites spend on the banner that asks leave to track you.
The rest is wiring, and there is less of it than you would expect. A single WireGuard component opens the private door, so your own devices reach the chip from anywhere and nothing else can. Making it public is optional: an AAAA record and one firewall rule, or a relay you own if you would rather not show your address. Flash, and watch it come up.
The one genuinely fiddly part, and we would sooner say so than pretend otherwise, is TLS. A browser wants a real certificate, and a microcontroller is an awkward place to run an ACME client. The clean answer is to do the certificate dance off the device: obtain a Let’s Encrypt certificate by a DNS-01 challenge on any machine you please, flash it alongside the firmware, and renew by re-flashing. Honest friction, named plainly; everything else is as small as it looks.
Open the network tab
Here is the part we like best, and it costs nothing to verify. Load the site, open the browser’s network tab, and watch what the page reaches for. Nothing. No analytics beacon, no font CDN, no tag manager, no ad exchange, no telemetry, no fourth party of any description. The page asks for its own files and is then still. Recall the path of that other click, the nineteen companies and the long itemized bill, and find it here simply empty. A static site cannot track you, for there is no one home to do it. It is private not because we have promised to behave but because nothing is present that could misbehave: privacy by architecture rather than by policy. You need not trust it. There is nothing to trust.
And because the whole of it (site, server, both doors) fits inside one person’s head, a second gift comes free. A thing you can hold in your head is a thing you can trust. You can read every layer. There is no tier beneath the tier, no region behind the region, no contract you never signed quietly governing the machine that keeps your words. The elaborate version asks for faith in an endless regress of abstractions you will never see; this one asks only that you look.
What it costs, and what it doesn’t
Ninety-nine cents, once, against a cloud bill that never stops, though the dollars are the smaller of the two charges. The rented version billed you twice, once in money and once in the long receipt from a few paragraphs back, and for all of it bought you nothing the chip does not already do. The visitor to a static page on your own server is not a product; her attention is not auctioned in the instant the page takes to paint; she came for the document and she got the document, which was once the whole of the web and on this chip is again.
A website you can understand
None of this is to say the cloud is a mistake, or a CDN a swindle. They are real answers to real problems: genuine global scale, traffic that swings by orders of magnitude within the hour, video served to millions, data that must live in many places at once. The fault is not that these tools exist; it is that they have become the reflex, reached for to serve a brochure or a blog or a personal page that has none of the problems they were built to solve. Most of the web is not Netflix. Most of the web is a document.
So: a chip from a drawer holds a real website, reachable from anywhere by you alone, tracking no one, owing nothing to anyone, for less than a coffee and some sixty cents of electricity a year, and all of it fits in your head. That last fact is the one that matters. Strip a web page down to the part that was ever truly for the reader and this is what remains: a small machine handing a document to whoever you choose. Everything you had to peel away to reach it was the other thing: complexity grown so far from the good it once did that the only way to keep the arrangement standing was to make it too involved to question.
This is a toy, and we will say so. But it is the same correction Virtues makes at the scale of an entire life. The record of who you are ought to be simple enough to understand and small enough to own, not interred in another company’s datacenter, behind another company’s abstractions, answering to another company’s purpose. A thing you own outlives the company that would have hosted it; it goes on working after everyone else has stopped caring. You do not rent your own existence back from the people who profit by it. Simplicity, it turns out, is not the humble choice. It is the honest one.
There is a chip in a drawer. There is, in all likelihood, one in yours.
Try it yourself
We are putting the full firmware, the partition layout, the WireGuard setup, and a starter SvelteKit site on GitHub. The board runs under a dollar, the whole bill of materials about three, and the build an afternoon’s work from start to finish.
And if you would rather point the same idea at the data of a whole life, with the same two doors and the same architecture with no one in the middle, built to be lived with rather than tinkered with, that is what we make. See how Virtues self-hosts.