Share a folder over your network. As easy as takeout!

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.

github.com/crimsonflower420/KrazyTakeoutGoBox · binary krazytogo · image ghcr.io/crimsonflower420/krazytogo:latest

Mount a folder. Open a port. Browse the files.

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.

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.

The door is the port

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.

You pick the container program

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.

Folder → box → port

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.

What the listing looks like

The built-in list is just plain names. Want it prettier? Drop an index.html in the folder.

Success looks like this

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/.

Small on purpose. Does one thing.

  • Serve a folder

    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.

  • Big files, no problem

    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.

  • Tiny official image

    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.

  • Any file type

    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.

  • Localhost or LAN

    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.

  • Read-only, on purpose

    No uploads, no logins, no admin page. You put files in the folder yourself. Need uploads or accounts? copyparty is great for that.

A port is a door on the network

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.

One box, many everyday shares

LAN folders, a USB path as links, a media companion, a short-lived zip handoff — same mount, same port idea.

Everyday shares. No fuss.

A few everyday ideas. Simple, local, and done when you're done.

  • Share a folder on the LAN

    Mount a directory you already have, publish a port, hand a roommate or teammate the URL. Same listing you see on localhost.

  • USB stick as a URL

    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.

  • Companion takeout for media apps

    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.

  • Hand off a file for an hour

    Drop a zip into a folder, start the box, and send the link. Stop it when you're done.

First run, then leave the box running

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.

first run
$ krazytogo -root ./data -addr :8080
serving ./data on :8080
$ curl -fsS http://127.0.0.1:8080/hello.txt
hello
first run

Host go install — quick first run on this machine. Fine to try; not the setup you leave running.

Install the binary
go install github.com/crimsonflower420/KrazyTakeoutGoBox/cmd/krazytogo@latest

Requires Go 1.22+. Put $(go env GOPATH)/bin on your PATH (often ~/go/bin).

Make a sample file
mkdir -p data
echo hello > data/hello.txt
Run it
krazytogo -root ./data -addr :8080
-root / KRAZY_ROOT
Directory to serve (default ./data; /data in images)
-addr / KRAZY_ADDR
Listen address (default :8080; gokrazy :80)
-browse / KRAZY_BROWSE
Directory listing (default on; off → dirs 404)

Precedence: flags > env > defaults.

Long-running path: Docker or Podman below. Kubernetes is in Deploy. Same four beats either way.

long-running
$ 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
hello
long-running

Mount → choose a container program → publish a port → open the browser. That is the long-running path.

Run the box
docker pull ghcr.io/crimsonflower420/krazytogo:latest
docker run --rm -p 8080:8080 \
  -v "$PWD/data:/data" \
  ghcr.io/crimsonflower420/krazytogo:latest
I already cloned the repo

Make the sample file first, then:

From a checkout
go run ./cmd/krazytogo -root ./data -addr :8080
Build the image yourself

From a checkout when you want to change the Dockerfile. Published image is usually enough.

docker build
docker build -t krazytogo .
docker run --rm -p 8080:8080 \
  -v "$PWD/data:/data" krazytogo
Build a local binary

Build a portable binary yourself (no extra C libraries). Make the sample file first.

Build it yourself
CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o krazytogo ./cmd/krazytogo
./krazytogo -root ./data -addr :8080

When you want that box to stay up — Docker, Podman, or Kubernetes — Deploy has the same image for each.

One image. Three container programs. You choose.

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.

Docker

Image ghcr.io/crimsonflower420/krazytogo:latest. Mount /data, publish 8080.

When Docker is already on the machine.

Docker
IMAGE=ghcr.io/crimsonflower420/krazytogo:latest
docker pull "$IMAGE"
docker run -d -p 8080:8080 \
  -v "$PWD/data:/data" "$IMAGE"

Podman

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.

Podman
IMAGE=ghcr.io/crimsonflower420/krazytogo:latest
podman pull "$IMAGE"
podman run -d -p 8080:8080 \
  -v "$PWD/data:/data:Z" "$IMAGE"

Kubernetes

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/
  • Image ghcr.io/crimsonflower420/krazytogo:latest
  • Cluster storage volume at /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.

Short answers.

What is the Krazy Takeout Go Box?

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.

What is a container program, and which one do I pick?

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).

Why Docker and Podman and Kubernetes?

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.

What is a port in this context?

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.

Localhost vs my LAN — what’s the difference?

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.

How do I know it worked?

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.

Do I need the internet?

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.

How do files get in?

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.

Who can download?

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.

Can I style the listing?

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.

Can I run this next to Jellyfin, Plex, Emby, Immich, or another media app?

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.

Should I install the Takeout Go Box inside another container?

No. Run the Takeout Go Box beside the other app. Two boxes, one share, two ports.

Can I run it without a container?

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.

How big is the binary?

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.

How huge can the share get?

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.

Can I grow the official image?

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.

Why is it krazy?

The name is a reference to gokrazy Linux.

Can I upload files?

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.

How is this different from copyparty?

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.

License / support?

GPL-3.0. If you like it, a star or a coffee is always appreciated.

Small on purpose.

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.

  • One folder

    Shares files from one folder, with an optional plain list of names in the browser.

  • Read-only

    No uploads. You put files in the folder yourself.

  • No admin UI

    The file list is the only page. No admin screen to learn.

  • One program

    One small Go program. Nothing else to install.

Support the project.

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.