Black IDE
Download
Loading release…

The Expert Tool for Sovereign Engineering

A telemetry-free build of VS Code with an autonomous coding agent wired into the editor — not bolted on as an extension. It researches your codebase, writes a plan, and waits for your approval before it touches a single line.

Download Black IDE Read the Docs
0
Telemetry endpoints
0
Capabilities
0
Native agent tools
0
LLM providers
Capabilities

An agent with guardrails, not a chatbot in a sidebar

Every destructive capability is gated behind a plan you approve, a diff you can revert, and an index that never leaves your machine.

01 · two-phase execution

Plan → Approve → Run.
Total authority.

Any non-trivial prompt is forced into a read-only planning loop. The agent researches the codebase, then writes an implementation_plan and task_list artifact — it physically cannot mutate source files in this phase. Execution only begins when you approve.

Pending approvals persist to VS Code's Memento store, keyed per thread — a crash or reload restores the review card exactly where you left it.

plan
approve
run
implementation_plan.md task_list.md walkthrough.md
02 · reverse-hunk undo

Revert a function, not a file

Checkpoints store the structural diff, never a full copy. Restoring applies the reverse hunk to disk, so you can roll back one edit while keeping every other change the agent made in the same response.

− verify_token(&raw)?;
+ verify_jwt(&raw, &keyset)?;
+ refresh_if_expiring(&mut s);
hunk 2/3 restore
03 · hybrid retrieval

Retrieval that respects syntax

Chunks are whole functions and classes with their doc comments, never a fixed character window. Embeddings and BM25 are fused by Reciprocal Rank Fusion, then reranked — recall@10 of 97.2% on a measured corpus. The index is a local file; nothing is uploaded.

where is auth refreshed
impl TokenStore::refresh
fn verify_jwt
struct SessionGuard
04 · inline chat

Refactor at the cursor

Press Cmd+I on a selection. The rewrite streams straight into the buffer with a green decoration tracking the line offset, then accept, retry, or revert to the original snapshot.

