blueprint.

RENDERED ON YOUR MACHINE · no telemetry · no accounts · no cdns · the .html you generate opens offline, forever — that's the contract, not a feature.

kaeru — 150 files · 50 internal links · c / python / cpp. one command in, one sheet out: pan it, zoom it, pull it apart.

point it at any codebase and blueprint reads every import, traces which file leans on which, and draws the whole thing as one interactive drafting sheet. small projects settle into a quiet force layout; huge ones fold into a module treemap so the structure stays legible instead of collapsing into a hairball. the output is a single self-contained .html — no server, no build step, no phone-home.

install.

one line from the registry — the command you type afterward is just blueprint, the scope only ever lives in this install line:

npm i -g @captain09/blueprint

cd path/to/your/project
blueprint                 # writes ./blueprint.html
blueprint --open          # writes it and opens your browser
blueprint watch           # serves it live at localhost:4321, reloads on save

from source, if you'd rather build it yourself:

git clone https://github.com/xCaptaiN09/blueprint.git
cd blueprint && npm install && npm run build && npm link

at rest.

hermes — 48 files · python + javascript. shared glue (_common.py, _hermes_home.py) pulls its dependents into quiet hubs; the rest drift as lone dots. the honest shape of a bag-of-scripts repo, no layout tricks pretending otherwise.

see it answer.

click lkc.h and the sheet answers — two headers it includes, thirteen files that include it, every one listed in the spec panel. monochrome until you touch it; then exactly one accent, exactly where you're looking.

the sheet, key by key.

| do this | and the sheet does this | | ---------------- | ------------------------------------------------------------------------------------ | | hover a node | its connections light up orange; animated dashes show which way the dependency flows | | click a node | the spec panel opens — language, path, in/out degree, dependents, cycle flag | | press / | jump to search; enter frames the first match, esc clears it | | click a chip | filter the whole graph by language; fit reframes to the survivors | | click layout | reseed the physics for a fresh arrangement | | scroll | semantic zoom on big repos — blocks, then dot grids, then filenames | | drag | pan; the render loop goes silent the instant you stop, so the fans stay quiet |

three ways to run it.

generate scans once and writes a single self-contained blueprint.html — the artifact you commit, email, or open on a plane. -o <path> renames it, --json also dumps the raw graph, --exclude <globs> skips paths, --open launches the browser.

watch generates, then serves the sheet at http://localhost:4321 and keeps it live: save a file in your editor and the open tab reloads itself a beat later, so you can park it beside your work and watch the graph track your code. -p <port> and --no-open are there when you need them.

serve is an alias for watch, for the days "serve" reads better in your head.

supported languages.

parsed today — imports extracted and, where static analysis can honestly do it, resolved to local files:

| language | extensions | | ---------- | --------------------------------- | | javascript | .js .jsx .mjs .cjs | | typescript | .ts .tsx .mts .cts | | python | .py | | c | .c .h | | c++ | .cpp .cc .cxx .hpp .hxx | | go | .go | | rust | .rs | | java | .java | | kotlin | .kt .kts |

detected as files but not yet parsed — they show up as nodes with their import list in the panel, but no drawn edges, because their imports name packages and classes rather than files, and we'd rather show that honestly than invent connections. each is a small, self-contained parser away; see CONTRIBUTING.md.

how it works.

a gitignore-aware scanner walks the tree and groups files by extension; a small per-language parser pulls the import statements and resolves local paths; the results become a directed graph carrying in/out degree and Tarjan-detected circular dependencies; that graph is injected into one self-contained html template that draws everything on a canvas. the layout is adaptive — a Barnes–Hut force simulation for small and medium projects, a squarified directory treemap past the threshold — and the draw path is level-of-detail on a dirty-flag loop, which is what lets it scale from a 40-file script to a 70,000-file kernel without melting the tab.

LAYOUT_THRESHOLD (default 1500 files) flips between the force layout and the module treemap; EDGE_REST_CAP (default 1200 edges) decides whether the full edge web shows at rest or only on hover/search. both sit at the top of templates/graph.html — edit them and just regenerate, no rebuild needed.

sheet 01.

| | | | ---------------- | -------------------------------------------------- | | version | 0.1.3 | | install | npm i -g @captain09/blueprint | | runtime | node ≥ 18 | | languages parsed | js · ts · py · c · c++ · go · rust · java · kotlin | | output | one self-contained .html | | network | none — rendered on your machine | | license | MIT |

contributing.

blueprint is deliberately small and hackable: a typescript cli, a handful of per-language parsers, one html template, no framework to fight. adding a language is a good first issue — the architecture map and the four-step recipe live in CONTRIBUTING.md.

license.

MIT — © 2026 Muhammed Dilshad A (xCaptaiN09).