        
        A terminal IDE with a coding agent built in
      

turboIDE

A small, fast, keyboard-driven IDE that runs entirely in your terminal — with a coding agent built in. Claude Code, Codex or opencode runs in a window beside your code and can drive the editor itself: open the file it just changed, jump to the line, run a command. Everything an agentic loop needs, in one text-mode app you can SSH into.

↓ Download View on GitHub ↗

          FileEditViewCodeGitRunLuaAgentWindowsSettingsHelp
          ⌥ master
        

              [▪]
              1: editwindow.cc
              [▶]-[↑]
            
1#define Uses_TScrollBar
2#define Uses_TFrame
3#define Uses_TProgram
4#define Uses_MsgBox
5
6#include <tvision/tv.h>
7#include <turbo/scintilla.h>
8#include <turbo/styles.h>
9#include "editwindow.h"
10#include "commandpalette.h"
11
12using std::ios;
13
14EditorFrame::EditorFrame(const TRect &bounds) noexcept :
15    turbo::BasicEditorFrame(bounds)
16{
17}
Files — master
Git: All ▾
app.cc
buildconfig.cc
cmds.h
colordialog.cc
commandpalette.cc
commandrunner.cc
doctree.cc
editor.cc
editwindow.cc
frecency.cc
gitpane.cc
lua.cc

          1:1
          Alt-0 Agent
          Ctrl-O Open
          Ctrl-S Save
          F6 Next
          F12 Menu
          00:00:00
        

// 01

Code with an agent, not next to one

Run a coding agent in a bare terminal and all you get is a transcript. It tells you it rewrote src/app.cc:214, and you have nowhere to look. turboIDE makes the agent part of the IDE: it gets a window, it gets your editor, and the loop closes.

▪ Agent window · Alt-0 [↑]

Toggle a full agent window over your code with one key. It runs in the project directory as a real PTY — mouse, scrolling and full-screen TUIs all work — and Restart Agent gives you a clean context without leaving the IDE. Choose Claude Code, Codex or opencode per project, with a global default.

▪ The agent drives your editor [↑]

turboIDE speaks MCP. The agent can open a file in your editor, insert at your cursor and run IDE commands — so instead of describing an edit, it lands it in front of you. With Claude Code it's wired up the moment you open the project: no config, no trust prompt.

▪ Your Lua commands become agent tools [↑]

Every command you register from Lua is exposed to the agent as a typed MCP tool, automatically. Teach the IDE a trick — a deploy step, a codegen pass, a project-specific refactor — and the agent can use it too.

▪ Skills, in the file tree [↑]

.claude/skills appears as Project and Global Skills homes in the tree, right next to your code. Open one to edit its SKILL.md, or scaffold a new one from the tree. The context you give the agent lives with the project, and is versioned with it.

▪ Ctrl+click any path [↑]

Agents print paths. Ctrl+click src/app.cc:214:9 in any terminal window and turboIDE opens it, on the line, in an editor.

▪ Keep the loop running [↑]

Long-lived tools — a dev server, a watcher, a test runner — are checkable items on the Run menu, each streaming into its own output tab. Start them once and leave them running while you and the agent work.

Made for the machine at the other end of an SSH connection

On a remote box you have a terminal and nothing else. The usual answers are heavy: an editor server to install and keep alive, ports to forward, a GUI on your laptop that dies with the connection.

turboIDE is one binary and one PTY. SSH in, run turboIDE ., and you have the tree, Git, your editor, build output and the agent in a single window. Leave it inside tmux and it's still there — agent mid-task — when you reconnect.

$ ssh build-box
$ tmux new -s work
$ turboIDE .
  tree · git · editor · output
  · agent (Alt-0)

// 02

What it does

On top of Turbo's editor core, this fork adds the building blocks of an IDE — everything the agent needs to hand back to you, and everything you need when you take over. All inside the terminal.

▪ Project file tree [↑]

A recursive view of your working directory. Open files straight from the tree, create files and folders, and watch it stay in sync as things change on disk.

▪ Light Git integration [↑]

File status in the tree, and the everyday loop without leaving the editor: stage, commit, fetch/pull/push, switch branches, stash, and a conflict toolbar for merges.

▪ Integrated terminal [↑]

A real terminal window inside the app — ConPTY on Windows, a PTY on Unix and macOS — for running commands right next to your code.

▪ Run & tool processes [↑]

Configure build, run and test commands per project, and watch them stream into a resizable output pane. Long-running tools get their own checkable Run-menu item and their own output tab.

▪ Language Server (LSP) [↑]

Diagnostics, completion and hover — configurable per language, so your editor understands the code you're writing.

▪ Lua scripting [↑]

An embedded Lua 5.4 interpreter to configure and extend the editor. Run scripts from the Lua menu and hook into save, commit, open and close events.

▪ Command palette [↑]

Press Ctrl+B to run any command — including every Lua script you've registered yourself.

▪ Auto-save & Scintilla 5.5 [↑]

Documents save automatically when an editor loses focus — on the latest Scintilla release, with a wider set of language lexers.

// 03

Intuitive by design

Turbo behaves the way you'd expect — so you probably already know how to use it. A few of the keys that get you moving:

          [▪]keybindings.txt[↑]
        

Alt+0 Toggle agent
Ctrl+Click Open file path
Ctrl+B Command palette
Ctrl+O Open file
Ctrl+S Save
Ctrl+N New document
Ctrl+F Find
Ctrl+R Replace
Ctrl+G Go to line
Ctrl+E Toggle comment
Ctrl+W Close document
F6 Next document
Ctrl+Z Undo / redo
Ctrl+Q Exit

// 04

Get Turbo

Prebuilt binaries are attached to every release. Grab the one for your platform, or build from source on Linux.

Windows · x64

turbo-x64.exe

64-bit Windows (Intel / AMD).

↓ Download ↗

Windows · x86

turbo-x86.exe

32-bit Windows.

↓ Download ↗

macOS · Apple Silicon

turbo-macos-arm64

macOS on Apple Silicon.

↓ Download ↗

Linux

Build from source

CMake + a C++17 compiler and libncursesw.

Instructions ↗

$ git clone --recursive https://github.com/aestubbs/turboIDE.git

$ cmake . -DCMAKE_BUILD_TYPE=Release && cmake --build .

Clone --recursive — the build depends on the submodules in deps/ (Turbo Vision, nlohmann/json, Lua). For the newest per-commit builds, download the artifacts from a successful Actions run.

// 05

Standing on great work

Turbo is a fork of magiblot/turbo — an experimental terminal text editor built on Neil Hodgson's Scintilla editing component and the Turbo Vision application framework.

The IDE layer on top of that foundation was built by AI — every line of code here has been written by Claude Opus 4.8, working in Claude Code. The upstream editor, Turbo Vision and Scintilla are decades of careful human engineering; the tooling around it was designed, written and iterated in close collaboration with the model.

The agent integration is what that experience asked for. The model was writing this code in a terminal, beside a project it couldn't open — so the agent got a window, and then it got the editor. turboIDE is the answer to that.

This fork keeps the upstream editor's behaviour and grows it into a lightweight, cross-platform IDE — the project tree, Git, terminal, build commands, LSP, Lua scripting and a first-class coding agent, layered on top of a foundation that has been refined for decades.

Full credit to magiblot for the editor and the Turbo Vision framework, and to Neil Hodgson for Scintilla and Lexilla.

▪ magiblot/turboThe editor this project forks ↗ ▪ Turbo VisionThe application framework · magiblot/tvision ↗ ▪ ScintillaThe editing component · Neil Hodgson ↗