STATUZ IDE

Topology-Aware Development Environment

The end of text-only development.

Built on VS Code. Powered by a Rust Graph Engine.

16
AI Providers
5
Core Algorithms
3
Primitive Queries
1
Graph Engine

"Every IDE treats code as a file.
Statuz treats code as a system."

The topological paradigm.

Topology over Syntax

Every IDE treats code as text. Statuz treats code as a topological graph. Functions are nodes. Imports are edges. Modules are clusters. Dependencies are relations. This is not a metaphor — it is a computational model, backed by a Rust graph engine with dual-indexed adjacency lists for O(1) traversal in any direction.

Every node is a computation unit
Functions, classes, modules, files — all nodes in a single unified graph
Every edge is a relationship
depends_on, produces, consumes, validates, informs, contains, delegates_to — 7 built-in relation types, infinitely extensible
Every cluster is a bounded context
Fields represent distinct views of the same ecosystem. Cross-field bridges enable bidirectional traversal
Every change has a blast radius
Reverse BFS impact analysis across all fields simultaneously. Know exactly what breaks.
Additive Engineering

Statuz does not replace VS Code — it adds to it. The full VS Code extension ecosystem, debugger, terminal, and language servers remain untouched. The Statuz Layer sits on top, enriching the editor with topological reasoning, AI-powered code understanding, and strategic decision tracking.

Three Primitive Queries

A complete topological understanding of any software system can be reduced to three questions. Traverse, Impact, Path. Everything else — health reports, centrality analysis, diff detection, subgraph extraction — is a composition of these three primitives.

The Statuz Manifesto

01
Code is not text. Code is a graph. Functions are nodes. Imports are edges. Modules are clusters. Every IDE before Statuz treated code as a flat file — a relic of the punch-card era.
02
Understanding is more important than editing. VS Code gives you the best text editor in the world. Statuz gives you the first topological runtime. Two tools. One environment. No compromises.
03
Three queries are enough. Traverse. Impact. Path. Every question you can ask about a software system — blast radius, dependency chain, critical path, central hub, architectural drift — is a composition of these three primitives.
04
AI is not a feature. It is a substrate. 16 providers, a unified streaming architecture, MCP protocol, reasoning extraction, and inline editing — not as an add-on, but as a first-class citizen in the topological model.
05
Every decision is a commitment. Every drift is detectable. DCR tracks architectural decisions with formal commitment levels. Drift detection scans for decay, contradiction, and violation. The board visualizes the strategy. The engine enforces the topology.
VS Code lets you edit code.
Statuz lets you understand it.

Three primitive queries. One graph. Infinite compositions.

Traverse

"What does this connect to?"
O(1) adjacency list lookup. Filter by relation type. Supports cross-field bridge traversal.

traverse(node, relation?)
Impact

"If this changes, who is affected?"
Reverse BFS blast radius analysis. Degree centrality. Critical path detection. Cross-field propagation.

impact(node)
Path

"How do I get from A to B?"
BFS shortest path with parent tracking. Field-level path annotation. Cross-field via bidirectional bridges.

path(from, to)

The graph engine,
in full detail.

GraphEngine — In-Memory Topological Runtime

Written in Rust, compiled via napi-rs, the GraphEngine is the computational heart of Statuz. It maintains an adjacency-list-based directed graph with triple-redundant edge storage for O(1) traversal in both directions. Three copies of every edge exist simultaneously: the global edge registry, the source node's outgoing adjacency (indexed by relation type), and the target node's incoming adjacency (also indexed by relation type). Cascade removal ensures consistency without garbage collection.

Storage HashMap<NodeId, Node>
Traversal O(1) adjacency lookup
Edge Indexing Triple-redundant
Runtime Rust + napi-rs
.stz Binary Format

Self-contained, encrypted, content-addressable. Magic bytes "STZ\0" identify the format. Content is msgpack-encoded, optionally zstd-compressed (level 3), and ChaCha20-encrypted with an Argon2id-derived key. The Cluster ID is the first 16 bytes of a blake3 hash. The hash covers content only, so metadata can be modified without invalidating it.

