Gossa

Self-hosted file management, honestly reviewed. No marketing fluff, just what you get when you run it.

TL;DR

• What it is: A fast, dependency-free web file server written in Go — browse, upload, stream, and share files over a browser, running as a single binary [1].
• Who it’s for: Homelab users, developers, and self-hosters who want a dead-simple way to serve a directory over the web without deploying Nextcloud or spinning up a PHP stack [1][2].
• Cost savings: Google Drive costs $2.99–$9.99/mo per user for storage. Dropbox for Teams runs $15–$24/user/mo. Gossa runs on a $5/mo VPS, $0 software license, and exposes as much local storage as you point it at [1].
• Key strength: The entire server is under 250 lines of Go code. You can read the whole codebase in 20 minutes and know exactly what it does and doesn’t do [1][README].
• Key weakness: No built-in HTTPS, no built-in authentication — those are intentionally delegated to a reverse proxy. If you don’t already know what Caddy is, setup is harder than it looks [README].

---

What is Gossa

Gossa is a web file server. You point it at a directory, it serves that directory through a browser. You can browse folders, drag-and-drop upload files, watch videos, view images, read PDFs, edit text files, and navigate with keyboard shortcuts. That’s the whole product [1][README].

The GitHub description calls it “a fast and simple multimedia fileserver” and the repository lives at github.com/pldubouilh/gossa under an MIT license [README]. As of this review it sits at 1,078 GitHub stars with 78 forks — modest numbers that reflect its niche: a tool that solves one specific problem cleanly, not a platform trying to be everything [README].

The author, Pierre Dubouilh, describes it with a phrase worth taking seriously: “dependency-free and with under 250 lines of code, easy to review.” That’s not a marketing claim — it’s a verifiable fact. The main server file, gossa.go, is that small. The build is reproducible and hashes are posted on the release page [README]. For anyone who’s ever looked at a self-hosted tool and wondered “what is this thing actually doing?”, Gossa is the rare case where you can answer that question by reading the code in a lunch break.

The last release is v1.1.2, published August 30, 2024. The project has shipped 22 releases total, which suggests steady maintenance without feature churn [README].

LinuxLinks, one of the few publications that has written directly about Gossa, describes it as a web-based file manager in the same roundup as Nextcloud, FileBrowser, and Filestash [2]. The placement is accurate but slightly misleading — those tools have user management UIs, plugin systems, and office integration. Gossa has none of that. It’s not in the same weight class; it’s playing a different sport.

---

Why people choose it

The third-party coverage on Gossa is thin — LinuxLinks has a dedicated entry [1] and it appears in their web-based file manager roundup [2][3]. There are no deep video reviews, no Reddit threads full of migration stories, no Trustpilot page. That’s consistent with the tool’s character: it’s a narrow utility that people either find, install in 10 minutes, and use silently, or never discover at all.

From what coverage exists, the appeal comes down to three things:

Simplicity as a feature. LinuxLinks explicitly calls out that Gossa is “lightweight and dependency free” and notes its Go-based static server as a strength [1]. In the web-based file manager roundup [2], it sits between heavier tools like Nextcloud and more obscure options. The implied contrast is clear: if you want file browsing without a database, without PHP, without a plugin system, and without a 20-step installation guide, Gossa is the answer.

Auditability. Under 250 lines of code is not just a speed claim — it’s a security claim. When you’re running a file server that exposes your storage to the network, the less code that runs between your files and the internet, the smaller the attack surface. The project also publishes reproducible builds with checksums [README]. For someone who reads code and cares about what’s running on their server, this is a meaningful differentiator.

The “do one thing well” philosophy. The README explicitly states that HTTPS and authentication have been “left to middlewares and proxies” and provides Caddy configuration samples as a reference [README]. This is a deliberate architectural choice, not a gap. It means Gossa never has to ship its own TLS code, its own auth system, or its own user database — categories where security bugs live. The tradeoff is that you need to know how to set up Caddy or nginx. The benefit is that you don’t have to trust that Gossa’s auth code is correct, because there isn’t any.

---

Features

From the README and direct inspection:

File browsing and management:

• Files and directories browser with drag-and-drop uploader [README]
• Rename, move, and delete files through the UI [README]
• Read-only mode for serving files without allowing uploads [README]
• Keyboard navigation throughout the interface [README]

Media handling:

• Video streaming directly in the browser [README][1]
• Image/picture browser [README]
• PDF viewer [README]
• Simple note/text editor [README]

Technical characteristics:

• Written in Go, single static binary, no runtime dependencies [README][1]
• Under 250 lines of server code [README][1]

• 95% test coverage [README]

• Reproducible builds with published hashes [README]
• Multi-platform: Linux, macOS, Windows [README]

Deployment options:

• Single binary download from the releases page [README]
• Docker image on DockerHub (pldubouilh/gossa) [README]
• AUR package for Arch Linux: yay -S gossa [README]
• Nix package: nix-shell -p gossa [README]
• MPR package available [README]
• Systemd user service support for autostart [README]

