Running a Darkan World Server in CubeCoders AMP

I recently went down the rabbit hole of getting a Darkan world server running under CubeCoders AMP. Darkan is an open-source/community RuneScape private server project with its own cache, client, world server, and lobby architecture. The server is based on circa-2012 content. The setup is not a one-click AMP template, but it is very doable with AMP’s Java App Runner instance, a MongoDB instance, and a little bit of manual configuration.

This post walks through the process I used to run a Darkan world server in AMP using Podman-managed instances.

The Architecture

For this setup, I used two AMP instances:

Darkan World Server
└── Java App Runner instance

MongoDB
└── MongoDB AMP instance

The Darkan world server connects to MongoDB for persistence and uses the Darkan development lobby for account creation, lobby login, and world selection.

At the time of writing, a fully custom lobby is not practical yet. Darkan’s lobby is proprietary, and although a unified server/lobby project appears to be underway, there is not currently a public lobby server JAR that can be dropped into AMP the same way as the world server. You could create your own JAR since the code is available, but the public branches are, to my understanding, missing crucial functionality right now. Plus, I wanted something a little more plug-and-play than compiling my own custom JAR constantly.

The unified project is here:

https://gitlab.com/darkanrs/server

For now, the easiest path is to run your own world server and connect through the Darkan development lobby.

Create the Java Server Instance

In AMP, create a new Java App Runner instance for the Darkan world server.

Set the world server ports. In my case, I used the default ports:

43595 TCP
43596 TCP

Make sure this matches the port in worldConfig.json later. If you are crossing VLANs or exposing the server publicly, also make sure that the ports are allowed through your firewall and forwarded correctly.

In the Java App Runner settings, configure the Java version and startup options. I used the Java 25 podman container because the release JAR I downloaded required a newer Java runtime.

Now save your settings and start the server. Manage the instance, and go to

Configuration > Java App Runner

Now set the instance to use Java 24 since this is the current recommended version from the devs.

Example settings:

Java Version: Specific instance version
Specific Instance Java Version: 24
Java Arguments: --enable-preview -Xms512M -Xmx2G
Jar Name: world-server.jar
Jar Options: com.rs.Launcher
App Subdirectory: blank

Click the Download tab and configure as follows :

App Download Type: Git repo
App Download source: https://gitlab.com/darkanrs/world-server.git
Git Repo branch: dev or master

Then go to:

Status > Actions > Update

This lets AMP prepare the Java App Runner instance.

Create the MongoDB Instance

Next, create a separate MongoDB instance in AMP. Pretty much all values can be left as default this time around.

Once MongoDB is running, open the instance, open the MongoDB console, and create a database user for Darkan:

use darkan-server

db.createUser({
  user: "darkan",
  pwd: "choose-a-password-here",
  roles: [
    { role: "readWrite", db: "darkan-server" }
  ]
})

Save this password. You will need it in the Darkan world server config.

Enter the Java Instance

SSH into the AMP host.

If AMP is using Podman, list the containers:

podman ps -a

Find the Java App Runner container name. Mine was similar to:

AMP_JavaAppRunner01

Enter the container:

podman exec -it AMP_JavaAppRunner01 bash

AMP maps the app files inside the container under:

/AMP/java-app-runner

The parent /AMP directory is important because Darkan expects the cache at ../cache/ relative to the world server directory.

Clone the Darkan Cache

Inside the Java App Runner container:

cd /AMP

rm -rf cache

git clone https://gitlab.com/darkanrs/cache.git cache
cd cache

git lfs install
git lfs pull

ls -lh main_file_cache.dat2

You should see main_file_cache.dat2, which is a large cache file.

If git lfs is not available, install it first:

apt update
apt install git-lfs -y

Depending on how AMP and Podman map the filesystem, you may need to fix permissions later so the amp user inside the container can read the cache.

Optional: Install Nano

If you prefer editing files from the shell:

apt update
apt install nano -y

You can also use AMP’s File Browser and File Editor instead.

Configure Darkan

The Darkan world server config lives here:

cd /AMP/java-app-runner
nano data/worldConfig.json

Set the MongoDB fields and world information.

Example:

{
  "serverName": "choose-a-name",
  "ownerName": "your-username",
  "cachePath": "../cache/",
  "debug": true,
  "mongoUrl": "localhost",
  "mongoPort": 27017,
  "mongoUser": "darkan",
  "mongoPass": "choose-a-password-here",
  "mongoDbName": "darkan-server",
  "lobbyIp": "dev.darkan.org",
  "lobbyApiKey": "TEST_API_KEY",
  "worldInfo": {
    "number": 3,
    "ipAddress": "IP_OR_DNS",
    "port": 43595,
    "activity": "world_name_in_lobby",
    "country": 1,
    "quickChat": false,
    "lootShare": true,
    "members": true,
    "pvp": false,
    "highlight": false
  }
}

A few important notes:

localhost only works for MongoDB if both containers are running on the same AMP instance manager with host networking enabled, which is how my setup is running.

Do not use 0.0.0.0 for worldInfo.ipAddress. That may be fine for binding a service locally, but it is not a usable address for the lobby or client to connect to. Use a public IP, LAN IP, or DNS name that clients can actually reach.

In my case, I used a DNS name like:

rs2.example.com

Also make sure the port in worldInfo.port matches the AMP instance port and your firewall rules.

Download the Latest World Server Release JAR

AMP’s built-in download/update settings do not cleanly support “download the latest JAR from GitLab releases” for this project, so I used a small helper script.

Inside the Java App Runner directory:

cd /AMP/java-app-runner

