Skip to main content
Architecture Explorer analyzes your codebase and generates an interactive visualization of its structure — modules, dependencies, handler call graphs, and more. It runs inside your workspace and serves a web-based UI you can access from your browser.

​
What It Does

Architecture Explorer scans your project files, builds a dependency graph, and renders it as an interactive web application. You can explore:
  • Module structure — how files and directories relate to each other
  • Dependency graphs — which modules import or depend on others
  • Handler call graphs — trace the flow from HTTP handlers through business logic
  • Code metrics — file sizes, complexity indicators, and module boundaries

​
Supported Languages

LanguageDetectionWhat’s analyzed
RustCargo.tomlCrate dependencies, module tree, handler functions
TypeScriptpackage.jsonImport graph, component hierarchy, route definitions
JavaScriptpackage.jsonImport graph, module structure
Architecture Explorer scans up to 5 projects at a maximum directory depth of 25. For monorepos, it discovers and analyzes each project (crate or package) independently.

​
Availability by Image

Architecture Explorer comes pre-installed in the full image. For other images, you need to install it first.
ImageStatusAction needed
fullPre-installedLaunch directly
baseNot installedInstall, then launch
devNot installedInstall, then launch
openclawNot installedInstall, then launch
Use the full template if you want Architecture Explorer available immediately without an installation step. See Images & Templates for details.

​
Installation

If your workspace doesn’t use the full image, install Architecture Explorer first.

​
Start the installation

curl -X POST https://api.rigbox.dev/api/workspaces/$WORKSPACE_ID/tools/architecture-explorer/install \
  -H "Authorization: Bearer $RIGBOX_API_KEY"
See Install Architecture Explorer for the full response schema.

​
Poll for installation status

Installation takes 1-3 minutes depending on the workspace image. Poll until the status is installed. 
while true; do
  STATUS=$(curl -s https://api.rigbox.dev/api/workspaces/$WORKSPACE_ID/tools/architecture-explorer/install-status \
    -H "Authorization: Bearer $RIGBOX_API_KEY" | jq -r '.status')
  echo "Status: $STATUS"
  [ "$STATUS" = "installed" ] && break
  sleep 5
done
See Installation Status for the response schema.

​
Installation complete

Once installed, Architecture Explorer is ready to launch.

​
Launching Architecture Explorer

After installation (or immediately on the full image), launch the tool. 
curl -X POST https://api.rigbox.dev/api/workspaces/$WORKSPACE_ID/tools/architecture-explorer/launch \
  -H "Authorization: Bearer $RIGBOX_API_KEY"
See Launch Architecture Explorer for the response schema.

​
Accessing the Visualization

Once launched, Architecture Explorer serves a Vite development server on port 5174 inside the workspace. It’s accessible at: 
https://arch-{workspace-id}.rigbox.dev
Open this URL in your browser to interact with the visualization.
The arch- prefixed subdomain is created automatically when you launch Architecture Explorer. You don’t need to create an app route manually.

​
What you’ll see

The visualization includes:
  • Project overview — list of all detected projects with their type (Rust crate, Node.js package)
  • Dependency graph — interactive node graph showing how modules connect
  • File tree — expandable tree view of the analyzed directory structure
  • Call graph — for Rust projects, trace handler functions through layers of business logic
  • Search — find specific modules, functions, or files across all analyzed projects

​
Stopping Architecture Explorer

When you’re done, stop the tool to free up resources. 
curl -X POST https://api.rigbox.dev/api/workspaces/$WORKSPACE_ID/tools/architecture-explorer/stop \
  -H "Authorization: Bearer $RIGBOX_API_KEY"
See Stop Architecture Explorer for details.

​
Complete Example: Analyze a Rust Project

This walkthrough clones a Rust project into a workspace and visualizes its architecture. 1. Create a workspace with the full image 
import requests
import time

API_URL = "https://api.rigbox.dev/api"
HEADERS = {"Authorization": f"Bearer {api_key}"}

# Quick deploy with the full template (Architecture Explorer pre-installed)
workspace = requests.post(
    f"{API_URL}/quick-deploy",
    headers=HEADERS,
    json={"template_id": "full"},
).json()

workspace_id = workspace["workspace"]["id"]

# Wait for the workspace to be running
while True:
    ws = requests.get(
        f"{API_URL}/workspaces/{workspace_id}",
        headers=HEADERS,
    ).json()
    if ws["vm"]["status"] == "running":
        break
    time.sleep(2)

print(f"Workspace running: {workspace_id}")
2. Clone your project SSH into the workspace and clone the repository you want to analyze: 
git clone https://github.com/your-org/your-rust-project.git
3. Launch Architecture Explorer 
requests.post(
    f"{API_URL}/workspaces/{workspace_id}/tools/architecture-explorer/launch",
    headers=HEADERS,
)
print(f"Launched — open https://arch-{workspace_id}.rigbox.dev")
4. Explore the visualization Open https://arch-{workspace_id}.rigbox.dev in your browser. Architecture Explorer will scan the cloned project, detect Cargo.toml, and build the dependency and call graphs. 5. Stop when done 
requests.post(
    f"{API_URL}/workspaces/{workspace_id}/tools/architecture-explorer/stop",
    headers=HEADERS,
)

​
Tips

For the fastest experience, use the full template. Architecture Explorer is pre-installed and ready to launch immediately — no installation wait.
Architecture Explorer works best with well-structured projects that have clear module boundaries. Flat file structures with hundreds of files in one directory produce less useful visualizations.
Architecture Explorer consumes CPU and RAM while running. If your workspace has limited resources (e.g., 512 MB RAM), consider stopping other services before launching.

​
Next Steps