Hello! Gobby is here to help, oh yes.
Gobby is one little Go binary — no masters to install, no databases to feed. You point Gobby at a folder and Gobby scans your movies, series, music, books and loose files, remembers them in a tidy SQLite drawer, and opens two doors on the same port:
- a web page for your phone or browser (Gobby prints a link and a QR in the terminal), and
- an MCP server 🧙♂️ so a supreme intelligence can search your library.
Gobby never owns anything. Gobby only explores what you already have, fetches the little covers and details from free services, and — if you ask him nicely — opens a tunnel so you can watch from afar. No copyright lives in Gobby's drawer, oh no. Gobby is a free elf, not a pirate.
Your little edits — titles, notes, ratings, the watchlist — live only in the drawer. Gobby would iron his hands before touching your original files.
Made with vibe coding ✨ — Gobby was written hand-in-hand with a supreme intelligence, then read over line by line. A free elf and a clever wizard, oh yes. 🧦🪄
Grab the binary for your platform from the Releases page and drop it in the folder you want it to live in. That's it — one file, no install. (See the CHANGELOG for what's new.)
ffmpeg is baked in. mkv/avi playback needs ffmpeg, and the release binary
carries it embedded as WebAssembly (go-ffmpreg) —
truly one file, nothing to download. Want it faster? Drop a native ffmpeg
next to Gobby (or have one on PATH) and Gobby uses that instead of the embedded
one — no startup cost, no transcode limits.
Needs Go 1.26+. Pure-Go SQLite (modernc) and a WASM ffmpeg mean no CGO and no C toolchain — cross-compile all three platforms from one machine.
go build -tags embedffmpeg -o gobby ./src # your platform, ffmpeg embedded
./build/publish.sh # cross-compile Win + Linux + macOS into bin/
./build/publish.sh v0.3.0 # ...stamping an explicit versionWithout -tags embedffmpeg you get the lean build that downloads a slim ffmpeg
on demand instead (LGPL, smaller binary). That slim ffmpeg is built separately
with Docker:
./build/ffmpeg-slim/build.sh # drops ffmpeg.exe next to the scriptgobby # scans next to the binary (or one folder up if empty)
gobby -p D:\ # scans this folder
gobby -p E:\ -library my-disk # keeps the same library even if the drive letter changes
gobby -port 9000 # a different door (8420 by default)
gobby -h # Gobby explains himselfGobby prints his name, version and a link (with a QR) when he wakes up.
Then open the link Gobby prints, or scan the QR from your phone. Same house, same door.
A chat bubble sits in the corner: ask Gobby about your library in plain language ("what action films haven't I watched?") — by voice too — and he uses his own tools to answer, speaking like a shy house-elf. Beyond looking things up he can also act: open an item you ask for, or add a title to your watchlist. Replies keep context across the conversation, show which tools he used, and offer clickable result cards.
Point it at any OpenAI-compatible endpoint — Ollama, LM Studio, OpenAI, Gemini, Groq, or a gateway like LiteLLM / OpenRouter / OmniRoute. Configure it right in the bubble's settings: pick a preset, load the model list (which also tests the connection — you can't save until it connects), pick a model from a searchable list, save. You can keep several providers and switch with a click, turn a model's slow "thinking" off per provider, and read its reasoning in a collapsible note.
API keys are stored per provider but never leave the machine: they're
redacted from every response and excluded from database export. A
GOBBY_LLM_KEY env var still works as an override.
Gobby runs headless in a container just as happily. A Dockerfile and
docker-compose.yml ship in the repo. Point the media mount at your library,
then:
docker compose upTwo volumes, each with its own job:
/media— your library, mounted read-only (:ro). Gobby only reads it./data— wheregobby.dblives, a persistent volume so your catalogue survives restarts.
ffmpeg is baked into the image, so mkv/avi play with nothing to download.
Configure with env vars (all optional): GOBBY_PATH (scan folder, default
/media), GOBBY_DATA (db folder, default /data), GOBBY_PORT, GOBBY_LIBRARY.
Running the plain binary still works exactly as before — the container is just another way to wake Gobby, not a replacement.
- Scans offline — reads filenames and embedded tags, no internet needed to catalogue.
- Fetches covers & details — from free, keyless services (see below) when you ask.
- Series, albums, authors — grouped neatly, with seasons, episodes and synopses.
- Files tab — a coloured size-tree of the whole disk, so you see what eats the space.
- Photo gallery — images get their own tab: a thumbnail grid with a lightbox and per-image details (name, format, resolution, size).
- Filter by colour — Gobby reads the dominant colour of every cover and photo, so you can filter the library by colour with a click.
- Saved — one place for anything to watch/read/listen later, links worth keeping (paste a URL and Gobby fetches the title, description and image — GitHub repos too), and your physical shelf: mark what you own, add location/format/condition, and scan a barcode (phone camera) to pull the title and cover and file it — or link it to an entry you already had, no duplicates.
- Plays in the browser — mkv/avi are remuxed on the fly with a slim ffmpeg (video copied, audio to AAC), so they play where browsers normally refuse.
- Pick the audio, drop in subtitles — choose an audio track and load embedded subtitles as WebVTT, all decoded by the same little ffmpeg.
- Resumes where you left off — playback position is remembered, with a progress bar on the shelf; finishing an episode auto-plays the next (music too).
- Keyboard player — space to pause, ←/→ to seek,
ffor fullscreen. - Reads epub inline — a paginated reader (epub.js) that remembers your page.
- Voice search — tap the mic and speak your query (where the browser supports it).
- Reveal, upload & delete (on the machine running Gobby) — open a file's folder in your OS explorer, drop a file into a folder from the Files tab, or delete a file from disk (host-only, with confirmation). Everyone else stays read-only.
- Filter the Files tree — a search box that narrows the size-tree as you type.
- Cast to a TV — Gobby also serves over HTTPS (self-signed, on the next port) so the browser's Cast SDK works on the LAN; the QR points there.
- Remote access — one click opens a temporary Cloudflare tunnel (public link + QR), gated by a per-tunnel key so a stray URL alone can't reach your library.
- Preview PDFs/audio/images inline, and a little sound for every tap.
- Read-only for guests — anyone arriving through the public tunnel can look, not edit.
- Updates himself — from the About screen Gobby checks GitHub for a newer release and swaps his own binary (and ffmpeg) in place. Restart and he's new.
| For | Service |
|---|---|
| Movies & series | Cinemeta |
| Books | Open Library |
| Music | MusicBrainz + Cover Art Archive |
| Games | CheapShark |
| Fallback covers | iTunes Search |
| Remote access | Cloudflare Tunnel |
| Cast to TV | Google Cast |
Go · SQLite (modernc) · Alpine.js · cuelume (sound) · MCP Go SDK · dhowden/tag · rsc.io/qr · a slim ffmpeg (playback)
Gobby exposes an MCP server at /mcp on the same port. Add it and your supreme intelligence 🧙♂️ can:
- Browse & search —
search_media,get_media,browse_library,recent_media,library_info - Play —
play_media(opens on the host and returns a web link to watch on any device) - Edit —
update_media(title/notes/rating/…),set_media_section,set_media_progress,enrich_media - Watchlist —
search_titles,add_to_watchlist,list_watchlist,remove_from_watchlist,set_watchlist_done
claude mcp add --transport http gobby http://localhost:8420/mcpGobby's own code is MIT — see LICENSE. But the release binary
ships ffmpeg embedded (go-ffmpreg,
GPLv3), so the distributed binary as a whole is GPLv3. Build without
-tags embedffmpeg (the slim, downloaded-on-demand ffmpeg is LGPL) if you need
a non-GPL binary. Bundled components and their licenses:
| Component | License | Notes |
|---|---|---|
| go-ffmpreg (embedded WASM ffmpeg) | GPLv3 | ffmpeg compiled to WebAssembly, bundled in the release binary → makes the whole binary GPLv3. |
| ffmpeg (slim build, non-embed builds) | LGPL-2.1-or-later | Built with no --enable-gpl / --enable-nonfree. Config in build/ffmpeg-slim/. A separate, replaceable binary — used when not embedding. |
Go std + golang.org/x/* |
BSD-3-Clause | |
| modernc.org/sqlite (+ libc, memory, …) | BSD-3-Clause | pure-Go SQLite |
| dhowden/tag | BSD-2-Clause | audio metadata |
| mdp/qrterminal, rsc.io/qr | MIT / BSD-3 | terminal + PNG QR |
| MCP Go SDK, google/jsonschema-go, google/uuid | Apache-2.0 / BSD-3 | |
| Alpine.js | MIT | vendored in src/web/ |
| cuelume | MIT | tap sounds, vendored in src/web/ |
| epub.js | BSD-2-Clause | inline epub reader, vendored in src/web/ |
| JSZip | MIT | used under MIT (JSZip is MIT-or-GPLv3); vendored in src/web/ |
Logo: the goblin mark is “Goblin” by Caro Asercion, licensed CC BY 3.0 and recoloured / set on a background for Gobby.
On the media Gobby indexes: Gobby ships no content and no copyrighted material. It only reads files you already have on your own disk and fetches cover art and metadata from public, keyless services — Cinemeta, Open Library, MusicBrainz / Cover Art Archive, CheapShark, and the iTunes Search API — used within their terms for read-only, personal cataloguing. The Cloudflare tunnel and Google Cast are optional, user-initiated conveniences. What you do with your own library is, as ever, on you — Gobby is a free elf, not your lawyer. 🧦