A web interface for monitoring and managing your LANCache. Track downloads in real-time, identify which games are being cached, measure bandwidth savings, and prefill your cache before LAN parties.

docker pull ghcr.io/regix1/lancache-manager:latest

• Screenshots
• Features
• Quick Start
• Docker Compose Reference
• Configuration Options
• Tabs Overview
• Steam Prefill
• Custom Themes
• Grafana & Prometheus
• Multiple Datasources
• Troubleshooting
• Building from Source
• Need Help?

Dashboard

Stats at a glance with draggable cards and time range filtering

Downloads

Normal View

Compact View

Retro View

Three view modes to browse your cached games

Clients

Monitor which devices are using your cache

Users

Manage sessions and access controls

Events

Calendar view of download activity and LAN events

Prefill

Pre-download games to your cache before your LAN party

• Draggable stat cards - Reorder or hide cards to customize your view
• Time range filtering - View stats for live, 1h, 24h, 7 days, 30 days, or custom ranges
• Service breakdown - See bandwidth usage per platform (Steam, Epic, Battle.net, etc.)
• Recent downloads - Quick view of what's been cached
• Top clients - Identify your heaviest users

• Three view modes - Normal (cards), Compact (list), and Retro (terminal style)
• Flexible sorting - By date, size, cache efficiency, session count, or name
• Powerful filtering - By service, client, or hide small/unknown downloads
• Data export - JSON or CSV

• Device tracking - See all devices that have used your cache
• Client grouping - Organize clients with custom names
• Bandwidth stats - Track usage per client

• Session management - View active authenticated and guest sessions
• Guest access - Configurable read-only access duration
• Access control - Revoke sessions as needed

• Calendar view - Visualize download activity over time
• Custom events - Create events for LAN parties
• Activity tracking - See what was downloaded during each event

• Steam integration - Pre-download games directly to your cache
• Steam Guard support - Works with all authentication methods
• Library selection - Choose which games to prefill
• Real-time progress - Monitor downloads as they happen

• Cache operations - Clear cache by service or remove specific games
• Log processing - Reprocess logs, handle corruption
• Game detection - See what games are in your cache with actual sizes
• Depot mappings - Download 290,000+ game mappings from GitHub
• Theme editor - Create and import custom themes
• Prometheus metrics - Export data to Grafana

docker run -d \
  --name lancache-manager \
  -p 8080:80 \
  -v ./data:/data \
  -v /path/to/lancache/logs:/logs:ro \
  -v /path/to/lancache/cache:/cache:ro \
  -e TZ=America/Chicago \
  -e LanCache__LogPath=/logs/access.log \
  -e LanCache__CachePath=/cache \
  ghcr.io/regix1/lancache-manager:latest

docker logs lancache-manager | grep "API Key"

The key is also saved to /data/api_key.txt.

1. Open http://localhost:8080
2. Navigate to Management and enter your API key
3. Click Process Logs to analyze your existing cache data

A complete docker-compose.yml with all available options:

version: '3.8'

services:
  lancache-manager:
    image: ghcr.io/regix1/lancache-manager:latest
    container_name: lancache-manager
    restart: unless-stopped
    ports:
      - "8080:80"
    volumes:
      - ./data:/data
      - /mnt/lancache/logs:/logs:ro
      - /mnt/lancache/cache:/cache:ro
      - /var/run/docker.sock:/var/run/docker.sock

    environment:
      #===========================================================
      # REQUIRED - You must configure these for your environment
      #===========================================================

      # User/Group ID - match your LANCache filesystem permissions
      - PUID=33
      - PGID=33

      # Your timezone
      - TZ=America/Chicago

      # Paths to your LANCache log file and cache directory
      - LanCache__LogPath=/logs/access.log
      - LanCache__CachePath=/cache

      #===========================================================
      # OPTIONAL - Defaults work for most users (auto-detected)
      #===========================================================

      # Internal port binding (do not change)
      - ASPNETCORE_URLS=http://+:80

      # Security (all have sensible defaults)
      # - Security__EnableAuthentication=true
      # - Security__MaxAdminDevices=3
      # - Security__GuestSessionDurationHours=6
      # - Security__RequireAuthForMetrics=false
      # - Security__ProtectSwagger=true

      # Nginx log rotation (auto-detects container name)
      # - NginxLogRotation__Enabled=true
      # - NginxLogRotation__ContainerName=
      # - NginxLogRotation__ScheduleHours=24

      # Memory management (leave disabled unless needed)
      # - Optimizations__EnableGarbageCollectionManagement=false

      # Cache clearing mode
      # - CacheClear__DeleteMode=preserve

      # Steam Prefill (all auto-detected)
      # - Prefill__DockerImage=ghcr.io/regix1/steam-prefill-daemon:latest
      # - Prefill__SessionTimeoutMinutes=120
      # - Prefill__DaemonBasePath=/data/prefill-sessions
      # - Prefill__HostDataPath=

      # Multiple datasources (auto-discovery available)
      # - LanCache__AutoDiscoverDatasources=true
      # - LanCache__DataSources__0__Name=Default
      # - LanCache__DataSources__0__CachePath=/cache
      # - LanCache__DataSources__0__LogPath=/logs
      # - LanCache__DataSources__0__Enabled=true