cat > update-world-server-jar.sh <<'EOF'
#!/bin/bash
set -e

GITLAB_API_URL="https://gitlab.com/api/v4"
PROJECT_ID="42378996"

echo "Checking latest Darkan world-server release..."

PACKAGE_DOWNLOAD_URL="$(curl -s "${GITLAB_API_URL}/projects/${PROJECT_ID}/releases?order_by=created_at&sort=desc" \
  | jq -r 'max_by(.released_at) | .assets.links | map(select(.name | endswith("-jar"))) | .[0].direct_asset_url')"

if [ -z "$PACKAGE_DOWNLOAD_URL" ] || [ "$PACKAGE_DOWNLOAD_URL" = "null" ]; then
  echo "Could not determine latest release JAR URL"
  exit 1
fi

echo "Downloading: $PACKAGE_DOWNLOAD_URL"
curl -L "$PACKAGE_DOWNLOAD_URL" -o world-server.jar

echo "Downloaded:"
ls -lh world-server.jar
EOF

chmod +x update-world-server-jar.sh

If jq is missing:

apt update
apt install jq curl -y

Download the latest server JAR:

./update-world-server-jar.sh

You should now have:

/AMP/java-app-runner/world-server.jar

Test the Server Manually

Before relying on the AMP UI, test the JAR directly.

If using Podman:

podman exec -it AMP_JavaAppRunner01 bash -lc '
su -s /bin/bash amp -c "
cd /AMP/java-app-runner
export JAVA_HOME=/usr/lib/jvm/temurin-25-jdk-amd64
export PATH=\$JAVA_HOME/bin:\$PATH
java --enable-preview -Xms512M -Xmx2G -jar world-server.jar com.rs.Launcher
"
'

A successful start should show the server loading config, connecting to MongoDB, loading the cache, and starting the embedded server components.

If AMP complains that the Java executable does not exist, check whether it is trying to launch:

/AMP/java-app-runner/java/bin/java

In my case, I had to recreate the Java path as a symlink to the installed Temurin runtime:

podman exec -it --user root AMP_JavaAppRunner01 bash -lc '
cd /AMP/java-app-runner

rm -rf java
ln -s /usr/lib/jvm/temurin-25-jdk-amd64 java
chown -h amp:amp java

/AMP/java-app-runner/java/bin/java -version
'

Then AMP’s Java App Runner could find the executable it expected.

Fix Permissions If Needed

Because AMP is running the Java process as the amp user, files created as root can cause failures.

If the server fails to read the cache or config, fix permissions from inside the container:

podman exec -it --user root AMP_JavaAppRunner01 bash -lc '
ls -ld /AMP/cache /AMP/java-app-runner
ls -lh /AMP/cache/main_file_cache.dat2

chown -R amp:amp /AMP/cache /AMP/java-app-runner
chmod -R u+rwX,go+rX /AMP/cache
chmod -R u+rwX /AMP/java-app-runner

su -s /bin/bash amp -c "head -c 1 /AMP/cache/main_file_cache.dat2 >/dev/null && echo cache-readable"
'

If you are working from the host as the amp user and see strange numeric ownership, such as 165536, that is probably rootless Podman UID mapping. In that case, fix ownership from inside the container rather than from the host.

Start from AMP

Once the manual test works, start the instance from the AMP UI.

Connecting with the Client

For now, use the Darkan development lobby.

Download the latest client loader from:

https://gitlab.com/darkanrs/client-loader/-/releases

Start the client, select the development lobby, create an account, and look for your world.

Make sure the world port is open and reachable. If you are hosting publicly, that means:

AMP instance port
Linux firewall
Router/NAT/firewall
DNS record

all need to agree on the same TCP port.

About Custom Lobbies

At the moment, there does not appear to be a simple public lobby JAR that can be dropped into AMP the same way as the world server JAR.

Darkan’s lobby is proprietary. An open-source unified server/lobby project appears to be underway here:

https://gitlab.com/darkanrs/server

The project includes lobby-related development, but there is not yet a public release workflow that makes a lobby JAR available for the same AMP setup. You could use public branches of both the server repo and the client with Kotlin or another IDE to build your own JARs, but since these are in early beta, I don’t consider this practical for many people.

The current practical approach is:

Use the Darkan development lobby
Run your own world server
Point the client at the development lobby
Connect to your world through the world list

Stay tuned for part two, where I’ll revisit this once the appropriate client executable and lobby server JAR files are available publicly.

Final Notes

This was more involved than a typical AMP game server because Darkan is not a native AMP app template. The big takeaways were:

Use Java App Runner
Use a separate MongoDB AMP instance
Put the cache at /AMP/cache
Make sure worldConfig.json points to MongoDB
Use a real reachable DNS/IP for worldInfo.ipAddress
Download the release JAR manually or with a helper script
Fix Podman/AMP permissions so the amp user can read the cache and config

Once those pieces are in place, the world server can run cleanly under AMP.

Jonah May

Hey there! I’m Jonah May, a Product Architect and Product Engineering Manager at CyberFortress, a Platinum VCSP dedicated to keeping data safe and recoverable. When I’m not working on backup strategies and automation, you’ll find me deeply involved in the Veeam community—as a Veeam Vanguard, Veeam Certified Architect, VCSP Technical Ambassador, and co-founder of the Veeam Community Hackathon. I also help lead the Texas and Automation Desk Veeam User Groups, where we nerd out over all things backup, automation, and infrastructure.Beyond tech, I’m a Scout leader, having earned my Eagle Scout back in the day. I love sharing knowledge, solving problems, and making technology work smarter, not harder. If you’re into Veeam, automation, or home labs, let’s connect!