The Graph-Native Intelligence Layer for Code
Know what breaks before you break it.

Quick Start • GUI • Features • Architecture • Protocol • Contributing

About to change code but afraid of breaking things?

$ arbor refactor detect_language

🔍 Analyzing detect_language

🟢  Confidence: High | Role: Core Logic
   • 15 callers, 3 dependencies
   • Well-connected with manageable impact

⚠️  18 nodes affected (4 direct, 14 transitive)

Will break immediately:
  • parse_file (function)
  • get_parser (function)

→ Proceed carefully. Test affected callers.

That's it. One command. Know what breaks before you break it.

Arbor now includes a native graphical interface for impact analysis:

arbor gui

Features:

• 🔍 Symbol Search: Enter any function, class, or method name
• 📊 Impact Display: See direct callers, indirect callers, and dependencies
• 🔒 Privacy Spoilers: File paths hidden by default (click to reveal)
• 🌙 Dark/Light Mode: Toggle with one click
• 📋 Copy as Markdown: Export analysis for PR descriptions
• 📜 Search History: Quick access to recent searches

CLI and GUI share the same engine — identical analysis across both.

# Install
cargo install arbor-graph-cli arbor-gui

# Run on any project
cd your-project
arbor refactor <function-name>

# Or use the GUI
arbor gui

📖 More commands? See the 5-minute Quickstart Guide

Most AI coding assistants treat your codebase like a bag of text. They embed chunks into vectors and hope similarity search finds the right context.

Arbor builds a graph. Every function, class, and import is a node. Every call and dependency is an edge. When you ask "what breaks if I change this?", Arbor traces the actual call graph — not keyword matches.

Traditional RAG:         Arbor:
                         
"auth" → 47 results      "auth" → AuthController
                                  ├── validates via → TokenMiddleware  
                                  ├── queries → UserRepository
                                  └── emits → AuthEvent

# Clone and build
git clone https://github.com/Anandb71/arbor.git
cd arbor/crates
cargo build --release

If building the GUI on Linux, you'll need the following development headers:

sudo apt-get install -y pkg-config libx11-dev libxcb-shape0-dev libxcb-xfixes0-dev \
    libxkbcommon-dev libgtk-3-dev libfontconfig1-dev libasound2-dev libssl-dev cmake

# Build visualizer (requires Flutter)
cd ../visualizer
flutter build windows

That's it. Your IDE or AI agent can now connect to ws://localhost:7433 and query the graph, or use the MCP protocol over stdio.

A lightweight, egui-based interface for quick impact analysis:

• Enter a symbol name, see what breaks
• Privacy-first: file paths hidden behind spoilers
• Copy results as Markdown for PR descriptions

Every analysis now includes explainable confidence:

Arbor classifies nodes by their structural role:

• Entry Point: No internal callers (API endpoints, main functions)
• Utility: Helper functions called by many
• Core Logic: Central to the domain
• Adapter: Bridges between layers
• Isolated: No detected connections

Arbor enables Claude and other LLMs to "walk" your code graph. Using the Model Context Protocol (MCP), agents can run:

• find_path(start, end): Discover the logic flow between two distant components (A* algorithm).
• analyze_impact(node): Determine the blast radius of a change before it happens.
• get_context(node): Retrieve semantically relevant code, not just keyword matches.

Arbor understands that code doesn't live in isolation. It resolves imports, calls, and inheritances across file boundaries using a Global Symbol Table.

Concrete example: When you import User in profile.ts, Arbor knows it's the same User class defined in auth.ts. If you rename User.email → User.emailAddress, Arbor can tell you which 7 files in services/ will break — before you run the tests.

Powered by Sled, Arbor's graph persistence layer is atomicity-compliant and lightning fast.

• Granular Updates: Only "dirty" nodes are re-written to disk. Saving a file in a 100k LOC repo triggers minimal I/O.
• Instant Load: The graph state loads instantly on startup, no re-indexing required.

The visualizer exists to make AI reasoning inspectable. Every node an LLM touches can be seen, traced, and verified by a human.

• Force-Directed Graph: 100k+ nodes with Barnes-Hut QuadTree optimization
• AI Spotlight: Camera follows the node an AI agent is currently examining
• Impact Highlights: See which nodes "vibrate" when you preview a change
• Interactive: Drag nodes, hover for details, filter by file/type

