Chris Wellons Ships Prospero, a Public-Domain C++ Coding Harness, Free or $25 Pro

TL;DR

Chris Wellons, the systems programmer behind w64devkit, has released Prospero, a native coding harness written in C++ on Dear ImGui. Its organizing rule is that nothing waits forever: permission prompts deny themselves after 30 seconds, shell commands turn into background jobs at two minutes, and a subagent is cut off after a fixed number of model requests. The Community Edition is public domain on GitHub; a $25 build on itch.io adds the headless engines that let one window drive agents on other machines, Windows XP included.

What shipped

The repository went public on October 21 and was tagged v0.10.0 the night of October 31, the same day Wellons published the announcement post. That is 388 commits in ten days. The Hacker News thread sat at 181 points and 120 comments when we checked.

Prospero is one executable. The window, the agent loop, the tools and the HTTP client live in the same process, with SDL3, FreeType and md4c under the GUI on macOS and Linux, and a Win32 layer over Direct3D 11 on Windows. It speaks the OpenAI Chat Completions API, so llama.cpp, vLLM, LiteLLM and OpenRouter all work, plus the Anthropic Messages API with extended thinking and prompt caching. It speaks MCP too, and can search the web through SearXNG when you allow it. Nothing is configured out of the box, and you cannot use a Claude subscription.

Configuration is a single INI file at ~/.config/prospero/prospero.ini, which the post greets with "No JSON, thank goodness." Keys never land in the file: a setting points at an environment variable or a file instead. One INI can include another by path or by URL, pinned to a SHA-256 if you like, which is how a team ships a managed config without a management server, and included files are restricted in what they may set.

Every operation has a deadline

The design principle Wellons puts first is "Never wait forever." In his words, "Every operation has a deadline." A harness built to be left alone cannot block on a human who has gone to lunch.

So a permission prompt is a card with a countdown. If you do not answer within 30 seconds, the agent gets a denial and is told to carry on without that path, then ask you at the end of its turn if it truly could not finish. The desktop tool, which can click and type on your screen, gives you 60 seconds. A question from the agent waits 300 seconds, then it goes with its own recommendation. A session nobody has open is unattended, and its asks are denied at once.

Shell commands get the same treatment in the other direction. A command still running at its two-minute limit is not killed; it moves to the background as a job and the agent moves on, reading the job's output as it runs and getting a notice when it ends. The agent can ask for up to ten minutes before that happens, a job may run for 30 minutes by default and two hours at most, and a session holds at most 16 jobs. A job that finishes while the session is idle wakes it to report, at most five times an hour.

Subagents have a budget instead of a clock: each is told to wrap up after 200 model requests and is stopped at 300. The harness sets these limits, so neither the model nor you has to.

What the permission prompts are for

Wellons is blunt about what the permission system is for. "Permissions are about gently reminding the agent of your wishes, and catching simple mistakes," he writes, and adds that real isolation means containers or separate hardware. "A human in the loop is like putting a ball and chain on the agent, giving up most of its advantages."

The file tools roam the working directory freely and ask before touching anything outside it. Shell commands do not ask at all; the agent is told to stay inside the directory, and the docs admit nothing holds a command to it. A write to Prospero's own configuration asks every time, with no "always allow" button, because the config decides what runs.

Bypass mode, picked in red, turns the asks off for an agent working somewhere it can do no harm. Even then the harness refuses writes under its own state directory, paths with a NUL byte, and web pages whose address never appeared in the conversation. Only you can turn it on; the agent and the config cannot.

When the harness stops a command, it stops everything the command started: "The whole process tree lives and dies together," using job objects on Windows and the equivalent elsewhere.

The engine runs sessions, the window only shows them

The harder idea is the split between engine and window. Normally both live in one process, but the same executable can run headless with prospero serve, keep working after you close the window, or run on another machine over ssh. Think of the engine as a restaurant kitchen and the window as the dining room: lock the dining room and the kitchen keeps cooking, and a kitchen in another building still sends its orders to your table.

Deploying to a remote uploads an engine binary with scp to ~/.prospero, verified by SHA-256. The headless build drops the GUI dependencies; on Windows it is CRT-free, imports only kernel32, advapi32 and winhttp, and its i686 build runs on Windows XP. The README puts it as "Imagine a coding harness on Windows XP." You now have a way to run an agent on the lab box nobody has dared reboot since 2009.

