How to Set Up a V Rising Dedicated Server on a Linux VPS (September 2026)

Running your own V Rising dedicated server on a Linux VPS gives you a persistent vampire kingdom that stays online 24/7. Friends can drop in and build castles whether you are logged in or not, and you get full control over PvP rules, clan sizes, and save frequency.

The catch? V Rising does not ship a native Linux server binary. The dedicated server tool runs as a Windows executable (VRisingServer.exe), so Linux administrators need a compatibility layer like Wine to make it work. Our team has tested both the Docker approach and the direct SteamCMD-plus-Wine method on multiple Ubuntu and Debian VPS instances, and this guide covers everything you need to get a stable server running.

Whether you are setting up a private server for a few friends or a community server for dozens of players, this step-by-step walkthrough covers prerequisites, installation, configuration, port forwarding, auto-restart, troubleshooting, and updates. By the end, you will know exactly how to set up a V Rising dedicated server on a Linux VPS using whichever method fits your comfort level.

Prerequisites: What You Need Before Starting

Before diving into installation, you need the right VPS hardware and software stack. V Rising is a resource-hungry game server, and skimping on specs will result in lag, crashes, and frustrated players.

Minimum VPS requirements:

• 2 vCPU cores (4 cores recommended for 10+ players)

• 4 GB RAM minimum (8 GB recommended for larger worlds)

• 20 GB SSD storage (the server files alone take roughly 6 GB)

• x86_64 architecture (this is critical and we explain why below)

• Ubuntu 22.04 LTS or 24.04 LTS (Debian 12 also works well)

ARM-based VPS instances will not work. The Docker image and Wine both require x86_64 architecture. If you try to run this on a Raspberry Pi or an ARM cloud instance, you will see an error about no matching manifest for linux/arm64.

You also need SSH root or sudo access to your VPS, and a basic familiarity with the Linux command line. No Steam game purchase is required. SteamCMD allows anonymous downloads of the dedicated server tool, so even players who do not own V Rising can host a server.

Understanding the Linux Challenge

Stunlock Studios, the developer of V Rising, has stated that there is only a Windows version of the server available. This means there is no official native Linux binary, and all Linux setups rely on community-built compatibility layers.

Two proven approaches exist. The first uses Docker with the popular TrueOsiris/vrising container, which bundles Wine inside a Docker image for easy deployment. The second installs Wine directly on your Linux system and runs the server through SteamCMD. Both produce a working server, but Docker is significantly easier to manage and update.

We recommend Method 1 (Docker) for most users because it isolates the server environment, handles Wine automatically, and makes updates a single command. Method 2 (SteamCMD and Wine) gives you more granular control but requires manual dependency management.

Method 1: Setting Up V Rising Server with Docker

This is the recommended path for setting up a V Rising dedicated server on a Linux VPS. Docker handles the Wine layer automatically, and the TrueOsiris container is actively maintained with thousands of pulls from the community.

Step 1: Install Docker and Docker Compose

Connect to your VPS via SSH and update your package list first. Then install Docker using the official repository method, which ensures you get the latest stable version rather than potentially outdated distro packages.

Run these commands on Ubuntu or Debian:

sudo apt update && sudo apt upgrade -y
sudo apt install ca-certificates curl gnupg lsb-release -y
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin -y

Verify Docker installed correctly by running sudo docker run hello-world. If you see a confirmation message, you are ready for the next step.

Step 2: Create the Server Directory Structure

Create a dedicated directory for your V Rising server data. This keeps everything organized and makes backups simple.

mkdir -p ~/vrising/server-data
mkdir -p ~/vrising/server-settings

The server-data folder holds your world saves and auto-generated config files. The server-settings folder is where you can place custom configuration that persists across container restarts.

Step 3: Write the Docker Compose File

This is where the magic happens. Create a file named docker-compose.yml inside your vrising directory. This file tells Docker how to run the V Rising server container, which ports to expose, and where to store persistent data.

cd ~/vrising
nano docker-compose.yml

Paste the following configuration. Adjust the timezone and server name to your preferences:

