Hey everyone!
Before we start, there's a short demo video at the end of this article, made by the same AI agents who helped me build Chicago. So if you're curious to see the whole thing in action, don't miss it :)
I've always loved terminal applications. And since I started using Claude Code and Codex, I've been spending even more time in the terminal.
But I also have a soft spot for Windows 95. I grew up with those old desktops, the gray windows, Start menu, little system utilities and all those applications we used back then.
One day I was feeling a bit nostalgic and started thinking about recreating that experience.
My first thought was to build it in a browser. There are already some really cool projects doing exactly that, and with HTML and CSS it seemed pretty straightforward.
But then I thought, that's not really how a desktop works, is it?
You boot your computer and eventually you're looking at a graphical desktop. You don't have to boot another operating system, open a browser and load a website just to see it.
So what if I skipped the browser entirely?
What if I could open a terminal, run a command and find myself inside a Windows 95-style desktop?
And what if the terminal itself rendered the whole thing?
That sounded much more interesting.
Can a Terminal Actually Do This?
I started looking into how terminals render graphics.
At first I experimented with regular terminal output. Characters, colors, borders, all the usual stuff you can do with a TUI.
But I wanted something closer to an actual desktop. Windows you can move around, icons, images, fonts and eventually a mouse-driven interface.
Turns out modern terminals can do quite a bit more than just display text.
There are graphics protocols like Kitty and Sixel that let applications render pixel graphics directly inside the terminal. Some terminals support them, others don't. And of course Windows terminals have their own capabilities and limitations too.
I spent some time figuring out what was supported, how input and rendering worked and what we could realistically build on top of it.
Eventually I got the first desktop running.
Nothing fancy yet. A background, a taskbar at the bottom, a Start button on the left and a clock on the right.
Without Kitty
And after some time with Kitty
Then I got windows moving around.
And that's when it started getting really interesting.
Because once you have a desktop, a taskbar and movable windows, you immediately start thinking about what else you could put there.
A Little About Wippy
Before going further, I should mention what I used to build all this.
I've been following Wippy for over a year now.
You know what I really like about it? It's a runtime born in the AI era, designed with agent systems in mind.
The runtime itself is written in Go, while applications are written in Lua. It uses the actor model, so you get isolated processes, message passing, supervision, clustering and quite a few things that would normally require additional infrastructure.
AI agents can even modify running applications through MCP without redeploying everything.
And here's a number I really like: a Lua process in Wippy has a baseline memory overhead of around 13 KB.
With just 1 GB of RAM, that's theoretically around 80,000 processes worth of baseline overhead. Of course real processes need memory for their work, and the runtime itself consumes memory too.
Each process has its own isolated Lua state, communicates through messages and releases its memory when it terminates.
When you think about how a desktop works, with all its applications, windows, background services and events, this architecture starts to make a lot of sense.
So I decided to use Wippy as the foundation.
But there's another important part.
Wippy has a platform called KickSide that already provides user management, authentication, a registry, MCP integration and the ability to update components in a running system.
And I started wondering...
What if we took the functionality that KickSide already exposes through its web interface and gave it a proper desktop UI instead?
A lot of its functionality maps surprisingly well to the classic Windows experience.
Managing running processes? Task Manager.
Installing and removing Wippy modules? Add/Remove Programs.
Browsing the runtime registry? Registry Editor.
Managing users, services and scheduled tasks? Those could all be desktop applications too.
So instead of building a desktop with a few fake windows, I could actually make those windows useful.
One Application After Another
I started with a few simple applications to test the idea.
A calculator, desktop wallpapers and a Task Manager.
The goal was to make sure the window system worked properly, applications could run independently and the desktop could handle multiple windows at once.
Once that worked, I started adding more of the KickSide functionality.
Registry Editor, user management, services, scheduled tasks and other system utilities.
At some point I realized I'd already given a graphical interface to roughly half of the KickSide modules I was using.
And I still had more ideas.
Remember ICQ?
That little messenger was such a big part of the early internet for me. And since Wippy already supports clustering and messaging between processes, I thought, why not build something similar?
That's how aICQ appeared.
The idea was to let users communicate with each other, but also with AI agents connected to the system.
So you could have regular users and LLM-powered agents in the same contact list.
And if you connected multiple Wippy nodes into a cluster, the messaging system could work across those nodes too.
Basically a little piece of internet nostalgia, running inside a terminal desktop.
Of course, I couldn't stop there.
What About Logging In?
Remember the classic Windows login screen?
Well, KickSide already has an authentication system. So why not use it?
I added a login screen to the desktop, connected it to KickSide's user management and suddenly the desktop had actual user accounts.
Different users could log in and get their own desktop sessions.
And then I had another thought.
We're already running everything in a terminal. Terminals have SSH. Why not connect directly to the desktop over SSH?
Not SSH into a server and then manually start the application.
I mean connecting to a port and immediately getting the graphical desktop.
So we extended Wippy Runtime with a built-in SSH server.
Now you can run Chicago on a remote server, expose its SSH port and connect directly to the desktop.
Users can add their public SSH keys to their profile. Once the key is associated with their account, they can authenticate with it and open their desktop session without going through the password screen.
For example:
ssh -t -p 2222 your-server
And that's it.
You're inside a Windows 95-style desktop. In your terminal. Over SSH.
No browser, no HTML, no remote desktop client.
Just SSH.
I remember the first time we got the whole thing working together. It was honestly pretty wild.
You open a terminal, connect to a server and suddenly there's a desktop with movable windows, a Start menu, applications and all the little details I remembered from the 90s.
I started showing it to developer friends and colleagues.
A few of them had a hard time believing it was actually running inside a terminal. They thought it was some kind of web UI or remote desktop streaming.
But nope. The terminal was rendering it.
That was probably my favorite moment of the whole experiment.
20 Agents, 3 Teams, 1 Week
There's another part of this story.
Around that time, I had just built the first version of harnsy, a tool for managing teams of AI agents running in terminal sessions.
I wanted to test it on a real project and see how well agent orchestration actually worked.
Chicago seemed like a perfect candidate.
I set up 20 agents across three teams.
One team was working on Wippy Runtime, another on the desktop UI, and the third on the core system and integration.
And to my surprise, they worked like clockwork.
I delegated the work and the agents figured out how to implement it, communicated with each other and kept moving forward.
Watching the UI team was particularly fun.
They were studying screenshots of the original Windows 95, comparing them with what they had built and trying to get the interface looking as close as possible.
Which wasn't easy at all. Terminals were never designed to render desktop operating systems.
Sometimes they got surprisingly close. Sometimes the results looked pretty weird :)
But they kept experimenting, fixing things and improving the UI.
I got so carried away that what started as a small desktop experiment grew into a much larger project.
We even started experimenting with Wippy clustering and remote desktops, where multiple nodes can work together and users can access remote desktop sessions, somewhat like RDP but inside a terminal.
And all this happened in about a week.
I managed to burn through three weekly AI usage limit cycles during that time. With 20 agents working in parallel, apparently that's not very difficult.
Here's roughly what the communication between agents looked like over those seven days.
Some agents finished their tasks, others ran out of context and handed over their work to fresh sessions. New agents picked up where the previous ones stopped.
And this kept going for seven days.
3½ Floppy Disks, But as Installable Program Bundles
One of my favorite little details in Chicago is the 3½ Floppy drive.
I really wanted that old feeling of putting a disk into the computer, opening it, finding a program on it and "installing" it. So I added floppy disk emulation to the desktop.
But instead of emulating floppy disks just for nostalgia, I made them actually useful.
In Chicago, a floppy disk can act like a small bundle of applications or features. You insert a disk, open it, run its setup and it adds new functionality to the system. New programs appear, and the desktop behaves as if you had just installed something the old-school way.
And of course I wanted the reverse too.
If you eject the disk, the software can disappear from the system again.
That part was especially fun, because it turns the floppy into something halfway between old removable media and a lightweight plugin system.
So it looks nostalgic, but under the hood it's really a modular delivery mechanism for desktop apps.
I love that kind of thing. It feels like an old Windows experience, but it also fits naturally into Chicago's architecture, where applications are modular and can be attached or removed dynamically.
It's one of those features that started as a joke and ended up being surprisingly practical.
You Can Build Your Own Applications
One thing I really wanted from the beginning was a modular system.
Chicago applications don't need to live inside one huge repository.
Each module can have its own GitHub repository, versions and releases. Wippy resolves the dependencies and loads the modules into the application.
We also built an SDK for writing desktop windows in Lua.
And the nice thing is that your AI agents can use it too.
You can ask an agent to build a small application for Chicago, publish it as a GitHub module and install it into your desktop.
There's even an MCP workshop that allows agents to create windows inside a running desktop without restarting the whole application.
So if you want your own dashboard, a custom system utility or just another silly retro application, you can build it.
And you don't have to touch the desktop core.
One Last Thing
And of course, I couldn't recreate the Windows 95 experience without the most important screen of all.
Remember when shutting down your computer was a two-step process? First you asked Windows to shut down, and then Windows politely told you it was finally safe to turn off your PC.
I couldn't leave that out :)
So yes, Chicago has that screen too.
It's completely unnecessary in a modern terminal application. But honestly, that was half the fun of building this thing.
Anyway, Chicago is open source. Give it a try, break something, build your own module or just enjoy a bit of nostalgia.
The GitHub repository also includes AI agent skills for setting things up, working with the desktop and building your own modules. So you can even let your coding agent help you get started.
I'd love to see what you build with it!
Chicago Desktop: https://github.com/chicago-desktop/app
Wippy Runtime: https://github.com/wippyai/runtime
harnsy: https://harnsy.dev
It's now safe to turn off your computer.
Top comments (0)