Skip to content
Back to search

thinkrail

Vibe code with pi in a lightweight, real IDE - The Vibe You Need

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/JetBrains/thinkrail with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/JetBrains/thinkrail'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/jetbrains--thinkrail/badge.svg)](/listings/jetbrains--thinkrail)

HTML

<a href="/listings/jetbrains--thinkrail"><img src="/api/listings/jetbrains--thinkrail/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

ThinkRail ships in two additive forms: a native desktop installer and the self-contained `thinkrail` CLI, which opens the same app in your browser. Both embed the same in-process agent host and are published with `SHA256SUMS` on the [releases page](https://github.com/JetBrains/thinkrail/releases).

JetBrains signs the Windows CLI and desktop setup executable. The macOS CLI is signed but not yet notarized. Signed/notarized desktop DMGs require the coordinated JetBrains service pipeline; older published DMGs and local Electrobun packages may still be unsigned and blocked by Gatekeeper. Linux artifacts are unsigned. Local installer smoke is not notarization verification.

Desktop

Download the matching `thinkrail-desktop-*` asset: a DMG for macOS Apple Silicon, a setup ZIP for Windows x64, or a setup tarball for Linux x64/ARM64. Extract the complete Windows ZIP before running its setup executable, keeping its adjacent payload; extract the Linux tarball and run `installer`. Electrobun 2.0.1 does not provide a macOS Intel desktop build. The coordinated macOS release pipeline uses Electrobun's expanded app archive for JetBrains signing and SRE DMG finalization; that intermediate archive is not a public download. The signing limitation above remains until that private pipeline update is deployed.

Linux desktop builds require Ubuntu 24.04 or another glibc 2.38+ distribution with GTK 3, WebKitGTK 4.1, Ayatana AppIndicator 3, and librsvg 2. On Ubuntu 24.04:

sudo apt install libgtk-3-0 libwebkit2gtk-4.1-0 libayatana-appindicator3-1 librsvg2-2

Eligible packaged stable and nightly desktop builds check for updates in the background. An update follows the classic consent-driven flow in **Settings → Updates**: **Download** → **Downloading** → **Preparing update** → **Install & Restart**. Closing Settings or quitting normally defers it; only **Install & Restart** applies the prepared release. The updater appears only when the package carries a valid HTTPS feed identity. Existing installations that predate that identity need one manual installation before in-app updates are available.

CLI / browser

The CLI installer downloads the right binary, verifies its SHA-256 checksum, and puts `thinkrail` on your PATH.

**macOS / Linux** (also Windows under Git Bash):

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

**Windows** — the same command works from cmd and PowerShell:

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

Nightly builds and pinned versions:

# macOS / Linux — a pinned version must belong to the selected channel
curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash -s -- --channel nightly
curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash -s -- --channel stable --version 0.1.2
curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash -s -- --channel nightly --version 0.2.0-nightly.10
# Windows — options are env vars (THINKRAIL_CHANNEL, THINKRAIL_VERSION, THINKRAIL_PREFIX, THINKRAIL_NO_MODIFY_PATH)
$env:THINKRAIL_CHANNEL='nightly'; irm https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.ps1 | iex   # PowerShell
set "THINKRAIL_CHANNEL=stable" && set "THINKRAIL_VERSION=0.1.2" && powershell -c "irm https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.ps1 | iex"   # cmd

Then run `thinkrail` (add a git repo path to open it as a project: `thinkrail ~/code/my-repo`). Installed stable/nightly CLI hosts periodically offer **Run Update** in **Settings → Updates**. That action runs the host machine's parameterless `thinkrail update` in the background; the current host stays alive, and a successful update asks you to restart it manually. This is also true when the UI is open in a browser on another machine.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 220 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # ThinkRail
  2. [![JetBrains incubator project](https://jb.gg/badges/incubator-plastic.svg)](https://confluence.jetbrains.com/display/ALL/JetBrains+on+GitHub)
  3. [![GitHub stars](https://img.shields.io/github/stars/JetBrains/thinkrail?style=social)](https://star-history.com/#JetBrains/thinkrail&Date)
  4. [![Discord](https://img.shields.io/badge/Discord-Join%20the%20chat-5865F2?logo=discord&logoColor=white)](https://thinkrail.ai/discord)
  5. ThinkRail is an agentic IDE that gets better every time you use it. With Spec-Driven Development support, it learns your project as you work, becoming more capable and helpful over time.
  6. We built a rich interface around the `pi` coding agent, isolated work into separate workspaces, and gave the agent durable project knowledge through the spec graph and reusable skills. We are now adding full extension support, so ThinkRail can create the tools it needs based on how you work.
  7. **Website:** [thinkrail.ai](https://thinkrail.ai/) · **Blog:** [thinkrail.ai/blog](https://thinkrail.ai/blog/) ·
  8. **Discord:** [thinkrail.ai/discord](https://thinkrail.ai/discord)
  9. ⭐ If you find ThinkRail useful, give it a star. It helps others discover it.
  10. <p align="center">
  11. <a href="https://www.star-history.com/jetbrains/thinkrail">
  12. <picture><source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/badge?repo=JetBrains/thinkrail&type=rank&theme=dark" /><source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/badge?repo=JetBrains/thinkrail&type=rank" /><img alt="Star History Rank" src="https://api.star-history.com/badge?repo=JetBrains/thinkrail&type=rank" /></picture> <picture><source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/badge?repo=JetBrains/thinkrail&type=trending&theme=dark" /><source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/badge?repo=JetBrains/thinkrail&type=trending" /><img alt="GitHub Trending Repository of the Day" src="https://api.star-history.com/badge?repo=JetBrains/thinkrail&type=trending" /></picture>
  13. </a>
  14. </p>
  15. <picture>
  16. <source media="(prefers-color-scheme: dark)" srcset=".github/readme-assets/workbench-dark.png">
  17. <img src=".github/readme-assets/workbench-light.png" alt="ThinkRail workbench: the Projects pane beside the left tool rail listing worktree workspaces and their Settled shelf, a finished pi conversation with its tool steps in the center, the resulting diff beside it, and the Specs tree above the Changes list on the right with their tools on the edge rail" width="900">
  18. </picture>
  19. *From the left: An isolated workspace, a work session with an AI agent in that workspace, the code change made by the agent, and the spec tree.*
  20. <a id="install"></a>
  21. ## Installation
  22. ThinkRail ships in two forms: a native desktop installer and the self-contained `thinkrail` CLI. You can install them from out [Landing page](https://thinkrail.ai/#install).
  23. For latest version, see the [Releases page](https://github.com/JetBrains/thinkrail/releases).
  24. ## What you get
  25. - **Isolated workspaces.** Open any git repo as a project and create `git worktree` workspaces from it, each with its own branch and working directory. Agents can then work in parallel without touching your original codebase; when they finish, merge the results you want to keep and delete the rest. Ask a chat to do something "in a side workspace" and the agent starts that workspace and its chat itself, then checks how its chats and pull requests are doing. You can also attach existing git worktrees or explicitly work in the project folder.
  26. * Finished and dormant workspaces are settled when their pull request merges or closes, or after a quiet week, and return the moment you work in them again.
  27. * The topbar shows where the active branch stands against `origin`, and the state of its pull request. From there you can publish, push, or open a new PR described from the plan, the commits, your PR template, or an agent-written draft.
  28. * Once a GitHub PR is open, ThinkRail shows its CI checks and review decision, and lets you mark it ready, merge it, reopen it, or delete the remote branch.
  29. - **An IDE around the agent.** ThinkRail comes with Monaco editor tabs, a file tree integrated with git to show code changes as they happen, terminals, and document support. Rendered Markdown previews have a heading outline that follows the section you're reading; hide it or move it to either side. The pane you're typing in carries an accent line, a frame briefly lights the pane the keyboard takes you to, and VS Code-style keys move you around: `F6` steps between panes, `⌘L` jumps to the chat input, `⌘0` to Projects, `⌘1`–`⌘9` to an editor group, and `` ⌃` `` to the terminal; `⌘\` splits the editor and `⌃⌘←` / `⌃⌘→` move a tab between groups. In a chat, `⌘↑` steps from the input into the conversation, where arrows or `j`/`k` walk messages, tool calls and thinking blocks, `→`/`←` unfold them, `C` copies and `O` opens the file a tool touched. When the agent asks a question, `F6` (or `⇧Tab` from the input) lands on its options, `D` marks it for discussion, `I` steps into an HTML mockup and `⌘↵` answers. Review comments need no mouse either: Tab onto a diff and a line cursor moves with arrows or `j`/`k` (`h`/`l` switch sides, Shift extends), Enter comments, and rendered Markdown blocks, image regions and the swipe divider take the same keys. Press `F` outside a text field (or `⌘;` anywhere) for hint mode: every button, tab, row and field gets a short label, and typing it presses that element (Shift on the last letter only focuses it); Esc leaves a text field, so `F` works from anywhere, and repeated Esc climbs back to the main area; a waiting agent question takes focus unless you're typing. Switch hint mode off in Settings → Extensions & skills. In the sidebar trees `S` searches the visible rows and `h`/`j`/`k`/`l` move like the arrows. `⌘?` opens a filterable, near-fullscreen cheatsheet of every shortcut in columns, with the pane you're in highlighted (a Mac browser keeps `⌘?` for its Help menu, so use the keyboard icon at the bottom of the left tool rail or the palette there); tooltips show a button's shortcut. Settings works from the keyboard too: arrows move through the sections and the settings inside them, Delete resets a setting to its default, and `S` or `/` searches every individual setting. Rebind shortcuts in Settings → Keyboard, a tree of shortcuts by area that you can filter by name or by keys — the global chords and the keys a tree, tab strip, chat, review or palette takes while focused (letters like `S`, `C` or `j`/`k`, and chords like `⌘↵`); arrows, Enter, Esc, Tab, Space, Home/End and PgUp/PgDn stay fixed. Bindings are saved on the host, so every window and browser follows, and export or import as a JSON file; extensions bring their own shortcuts, which you can rebind too.
  30. - **Powerful chat features.** You can open several concurrent work sessions per workspace, each with its own model. Send a prompt, or queue it as a follow-up, delegate to subagents, and work together on a shared plan: the agent updates it, and you review and edit.
  31. - **Find anything from one box.** `⌘K` (or a double tap of Shift) opens a palette that finds chats and the messages inside them, workspaces and projects, files in the current workspace, specs, and plans, with a preview pane. It also runs the app's commands, including the active tab's layout commands (split, move to another group or pane, new or remove group, close), and opens Settings sections or an individual setting, and with nothing typed it lists the chats waiting for you. Type a task and press `⌘↵` to open Create workspace with it as the prompt. Press `⌘⇧F` to find text inside the workspace's files as you type: matches are grouped by file, with match-case and whole-word toggles and a code preview, and `↵` opens the file at that line.
  32. - **Chats without a project.** Ask, plan, or draft without a repository. Each chat gets its own scratch folder under **Chats** for its files, terminal, and plan, with no branch, review, or pull request. Start one from the Welcome screen, the Create dialog, the palette, or the Chats section; deleting a chat moves its whole folder to the Trash. When a chat turns into work, **Continue in workspace** has the agent write a handoff summary and starts a new workspace chat with it.
  33. - **Artifacts that stay.** Everything the agent makes for you, such as design notes, mockups, diagrams, screenshots, and reports, lands in the workspace's git-ignored `.thinkrail/context/` folder. The Artifacts tool shows it newest first, as a folder tree, or — in its Smart view — as what the agent actually made for you: the mockups and reports it showed or linked, and the one you picked, with the scripts and scratch renders behind each folded away. Each round in the chat lists the artifacts it made. It also names the chat that wrote each file and the ignored files its runs left behind. A dot on its rail icon tells you something new arrived. Nothing there disappears on its own: if the agent deletes a file, it stays listed, and opening it brings it back. The agent is steered away from leaving new files in `/tmp`. Mention an artifact in the chat, reveal it in Files, rename it, or cut and paste it into your project.
  34. - **Always up-to-date specifications.** A connected graph of `SPEC.md` files lives beside the code; the agent reads, searches, and maintains it through dedicated `spec_*` tools, so project intent persists across sessions. The read-only Specs tool renders the graph as a tree in its own view. Type `#` and a question in the palette to find the spec sections that answer it, in any word order and word form, ranked the way the agent's own `spec_search` ranks them. Press `↵` to open the spec at that heading, or `⌥↵` to ask the agent in a new chat when the specs phrase it differently.
  35. - **Skills.** ThinkRail loads your `pi` skills and any already in your project. It can also import skills from Claude, Codex, and other coding agents: switch them on in Settings → Extensions & skills, or per project in the Skills dialog, which also shows the size of your skill catalog. A large library is listed within a small prompt budget, and the agent finds the rest with a skill search.
  36. - **Agent tools beyond the shell.** Thanks to the ThinkRail GUI, your AI agent can ask you structured multiple-choice questions in the chat instead of guessing, draw Mermaid diagrams, and show comparisons and file previews. When the agent proposes a UI change, it shows a before/after mockup you can comment on like a diff; in a browser, the agent's mockups are clickable prototypes whose scripts run in a sandbox with no network access. Any HTML file, from a mockup to a generated report, opens in your browser from its tab, its preview or the Files menu. When a question's options come with mockups, open them full screen to flip through them, put two side by side (two HTML mockups scroll together and also compare with a swipe or an overlay), or see them all at once, and pick one right there. When it is done and waiting for you, it can suggest what you might send next as one-click chips above the composer: `⌥1`–`⌥9` sends one, and Shift+click or `⇧⌥1`–`⇧⌥9` puts it in the input to edit first (both rebindable in Settings → Keyboard).
  37. - Settings → Extensions & skills lists the ThinkRail extensions the agent may use. It can also install any `pi` package by source (npm, git or a local folder), for you or for a repository, showing what each one adds and letting you switch individual packages, their extensions and skills, and `pi`'s built-ins on or off.
  38. - The tools behind the questions, diagrams, previews, and next-message suggestions are also published as plain `pi` packages: `pi install npm:@thinkrail/pi-ask-user-question` for the questions ([`@thinkrail/pi-ask-user-question`](https://www.npmjs.com/package/@thinkrail/pi-ask-user-question)), `pi install npm:@thinkrail/pi-visualize` for the diagrams and previews ([`@thinkrail/pi-visualize`](https://www.npmjs.com/package/@thinkrail/pi-visualize)), and `pi install npm:@thinkrail/pi-next-steps` for the next-message suggestions ([`@thinkrail/pi-next-steps`](https://www.npmjs.com/package/@thinkrail/pi-next-steps), sent with Alt+1…9 in the terminal), so a vanilla `pi` in the terminal gets the same tools.
  39. - **MCP servers.** Connect the MCP servers in your `pi` `mcp.json`, or configure them in Settings → MCP servers. Your own servers, which apply to every project, can be added, switched on or off and removed there even with no project open. ThinkRail asks in the chat before calls that the server does not mark read-only, or always allows the tools you trust in a project. Servers a repository defines stay off until you approve them. ThinkRail signs you in to OAuth servers from Settings and shows each chat's servers next to its background commands and subagents, with each server's state and the chat's calls to it.
  40. - **Your providers, your credentials.** Sign in with [JetBrains AI](https://www.jetbrains.com/ai/) or connect any provider through `pi`'s own auth. ThinkRail has no accounts of its own.
  41. - **Your `pi` setup.** ThinkRail reads your existing `pi` configuration (`~/.pi/agent`). To use another one (for example, a personal `~/.pi/agent-personal`), or to pass extra environment variables to the agent, terminals and MCP servers, set them in Settings → Environment. The configuration becomes active on the next start. Settings → Models also holds `pi`'s prompt-cache warming (off, only while a run is active, or also between runs); ThinkRail keeps it to active runs unless you choose otherwise, so idle chats don't spend in the background.
  42. - **Your own model servers.** Go to Settings → Providers → Custom servers and connect a company LLM gateway or a model running on your own machine. Any OpenAI-compatible server fits: LiteLLM, sglang, vLLM, Ollama, LM Studio, or llama.cpp.
  43. - The **Find models** button lists the models available on the server, together with their capabilities. The server is saved to `pi`'s `models.json`. The models models appear in the chat model picker, and in the `pi` CLI alike.
  44. - **Desktop app or browser.** A native desktop app, or the `thinkrail` CLI that opens the same app in your browser. Both embed the same engine host. App state lives under `~/.thinkrail`.
  45. - **Your language.** ThinkRail uses your system language or a language you pick in Settings → Language: English, Japanese, Polish, Russian, Simplified Chinese, Spanish, or Traditional Chinese (Taiwan). You can add a language ThinkRail doesn't ship yet by putting a translated locale file, for example `de.json`, in `~/.thinkrail/locales`. (Tell your AI agent to do it for you!)
  46. - **Your themes.** In Settings → Appearance, you can choose from dark, light, minimal, and high-contrast themes. You can also make your own theme by copying a bundled `*.theme.json`, changing its id and colors, and saving it to `~/.thinkrail/themes`. (Again, tell your AI agent to do it for you!)
  47. - **Your fonts.** In Settings → Text & fonts, you can pick the interface and code fonts and set separate line widths for chat and for code. You can choose from the bundled Geist and JetBrains Mono, any font installed on your computer, and font files kept in `~/.thinkrail/fonts`, with fallback fonts for icon glyphs, a code size, ligatures, and a text-weight slider.
  48. <picture>
  49. <source media="(prefers-color-scheme: dark)" srcset=".github/readme-assets/specs-dark.png">
  50. <img src=".github/readme-assets/specs-light.png" alt="The Specs tool, opened from the right edge rail, listing the project's spec tree while the product goal spec is rendered in the editor" width="900">
  51. </picture>
  52. *The project's spec graph as a tree (on the right), with the spec itself rendered alongside in the center.*
  53. ## Installation details
  54. ### Desktop
  55. Download the `thinkrail-desktop-*` asset for your platform:
  56. - **macOS 14+ (Apple Silicon or Intel)**: open the DMG for your architecture: `thinkrail-desktop-darwin-arm64.dmg` or `thinkrail-desktop-darwin-x64.dmg`.
  57. - **Windows x64**: extract the complete setup ZIP, then run the executable.
  58. - **Linux x64 / ARM64**: extract the setup tarball and run `installer`. Desktop builds need glibc 2.38+ with GTK 3, WebKitGTK 4.1, Ayatana AppIndicator 3, librsvg 2, and Ubuntu 24.04 or newer, plus `libnotify-bin` for desktop notifications:
  59. ```bash
  60. sudo apt install libgtk-3-0 libwebkit2gtk-4.1-0 libayatana-appindicator3-1 librsvg2-2 libnotify-bin
  61. ```
  62. There are two update channels: stable and nightly. If the ThinkRail desktop app, you can check them in **Settings → Updates**: **Download** → **Preparing update** → **Install & Restart**.
  63. ### Command line
  64. The installer downloads the right binary, verifies its SHA-256 checksum, and puts `thinkrail` on your PATH.
  65. **macOS / Linux** (also Windows under Git Bash):
  66. ```bash
  67. curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash
  68. ```
  69. **Windows**: the same command works from cmd and PowerShell:
  70. ```powershell
  71. powershell -c "irm https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.ps1 | iex"
  72. ```
  73. Then run `thinkrail`, optionally with a git repo to open as a project:
  74. ```bash
  75. thinkrail ~/code/my-repo
  76. ```
  77. * `thinkrail` needs `git` on your PATH and a model provider. You can sign in with JetBrains AI from the app or use your own provider credentials. The first launch walks you through connecting a provider and picking a project; **Start a new project** creates an empty git repository (under `~/thinkrail` by default), so you don't need one ready.
  78. * **Add project → Clone repository…** clones a Git URL into a new folder on the computer running ThinkRail and opens it as a project. Choose the parent folder and folder name, optionally limit the history depth, or cancel an in-progress clone.
  79. * GitHub and other Git hosts work with the Git credentials and SSH keys already on your machine.
  80. * `thinkrail --help` lists the flags, and `thinkrail --version` prints the build.
  81. <details>
  82. <summary><strong>Nightly builds, pinned versions, updates, and uninstall</strong></summary>
  83. The installer takes `--channel stable|nightly` and `--version`; a pinned version must belong to the
  84. selected channel:
  85. ```bash
  86. curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash -s -- --channel nightly
  87. curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash -s -- --channel stable --version 0.3.1
  88. curl -fsSL https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.sh | bash -s -- --channel nightly --version 0.4.0-nightly.2
  89. ```
  90. On Windows the options are environment variables (`THINKRAIL_CHANNEL`, `THINKRAIL_VERSION`, `THINKRAIL_PREFIX`, `THINKRAIL_NO_MODIFY_PATH`):
  91. ```powershell
  92. $env:THINKRAIL_CHANNEL='nightly'; irm https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.ps1 | iex # PowerShell
  93. set "THINKRAIL_CHANNEL=stable" && set "THINKRAIL_VERSION=0.3.1" && powershell -c "irm https://raw.githubusercontent.com/JetBrains/thinkrail/main/install.ps1 | iex" # cmd
  94. ```
  95. If you keep ThinkRail running, it periodically checks for updates and, when it finds one, shows an "Update available" button in the GUI.
  96. `thinkrail uninstall` removes the executable, the PATH entry the installer added, and the install metadata; it then asks whether to delete your `~/.thinkrail` app state (kept by default; `--remove-data` deletes it, and `-y` skips the questions).
  97. If you prefer a manual install, download a binary and the `SHA256SUMS` from the releases page, and verify the checksum. For self-update to work, rename it to `thinkrail` (`thinkrail.exe` on Windows) and place it at `<prefix>/bin/thinkrail[.exe]`; a binary kept under its release filename or elsewhere must be replaced manually or reinstalled with the script.
  98. </details>
  99. ### Platform notes
  100. | Platform | Desktop | CLI |
  101. | --- | --- | --- |
  102. | macOS Apple Silicon / Intel | DMG | signed binary |
  103. | Windows x64 | signed setup executable and app binaries | signed `.exe` |
  104. | Linux x64 / ARM64 | setup tarball, unsigned | unsigned |
  105. JetBrains signs the Windows CLI, the desktop setup executable, and every executable and DLL the desktop app installs. The macOS CLI is signed but not yet notarized. Signed and notarized desktop DMGs must come from the coordinated JetBrains service pipeline; older published DMGs and locally built packages may still be unsigned and blocked by Gatekeeper. Linux artifacts are unsigned.
  106. ## Analytics & privacy
  107. ThinkRail apps collect basic usage events: launches, chat creation, message sends, and provider connections. The data is tied to a random installation ID. Usage analytics never include prompts, code, files, credentials, or account identity. Error reports are always sent as well, tied to the same installation ID, so we can fix crashes: they include the error type and code, and where in ThinkRail's own code it happened. They never include error messages, file paths, names, URLs, or anything from your projects or extensions.
  108. Additional product usage is shared only while **Share additional usage data** is on; the switch is offered during first-run setup (or right after you skip it) and lives in **Settings → Privacy**. From the command line, `thinkrail --no-analytics` (or `THINKRAIL_NO_ANALYTICS=1`) turns additional sharing off for that launch. With additional sharing on, a packaged build may open the ThinkRail blog in your browser once to link your installation to the website visit that brought you here - only where you accepted marketing cookies on the website or no consent is required, and that link expires after 30 days.
  109. Feedback surveys are separate from usage analytics. ThinkRail may invite you to a short survey, and you can also open it from **Settings → Share feedback**. Your answers, including anything you type, are sent to the ThinkRail team only when you press **Send**, and tied to the same random installation ID, not to your name or account. Please don't include secrets, code, or personal data. To have your answers deleted, email [info@thinkrail.ai](mailto:info@thinkrail.ai).
  110. The ThinkRail apps and the ThinkRail website ([thinkrail.ai](https://thinkrail.ai/)) use PostHog Inc. services for analytics. The website also uses PostHog Surveys to collect feedback after a desktop download and, only if you choose to provide it, your email address, which is used to ask for further feedback and to send product updates. PostHog's privacy policy is at [posthog.com/privacy](https://posthog.com/privacy).
  111. ## Under the hood
  112. ThinkRail is a thin host that runs `pi` in-process and bridges it to a web UI. `pi` owns models, skills, compaction, cost, and session state. ThinkRail owns workspace management, the GUI, and the contracts between the engine and the GUI.
  113. * **Engine** (`packages/server` + `packages/shared`): a `Bun.serve` HTTP+WS host with one in-process `pi` session per chat, launched by `apps/cli` or `apps/desktop`.
  114. * **Contracts** (`packages/contracts`): the typed, versioned protocol between the engine and the GUI.
  115. * **GUI** (`apps/web`): React 19 + Zustand + Tailwind v4, shipped independently; it communicates with the engine through the contracts.
  116. `goal-and-requirements.md` and `architecture.md` are the product and design specs. ThinkRail is developed spec-first: a `SPEC.md` sits beside every module, and when a change made by an AI agent moves a boundary or a contract, the spec is updated in the same change.
  117. ## Developing ThinkRail
  118. You need **Bun** 1.4.4 (the pinned package manager and runtime), **Node.js** ≥ 22.23.4 (the in-process `pi`
  119. engine needs ≥ 22.19; the website build and typecheck need ≥ 22.23.4 for Astro 7.4), and an AI provider for
  120. agent work.
  121. ```bash
  122. git clone https://github.com/JetBrains/thinkrail.git
  123. cd thinkrail
  124. bun install
  125. bun run dev # host + web client together; Ctrl+C stops both
  126. ```
  127. ```bash
  128. bun run --filter @thinkrail/cli dev # browser launcher
  129. bun run build:binary # standalone CLI artifact
  130. bun run desktop:dev # package and open the Electrobun app
  131. bun run desktop:build # package without opening it
  132. ```
  133. [`CONTRIBUTING.md`](CONTRIBUTING.md) covers the checks, the end-to-end suites, desktop packaging, and the repository layout.
  134. ## Contributing
  135. Contributions are welcome. See [`CONTRIBUTING.md`](CONTRIBUTING.md). This project and community are governed by the [Code of Conduct](CODE_OF_CONDUCT.md).
  136. ## Community
  137. Join us on [Discord](https://thinkrail.ai/discord) to ask questions, share what you're building, and talk to the team. Bugs and feature requests go to [GitHub issues](https://github.com/JetBrains/thinkrail/issues).
  138. ## License
  139. Licensed under the [Apache License 2.0](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.