• Sub-100ms Incremental Sync: Parsing happens in milliseconds.
• Binary Serialization: Graph state uses efficient bincode encoding.
• Rust Core: Built on the safety and speed of Rust.

For monorepos using pnpm, npm link, or symlinked local packages:

arbor index --follow-symlinks
arbor viz --follow-symlinks
arbor bridge --follow-symlinks

This ensures symlinked dependencies are indexed instead of skipped.

arbor/
├── crates/                 # Rust workspace
│   ├── arbor-core/         # AST parsing, Tree-sitter integration
│   ├── arbor-graph/        # Graph schema, Sled Store, Symbol Table
│   ├── arbor-watcher/      # File watching, incremental sync
│   ├── arbor-server/       # WebSocket server, protocol handler
│   ├── arbor-mcp/          # Model Context Protocol bridge
│   ├── arbor-cli/          # Command-line interface (pkg: arbor-graph-cli)
│   └── arbor-gui/          # Native GUI (egui-based) ← NEW
├── visualizer/             # Flutter desktop app
│   ├── lib/
│   │   ├── core/           # Theme, state management
│   │   ├── graph/          # Force-directed layout, LOD logic
│   │   └── shaders/        # GLSL bloom/glow effects
│   └── shaders/            # Raw GLSL files
└── docs/                   # Extended documentation

• Core indexer and CLI
• Logic Forest visualizer (LOD, Bloom)
• VS Code extension
• Agentic Bridge (MCP)
• Multi-language parsers (Rust, TS, Python, Go, Java, C/C++, C#, Dart)
• Impact Radius Simulator
• Context-Aware Edge Resolution
• Persistent Caching

See the impact. Trust the output.

• Native GUI: Egui-based impact analysis interface
• Confidence Scoring: Explainable Low/Medium/High risk levels
• Node Roles: Entry Point, Utility, Core Logic, Adapter, Isolated
• Privacy Spoilers: File paths hidden until clicked
• PR Summary Generator: arbor pr-summary
• Watch Mode: arbor watch for auto-refresh

📖 Full roadmap: docs/ROADMAP.md

• The target node may not exist in the graph. Run arbor query "NodeName" to verify.
• The node may have no dependents (nothing calls or imports it).
• Try increasing depth: arbor refactor NodeName --depth 5.

• Flutter uses composition, not inheritance. Arbor tracks contains edges, not class hierarchies.
• Use arbor refactor WidgetName --depth 2 to see nested widgets.

• In monorepos with linked packages (pnpm, npm link).
• When local dependencies are symlinked into node_modules.
• Default is OFF to avoid infinite loops from circular links.

• Check that your files use supported extensions: .rs, .ts, .tsx, .py, .dart, .go.
• Ensure files are not excluded by .gitignore.
• Run arbor status to see which extensions were detected.

Arbor is designed with a Local-First security model:

• No data exfiltration: All indexing and querying happens 100% locally. No code leaves your machine.
• No API keys required: Works entirely offline.
• No telemetry: Zero phone-home behavior.
• Open source: Full source code available for audit.

Arbor is for:

• Large or long-lived codebases
• AI-assisted refactoring where correctness matters
• Engineers who value precision over convenience

Arbor is not for:

• Small scripts or throwaway code
• Prompt-only workflows without code context
• People who just want autocomplete

Arbor represents the complete "Nervous System" for your code:

     Claude asks about AuthController
           │
           ▼
    ┌─────────────────┐
    │   Arbor Bridge  │  ← MCP Server (ArborQL)
    │   (arbor-mcp)   │     "find_path(Auth, DB)"
    └────────┬────────┘
             │ trigger_spotlight()
             ▼
    ┌─────────────────┐
    │   SyncServer    │  ← WebSocket broadcast
    │   (port 8080)   │
    └────────┬────────┘
             │ FocusNode message
     ┌───────┴───────┐
     │               │
     ▼               ▼
┌─────────┐    ┌─────────┐
│ VS Code │    │  Forest │
│ Golden  │    │ Camera  │
│Highlight│    │Animation│
│ #FFD700 │    │ 600ms   │
└─────────┘    └─────────┘

MIT — use it however you want. See LICENSE for details.

Built for developers who think code is more than text.

"The forest is mapped. The AI is walking the path."

⭐ Star us on GitHub