On August 19, 2026, Rob Pruzan (@RobKnight__) posted three words that undersell what they describe: "VS Code inside the terminal." The project is terminal-code — a VS Code-compatible CLI editor that runs entirely inside a terminal window, works over a plain SSH connection, and syncs its colors to whatever terminal theme is already installed. The launch thread passed 1.8M views within a day.
Pruzan is the founder of Zenbu (Y Combinator Program 26) and the creator of terminal-browser, the project terminal-code is actually built on. His bio also credits stints on the Next.js team and co-authorship of react-scan, the React render-tracking devtool — which matters here, because terminal-code isn't a first attempt at "put a real UI inside a terminal." It's the second act of a pattern Pruzan has already shipped once.
This isn't the same idea as VS Code Remote-SSH, which most developers already associate with "editing code on a remote box." Remote-SSH keeps the familiar VS Code desktop app running locally and tunnels a lightweight server to the remote machine — you still need a GUI, a display, and the Remote-SSH extension configured. terminal-code skips the GUI entirely: the terminal session itself becomes the editor.
TL;DR
| Question | Direct answer |
|---|---|
| What is it? | A VS Code-compatible CLI editor that renders inside a terminal window instead of a desktop app. |
| Who made it? | Rob Pruzan, founder of Zenbu (YC P26), creator of terminal-browser. |
| Does it work over SSH? | Yes — that's the headline feature. No local GUI, no port forwarding, no separate remote extension. |
| How does theming work? | It syncs to your existing terminal color scheme instead of shipping its own fixed theme. |
| What's it built on? | terminal-browser's "app mode," which Pruzan compares to building Electron apps — except the runtime is a terminal, not Chromium. |
| Is it open source? | Yes, per Pruzan's reply on the thread — check terminal-code.com for the current repo link. |
| Does it replace tmux? | No — it's an editor, not a multiplexer. Run it inside a tmux pane the same way you'd run vim. |
What "VS Code inside the terminal" actually means
VS Code is, structurally, an Electron app: a Chromium renderer wrapped around a desktop shell. Terminal editors like vim, Neovim, and Helix exist on the opposite end — text-mode interfaces drawn with ANSI escape codes, no windowing system involved. terminal-code sits in between: Pruzan describes it as VS Code-compatible, running inside the terminal's own rendering surface, with SSH support as a first-class use case rather than a bolt-on.
That combination is the actual news here. A terminal editor that works over SSH is not new — that's every terminal editor ever built. What's new is a VS Code-compatible one that does it, because VS Code's usual value (its extension ecosystem, its familiar keybindings and UI conventions, its command palette) has historically required the Electron shell to exist. terminal-code's bet is that you can keep enough of that VS Code-shaped experience while dropping the GUI dependency entirely.
The theme-sync detail reinforces the same design goal. A GUI app carries its own visual identity regardless of what terminal you launch it from. terminal-code instead inherits whatever ANSI theme your terminal already has configured — so switching between a shell prompt and the editor doesn't produce a jarring context switch, the way alt-tabbing into a separate Electron window does.
The foundation: terminal-browser's "app mode"
terminal-code isn't a from-scratch project — Pruzan built it on top of terminal-browser, an earlier tool from the same account. In a follow-up post on the same thread, he described the underlying mechanism directly:
"terminal-code uses terminal-browser's app mode feature, which is like building electron apps inside the terminal"
That's a useful way to think about the layering. Electron lets developers ship a desktop GUI app using web technologies, rendered by an embedded Chromium instance instead of a system-native toolkit. App mode, per Pruzan's description, offers a comparable capability aimed at terminals — a framework for building full application-like interfaces that render inside a TUI (text user interface) rather than a browser window or a native desktop window. terminal-code is the first public showcase of what building on top of that framework looks like at the scale of "a real code editor."
Where it fits next to what you already use
| Tool | What it actually is | Needs a local GUI? | Runs over SSH natively? |
|---|---|---|---|
| VS Code (desktop) | Electron app, native window | Yes | No — needs Remote-SSH extension |
| VS Code Remote-SSH | Local GUI + remote server process | Yes | Via a configured tunnel |
| vim / Neovim | Terminal-mode text editor | No | Yes, natively |
| tmux | Terminal multiplexer, not an editor | No | Yes, natively |
| terminal-code | VS Code-compatible editor, TUI-rendered | No | Yes, natively |
The comparison to cmux and other terminal-first tools built for the current wave of AI coding agents is worth drawing out too: the last two years of developer tooling have pushed hard toward running agents and editors on a remote box — a VPS, a devbox, a disposable sandbox — and reaching it from wherever you happen to be. terminal-code fits that same trend line: it's one more piece of infrastructure that assumes your actual work happens somewhere you SSH into, not on the machine in front of you.
What people are asking
"Is this actually VS Code, or just VS Code-shaped?" Pruzan's own framing is "VS Code inside the terminal" and "VS Code compatible" — read that as compatibility with VS Code's interface conventions and workflow, not a claim that Microsoft's Electron build is somehow running headless inside a TUI. The thread doesn't specify extension-API compatibility depth; test against your actual extension list before treating it as a drop-in replacement.
"Does Cmd+J open a terminal inside VS Code running inside a terminal?" One reply on the thread asked exactly this, and it's a fair joke about the recursion on offer — a terminal-rendered editor that itself has an integrated terminal panel is, structurally, a terminal inside a terminal. Whether that panel is implemented and how it behaves isn't detailed in the launch thread.
"Why not just use Neovim?" Several replies leaned this direction, including a pointed link to a Neovim advocacy site. It's a legitimate question with a boring answer: Neovim requires learning modal editing and typically a personal config investment measured in years, not minutes. terminal-code's pitch is closer to "the VS Code muscle memory you already have, minus the GUI dependency" — a different trade-off, not a replacement claim for people who've already made the Neovim investment.
"Is someone going to put Microsoft Teams in the terminal next?" Also a real reply, from Matan Grinberg — read as commentary on how far the "put GUI app X inside a terminal" pattern could plausibly be pushed once app mode exists as reusable infrastructure, not a roadmap item.
Limitations and what's unverified
The launch thread is a demo and an announcement, not documentation. A few things worth checking before treating this as production-ready:
- Extension compatibility depth is unstated. "VS Code-compatible" could mean anywhere from "matches core keybindings and UI" to "runs the actual extension marketplace" — the thread doesn't specify, and that gap matters enormously for anyone with a deep extension list.
- Repo location wasn't posted directly in the thread. A reply confirms the project is open source and points to the repo for details, but doesn't include the URL in the visible text — check terminal-code.com directly rather than trusting a third-party link claiming to be the mirror.
- Performance over high-latency SSH is untested publicly. A TUI editor rendering complex UI over SSH has to move more than plain keystrokes; how it behaves on a slow or high-latency connection compared to a lightweight editor like vim isn't demonstrated in the launch material.
- "App mode" itself is lightly documented from the outside. Most of what's known about the underlying terminal-browser feature comes from Pruzan's own tweet-length description — treat it as the author's framing until independent write-ups or docs are available.
Related on explainx.ai
- cmux: a terminal built for AI coding agents — vertical tabs, SSH support, and notification design for terminal-first workflows
- Claude Code on VPS + SSH: the levelsio remote stack — a working example of "your real work lives on a box you SSH into"
- oh-my-pi: a minimal terminal coding agent — another terminal-native tool built for the current agent-coding wave
- What is a terminal? Mac and Windows basics — start here if "TUI" and "SSH" aren't yet familiar ground
- Claude Code VS Code extension setup guide — the GUI-side counterpart to this terminal-first approach
- screenpipe (YC S26) — another recent YC developer-tool launch with a fast-moving X thread
- What is an agent harness? — the broader pattern of moving developer tooling onto remote, disposable machines
Official: terminal-code.com · terminal-browser.com · Rob Pruzan's launch thread on X, August 19, 2026
View counts, feature claims, and the open-source status reflect the August 19, 2026 launch thread as of publication. terminal-code is an early, actively developing project — extension compatibility, SSH performance, and the repository location may change; verify current details at terminal-code.com before adopting it for real work.