Multi-user support:

• Multiple account setup via reverse proxy configuration [README]
• Caddy config samples included in the support/ directory [README]

PWA support: The UI is PWA-able, meaning you can add it to your phone’s home screen and it behaves like a native app [README].

What it does not have: no built-in user management UI, no sharing links with expiry dates, no WebDAV, no office document editing, no mobile app, no S3 backend support, no plugin system. These are not bugs — they’re the product. If you need any of those things, Gossa is the wrong tool.

---

Pricing: SaaS vs self-hosted math

Gossa has no SaaS tier, no cloud version, no pricing page. It’s MIT-licensed software that runs on your hardware. The cost is: your server + your time.

Comparable SaaS products for file access and sharing:

• Google Drive: 15GB free; 100GB for $2.99/mo; 2TB for $9.99/mo per user
• Dropbox Plus: $11.99/mo; Dropbox Business starts at $15/user/mo
• Box: $10–$15/user/mo for business tiers

Gossa self-hosted:

• Software: $0 (MIT) [README]
• VPS: $4–6/mo for a Hetzner or DigitalOcean instance with 2GB RAM, sufficient for most home or small-team file sharing use cases
• Storage: attach a cheap external volume or use your existing NAS

Concrete example: A 5-person team on Dropbox Business pays $75/mo. That’s $900/year. A Hetzner VPS with a 1TB storage box runs around $9/mo total. Gossa running on that setup costs $108/year. The caveat: Dropbox has mobile apps, collaboration features, version history, and a polished interface that Gossa doesn’t offer. You’re not getting a like-for-like replacement — you’re getting a simpler tool for less money. Whether that trade is worth it depends entirely on what your team actually uses Dropbox for.

---

Deployment reality check

Deployment is where Gossa earns its reputation for simplicity — and where first-time self-hosters can get tripped up.

The fast path (Docker):

mkdir ~/LocalDirToShare
sudo docker run -v ~/LocalDirToShare:/shared -p 8001:8001 pldubouilh/gossa

That’s genuinely two commands. You’re serving files [README].

What you actually need for a production-grade setup:

• A Linux server or VPS with Docker installed
• A reverse proxy (Caddy is simplest; nginx works fine) for HTTPS and authentication
• A domain name if you want to access it outside your local network
• A Caddy or nginx config — the repository includes sample configs in support/ [README]
• A systemd unit file if you want it to survive reboots — also in support/ [README]

The gap: Gossa exposes your files over HTTP by default with no authentication. The README is explicit that this is intentional, and Caddy configs are provided. But if you set it up with the two-command Docker approach and expose port 8001 to the internet without adding a reverse proxy in front, your files are publicly readable. For a homelab on a local network this is fine. For anything internet-facing, you need the Caddy step first.

What can go sideways:

• If you’re not already comfortable with reverse proxies, the jump from “working locally” to “working securely over HTTPS with auth” is the hard part, not Gossa itself
• Multi-user setup is handled entirely through the proxy layer — you’re not getting per-user permissions or file visibility controls inside Gossa
• Last release was August 2024. The project appears to be maintained but not actively developed, which is fine for a tool this simple, but worth knowing [README]

Realistic time estimate for someone comfortable with Docker and Caddy: 15–30 minutes to a working HTTPS setup. For someone following a tutorial without prior self-hosting experience: 2–4 hours including DNS propagation.

---

Pros and Cons

Pros

• Genuinely minimal codebase. Under 250 lines of Go is readable by any developer in an afternoon. That’s a real security and auditability advantage over tools with tens of thousands of lines of framework code [README][1].
• MIT license. No commercial licensing traps, no usage restrictions, no “free up to N users” ceilings [README].
• Single binary. No runtime dependencies — Go compiles to a self-contained executable. You copy it to your server and run it. No installing Node, PHP, Python, or anything else [README][1].
• Reproducible builds. The project publishes hashes you can verify against what you downloaded [README]. Most self-hosted tools don’t bother with this.
• Multimedia support out of the box. Video streaming, image browsing, and PDF viewing work in the browser without installing codecs or plugins [README][1].
• PWA support. Add it to your phone’s home screen and it behaves like a native app [README].
• Established packaging. Available on AUR, Nix, and MPR — distributions that care about reproducibility [README].
• Active enough to trust. 22 releases, CI passing, test coverage above 95% — this isn’t an abandoned repo [README].

Cons

