Self-Hosted Game Download Cache Servers: LanCache vs SteamCache vs NetBoot.xyz

Introduction

Modern PC games routinely exceed 100 GB, and re-downloading them across multiple computers in a household or LAN party consumes bandwidth and time. A game download cache server sits on your local network and stores downloaded game files — when a second computer requests the same game, the cache serves it at local network speed (often 10 Gbps) instead of re-downloading from the internet. Three tools lead this space: LanCache, SteamCache, and NetBoot.xyz. This guide compares their architecture, supported platforms, and deployment.

Comparison Overview

LanCache: Multi-CDN Transparent Cache

LanCache is the most comprehensive game cache solution. It acts as a transparent caching reverse proxy — you configure your router to redirect traffic destined for game CDNs through LanCache, which caches the responses. The next request for the same file is served from the local cache.

Key Strengths:

• Caches Steam, Epic Games Store, Origin, Uplay, Battle.net, Riot Games, Nintendo eShop, and Windows Update
• DNS-based redirection (no client-side configuration needed)
• Supports cache pre-filling for planned LAN parties
• SNI proxy for HTTPS content (requires custom CA certificate on clients)
• Docker Compose deployment with modular services

Docker Compose Deployment:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

version: "3.8"
services:
  lancache-dns:
    image: lancachenet/lancache-dns:latest
    container_name: lancache-dns
    environment:
      - USE_GENERIC_CACHE=true
      - LANCACHE_IP=192.168.1.100
      - UPSTREAM_DNS=1.1.1.1
    ports:
      - "53:53/udp"
      - "53:53/tcp"
    restart: unless-stopped

  lancache-monolithic:
    image: lancachenet/monolithic:latest
    container_name: lancache-monolithic
    environment:
      - CACHE_ROOT=/data/cache
      - CACHE_DISK_SIZE=500g
      - CACHE_MAX_AGE=3650d
      - UPSTREAM_DNS=1.1.1.1
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /mnt/cache:/data/cache
    restart: unless-stopped

  lancache-sni-proxy:
    image: lancachenet/sniproxy:latest
    container_name: lancache-sni-proxy
    environment:
      - UPSTREAM_DNS=1.1.1.1
    ports:
      - "444:443"
    restart: unless-stopped

  steam-prefill:
    image: tpill90/steam-lancache-prefill:latest
    container_name: steam-prefill
    volumes:
      - /mnt/cache:/data/cache
    command: prefill --all
    restart: "no"

The optional steam-prefill container primes the cache before a LAN party by pre-downloading popular games. This means guests arrive and download at full LAN speed from the first byte, without waiting for the cache to warm up.

LanCache’s modular architecture allows you to customize which CDNs are cached. The DNS container resolves game CDN hostnames to your LanCache IP. The monolithic container handles the actual caching. The optional SNI proxy intercepts HTTPS connections (which most modern game clients use) by presenting a custom CA certificate — clients must trust this certificate, which is easy on your own machines but may be impractical for guest devices.

SteamCache: DNS-Based Steam-Only Cache

SteamCache takes a simpler approach by using only DNS redirection. It does not attempt to intercept or decrypt HTTPS traffic — instead, it serves cached content over plain HTTP by redirecting Steam’s content server DNS entries to your local cache server. Since Steam still supports HTTP for content delivery, this avoids the SSL complexity entirely.

Key Strengths:

• No SSL certificates required
• Minimal resource usage (~128 MB RAM, ~50 MB disk for the cache database)
• Extremely simple configuration
• Works as a DNS server or as a standalone cache
• Battle-tested at large LAN parties (DreamHack, QuakeCon)

Docker Compose Deployment:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

