The code editor you can take apart. A familiar VS Code experience on top of a Rust core that ships as libraries — swap the editor, replace the terminal, or embed the whole session in your own app.

Ecosystem

Built for two audiences

For users: a familiar editor that doesn't cost you a gigabyte of RAM

• Sub-second startup. Native Rust binary, no Electron boot.
• ~60% less memory than VS Code on the same workspace.
• Your extensions still work. ESLint, Prettier, GitLens, Python — they run unchanged on the bundled Node.js host.
• Secure by default. Every extension starts with zero permissions, isolated by an OS-native sandbox (macOS sandbox-exec, Linux bubblewrap, Windows Job Objects).
• Familiar UI. Monaco editor, xterm.js terminal, VS Code theme compatibility, ARIA-correct components.
• Cross-platform. macOS, Linux, and Windows.

Download a prebuilt release from the Releases page, or build from source — see Quickstart.

For developers: an IDE that ships as a kit, not a black box

Every subsystem is a separate crate with a clean API. cargo add what you need, ignore the rest. The desktop app itself is just one composition of these crates — yours can be different.

[dependencies]
dscode-core           = "0.3"   # rope text buffer, app directories
dscode-lsp            = "0.3"   # LSP client, manager, pool
dscode-dap            = "0.3"   # Debug Adapter Protocol
dscode-terminal       = "0.3"   # PTY lifecycle, event sender trait
dscode-extension-host = "0.3"   # sandbox, IPC, permissions, rate limiter
dscode-session        = "0.3"   # workspace, configuration, lifecycle

Beyond Rust: npm i @dscode/monaco-wasm, pip install dscode-core.

use dscode_core::{TextBuffer, AppDirectories};

let buffer = TextBuffer::new("Hello, world!");
println!("{} chars", buffer.len_chars());

let dirs = AppDirectories::resolve(None);
println!("Config dir: {:?}", dirs.config_dir);

use dscode_lsp::{LspManager, LspServerPool, LspServerStrategy};

let pool = LspServerPool::new(LspServerStrategy::OnePerLanguage);
let manager = LspManager::new(pool);
manager.register_server("rust", "rust-analyzer", vec!["--stdio".into()]);

Each crate has optional Tauri integration via a feature flag, so the same crate works in a desktop app or a headless CI runner:

dscode-terminal = { version = "0.3", features = ["tauri"] }

See the Library Guide for the full tour.

The crates

For hackers: replace anything

Recipes

• Headless CI runner — use dscode-session without the tauri feature to scan workspaces, run extensions, and emit diagnostics as JSON.
• Custom terminal UI — implement TerminalEventSender from dscode-terminal and forward PTY output to a websocket, a log file, or your own renderer.
• Embed in your own Tauri app — pull in dscode-session with the tauri feature and you have the full IDE session inside your application.
• Write a different LSP client — dscode-lsp exposes LspClient directly if you'd rather build a bespoke manager.
• Build a live theme editor — combine dscode-core::AppDirectories with the CSS-custom-property theme layer to preview themes in real time.

Code examples for each are in docs/library-guide.md.

Design principles

1. Everything is a library. The application is a thin composition layer; the real value is in the crates.
2. APIs over implementations. We standardise on interfaces (TerminalEventSender, LspClient, TextBuffer) so you can swap implementations without touching the rest of the system.
3. VS Code compatibility is a feature, not a constraint. We support VS Code extensions because they're useful — but their limitations don't dictate our architecture.
4. Security by default. Extensions can't read your SSH keys by accident. Deny-by-default sandboxing is non-negotiable.
5. Performance is table stakes. Sub-second startup and low memory aren't traded for convenience.

Architecture

┌──────────────────────────────────────────────────────────────┐
│             Tauri Window (WebKit/Chromium)                   │
│  ┌────────────────────────────────────────────────────────┐  │
│  │   Frontend (Svelte 4 + TypeScript)                     │  │
│  │   - Monaco Editor                                      │  │
│  │   - Svelte Components (38 components)                  │  │
│  │   - CSS Custom Properties (VS Code theme compat)       │  │
│  │   - ARIA accessibility, focus traps                    │  │
│  └──────────────────────┬─────────────────────────────────┘  │
│                         │ Tauri IPC (invoke/emit)             │
│  ┌──────────────────────▼─────────────────────────────────┐  │
│  │   Rust Binary (src-tauri)                              │  │
│  │   - SessionManager (central coordinator)               │  │
│  │   - Tauri Command Handlers (45 modules)                │  │
│  │   - Bootstrap, Logging, Monitoring, File Watcher       │  │
│  └──────────┬─────────────────────────────────────────────┘  │
└─────────────┼────────────────────────────────────────────────┘
              │ depends on
┌─────────────▼────────────────────────────────────────────────┐
│  Cargo Workspace Library Crates                              │
│  ┌──────────────┐ ┌──────────────┐ ┌──────────────────────┐  │
│  │ dscode-core  │ │  dscode-lsp  │ │    dscode-dap        │  │
│  │ TextBuffer   │ │  LspClient   │ │    DebugAdapter      │  │
│  │ AppDirs      │ │  LspManager  │ │    DebugManager      │  │
│  │ CoreError    │ │  LspPool     │ │    DapPool           │  │
│  └──────────────┘ └──────────────┘ └──────────────────────┘  │
│  ┌──────────────────────┐ ┌──────────────┐                   │
│  │ dscode-extension-host│ │ dscode-term  │                   │
│  │ HostManager          │ │ TermManager  │                   │
│  │ IPC + Sandbox        │ │ PTY          │                   │
│  │ Permissions + Rate   │ │ EventSender  │                   │
│  │ Secrets + Validator  │ │ TermError    │                   │
│  └──────────────────────┘ └──────────────┘                   │
│  ┌──────────────────────────────────────────────────────────┐│
│  │ dscode-session                                           ││
│  │ ConfigStore, ExtensionLifecycle, Workspace, Documents,   ││
│  │ Contributions, EventEmitter, SessionState                ││
│  └──────────────────────────────────────────────────────────┘│
└──────────────────────────────────────────────────────────────┘
              │ NNG IPC (nanomsg, serde_json)
   ┌──────────┴────────────┬─────────────┐
   │                       │             │
 ┌─▼─────────┐     ┌──────▼────┐  ┌────▼────┐
 │ Extension │     │    LSP    │  │  Debug  │
 │   Host    │     │  Server   │  │   DAP   │
 │ (Node.js) │     │           │  │  Server │
 └───────────┘     └───────────┘  └─────────┘

