The universal terminal operating layer that bridges GUI and CLI across every platform. Translate human intent into system execution while preserving terminal power-user control.
One system that unifies terminal workflows across every interface, every platform, every deployment mode.
nexus --setup.render() preview, secret-masked credential fields, cross-field search, JSON export/import. Reachable 4 ways: g hotkey · : palette · nexus --configure-modules · nexus-cli config modules.pip install nexus-terminal
nexus
git clone https://github.com/matx104/nexus && cd nexus
pip install -e .
docker run -it --rm matx104/nexus:latest
Jump into the interactive playground and explore NEXUS commands in your browser.
Every feature designed to preserve power-user control while making the terminal accessible to everyone.
Unified discovery engine. Auto-scans builtin and user modules. Handles caching, user prefs, enable/disable, per-module settings. Single source of truth for all interfaces.
from nexus.modules import get_registry
registry = get_registry()
registry.discover() # Finds 1,358 modules
for m in registry.get_all_manifests():
print(f"{m.icon} {m.name}")
Parse → Explain → Confirm → Execute → Result. Risk scoring with safe/caution/dangerous levels. Dry-run mode. Context memory for smart suggestions.
"X then Y"docker ps --format tableeDEX-UI inspired. Panel zones with resizable ratios. Module browser with category search across 1,358 modules. 11 border styles. 19 themes synced via unified engine.
┌──────────┬──────────────┬──────────┐
│ LEFT │ CENTER │ RIGHT │
│ Sys Mon │ World Map │ Network │
│ CPU │ Processes │ Weather │
│ RAM │ Files │ Calendar │
├──────────┴──────────────┴──────────┤
│ BOTTOM ─ Terminal / Keyboard / Audio│
└───────────────────────────────────┘
Per-module permissions: NETWORK, FILESYSTEM, PROCESS, SHELL. SafeMode levels. Policy engine with audit logging. Organization mode with role-based access.
ModuleManifest(
id="network-scanner",
name="Network Scanner",
permissions=[
Permission.NETWORK,
Permission.PROCESS,
],
category="secops",
)
Every action accessible from the keyboard. No mouse required.
NEXUS isn’t just a terminal emulator. It’s an operating layer.
| Feature | NEXUS | tmux | Warp | eDEX-UI | btop |
|---|---|---|---|---|---|
| Module system (1,358+) | ✓ | — | — | — | — |
| Intent engine (NLP) | ✓ | — | ~ | — | — |
| Theme engine (14+) | ✓ | ~ | ✓ | ~ | ✓ |
| 5 interfaces (Rich TUI/Classic/CLI/Web/Desktop) | ✓ | — | — | — | — |
| GUI with GLSL shaders | ✓ | — | — | ✓ | — |
| MCP / AI integration | ✓ | — | ~ | — | — |
| System monitoring | ✓ | — | — | ✓ | ✓ |
| Cross-platform (Win/Mac/Linux) | ✓ | ~ | ~ | ✓ | ✓ |
| Plugin / extension API | ✓ | ~ | — | — | — |
| Organization / multi-user mode | ✓ | — | ✓ | — | — |
| Permission model & sandboxing | ✓ | — | — | — | — |
| Open source & free | ✓ | ✓ | — | ✓ | ✓ |
Every module auto-discovered by the registry. Available across all 5 interfaces. Filter by category or search.
Every module available everywhere. The registry is the single source of truth.
$ nexus
$ nexus --classic
$ nexus-cli
$ cd desktop && npm run dev
$ nexus-mcp
Every theme is a frozen dataclass with 20 color attributes. Auto-syncs across Rich TUI, Tauri desktop, and Web (CSS variables). The 4 armory-* palettes are byte-for-byte identical to the Armory project's sovereign palette — switch in one tool, change in all of them.
from nexus.core.theme import set_theme, get_theme
set_theme("synthwave")
theme = get_theme()
# Use in any interface
theme.accent # "#FF00FF" — Rich, CLI
theme.to_css() # "--nx-accent: #FF00FF; ..."
Python-native. Rich TUI. Module registry as single source of truth. Zero-config module discovery.
nexus/modules/builtin/ → auto-discovered everywhere. No imports to update, no configs to wire.render() returns Rich’s RenderableType. CLI prints it, TUI panels it, GUI converts it, Web serializes it.subprocess.run(), psutil, urllib. shutil.which() detects tools. No demo data — graceful “not installed” messages.12-phase master plan. All phases complete.
All phases complete. Here’s where the community can take NEXUS next.
71 screenshots across all themes, modules, and interfaces. All tests passed.
Live demonstration of NEXUS in action with system monitoring, network stats, and active modules.
All 1,358 modules discovered automatically across 10 categories with zero configuration.
All 19 themes tested with complete color palettes and visual consistency.
Sample modules demonstrating real functionality across all categories.
Full-featured CLI for scripting and automation.
Try NEXUS commands in your browser. No installation required. This is a simulated terminal that mirrors the real NEXUS experience.
do "your intent" to simulate the NLP intent pipeline. Parses, explains, and scores risk for any command.Want the real thing?
Two integration surfaces: the Python Module API for building modules, and the MCP Server for AI assistant integration.
Every module inherits from BaseModule and implements 5 methods. The registry discovers it automatically.
ModuleContext with config, settings, and runtime info. Store context for later use.RenderableType (Panel, Table, Text, Group, etc.). Called by every interface: CLI prints it, TUI panels it, GUI converts it, Web serializes it to JSON.intent_patterns. Return a string result or None to decline.from nexus.modules.base import BaseModule, ModuleContext
from nexus.modules.manifest import ModuleManifest, Permission
from rich.panel import Panel
class MyModule(BaseModule):
def get_manifest(self):
return ModuleManifest(
id="my-module", name="My Module",
version="1.0.0", author="you",
description="What it does",
permissions=[Permission.NETWORK],
category="tools", icon="🔧",
)
def initialize(self, ctx: ModuleContext):
self._ctx = ctx
def render(self):
return Panel("Hello from my module!")
def on_intent(self, text):
return f"Handled: {text}"
def cleanup(self):
pass
| Field | Type | Required | Description |
|---|---|---|---|
id | str | ✓ | Unique ID: [a-z0-9-] only |
name | str | ✓ | Human-readable display name |
version | str | ✓ | Semver version string |
author | str | ✓ | Author name |
description | str | ✓ | What the module does |
permissions | list[Permission] | NETWORK, FILESYSTEM, PROCESS, SHELL | |
supported_os | list[str] | windows, linux, macos | |
ui_surfaces | list[UISurface] | PANEL, MODAL, OVERLAY, STATUSBAR | |
intent_patterns | list[str] | Glob patterns for NLP matching | |
category | str | ✓ | One of 10 lowercase categories |
icon | str | Emoji or character icon | |
tags | list[str] | Searchable tags |
NEXUS exposes all capabilities to AI assistants via Model Context Protocol. Supports stdio and HTTP transport.
The web dashboard exposes 6 REST endpoints for programmatic access. Start with nexus --web.
?category= filter and ?search= query.{"text": "show docker containers"}. Returns parsed command, risk, and explanation.# List all secops modules
curl http://localhost:8080/api/modules?category=secops
# Run a specific module
curl -X POST http://localhost:8080/api/modules/network-scanner/run
# Process an intent
curl -X POST http://localhost:8080/api/intent \
-H "Content-Type: application/json" \
-d '{"text": "check disk usage"}'
# Get all themes
curl http://localhost:8080/api/themes
The 5-stage NLP pipeline that transforms natural language into safe system execution.
on_intent(). Timeout and error handling built in.from nexus.intent import IntentEngine
engine = IntentEngine()
# Simple intent
result = engine.process("show docker containers")
print(result.command) # "docker ps --format table"
print(result.risk) # RiskLevel.SAFE
print(result.explanation) # "Lists running Docker containers"
# Chained intents
result = engine.process("stop nginx then check port 80")
# Resolves to two commands with risk scoring on each
# Dry-run mode
result = engine.process("rm -rf /tmp/cache", dry_run=True)
print(result.risk) # RiskLevel.DANGEROUS
print(result.would_execute) # False (dry-run)
NEXUS is MIT-licensed and built in the open. Every contribution makes the terminal better for everyone.
nexus/modules/builtin/. Inherit from BaseModule, implement 5 methods, and it’s auto-discovered across all interfaces. See the API docs for the full interface.NexusTheme frozen dataclass to nexus/core/theme.py. Define 20 color attributes and it auto-syncs to TUI, GUI, and Web via the unified engine.nexus doctor output.nexus/tools/. Each tool is a standalone script auto-discovered by the CLI. 44 tools ship today — there’s room for more.docs/. The User Guide, Quick Start, and Plugin Development guides all welcome improvements and examples.BasePlugin in nexus/plugins/community/. Build integrations for services NEXUS doesn’t cover yet.git clone https://github.com/matx104/nexus && cd nexus
python -m venv .venv && source .venv/bin/activate
pip install -e ".[dev]"
python -c "from nexus.modules import get_registry; r = get_registry(); r.discover(); print(f'{len(r)} modules')"
nexus
| I want to… | Look here | Base class |
|---|---|---|
| Build a module | nexus/modules/builtin/ | BaseModule |
| Build a plugin | nexus/plugins/community/ | BasePlugin |
| Add a CLI tool | nexus/tools/ | Standalone script |
| Add a theme | nexus/core/theme.py | NexusTheme |
| Add a shell adapter | nexus/shell/ | ShellAdapter |
| Modify the TUI | nexus/interactive_tui.py | Textual App |
| Modify the desktop app | desktop/src-tauri/ · desktop/src/ | Tauri (Rust) + Electron fallback |
| Modify the Web API | nexus/web/api.py | HTTP handlers |
| Modify the MCP server | nexus/mcp/ | MCP handlers |
Ready to build?
NEXUS sits on top of ARMORY — the Bash bootstrap system that installs 250+ CLI tools. Together they form a complete terminal operating stack.
Python/Rich + Ink • 1,358 modules • 19 themes • 6 interfaces
The Experience LayerBash • 96 toolpacks • 554 tools • 7 profiles • 642 lore scripts
The Foundation Layerarmory modules enable devx,cloud,k8s
CLI tools like kubectl, terraform, lazygit are installed system-wide.
shutil.which("kubectl")
Each NEXUS module checks for its backing tool at startup.
nexus --classic
NEXUS renders tool output in themed panels with intent processing.
| ARMORY Toolpack | Key Tools | NEXUS Modules |
|---|---|---|
| functional | htop, ncdu, curl, git, tmux | htop-processes, neofetch-sysinfo, byobu-sessions |
| devx | lazygit, bat, delta, gh, fzf | lazygit-tui, fzf-finder, bat-viewer, git-extras-info |
| cloud + infra | aws-cli, terraform, ansible, pulumi | aws-ec2, terraform-plan, ansible-runner, pulumi-stack |
| k8s | kubectl, helm, k9s, stern, kubectx | k8s-dashboard, helm-manager, stern-logs, kubectx-switcher |
| security | nmap, trivy, nikto, snyk, hydra | port-scanner, vuln-scanner, nikto-scanner, snyk-scanner |
| observability | btop, glances, prometheus, jaeger | btop-monitor, glances-monitor, prometheus-query, jaeger-tracing |
| modern-unix | eza, dust, duf, procs, doggo | eza-ls, dust-usage, duf-disks, doggo-dns |
| entertainment | cmatrix, figlet, fortune, cbonsai | cmatrix-display, figlet-banner, cbonsai-tree, pipes-animation |
| databases | pgcli, mycli, litecli, redis, neo4j | pgcli-console, mycli-console, litecli-console, neo4j-client |
| gitops + mesh | flux, argocd, istio, linkerd, cilium | flux-status, istio-mesh, linkerd-mesh, cilium-status |
| containers | docker, podman, docker-slim, hadolint | docker-dashboard, docker-slim-optimizer, hadolint-checker |
| web + ai | node, vite, hugo, litellm, mlflow | node-runtime, vite-builder, hugo-site, litellm-gateway, mlflow-tracker |
# Install ARMORY first (the foundation)
git clone https://github.com/matx104/armory ~/armory
cd ~/armory && ./bootstrap.sh
# Enable toolpacks
armory modules enable functional,devx,cloud,k8s,security
# Install NEXUS via ARMORY bridge
armory nexus install
# Launch NEXUS
armory nexus launch # Interactive TUI
armory nexus launch classic # Dashboard
armory nexus launch web # Browser at localhost:8080