Skip to main content
meow is one binary, but internally it’s a set of sharply separated layers. The design goal is structural separation of side effects from computation: only the outermost layer reads the ambient host (environment, home directory, current working directory); everything beneath it operates on values it was handed. That discipline is what makes determinism, testability, and the single-parse pipeline possible.

​
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 keeps a single lossless Oxc model in memory and serves every in-process consumer from it:
1

Concrete Syntax Tree (CST)

A lossless tree that preserves every token and whitespace span — what the formatter needs to reprint faithfully.
2

Semantic graph

Scopes, bindings, and references built on top of the CST — what the linter and semantic-aware tooling need.
3

Runtime IR & type-stripping

TypeScript annotations are blanked in place (preserving byte positions, so no source maps are needed) to produce the JavaScript the runtime executes.
These stages are modeled as lazy, invalidatable queries: a stage is computed on demand and cached, and editing a file invalidates only what depends on it. The formatter, linter, and runtime type-stripper all draw from this one graph (meow-graph) instead of re-reading your source.
meow-graph is the single Oxc entry point for the formatter, the linter, and the runtime’s in-place type-stripping — one parse, reused. The bundler (Rolldown) is built on the same Oxc generation and resolves modules through meow’s own resolver, so the dependency graph stays consistent. Type-checking is the one job Oxc doesn’t do, so meow check delegates to tsc.

​
The execution model

meow runs on a tuned build of V8, embedded through deno_core. The main module runs on the main thread’s isolate; parallelism comes from one isolate per OS thread, not cooperative scheduling.

The main module runs on the main thread. Each node:worker_threads worker gets its own OS thread, its own V8 isolate, and its own event loop; they communicate only through serialized messages (and SharedArrayBuffer for shared memory).

A V8 isolate is entered when it’s constructed and exited only when it’s dropped, in strict LIFO order per OS thread — so two long-lived isolates can’t share a thread. Rather than fight that, meow gives each node:worker_threads worker its own OS thread, isolate, and single-threaded async runtime (the model Node and Deno use). Workers share nothing but structured-cloned messages and any SharedArrayBuffer you pass; each reuses the project’s immutable resolution graph + content cache by reference and boots from the same V8 snapshot, so spawning stays cheap. See Workers for the full surface. 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 and formatting on the shared Oxc graph, and bundling (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.
This duality is a real design rule in meow: a feature is only “done” when it is both fast and delightful. Benchmarks are never won by dropping the SHA-512 supply-chain check or by re-parsing your code in a corner.

​
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.