Deadlock Dedicated Proton Server

Run Valve's Deadlock dedicated server on Linux using Docker and GE-Proton, with the Deadworks modding framework bundled in. A temporary solution until Valve publishes a native Linux server binary.

Based on the original deadlock-proton-server by 8ucz3k, updated with critical fixes for current Deadlock versions.

What's different from the original?

Issue	Original repo	This repo
Proton version	GE-Proton9-5 (missing SteamClient023)	GE-Proton10-34 (supports SteamClient023)
Executable name	project8.exe (renamed by Valve)	deadworks.exe (Deadworks-wrapped deadlock.exe)
Virtual display	None	Xvfb included (required by Proton/Wine)
Vulkan support	None (crashes on headless)	Mesa llvmpipe software Vulkan
Default map	street_test (doesn't exist)	dl_streets
Skip updates	Not supported	SKIP_UPDATE=1 to skip SteamCMD on restart
Modding framework	None	Deadworks bundled (always launched via deadworks.exe)

Deadworks integration

The image bundles the Deadworks server-side modding framework:

• The Deadworks release artifact is downloaded at image build time into /opt/deadworks/ and overlaid onto the game directory each time the container starts (so SteamCMD validation can't strip it).
• The Windows .NET 10 runtime is bundled at /opt/dotnet/ and exposed to Wine via DOTNET_ROOT=Z:\opt\dotnet.
• The server is launched via deadworks.exe instead of deadlock.exe. Plugins drop into Deadlock/game/bin/win64/managed/plugins/.

To pin a specific Deadworks or .NET version, override the build args:

docker build \
  --build-arg DEADWORKS_VERSION=v0.4.6 \
  --build-arg DOTNET_VERSION=10.0.0 \
  -t deadlock-server -f docker/Dockerfile docker/

Important: Performance Expectations

This is not like hosting a CS2 server. Expect higher resource usage compared to traditional Source engine dedicated servers.

CS2 and other Source engine games ship a native Linux dedicated server binary (srcds) that runs headless — no GPU, no rendering pipeline, just pure game simulation. That's why CS2 servers run fine on cheap CPU-only VPS instances.

Deadlock does not have a native Linux server binary. As of April 2026, Valve only provides a Windows executable (deadlock.exe), with no separate dedicated server AppID or headless mode (Steam Community discussion, SteamDB). This project works around that by running the Windows binary through GE-Proton (Wine), which means:

• DXVK + Vulkan rendering is still active even in dedicated mode. On servers without a GPU, this falls back to Mesa llvmpipe (software rendering on CPU).
• Higher CPU and memory usage compared to a native headless server.

Headless rendering optimizations

This image includes aggressive optimizations to minimize the rendering overhead:

Optimization	What it does
Xvfb 640x480x8	Minimal virtual display (down from 1024x768x16)
-width 640 -height 480	Forces Source 2 to render at minimum resolution
+fps_max 30	Caps render FPS (server tick rate is independent)
WINEDEBUG=-all	Suppresses all Wine debug output (major CPU saver)
DXVK_LOG_LEVEL=none	Disables DXVK logging
DXVK_STATE_CACHE=0	Disables shader cache disk I/O
MESA_NO_ERROR=1	Skips OpenGL error checking
LP_NUM_THREADS=2	Limits llvmpipe to 2 CPU threads (default: all cores)
PROTON_LOG=0	Disables Proton debug logging
-nojoy	Disables joystick subsystem
-novid	Skips intro video

Recommended hardware:

• 4+ CPU cores (8+ recommended for smoother performance)
• 8 GB+ RAM (16 GB+ recommended)
• A server with a GPU will perform significantly better, but is not required

This is a community workaround. When Valve releases a proper headless Linux server binary (like they did for CS2), these limitations will go away.

Requirements

• Linux server with 4 GB+ RAM (8 GB+ recommended) and 40 GB+ free disk space
• Docker and Docker Compose
• A Steam account that owns Deadlock

Quick start

# 1. Clone this repo
git clone https://github.com/Oskar-Sterner/deadlock-dedicated-proton-server.git
cd deadlock-dedicated-proton-server

# 2. Build the Docker image (~1.5 GB download)
docker build -t deadlock-server -f docker/Dockerfile docker/

# 3. Configure your server
cp env.sample .env
nano .env  # Add your Steam credentials and server settings

# 4. Start the server (~36 GB game download on first run)
docker compose up -d

# 5. Watch the logs
docker compose logs -f

Configuration

Edit .env to configure the server:

# Server settings
PORT=27015
SERVER_PASSWORD=            # Leave empty for no password
MAP=dl_streets              # Available: dl_streets, dl_midtown, dl_hideout

# Steam credentials (required for downloading game files)
STEAM_LOGIN=your_username
STEAM_PASSWORD=your_password
STEAM_2FA_CODE=XXXXX        # From Steam Guard mobile app

# Set to 1 after initial download to skip SteamCMD on restarts
SKIP_UPDATE=0

Available maps

Map	File size
dl_streets	892 MB
dl_midtown	1008 MB
dl_hideout	370 MB

System tuning

Raise vm.max_map_count (required for Wine/Proton games):

# Apply immediately
sudo sysctl -w vm.max_map_count=2147483642

# Persist across reboots
echo 'vm.max_map_count=2147483642' | sudo tee -a /etc/sysctl.conf

Managing the server

# View logs
docker compose logs -f

# Stop the server
docker compose down

# Restart the server
docker compose restart

# Update game files (requires fresh 2FA code in .env)
# Edit .env with new STEAM_2FA_CODE, then:
docker compose down && docker compose up -d

RCON

There is no interactive console. Use RCON to manage the server:

• RCON is available on the same port as the game server (default 27015)
• Use any Source engine RCON client to connect

Server config

Place a server.cfg file in server/Deadlock/game/citadel/cfg/ to configure server convars.

Updating

Game updates

When Deadlock receives an update:

1. Get a fresh Steam Guard 2FA code
2. Update STEAM_2FA_CODE in .env
3. Set SKIP_UPDATE=0 in .env
4. Restart: docker compose down && docker compose up -d

Proton updates

If a newer GE-Proton is needed, edit the PROTON_VERSION build arg in docker/Dockerfile and rebuild:

docker build --no-cache -t deadlock-server -f docker/Dockerfile docker/
docker compose down && docker compose up -d

Troubleshooting

Server crashes immediately on map load

The most common cause is an outdated Proton version missing the SteamClient023 interface. Make sure you're using GE-Proton10-34 or newer.

Check which interfaces your Proton supports:

docker run --rm --entrypoint bash deadlock-server -c \
  'cat /home/steam/.steam/steam/compatibilitytools.d/GE-Proton*/files/lib/wine/x86_64-unix/lsteamclient.so \
   | tr -d "\0" | grep -oP "SteamClient0[0-9]+" | sort -u'

You need SteamClient023 in the output.

Server hangs on "hanging forever..."

Check the logs above that message for the actual error. Common causes:

• Wrong Steam credentials or expired 2FA code
• Permissions issue on the server/Deadlock directory
• Game executable not found (check if Valve renamed it again)

"Two-factor code mismatch" error

Steam Guard codes expire quickly. Get a fresh code, update .env, and restart.

After the initial download, set SKIP_UPDATE=1 in .env so restarts don't need a fresh 2FA code.

High CPU during startup

Normal. The server uses significant CPU while loading the map (especially with software Vulkan rendering via llvmpipe). It settles down after initialization. With the built-in rendering optimizations, idle CPU usage should be significantly lower than without them.

How it works

1. SteamCMD downloads the Windows Deadlock server files (App ID 1422450)
2. Deadworks files (bundled in the image at /opt/deadworks/) are overlaid onto the game directory at startup, and the bundled .NET 10 runtime is exposed via DOTNET_ROOT
3. GE-Proton (a Wine-based compatibility layer) runs deadworks.exe on Linux
4. Xvfb provides a minimal virtual display (640x480x8) that Proton requires
5. Mesa llvmpipe provides software Vulkan rendering, tuned for minimal CPU usage
6. DXVK/Wine/Proton are configured to suppress logging, disable caches, and skip unnecessary subsystems
7. Docker wraps everything for portability and isolation

Credits

• Original concept: 8ucz3k/deadlock-proton-server
• Deadworks — server-side modding framework
• GE-Proton by GloriousEggroll
• SteamCMD Docker image by CM2.Network

License

MIT