A desktop app with an AI that actually does the work.
Rift is a desktop app for coding with AI. The AI works inside your project. It reads your
files, searches the code, and can run git for you, and you choose how much it does on its own.
All of that lives in a proper desktop app, with several chats open at once, a web browser built in, and
a meter showing what each turn costs.
It runs on Rust, which keeps it fast and stable. The AI can act on the app
itself, and the whole thing installs and updates without you lifting a finger. Nothing ever
ships unless every test passes first. It's still early, but you can download and run it right now — and every line of the code is
public.
Tell it what you want and watch it happen. You'll see it open a project, work through the
code in chat, split the window into side-by-side panes, and restyle the entire app from
settings with one click. No narration, just the real thing working.
0:00 / 0:00
Every frame here is the real app. This is the actual Rift, running a live session, captured start to finish.
02 / 06The problemWhy this exists
The best AI coding tool lives in a terminal window. I wanted a real app.
The AI I code with every day runs in a plain terminal window. It's powerful, but it's a cramped
place to work. There are no tabs. There's no clean way to look at its changes side by side, no
browser for the thing you just built, and no sense of what a session is costing you until the
bill shows up. Most of the desktop versions out there just wrap a web page around a chat box and
call it an app.
Rift takes that same way of working and builds it into a proper desktop app. You point it at a
project and the AI works the way you would. It reads the code, searches it, and runs git, and
you set how much of that it can do without asking. The preview opens in a browser docked right next to
the chat, your cost and usage stay in view the whole time, and you can talk to it instead of
typing.
03 / 06Inside RiftThree pillars
Three things make it more than a chat window.
There's an AI that actually does the work. There's an app it can reach out and act on. And the
whole thing ships and updates itself. The film above shows all three of them in motion.
01An AI with real tools, not just chat
This isn't a chat box with a fancy name. The AI actually does the work. It reads your files and searches your code, and it can run git for you (the tool that saves and tracks code changes). Everything it touches is fenced to the one folder you point it at. You can keep several conversations going, jump in and redirect it mid-task, set exactly what it's allowed to touch, and watch what each turn is costing you as it goes.
What it does
Reads and searches your code, runs git
Your part
You stay in control and review the work
02An app the AI can drive
Most AI tools can only talk back at you. Rift's AI can actually act on the app. When it needs a decision, a question pops up right in the chat. It can open a live preview of whatever you're building in the browser that's built in. When a long job finishes, it nudges the corner of the window so you know. It also keeps track of where things stand, like what's on your screen and how much of your usage you've spent.
What it does
Asks you, shows previews, sends a nudge
What it tracks
What's on screen and how much is left
03It ships itself
One command starts a release. It builds the app, packages it up, and publishes it, and every copy already out in the world updates itself the next time someone opens it. The current build is public right now, a one-click Windows installer, v0.148.0, and the code behind it is open source. And nothing ever goes out the door unless the compiler, the type-checker, and the full test suite all pass first.
A real web browser docked right next to the chat. You can scroll, click, and type an address, and the AI can open pages in it for you.
See what it costs
You can see exactly what every turn costs and how much of your usage is left. No surprise bill at the end of the month.
Talk to it
Speak instead of typing. The part that turns your voice into text runs right on your computer, so no audio ever leaves it.
You decide what it can touch
Set it to ask you before every change, or let it run on its own. You choose how much freedom the AI gets, and you can change it any time.
Work on several things at once
For a big job, it can split the work across several helpers running at the same time. Each one is kept walled off so they don't step on each other.
Clean up your wording
Type a rough thought, hit one button, and it rewrites it into a clear, specific instruction before it sends.
04 / 06The ugly cornersWhere the work actually lived
You could fake this in a weekend. The real version took months.
Anyone can put a chat box in a window. The hard part is making an AI that's actually safe to
hand real tools to. It's building an app the AI can drive without being able to hijack it. It's
shipping updates that can't leave anyone stranded. That's where the months went. Here are four
of those corners.
01I deleted the feature the app was named for
Rift started as a tool for syncing files to game servers. I cut the entire sync half, about a quarter of the code, once the AI part became the product.
Rift began as a control panel for game-server developers. It watched your files and pushed them to a remote server safely. Then the AI side outgrew all of that. I noticed I was opening Rift to write code, not to sync anything. So I tore out the half the app was literally named after: the remote connection, the file watcher, all of it. That was around 15,000 lines, deleted on purpose. What's left does one job, and every line of it earns its place.
What I cut
About 15,000 lines, on purpose
The result
One product that does one job
02I shipped an update that broke every copy out there
One lost key locked everyone out. So I rebuilt updates so that no key can ever do that again.
My old update system signed each release with a secret key. When I lost that key, every installed copy was stuck and could never accept another update again. I rebuilt the whole thing so there's no key left to lose in the first place. The tricky part was that an update quietly fails if the app is still busy in the background, so the new system shuts those jobs down cleanly before it swaps itself out. Nobody gets stranded like that again.
The fix
No key left to lose
The result
Updates that can't lock anyone out
03My AI can run git, so I attacked it first
The AI can save and push code on its own. Before it shipped, I tried to break it on purpose.
The moment an AI can run real commands on your machine, those commands become a door someone could sneak through. Real security holes had just turned up in tools a lot like mine, so I assumed mine had them too. I locked down everything it accepts. It can only touch the project folder, it can only run a short list of safe operations, it can't be tricked into reaching outside the project, and it flatly refuses anything dangerous. Two separate checks both have to agree before it's allowed to act, so if one of them is ever wrong, the other still holds the line.
My approach
Two checks, and both have to agree
The result
Locked down before it ever shipped
04The AI was being told to use a tool that didn't exist
It was being pointed at a feature an earlier cleanup had quietly deleted.
While I was going through what the AI could do, I found a ghost. Whenever it got stuck, the app would tell it to go ask me a question. But the feature that actually showed me that question had been deleted weeks earlier in a big cleanup. The AI was being told to use something that wasn't there anymore. I rebuilt it properly and made it fail gracefully. Now, if that part is ever down, the AI just isn't offered those tools at all, instead of trying and hitting an error.
The fix
Rebuilt it, and it fails gracefully now
The result
Asking, previews, and nudges all work
05 / 06How I built itAI-assisted, not AI-written
I taught myself this, and I build by working alongside AI. But I make the calls.
Here's how I actually work. I decide what to build next. I sketch out the shape I want and the
limits it has to stay inside, and I hand that to the AI. Then I read back through everything it
gives me, push back on whatever's wrong, and only keep what I've read through and can stand
behind. Nothing ships until it's clean. The Rust compiler, the type-checker, and the full test
suite all have to pass first.
That's why I can walk you through any decision on this page. Why the update system can't lock
anyone out. Why the AI's reach into your code is fenced off the way it is. Why the security
still holds even if one check fails. The AI helped me move faster. The decisions were all mine.
And you don't have to take my word for it. Rift is open source — the code, the commits, every
decision on this page, all of it is public. Read it on GitHub ↗
The git lockdown got designed up front, written out before a single line shipped. That's the order I want for anything that touches the internet or runs a command. Figure out how it could go wrong first, don't bolt safety on after it already works.
02
Delete faster
I knew the AI was the real product weeks before I actually cut the sync half. I held onto dead weight because I'd already sunk time into it, and when I finally cut it, it left that ghost tool behind. Next time I'll make the call the same week the evidence is in front of me.
03
Keep files small enough to hold in your head
A couple of core files grew past 2,000 lines and got scary to touch. I've been breaking them into smaller, focused pieces. The work goes a lot easier when each piece fits in your head at once.
This is the kind of thing I build. If you're hiring, let's talk.