Your codebase.
Understood.
Blink is a Rust-powered developer tool in active development. It's designed to analyze projects, understand architecture, automate workflows, and integrate into your repository through native project configuration.
Understand a repository.
What Blink is being built to do.
One tool, meant to be used across every project — from the moment you clone a repository to your daily development loop. Here's the interface it's being designed around.
Understand any repository in an instant.
blink inspectPoint Blink at a project and it reads the structure the way an experienced engineer would — turning a folder of files into a clear picture of what the project is and how it is built.
- Detects languages and frameworks
- Identifies build systems and package managers
- Locates entry points
- Maps the shape of the architecture
A fast local index of your entire project.
blink indexBlink builds a local index of your project so everything it does afterwards is fast. The index updates incrementally — only what changed is re-read.
- Incremental updates on change
- Cached analysis between runs
- Fast searching across the project
- Efficient filesystem traversal
Remove the repetitive parts of development.
blink setupblink runblink checkblink doctorThe tasks you run every day — environment checks, project setup, validation, and workflow execution — become single commands that behave the same in every repository.
- Environment checks
- Project setup
- Validation runs
- Task execution
blink setupautomatedblink runautomatedblink checkautomatedblink doctorautomatedFind measurable improvements.
blink optimizeBlink looks across the project and surfaces concrete, actionable improvements — not vague advice. Every suggestion points at something real.
- Dependency issues
- Project organization problems
- Configuration problems
- Workflow inefficiencies
A configuration file built for developer workflows.
.bnk.bnk lets Blink understand how your project works.
# .bnk [project] name = "my-app" [commands] dev = "npm run dev" test = "npm test" [scan] ignore = ["node_modules"]
With .bnk, Blink can:
- Customize analysis
- Define project commands
- Configure indexing
- Manage workflows
- Support plugins
Optional
Blink works without it. Add a .bnk only when you want to shape how Blink reads your project.
Lightweight
A small, readable file that lives in your repository root — no scaffolding, no ceremony.
Language independent
The same format works whether your project is Rust, TypeScript, Python, or a mix.
Project specific
Committed alongside your code, so every contributor gets the same Blink behavior.
See how your project fits together.
blink depsblink graphUnderstand what your project depends on and how its pieces relate. Blink builds a dependency graph you can actually read.
- Dependencies at a glance
- Relationships between modules
- Project structure made visible
A core that connects to everything.
Blink's plugin architecture lets the core delegate work to extensions you write, so Blink can understand tools and conventions it never shipped with.
blink pluginAnalyzers
Teach Blink to understand a new kind of project or a convention specific to your team.
Detectors
Recognize frameworks, tools, and file types beyond the built-in set.
Exporters
Turn Blink's understanding of a project into whatever format your tooling expects.
Integrations
Connect Blink to the rest of your development environment.
One engine. Focused crates.
Blink is a small Rust workspace. The CLI is a thin surface over a shared core, and each remaining crate owns exactly one job — with no circular dependencies between them.
blink-clicommand surfaceEvery command you run — inspect, index, optimize, report — enters here and delegates straight into the core. The CLI owns argument parsing, help, and presentation, and nothing else.
blink-coreshared engineThe vocabulary the whole tool is built on: the project model and the plumbing every other crate draws from. Core depends on nothing else in the workspace, so it stays reusable.
blink-config.bnk configurationLoads and validates the .bnk project file. It resolves defaults, reports clear errors on malformed input, and hands a typed configuration to the rest of the tool.
blink-indexfast local indexBuilds and incrementally maintains the local project index that makes searching and repeated analysis fast. Only changed files are re-read.
blink-analyzerunderstandingReads a project into structured knowledge — languages, frameworks, dependencies, and the concrete improvements Blink can recommend.
blink-reportreportingTurns the analyzer's findings into human-readable reports and structured output for the terminal, files, and other tooling.
blink-pluginextensibilityThe plugin surface. Custom analyzers, detectors, exporters, and integrations register here and become first-class parts of every command.
The command surface, planned.
A focused, consistent set of commands. Snippets below are illustrative previews of the intended interface, not captured output.
$ blink inspectUnderstand a repository.
$ blink inspect ⚡ Blink Inspect Project my-application Languages Rust, TypeScript Framework Next.js Package Manager pnpm Configuration .bnk detected
Designed for speed.
Blink is being built to feel instant, even on large repositories. These are the design choices behind that goal — not benchmark claims.
Rust implementation
A single, small native binary with no runtime to warm up.
Incremental indexing
Only changed files are re-read, so repeat runs stay fast.
Caching
Analysis is cached between runs and reused whenever nothing changed.
Efficient filesystem analysis
Project traversal skips what it should and touches each file once.
How Blink is meant to fit your day.
The workflows Blink is being designed around, command by command — from the first clone to your daily loop.
Joining a new repository
The first thing to run when you land in an unfamiliar codebase.
$ git clone <repository-url>$ cd <repository>$ blink inspect
Setting up development
Check the environment, then get the project ready to work on.
$ blink doctor$ blink setup
Daily workflow
Validate the project, then run it — every day, one command each.
$ blink check$ blink run dev
Read the docs
Being built in Rust, right now.
Blink is in active development and not yet publicly released.What you see here is the design and the interface Blink is being built toward. Source, packages, and downloads will be linked here once they're real.