SeleneCode parses your codebase into an embedded graph — every symbol, every call, every dynamic-dispatch hop — and serves it to AI agents over MCP. One structural question, one call, zero file reading. A single static binary; nothing ever leaves your machine.
$ curl -fsSL https://selenecode.com/install.sh | sh
Every session, every agent, re-derives the same structure: grep, read, guess, read again. Selene computes it once — deterministically, from the AST — and answers flow questions with the verbatim source, the call path, and the blast radius, together.
❯ selene explore "how does a request become a database write" ## Context for: how does a request become a database write Found 42 relevant symbols across 1,214 indexed files. ### Flow 1. handle_request (src/api/routes.rs:88) 2. validate_payload (src/api/guard.rs:41) 3. Store::persist (src/db/store.rs:203) *(dynamic ~0.8)* ### Blast radius — 17 symbols across 6 files ### Source — verbatim, line-numbered, safe to edit from … Token economy: this answer ≈ 5k tokens; the 75 files it distills total ≈ 237k tokens — 52× less than pulling them into context.
Scanner, extraction, resolver, graph engine, MCP server — every crate is
Rust, compiled to one static binary with the database inside it: SurrealDB
embedded on RocksDB, full-text index included. That store opens in
about 80 ms on a
344-file index, and on macOS and Linux the daemon holds it warm, so your agent's
second question never pays it again. The one part that isn't Rust — the galaxy UI — ships
pre-built into a single HTML file the binary carries, so cargo build never
needs Node, and neither do you.
How to read these. What was timed is a cold, full
selene index of the same source-only corpus by each tool, and lower is faster:
0.66× means SeleneCode finished that index in 66% of CodeGraph's wall time — best-of-3, same
machine (selene-crates and django measured 2026-09-09; codegraph-src's 0.77× is the older
2026-07-17 window and has not been re-run). Faster never meant resolving less: a gate holds
the Rust resolver to the TypeScript engine's edge identity at tolerance 0 over an
18-project corpus. django measured 1.03× in the previous window, so the medium corpus reads as at
parity — unresolved either way until a counter-balanced A/B says otherwise. VS Code scale
has not been re-benchmarked since these optimizations. The millisecond band is corridor
traversal and path-finding on the Phase-1 synthetic fixture, not hub-rooted queries, which are
bound by result size.
selene index and selene sync never call a model, and a stock
binary cannot reach one at all — the LLM crate is an optional dependency behind a feature
that is off by default. Extraction itself is sync, with no async runtime on the path, and
its parallel fan-out commits in a fixed order — so the ids never depend on which thread
finished first.
Callers, callees, impact and shortest path are Rust walks whose every adjacency
expansion is one batched query over the whole frontier — never a query per node — so
a traversal costs O(depth) round-trip pairs however wide the frontier gets, and each node's
payload crosses the wire at most once per walk. On the Phase-1 benchmark graph — synthetic,
20,000 nodes and 102,008 edges — corridor traversal at depth 3–5 and 15-hop path-finding
land at 1.2–4.4 ms.
One crate touches the database; everything above it sees a single GraphStore
trait.
selene install -t auto finds every agent on the machine and wires them
all — eight targets across four
config formats (JSON, TOML, JSONC, YAML). It rewrites exactly the selene entry and
leaves every neighboring MCP server byte-identical; if the file will not round-trip
losslessly it refuses to write at all. Your ~/.claude.json stays yours.
Extraction is AST-derived — never LLM-summarized. Same code in, same graph out,
byte for byte. Gates hold it at tolerance 0.
Callbacks, event emitters, React re-renders, framework routes — the hops grep can't
follow are synthesized end-to-end, each marked with its confidence.
Markdown, rst, txt — and the extracted text of pdf/docx — become sections whose code-mentions are resolved. "Why was X chosen?" answers from your own docs.
selene viz renders your architecture as an interactive star map —
Louvain call-clusters as named constellations, god-nodes, rare bridges. One offline file.
Betweenness centrality finds the true bottlenecks degree can't see. Import cycles,
orphan modules, one-edge surprises — selene insights, for humans and agents.
selene diff HEAD~5 — what changed in the graph since a revision,
read straight from git objects. No checkout; your worktree is never touched.
Every exploration is journaled locally. A new session recalls where the last one dug — knowledge compounds instead of evaporating.
One static binary. Embedded database. Optional semantic search runs on local ONNX. No server, no API key, no telemetry — nothing leaves your machine, ever.
selene enrich is optional and additive: it turns the call
graph into a codebase you can actually tour — named Domains, the Flows that connect
them, a computed read-order, and a galaxy you can watch build live. Every pass ships a
real zero-LLM floor first; a model, if you point one at it, narrates instead of
templating.
❯ selene enrich Domains: 9 found (Louvain communities, named) Flows: 23 found (entry points, hop chains resolved) Tour: 11 stops, read-order computed … zero-LLM floor: 0 provider calls made, 0 needed ❯ selene doctor index fresh · synced 3m ago · 19,061 nodes enrichment fresh · 118 calls avoided by the graph provider none configured — structure-only
Louvain call-clusters become named Domains; entry points become Flows carrying
their resolved hop chain. Real names with zero LLM configured —
plug one in and it narrates instead of templating.
selene tour computes the onboarding read-order from the graph
itself — the order to read the codebase in, not a hand-written README section.
selene viz --open renders a starship UI as one offline HTML file;
--watch serves it live on a local port. Five views share the rail —
Galaxy (the map), Systems (Domains as star systems), Logbook
(every ops/doc fact), Navigation (the path finder) and Mission (the
tour). Pick a symbol and its Dossier opens: source, relationships, each edge's
provenance.
Leave --watch open while an agent works: every new function or class
bursts into the map with a supernova animation seconds after it's written,
with a live index-size / RAM sparkline in the header.
Dockerfiles, compose, CI YAML, Makefiles, Cargo.toml/
package.json/pyproject.toml, Terraform, SQL, .env
— 13 formats, parsed at index time, with an edge from an env key straight to the
code that reads it.
--clear takes it backEnrichment is additive and index-time. selene enrich --clear removes
everything it added, and a gate holds the graph byte-identical to before it ran.
$ curl -fsSL https://selenecode.com/install.sh | sh
> irm https://selenecode.com/install.ps1 | iex
$ brew install mess69/selenecode/selene
> scoop bucket add selenecode https://github.com/Mess69/selenecode-releases
scoop install selene
Already on it? selene upgrade keeps it fresh —
selene upgrade --check just looks, selene upgrade 0.2.0 pins.
Pick your platform above — prebuilt, checksum-verified, no Rust, no Node, nothing to compile.
selene install — indexes the repo, installs git hooks that keep the graph
in sync, and registers the MCP server in Claude Code, Cursor, Codex, opencode…
Restart your agent and ask a structural question. It answers from the graph — verbatim
source, call paths, blast radius — instead of burning context on Read/Grep.
Code is parsed locally. The graph lives locally. The answers are deterministic. Nothing leaves your machine — ever.
the selene invariants · held by gates, not promises