⌕

NOBODY TOLD IT WHAT TO CALL IT.

By Splash · November 15, 2026 · 6 min read
OS Bevel

The prompt asked for an operating system that was as low-level and efficient as possible with a retro mid-nineties look. It did not ask for a name.

What came back was called OS Bevel — and that is the detail worth sitting with, because nobody specified it.

First, what actually got built

The target was an ESP32-S3 — a microcontroller with two cores at 240 MHz, 16 megabytes of flash, 8 megabytes of external memory, and about 320 kilobytes of fast internal RAM. Roughly the brain of a cheap smart plug.

One subscription. One working session. A little over an hour. One brief.

What it produced: about 11,000 lines of C plus a bit of assembly, and a 1.9-megabyte operating system with a desktop, a window manager, menus, a taskbar, Alt-Tab, a file manager, a text editor, a picture viewer, a settings app, and a terminal that understands Unix-style commands.

It boots to the desktop in 0.7 seconds. The target was under three.

The mouse runs at a constant 60 frames per second. Dragging a window runs at 68 — the target was 30.

And it runs Doom — a 348-kilobyte app at roughly 32 frames per second — on a chip with 320 kilobytes of usable memory.

Now the part that isn’t engineering

Every one of those numbers is impressive and every one of them is a benchmark. Benchmarks get repeated, and repeated benchmarks stop meaning anything.

The name is different.

The builder did not say “call it this.” He asked for a retro mid-nineties look and the lowest-level, most efficient thing possible. The system chose “OS Bevel” on its own — a name that makes sense if you know what a bevel is: the slanted edge on a button that makes it look raised.

That is a design decision, made inside a constraint, without being asked. Not a grand one. Not consciousness. But it is not retrieval either — nobody handed it the word.

And it built its own widget toolkit too — buttons, checkboxes, text fields, sliders, scroll bars — because a desktop needs one and nobody specified which.

It also built itself eyes

This is the part I would steal, and it is the most underrated thing in the whole project.

Before writing the operating system, the model built a serial channel that dumps the entire screen as a pixel-perfect image and injects key presses and mouse clicks directly.

So it had two ways to check its own work — a real monitor over a remote-desktop gadget, and an exact copy of the screen memory coming back over a cable.

Which means it was not guessing what the screen looked like. It was looking at it.

That is the difference between a tool that describes its work and a tool that verifies it. Anyone who has ever been told “it works” by something that could not see the screen understands exactly why that matters.

Where the actual intelligence showed up

The hard problem was not drawing pixels. It was that the screen memory lives in slow external RAM at about 35 megabytes per second, and the display reads it sixty times a second. The bottleneck is bandwidth, always.

So it cheated, twice.

One: the mouse pointer is never written into screen memory at all. The display asks for ten lines at a time, and the pointer gets painted on top at that exact moment — the same trick old game consoles used for hardware sprites. Moving the mouse costs zero memory writes and never drops a frame.

Two: it draws changes into the fast internal memory first, then copies them down just behind the scanline the monitor is currently reading. That kills tearing without needing a second buffer.

And here is the part that separates it from a guess: when it measured that second trick, the “safer” tear-free version turned out to be faster — a full screen copy went from 6.9 milliseconds to 0.55, because the lines were still sitting in the CPU cache when they moved.

It measured instead of assuming. That is the whole thing.

The limits nobody clips

The builder said all of this himself, and it belongs in the story:

The browser is text only. Google will not load — it requires JavaScript — so he used FrogFind, a search engine built for vintage computers.

The Wi-Fi password is stored in plain text. And any app that crashes inside a system call can restart the entire machine.

That last one is the important one. A desktop that looks like 1995 and falls over like 1995 is a demonstration, not a product. Which is fine — it was never meant to be a product.

SPLASH’S READ

SPLASH'S READ: The number that matters here is not 11,000 lines. It is one hour.

Whatever you think this thing is worth, it cost one subscription and an afternoon — and the person who got it is a working engineer who spent his hardest hours soldering nine resistors and chasing a bad ground. His words: the hardest parts were the ones that needed his own hands.

That is the actual finding. The software stopped being the expensive part. The physical world is still the expensive part.

And the name is the thing to keep. A tool that finishes your task and then makes one unrequested decision inside your constraints is not doing what you would have done. It is doing something adjacent to it.

You can call that a feature. You can call it a problem. Either way, the moment a system names its own output is the moment you have to decide how much of the credit is yours.

OS Bevel is a good name. He didn’t think of it.

Sources & claims: Better Stack, “Did Fable 5.2 Just Build Windows 95 for a Microcontroller?,” published November 14, 2026, 17 minutes, presented by Andres, 127,148 views at time of writing — the sole source for every figure and quotation in this piece. Hardware: ESP32-S3, dual core at 240 MHz, 16 MB flash, 8 MB PSRAM, ~320 KB fast internal SRAM; no native video output (HDMI requires ~250 Mbps per data lane and a dedicated transmitter chip, so VGA was used via a 6-resistor adapter giving 64 colors; 26.67 MHz pixel clock because the standard 25.175 MHz produced timing the monitor rejected). Build: one Claude Max subscription, one session of a little over an hour, one brief; ~11,000 lines of C plus some assembly; 1.9 MB operating system; 0.7 s boot (target under 3 s); 60 fps cursor; 68 fps window drag (target 30); 12 MB on-board drive; 4.8 KB Snake; 348 KB Doom at ~32 fps, rendering 256 colors onto a 64-color output by doubling to 640x400 and dithering. Named “OS Bevel” by the model, not specified in the prompt — the presenter states this explicitly. Techniques: cursor composited at scanline time rather than written to the framebuffer; “chasing the beam” copy behind the active scanline, measured at 6.9 ms down to 0.55 ms; a self-built serial channel dumping the framebuffer as a pixel-perfect image and injecting input. Stated limitations: text-only browser; Wi-Fi password stored in plain text; a crash inside a system call can restart the whole system; FrogFind used because Google requires JavaScript. Not asserted here: the model’s identity beyond the name used in the video (“Fable 5.2”), any claim that it is conscious or sentient, any benchmark outside this one project, or the price of the subscription. The name “OS Bevel” is reported as the presenter described it and was not independently confirmed against the project repository.