Deploying Veloren

Introduction

Veloren is an open-source multiplayer voxel RPG inspired by games like Cube World, The Legend of Zelda: Breath of the Wild, and Dwarf Fortress. Written in Rust for performance and safety, Veloren features a procedurally generated open world, combat, crafting, and exploration in a vibrant, blocky universe.

Key highlights of Veloren:

Open World Exploration: Procedurally generated landscapes with diverse biomes
Multiplayer: Host servers for cooperative gameplay with friends
Combat System: Action-oriented combat with various weapons and abilities
Crafting: Gather resources and craft equipment
Character Progression: Level up skills and abilities
Community Driven: Developed entirely by volunteers and open-source contributors
Cross-Platform: Runs on Linux, Windows, and macOS
Rust Performance: Built with Rust for efficiency and reliability

This guide walks through deploying a Veloren dedicated server on Klutch.sh using Docker, configuring world settings, and managing your server.

Why Deploy Veloren on Klutch.sh

Deploying a Veloren server on Klutch.sh provides several advantages:

Simplified Deployment: Klutch.sh automatically detects your Dockerfile and builds the Veloren server without complex orchestration. Push to GitHub, and your game server deploys automatically.

Persistent Storage: Attach persistent volumes for your world data, player progress, and server configuration. Your world survives container restarts.

Always Online: Your Veloren server stays accessible 24/7 without running on your personal hardware.

GitHub Integration: Connect your configuration repository directly from GitHub. Updates trigger automatic redeployments.

Scalable Resources: Allocate CPU and memory based on expected player count and world complexity.

Prerequisites

Before deploying Veloren on Klutch.sh, ensure you have:

A Klutch.sh account
A GitHub account with a repository for your configuration
Basic familiarity with Docker and containerization concepts
Veloren game client for testing (download from veloren.net)

Preparing Your Repository

Create a GitHub repository containing your Dockerfile for Veloren server deployment.

Repository Structure

veloren-server/
├── Dockerfile
├── settings.ron
└── .dockerignore

Creating the Dockerfile

FROM registry.gitlab.com/veloren/veloren:latest-server

# Set environment variables
ENV VELOREN_SERVER_NAME=${VELOREN_SERVER_NAME:-"My Veloren Server"}
ENV VELOREN_MAX_PLAYERS=${VELOREN_MAX_PLAYERS:-16}

# Copy custom settings if provided
COPY settings.ron /opt/veloren-server/settings.ron

# Create data directories
RUN mkdir -p /opt/veloren-server/saves

# Expose game server port
EXPOSE 14004/tcp
EXPOSE 14004/udp

# Volume for world data
VOLUME ["/opt/veloren-server/saves"]

# Start the server
CMD ["./veloren-server-cli"]

Creating Server Settings

Create a settings.ron file for server configuration:

(
    gameserver_address: "0.0.0.0:14004",
    metrics_address: "0.0.0.0:14005",
    auth_server_address: Some("https://auth.veloren.net"),
    max_players: 16,
    world_seed: 59686,
    server_name: "My Veloren Server",
    server_description: "A friendly Veloren server hosted on Klutch.sh",
    start_time: 9.0,
    map_file: None,
    max_view_distance: Some(30),
    banned_words_files: [],
    max_player_group_size: 6,
    client_timeout: (
        secs: 40,
        nanos: 0,
    ),
    spawn_town: None,
    safe_spawn: true,
    max_player_for_kill_broadcast: Some(20),
)

Environment Variables Reference

Variable	Required	Default	Description
`VELOREN_SERVER_NAME`	No	`My Veloren Server`	Display name for your server
`VELOREN_MAX_PLAYERS`	No	`16`	Maximum concurrent players

Deploying Veloren on Klutch.sh

Push Your Repository to GitHub

Initialize your repository and push to GitHub with your Dockerfile and settings file.

Create a New Project on Klutch.sh

Navigate to the Klutch.sh dashboard and create a new project. Give it a descriptive name like “veloren-server” or “veloren-world”.

Create a New App

Within your project, create a new app. Connect your GitHub account if you haven’t already, then select the repository containing your Veloren Dockerfile.

Configure Network Traffic

In the deployment settings:

Select TCP as the traffic type
Set the internal port to 14004
Note: Veloren uses both TCP and UDP on port 14004

Set Environment Variables

Add the following environment variables:

Variable	Value
`VELOREN_SERVER_NAME`	Your server name
`VELOREN_MAX_PLAYERS`	`16` (adjust as needed)

Attach Persistent Volumes

Add the following volume:

Mount Path	Recommended Size	Purpose
`/opt/veloren-server/saves`	10 GB	World data and player saves

Allocate Resources

Veloren servers benefit from adequate resources:

CPU: 2+ cores recommended for smooth gameplay
Memory: 4GB+ RAM recommended depending on player count

Deploy Your Application

Click Deploy to start the build process. Klutch.sh will build the container, attach volumes, and start your Veloren server.

Connect to Your Server

Note your server’s hostname and share it with players. They can connect using the Veloren client’s server browser or direct connect feature.

Server Administration

Connecting to Your Server

Launch the Veloren game client
Select Multiplayer
Enter your server’s hostname and port
Connect and create a character

Server Commands

Administrators can use chat commands:

/players - List connected players
/kick [player] - Remove a player from the server
/ban [player] - Ban a player
/unban [player] - Remove a ban
/give_item [player] [item] - Give items to players
/tp [player] - Teleport to a player
/time [value] - Set world time

Managing Administrators

Edit the admins.ron file to grant admin privileges:

[
    "player_uuid_1",
    "player_uuid_2",
]

World Configuration

Customizing World Generation

Modify settings.ron to customize your world:

(
    world_seed: 12345,  // Change for different world
    map_file: None,     // Or specify a custom map
    start_time: 9.0,    // Starting time of day (0-24)
    safe_spawn: true,   // Prevent PvP in spawn area
)

Performance Tuning

Adjust for your resource allocation:

(
    max_view_distance: Some(20),  // Reduce for better performance
    max_players: 8,               // Lower player count reduces load
)

Troubleshooting

Players Cannot Connect

Verify the server port (14004) is accessible
Check that both TCP and UDP traffic is allowed
Ensure the server has fully started before connecting

Performance Issues

Reduce max_view_distance in settings
Lower max_players if needed
Allocate more CPU and memory resources

World Not Saving

Verify the persistent volume is correctly mounted
Check disk space availability
Review server logs for save errors

Additional Resources

Conclusion

Deploying a Veloren server on Klutch.sh gives you a persistent multiplayer world for exploring with friends. The combination of Veloren’s engaging gameplay and Klutch.sh’s deployment simplicity means you can quickly host your own voxel RPG adventure without managing complex server infrastructure.