GitDepth documentation

How do I visualize a GitHub repository?

Open the app and paste the repository's URL, then choose Analyze codebase. Or use the shortcut: replace github.com with gitdepth.com in the repository's address. github.com/owner/repo becomes gitdepth.com/owner/repo, which opens the app and starts the analysis straight away. Deeper links such as /tree/main/src work too — the whole repository is analyzed.

Can I analyze code that isn't on GitHub?

Yes. In the app, choose Upload folder to pick a local folder, or Upload ZIP for a zipped project. This is also how to map private code: only public repositories can be analyzed by URL.

What happens during an analysis?

GitDepth clones the repository (a shallow clone of the default branch) or unpacks your upload, walks the project file by file with live progress, and builds a graph of every symbol and connection it finds. When it finishes, the code map opens. Repositories you've analyzed appear under Recent in the app, and reopening one reuses the existing analysis while the server still has it.

Which languages does GitDepth support?

Python (.py) and JavaScript/TypeScript (.js, .jsx, .ts, .tsx, .mjs, .cjs). Other files are skipped. No build step, install, or configuration is needed.

Connections are calls between symbols, imports between files, JSX renders (a component rendering another), and the database and network calls above. A call is matched to a symbol in the same file, to something it imports, or — when the name is unique across the project — by name; a call that can't be matched confidently is left out rather than guessed.

What am I looking at?

• Folders are shaded regions, nested the way your project is. Click a folder's name to zoom into it.
• Files are cards. The colored stripe along the top shows the mix of symbol types inside.
• Symbols are chips inside their file, in source order, colored by type: function, component, class, API route, database call. A ring marks an entry point, a dashed outline marks unused code, and the small bars show complexity (branching and length).

Why does the map change as I zoom?

Detail follows zoom so the map stays readable at any size. Zoomed out, you see folder names; zoom in and file names appear, then a mosaic of symbols, then readable symbol names. Labels never pile on top of each other — the ones that don't fit at the current zoom wait until there's room. A location bar shows which folder and file you're in, with an Overview button to zoom back out.

Hover any symbol, file, or folder for details. The Map key in the corner explains every color and shape, and the search bar jumps straight to any symbol by name.

How do I see what calls a function?

Click it. Everything that leads to it lights up in orange (used by), everything it goes on to call lights up in blue (uses), and the rest of the codebase fades back. Its direct connections are drawn strongly; connections further along the chain are faint. A summary bar shows the counts, and Esc clears the trace.

Clicking a file traces its imports instead: which files it imports and which files import it.

How does GitDepth find dead code?

A function, class, or component is marked unused when nothing else in the parsed code calls or renders it, and it isn't an entry point. Turn on Dead code only in the filters to fade everything else; each file with unused code gets a badge, and the sidebar lists every unused symbol so you can jump to it.

Is everything it flags safe to delete?

Not necessarily — treat the list as candidates to review. Static analysis can't see code that is only reached dynamically (by name lookup, reflection, or getattr), registered with a framework (signal handlers, plugins, CLI commands), called from tests or from outside the repository, or part of a library's public API.

Which parts of the codebase depend on each other?

Turn on Folder dependencies under View in the filters. Arrows run from each folder to the folders whose code it calls or imports; thicker arrows and the number on each mean more connections. Zoomed out you see dependencies between the top-level folders, and zooming in splits them into subfolders. Only the strongest links are drawn, so large projects stay readable.

What is Story View?

Story View explains a codebase in plain English, for anyone — including people who don't read code. It finds the main journeys through the code, each starting from a place where the code begins doing something (an API route, a page, a command), and describes every step in plain language. When a codebase has few such entry points — common in libraries — journeys also start from public functions that nothing else in the project calls.

How do I use it?

Switch to Story View at the top of the app. Pick a journey from the list to read it as a numbered outline — indentation shows which step leads to which — with each step's location in the code and any smaller steps folded into it. Play this journey starts a guided tour (Space pauses, ← → step, Esc exits), and Tour the whole app plays the opening steps of every journey. Journeys are kept to at most 30 steps so each one stays readable. Story View needs an AI key (see below).

Can I ask questions about the code?

Yes. Open Ask GitDepth and ask in plain English — for example, "how does checkout work?" Answers are grounded in the parsed code, and the parts of the code the answer refers to light up on the map. In Story View, answers also point you to the matching journey. The assistant uses your AI key.

Which features need an API key?

Only the AI features: plain-English symbol summaries, Story View, and the chat assistant. Parsing, the code map, tracing, search, filters, folder dependencies, and export all work without a key.

Which AI providers can I use?

Groq, OpenAI, or any OpenAI-compatible endpoint, chosen in AI Settings. Groq offers a free tier. You use your own key so usage runs on your own account; GitDepth doesn't charge for or resell AI usage.

Where is my key stored?

Only in your browser's local storage. When you use an AI feature, the key and the relevant code or question pass through GitDepth's server to your provider for that single request and are never written to disk.

• Only public GitHub repositories can be analyzed by URL; clones never use stored Git credentials.
• A clone that takes longer than 2 minutes is stopped — very large repositories may need a ZIP of the part you care about.
• Files larger than 512 KB are skipped.
• ZIP and folder uploads are limited to 100 MB, and a project can have at most 10,000 source files and 100 MB of source code. Folder uploads only send source files — dependencies, build output, and assets stay on your computer.
• These folders are skipped: node_modules, .git, venv, .venv, env, dist, build, __pycache__, .next, .turbo, coverage, .pytest_cache, target, .idea, .vscode, vendor, and other hidden folders. Only source files are kept on the server; everything else in a clone or ZIP is discarded.
• By default each IP address can make 20 requests per hour, counted across new analyses and AI requests (summaries, Story View, chat). Opening the map, tracing, and filtering don't count.
• Analyses are temporary: an analysis is available for up to 24 hours, and the server may forget it sooner if it restarts.

Is my source code stored?

Only temporarily. Submitted code is cloned or extracted into a per-analysis folder on the server, used only to build your map and answer your questions, and deleted automatically within 24 hours. There are no accounts and no cookies; GitDepth counts anonymous pageviews without identifying you. The Privacy Policy has the details.

Export PNG saves an image of the current view. Export JSON downloads the full parsed graph — every symbol with its type, file, line range, and complexity, and every connection — for use in your own tools.