Get started

Try hunt on your own computer in a few minutes, then run it for good: on your computer, on a server, or for a whole team.

Try it

The quickest way to see hunt is to run it on your own computer, with Docker. You need nothing else: no account, and no database to set up.

1. Run it

docker run --rm -p 127.0.0.1:4848:4848 ghcr.io/arabesquelabs/hunt

Then open http://localhost:4848. This copy keeps nothing once you stop it (with Ctrl-C), which is what you want for a look around. To keep what you add, see Install it.

The image is built for Intel and AMD computers (linux/amd64). On a Mac with Apple silicon, Docker runs it all the same, through emulation: if it asks, add --platform linux/amd64 after docker run.

2. Add your first application

On the Tracking Board, choose Add application (or press N).
Paste a job posting's link (from LinkedIn, Greenhouse, Lever, Ashby, Workable or levels.fyi) into Posting link, and choose Read posting. hunt fills in the role, the company, the pay and the description. No link? Type the company and the role instead.
Choose the stage it's at (Applied, say), and add it.

The application is a card on the board now. Drag it along as things move, open it to add an interview or a note, and give it a next step with a date: it shows on the card, and on the Calendar.

3. Or look around with demo data

hunt comes with made-up demo data: companies, applications at every stage, people, interviews, notes and files, so every page has something on it. It needs Rust (1.85 or later), git and sqlite3:

git clone https://github.com/ArabesqueLabs/hunt
cd hunt
make demo    # builds hunt, and fills target/dev.db with the demo data
make dev     # serves it on http://127.0.0.1:4848

Every company, person and address in it is made up. The screenshots are of it.

Or let us run it

A hosted hunt, which we run for you, is coming soon: nothing to install or keep up to date. Join the early access list and we'll let you in when there's room.

Install it

To keep hunt, run it with somewhere to keep its data. Pick one way:

	Best for	Needs
Docker	your own computer, or a server	Docker
Docker Compose	a server you manage with Compose	Docker, with Compose
From source	running it without Docker, or working on it	Rust 1.85 or later
Kubernetes	a cluster you already run	a cluster, and a volume

With Docker

docker run -d --name hunt --restart unless-stopped \
  -p 127.0.0.1:4848:4848 -v hunt-data:/data \
  ghcr.io/arabesquelabs/hunt:latest

Your data is in the hunt-data volume, as a SQLite database (/data/hunt.db). It stays when the container is replaced.
Who can reach it: 127.0.0.1:4848 keeps it to this computer. To open it to your network, use -p 4848:4848, but read Keep it private first.
Versions: latest is the newest build of main. To stay on a release, use its version's tag instead (ghcr.io/arabesquelabs/hunt:v0.15.0).
Is it up? curl http://localhost:4848/healthz says ok once hunt and its database answer.

More in Docker: versions, updating, and building the image yourself.

With Docker Compose

Save this as compose.yaml:

services:
  hunt:
    image: ghcr.io/arabesquelabs/hunt:latest
    ports: ["127.0.0.1:4848:4848"]
    volumes: ["hunt-data:/data"]
    restart: unless-stopped
volumes:
  hunt-data:

Then start it, from the same folder:

docker compose up -d

From source

With Rust 1.85 or later:

cargo install --git https://github.com/ArabesqueLabs/hunt
hunt serve

That serves http://127.0.0.1:4848, with its database in ~/.hunt/hunt.db. --addr (or HUNT_ADDR) says where to listen, and --db (or HUNT_DB) which database. The same hunt is also the command line.

To keep it running, start it as a service: with systemd on Linux, or launchd on a Mac. Its one process is all there is.

On Kubernetes

hunt is one pod with one volume. Only one copy can run at a time, since SQLite is a file on that volume, so updates replace the pod rather than rolling:

apiVersion: v1
kind: PersistentVolumeClaim
metadata: { name: hunt-data }
spec:
  accessModes: [ReadWriteOnce]
  resources: { requests: { storage: 1Gi } }
