HN Explorer

Show HN: I built an OS that is pure AI (pneuma.computer)

34 points by evanbarke ↗ HN
I've been building Pneuma, a desktop computing environment where software doesn't need to exist before you need it. There are no pre-installed applications. You boot to a blank screen with a prompt. You describe what you want: a CPU monitor, a game, a notes app, a data visualizer and a working program materializes in seconds. Once generated, agents persist. You can reuse them, they can communicate with each other through IPC, and you can share them through a community agent store. The idea isn't that everything is disposable. It's that creation is instant and the barrier to having exactly the tool you need is just describing it.

Under the hood: your input goes to an LLM, which generates a self-contained Rust module. That gets compiled to WebAssembly in under a second, then JIT-compiled and executed in a sandboxed Wasmtime instance. Everything is GPU-rendered via wgpu (Vulkan/Metal/DX12). If compilation fails, the error is automatically fed back for correction. ~90% first-attempt success rate.

The architecture is a microkernel: agents run in isolated WASM sandboxes with a typed ABI for drawing, input, storage, and networking. An agent crash can't bring down the system. Agents can run side by side, persist to a local store, and be shared or downloaded from the community store.

Currently it runs as a desktop app on Linux, macOS, and Windows. The longer-term goal is to run on bare metal and support existing ARM64 binaries alongside generated agents. A full computing environment where AI-generated software and traditional applications coexist.

Built entirely in Rust.

I built this because I think the traditional software model of find an app, install it, learn it, configure it; is unnecessary friction. If a computer can generate exactly the tool you need in the moment you need it, and then keep it around when it's useful, why maintain a library of pre-built software at all?

Free tier available (no credit card). There's a video on the landing page showing it in action.

Interested in feedback on the concept, the UX, and whether this is something you'd actually use.

34 comments

[ 4.4 ms ] story [ 63.0 ms ] thread
subdomain
Seems like a cool idea—I'm always game to try new operating systems! Recently been playing around with Playbit (https://playbit.app/)

Pneuma reminds me a little bit of Yansu AI, a project I saw recently on HN that proactively builds apps with AI (https://yansu.app/)

bensyverson
I think this is the way things are ultimately going (software as ephemerally generated based on your preferences), but at the moment, I can't see myself using these generated apps. Maybe it's just an aesthetic thing—have you experimented with personalized theming?
evanbarke
Yeah you can edit them however you like. I asked it to make a game with a lion fighting a bulldog and it could even doing that :D
owenpalmer
> Currently it runs as a desktop app on Linux, macOS, and Windows

Does that mean it's not actually an OS?

ingatorp
I mean Chrome OS started as a browser only OS. So theoretically it can be an OS.
evanbarke
Hey. This is a fair remark and logical too. It's build to run in a sandbox on other OS now to ease uptake. Asking people to install a new OS because "trust me bro" is not gonna work.

That said it is build as an os. It generates real wasm that runs directly on the machine.

Porting to baremetal is next on the backlog. It will require embedding rust cranelift directory into pneuma amongst other things but the hardest/biggest and most architectural part is already done: wasm. You can check out the blog for more info.

owenpalmer
> It generates real wasm that runs directly on the machine.

Well, it's not directly on the machine. You still need the wasm engine/runtime to run it

mfro
Some might claim a browser is an OS. Some do claim emacs is an OS. Tlon claims urbit is an OS. It’s a fairly fluid term nowadays.
erelong
One critique is that I think it might be more efficient to just make use of existing software for some of these things rather than generate them on the fly (for something for example like a text editor), but I guess that will depend on how costly it is to run AI programs in the future (if it becomes much cheaper, then I could see your concept being taken up by more people)
evanbarke
Yes that is definitely still gonna be necessary and it's why I build on a store where people can upload their apps/agents. There is a loose community section and in the backlog I have work around offering an sdk and official store for established companies to ship pneuma apps.
nextaccountic
> the UX

For this to be practical you really need to build things iteratively and asking the user questions, rather than attempting at one shot half assed ideas

Also most people are better explaining details with voice rather than text.

evanbarke
Voice is a great idea! On the backlog. Also pneuma already supports iteration/edits. You can say "edit my pong game so the paddles are pink" and it's smart enough to do it.
citizenpaul
>better with voice.

Ive found most people are not good at explaining details period.

Also how many time have you heard something like.

Blah blah, except, blah, only when, blah, but not that except.......

To the point where they've contradicted themselves several times and made at least two mutually exclusive things true.

spl757
How did you solve the problem of hallucinations?
IxInfra
the duct tape framing is fair but the deeper issue is the model has no persistent understanding of the system it's working in. each generation starts from scratch with no memory of prior context or architectural decisions. that's a harder problem than prompt engineering but it's solvable at the infrastructure layer
fractallyte
It's a fascinating paradigm – as though it dropped here out of some future.

However, I'd never use it. Reason: having everything dynamically created JIT means there's a trade-off somewhere else; in this case, it's energy consumption. I'd rather "cache" applications (ie. have them as installable software, which has been built just once) than endlessly recreate software from scratch each time, with all the energy usage that entails.

human_hack3r
I don't think generating an app would be the move forward. Rather it should be an agentic application that can be installed/added and the main agent controls it.

Building apps on the fly seems cool, But hits the frustration when they don't work at times, When building as a side project we tolerate it because we are in building phase, But when using we might not tolerate the issues.

Finally the security also plays a major role, So instead of building apps at runtime, We need agents and skills as portable objects.

plagasul
how does pneuma deal with persistence of user data?
hoppp
Sounds expensive to sustain and inefficient
PH4NTXMOFFICIAL
That's a very interesting and innovative idea. Congratulations, well tuned!
johnbuildss
Cool, curious though long did it take to build it?
a3ka
The WASM sandbox per agent with typed ABI is a really clean isolation model. Most agent runtimes I've seen just throw everything into one process and hope for the best.

Curious about the IPC layer between agents. When agents communicate with each other, is there any access control on what one agent can request from another? Or is it open by default?

In practice the moment you have multiple agents that persist and talk to each other, you need some kind of permission model — otherwise one rogue agent can access everything through a chain of IPC calls. Even if each individual sandbox is secure.

The Rust + WASM combo is solid for this. We use Rust for similar reasons — memory safety matters a lot more when agents run autonomously.

citizenpaul
This is really cool. It reminded me of my first thought for an AI app was a No-Interface crm/order system. I was talking to my bro in sales and all he ever does is complain about what a pain computers are. This takes that idea to the next level.

llms were not quite there at the time maybe ill revisit.

evanbarke
That's exactly it! I've absolutely loved the empowered my AI coding has brought me. This is about bringing the same to the end user with no technical skills!
0xqlive
The WASM sandbox + microkernel architecture is the right foundation for agent isolation, but it surfaces a problem that most agent systems don't address until it's too late: if every agent is ephemeral and generated on demand, your audit story is basically nonexistent. An agent crashes, does something unexpected, produces wrong output — and you have no record of what it was running, what context it had, or why it made the decisions it did.

With traditional software you at least have a binary you can inspect. Here the "program" is a generated Rust module that may never exist again in the same form. That's a genuinely hard problem for any use case where you need to reproduce or explain behavior after the fact.

The community agent store helps for sharing, but it also raises the question: when a downloaded agent does something wrong, who's responsible and how do you trace it? This feels like the unsexy infrastructure problem that'll define whether Pneuma can be trusted for anything beyond personal use.