NEW STANDARD: DSM

v0.36.1

The Unified Development
Stack Manager (DSM).

Hybrid code search, cross-repo API contract checks, security audits and stack orchestration — done locally by a Rust binary, not by an AI burning your token quota. Save AI for what only AI can do.

Get Started for Free View on GitHub View Documentation

void-stack — PowerShell

> void add mi-app F:\projects\mi-app

Scanning project...

✓ backend → uvicorn main:app --port 8000

✓ frontend → npm run dev

✓ docker:db → docker compose up postgres

> void start mi-app

[backend] → http://localhost:8000

[frontend] → http://localhost:5173

void-stack — zsh

$ void add mi-app ~/projects/mi-app

Scanning project...

✓ backend → uvicorn main:app --port 8000

✓ frontend → npm run dev

✓ docker:db → docker compose up postgres

$ void start mi-app

[backend] → http://localhost:8000

[frontend] → http://localhost:5173

void-stack — bash

$ void add mi-app /home/dev/projects/mi-app

Scanning project...

✓ backend → uvicorn main:app --port 8000

✓ frontend → npm run dev

✓ docker:db → docker compose up postgres

$ void start mi-app

[backend] → http://localhost:8000

[frontend] → http://localhost:5173

100%

Rust

2,313

Tests

MCP Tools

97.5%

Token Savings

Languages

Users report up to 97.5% reduction in token waste by injecting surgical context instead of full files.

Most DevOps tasks don't need AI — they need a fast, reliable tool. Void Stack handles them in Rust: start and monitor your entire stack with one command, audit secrets with OWASP patterns offline, generate architecture diagrams from source code, index your codebase with local vector embeddings. Zero tokens burned. Zero data sent anywhere. And when you do bring in Claude, Cursor, or any MCP client — they get the audit report, the architecture map, and surgical code chunks, not raw files to wade through.

AI-Powered DevOps

Any AI client. Zero token waste.

Stop burning token quota on tasks a Rust binary can do in milliseconds. Void Stack audits your security, maps your architecture, indexes your codebase, and monitors your services — all locally, all offline. Connect any MCP client and it gets structured results, not raw files.

Void Stack does the analysis. Your AI gets the results.

With the native MCP server, any compatible LLM can diagnose issues, start services, analyze technical debt, and audit security — all without leaving your editor.

list_projects start_project analyze_project audit_project generate_diagram get_logs check_dependencies scan_directory suggest_refactoring save_debt_snapshot compare_debt semantic_search index_project_codebase build_structural_graph get_impact_radius query_graph watch_project project_map list_entrypoints check_contracts get_api_contracts +54 more

Claude · Cursor · OpenCode · any MCP client

"Analyze the technical debt of mi-app"

↓

MCP Server (void-stack-mcp)

75 tools • JSON-RPC • Zero config

↓

Void Stack Core

Analyze • Audit • Start • Monitor

3-step MCP setup

void add mi-app ~/projects/mi-app

Auto-detects services from Dockerfile, package.json, pyproject.toml…

→

Install and wire the MCP server

curl -fsSL https://void-stack.dev/install.sh | bash

void setup

void setup registers the MCP server in Claude Desktop, Claude Code, Cursor, Windsurf, Cline and VS Code. Windows: install.ps1. Claude Desktop also takes the .mcpb from Releases.

→

Ask your AI. It now has everything.

full_analysis mi-app

Full audit + architecture + semantic search in a single tool call.

← the “aha!” moment

The Context Engine at work

void search my-app "auth middleware flow"

Without Void Stack AI reads the whole file

auth.ts · 170 lines

162 more lines ↓

~170 tokens

97.5%

fewer tokens

42× cheaper

With Void Stack Returns only what matters

auth.ts · 170 lines Semantic Index

104

112

145

✓ 4 relevant chunks ↑

~4 tokens

Compatible with

Claude Desktop claude.ai

Claude Code claude.ai

OpenCode FREE models

Cursor cursor.sh

Windsurf codeium

Cline vs code

Zed zed.dev

Gemini CLI google

Codex CLI openai

Aider doesn't support MCP natively — configure once in any client above and you're done.

With OpenCode you can use free models (MiniMax, Qwen, DeepSeek) — zero API cost, full void-stack MCP integration.