⌘I add retry logic
async fn fetch(&self) {
+ backoff::retry(policy, ||
AcceptEdit againReject
05 · specialized roles

Nine roles, or write your own

Each mode carries its own system prompt, tool allowlist and iteration budget — enforced where tools execute, not merely advertised. Drop a Markdown file with YAML frontmatter into .blackide/modes/ and the loader hot-reloads it, with errors surfacing as inline diagnostics.

06 · zero telemetry

Stripped, not toggled off

Telemetry endpoints are removed from the VSCodium build at compile time — there is no setting to flip back on. Extensions resolve through the community Open VSX registry.

usage.ping crash.dmp exp.flags metrics.v2
0 outbound calls at rest
07 · seamless tool discovery

Your infrastructure, registered as tools

The built-in Model Context Protocol client scans .blackide/mcp.json at startup, spawns each server over stdio, and completes the JSON-RPC handshake. Discovered schemas are converted into tool definitions and registered with the agent's registry — callable by the model the moment the handshake lands.

No adapter code — whatever a server advertises through tools/list becomes callable. Today the transport is stdio and the surface is Agent mode; remote transports are named as not shipped rather than implied.

client
postgres6 tools
sentry4 tools
k8s-ctl9 tools
08 · parallel isolation

Subagents in real Git worktrees

Subagents and task agents get their own worktree under a hash of your workspace path, so the live tree is never a scratchpad. Git operations serialize behind a mutex to avoid index.lock conflicts, and reintegration carries only the delta the run produced — your uncommitted edits are never in its path.

On conflict the worktree is preserved, not discarded: the error names the branch, path, baseline SHA and the exact command to drop it yourself.

frontend backend devops merge
09 · responsiveness

The agent can't freeze your editor

The React webview and the Node.js extension host run on decoupled event loops joined only by an IPC event bus. A tool call chewing through a large repository emits progress events — it never blocks typing, scrolling, or inline chat.

0msUI loop
IPC
3.2sagent loop
10 · multi-agent sdlc pipeline

“Build a CRM” is not
one agent turn

A substantial request runs as a seven-phase pipeline instead of a single loop. A Sr Architect drafts the high-level design, a Sr Engineer turns it into a low-level one, a Planner emits features_plan.md — and then everything stops at an approval gate. Reject it and the run unwinds silently, having built nothing.

Past the gate, phases are selected from a dependency graph rather than a hardcoded sequence: a plan with no backend tasks never wakes the backend executor. Each phase can route to its own model, so cheap scaffolding and expensive execution are not billed at the same rate.

Up to four pipelines run concurrently, each with its own abort controller and run-local checkpoint manager. No competing IDE ships phased SDLC orchestration at all.

analysis
Sr Architect · HLD
Sr Engineer · LLD
Planner
⏸ approval
gate
executors
Design
Backend
Frontend
Testing
reconcile → overview.md
11 · project-aware skills

It reads the repo you actually have

A manifest-based profiler identifies your stack — 100% accurate across a 21-fixture corpus — and resolves the right guidance from 47 bundled skill packs by stack, role and trigger. Each pack carries a golden eval task, so a pack cannot silently rot.

detected django pytest postgres
django/orm-idiomsrank 1
testing/pytestrank 2
cross/migrationsrank 3
rails/* · not injected — wrong stack
12 · model routing & failover

Sixteen providers, seven roles

Chat, plan, edit, apply, autocomplete, embed and rerank each resolve to their own model in one router, so a cheap model can materialise an edit while a strong one decides it. When a provider breaks, the circuit opens and the turn fails over — context survives, and it never switches after output has started streaming.

plananthropic
applygroq
chatopenai breaker open
→ failover · ollama
13 · the safety spine

“Phones home to nobody” is a test, not a promise

Every outbound destination the product can reach is declared in an egress register with a reason and a trigger, and a source walk fails the build when an undeclared network call appears. Turning the analytics sink off removes its egress by construction — there is no endpoint in the source to disable.

Underneath sit the parts that make an autonomous agent survivable: a command deny list a user cannot override, secrets in the OS keychain rather than settings.json, one central workspace-boundary guard covering traversal, symlinks and .git, and an append-only audit trail that is redacted on the way in.

Auto-approve is ignored in unattended runs — a pipeline cannot inherit a permission you granted for interactive work. An org policy can only tighten capability, never widen it.

destinationwhy
api.anthropic.comyour configured model
api.github.comrelease check · on request
open-vsx.orgextension gallery
vendor telemetrynot present in source
0 undeclared destinations · enforced by a source walk
The full inventory

Every capability, graded honestly

Marketing pages list what a product does well. This one lists everything it does, with two labels per row — how far along it is, and how good it actually is next to what a competent competitor ships. Nothing below is rounded up, and the twelve things we have deliberately chosen not to build are listed too.

71
Production

Shipped, tested, on by default — or one obvious toggle away — and relied on daily.

14
Intermediate

Shipped and useful, with a real limitation that we name instead of hiding.

4
Experiment

Built but off by default, or built as a core whose wiring is not finished.

12
Planned

Specified in the roadmap and not built — including five we are choosing to leave unbuilt.

quality leads the field at bar works, with a limit
Nothing matches that Try a capability name, or a term like worktree, egress or memory.
Where we lead

SDLC pipeline orchestration, the command-policy and safety posture, reverse-hunk checkpoints, code intelligence reaching the fork's own language servers where extension-only competitors cannot, project-aware skills — and, uniquely, an enumerable and test-enforced egress register.

Where we are behind

Sandboxed execution tiers, MCP transport parity beyond stdio, review automation, and the daily-driver autocomplete model: next-edit prediction is at capability bar, but a competitor trains a model for that job where we route a role to a general one.

Distribution

A full fork, built and checksummed in the open

Black IDE ships as a standalone Electron application, not an extension you bolt onto someone else's binary.

01

Compile

TypeScript and webviews bundled through esbuild.

02

Package

Electron binaries and native modules assembled per platform.

03

Frameworks

Isolated GPU and renderer helper apps bundled for stability.

04

Checksum

SHA-1 and SHA-256 generated for every published asset.

05

Release

Uploaded to GitHub Releases and served from this page.

Download
Checking release channel…
macOS
Detected
Download Installer (.dmg)
Apple Silicon · —
Portable ZIP CLI Binary
Windows
Detected
Download User Setup (.exe)
x64 User Setup · —
System Setup Portable ZIP
Linux
Detected
.deb .rpm
Debian / RedHat · —
AppImage
Show all packages