There are already plenty of re-skinned GUIs built on the Pi Coding Agent, and JetBrains has open-sourced one too — ThinkRail. Coming from the long-time king of IDEs, you’d expect the engineering quality to be solid.

The project has been around for a few months, but I haven’t seen any official promotion and hardly anyone talks about it — barely 500 GitHub Stars. I used to wonder: since JetBrains already has its officially promoted new ADE tool, Air, why build a separate ThinkRail dedicated to Pi?

After trying it, the two turn out to target different niches: Air is an enterprise-grade heavy battleship, while ThinkRail is an ultra-lightweight tool for geeks. It’s built on Electrobun (Bun’s cross-platform desktop solution) and uses very little memory.

Its feature set is pretty much on par with other ADEs on the market:

🔹 Git worktree isolation: every workspace gets its own independent worktree branch and directory, ideal for parallel development with multiple agents.

🔹 Spec-driven development (SDD): this one is a bit distinctive — it makes the agent read and understand the architecture design before writing any code, keeping the output from going off the rails.

🔹 Basic IDE features: an integrated Monaco editor, real-time Git diff review, and a standalone terminal.

Available for direct download and hands-on experience on all platforms:

Official site: https://thinkrail.ai Project repo: https://github.com/JetBrains/thinkrail…

ThinkRail — the agentic IDE that gets better every time you use it

Source: https://thinkrail.ai/

JetBrains InnovationHubApache-2.0open source

The agentic IDE that gets better every time you use it.

Open a repo as a project. Cut isolatedgit-worktree workspaces. Pair with a real agent across Monaco tabs, terminals, and diffs — while your project’s intent lives in aspec graph the agent actually reads.

macOS

Browser UI via command lineInstall the local launcher; runthinkrailto open the browser UI.

curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash

Windows

Browser UI via command lineInstall the local launcher; runthinkrailto open the browser UI.

PowerShell

irm https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.ps1 | iex

Command Prompt (cmd)

powershell -c "irm https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.ps1 | iex"

WSL

curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash

Linux

Browser UI via command lineInstall the local launcher; runthinkrailto open the browser UI.

curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash

Why ThinkRail

Agents deserve worktrees, not your working tree.

Every workspace is a realgit worktree— its own branch, its own cwd. Run several agents in parallel; each one’s mess stays on its branch, andmainstays clean until you say otherwise.

Specs are the ground truth.

ThinkRail is built spec-first, and so are your projects: a connected graph of spec files lives beside the code, and the agent reads, searches, and maintains it with dedicated tools. Intent survives the session.

A thin host, a real engine.

Thepicoding agent (https://pi.dev/)runs in-process and owns models, skills, compaction, and cost. ThinkRail owns the workspace, the editor, and the wire — it never assembles prompts behind your back.

Projects → workspaces

A project is any local git repo. A workspace is agit worktreecut from it — created in one click, listed in the rail, disposable without ceremony.

# one repo, three parallel lines of thought
~/code/my-repo                        ← project
└─ ~/.thinkrail/worktrees/
   ├─ workspace-1   ⎇ feature/auth      agent A building
   ├─ workspace-2   ⎇ fix/flaky-test    agent B fixing
   └─ workspace-3   ⎇ spike/ideas       you, exploring

• Own branch + cwd per workspace — files, diffs, terminals, and chats all scope to it.
• Switch workspaces instantly; nothing reloads, nothing leaks across.
• Merge the good one, delete the rest. Your repo never noticed the chaos.

A real IDE around the agent

Watch the agent work — or work beside it — without leaving the page.

Monaco editor tabs

The VS Code editor engine: syntax everywhere, rendered markdown with a source toggle, file tabs per workspace.

Files tree

The active worktree at a glance — like the rail on the right of this very page.

Changes

A live git diff of the workspace branch, so you review the agent’s work as it lands.

Terminals

Real PTYs scoped to the worktree — run the tests yourself while the agent keeps typing.

Chats that stream like the engine thinks

This transcript is a realpisession, captured in ThinkRail while it worked on its own repo:

Quick tour: what is ThinkRail, and what are the three rings of its architecture? Keep it brief.

readgoal-and-requirements.md·architecture.md

ThinkRail is the agentic IDE built around thepicoding agent — a thin host that runspiin-process and bridges it to a rich UI, whilepiowns models, skills, compaction, cost, and session state.

Thethree rings:

1. Engine host(packages/server) —createServer()runs an HTTP+WS host plus anAgentSessionManager: one in-processpisession per tab.
2. The wire(packages/contracts) — the typed, versioned protocol between host and UI. Types only.
3. UI client(apps/web) — mobile-first React that ships independently and dials any host over the wire.

Done5s · 25.9k tok · $0.17

• Several sessions per workspace, streaming concurrently.
• Pick the model per session; tokens and cost tick live in the header.
• Steer a running turn or queue a follow-up — no waiting for the agent to finish.
• Interactive tools: the agent can ask structured questions back, right in the chat.

Specs are first-class

Every module carries aSPEC.mdwith frontmatter linking it into a graph — goal, architecture, modules, tasks. The bundledpi-spec-graphextension gives the agentspec_*tools to search, navigate, and maintain it, and the Specs tab renders the live graph of your worktree:

ThinkRail — product goal and scopemain spec

ThinkRail — top-level architecturearch

Engine host (server library)module

agent — in-process pi sessionssubmodule

---
id: module-server
type: module-design
status: active
parent: architecture
---

Plain markdown, plain frontmatter, versioned with the code — reading the specs is enough to understand an area and formulate the next task. The agent keeps them honest as it builds.

Install

Choose your platform and start working.

Linux: extract the archive, run./installer, and check thenative library requirements (https://github.com/JetBrains/thinkrail#install).

Browser UI via command lineInstall the local launcher, then runthinkrailto open the browser UI.

macOS, Linux, WSL

curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash

Windows PowerShell

irm https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.ps1 | iex

Command Prompt

powershell -c "irm https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.ps1 | iex"

Requiresgitand an authenticatedpiprovider. Seeall releases (https://github.com/JetBrains/thinkrail/releases)andadvanced CLI options (https://github.com/JetBrains/thinkrail#install).

Open source, spec-first

ThinkRail is aJetBrains (https://github.com/JetBrains)InnovationHub project, licensedApache-2.0 (https://github.com/JetBrains/thinkrail/blob/main/LICENSE). The repo is developed spec-first — the top-level specs are the product’s ground truth, and this website is itself a module with aSPEC.md.

GitHub (https://github.com/JetBrains/thinkrail)Issues (https://github.com/JetBrains/thinkrail/issues)Contributing (https://github.com/JetBrains/thinkrail/blob/main/CONTRIBUTING.md)Code of Conduct (https://github.com/JetBrains/thinkrail/blob/main/CODE_OF_CONDUCT.md)Releases (https://github.com/JetBrains/thinkrail/releases)