services:
  vrising:
    image: trueosiris/vrising:latest
    container_name: vrising-server
    restart: unless-stopped
    environment:
      - TZ=America/New_York
      - VR_SERVER_NAME=My V Rising Server
      - VR_SAVE_NAME=world1
      - VR_MAX_USERS=40
      - VR_MAX_ADMIN_users=5
    volumes:
      - ./server-data:/data
      - ./server-settings:/settings
    ports:
      - "9876:9876/udp"
      - "9877:9877/udp"
    network_mode: bridge

The environment variables let you control the server name, save name, and player limits without editing config files manually. The two port mappings correspond to V Rising’s game traffic and query ports, both using UDP protocol.

Step 4: Start the Server

Launch the server in detached mode so it runs in the background:

sudo docker compose up -d

The first run takes several minutes as Docker downloads the container image and SteamCMD fetches the V Rising server files. Monitor the progress with:

sudo docker logs -f vrising-server

When you see a message indicating the server has started and is listening, your V Rising dedicated server is live. Press Ctrl+C to exit the log view without stopping the server.

Step 5: Verify the Server Is Running

Check that the container is running and healthy:

sudo docker ps

You should see the vrising-server container listed with a status of “Up.” Then launch V Rising on your PC, go to the server browser, and search for your server by name. If it appears, your Docker-based V Rising dedicated server on your Linux VPS is fully operational.

Method 2: Setting Up V Rising Server with SteamCMD and Wine

If you prefer not to use Docker, or if you want more control over the server process, you can install Wine directly and run the V Rising server through SteamCMD. This method involves more steps but gives you a leaner setup without container overhead.

Step 1: Install Wine and Dependencies

On Ubuntu, enable 32-bit architecture support and add the Wine repository. V Rising’s server binary is a 64-bit Windows application, but some Wine dependencies require 32-bit libraries.

sudo dpkg --add-architecture i386
sudo mkdir -pm755 /etc/apt/keyrings
sudo wget -O /etc/apt/keyrings/winehq-archive.key https://dl.winehq.org/wine-builds/winehq.key
sudo wget -NP /etc/apt/sources.list.d/ https://dl.winehq.org/wine-builds/ubuntu/dists/$(lsb_release -cs)/winehq-$(lsb_release -cs).sources
sudo apt update
sudo apt install --install-recommends winehq-stable -y

Also install lib32 libraries and screen for running the server in a background session:

sudo apt install lib32gcc-s1 screen -y

Verify Wine works by running wine --version. You should see a version string like Wine 9.0 or higher.

Step 2: Install SteamCMD

Create a dedicated user for the server to avoid running Wine as root, which can cause permission issues. Then download and extract SteamCMD:

sudo useradd -m -s /bin/bash steam
sudo passwd steam
su - steam
mkdir ~/steamcmd && cd ~/steamcmd
wget https://steamcdn-a.akamaihd.net/client/installer/steamcmd_linux.tar.gz
tar -xvzf steamcmd_linux.tar.gz

Run SteamCMD to verify it launches:

./steamcmd.sh

You should see a Steam prompt that looks like Steam>. Type quit to exit for now.

Step 3: Download the V Rising Server Files

This is where many people make a critical mistake. There are two Steam app IDs related to V Rising, and using the wrong one will install the wrong thing.

The app ID 1604030 is the game client. The app ID 1829350 is the dedicated server tool. You need 1829350. Run SteamCMD with this command:

./steamcmd.sh +force_install_dir ~/vrising_server +login anonymous +app_update 1829350 validate +quit

The anonymous login works because the dedicated server tool does not require game ownership. The validate flag ensures all files download correctly and match Steam’s checksums. This download takes several minutes depending on your VPS bandwidth.

Step 4: Create a Launch Script

V Rising includes a batch file for Windows, but on Linux you need a shell script that invokes Wine. Create the launch script:

cat > ~/vrising_server/start_server.sh << 'EOF'
#!/bin/bash
cd ~/vrising_server
wine64 ./VRisingServer.exe -persistentDataPath ./savedata -serverName "My V Rising Server" -saveName "world1" -logFile ./logs/server.log
EOF
chmod +x ~/vrising_server/start_server.sh

The -persistentDataPath argument controls where save data and generated config files are stored. Keep track of this path because that is where your configuration files will appear after the first run.

Step 5: First Run and Wine Initialization

Launch the server inside a screen session so it keeps running after you disconnect from SSH:

screen -S vrising
~/vrising_server/start_server.sh

The first launch takes longer as Wine initializes the Wine prefix and generates config files. Once you see the server listening on ports, press Ctrl+A then D to detach from the screen session. The server continues running in the background.

Configuring Your V Rising Server Settings

V Rising uses two JSON configuration files that control everything from your server name to PvP rules. Understanding the difference between them is essential for tuning your server to match your playstyle.

You must run the server at least once before editing config files. The server generates default configuration files on first launch. If you try to create them manually before the first run, they may be overwritten or ignored.

ServerHostSettings.json

This file controls the server’s connection and hosting parameters. It lives in the persistentDataPath/Settings directory. For Docker users, this appears under server-data/Settings/. Key fields include:

• Name: The server name displayed in the browser list

• Description: A short description shown when players select your server

• MaxConnectedUsers: Maximum concurrent players (default 40, reduce for smaller VPS plans)

• MaxConnectedAdministrators: How many admin slots are reserved (default 5)

• Password: Set a password for private servers, or leave empty for public

• Port: Game port, defaults to 9876

• QueryPort: Query/listing port, defaults to 9877

• AutoSave: Set to true for automatic saving

ServerGameSettings.json

This file controls gameplay rules and is where most tuning happens. Key fields include:

• GameModeType: Set to “PvP” or “PvE” depending on your server type

• ClanSize: Maximum players per clan (default 4, increase for larger communities)

• CastleDamageMode: Controls castle destruction rules in PvP

• DeathContainerPermission: Determines who can loot your body after death

• AutoSaveInterval: How often saves happen in seconds (default 300)

• AutoSaveCount: Number of rotating save slots to keep (default 20)

• DropTableModifier_General: Adjusts loot drop rates

After editing either file, you must restart the server for changes to take effect. Docker users can restart with sudo docker compose restart. SteamCMD users should reattach to the screen session, stop the server, and relaunch.

Opening the Right Ports for V Rising

V Rising uses exactly two ports, both on UDP protocol. Getting these right is critical for players to connect and for your server to appear in the public browser list.

Port 9876 UDP handles game traffic. This is where all player connections and gameplay data flow. Port 9877 UDP handles server queries and browser listing information. Both must be open for the server to function properly.

A common misconception is that V Rising uses port 27015, which is the default Steam query port for many other games. V Rising does not use 27015. If you see guides referencing that port, they are incorrect for V Rising.

If your VPS uses UFW (Uncomplicated Firewall), open both ports with these commands:

sudo ufw allow 9876/udp
sudo ufw allow 9877/udp
sudo ufw reload

For firewalld users (common on CentOS and Fedora), use:

sudo firewall-cmd --permanent --add-port=9876/udp
sudo firewall-cmd --permanent --add-port=9877/udp
sudo firewall-cmd --reload

If your VPS provider has an external firewall or security group (common with AWS, Google Cloud, and Azure), you must also open these ports in the cloud console. Internal OS firewall rules do not override cloud-level network security groups.

Setting Up Systemd for Auto-Restart

A dedicated server should survive crashes and reboots automatically. Systemd service files are the standard way to achieve this on modern Linux distributions, whether you use Docker or SteamCMD.

For Docker users, systemd handles container start on boot. Create a service file:

sudo nano /etc/systemd/system/vrising.service

Add the following configuration, replacing yourusername with your actual Linux username:

[Unit]
Description=V Rising Dedicated Server (Docker)
After=docker.service
Requires=docker.service

[Service]
Type=oneshot
RemainAfterExit=yes
WorkingDirectory=/home/yourusername/vrising
ExecStart=/usr/bin/docker compose up -d
ExecStop=/usr/bin/docker compose down
TimeoutStartSec=0

[Install]
WantedBy=multi-user.target

Enable and start the service:

sudo systemctl daemon-reload
sudo systemctl enable vrising.service
sudo systemctl start vrising.service

For SteamCMD users, the systemd service runs the Wine-based launch script directly. Use Type=forking with a screen session, or switch to a tmux-based approach for cleaner process management.

The restart: unless-stopped directive in Docker Compose already handles crash recovery for container users. Systemd ensures the container starts automatically after a full VPS reboot.

Updating Your V Rising Server