Hybrid Context Engine

Semantic intelligence. Structural precision.

Most tools choose between semantic search OR structural graphs. Void Stack combines both: vector embeddings find what is conceptually related, Tree-sitter graphs show what structurally breaks. 97.5% fewer tokens. Zero data leaves your machine.

Your codebase

any language

→

void index

BAAI · BM25 + int8 · local

→

Semantic filter

4 chunks · not 500 lines

→

Claude / Cursor

surgical context

What makes it different

GraphRAG

Semantic seeds + structural BFS expansion in one call. Callers, callees, and related chunks — no multiple round-trips.

Cross-Project Search

One query searches every registered project at once (70 on our test machine). Shared symbols surface automatically across backend, frontend, and proxy services.

Leiden Clustering

Community detection over chunk embeddings groups results by semantic area — not just similarity scores.

Interactive graph.html

Self-contained offline graph viewer. Force-directed layout, layer colors, CC filters, click-to-detail. No CDN, no data sent.

Hybrid Search

BM25 + vector retrieval fused with RRF over SQLite FTS5. Exact identifiers are now first-class — validateToken ranks ahead of fuzzy near-matches.

review_diff

Compact, LLM-ready PR review under ~4k tokens: findings on changed lines + blast radius + test coverage — not the whole diff.

suggest_tests_for_diff

Run the 12 tests that actually cover your change — not all 2,313. Maps changed symbols to the tests that exercise them.

find_dead_code

Zero-caller candidates surfaced with confidence levels, so you prune what's truly unused without guessing across the call graph.

API Contracts

check_contracts verifies REST + gRPC .proto contracts across all your projects in 0.89 s (23× faster in v0.36). get_api_contracts lists one line per gRPC service and hides generated stubs — 410k → 33k characters on a Flutter app.

Compact by default

Results are location + symbol + the matching lines, and hits already sent in the session are not repeated. Understanding a 430-file app took 91% less text than reading the files by hand (10,556 vs 114,236 characters).

GPU indexing

On Windows, embeddings run on any DirectX 12 GPU via DirectML — nothing to install. A 6,467-chunk index: 623 s on CPU → 40 s on GPU, identical results.

project_map + list_entrypoints

The lay of the land in one call: packages, folders, key docs, then every HTTP route, gRPC RPC, MCP tool, CLI flag, Tauri command, UI route and job — Dart/GoRouter included.

Semantic Search

"Find all code related to OAuth authentication"
→ Returns conceptually related chunks across any file

Structural Graph

"What breaks if I change validateToken()?"
→ BFS blast radius across 14 languages

Hybrid Context Engine — vector embeddings + Tree-sitter call graph

Semantic Search

97.5%

avg token reduction · benchmark

Benchmark: 97.5% measured over 135 real queries on void-stack's own codebase. Instead of reading a 170-line file, your AI gets 4 relevant lines.

In production: 68.6% avg token savings across 874 operations over 30 days — self-reported by get_token_stats.

void search my-app "auth middleware flow"

Structural Graph

instant

blast radius analysis

Tree-sitter call graph across 14 languages. Know exactly what breaks before you touch a single line of code.

build_structural_graph get_impact_radius query_graph

Always Fresh

git diff

incremental indexing

SHA-256 + git diff: only changed files re-indexed. Watch mode updates on every save. Post-commit hook updates on every commit.

watch_project install_index_hook

Structural analysis — 14 languages

Rust Python TypeScript JavaScript Go Dart Java PHP C C++ / MQL4·MQL5 Elixir C# Swift GDScript

