Synapse

Inspiration

Codebases are becoming more vibecoded by the day—(em dash) half human, six-sevenths AI, and glued together at 2 am. It’s never been easier to drown while trying to understand one. You clone a repo, open main.py, try to make sense of it... And then give up and let Claude explain it while you burn through precious tokens and time.

What it does

Drop in a GitHub URL, an archive, or even a single file. We parse it with tree-sitter, currently in Python, JS/TS, Java, Go, and Swift, easily expandable to more, and stitch every function, call, and branch into one unified graph, even across languages.

From there:

Zoom from whole-architecture clusters down to a single call site.
Click a function to light up everything it calls and everything that calls it — instant impact analysis.
Spot dead code and hot paths that would normally hide in the noise.
Ask the built-in AI to explain any function, path, or cluster in plain English, anchored to whatever you just clicked.

How we built it

The core is a tree-sitter parser feeding into our own IR compiler (we're on v3 - more on that below). Each language's AST gets walked and reduced to one common shape: a graph of nodes and edges. On top of that we run a clustering pass that groups nodes by filesystem tree and scores each one by importance, so the layout doesn't collapse into spaghetti when you throw a real repo at it. For the AI side we used Llama. It is good enough to summarise a function or explain what a cluster of nodes is doing, without locking us into a paid API. Repos clone into a temp dir, graphs live in memory, and a lightweight cache keeps already-parsed repos and AI summaries warm so you're not paying the parse cost twice.

Challenges we ran into

Cross-language call resolution. Each tree-sitter grammar has its own node types. Mapping function_definition (Python) and method_declaration (Java) and arrow_function (JS) into a single IR took three rewrites. Thats why the ir_compiler is a v3.
Graph layout at scale. A 50k-node graph rendered naively is unreadable soup. Clustering by directory and scoring node importance was the breakthrough that made large repos legible.
Demo polish under deadline. The landing page, sample repo flow, and inspector all got rebuilt in the final stretch.

Accomplishments that we're proud of

Clustering + importance scoring that makes thousand-node graphs feel navigable.
End-to-end: paste a repo URL → first interactive graph in seconds.
A genuinely multi-language graph — not five tools glued together, one IR.

What we learned

Graphs are a UX problem, not a data problem. Computing the edges is easy; making 10,000 of them readable is the actual work.
AI is best when it doesn't do everything. The less AI the more elegant the solution.