> ## Documentation Index
> Fetch the complete documentation index at: https://docs.meow.style/llms.txt
> Use this file to discover all available pages before exploring further.

# Installation

> Install the meow binary on macOS, Linux, or Windows — then verify it in seconds.

meow ships as a **single self-contained binary**. There is no runtime to install
alongside it, no `node_modules` for the tool itself, and no global package graph
to manage. You install one file and you have the runtime, package manager, and
toolchain.

## Install script

The fastest path on macOS and Linux:

```bash theme={null}
curl -fsSL https://meow.style/install | sh
```

This drops the `meow` binary into `~/.meow/bin` and adds it to your `PATH`. Open a
new shell afterwards (or `source` your profile) so the updated `PATH` takes effect.

<Note>
  The first time you run `meow run` or `meow install`, meow also writes drop-in
  shims for `node`, `npm`, `pnpm`, `yarn`, `bun`, `npx`, `pnpx`, and `bunx` into
  `~/.meow/bin`. That's what lets framework tooling that shells out to `node`
  transparently re-enter meow. See [Node.js compatibility](/runtime/node-compat#the-node-shim).
</Note>

## Build from source

meow is a Rust workspace. If you have a stable Rust toolchain you can always build
the binary yourself — this is the canonical, always-works path.

<Steps>
  <Step title="Install Rust (stable, 1.85+)">
    Use [rustup](https://rustup.rs). meow pins the **stable** channel with
    `clippy` and `rustfmt`.
  </Step>

  <Step title="Install system build dependencies (Linux only)">
    The embedded V8 engine needs a C/C++ toolchain:

    ```bash theme={null}
    sudo apt-get update
    sudo apt-get install -y build-essential make cmake clang libclang-dev
    ```

    macOS needs the Xcode Command Line Tools (`xcode-select --install`); Windows
    needs the MSVC build tools.
  </Step>

  <Step title="Clone and build">
    ```bash theme={null}
    git clone https://github.com/0xchasercat/meow
    cd meow
    cargo build --release
    ```

    The optimized binary lands at `target/release/meow`. Building bakes a V8
    startup snapshot into the binary, which adds a few seconds to the first build.
  </Step>

  <Step title="Put it on your PATH">
    Copy `target/release/meow` somewhere on your `PATH`, or install it with Cargo:

    ```bash theme={null}
    cargo install --path crates/cli
    ```

    This installs the `meow` binary from the `meow-cli` crate.
  </Step>
</Steps>

## Verify

```bash theme={null}
meow --version
```

Run with no arguments to see the landing screen — the command catalog plus live
telemetry about how meow was installed, your cache size, and any shadow
installations on your `PATH`:

```bash theme={null}
meow
```

Then check your environment, config, and lockfile health at any time:

```bash theme={null}
meow doctor
```

```text theme={null}
╭─ meow doctor ───────────────────────────────╮
│ ◉ meow 0.0.0                                 │
│ ✓ package.json    found                      │
│ ✓ lockfile        12 packages                │
│ ✓ node_modules    materialized               │
│ ✓ cache           ~/.meow/cache              │
╰──────────────────────────────────────────────╯
```

## Platform support

meow is tested in CI on **Linux, macOS, and Windows**. Package materialization
uses the best primitive each platform offers:

| Platform     | Package contents          | Dependency edges         |
| ------------ | ------------------------- | ------------------------ |
| macOS (APFS) | `clonefile` copy-on-write | symlinks                 |
| Linux        | recursive hardlinks       | symlinks                 |
| Windows      | recursive hardlinks       | NTFS directory junctions |

See [node\_modules & materialization](/package-manager/node-modules) for why meow
never uses symlinks for package *contents*.

## Where meow keeps its files

Everything global lives under `~/.meow`:

| Path                          | Purpose                                              |
| ----------------------------- | ---------------------------------------------------- |
| `~/.meow/bin`                 | The `meow` binary and the `node`/`npm`/`npx`/… shims |
| `~/.meow/cache/<algo>/<hash>` | Global content-addressed package cache (tarballs)    |
| `~/.meow/cache/metadata`      | Cached npm registry metadata                         |
| `~/.meow/cache/unpacked`      | Unpacked package store                               |
| `~/.meow/global`              | Globally installed packages (`meow add -g`)          |

<Tip>
  Set `MEOW_HOME` to relocate the whole `~/.meow` tree — useful for CI caching or
  keeping the cache on a fast volume. Child runtimes inherit it automatically.
</Tip>

## Multiple installations

If meow detects another `meow` binary earlier on your `PATH`, the landing screen
warns you:

```text theme={null}
⚠ Multiple meow installations detected!
  You are running: /usr/local/bin/meow
```

This usually means a build-from-source binary is shadowing (or being shadowed by)
the installer copy in `~/.meow/bin`. Keep one, or order your `PATH` deliberately.

## Next steps

<CardGroup cols={2}>
  <Card title="Quickstart" icon="rocket" href="/quickstart">
    Build and run something real in 60 seconds.
  </Card>

  <Card title="Migrate from Node" icon="arrow-right-arrow-left" href="/migrate-from-node">
    Map your `npm` / `node` / `npx` muscle memory onto meow.
  </Card>
</CardGroup>