version: "3.8"
services:
  steamcache-dns:
    image: steamcache/steamcache-dns:latest
    container_name: steamcache-dns
    environment:
      - STEAMCACHE_IP=192.168.1.100
      - UPSTREAM_DNS=1.1.1.1
      - LANCACHE_IP=192.168.1.100
    ports:
      - "53:53/udp"
    restart: unless-stopped

  steamcache:
    image: steamcache/steamcache:latest
    container_name: steamcache
    environment:
      - CACHE_ROOT=/data/cache
      - CACHE_DISK_SIZE=500g
      - CACHE_MAX_AGE=3650d
    volumes:
      - /mnt/steamcache:/data/cache
    ports:
      - "80:80"
    restart: unless-stopped

The key difference from LanCache is the absence of the SNI proxy. SteamCache only caches HTTP content — which works because Steam’s content delivery network (powered by Akamai and CloudFront) still supports HTTP range requests for game downloads. This covers the vast majority of Steam game data. However, it cannot cache Epic Games Store, Battle.net, or other launchers that require HTTPS.

SteamCache is ideal for households or small LAN parties focused on Steam games. The zero-certificate approach means zero client configuration — just point your router’s DNS to the SteamCache DNS server and every device on the network benefits automatically.

NetBoot.xyz: Network Booting and OS Image Caching

NetBoot.xyz serves a different but complementary purpose. Rather than caching game downloads, it provides network booting (PXE/iPXE) for operating system installers, live environments, and utility ISOs. It is commonly deployed alongside game cache servers at LAN parties to let attendees quickly re-image machines or boot diagnostic tools.

Key Strengths:

• Boots Linux distributions, Windows PE, and utility ISOs over the network
• No USB drives needed for OS installation
• Self-updating menu of available operating systems
• Can cache ISOs locally for repeated use
• Integrates with existing DHCP/TFTP infrastructure

Docker Compose Deployment:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

version: "3.8"
services:
  netbootxyz:
    image: lscr.io/linuxserver/netbootxyz:latest
    container_name: netbootxyz
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/Chicago
      - MENU_VERSION=2.0.72
    volumes:
      - ./netbootxyz/config:/config
      - ./netbootxyz/assets:/assets
    ports:
      - "3000:3000"
      - "69:69/udp"
      - "8080:80"
    restart: unless-stopped

NetBoot.xyz presents a boot menu over PXE (Preboot Execution Environment). When a computer boots from the network, it loads the NetBoot.xyz menu and can select from dozens of operating systems to boot or install. The web interface at port 3000 lets you manage which ISOs are available, download new ones, and configure boot parameters.

At a LAN party, NetBoot.xyz eliminates the need for USB installers. Attendees can boot into a live Linux environment, install Windows from a cached ISO, or run hardware diagnostics — all without physical media. Combined with a game cache server, this creates a turnkey gaming event infrastructure.

Why Self-Host Your Game Cache?

Downloading a 150 GB game at a 12-person LAN party means 1.8 TB of internet traffic if everyone downloads independently. With a cache server, the first download pulls from the internet at your connection speed (e.g., 100 Mbps = ~3.5 hours for 150 GB). Every subsequent download pulls from the cache at LAN speed (1 Gbps = ~20 minutes, 10 Gbps = ~2 minutes). The savings compound dramatically — 12 people downloading the same 150 GB game at a LAN party without a cache would take 42 hours of cumulative download time. With a cache, it takes 3.5 hours for the first person and 20 minutes each for the remaining 11 — a 6x time savings.

Beyond LAN parties, a cache server benefits multi-gamer households. When you and your family members play the same games, only one copy needs to traverse your internet connection. Game updates — which can be 50+ GB — are also cached. Your ISP data cap goes further when each update downloads only once.

For an in-depth guide on managing game servers themselves, see our self-hosted game server management comparison. If you want to run your own game servers on self-hosted platforms, check out our game server platforms guide. For general game server setup, our Pterodactyl setup guide covers the full deployment.

Optimizing Cache Performance

Storage: Use SSDs for the cache volume. Game downloads involve many small files assembled into large archives — SSDs handle this random I/O pattern far better than spinning disks. A 1-2 TB NVMe SSD costs under $100 and can cache hundreds of games. For large events, consider a RAID 0 array for maximum throughput.

