Hobbyists Are Self-Hosting a Nintendo eShop With Ownfoil on a Raspberry Pi

Ownfoil is an open‑source project that lets a Nintendo Switch owner host their own personal "eShop" — a private web catalog of titles they legally own, served from a Raspberry Pi 4 on their home network and installed directly to the Switch via the homebrew Tinfoil installer. The hobbyist scene around it grew sharply this month after a series of GitHub forks added auth, HTTPS, and a cleaner UI. The setup itself is genuinely interesting hardware work: a Pi 4 8GB, a USB SSD, an hour of configuration, and a Switch already running custom firmware.

What Ownfoil actually does

Ownfoil (active forks tagged self‑hosted on GitHub) is a web app that scans a directory of legitimately‑owned game backups — NSP, NSZ, XCI files — and presents them through a browser UI and a Tinfoil‑compatible JSON catalog endpoint. The Switch, running the well‑known Atmosphere CFW with the Tinfoil installer, points at the Pi's URL and sees a private eShop populated only with the games on that drive. Installations go over HTTPS or HTTP, attribute the right title IDs, and integrate with the Switch's home menu the same way a real eShop install does.

It is, narrowly, the cleanest way for a Switch homebrew user to manage their own ROM library — assuming they have the legal right to those backups, which on the Switch is a fraught question (the U.S. courts haven't settled it; rights holders argue cartridge dumps are unauthorized circumvention). This article does not endorse downloading games you don't own. It does report on the hardware and self‑hosting story, which is interesting on its own.

Why the project is suddenly trending

Three things happened in late May 2026:

1. A new fork shipped HTTPS termination via a built‑in Caddy proxy, which made phone setup almost click‑through and eliminated the manual certificate dance that scared off non‑technical users.
2. A separate fork added per‑user accounts and access logs, which appealed to small homelab groups (a household, a small friend group) who wanted to share a library responsibly.
3. A cleanup pass on the UI brought it closer to feature parity with the real eShop — proper cover art, descriptions, and a "recently added" rail.

That combination crossed a usability threshold. Reddit's r/homelab and the Switch homebrew communities started linking the project, and search demand for "self‑host nintendo eshop pi" spiked. It is a familiar pattern in self‑hosted software — most projects coast in obscurity for years until a UI/UX update makes them mainstream‑adjacent.

The hardware piece: Raspberry Pi 4 8GB as the host

The default reference build is a Raspberry Pi 4 Model B 8GB with a USB 3.0 SSD enclosure. The reasons it works are simple: Ownfoil's workload is almost entirely disk I/O and HTTPS termination, which the Pi 4 handles comfortably; 8 GB of RAM gives the OS room for filesystem cache and a few container sidecars; and the gigabit Ethernet on the Pi 4 is the real bottleneck for transfers, not the CPU.

Real numbers from a Pi 4 8GB serving Ownfoil over a wired connection to a Switch on the same gigabit LAN:

That is fine for a single‑user household. A family of four sharing the library hits a different limit — the Pi's 4 USB 3.0 ports start fighting for bus bandwidth when two installs run concurrently, and the gigabit NIC saturates quickly. For more than two simultaneous Switches, the canonical upgrade is a Pi 5 or an old x86 thin client.

Storage planning

Modern Switch titles are 3–18 GB. A 250‑title library easily passes 2 TB. The honest storage stack for an Ownfoil Pi:

Tom's Hardware's Raspberry Pi coverage consistently notes that USB storage performance on Pi 4 is bottlenecked by the controller, not the drive — a USB 3.0 SSD typically tops out around 380 MB/s read, which is more than enough for this workload but worth knowing if you're benchmarking the Pi for other tasks.

A walkthrough of the setup

In broad strokes, an Ownfoil Pi build takes about an hour. The high‑level steps:

1. Flash Raspberry Pi OS 64‑bit Lite to a microSD card. Enable SSH at first boot.
2. Boot the Pi, install Docker and docker‑compose.
3. Mount the USB SSD at a consistent path (/mnt/games is conventional).
4. Pull an Ownfoil fork's docker‑compose file. Edit the volumes section to point at /mnt/games.
5. Bring up the stack. Caddy will fetch a Let's Encrypt cert if the Pi is reachable from a domain you own.
6. Open the web UI from a laptop, point the library scanner at the games folder, wait for the scan.
7. On the Switch (running Atmosphere CFW and Tinfoil), add the Pi's URL as a host in Tinfoil. The library appears.

This is materially simpler than the equivalent dance was three years ago. The mainline forks have prebuilt Docker images, sane defaults, and example compose files in the README. A user who knows how to SSH into a Pi and edit a YAML file can finish in 60 minutes.

The legal piece, said clearly

Switch homebrew is a legal grey zone in the U.S. The Atmosphere custom firmware and the Tinfoil installer are not themselves infringing — they are open‑source tools. Dumping a cartridge you own to an NSP file is contested but defensible under personal backup arguments; distributing those dumps is unambiguously infringing; and downloading dumps you didn't make yourself is what gets people sued. Ownfoil itself does not ship games; it indexes whatever's on your disk.

Treat it as you would a self‑hosted media server: the tool is fine, the library is yours, and what you put in the library is your responsibility. If you would not put a stack of physical cartridges on the shelf, don't put their NSPs on the Pi.

Common pitfalls

1. Insufficient power. The Pi 4 8GB with a USB SSD needs a real 5V/3A USB‑C PSU. Cheap chargers undervolt and the Pi reboots mid‑install.
2. Microsd corruption. Running the OS off microSD for an Ownfoil instance with frequent writes will eat the card in 6–12 months. Boot from the SSD instead — Pi 4 supports it.
3. Switch‑side cert errors. If you use a self‑signed cert, Tinfoil rejects it. Either run a real Let's Encrypt cert (needs DNS pointing at your Pi) or use plain HTTP on the LAN.
4. NSP vs NSZ vs XCI. Tinfoil installs all three; some forks of Ownfoil require you to set the right MIME types in Caddy for the right file extension or downloads stall.
5. Title key clashes. If two NSPs share a title ID (a base game and an update), Tinfoil sometimes shows the wrong one. The Ownfoil scanner has a deduplication option — turn it on.

Why this is actually a real homelab piece

Stripped of the Switch‑specific story, Ownfoil is a good case study in modern self‑hosted apps: clean containerization, secure‑by‑default networking, sane UX, and a real workload that benefits from cheap commodity hardware. The Pi 4 8GB has aged extremely well in this role — there are still very few sub‑$100 boards that can host a containerized service stack and serve gigabit‑saturating file transfers reliably.

If you don't run a Switch, the same hardware will happily host a Jellyfin instance (self‑hosted media server guide), a Nextcloud instance, a Pi‑hole, or any combination of small services. The Pi 4 is the floor for "self‑hosted as a hobby" in 2026 and has been for two years running.

What to watch next

The Ownfoil ecosystem is fluid. The forks change weekly. Expect:

• Eventual takedown notices targeting the most visible forks — Nintendo's lawyers do not sleep on this stuff.
• A move from the most active forks toward decentralized distribution (git repos hosted outside GitHub).
• Friendlier setup wrappers that bundle Atmosphere updates, Tinfoil, and Ownfoil under one onboarding flow.
• More handheld‑native versions — running Ownfoil on a Pi 5 with a small touchscreen as a portable library is an obvious next step.

Bottom line

Ownfoil is the moment a niche corner of the Switch homebrew scene became approachable to ordinary self‑hosters. The hardware story is the most interesting part for buyers: an inexpensive Raspberry Pi 4 8GB, a USB SSD, and a wired LAN deliver a fully functional private game catalog with throughput that saturates a Switch's wired connection. The legality question is exactly the same as it has always been on Switch homebrew — interesting tool, your library, your responsibility.

A representative bill of materials

For anyone planning a build, here's an itemized parts list with current pricing:

That's it. There is no recurring cost beyond electricity (the build pulls 5–8 W steady‑state) and your existing domain registration if you want HTTPS that doesn't trip on certs.

Ownfoil performance with a Pi 5

For completeness: a Raspberry Pi 5 8GB is faster across the board on this workload, but the bottleneck is usually the Switch's wired NIC, not the Pi. Real numbers:

For a single‑Switch household, save the money and get a Pi 4. For a 3+ Switch household, the Pi 5's extra USB bus and faster NIC pay back. Either way, the actual cap is the Switch's gigabit port (or the slower Wi‑Fi if you don't wire it).

Backup and durability

The single biggest mistake new self‑hosters make is putting everything on one disk with no backup plan. Three rules that hold up:

1. Snapshot the library elsewhere. A second cheap USB HDD with weekly rsync of the games folder is enough to survive a primary‑drive failure.
2. Back up the Ownfoil database. It's tiny (a few MB) and contains your scan state, custom metadata, and any user accounts. Include it in your nightly backup.
3. Document your stack. Six months from now you will not remember which fork you ran or which Caddy version. Write a one‑page README and check it into a private git repo.

That's not Ownfoil‑specific advice — it's true of any self‑hosted service worth running. The Pi is cheap enough that "build a redundant pair" is a real option for the obsessive.

Related guides

• Self‑Host Jellyfin on a Raspberry Pi 4 8GB
• Lenovo G02 Retro Handheld News
• The Sound Blaster Monopoly: How Creative Still Shapes Retro PC Audio

Citations and sources

• Raspberry Pi — Raspberry Pi 4 Model B Official Page
• Tom's Hardware — Raspberry Pi Coverage
• GitHub — Self‑Hosted Project Index