Magic: "STZ\0" (4 bytes) Version: 0x0002 (2 bytes, LE) Flags: 0x0000 (2 bytes, LE) Salt: 16 bytes (Argon2id) Content: msgpack . zstd . ChaCha20 Hash: 32 bytes (blake3)
Cluster & Field Architecture

A Cluster owns all nodes centrally. Each Field owns its own edges — representing different views of the same ecosystem. Cross-field bridges are bidirectional: each bridge creates forward and reverse edges simultaneously. Cross-field traversal uses recursive DFS with visited-set deduplication. Impact analysis propagates across all fields via reverse BFS, following bridge edges to discover affected nodes in remote fields.

Cross-Field Traversal Recursive DFS with visited sets for both fields and nodes. Depth-limited. Returns HashMap<FieldId, (Vec<NodeId>, Vec<Edge>)>.
Cross-Field Impact Reverse BFS across ALL fields. When crossing a bridge, follows the reverse bridge to the other field.
Algorithm Suite

Beyond the three primitives, the engine provides a complete analytical toolkit.

Degree Centrality Top-N sort by total degree
Transitive Closure Full BFS reachability
Health Report Orphans, sinks, sources, disconnected components
Subgraph Extraction Depth-limited BFS from seed nodes
Diff Engine Full cluster comparison, WEIGHT_EPSILON 1e-10
Validation 8 issue categories, severity-graded
Merge System 4 strategies: Skip, Overwrite, Rename, MergeMeta
Clone Content-addressable ID regeneration

"Three queries. One graph.
Everything else is a composition."

16 providers. One unified
streaming architecture.

A unified provider dispatcher maps 16 providers to their respective chat, FIM, and model-list implementations. Each provider is a first-class entry in a typed record, ensuring compile-time exhaustiveness checking.

AnthropicNative SDK
OpenAINative SDK
GeminiNative SDK
GroqOAI Compat
MistralNative FIM
OllamaLocal
DeepSeekOAI Compat
OpenRouterOAI Compat
xAI (Grok)OAI Compat
vLLMLocal
LM StudioLocal
AzureEnterprise
Vertex AIEnterprise
BedrockEnterprise
liteLLMProxy
OAI CompatAny
Stage 1 Unified Dispatcher Typed CallFnOfProvider record maps provider name to implementation
Stage 2 Streaming Abstraction 3 streaming patterns normalized to one callback interface
Stage 3 Reasoning Extraction Multi-vendor reasoning: budget sliders, effort sliders, think tags, thinking fields
Stage 4 Tool Calling 3 native formats (OpenAI, Anthropic, Gemini) + XML fallback parser
OpenAI Streaming
For-await over chunked response. Accumulates fullText, fullReasoning, tool call fragments from delta chunks.
for await (const chunk of response)
Anthropic Events
Event-based streaming with content_block_start, content_block_delta, thinking_delta, input_json_delta, redacted_thinking.
stream.on('streamEvent', ...)
Gemini Native
For-await over generateContentStream. Extracts functionCalls from chunks for native tool calling.
for await (const chunk of stream)
Reasoning System

Two slider types: budget_slider (Anthropic, Gemini) and effort_slider (OpenAI, xAI, OpenRouter). Provider-specific reasoning IO settings. Manual think-tag parsing for open-source models. Per-feature reasoning toggle. Reserved output token space adjustment.

Claude Opus 4 200K ctx, budget 1024-8192
o3 / o4-mini 1M ctx, effort slider
Gemini 2.5 Pro 1M ctx, budget 1024-24576
Llama 4 10M ctx (open-source record)
Inline Edit Engine

Dual-mode editing: Fast Apply (search/replace blocks) and Slow Apply (full file rewrite). Search/replace has up to 4 retries with block-by-block streaming. Overlap detection prevents conflicting edits. Right-to-left application preserves line numbers. Snapshot-based undo/redo with full state capture. Streaming diff zones with sweep animation.