Network: Place the cache server on the same switch as gaming clients. Avoid routing cache traffic through consumer-grade routers, which often bottleneck at 500 Mbps to 1 Gbps. A dedicated gigabit switch with the cache server connected at 10 Gbps ensures cache reads never saturate the network link.

DNS Configuration: Both LanCache and SteamCache work by intercepting DNS queries for game CDN domains. Configure your DHCP server to hand out the cache server’s IP as the primary DNS. For robustness, set a public DNS (like 1.1.1.1 or 8.8.8.8) as the secondary DNS — if the cache goes down, clients fall back to direct downloads automatically.

Pre-Filling Strategy: Use steam-lancache-prefill to warm the cache before events. Run it overnight to download the top 50 most popular Steam games to the cache. The tool accepts game App IDs and can prioritize by player count. For multi-CDN events, manually trigger downloads of popular titles from each launcher to prime their respective caches.

LAN Party Infrastructure Stack

A complete LAN party infrastructure combines all three tools:

1. LanCache handles multi-platform game downloads (Steam, Epic, Battle.net, etc.)
2. SteamCache serves as a lighter alternative or failover for Steam-only content
3. NetBoot.xyz provides network booting for OS installs and utilities
4. A dedicated switch connects everything at 10 Gbps
5. DHCP server points DNS to the cache and provides PXE boot options

This stack transforms any space into a professional-grade gaming event venue. Attendees arrive with their computers, boot from the network if they need an OS reinstall, and download games at LAN speed from the local cache. Total internet usage drops by 80-90% compared to direct downloads.

FAQ

Does LanCache work with consoles (PlayStation, Xbox, Nintendo Switch)?

Partially. LanCache can cache Nintendo Switch game downloads because Nintendo uses standard HTTP CDN infrastructure that LanCache’s DNS redirection can intercept. PlayStation and Xbox use proprietary protocols with certificate pinning, making them much harder to cache. For console-heavy households, consider a dedicated SteamCache for PC games and accept that console downloads will bypass the cache.

How much storage do I need for a game cache?

A 1 TB SSD comfortably caches 8-15 AAA games. For a household with 3-4 gamers, 1 TB provides good coverage. For LAN parties with 10-20 attendees, 2-4 TB is recommended, especially if you pre-fill with popular titles. Use CACHE_MAX_AGE to automatically expire old content — games that haven’t been requested in 365 days are unlikely to be needed again.

Can I run LanCache on a Raspberry Pi?

Technically yes, but not recommended. The ARM CPU and USB-attached storage on a Raspberry Pi 4 bottleneck at ~30-40 MB/s, which is slower than a typical 300 Mbps internet connection. A used small-form-factor PC with an NVMe slot and a gigabit Ethernet port costs $150-200 and delivers 10x the cache throughput. Save the Pi for Shairport Sync instead.

Does caching game downloads violate any terms of service?

Game cache servers have been used at major LAN events (DreamHack, QuakeCon, Intel LANFest) for over a decade with no legal issues. They function identically to a standard HTTP caching proxy, which is a fundamental internet technology. Valve (Steam) has never objected to cache servers; some game publishers are even aware of and informally support the practice because it reduces load on their CDNs during large events.

What is the difference between LanCache and SteamCache since both use lancachenet images?

SteamCache is the original project that started the game caching movement. LanCache is its successor, created by the same community. The main difference is scope: SteamCache focuses only on Steam, while LanCache has expanded to cover multiple game platforms and Windows Update. Both use the same underlying caching engine (nginx with custom modules). SteamCache is simpler to deploy; LanCache is more capable. If you only play Steam games, SteamCache is sufficient. If you use multiple launchers, LanCache is the better choice.

💰 Want to test your market judgment? I use Polymarket for prediction market trading — the world’s largest prediction market platform. From election outcomes to technology regulation timelines, you can stake on anything. Unlike gambling, this is a genuine information market: the more you know, the better your odds. I’ve earned consistently by predicting technology-related event trends. Sign up with my referral link: Polymarket.com