SeleneCode Install

Performance

Amazing performance on every project we measured.

SeleneCode is a Rust binary with an embedded graph database, built so an agent gets its answer faster than it could open a single file. Indexing beats the TypeScript engine SeleneCode replaced, a graph traversal takes milliseconds, a complete answer takes a fraction of a second, and every answer costs a small fraction of the tokens of reading the files it distils. Every figure on this page was measured, and names the document it was read from.

1.5×faster indexing than the engine it replaced, selene-crates corpus
1.2–4.4 msper multi-hop graph traversal, 20,000-node fixture
0.18–0.45 sper complete answer once the daemon is warm
52×fewer tokens than reading the files, measured on every answer

What that means for your agent

One call, not twenty

An explore answer carries the call path, the verbatim source, and the affected code together: the reading an agent would otherwise do file by file, delivered in one round trip and priced in tokens at the bottom of every answer.

Ready before you finish typing

Opening an existing index costs about 80 ms on a 344-file project. On macOS and Linux a daemon keeps it open while your agent is connected, so the second question never pays even that.

Fresh without a rebuild

selene sync re-indexes only the files that changed. Git hooks run it after every commit, merge, and checkout, and the daemon watches your files while you work, so the graph your agent reads is the code you have right now.

SeleneCode vs Graphify

Graphify is the best-known way to give a coding assistant a knowledge graph of a repository. Here is where SeleneCode goes further, on what each project's own documentation says.

AspectSeleneCodeGraphify
RuntimeOne static Rust binary. Nothing else to install.A Python package: uv tool install graphifyy
Where the graph livesAn embedded graph database with indexed queriesA JSON file (graph.json) built with NetworkX
Answer time0.18–0.45 s per complete answer; 1.2–4.4 ms per traversalNot published
Model calls while indexingNone, for anything: code, documents, PDFs, Word files, and configNone for code; documents, PDFs, images, and video "route through your IDE session's model"
Keeping the graph currentIncremental sync of changed files, git hooks on commit, merge, and checkout, and a file watcher while your agent is connectedA git hook that rebuilds on commit and on branch checkout
Indirect callsCallbacks, event emitters, React and JSX renders, and framework routes bridged end to end, each marked as dynamic in the answerEdges tagged extracted or inferred
One question, one answerexplore returns the call path, the verbatim source, and the affected code in one callquery_graph, get_node, shortest_path, get_pr_impact
Graph accuracy gateA gate holds cross-file resolution to the reference engine's edge identity at tolerance 0No edge-level accuracy gate published; its benchmarks report task-level answer coverage instead

Swipe sideways to see both columns.

Graphify facts are quoted from its own documentation as read on 2026-09-12. "Not published" means no figure was found there.

How we measure

Indexing is timed as a cold, full selene index of the same source-only corpus by each tool, best of three runs on the same machine; the selene-crates corpus was measured on 2026-09-09, and 1.5× faster is 5,228 ms against 3,468 ms. Faster never meant resolving less: a gate holds the Rust resolver to the reference engine's edge identity at tolerance 0, so the same cross-file references are found with the same endpoints.

The traversal band is corridor traversal (following one narrow chain of calls, hop by hop) at depth 3 to 5 and 15-hop path-finding on a synthetic fixture of 20,000 nodes and 102,008 edges, where every step is one batched query over the whole frontier, never a query per node. The answer time is selene explore on a 344-file project with the daemon warm, calls 3 to 6 of a session. The token figure is what every answer prints at its end, computed from the indexed sizes of the files it distils; the README's example answer is 5,000 tokens for 75 files totalling 237,000.