Fast Apply Search/Replace blocks
Retries Up to 4 (N_RETRIES)
Threshold 1000+ chars → Fast Apply
Undo Snapshot-based, deepClone
Autocomplete Engine

Custom LRU cache with O(1) lookups, abort-on-eviction for LLM requests. 500ms debounce, 60s timeout. Four completion types: fill-middle, redo-suffix, next-line, no-predict. Stack-based parenthesis balancing prevents syntax errors. Subsequence matching handles LLM-generated suffix variations.

Cache LRU, max 20 per doc
Debounce 500ms
Timeout 60s
Pending Limit Max 2 concurrent
MCP Protocol

Full Model Context Protocol integration. Dynamic tool discovery, server management, toggle on/off, MCP config file support. Tools are converted to provider-native formats (OpenAI, Anthropic, Gemini) or fall back to XML parsing for providers without native tool support.

Tool Formats 3 native + XML fallback
Chat Modes normal, gather, agent
Tool Matrix Agent: all tools; Gather: read-only
SDK @modelcontextprotocol/sdk 1.11

Track every decision.
Detect every drift.

A formal decision tracking system that registers every architectural commitment, detects drift before it becomes debt, and uses AI to surface implicit decisions the rule engine would miss.

6
Commitment Levels
5
Decision Categories
4
Detection Sources
Commitment Levels

Every decision progresses through a formal commitment hierarchy, from tentative exploration to fully committed. Rejected and superseded decisions are retained for audit trails.

Exploring Tentative Adopted Committed Rejected Superseded
Drift Detection Engine

Three scan types: commitment decay (14/7 day thresholds), assumption staleness (21 day threshold), constitution violation (forbidden feature matching, NLP-based constraint detection with Chinese-language support). O(n^2) pairwise contradiction cross-scan across all decisions.

Direct Conflict Scope Creep Commitment Decay Assumption Invalidated Constitution Violation
AI Bridge

Dependency-injected AI analysis layer. Temperature 0.2 for deterministic outputs. Non-blocking design — AI unavailability never blocks registration. Parses 3 response formats (object, JSON string, markdown-wrapped JSON). Extracts decisions from conversation with confidence >= 0.5 threshold.

Sandboxer Board

Native SVG canvas with 4-layer rendering (edges, nodes, temp-edges, root). Five custom arrow markers. Zoom clamp 200-8000 viewBox. Drag-to-connect with auto-detection. 50-deep snapshot undo/redo. Context menus per node, edge, and canvas. No React, no third-party graph library — pure SVG.

Rendering 4-layer native SVG
Edge Types 5 semantic types
Undo Depth 50 snapshots
Dependencies Zero

"Every decision is a commitment.
Every drift is detectable."

Everything you need to
understand your code.

AI Chat & Inline Edit

Context-aware AI assistant with Ctrl+K/L inline editing. Streaming diffs, fast/slow apply modes, 4 retries for search/replace, and autocomplete with LRU caching and parenthesis balancing.

Chat Ctrl+K Autocomplete
Sandboxer Board

Strategic planning canvas with native SVG rendering. DCR drift detection, 50-step undo/redo, 5 edge types, automatic layout, and drag-to-connect. No third-party dependencies.

SVG Canvas DCR Strategy
Agent Management

ECC catalog browser with one-click install/uninstall. Harness visualization canvas for skills, commands, agents, and rules. Full catalog with 60+ components and 87 commands.

ECC Catalog Harness
16 AI Providers

Anthropic, OpenAI, Gemini, Groq, Mistral, Ollama, DeepSeek, OpenRouter, xAI, LM Studio, vLLM, Azure, Vertex AI, Bedrock, liteLLM, OAI Compat. Per-model capability configuration with reasoning support.

Multi-Model Local Cloud
MCP Protocol

Model Context Protocol integration. Full tool discovery, server management, dynamic tool calling. 3 native tool formats + XML fallback. Chat modes: normal, gather, agent.