• No built-in authentication. You must wire up a reverse proxy to get any access control at all. This is by design, but it means the “simple” install is insecure for internet-facing deployments [README].
• No user management UI. Multi-user setup is handled entirely outside Gossa. There’s no admin panel, no user list, no per-user settings [README].
• No WebDAV. You can’t mount Gossa as a network drive from Windows, macOS, or mobile file managers. It’s a browser-only interface [README].
• No sharing links. You can’t generate a time-limited download link for a specific file. Either the whole server is accessible to an authenticated user or it isn’t [README].
• No S3 or remote backend. Gossa serves local filesystem paths. It can’t front an S3 bucket or a Backblaze B2 store [README].
• Sparse community. 1,078 GitHub stars and 78 forks means a small user base and limited third-party documentation. If you hit an edge case, you’re reading Go source code [README].
• Last release August 2024. Not dead, but not actively gaining features. It’s a finished tool, not a growing platform [README].
• 90s web UI. The README calls this out itself. The interface is functional but not polished — no animations, no dark mode, no responsive design beyond basic usability [README].

---

Who should use this / who shouldn’t

Use Gossa if:

• You want a file server that runs as a single binary with no dependencies, period.
• You’re comfortable setting up Caddy or nginx and understand why HTTPS matters for internet-facing services.
• You run a homelab and want a fast way to browse and share a specific directory without deploying something as large as Nextcloud.
• You care about being able to read and understand every line of code running on your server.
• You want video streaming or image browsing without installing a full media server.

Skip it if:

• You’ve never set up a reverse proxy. The tool will technically run in two commands, but you won’t be able to expose it safely without that knowledge.
• You need user management — separate login accounts, per-user file visibility, permission controls. Gossa has none of this.
• You need WebDAV to mount it as a network drive from your OS.
• You need sharing links with expiry or per-file access control.
• You want an actively growing project with a roadmap, community forum, and regular feature releases.
• You’re replacing Dropbox for a team. Gossa doesn’t have the collaboration features to compete there.

---

Alternatives worth considering

From the LinuxLinks web-based file manager roundup [2] and the self-hosted catalog [4]:

• FileBrowser — The closest comparable. Also a single-binary Go file server, but with built-in user management, a proper admin UI, and WebDAV support. More features, more code. If you need per-user authentication without configuring a reverse proxy, pick FileBrowser over Gossa.
• Dufs — Another Go-based file server with WebDAV, access controls, and search. More featureful than Gossa, still lightweight [2].
• Filestash — Dropbox-style UI with support for S3, SFTP, FTP, and other backends. Much heavier, but can front remote storage [2].
• AList — Supports dozens of storage backends including local, S3, Dropbox, Google Drive, and others. If you need to aggregate remote storage sources, AList is the right tool [2].
• Nextcloud — The full-featured option. Document editing, calendar, contacts, mobile apps, federation. Also: PHP, a database, a cron job, and a much more complex deployment. Only worth it if you actually use those features.
• OASIS — A self-hosted file server written in Rust with Svelte frontend. Newer, less battle-tested than Gossa [2].
• Tiny File Manager — PHP-based, single-file deployment. If your server already runs PHP, this requires less setup than Gossa. If it doesn’t, don’t install PHP just for this [2].

The realistic shortlist for someone who wants something like Gossa: Gossa vs FileBrowser. If you already run Caddy or nginx and want zero additional complexity in the application layer, pick Gossa. If you want to hand a URL and credentials to a non-technical person without explaining how the proxy layer works, pick FileBrowser.

---

Bottom line

Gossa earns its place by refusing to grow beyond its purpose. It’s a file server. It serves files. The entire implementation fits in a document you can read in 20 minutes, it ships as a single binary, and it runs on anything that runs Go — which is everything. The trade-offs are honest and documented upfront: no built-in auth, no WebDAV, no user management, no sharing links. If those absences are problems for you, the tool isn’t hiding that. If they’re not problems — if you just need a fast, auditable, dependency-free way to browse a directory over a browser — nothing else in the self-hosted file manager space is this simple.

For a non-technical founder expecting a Dropbox replacement, this is the wrong tool. For a developer who wants to expose a directory on their homelab and knows what Caddy is, it takes 15 minutes and then it disappears into the background and just works.

---

Sources

1. LinuxLinks — “gossa - fast and simple multimedia fileserver” (updated October 11, 2025). https://www.linuxlinks.com/gossa-fast-simple-multimedia-fileserver/
2. LinuxLinks — “15 Best Free and Open Source Web-Based Linux File Managers”. https://www.linuxlinks.com/best-free-open-source-web-based-linux-file-managers/
3. LinuxLinks — File Manager Archives. https://www.linuxlinks.com/tag/file-manager/
4. Shaynly — “A Catalog Of Self-Hosted Free Software Network Services And Web Applications”. https://shaynly.com/self-hosted-free-software/
5. Medevel — “Top 60+ Open-source Apps Written with The Go Language in 2024”. https://medevel.com/golang-apps-6729/

Primary sources:

• GitHub repository and README: https://github.com/pldubouilh/gossa (1,078 stars, MIT license, 22 releases)
• Release page: https://github.com/pldubouilh/gossa/releases
• DockerHub image: https://hub.docker.com/r/pldubouilh/gossa