Every codebase has a shape. Most of it stays undrawnNeedyNodes is a free, browser-based tool that turns a codebase into an interactive dependency map: folders become regions, files are laid out in the direction their imports run, and circular dependencies or dead exports are flagged automatically. Point at a file to see what it uses and what uses it, or double click it to see every file a change to it can reach. It parses JavaScript, TypeScript, Python, Go, Rust, Vue and Svelte, up to 1000 files per map. Nothing is uploaded: parsing runs entirely in the browser.Three ways to add code

Paste the URL of a public GitHub repository.

Drop files, or drag a whole folder onto the canvas.

Paste a snippet straight from the clipboard.

What it findsOnce the map is drawn it reports the file the rest of the project leans on, imports that run in circles, exports nothing uses, files that have outgrown themselves, and import chains that run too deep.Real projects, already mapped

How Zustand is structured: The state management library, all sixteen files of src. vanilla.ts sits at the centre and every middleware builds on it. (16 files; TypeScript)

How Vue's reactivity is structured: The thirteen files behind ref(), reactive() and computed(). The circles between them are real: that is how reactivity works. (13 files; TypeScript)

How the Svelte compiler is structured: Parse, analyze, transform. The three phases every .svelte file passes through, in 33 files of compiler. (33 files; JavaScript)

How Flask is structured: The Python web framework in 24 files: the app object, request context, routing and templating, small enough to take in at once. (24 files; Python)

Task Tracker (multi-language demo): Eleven files across TypeScript, Python, Go, JSON and CSS, built to show what a mixed-language project looks like on the canvas. (11 files; TypeScript, Python, Go, JSON, CSS)

How axios is structured: The HTTP client, the whole repo in 286 files with its tests and examples. lib/utils.js carries the library: a change to it can reach 43 files. The HTTP adapter is the biggest file by far. (286 files; JavaScript, TypeScript)

How FastAPI is structured: The Python web framework with its tests and scripts, 784 files, without the documentation's code samples. routing.py is the heart of it, at 6,553 lines. (784 files; Python)

How Gin is structured: The Go web framework, the whole repo in 110 files. context.go is the centre, and the top level and binding/ lean on each other. (110 files; Go)

How Express is structured: The Node web framework, the whole repo in 162 files, most of them tests and examples. The framework itself is six files in lib/, with no cycles anywhere. (162 files; JavaScript)

How ripgrep is structured: The fast search tool, its whole Rust workspace in 119 files across its crates and no cycles between them. The flag definitions are the biggest file, at 7,780 lines. (119 files; Rust)

How Hono is structured: The web framework for every runtime, the whole repo in 490 files of TypeScript: an adapter for each runtime and its benchmarks. src/types.ts is what everything leans on: a change there can reach 109 files. (490 files; TypeScript)

How fzf is structured: The command line fuzzy finder, the whole repo in 106 Go files with no cycles. terminal.go is the heart of it, at 8,934 lines. (106 files; Go)

How Redux is structured: The state container, the whole repo in 182 files, most of them examples and the website. The library itself is 17 files in src/, starting at src/index.ts. (182 files; TypeScript, JavaScript)

How bat is structured: The cat clone with syntax highlighting, its Rust source in 121 files without the sample files it highlights in tests. error.rs is what the rest leans on, and there are no cycles. (121 files; Rust)

How Rich is structured: The Python library for rich terminal output, the whole repo in 224 files without its benchmark results. console.py is the centre: a change to it can reach 49 files. (224 files; Python)

How requests is structured: The Python HTTP library, the whole repo in 52 files with no cycles. compat.py is what the rest leans on, and models.py is the biggest file of the library. (52 files; Python)

How Bubble Tea is structured: The Go framework for terminal apps, the whole repo in 129 files, 70 of them examples. tea.go is the centre, and there are no cycles. (129 files; Go)

How Cobra is structured: The Go library behind many command line tools, the whole repo in 41 files with no cycles. command.go is the centre of it, at 2,073 lines. (41 files; Go)

How fd is structured: The fast alternative to find, the whole repo in 32 Rust files with no cycles. config.rs is what the rest leans on: a change to it can reach 12 files. (32 files; Rust)

How Zod is structured: The TypeScript schema library, its whole monorepo in 562 files with v3 and v4 side by side. A change to v4/core/util.ts can reach 163 files, and core/schemas.ts is the biggest at 5,230 lines. (562 files; TypeScript)

How Fiber is structured: The Express inspired Go web framework, the whole repo in 414 files, most of them middleware. app.go stands out at twelve times a typical file here. (414 files; Go)

How Preact is structured: The small React alternative, the whole repo in 276 files: the core, its React compatibility layer, hooks and debug tools. src/constants.js is what everything leans on. (276 files; JavaScript, TypeScript)

How Fastify is structured: The Node web framework, the whole repo in 323 files, 226 of them tests. fastify.js is what it rests on: a change to it can reach 29 files. (323 files; JavaScript, TypeScript)

How Koa is structured: The minimal Node web framework, the whole repo in 89 files, 74 of them tests. The framework is seven files in lib/, with no cycles anywhere. (89 files; JavaScript)

How Echo is structured: The Go web framework, the whole repo in 119 files, half of them middleware, with no cycles. echo.go is where it starts. (119 files; Go)

How Immer is structured: The immutable state library, the whole repo in 69 files. src/internal.ts gathers the internals, and src and its core/ folder lean on each other. (69 files; TypeScript, JavaScript)

How MobX is structured: The reactive state library, its monorepo in 220 files with mobx-react and mobx-react-lite, without the docs' copies of CodeMirror and jQuery. internal.ts gathers the core: a change to it can reach 52 files. (220 files; TypeScript, JavaScript)

How axum is structured: The Rust web framework from the Tokio project, its whole workspace in 386 files: axum, axum-core, axum-extra, the macros and the examples. No cycles between the crates. (386 files; Rust)

How Jotai is structured: The atomic state library for React, the whole repo in 227 files with its examples and website. src/vanilla.ts is the core: a change to it can reach 27 files. (227 files; TypeScript, JavaScript)

How Click is structured: The Python library for command line interfaces, the whole repo in 111 files with tests and examples. core.py holds most of it, at 4,039 lines, and there are no cycles. (111 files; Python)

How httpx is structured: The Python HTTP client, the whole repo in 70 files. _types.py is what the rest leans on, and _client.py is the biggest at 2,020 lines. (70 files; Python)

How Starlette is structured: The Python ASGI framework, the whole repo in 98 files. starlette/types.py is what everything leans on: a change to it can reach 39 files. (98 files; Python)

Supported languagesJavaScript, TypeScript, JSX, TSX, Python, Go, Rust, Vue and Svelte are parsed for functions, classes, imports and exports. HTML, CSS, SCSS, JSON, YAML and TOML are summarized as compact cards, 19 file extensions in total.Where your code goesNowhere. There is no backend and no account. Parsing happens in the browser tab you have open, and closing it discards the project unless you saved it yourself.See open-source codebases already visualized · About NeedyNodes