slate

Your personal Letterboxd. A fast watchlist for everything you want to watch and everything you've loved — private by default, shareable when you choose.

Letterboxd is great, but the feed can get in the way of the shelf. Slate keeps the personal-app feeling: sign in with Google on the hosted version, or run a single-user copy in Docker. Either way, your library starts private and stays focused.

• ⌘K command palette: search TMDB and add anything to your library in one keystroke
• AI search: flip the "Ask AI" pill (or ⌘⇧K) and type plain English like "cozy autumn mysteries", "A24 horror after 2020", or "Nolan thrillers". Live query suggestions surface as you type. Powered by any OpenAI-compatible endpoint (Groq's free tier running Llama 3.3 70B by default) or Claude. Optional; drop in one key to enable
• Three clean states: Watchlist, Watching, Watched, with Love / Like / Dislike ratings and private notes
• Google accounts: the hosted app keeps each person's titles, lists, ratings, imports, recommendations, and ordering isolated in Neon
• Shareable profiles: opt in to a read-only public URL for your Watchlist, Watching, and Watched shelves; profiles are private by default
• Episode tracking without the chore: for the shows you're watching, slate stores where you are (S2·E5), not every episode you've ticked off. Tap the chip on the card to advance one episode; on the title page, tap any episode in the season grid to set "I'm caught up to here." Two clicks to recover after a binge
• Critic scores you can trust: IMDb rating + Rotten Tomatoes Tomatometer (with Metacritic fallback) on every saved title, fetched once via OMDB and cached
• Custom lists: curate collections like "Cozy winter" or "A24 horror"
• Rich title pages: cast, streaming providers, TMDB reviews, trailers
• One-step import from Letterboxd or Trakt CSV exports — /import
• Passcode gate: optional shared-cookie lock for private deployments
• Themeable: System, Light, or Dark mode via the three-way toggle; six accent color palettes to pick from (violet, indigo, sky, emerald, rose, amber)
• Responsive: looks good on every screen size

Next.js 16 (App Router) · React 19 · Tailwind CSS v4 · shadcn/ui · Postgres — Neon (Vercel) or PostgREST (self-host) · TMDB API · Docker / Vercel

Prefer a managed stack? Slate deploys to Vercel + Neon — free serverless Postgres that never pauses — in a few minutes.

git clone https://github.com/gitshanks/slate.git
cd slate && npm install

The database is Neon — free serverless Postgres that (unlike Supabase's hobby tier) never pauses and doesn't cap you at two projects. You provision it from inside Vercel in the next step, so there's no key to grab up front.

Push to GitHub and import at vercel.com/new. Then, inside the project:

1. Add the database. Storage → Create Database → Neon (Vercel Marketplace). Pick the same region as your project — it provisions a free Neon Postgres and sets DATABASE_URL for you automatically.
2. Load the schema. In the Neon console → SQL Editor, paste supabase/schema.sql and run it. That's the entire database. Re-running is safe — every create / alter uses if not exists, so it picks up new columns without touching your data.
3. Add the rest of the environment variables (Settings → Environment Variables):

Prefer Supabase, or already have another Postgres? Set SUPABASE_URL + SUPABASE_SERVICE_ROLE_KEY instead of DATABASE_URL — the data layer uses whichever backend is configured.

1. Set NEXT_PUBLIC_SLATE_HOSTED=1, AUTH_SECRET, the two Google OAuth variables, and NEXT_PUBLIC_SITE_URL.
2. In Google Cloud, authorize https://your-domain/api/auth/callback/google.
3. For an existing database, run npm run db:migrate:accounts. A new database gets the same ownership/profile schema from supabase/schema.sql.
4. If the deployment already contains your pre-account library, set SLATE_LEGACY_OWNER_EMAIL to your Google email before the first sign-in. Only that account can claim the legacy rows.

Leave every hosted-account variable unset to retain the original self-hosted/single-user behavior, including the optional APP_PASSCODE gate.

Slate is designed to be self-hosted. Everything runs on your machine and your data never leaves it. The only outbound calls are to TMDB for metadata.

git clone https://github.com/gitshanks/slate.git
cd slate
cp .env.example .env          # fill in TMDB_API_KEY + OMDB_API_KEY
docker compose up -d

Open http://localhost:3000. Done.

You'll want two free keys before you start:

• TMDB (themoviedb.org/settings/api) — required. Drives metadata, posters, search, cast, providers, recommendations.
• OMDB (omdbapi.com/apikey.aspx) — strongly recommended. Drives the IMDb / Rotten Tomatoes / Metacritic chips on saved titles. 1,000 lookups/day is plenty for a personal library; results are cached for 24h. Skip it and the app still runs, but every rating chip stays blank.

All your titles, ratings, and notes live in the postgres_data volume.

# Back up
docker compose exec postgres pg_dump -U slate slate > slate.sql

# Restore
cat slate.sql | docker compose exec -T postgres psql -U slate slate

# Wipe everything
docker compose down -v

• Put Caddy or Traefik in front of the slate container for TLS and a real domain.
• Set APP_PASSCODE in .env to gate access behind a shared code.
• The stack is single-user by design. If you want to expose it publicly, keep the passcode on.
• PostgREST runs without JWT auth inside the compose network, so don't expose port 3001 to the internet.

Two one-shot scripts cover the cases where a feature shipped after some titles were already in your database. Both read .env.local / .env, throttle to stay polite on the free TMDB / OMDB tiers, and skip rows that already have data, so they're safe to re-run.

# IMDb / Rotten Tomatoes / Metacritic for every saved title
npx tsx scripts/backfill-ratings.ts

# Per-season episode counts for every TV title — needed for the
# +1 chip and the season picker on title pages
npx tsx scripts/backfill-seasons.ts

Coming from another tracker? Drop a CSV into /import:

• Letterboxd: Settings → Data → Export your data. Import watched.csv, ratings.csv, or watchlist.csv.
• Trakt: any movie/show CSV export.

Rows are matched against TMDB, deduped against your library, and dropped into the right state with ratings preserved.

app/
  (app)/              # main app — protected by passcode when set
    page.tsx          #   /              Watchlist
    watching/         #   /watching
    watched/          #   /watched
    title/[id]/       #   /title/:id
    lists/            #   /lists, /lists/:slug
    discover/         #   /discover
    search/           #   /search        keyword + AI search results
    import/           #   /import
    person/[id]/      #   /person/:id
    share/            #   /share         add-to-library deep link
  landing/            # marketing landing page (demo mode)
  unlock/             # passcode screen
  api/
    tmdb/search/      #   server-side TMDB proxy
    ai-suggest/       #   live AI query suggestions
    ai-chat/          #   natural-language AI search
    version/          #   build version probe
  layout.tsx          # root shell + ThemeProvider + Sonner
  globals.css         # design tokens (HSL → @theme inline)
components/
  ui/                 # shadcn/ui primitives
  command-palette.tsx
  poster-card.tsx
  backdrop-hero.tsx
  review-sheet.tsx
  ...
lib/
  supabase.ts         # server-only client + generated types
  tmdb.ts             # TMDB fetch helpers
  actions.ts          # Server Actions — all mutations
  ai-search.ts        # natural-language query parsing
  accent-theme.ts     # accent color palette config
  ...
proxy.ts              # hosted auth routing + self-hosted passcode gate
supabase/schema.sql   # one-shot DB setup
docker-compose.yml    # self-host stack
Dockerfile            # Next.js standalone runner image

• The database credential (DATABASE_URL for Neon, or SUPABASE_SERVICE_ROLE_KEY) is read only inside server-only modules (lib/supabase.ts, lib/neon-client.ts), so it can never leak into a client bundle.
• TMDB_API_KEY never touches the browser. The command palette routes through /api/tmdb/search.
• Hosted sessions use Auth.js with Google OAuth. Every owned query and Server Action is scoped in the server-side data access layer; Proxy redirects are only the fast outer gate.
• Public profile pages first verify the profile's is_public flag and expose only read-only library fields.
• Self-hosted mode retains the optional shared passcode gate and stable self-hosted database owner.

This product uses the TMDB API but is not endorsed or certified by TMDB. Poster and backdrop artwork is served from TMDB's CDN.

• Jellyfin library integration: show what you already own in slate, matched via TMDB IDs. Coming soon.

• Following or a social feed: public profiles are direct-link, read-only shelves rather than another engagement network.
• Plex library integration.
• Trakt / MyAnimeList sync: CSV one-shot import only.
• Native mobile apps: PWA install is supported on iOS Safari and Chromium.
• Library export: you can import a library but can't yet dump one out.

MIT. Fork it, host it, make it yours.