The share is the folder
Pick any folder you already have and mount it at /data. Photos, notes, zip files: whatever's in there shows up in your browser. Nothing to rebuild.
A tiny read-only file server for sharing a folder over a local network. Point Krazy Takeout Go Box at a folder, open your browser, and there are your files. Nobody can upload, change, or delete anything. Try it right on your computer, or keep it running with Docker, Podman, or Kubernetes.
How it works
A folder goes in. A port is the door out. Your browser walks through that door and sees your files. That's it. To keep it running, see Deploy.
Pick any folder you already have and mount it at /data. Photos, notes, zip files: whatever's in there shows up in your browser. Nothing to rebuild.
Inside the box, the server listens on :8080. Think of that number as a door. Keep it on your own computer, share it on your home network, or put something like Tailscale in front later. There are no logins built in.
To keep it running, use a container program (a tool that runs a sealed-up package of software). Docker, Podman, and Kubernetes all run the same small image. Use whichever one you have, or want to learn.
Mount the path. The box serves what is there. The port is how your browser (or a friend on the LAN) reaches it — a folder turned into a URL.
The built-in list is just plain names. Want it prettier? Drop an index.html in the folder.
Open a file URL or click a name. The file streams from the mounted folder. That is the whole trick.
The built-in folder page is a plain list of names. Put an index.html (and an optional style.css) in the folder and that page shows instead. There's a sample in examples/browse/.
Features
Point it at a folder and you get a simple list of what's inside. Click a name to open it. Handy for turning a USB stick into a set of links.
If a big download gets cut off, it can pick up where it left off. There's also a quick check page (/healthz) that tells you the box is up.
The whole thing is one small program in an almost-empty container image. No extras packed in. The same image works in Docker, Podman, and Kubernetes.
JPG, text, zip, video — if it is a file on the mounted folder, the box can serve it. Share vacation photos with a roommate on the LAN without copying a drive.
Bind so only this machine can reach it, or publish a port your LAN can use. Same listing either way — you decide how open the door is.
No uploads, no logins, no admin page. You put files in the folder yourself. Need uploads or accounts? copyparty is great for that.
Localhost keeps it on this machine. Publishing the port lets peers on your LAN reach the same listing — handy for sharing photos with a roommate. You choose how open that door is.
LAN folders, a USB path as links, a media companion, a short-lived zip handoff — same mount, same port idea.
What people use it for
A few everyday ideas. Simple, local, and done when you're done.
Mount a directory you already have, publish a port, hand a roommate or teammate the URL. Same listing you see on localhost.
Plug in a drive, mount the path into the box, open the listing. The stick becomes a set of links on the LAN — no copying a whole disk.
Keep playback in Jellyfin, Plex, Emby, Immich, or any other media app in a container. Sit the Takeout Go Box beside it on the same media folder and a second port when someone just wants the files.
Drop a zip into a folder, start the box, and send the link. Stop it when you're done.
Quick start
Host go install is a quick first run — fine to try, great as a test run. For a box you leave running, use a container program (Docker, Podman, or Kubernetes): mount a folder, publish a port. Same image either way.
Long-running path — four beats: (1) Mount a folder you already have. (2) Choose a container program (Docker, Podman, or Kubernetes). (3) Publish a port (the box listens on 8080 inside; map it on the host). (4) Open the browser — a listing or a file URL. Host go install skips the container program and is only a first run.
$ krazytogo -root ./data -addr :8080 serving ./data on :8080 $ curl -fsS http://127.0.0.1:8080/hello.txt hellofirst run
PS> krazytogo -root ./data -addr :8080 serving ./data on :8080 PS> curl.exe -fsS http://127.0.0.1:8080/hello.txt hellofirst run
Host go install — quick first run on this machine. Fine to try; not the setup you leave running.
go install github.com/crimsonflower420/KrazyTakeoutGoBox/cmd/krazytogo@latest
Requires Go 1.22+. Put $(go env GOPATH)/bin on your PATH (often ~/go/bin).
Requires Go 1.22+. Put %USERPROFILE%\go\bin on your PATH.
Requires Go 1.22+. Put $(go env GOPATH)/bin on your PATH (often ~/go/bin).
mkdir -p data
echo hello > data/hello.txt
New-Item -ItemType Directory -Force -Path data | Out-Null
Set-Content -Path data/hello.txt -Value hello
krazytogo -root ./data -addr :8080
-root / KRAZY_ROOT./data; /data in images)-addr / KRAZY_ADDR:8080; gokrazy :80)-browse / KRAZY_BROWSEPrecedence: flags > env > defaults.
Long-running path: Docker or Podman below. Kubernetes is in Deploy. Same four beats either way.
$ docker pull ghcr.io/crimsonflower420/krazytogo:latest $ docker run --rm -p 8080:8080 -v "$PWD/data:/data" \ ghcr.io/crimsonflower420/krazytogo:latest serving /data on :8080 $ curl -fsS http://127.0.0.1:8080/hello.txt hellolong-running
PS> docker pull ghcr.io/crimsonflower420/krazytogo:latest PS> docker run --rm -p 8080:8080 -v ${PWD}/data:/data ` ghcr.io/crimsonflower420/krazytogo:latest serving /data on :8080 PS> curl.exe -fsS http://127.0.0.1:8080/hello.txt hellolong-running
Mount → choose a container program → publish a port → open the browser. That is the long-running path.
docker pull ghcr.io/crimsonflower420/krazytogo:latest
docker run --rm -p 8080:8080 \
-v "$PWD/data:/data" \
ghcr.io/crimsonflower420/krazytogo:latest
docker pull ghcr.io/crimsonflower420/krazytogo:latest
docker run --rm -p 8080:8080 `
-v ${PWD}/data:/data `
ghcr.io/crimsonflower420/krazytogo:latest
Make the sample file first, then:
go run ./cmd/krazytogo -root ./data -addr :8080
From a checkout when you want to change the Dockerfile. Published image is usually enough.
docker build -t krazytogo .
docker run --rm -p 8080:8080 \
-v "$PWD/data:/data" krazytogo
Build a portable binary yourself (no extra C libraries). Make the sample file first.
CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o krazytogo ./cmd/krazytogo
./krazytogo -root ./data -addr :8080
$env:CGO_ENABLED = "0"
go build -trimpath -ldflags="-s -w" -o krazytogo.exe ./cmd/krazytogo
.\krazytogo.exe -root .\data -addr :8080
When you want that box to stay up — Docker, Podman, or Kubernetes — Deploy has the same image for each.
Deploy targets
A container program runs a sealed-up package of software. Docker, Podman, and Kubernetes all run the same ~5.4 MiB image. Mount a folder at /data and publish port 8080. Running it straight on your computer with go install is great for a first try.
Same image in each one. Pick the container program you already have. There's no wrong first choice.
Image ghcr.io/crimsonflower420/krazytogo:latest. Mount /data, publish 8080.
When Docker is already on the machine.
IMAGE=ghcr.io/crimsonflower420/krazytogo:latest
docker pull "$IMAGE"
docker run -d -p 8080:8080 \
-v "$PWD/data:/data" "$IMAGE"
Same image, runs without needing root on the host. Keep :Z on SELinux volumes. Mount /data, publish 8080.
Same image without a system-wide Docker service.
IMAGE=ghcr.io/crimsonflower420/krazytogo:latest
podman pull "$IMAGE"
podman run -d -p 8080:8080 \
-v "$PWD/data:/data:Z" "$IMAGE"
Same image. Storage at /data, service on port 8080. Ready-made, locked-down setup files are in deploy/kubernetes/.
When you already have a cluster.
kubectl apply -k deploy/kubernetes/ghcr.io/crimsonflower420/krazytogo:latest/data. Publish port 8080. Same volume shape as Docker and Podman.Bonus: run it on a Raspberry Pi with gokrazy. Same program, built with -tags gokrazy.
FAQ
A tiny read-only file server for sharing a folder over a local network. As easy as takeout! I'm a new vibe coder and this is my first vibe-coded project. I haven't tested it on my own home network yet, so treat it as an early project.
A container program is a tool that runs an isolated package of software. Docker, Podman, and Kubernetes all run the same Takeout Go Box image. Mount your folder at /data, publish :8080. Pick the one you already use (or want to learn).
Because you already run one of them — or you are learning one. They are three launchers for one Takeout Go Box, not three editions of the product.
A port is a numbered door on the machine’s network. The Takeout Go Box listens on 8080 inside. When you publish it (for example -p 8080:8080), your browser reaches the files through that door — like opening a takeout window on localhost or the LAN.
127.0.0.1 (localhost) only this computer can open. Your LAN address (often 192.168.…) lets other devices on the same home or office network open the same listing. Start on localhost; publish wider only when you mean to share.
Open http://127.0.0.1:8080/ — you should see a plain list of names from the mounted folder. Click a file (or open its URL) and it downloads or displays. Connection refused usually means nothing is listening on that port; a 404 usually means the file is not on the mounted path.
Not to serve files on localhost or your LAN. You need the network once to go install or pull the image; after that, a local mount and a published port work offline. Peers on the LAN reach you without the public internet.
You put them in the mounted folder (copy them, sync them, or plug in a drive). They show up in the list. There's no way to log into the box itself, and that's on purpose.
Anyone who can reach the port. Use localhost to keep it on just your computer. For a more private share, put something like Tailscale or Caddy in front. There's no login built in.
Official list is plain names. Put index.html on the volume to replace it — see examples/browse. A lone style.css cannot restyle the auto list, because the auto list does not link it.
Yes. Run it next to any media app in a container. Mount the same media folder into both. Keep the app on its own port and give the Takeout Go Box a different one (inside the box it's :8080). See the media companion tutorial. Anyone who can reach the port can download the files, so put something like Tailscale in front if it shouldn't be public.
No. Run the Takeout Go Box beside the other app. Two boxes, one share, two ports.
Yes — host go install is a quick first run. Fine to try. For anything you want to keep running, use a container program (Docker, Podman, or Kubernetes): mount a folder, publish a port.
About 5.4 MiB on 64-bit Linux (amd64). It only uses what comes with Go, and the official image holds just the program. Nothing else.
The image stays tiny. The ceiling is the filesystem you mounted — no product cap. A single file on ext4 is about 16 TiB; cloud disks commonly reach 64 TiB each.
No. Keep the official image tiny. Need extra tools? Run a helper container beside the Takeout Go Box. For plugging in a drive and serving it, see the USB drive tutorial.
The name is a reference to gokrazy Linux.
No. It only shares files; it never changes them. You put files in the folder yourself. The giant Takeout Go Box tutorial shows how to share lots of folders at once.
copyparty is a much bigger, mature file server with uploads, accounts, and lots more. If you need any of that, use copyparty. It's great. Krazy Takeout Go Box is the opposite: it just shares a folder for reading, with nothing to set up.
What it does (and doesn't)
I'm a new vibe coder and this is my first vibe-coded project, so I kept it small. Anything extra runs next to the box, not inside it.
Shares files from one folder, with an optional plain list of names in the browser.
No uploads. You put files in the folder yourself.
The file list is the only page. No admin screen to learn.
One small Go program. Nothing else to install.
Tutorials
Three easy walkthroughs for folks who know their way around folders and are learning about ports. The box stays tiny. Your folder, and the apps next to it, do the rest.
Same media folder in Jellyfin, Plex, Emby, Immich — or anything else — and the Takeout Go Box. Companion listing on a second port — handy when someone just wants the files.
Plug in a drive, mount the path into the box, publish a port — hand the USB as a URL on the LAN.
Mount directories from all over your computer into one share on a single port.
Go krazy — leave the toolkit on the other side of the wall.
Support
Krazy Takeout Go Box is free and open source (GPL-3.0). If it saves you an afternoon, a star or a coffee would make my day. No pressure.