Detects Unity (C#), Unreal Engine (C++ / UEFN Verse), Godot (GDScript) and MetaTrader (MQL4/MQL5) projects — and skips their cache and build folders.

Inspired by code-review-graph (MIT) — reimplemented natively in Rust. No Python required.

Zero Token Tax

What Void Stack does so your AI doesn't have to.

Every row is a task a Rust binary nails in milliseconds, for free. Stop paying your token quota to do them slowly.

Task

Without Void Stack

With Void Stack

Scan for hardcoded secrets

Ask AI to scan for hardcoded secrets — it reads files, burns tokens, may miss patterns.

void audit runs 12 OWASP regex patterns in Rust — instant, offline, zero tokens.

Explain my architecture

Feed AI your files and hope it figures out the architecture on its own.

void analyze builds the dependency graph + anti-patterns in Rust — AI gets the structured report.

Generate a diagram

Ask AI for a diagram — it guesses from partial context.

void diagram emits Mermaid / Draw.io straight from your source — no guessing.

Find files related to a bug

AI reads full files, 170 lines per result, wasting the context window.

void search returns 4 relevant chunks via local embeddings — 97.5% fewer tokens.

Start your dev stack

Type commands one by one, or ask AI to remember them across sessions.

void start mi-app — all services, pre-launch hooks, venv activation, one command.

Review a PR

AI reads the full diff to review it — ~70k tokens before it even starts thinking.

void review ships a compact payload — findings + blast radius + coverage in ~2.6k tokens.

Which tests should I run?

Run all 2,313 tests — or ask AI to guess which ones matter for your change.

void suggest-tests maps your diff to the 12 tests that actually cover it.

Did the backend change break the app?

AI reads backend and frontend files across repos looking for broken routes — and still misses a /api vs /api/v1 drift.

void contracts check verifies REST + gRPC contracts across every registered repo in 0.89 s and names the exact call site.

When you connect any MCP client — Claude, Cursor, Cline, OpenCode — all of this is already done. One call to full_analysis and your AI has everything.

Production-Grade Engineering

Architected by Rust. Audited by itself.

Docker Intelligence

Auto-detection of Dockerfile and Compose with 4 execution modes. One-click import from docker-compose.yml.

Phase 12

Security First

Secrets scanning and vulnerability auditing 100% offline. OWASP pattern detection without sending code to any external service.

Offline

Visual Architecture

Auto-generated Mermaid and Draw.io diagrams from your source code. API routes, DB models, architecture layers.

Auto-generated

Dependency Doctor

9 parallel detectors for Node, Python, Rust, Go, Java, .NET, PHP, Flutter, and Ruby. If a dependency is missing, Void Stack doesn't just warn you — it gives you the exact command to fix it.

9 Detectors

Self-Healing Infrastructure

No more zombie services. If a process dies, you know instantly. Exit Watcher monitors every service in real-time and flags failures the second they happen.

Exit Watcher

Privacy First

Your .env files are never fully read. Security analysis is 100% local — no data leaves your machine. Your code is yours. Your security too.

100% Offline

Dogfooding

Built with Void Stack, for Void Stack.

We believe in our craft. We used our own analysis engine to detect technical debt in our codebase. Result: 75% complexity reduction, 97.5% token savings on semantic search, and 2,313 tests keeping the codebase honest.

Cyclomatic Complexity ↓ 75%

CC=41 → CC=10

analyze_best_practices — from God Function to table-driven

God Classes Eliminated ↓ 100%

1197 LOC → 340

MCP Server — extracted into 10 tool modules

Audit False Positives ↓ 83%

83% → 0%

Risk score from 25/100 to 2/100 on self-analysis

Tests Passing Stable

2,313

whole workspace, desktop app aside — all green

void-stack — Workspace Architecture

┌─────────────────────────────────────────────────────────────────┐
│                         INTERFACES                              │
├──────────┬─────────┬────────────┬──────────┬────────────────────┤
│ CLI      │ TUI     │ Desktop    │ MCP      │ Daemon             │
│ void     │ ratatui │ tauri+react│ rmcp     │ gRPC (tonic)       │
├──────────┴─────────┴────────────┴──────────┴────────────────────┤
│                           ↓ uses                                │
├─────────────────────────────────────────────────────────────────┤
│                       VOID-STACK-CORE                           │
├────────┬────────┬────────┬────────┬────────┬────────┬───────────┤
│Manager │Detect  │Analyze │Audit   │Docker  │Diagram │AI         │
│process │fw scan │cc+debt │secrets │compose │mermaid │ollama     │
│state   │venv    │pattern │vuln    │k8s/tf  │draw.io │suggest    │
│logs    │deps    │best-pr │config  │runner  │        │           │
├────────┴────────┴────────┴────────┴────────┴────────┴───────────┤
│                          CONTEXT ENGINE                         │
├────────────────┬────────────────┬────────────────┬──────────────┤
│ Index          │ Graph          │ Contracts      │ Inventory    │
│ BM25 + int8    │ tree-sitter    │ REST + gRPC    │ map          │
│ DirectML GPU   │ 14 languages   │ cross-repo     │ entrypoints  │
└────────────────┴────────────────┴────────────────┴──────────────┘

How do you prefer to work?

One toolkit. Three ways in.

CLI for speed. TUI for live monitoring. Desktop for visual architecture. MCP to let your AI handle it all. Same core, same projects, same config.

CLI

void

Fast commands from terminal. Ideal for scripts and CI/CD.

TUI

void-stack-tui

Interactive dashboard with live logs. For terminal lovers.

Desktop

void-stack-desktop

Cyberpunk GUI app. Tauri + React with mission-control aesthetic.

MCP Server

void-stack-mcp

75 tools for Claude, Cursor, OpenCode, or any MCP client.

Quick Start

From zero to productive in 30 seconds.

One-liner

Quick Install

curl -fsSL https://www.void-stack.dev/install.sh | bash

Installs to ~/.local/bin. Supports Linux x64/arm64 and macOS (Apple Silicon & Intel).

irm https://www.void-stack.dev/install.ps1 | iex

Installs to %LOCALAPPDATA%\void-stack\bin. Run in PowerShell (any version).

Installs CLI + TUI + MCP server — your full dev toolkit in one command.

Prefer Cargo? Install from source →

CLI

Fast commands from terminal. Ideal for scripts and CI/CD.

cargo install --git https://github.com/mague/void-stack void-stack-cli

TUI

Interactive terminal dashboard with live logs.

cargo install --git https://github.com/mague/void-stack void-stack-tui

MCP Server

75 tools for Claude Desktop, Claude Code, OpenCode, or any MCP client.

cargo install --git https://github.com/mague/void-stack void-stack-mcp

Add to your MCP client config

{ "mcpServers": { "void-stack": { "command": "void-stack-mcp" } } }

{ "mcp": { "void-stack": { "type": "local", "command": ["void-stack-mcp"], "enabled": true } } }

Or skip the manual config: void setup registers the server in 6 MCP clients (Claude Desktop, Claude Code, Cursor, Windsurf, Cline and VS Code) in one command.

Claude Desktop: drag the .mcpb from the Releases page, no JSON. Fewer tool definitions per session: add "args": ["--tools", "context"] (−64%). One server for Windows, WSL and Tailscale: void-stack-mcp --http 0.0.0.0:7400 (Streamable HTTP; a bare port binds to localhost).

Desktop

Cyberpunk GUI app. Tauri + React.

macOS (.dmg) Windows (.exe) Windows (.msi) Linux (.deb) Linux (.AppImage)

macOS: If blocked by Gatekeeper, run: xattr -cr /Applications/Void\ Stack.app

All installers are x64 (64-bit). macOS .dmg is Apple Silicon (ARM).

Or build from source:

cd crates/void-stack-desktop && cargo tauri build

Register project

Void Stack auto-detects your services:

void add mi-app ~/projects/mi-app

Start everything

One command. All services. All ports.

void start mi-app

Or use the GUI

Open the visual dashboard with all tools:

void-stack-desktop

MCP — claude_desktop_config.json

// Integrate with Claude Desktop:
{
  "mcpServers": {
    "void-stack": {
      "command": "void-stack-mcp"
    }
  }
}

// Now Claude can:
// - Search code with ~91% less text than reading files
// - Check REST & gRPC contracts across repos in under 1 s
// - Trace the blast radius of a diff and pick its tests
// - Start/stop services, audit security, draw diagrams

The Unified Development Stack Manager (DSM).

Any AI client. Zero token waste.

Void Stack does the analysis. Your AI gets the results.

Semantic intelligence. Structural precision.

What Void Stack does so your AI doesn't have to.

Architected by Rust. Audited by itself.

Docker Intelligence

Security First

Visual Architecture

Dependency Doctor

Self-Healing Infrastructure

Privacy First

Built with Void Stack, for Void Stack.

One toolkit. Three ways in.

CLI

TUI

Desktop

MCP Server

From zero to productive in 30 seconds.

Quick Install

CLI

TUI

MCP Server

Add to your MCP client config

Desktop

Register project

Start everything

Or use the GUI

The Unified Development
Stack Manager (DSM).