MCP Tool Discovery SDK
VS Code Ecosystem

100% compatibility with the VS Code extension marketplace. 80+ built-in extensions, themes, language servers, and debuggers. Full terminal, Git, and language protocol support.

Extensions Marketplace Themes

Topology vs. text.
The difference is qualitative.

Every modern IDE gives you a text editor with AI features. Statuz gives you a topological runtime with AI as a substrate. The difference is not incremental — it is categorical.

Feature Statuz VS Code Cursor JetBrains Zed
Topological Graph Engine ✓ Rust-native ✗ ✗ ✗ ✗
Three Primitive Queries ✓ O(1) traversal ✗ ✗ ✗ ✗
AI Providers ✓ 16 ~ 2 (GitHub Copilot) ✓ 8 ~ 3 ✓ 6
Decision Commitment Registry ✓ 6 levels ✗ ✗ ✗ ✗
Drift Detection Engine ✓ 5 scan types ✗ ✗ ✗ ✗
Strategy Canvas ✓ Native SVG ✗ ✗ ✗ ✗
MCP Protocol ✓ Full ✗ ✓ Limited ✗ ✗
Binary .stz Format ✓ Encrypted ✗ ✗ ✗ ✗
VS Code Extension Compatible ✓ 100% ✓ Native ✓ 100% ✗ ~ Partial
Open Source ✓ Apache 2.0 ✓ MIT ✗ Proprietary ✗ Proprietary ✓ GPL
ECC Agent Catalog ✓ 60+ agents ✗ ✗ ✗ ✗

Feature coverage as of Q3 2026. Third-party IDEs may add features over time. Statuz is the only IDE with a native topological graph engine at its core.

Three layers. One unified
development experience.

VS Code Core
Editor · Terminal · Debug · Git · Language Servers · Extension Host · 80+ Built-in Extensions
Statuz Layer
AI Chat · Inline Edit · Board Canvas · Agent Management · ECC · MCP Bridge · DCR Engine · 16 Providers
Rust Graph Engine
GraphEngine · Cluster · Field · .stz Format · traverse · impact · path · blake3 · ChaCha20
Coming Soon

The Statuz Layer sits on top of the full VS Code Core, preserving all native capabilities. The Rust Graph Engine (in development) provides the topological reasoning foundation. This is additive engineering — nothing is removed, only enriched.

"The text era is over.
The topology era has begun."

Get Statuz IDE.

Current version: 1.99.3-dev
License: Apache 2.0
Build: 21c8d8e
Windows

Windows 10 / 11, 64-bit
EXE Installer & Portable

Build from Source
macOS

macOS 12+, Intel & Apple Silicon
DMG & ZIP

Build from Source
Linux

Debian / Ubuntu / Fedora
DEB, RPM, Snap, AppImage

Build from Source

Pre-built binaries are coming soon. In the meantime, build from source.

System Requirements

  • Node.js 20+
  • 8 GB RAM minimum
  • 2 GB free disk space
  • GPU with WebGL support
  • Internet connection for AI features

Phased rollout.

Phase 0 — Brand Shell 70%
Product branding, icon replacement, codebase cleanup, license compliance. 33 legal issues identified and resolved. Brand migration from Void is in progress.
Active
Phase 1 — Rust Engine Integration 0%
napi-rs native module, IStatuzEngineService IPC channel, .stz file format support, GraphEngine with 3 primitive queries, 5,200+ lines of Rust code.
Planned
Phase 2 — Core Graph UI 0%
Cluster Explorer, Graph Visualizer, Query Console, Impact Analyzer, .stz file editor, real-time dependency visualization.
Planned
Phase 3 — AI Integration 0%
Graph-aware AI commands, auto-graph-builder, context bridge, semantic query enhancement, topology-aware code generation.
Planned
Phase 4+ — Advanced & Ecosystem 0%
Health dashboard, cross-field bridges, clone/merge, MCP server integration, signal bus, .stz standardization, cluster registry.
Planned