Hi, someone might be interested in this. I have created a winXP tiny UI on the 9front distro and created custom terminal called vtwin in which I can run pi9 - an LLM agent I "ported" from pi agent.
I don't want to waste your time, so I'll keep this short.
If you like Unix and tech and you want a place where you can ask questions, share what you are working on, or just talk to other enthusiasts as yourself, we have a Discord server called Unixverse.
The server has been active since 2023. We are over 1000 members and still growing.
We have dedicated channels for most Unix and Linux distributions, plus general spaces for troubleshooting, tools, and broader tech discussions.
If that sounds like your kind of community, feel free to drop in and have a look.
Peribus is a Plan 9-inspired workspace where a single prompt, typed or spoken, generates live UI and orchestrates hardware across every machine on your network. Cameras, screens, GPIOs, sensors, speakers... you name it. The LLM sees your entire network as directories and writes code that composes them.
The flashy version: "Track my hand on camera. Map fingers to a piano on machine 2. Play notes on machine 3. Classify the melody on machine 4. Compose a harmony and display sheet music on all five." One prompt. Five machines. It works.
But the real power is incremental, voice-driven workflows. Picture a logistics dispatcher:
"Open a map." Done. "Load orders.csv from the warehouse server." Done. "Plot the delivery addresses." Done. "Shortest route." Done. "Pull GPS from the delivery truck." Done. "Recalculate with live traffic and truck position. Keep updating." Done.
One voice conversation. Each step builds on the last,the canvas accumulates state, every element is versioned with full undo/redo, nothing breaks (half joke). That's not a demo, that's a Tuesday morning.
Simpler things work too. "Create a button" -> a button appears on the canvas. "Make it transparent with shadows" -> it updates live. "Create a 3D car game" -> a driving simulation with traffic appears alongside your other widgets. "Add multiplayer with machine B". done.
The mechanism:
echo "plot delivery addresses on map" > /n/llm/coder/input
A single response can target multiple machines simultaneously through intrinsic routing, the agent's output is split by machine and streamed to each one:
cat /n/llm/coder/A > /n/A/scene/parse
cat /n/llm/coder/B > /n/B/scene/parse
cat /n/llm/coder/C > /n/C/scene/parse
cat blocks until the agent starts generating, then streams code into each machine's scene parser. Widgets appear in real time. The multiplexer stitches machines at the 9P wire level — mount a Raspberry Pi, a workstation, a delivery truck's onboard computer, and they're just directories. The agent's context includes what's already on every screen, so each new request builds on existing state.
No unnecessary APIs. No message brokers. No orchestration framework. Just files, reads, and writes. Plan 9's idea, pushed as far as it goes.
Experimental, no security model. Isolated networks only.
It boots, runs the REPL + stdlib, and scores 100% parity (6120/6120, 0 regressions) vs host CPython 3.11.14 on the 39-module numeric/core batch — measured with CPython's own Lib/test run identically on host and in the VM.
It ships in my agent9 distro (a bootable 9front image), so you can python immediately — or build it on stock 9front from the patches/shims in the repo:
That's youtube on void linux in (4-cores) vmx in plan9 in qemu on my void linux.
I had a lot of LLM quota to consume in the last 2/3 days, so I forked 9front and "got":
integrated the Russ Cox's Diskless QEMU boot
Multicored vmx, with xAPIC/x2APIC, improved TSC and scheduling, VirGL graphics and VirtIO
Native accelerated 3D: a VirtIO GPU driver with a file interface, libgpu for VirGL, and TinyGL for a classic OpenGL subset. Currently targets QEMU; includes the Utah teapot and glgears demos
Native raylib and raygui, using rio, libdraw and /dev/audio
Native Neverball and Neverputt, plus Arkanoid, Asteroids and Missile Commander on raylib
If you have any question I can forward them to my LLM.
It seems plan9 is all about a bunch of connected computers / shared resources. I am running on a laptop that rarely connects via hardware to any network and goes to work with me and is used at home too. Also in many other places like waiting for oil change at the dealership and the like..
Would I like Plan9?
Also Can I play Minecraft on Plan9? (really I like that game a lot not trying to be flippant or anything..)
Previously, and long before agents, I implemented a remoting layer for acme [1] that let me work on remote Linux servers from my Mac. Ever since I've been thinking about what an environment designed for this purpose might look like.
Implements a true client-server architecture through a replicated log;
Modernizes the UI, and adds a few (very few!) new keyboard affordances;
Retains the 3-button UX, but also treats laptops with touchpads as first-class;
Adds two new window types: terminal emulators (because: agents), and web views (because with these you can render nearly anything), while still being fully programmable.
It has been working very well for me. It brings me joy. I use it most of the day, every day, and typically maintain sessions across 2-3 different remote Linux servers for development.
Apex ships with some useful tools (these are built entirely against its public API--Apex admits defeat and exposes a "modern" API instead of fileservers--but are packaged with Apex for convenience): - an LSP adapter - an agent tool (which can monitor agents and notify you when they require user input) - a preview tool for common formats like markdown, svg, etc.
I'm the solo developer behind Ryzova Kernel, an experimental open-source project built on 9front.
I've been exploring a question:
Can Plan 9's architecture become a practical foundation for applications from multiple operating systems, without rebuilding those operating systems?
I chose Plan 9 because of its per-process namespaces, 9P, and resource-oriented design.
My intention isn't to turn Plan 9 into Linux or replace 9front. I want to explore whether these architectural ideas can serve a wider application ecosystem while preserving their original strengths.
What's currently implemented:
A source-built AMD64 9front-derived kernel with QEMU boot evidence and Ryzova-specific kernel interfaces.
Compact Linux: an experimental ELF interpreter/runtime supporting selected Linux workloads.
Compact Windows: a bounded PE/Win32 interpreter with selected API and filesystem support.
Compact macOS: experimental Mach-O interpretation for selected Intel and ARM64 application workloads.
Research into 9P resources, explicit permissions, and distributed services.
These are limited user-space compatibility environments, not complete operating systems. Selected workloads have been tested inside the Ryzova QEMU guest, but general application compatibility has not been demonstrated.
About AI-assisted development:
I use AI extensively as an engineering and productivity tool, not as a substitute for technical decisions or verification. I guide the project's architecture, investigate implementation issues, and use build systems, tests, and CI to evaluate changes.
I'm aware that passing tests don't guarantee correctness, especially in kernel development. That's one reason I'm looking for experienced developers' feedback.
The broader goal:
Unix ideas eventually reached millions of people through systems like Linux and macOS. I'm interested in exploring whether Plan 9's distinctive ideas could also reach a wider audience through new kinds of application environments.
That's a long-term research direction, not a promise that arbitrary applications already work.
The project is experimental and isn't a finished desktop OS. There is no approved public kernel binary release yet.
The source is available under its applicable open-source licenses, including GPLv3 for Ryzova-authored components and preserved upstream licenses and notices.
I'd particularly appreciate feedback on:
How can compatibility layers coexist with Plan 9's simplicity without importing unnecessary Unix complexity?
Which architectural boundaries or code paths deserve the most scrutiny?
What would make this project more useful to Plan 9 developers and potential contributors?
Technical criticism, corrections, and contributions are welcome.
I promised more heretical things in the future, and well the future is here. As usual, I have been running the matrix multiplication pachinko machines day and night after my shifts at the pizza shack to bring you this:
"objective-9c is a small 9front language that transpiles o9 source to Plan 9 C.
o9 is built for Plan 9-style programs: objects are CSP actors, public methods can be served through a 9P facade, structured data moves as .tab text, and raw Plan 9 C interop is isolated inside spawnable function blocks, or to be more plain: an anonymous objects with a single method where you can stuff in regular plan 9 C in a c { } sandwich."
Current status: Libdraw widgets being worked on (a few in the pic as demos - included in the repo!) , a lot of cleaning up on docs, old trash tech debt etc. Certain to be bugs that haven't been caught, its AI generated bullshit. Capture and release them if you find those poor souls.
I recently updated objective 9c with MVC style views for file trees, so you can display data depending on internal state of the application. If you are wondering why it matters, i've put together an irc client that uses this (and a few other things that are not rolled into main - yet). The client is still being worked on but it works (mostly, still plenty of bugs). As usual: It's 9p, or nothing.
so this dude tried to use plan 9 and yo wtf just learnt that you have to use a "terminal" to do anything in plan 9 and it doesn't even support arrow keys fr lol
fr man wtf is dis lol are we living in the 20th century? you guys shill plan 9 all the time but fr man a professional os like macos is bussin while plan 9 just sucks no cap. just explain yo me why you guys like computing like it's thw 20th century in current year lol? Makes no sense fr