> For the complete documentation index, see [llms.txt](https://docs.hardpoint.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.hardpoint.dev/guides/invar/quick-start.md).

# Quick Start

Install and run Invar in 5 minutes

## Quick Start

Invar speaks the Redis wire protocol, but it's not Redis: there's no in-memory store to configure and no cluster to stand up. One process, one writer, and your data lands in object storage (or disk, for local dev) instead of RAM. This page gets you from nothing to a running instance in about a minute, then to a production-shaped instance backed by S3.

If you haven't seen it yet, the Invar guide overview covers the single-writer model and why it works this way — worth a skim before you go further than "does it run."

### Install

**Docker** (all platforms):

```bash
docker pull ghcr.io/hardpointlabs/invar:latest
```

{% hint style="info" %}
For convenience, we also publish container images to [Docker Hub](https://hub.docker.com/r/hardpointlabs/invar), however downloads from many cloud and CI environments are aggressively rate limited
{% endhint %}

**Homebrew** (macOS, Apple Silicon only):

```bash
brew install --cask hardpointlabs/tap/invar
```

This installs the same binary that runs inside the container, signed and notarized. Once installed, `invar` is on your `$PATH` and takes the exact same flags as the container image; every command below works by dropping the `docker run ...` wrapper and calling `invar` directly. Intel Macs and Linux desktops aren't covered by the cask yet- use Docker in those environments.

Invar ships as a single executable with a minimal dependency footprint. The same binary runs locally against a disk, or in production against S3-compatible object storage.

{% hint style="info" %}
Invar requires  `glibc` to be present in the host environment. Invar also ships without a compiled root CA bundle. On MacOS it defers to the system keychain; on Linux, this is typically shipped as a separate package (e.g. `ca-certificates` on Debian/Ubuntu).
{% endhint %}

### Run it locally

This starts Invar with the `fjall` backend, which persists to a local path instead of object storage. It's the fastest way to try Invar or run it in CI, and it needs no cloud credentials:

```bash
docker run -v /tmp/invar:/tmp/invar -p 6379:6379 -it \
  ghcr.io/hardpointlabs/invar:latest \
  --backend fjall --path /tmp/invar --redis
```

Or, if you installed via Homebrew:

```bash
invar --backend fjall --path /tmp/invar --redis
```

`--redis` tells Invar to serve RESP on `:6379`. `--path` is where `fjall` keeps its data — with Docker that's bind-mounted to `/tmp/invar`on the host so it survives container restarts; with the native binary it just writes there directly.

With that running, connect using any Redis client. `redis-cli` works as-is:

```bash
redis-cli -p 6379 ping
# PONG

redis-cli -p 6379 json.set user:1 $ '{"name": "Ada", "roles": ["admin", "beta"]}'
# OK

redis-cli -p 6379 json.get user:1
# {"name":"Ada","roles":["admin","beta"]}
```

That `JSON.*` support is the part that isn't "just Redis" — Invar speaks the same document commands you'd expect from RedisJSON, on top of the same wire protocol. There's more on this in Usage.

### Run it against object storage

Swap the backend to `slate` (Invar's [SlateDB](https://slatedb.io/)-backed mode) and point it at a bucket. This is the same code path you'd run in production — see Operations for what that looks like at deployment scale:

```bash
docker run -p 6379:6379 -it \
  -e AWS_REGION=us-east-1 \
  -e AWS_ACCESS_KEY_ID=... \
  -e AWS_SECRET_ACCESS_KEY=... \
  ghcr.io/hardpointlabs/invar:latest \
  --backend slate --bucket my-bucket-name --redis
```

Or natively:

```bash
export AWS_REGION=us-east-1
export AWS_ACCESS_KEY_ID=...
export AWS_SECRET_ACCESS_KEY=...
invar --backend slate --bucket my-bucket-name --redis
```

Invar picks up the standard `AWS_*` environment variables for credentials — nothing Invar-specific needed there. `--prefix`(default `/invar`) namespaces the keys Invar writes within the bucket, useful if you're sharing a bucket across multiple instances or tenants.

### What's next

* **Usage** — what's different from talking to real Redis: JSON commands, transaction caveats, scripting, and the command groups that don't apply here.
* **Operations** — running this for real: compute deployment (k8s, Fly.io, serverless) and configuring storage and caching.
* **CLI reference** — every flag and environment variable.
* **Redis command support** — the full compatibility matrix.