Everything gitplex does, and how to use it

1. 1

   Paste a repository

   Type owner/repo, paste a full URL like https://github.com/psf/requests, or a branch or tag URL like …/tree/v2.32.0. Or pick one of the example chips under the box.
2. 2

   Choose how much detail

   Architecture Map (press 1) for files and imports, or Full Code Graph (press 2) for every function, class and call. Press Enter to launch. Nothing starts until you do.
3. 3

   Watch it map, then explore

   The scan screen shows each stage with a timer. When it finishes, the explorer opens on the graph. Click any node to start.

You can map the same commit both ways. Each detail level is cached on its own, so switching from the map to the full graph runs a real second pass instead of reusing the first.

Node size follows centrality: the more of the codebase flows through a node, the bigger it is. An entry point carries an extra ring in the signal colour.

Edges

At rest, every edge is a quiet line so the shape stays readable. Select or hover a node and its edges light up, tinted by type.

Evidence and confidence

Every relationship records how it was found and how sure the parser is. Inferred edges are drawn as thinner curves; direct ones are straight.

Double-click a node to expand its neighbours onto the canvas. Right-click for more: zoom to it, set it as a path end, or copy a deep link to it.

Structure

The repository's folders and files, each with file counts and a bar showing its share of the code. Hover a folder for two actions: scope limits the graph to that folder, and the export icon writes just that folder up as Markdown.

Filters

Toggle node types and edge types on and off. Each chip shows how many of that type the repository has, in the same pattern the canvas uses.

Node budget

How many nodes the canvas draws, from 50 to 1,000 (300 by default). The most important nodes come first. When a view is trimmed, the toolbar shows capped: raise the budget, scope to a folder, or expand a node to see more.

gitplex checks package manifests, conventional filenames (main.py, manage.py, asgi.py, cli.py and friends), framework imports, detected routes, and graph centrality. Each hit is ranked, and the inspector tells you exactly why it was chosen. Open the Entry points section in the left rail to jump to one.

The wave follows real dependencies in reverse: whatever IMPORTS, CALLS, INHERITS, IMPLEMENTS, EXPOSES or TESTS the node, up to three hops out. Structure (DEFINES, CONTAINS) is left out: changing a function doesn't break the folder it lives in.

The readout counts dependents per hop, so you can see how far a change reaches and which code a reviewer should read first. Click empty canvas to clear it.

Press Copy on the readout to take the result with you: Markdown lists every dependent grouped by hop, with its file and line, ready for a pull request or a coding agent; JSON gives the same for scripts.

1. 1

   Select the first node

   Then press Path start in the inspector, or right-click it and choose Set as path start.
2. 2

   Select the second node

   Press Path end. The path lights up on the canvas.
3. 3

   Read the chain

   The path panel lists every hop and the relationship that carries it, and the camera frames the route. Copy it as Markdown or JSON, or clear it with ×.

Any two nodes work: a file and a function, a class and a route, two functions. Paths are searched up to six hops, following each edge in either direction, because a real route through code often goes up an import and down a call. Routes through real relationships are preferred; one that only climbs through a shared folder is used when nothing else connects the two.

Results come from a BM25 index over names, docstrings and source, combined with what the graph knows: centrality, closeness to an entry point, exact-name matches and test affinity. Each result shows its own score breakdown, so the ranking is something you can check.

Ranking modes

The palette has three modes in its top-right corner. hybrid (the default) blends text relevance with the graph signals. bm25 ranks by text alone, which is best when you know the exact words. graph ranks by structure, putting the most central matching nodes first.

Scope a search with a prefix

So function:parse returns only functions, where parse alone also finds matching files.

Hold Z to peek through it, and let go to return. To keep it on, use the Lens button in the toolbar.

Press Tour in the header. Each stop says what you're looking at and why it was chosen. It plays itself every seven seconds; use ← and → to move, Space to pause, and Esc to leave. Treat it as a suggestion: the order comes from structure, not from the authors.

Trivia and progress

The progress chip in the bottom-left counts the files you've opened and the discoveries you've made, like your first blast radius or your first path. When you know the place, take the five-question trivia from the same chip; every answer comes from the graph.

1. 1

   Open Export

   From the header for the whole repository, or from a folder's export icon in the Structure tree.
2. 2

   Choose what goes in

   Keep or drop functions and classes, and import relationships. The preview updates as you change them.
3. 3

   Copy or download

   You get one Markdown document with the structure, what each file defines, and how the files depend on each other.

The explorer lives at /repo/owner/repo. To point someone at one node, right-click it and choose Copy deep link; the link opens the explorer with that node selected.

Maps you open are remembered in this browser. The landing page lists them under Continue, and the repository name in the explorer header is a switcher to jump between them. An expired one shows “map again”.

Maps are kept for a day. If someone opens a link after the map has been cleared, they see a “not mapped yet” screen with a button to draw it again, which takes a few seconds for most repositories.

The moon and sun button switches the theme. The accent bubbles (on the right edge of the site, or in the explorer header) recolour everything that uses the signal colour: buttons, pulses, and the graph's node tones. Choose from four, named after Pokémon types: Grass (parrot green), Psychic (rose), Water (sky blue) and Fire (orange). Both choices are remembered in this browser.

1. 01Queued
2. 02Cloning repository
3. 03Scanning files
4. 04Parsing syntax trees
5. 05Building the code graph
6. 06Building the search index
7. 07Deriving entry points

The repository is cloned shallow with no working tree, or read straight from GitHub for an Architecture Map. tree-sitter parses every file, and a per-language extractor walks the syntax tree. Imports, calls and inheritance are either resolved or recorded as unresolved, never guessed, and a call never resolves to code in another language. The graph is stored in FalkorDB, and search is a BM25 index combined with graph signals.

Results are pinned to the exact commit shown in the header and cached by commit and detail level, so mapping a repository twice doesn't redo the work.

In a mixed repository each file gets its own language's treatment, so a Python backend with a TypeScript frontend is mapped in full on both sides. A call in one language never resolves to code in another. For a repository in a files-and-imports language, choosing Full Code Graph gives the same graph as the Architecture Map, so pick the map and skip the clone.

There are no accounts and no tracking beyond the optional feedback button. Code is read to build the map and isn't sent anywhere else: no language model sees it.

Which branch does it analyse?

The repository's default branch, unless you paste a /tree/<branch-or-tag> URL. The commit badge in the header is the exact commit the map is pinned to.

Why does my Rust, C# or Kotlin repository show only files?

Those languages are in the files-and-imports tier: gitplex maps the files and what imports what, but doesn't extract functions, classes or calls yet. Python, JavaScript, TypeScript, Go and Java get the full graph.

Why is a relationship missing?

It was either unresolvable from the code alone (dynamic imports, reflection, calls through variables), or it's outside the node budget. Check the inspector's relationship list, or raise the budget.

Why does an edge say inferred?

It was matched by name rather than proven through an import. It's usually right; the evidence label tells you how much to trust it.

Can it map private repositories?

Not today. gitplex only reads public repositories, and it never asks for a token.

Does search run Cypher queries?

No. Search is a BM25 index built during analysis and combined with precomputed graph signals. Cypher is used for node lookups, neighbourhoods and paths.

Still stuck? Use the feedback button, or open an issue on GitHub.