NEW STANDARD: DSM

v0.25.0

The Unified Development
Stack Manager (DSM).

Security audits, architecture analysis, and service orchestration — done by a Rust binary in seconds, 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

960

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 +22 more

Claude · Cursor · OpenCode · any MCP client

"Analyze the technical debt of mi-app"

↓

MCP Server (void-mcp)

42 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

cargo install void-stack-mcp

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

Drop the JSON into claude_desktop_config.json (or equivalent).

→

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 · HNSW · local

→

Semantic filter

4 chunks · not 500 lines

→

Claude / Cursor

surgical context

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 10 languages

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

Semantic Search

97.5%

avg token reduction

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

void search my-app "auth middleware flow"

Structural Graph

instant

blast radius analysis

Tree-sitter call graph across 10 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 — 10 languages

Rust Python TypeScript JavaScript Go Dart Java PHP C C++

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.

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 960 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

960

void-stack-core · analyzer · mcp — all green

void-stack — Workspace Architecture (auto-generated)

┌─────────────────────────────────────────────────────────────────┐
│                         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  │        │           │
└────────┴────────┴────────┴────────┴────────┴────────┴───────────┘

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-tui

Interactive dashboard with live logs. For terminal lovers.

Desktop

void-desktop

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

MCP Server

void-mcp

42 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

42 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-mcp" } } }

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

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-mcp"
    }
  }
}

// Now Claude can:
// - List and manage your projects
// - Start/stop services
// - Analyze architecture and debt
// - Audit security
// - Generate 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).