Your home base for cache statistics. View overall performance, recent activity, and service breakdowns. Stat cards are draggable—arrange them however you prefer.

Browse everything that's been cached. Choose between Normal view (cards with game art), Compact view (dense list for scanning), or Retro view (terminal aesthetic). Filter and sort to find what you're looking for.

Track every device that has downloaded through your cache. Group clients together with friendly names to identify machines at your LAN party.

Manage active sessions. See who's connected, configure guest access duration, and revoke sessions when needed.

A calendar showing download activity over time. Create custom events to mark LAN parties, then review what got downloaded during each one.

Pre-download games to your cache before people arrive. Log in with Steam, select games from your library, and let them download overnight.

The admin panel (requires authentication). Process logs, clear cache, download depot mappings, configure Steam API access, manage themes, and handle database operations.

The Prefill tab lets you pre-download games to your cache before your LAN party starts. This feature is powered by steam-lancache-prefill by @tpill90.

• Docker socket mounted (without :ro)
• Authenticated as admin
• Lancache-dns container running (or manual DNS configuration)

For prefill to work, the prefill container must resolve Steam CDN domains to your cache. The app auto-detects this in most cases:

• If your lancache-dns uses network_mode: host, prefill containers will also use host networking
• Otherwise, it uses the lancache-dns container's IP address for DNS resolution

Manual configuration (if auto-detection fails):

environment:
  # Option 1: Use host networking (simplest for host-networked lancache-dns)
  - Prefill__NetworkMode=host

  # Option 2: Explicit DNS IP (for bridge-networked lancache-dns)
  - Prefill__LancacheDnsIp=192.168.1.10

1. Navigate to the Prefill tab
2. Log in with your Steam account (Steam Guard supported)
3. Select games from your library
4. Start the prefill

Downloads run in a separate container with real-time progress updates. When your guests arrive, the games are already cached and ready to serve at full speed.

If you're migrating from steam-lancache-prefill or have a list of Steam App IDs you want to prefill, you can import them directly:

1. Click Select Apps to open the game selection modal
2. Click Import App IDs to expand the import section
3. Paste your App IDs in any of these formats:
   • Comma-separated: 730, 570, 440
   • JSON array: [730, 570, 440]
   • One per line
4. Click Import

The import will show you how many games were added, how many were already selected, and how many IDs aren't in your Steam library (these will be skipped during prefill).

Migrating from steam-lancache-prefill: Copy the contents of your selectedAppsToPrefill.json file and paste it directly into the import field.

Navigate to Management > Preferences > Theme Management to:

• Create themes from scratch with live preview
• Browse and install community themes
• Import/export themes as TOML files

[meta]
name = "My Theme"
id = "my-theme"
isDark = true
version = "1.0.0"
author = "Your Name"

[colors]
primaryColor = "#3b82f6"
bgPrimary = "#111827"
textPrimary = "#ffffff"

Themes are stored in /data/themes/.

scrape_configs:
  - job_name: 'lancache-manager'
    static_configs:
      - targets: ['lancache-manager:80']
    scrape_interval: 30s
    metrics_path: /metrics

For authenticated metrics, set Security__RequireAuthForMetrics=true and add:

    authorization:
      type: Bearer
      credentials: 'your-api-key-here'

# Cache hit rate as percentage
lancache_cache_hit_ratio * 100

# Bandwidth saved in last 24 hours
increase(lancache_cache_hit_bytes_total[24h])

# Cache size in GB
lancache_cache_size_bytes / 1024 / 1024 / 1024

