The Parse-Once pipeline
In a conventional toolchain, your code is parsed many times: the runtime parses it to execute, the linter parses it to analyze, the formatter parses it to reprint, the type-checker parses it, the bundler parses it again. Five tools, five parsers, five copies of your AST melting your CPU. meow parses your code exactly once using the Oxc parser and keeps a single lossless model in memory. That one model serves every consumer:Concrete Syntax Tree (CST)
A lossless tree that preserves every token and whitespace span — what the
formatter needs to reprint faithfully.
Semantic graph
Scopes, bindings, and references built on top of the CST — what the linter
and type-aware tooling need.
meow uses Oxc for all parsing, semantic analysis, type-stripping, and JSX
transformation. The bundler (Rolldown) uses the same Oxc generation internally,
so there is never a second, divergent AST in the dependency graph.
The execution model
meow runs on a tuned build of V8, embedded throughdeno_core. Execution is
cooperative, single-threaded, and multi-isolate:
!Send — they can’t move between OS threads. Rather than fight
that, meow embraces it: node:worker_threads workers and the test runner’s
per-suite isolates are spawned as cooperative tasks on the same thread’s Tokio
LocalSet. They interleave perfectly (think Vite’s parallel bundling pipelines)
without the heavy context-switching of OS threads.
CPU-bound work that should leave the main thread — SHA-512 verification and
tarball decompression during installs — is offloaded to background OS threads, so
network I/O is never starved waiting on a hash.
The crate map
meow is composed of focused crates, each isolating one concern. The only crate permitted to read ambient host state is the CLI edge.meow-cli
The command-line edge. Owns argument parsing, the omni-router, the terminal UI
helpers, and project-root discovery. The only layer that reads host
environment variables.
meow-config
Reads
meow.config.json and the user-owned package.json; generates the
git-ignored shadow tsconfig that editors and tsc consume.meow-graph
The single Oxc pipeline: CST, semantic graph, and runtime IR as lazy,
invalidatable queries. The one parser entry point for the whole workspace.
meow-runtime
V8 isolate orchestration, the event loop, runtime extensions, in-place
TypeScript stripping, and the determinism harness.
meow-loader
The single module resolver for the toolchain: ESM and CommonJS resolution,
content-addressed cache reads, and TypeScript source fallback.
meow-pkg
The lockfile model, the global content-addressed cache, integrity
verification, and
node_modules materialization.meow-tool
Linting, formatting (via the Oxc code printer), and bundling (via Rolldown over
meow’s own resolver).
meow-obs
Pure, deterministic dependency path-tracing — the engine behind the
why-*
observability verbs.meow-ui
A dependency-free terminal rendering engine: gradients, Bento panels, progress
bars, and structured diagnostics — degrading to plain text in pipes and CI.
Floof & Teeth
Two design values, deliberately in tension:The Floof
Best-in-class, empathetic terminal UX. Errors arrive as structured panels with
the offending line and a caret, not raw stack traces. Spinners are paw prints.
Output is a pleasure to read — and collapses gracefully to plain text when piped.
The Teeth
Zero-overhead systems engineering. One parse, copy-on-write installs, OS-thread
offloading, kernel syscalls, and a fat-LTO single-codegen-unit release binary.
Speed comes from engineering, never from skipping correctness.
Where to go next
Runtime modes
The
strict-web / node-compat split that shapes everything above the engine.Determinism
The harness that makes a bare run reproducible across machines.