V Rising receives regular updates from Stunlock Studios, and your server must match the latest client version for players to connect. When an update drops, players on the new version cannot join a server running the old version.

Docker update process is straightforward. Pull the latest image and recreate the container:

cd ~/vrising
sudo docker compose down
sudo docker pull trueosiris/vrising:latest
sudo docker compose up -d

The container automatically validates and downloads new server files on first start after the image update. This process takes a few minutes.

SteamCMD update process requires re-running the download command:

~/steamcmd/steamcmd.sh +force_install_dir ~/vrising_server +login anonymous +app_update 1829350 validate +quit

The validate flag is important during updates. It catches and replaces any corrupted or outdated files that could cause crashes after a patch.

Always back up your save data before updating. Copy the entire server-data or savedata directory to a safe location. Updates rarely corrupt saves, but having a backup protects you if something goes wrong.

Troubleshooting Common Issues

Even with a perfect setup, issues can arise. Here are the most common problems V Rising server admins encounter on Linux, along with proven fixes.

Server Not Showing in the Browser List

This is the number one issue reported across Reddit and Steam community forums. If your server does not appear in the in-game browser, check three things in order. First, confirm port 9877 UDP is open on both your VPS firewall and any cloud-level security group. Second, verify the server finished its initial startup by checking the logs. Third, wait 5 to 10 minutes, as the server list can take time to propagate.

If the server is running but still invisible, try connecting directly by IP using the “Direct Connect” option in the game. Enter your VPS IP address and port 9876. If direct connect works but the browser does not, the query port (9877) is almost certainly blocked.

ARM64 Architecture Not Supported

If you see an error like “no matching manifest for linux/arm64” when pulling the Docker image, you are running on an ARM-based VPS. The TrueOsiris container only supports x86_64 architecture. The only fix is to switch to an x86_64 VPS instance from your hosting provider.

Config Changes Not Taking Effect

This happens when edits are made to the wrong file location. V Rising generates config files in the persistentDataPath/Settings directory, not in the server installation directory. If you edited files under StreamingAssets/Settings in the SteamCMD installation folder, those are template files that get copied to the persistent data path on first run.

Always edit the files in the persistent data path. After making changes, restart the server completely. Docker users should run sudo docker compose restart rather than just stopping and starting the container.

Connection Refused Errors

When players get connection refused errors, the server either is not running or the port is blocked. Check container status with sudo docker ps or process status for SteamCMD setups. Then verify the firewall rules are active with sudo ufw status. Finally, confirm the server is actually listening on port 9876 by running sudo ss -ulnp | grep 9876.

Performance Issues and Lag

V Rising dedicated servers can consume significant memory as worlds grow. If players report rubber-banding or delayed interactions, check your RAM usage with free -h. If you are near your VPS memory limit, consider upgrading to a plan with more RAM or reducing the MaxConnectedUsers setting.

Disk I/O also matters. If your VPS uses a slow HDD instead of an SSD, auto-save operations can cause lag spikes. Use iostat to monitor disk performance, and consider reducing AutoSaveInterval frequency if saves are causing noticeable pauses.

FAQs

Conclusion

Setting up a V Rising dedicated server on a Linux VPS takes some preparation, but the result is a persistent vampire world that runs on your terms. The Docker method with the TrueOsiris container is the fastest path for most administrators, handling the Wine compatibility layer automatically and making updates a simple pull-and-recreate process. The SteamCMD method gives you more control over the environment at the cost of manual dependency management.

Remember the key pitfalls that trip up most new server admins. Use app ID 1829350 for the server tool, not 1604030 for the game client. Open ports 9876 and 9877 on UDP, not port 27015. Run the server once before editing config files, and always restart after making configuration changes. Back up your saves before every update.

Once your server is live and stable, the next steps are tuning gameplay settings to match your community. Adjust clan sizes, PvP rules, loot rates, and save frequency in ServerGameSettings.json. Invite your friends through direct IP connect while the browser list propagates, and start building your vampire kingdom.

Knowing how to set up a V Rising dedicated server on a Linux VPS puts you in full control of your multiplayer experience. Whether you are running a private server for a handful of friends or a community server for dozens of players, the Docker and SteamCMD methods in this guide will keep your world running smoothly through every game update.