A remote with no model configuration of its own borrows yours: your window relays the model calls with your keys and sends the responses back, so an API key never has to live on the remote. If the connection drops, the host keeps your place for three hours and a response cut off mid-stream resumes where it stopped.

On Windows, every WSL distro is a remote host of its own, reached through wsl.exe instead of ssh, so a session on a laptop can hand a Linux build to a distro and get only the report back. Sessions on the same host can message each other, and such a message never counts as your permission.

Lean, by his own account

The resource claim is the one to read carefully. "It uses around two orders of magnitude fewer resources than other harnesses without sacrificing features," Wellons writes, and neither the post nor the store page gives a memory figure to back it. The checkable facts are smaller: the macOS download is 10 MB, the Windows zip is 8.7 MB, and rendering is passive, so the window redraws only when something changes and then goes idle after a few "settle frames" to finish animations.

The source is 131,165 lines of C++ across 73 files. He argues the leanness pays off somewhere other than battery life: "Because Prospero is so lean, it may be the only harness that can drive a fuzz campaign." The Linux OOM killer goes after the biggest process, and you want that to be the fuzz target, not the supervisor.

Evals are built in

Prospero ships an eval runner rather than leaving model comparison to vibes. Each run copies a fixture into a temporary directory, lets the agent work unattended, then checks the result byte for byte or with a script. The bundled editbench suite is 40 one-line bugs in real code, to be fixed with the file tools alone.

The runner records pass or fail, steps, failed edits, tool errors by kind, guard denials, retries and tokens including cache reads, one JSON line per run. It then recommends an edit format per model, and only when that format beat every other beyond chance on the same tasks, by sign test at p < 0.05.

Free, $25, or build it yourself

The GitHub source and releases are the Community Edition, released into the public domain under the Unlicense. Its window title says so, and an empty transcript shows a one-paragraph greeting asking people who use it professionally to buy the other build. That is the whole nag.

The Professional Edition on itch.io is $25 or more, DRM-free with free updates. It is the same program with the engines compiled in: macOS arm64, Windows x86-64 and i686, Linux aarch64 and x86-64. The Community build carries no engines, which is what makes remote deployment the paid feature. The itch page lists Windows and macOS downloads; Linux users build from source or take the GitHub release, a gap a commenter flagged within hours.

On October 4 he described replacing the Jekyll generator behind his blog with a bespoke C++20 tool in about 20 minutes of prompt writing and two hours of Opus 5.5 work, against his own estimate of two to four weeks. The Prospero post does not say how much of Prospero the agents wrote; one commenter who read the code said it looked handwritten and asked.

What the thread pushed back on

• C++ for an agent GUI drew the sharpest objection. The author of the JUCE framework, who has built a coding agent himself, argued that agent interfaces are markdown, HTML and long scrolling text, which C++ makes painful.
• No plugin or extension system. One commenter said they will not try a harness they cannot extend themselves.
• Commenters asked why a Claude subscription cannot be used. The post states the limitation and does not explain it.
• The praise clustered on one point: a dense, docking ImGui interface that does not eat gigabytes, from a developer with a track record.

Caveats

The "two orders of magnitude" figure is the author's estimate with no published measurement. Stars were under a hundred when we looked. The itch store lists the app as "In development," and five versions from v0.8.1 to v0.10.0 were tagged inside the ten days the repo has been public, so expect churn. Permissions, by the author's own framing, are not a security boundary; if you run Bypass mode, run it in a container.

Key Takeaways

• Prospero is a native C++ coding harness by Chris Wellons, public domain on GitHub, with a $25 DRM-free Professional Edition on itch.io.
• Every operation has a deadline: 30 seconds for a file permission, 60 for a desktop action, 300 for a question, and shell commands become background jobs at two minutes instead of being killed.
• The engine and window are separable. The paid build embeds headless engines for five platforms, including a CRT-free Windows build that runs on XP.
• A remote with no keys of its own relays model calls through your machine, so API keys stay local.
• A built-in eval runner with 40 one-line-bug tasks picks each model's edit format by sign test on the same tasks.
• The headline resource claim is unmeasured; the 10 MB and 8.7 MB downloads and passive rendering are what you can check today.

Sources: Chris Wellons, "Prospero: a new coding harness for a more civilized age", skeeto/prospero on GitHub, Prospero docs: Building, Prospero docs: Remote and background hosts, Prospero docs: Development and evals, Prospero docs: Configuration, Prospero Professional Edition on itch.io, Hacker News discussion, Chris Wellons, "A new, bespoke static site generator to replace Jekyll"