# Bevel OS: A Desktop Built Around ESP32-S3 Constraints

A desktop interface does not necessarily need a desktop processor. With carefully chosen graphics, storage, and application boundaries, a microcontroller can support overlapping windows, a file manager, a terminal, and even a small web browser.

[Bevel OS](https://github.com/andrisgauracs/bevel-os) demonstrates that idea on a single ESP32-S3 board. Claude Fable 5.2 developed its visible desktop software through a coding-agent workflow, using feedback from real hardware. **The most instructive result is how the design works around limited memory bandwidth and input/output capabilities.** Its retro appearance is the consequence of an engineering budget as much as an aesthetic choice.

This guide examines the hardware path, renderer, application model, and feedback tools, while separating the demonstrated result from claims about a general-purpose operating system.

<iframe class="aspect-video h-auto" width="100%" height="315" src="https://www.youtube.com/embed/V8SZ6cJ6q5U" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

## A desktop environment on an existing embedded foundation

Bevel OS presents a mid-1990s-style desktop, but it is not Microsoft Windows and does not run Windows applications. Its window manager, widgets, shell, and applications form a custom environment for the board.

The underlying platform matters. The [architecture report](https://github.com/andrisgauracs/bevel-os/blob/main/docs/OS-REPORT.md) identifies ESP-IDF 5.5.3 and FreeRTOS for facilities including startup, scheduling, USB hosting, storage, and networking. Calling the result an operating system should not imply that the agent created every driver, protocol implementation, and scheduler from first principles.

![ESP32-S3 board and the memory and processor resources available to the desktop](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/2e7ef366-2c90-41db-408a-65ccb9d7a500/md2x =1920x1080)

*The build combines limited fast internal memory with larger external memory and flash storage.*

The demonstrated board has two 240 MHz cores, 16 MB of flash, and 8 MB of external PSRAM. Available fast internal memory is much smaller, on the order of a few hundred kilobytes after platform requirements. These are distinct resources: having megabytes of external RAM does not make every read and write equally cheap.

That distinction shapes the entire desktop. The framebuffer fits in external memory, but continuously scanning and repainting it competes for bandwidth. Storage fits in flash, but it cannot offer the capacity and write characteristics of a desktop SSD. A successful design must use each resource for the work it can support.

## Producing a picture without native video output

The board has no built-in HDMI output. Driving HDMI directly would require high-speed encoded signaling beyond what this arrangement can generate through ordinary GPIO. The project instead uses VGA, whose analog color levels and synchronization signals can be generated with a simpler hardware path.

Each color channel uses two GPIO signals through resistors. Four intensity levels per channel produce 64 combinations across red, green, and blue. This is a small palette, but enough for a desktop built around flat colors, bitmap fonts, and simple icons.

![Resistor-based VGA color generation using two GPIO signals for one channel](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/da39279d-4932-46e8-1150-c9aee9ff4e00/md1x =1920x1080)

*Two bits per color channel produce four intensity levels, giving a 64-color palette overall.*

Generating the right timing is as important as generating the color. The initial standard pixel-clock arrangement produces a signal rejected by the test monitor. An integer-divided clock around 26.67 MHz works with the chosen timing instead. This is a result for the tested hardware path, not evidence that every VGA display will accept arbitrary timing changes.

The practical lesson is that a software-visible failure can originate below the renderer. If the display never locks onto the signal, changing window code will not help. Establish a stable color test before attributing a blank screen to the graphical environment.

## USB input requires a host and a power path

The board's two USB-C connectors do not automatically provide two interchangeable peripheral ports. One connects through a USB-to-serial bridge, useful for flashing and logs. The native USB signals can support a keyboard or mouse, but the peripheral also needs a working power supply.

![USB input wiring separating native data signals from the peripheral power connection](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/13d7729b-153f-462d-f013-21da9d82d000/lg2x =1920x1080)

*A connector's shape does not establish that its data role and power path match the intended peripheral.*

The build uses breakouts to connect the native data pins and supply power separately. That physical work is part of the project's prerequisites. The software session begins after substantial wiring, signal testing, and enclosure preparation have already occurred.

This distinction makes the AI-development claim easier to assess. The agent can inspect code, flash firmware, interpret logs, and interact with a screen. It cannot perform soldering or discover the electrical state of a wire without an observation path or human assistance.

The completed setup also has a documented limitation around using separate input devices simultaneously. A working keyboard, a working mouse, or a combined receiver does not establish reliable support for every hub and device combination. Hardware compatibility should be recorded as tested combinations rather than inferred from one successful device.

## Giving the coding agent useful feedback

An agent developing graphics needs observations of the system it changes. Here, a JetKVM path exposes the real display and keyboard/mouse interaction. That provides an end-to-end view through the same output path a person uses.

The agent also builds a serial command channel for exact framebuffer dumps and input injection. A framebuffer dump is useful for pixel-level inspection; a real display capture is useful for checking that those pixels reach the monitor. Neither observation completely replaces the other.

![Development feedback through the real hardware display and JetKVM input](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/164fe2e0-7ce5-4a34-fb00-1277040dab00/lg1x =1920x1080)

*The real display and input path provide end-to-end hardware feedback during development.*

This combination shortens the iteration loop. Instead of relying on a human to describe every screen state, the agent can capture an image, issue an input, and compare the result. It can also run repeatable checks through the serial interface.

The generalizable technique is to expose a narrow, observable interface to the system under development. The interface should return enough evidence to detect failure, not merely acknowledge that a command was sent. A successful flash operation is an intermediate event; a correct screen and responsive input are the behavior being sought.

## The framebuffer is a bandwidth problem

A 640-by-480 display with one stored byte per pixel requires 307,200 bytes for a complete framebuffer. At a refresh rate near 60 Hz, scan-out repeatedly reads that memory whether the desktop changes or not.

External PSRAM supplies the capacity, but its bandwidth is shared with rendering. Repainting the entire screen for every small change would spend scarce write bandwidth on pixels that have not changed. Bevel instead tracks damaged regions and composes updates in fast internal memory before copying the result to PSRAM.

![Renderer diagram showing the external framebuffer and a small internal-memory composition strip](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/95107775-0f20-4d6d-b59b-aec53d55be00/public =1920x1080)

*A small fast buffer reduces repeated writes to the larger, slower framebuffer.*

This is a useful distinction between capacity and throughput. The framebuffer fits, yet the system can still perform poorly if its update pattern requires too much traffic. Efficient rendering depends on what is written, how often, and when those writes compete with display reads.

The design works strip by strip rather than allocating a second complete screen buffer. That keeps the fast-memory allocation small and makes the update path compatible with the board's limits. It also creates an opportunity to coordinate updates with scan-out.

## Drawing the pointer during scan-out

The mouse pointer is a small object that moves frequently. A naive implementation writes it into the framebuffer, restores the pixels under its old position, and paints its new position. Those writes consume bandwidth even when nothing else on the desktop changes.

Bevel composites the pointer while filling the scan-out buffers. The pointer appears in the outgoing image without being permanently painted into the stored framebuffer. Moving it therefore does not require rewriting the desktop image underneath it.

![Mouse pointer composited into scan-out while the stored framebuffer remains unchanged](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/99f1a985-e8dc-4ce3-c8c1-c45b23066500/md2x =1920x1080)

*The pointer can move without repeatedly erasing and repainting its background in external memory.*

The demonstrated pointer updates at the display's 60 FPS rate. That number describes this path on this build; it does not mean every application redraws its entire window at the same rate.

This separation is valuable because responsiveness is not one uniform metric. A desktop can keep a pointer smooth while a larger application update takes longer. Optimizing a frequently changing small element can improve perceived interaction without making every rendering operation equally fast.

## Updating behind the display beam

The compositor coordinates framebuffer writes with the lines the display has already consumed. It draws a region into internal memory, then copies it behind the current scan position. This reduces the chance that the display reads a partially updated region during the same refresh.

![Beam-aware update diagram and the measured copy-time comparison from the project](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/459fd344-3630-4fdd-f7e9-462d3cb17f00/lg2x =1920x1080)

*Coordinating writes with scan-out can address tearing without a second full framebuffer.*

The [performance log](https://github.com/andrisgauracs/bevel-os/blob/main/docs/PERF.md) reports that a particular full-screen copy measurement improves from about 6.9 milliseconds to 0.55 milliseconds with this arrangement. The stated explanation involves cache locality after scan-out has accessed the rows. This is a measurement of the tested copy path, not a universal multiplier for desktop performance.

Cache behavior makes this result more interesting than a simple instruction-count comparison. An operation that appears to add waiting can still reduce total time if it changes memory access locality. Measuring the actual path is more reliable than assuming that fewer synchronization steps always mean faster execution.

Tearing verification also has a boundary: the project's checks use scan-out counters. Those counters provide useful evidence about scheduling, while a display capture remains relevant to visible artifacts. Record which method supports each claim.

## A small desktop still needs application boundaries

The graphical environment includes familiar elements: overlapping windows, menus, dialogs, a taskbar, keyboard navigation, and basic widgets. Built-in applications include a file manager, text editor, picture viewer, terminal, and settings panels.

Storage uses a flash-backed drive rather than an SD card. Loadable applications are separate ELF programs with a defined interface to the environment. This allows an application to be added without treating every program as another hardwired desktop feature.

![Loadable applications on the flash drive and the small Snake application](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/9a98561e-f4c2-4410-7361-4b3c04e13d00/public =1920x1080)

*A defined application interface separates the desktop environment from programs loaded into it.*

That boundary is useful but weaker than a modern desktop process-isolation model. The environment can catch some faults in application code and present an error dialog. A fault occurring inside an operating-system call can still restart the whole system. Separate files and tasks do not automatically imply protected address spaces.

Doom illustrates both the capability and the limits. The port uses the existing doomgeneric project rather than recreating the game engine. It renders in a richer palette and uses dithering to display the result through the 64-color output path. The reported rate is around 32 FPS for the demonstrated scene, with no audio output on this hardware arrangement.

## Networking expands the scope and the constraints

The Wi-Fi browser supports a deliberately limited web experience. It lays out text, links, and simple structures rather than running a modern JavaScript application. A lightweight search service works where a contemporary JavaScript-dependent search page does not.

![Text browser displaying lightweight search results on the Bevel desktop](https://imagedelivery.net/xZXo0QFi-1_4Zimer-T0XQ/c3041fdc-abd8-4ab9-aa54-b68cff1c2000/lg2x =1920x1080)

*A useful browser on this hardware has a much narrower feature set than a desktop browser engine.*

That is a design boundary, not an incidental missing feature. A full browser engine would change the memory, processor, and compatibility requirements of the whole system. Keeping the browser narrow preserves a feasible workload for the board.

The build also stores its Wi-Fi password in plaintext on the local drive. Along with limited fault isolation and untested combinations of demanding applications, this places the project in the category of an experimental embedded desktop. Its successful demonstration should not be expanded into claims of production security or broad application compatibility.

## What the development result establishes

The reported software session runs a little over an hour and produces roughly 11,000 lines of C plus some assembly, on top of existing embedded components. The hardware preparation, earlier assistant work, physical interventions, and reused software remain part of the overall effort.

That accounting does not diminish the result. It identifies what made it possible: a constrained target, existing platform services, observable hardware, and a feedback loop that lets the agent test its changes. Counting only elapsed generation time would leave out the environment that supported the work.

The same approach can inform other embedded projects. Define the hardware budget, expose repeatable observations, distinguish foundational libraries from new code, and record manual interventions. Performance claims then become easier to reproduce and limitations easier to investigate.

## Final thoughts

Bevel OS shows how a small desktop can emerge from a tight combination of hardware choices and software mechanisms. Its renderer treats external-memory bandwidth as the central constraint, while serial feedback gives the coding agent a practical way to inspect and test real behavior.

**The result is compelling as an embedded systems demonstration with explicit limits.** It combines an original desktop environment with ESP-IDF, FreeRTOS, existing game code, and substantial hardware preparation. That concrete account is more useful than treating its Windows-like appearance as evidence of an entirely new general-purpose platform.