Stack at a glance

Frontend — Svelte 4, Monaco Editor, xterm.js, lucide-svelte, CSS custom properties for VS Code theme compatibility.

Backend (Rust) — Tauri 2.1, Tauri Commands + NNG for out-of-process IPC, ropey text buffers, tree-sitter parsing, tower-lsp, git2, portable-pty, tracing, thiserror, ripgrep-based search.

Extension runtime — a real Node.js process, NNG REQ/REP IPC with worker threads, full vscode.* API surface, OS-keyring-backed SecretStorage, deny-by-default sandbox.

Quickstart

Prerequisites

• Rust 1.75+ with cargo
• Node.js 20+ and npm
• Platform-specific dependencies:
  • Linux: libwebkit2gtk-4.1-dev, libssl-dev, libgtk-3-dev, librsvg2-dev, patchelf
  • macOS: Xcode Command Line Tools
  • Windows: Microsoft Visual C++ Build Tools

Build and run

git clone https://github.com/dipankar/dscode.git
cd dscode
npm install

npm run tauri:dev        # development with hot reload
npm run tauri:build      # production bundle

Production artefacts land in:

• macOS: src-tauri/target/release/bundle/macos/DSCode.app
• Linux: src-tauri/target/release/bundle/deb/dscode_*_amd64.deb
• Windows: src-tauri/target/release/bundle/msi/DSCode_*_x64.msi

Test and lint

cargo test --workspace                       # all crate tests
cargo test -p dscode-core                    # one crate
cargo clippy --workspace -- -D warnings      # lint

Project layout

dscode/
├── Cargo.toml                # workspace root
├── crates/
│   ├── dscode-core/          # TextBuffer, AppDirectories
│   ├── dscode-lsp/           # LSP client, manager, pool
│   ├── dscode-dap/           # Debug Adapter Protocol
│   ├── dscode-extension-host/# Extension host management
│   ├── dscode-terminal/      # Terminal manager
│   └── dscode-session/       # Session management
├── src-tauri/                # Tauri binary (the default app)
│   └── src/
│       ├── main.rs
│       ├── bootstrap.rs
│       ├── session/          # SessionManager + IPC
│       └── commands/         # 45 Tauri command modules
├── monaco-wasm/              # Monaco WASM bindings
├── extension-host/           # Node.js extension runtime
├── src/                      # Svelte frontend (38 components)
├── packages/                 # npm and pypi bindings
└── docs/                     # Documentation

Extension compatibility

DSCode's extension host isn't a compatibility shim — it's a full Node.js runtime speaking the same IPC protocol as VS Code. Extensions are first-class citizens, but they're also sandboxed and observable.

Language providers supported with full two-way IPC: Hover, Completion, Diagnostics, SignatureHelp, Rename, CodeLens, CodeActions, Formatting, DocumentHighlights, FoldingRanges, SemanticTokens, DocumentSymbols, WorkspaceSymbols, Definitions, References, DocumentLinks, ColorPresentations, InlineCompletions.

Extras DSCode adds on top of the VS Code API:

• Sandbox declarations — extensions declare filesystem, network, and shell permissions in package.json. Denied by default.
• Rate limiting — built-in per-extension quota.
• OS keyring access — vscode.SecretStorage is backed by the OS-native keyring.
• Hot reload — extensions reload without restarting the editor.

Security

• Deny-by-default sandbox — extensions start with no permissions.
• Platform sandboxes — macOS sandbox-exec, Linux bubblewrap, Windows Job Objects.
• Path validation — all filesystem access is checked against the workspace allowlist.
• VSIX hardening — Zip-Slip prevention, SHA256 hash check, package.json cross-validation.
• OS keyring — extension secrets are stored via the OS-native keyring.
• Crash recovery — extension host restarts with exponential backoff (max 3 attempts).
• Stale IPC cleanup — orphaned socket files and pending requests are reaped automatically.
• Node.js verification — bundled Node binary is hash-verified on startup.

See SECURITY.md for the disclosure process.

Documentation

• Architecture Overview
• IPC Design
• Extension System
• UI System
• LSP Integration
• Library Guide
• Roadmap

Contributing

DSCode is a community project. Contributions are welcome — whether you're fixing a bug, adding a feature, or replacing an entire subsystem.

Adding a new crate

1. Create crates/my-crate/ with a Cargo.toml that inherits [workspace.package].
2. Add "crates/my-crate" to [workspace].members in the root Cargo.toml.
3. Write a README.md with badges, install instructions, and a usage example.
4. Add an examples/ directory with at least one runnable example.
5. Open a PR. CI checks formatting, clippy, tests, docs, and cargo publish --dry-run.

Replacing a subsystem

1. Open an issue describing your use case.
2. We'll help you identify the minimal API surface to implement.
3. Submit a PR. Hackability beats backwards compatibility in pre-1.0 releases.

Full guidelines in CONTRIBUTING.md.

License

MIT