---
apiVersion: apps/v1
kind: Deployment
metadata: { name: hunt }
spec:
  replicas: 1
  strategy: { type: Recreate }
  selector: { matchLabels: { app: hunt } }
  template:
    metadata: { labels: { app: hunt } }
    spec:
      securityContext: { fsGroup: 65532 }
      containers:
        - name: hunt
          image: ghcr.io/arabesquelabs/hunt:latest
          ports: [{ containerPort: 4848 }]
          volumeMounts: [{ name: data, mountPath: /data }]
          readinessProbe: { httpGet: { path: /healthz, port: 4848 } }
          livenessProbe: { httpGet: { path: /healthz, port: 4848 } }
      volumes:
        - name: data
          persistentVolumeClaim: { claimName: hunt-data }
---
apiVersion: v1
kind: Service
metadata: { name: hunt }
spec:
  selector: { app: hunt }
  ports: [{ port: 4848, targetPort: 4848 }]

The image runs as a non-root user (65532), so fsGroup gives it the volume. To use the command line against it, forward its port (kubectl port-forward svc/hunt 4848). More in Kubernetes: deploying it, reaching it, and updating it.

Set it up

Choose a database

hunt keeps everything in SQLite unless you say otherwise, which is all one person needs. To use a database you already run, give its address as --db (or HUNT_DB, in a container):

hunt serve --db postgres://hunt:secret@localhost/hunt     # PostgreSQL 12 or later
hunt serve --db mysql://hunt:secret@localhost:3306/hunt   # MySQL 8.0.16 or later

Make the database first (CREATE DATABASE hunt); hunt adds its tables when it starts. It reaches PostgreSQL and MySQL without TLS, so keep them on the same machine or a private network.

Keep it private

On your own computer, hunt needs no sign-in: hunt serve listens on 127.0.0.1 alone, and the Docker commands here publish it there too. To reach it from elsewhere, give it a sign-in first:

A password, for one person: start it with HUNT_PASSWORD, and it asks for it at /login.
```
docker run -d --name hunt -e HUNT_PASSWORD='a long passphrase' \
  -p 4848:4848 -v hunt-data:/data ghcr.io/arabesquelabs/hunt:latest
```
Put it behind HTTPS too (Caddy does it on its own), and set the same HUNT_PASSWORD where you use the command line.
A sign-in proxy, for several people: Authelia, Authentik, oauth2-proxy or Tailscale signs people in, and tells hunt who they are.
Cloudflare Access, in front of the whole hostname.

What's public, and what needs signing in has the details of each.

Use the command line

Everything the board does, from your terminal. cargo install (above) installs it; it talks to the hunt at HUNT_URL (http://127.0.0.1:4848 unless you say):

hunt add --link https://jobs.ashbyhq.com/acme/1234 -s applied
hunt next acme "send availability" --due tomorrow
hunt board

With Docker, the image has it too: docker exec hunt hunt board. All its commands are in the docs.

Back it up

Settings → Backup and import downloads everything (applications, companies, people, files, tags, settings and the change log) as one JSON file, and imports one. Or from the command line:

hunt backup                                  # to hunt-backup-<date>.json
hunt restore hunt-backup-2026-10-20.json     # replaces everything (asks first)

A backup works with any database, so it's also how to move from SQLite to PostgreSQL or MySQL.

Update it

Docker: docker pull ghcr.io/arabesquelabs/hunt:latest, then remove the container and run it again; the volume keeps your data. With Compose, docker compose pull && docker compose up -d.
From source: run cargo install --git … again, and restart it.

A newer hunt upgrades a SQLite database in place. PostgreSQL and MySQL databases start at the current version: to carry one across an upgrade, back it up with the hunt that made it, and import the backup into a new database.

Run it for others

One hunt can serve several people, each seeing only their own search. They sign in through Cloudflare Access (with LinkedIn, GitHub, Facebook or Google), ask to join, and an admin lets them in:

hunt serve --tenants --admins you@example.com \
  --access-team yourteam --access-aud <the Access application's AUD tag>

Running it for others makes you responsible for their data: point hunt at your privacy notice and terms with HUNT_SITE_URL, and people agree to the terms when they ask to join. The docs have the details.

The docs: every page and setting, the command line, and how hunt works.
Screenshots: every page, with the demo data.
GitHub: the source, issues, and how to contribute.

Try it​

1. Run it​

2. Add your first application​

3. Or look around with demo data​

Or let us run it​

Install it​

With Docker​

With Docker Compose​

From source​

On Kubernetes​

Set it up​

Choose a database​

Keep it private​

Use the command line​

Back it up​

Update it​

Run it for others​

Next​