Most users run a single LANCache instance and don't need this section. However, if you have outsourced specific services to separate cache directories or run multiple LANCache instances, you can configure multiple datasources to monitor them all from one dashboard.

• Outsourced services - You've configured LANCache to store Steam on a separate drive from other services
• Multiple LANCache instances - You run separate cache servers for different purposes
• Segmented storage - Different services on different drives or partitions

Each datasource represents a log/cache directory pair. The app processes logs and tracks cache usage separately for each, then combines the data in the dashboard and downloads views.

The simplest approach—let the app scan for matching subdirectories:

environment:
  - LanCache__LogPath=/logs
  - LanCache__CachePath=/cache
  - LanCache__AutoDiscoverDatasources=true

What it detects:

1. Root-level datasource - If /logs/access.log exists and /cache contains LANCache hash directories (00/, 01/, etc.), creates a "Default" datasource
2. Subdirectory datasources - For each folder that exists in both /cache and /logs, creates a named datasource (e.g., /cache/steam + /logs/steam → "Steam")

Example directory structure:

/mnt/lancache/
├── cache/
│   ├── 00/, 01/, a1/, ff/    ← Default cache (hash dirs at root)
│   ├── steam/
│   │   └── 00/, 01/, ...     ← Outsourced Steam
│   └── epic/
│       └── 00/, 01/, ...     ← Outsourced Epic
└── logs/
    ├── access.log            ← Default log
    ├── steam/
    │   └── access.log        ← Steam log
    └── epic/
        └── access.log        ← Epic log

This creates three datasources: Default, Steam, and Epic.

For precise control or when directories are on separate drives, define each datasource explicitly:

environment:
  # Main LANCache
  - LanCache__DataSources__0__Name=Default
  - LanCache__DataSources__0__CachePath=/cache
  - LanCache__DataSources__0__LogPath=/logs
  - LanCache__DataSources__0__Enabled=true

  # Steam on a separate drive
  - LanCache__DataSources__1__Name=Steam
  - LanCache__DataSources__1__CachePath=/steam-cache
  - LanCache__DataSources__1__LogPath=/steam-logs
  - LanCache__DataSources__1__Enabled=true

With corresponding volume mounts:

volumes:
  - /mnt/lancache/cache:/cache:ro
  - /mnt/lancache/logs:/logs:ro
  - /mnt/steam-drive/cache:/steam-cache:ro
  - /mnt/steam-drive/logs:/steam-logs:ro

1. Verify the log path in Management > Settings
2. Confirm your volume mount matches LanCache__LogPath
3. Click Process Logs in Management
4. Check container logs: docker logs lancache-manager

1. Download latest mappings from Management > Depot Mappings
2. Add custom mappings for private depots if needed
3. Click Reprocess All Logs after adding mappings

cat ./data/api_key.txt
# or
docker logs lancache-manager | grep "API Key"

To generate a new key, stop the container, delete ./data/api_key.txt, and restart.

Verify PUID/PGID match your file ownership:

ls -n /path/to/cache

1. Ensure Docker socket is mounted without :ro
2. Confirm you're authenticated as admin
3. Check container logs for errors
4. HTTP 400 errors during download: The prefill container can't resolve Steam CDN domains to your cache. Either:
   • Set Prefill__NetworkMode=host if your lancache-dns uses host networking
   • Set Prefill__LancacheDnsIp to your lancache-dns IP address
   • The app auto-detects this if your lancache-dns container is running

Finding your lancache-dns IP:

docker inspect lancache-dns | grep IPAddress

Example for host networking setups:

environment:
  - Prefill__NetworkMode=host

Requirements: .NET 8 SDK, Node.js 20+, Rust 1.75+

git clone https://github.com/regix1/lancache-manager.git
cd lancache-manager

# Rust processor
cd rust-processor && cargo build --release

# Web interface
cd ../Web && npm install && npm run dev  # http://localhost:3000

# API
cd ../Api/LancacheManager && dotnet run  # http://localhost:5000

Docker build:

docker buildx build \
  --platform linux/amd64,linux/arm64 \
  -t ghcr.io/regix1/lancache-manager:latest \
  --push .

If you run into issues, feel free to open an issue on GitHub.

You can also find the LANCache community at the LanCache.NET Discord.

Enjoying LANCache Manager?

If this project has been helpful, consider supporting development.

☕ Click to donate

Every coffee helps keep this project alive!

MIT License