Vanilla Era setup
1.0.0 — 1.12.2
The shortest build on this list. Small database, small map extraction, and a toolchain that has not changed in a decade.
Before you start
Everything below assumes a clean host- A 1.12.1 or 1.12.2 clientExtraction reads your own legally obtained install. No client files ship with any core.
- Roughly 40 GB freeExtracted maps, vmaps, and mmaps dwarf the core itself. Check before you start.
- GCC 12+ · CMake 3.16+ · Boost 1.74+ · MySQL 8.0Install all of it up front — a missing dev package fails several steps later.
- Ports 3724 · 8085 reachableAuth then world. If only the first is open, players see the realm list and then hang.
Deployment paths
All 3 shown in fullQuick-start repack
Prebuilt · fastestInstall the toolchain
Everything on this sheet assumes GCC 12+ · CMake 3.16+ · Boost 1.74+ · MySQL 8.0. Install these first — a half-configured toolchain fails three steps later with a confusing error.
$ sudo apt update && sudo apt install -y git cmake make gcc g++ \ libmysqlclient-dev libssl-dev libbz2-dev libreadline-dev \ libncurses-dev libboost-all-dev mysql-server $ cmake --version && gcc --version # confirm before continuing
Unpack the repack
A repack carries compiled binaries and a seeded world database in one archive. Fastest route to a running realm, and the one that needs a fresh bundle every time the core moves.
$ sha256sum -c wf-vanilla-1.12.2-repack.tar.zst.sha256 $ tar --zstd -xf wf-vanilla-1.12.2-repack.tar.zst $ cd wf-vanilla && ls # bin/ etc/ sql/ tools/
Import the seeded database
The repack's SQL bundle creates all three schemas and fills the world database in one pass. This is the step that takes the longest.
$ mysql -u root -p < sql/create_databases.sql $ mysql -u root -p wf_classic_world < sql/vanilla_world.sql $ mysql -u root -p wf_classic_auth < sql/vanilla_auth.sql $ mysql -u root -p wf_classic_chars < sql/vanilla_characters.sql
Extract client data
The core needs maps, vmaps, and mmaps generated from a 1.12.1 or 1.12.2 client you own. Nothing is downloaded — this reads your install and writes into the server's data directory.
# run from the client root, not the server directory $ cd /path/to/client-1.12.2 $ ~/realm/bin/ad $ ~/realm/bin/vmap4extractor && ~/realm/bin/vmap4assembler Buildings vmaps $ ~/realm/bin/mmaps_generator --threads $(nproc) $ mv maps vmaps mmaps dbc ~/realm/data/
Point the config at your database
Two files: authserver.conf handles logins, worldserver.conf handles everything else. Copy the .dist versions before editing so you can diff against defaults later.
$ cp etc/authserver.conf.dist etc/authserver.conf $ cp etc/worldserver.conf.dist etc/worldserver.conf $ $EDITOR etc/worldserver.conf # see the key table below
Start both servers
authserver first, then worldserver. The world server holds the console — leave it in the foreground the first time so you can watch it load.
$ ./bin/authserver & $ ./bin/worldserver # "World initialized in X minutes" means you are up
Create an account and log in
Accounts live in the auth database, not in a config file. Create the first one from the worldserver console, then point the client at your host.
> account create admin <password> > account set gmlevel admin 3 -1 # then, client side — edit realmlist.wtf SET realmlist "127.0.0.1"
Full source build
CMake · contributableInstall the toolchain
Everything on this sheet assumes GCC 12+ · CMake 3.16+ · Boost 1.74+ · MySQL 8.0. Install these first — a half-configured toolchain fails three steps later with a confusing error.
$ sudo apt update && sudo apt install -y git cmake make gcc g++ \ libmysqlclient-dev libssl-dev libbz2-dev libreadline-dev \ libncurses-dev libboost-all-dev mysql-server $ cmake --version && gcc --version # confirm before continuing
Unpack the source bundle
The classic tree arrives as an archive alongside its checksum. Verify before you unpack — a truncated transfer fails much later, during linking, where the cause is unrecognisable.
$ sha256sum -c wf-vanilla-1.12.2-src.tar.zst.sha256 $ mkdir -p ~/src && tar --zstd -xf wf-vanilla-1.12.2-src.tar.zst -C ~/src $ cd ~/src/core && cat BUILD_ID # keep the BUILD_ID — the database bundle has to match it
Configure and compile
Build with tools enabled — the extractors compile from the same tree and must match your core version. Expect roughly ≈ 25 min on a modern machine.
$ cmake -B ~/build -S ~/src/core \ -DTOOLS=1 -DCMAKE_BUILD_TYPE=Release \ -DCMAKE_INSTALL_PREFIX=$HOME/realm $ cmake --build ~/build -j$(nproc) --target install
Create the databases
Three schemas: authentication, world content, and character state. Give the core its own MySQL user rather than reusing root.
$ mysql -u root -p > CREATE DATABASE wf_classic_auth DEFAULT CHARSET utf8mb4; > CREATE DATABASE wf_classic_world DEFAULT CHARSET utf8mb4; > CREATE DATABASE wf_classic_chars DEFAULT CHARSET utf8mb4; > CREATE USER 'wowfiles'@'localhost' IDENTIFIED BY '<password>'; > GRANT ALL ON \`wf_classic_auth\`.* TO 'wowfiles'@'localhost'; > GRANT ALL ON \`wf_classic_world\`.* TO 'wowfiles'@'localhost'; > GRANT ALL ON \`wf_classic_chars\`.* TO 'wowfiles'@'localhost';
Import and update the world database
Base import first, then every pending update in filename order. Skipping an update leaves the schema mid-migration and the core refuses to boot.
$ mysql -u wowfiles -p wf_classic_world < ~/db/wfdb-classic.sql $ for f in ~/src/core/sql/updates/world/*.sql; do \ mysql -u wowfiles -p wf_classic_world < "$f"; done
Extract client data
The core needs maps, vmaps, and mmaps generated from a 1.12.1 or 1.12.2 client you own. Nothing is downloaded — this reads your install and writes into the server's data directory.
# run from the client root, not the server directory $ cd /path/to/client-1.12.2 $ ~/realm/bin/ad $ ~/realm/bin/vmap4extractor && ~/realm/bin/vmap4assembler Buildings vmaps $ ~/realm/bin/mmaps_generator --threads $(nproc) $ mv maps vmaps mmaps dbc ~/realm/data/
Launch and watch the first boot
First boot is slow — the core caches the world database into memory. Watch for missing-data warnings; they tell you which extraction step to rerun.
$ ~/realm/bin/authserver & $ ~/realm/bin/worldserver # tail the log if you daemonize instead $ tail -f ~/realm/logs/Server.log
Create an account and log in
Accounts live in the auth database, not in a config file. Create the first one from the worldserver console, then point the client at your host.
> account create admin <password> > account set gmlevel admin 3 -1 # then, client side — edit realmlist.wtf SET realmlist "127.0.0.1"
Container stack
Compose · reproducibleInstall Docker and Compose
The container path skips the toolchain entirely — the build happens inside the image. Best fit if you plan to run more than one realm on the same host.
$ curl -fsSL https://get.docker.com | sh $ docker compose version
Unpack the stack and set your environment
One compose file brings up the database, the auth server, and the world server as separate services. Everything configurable lives in .env.
$ sha256sum -c wf-vanilla-stack.tar.zst.sha256 $ mkdir -p ~/stack && tar --zstd -xf wf-vanilla-stack.tar.zst -C ~/stack $ cd ~/stack && cp .env.example .env $ $EDITOR .env # DB password, realm name, external IP
Bring up the database first
Start MySQL alone and let it finish initialising before the servers try to connect, otherwise the first worldserver run races the schema import.
$ docker compose up -d database $ docker compose logs -f database # wait for "ready for connections"
Extract client data into the volume
Mount your 1.12.1 or 1.12.2 client read-only and run the extractor container. This is the one step that touches files outside Docker.
$ docker compose run --rm \
-v /path/to/client-1.12.2:/client:ro \
extractor -i /client -o /data
Start the servers
Both servers come up together once the data volume is populated. Compose restarts them automatically if the host reboots.
$ docker compose up -d authserver worldserver $ docker compose ps $ docker compose logs -f worldserver
Create an account and log in
Attach to the world server console inside the container to create the first account, then point your client at the host.
$ docker compose exec worldserver ./worldserver > account create admin <password> # client side — edit realmlist.wtf SET realmlist "127.0.0.1"
Configuration keys
Edit before first launchVerify it worked
In order — each one gates the next- Auth server acceptsThe client reaches the realm list. If it stalls here, it is port 3724 or the gamebuild column.
- World loads fullyThe console reports the world initialized with no missing-map warnings.
- Character enters the worldLogin, create a character, and zone in. Falling through terrain means vmaps failed.
- Movement is validatedRun, mount, and use a flight path. Rubber-banding points at mmaps, not at latency.
When it goes wrong
The four failures everyone hitsaddress to your public IP, not 127.0.0.1, for anyone outside the host.gamebuild column must equal your client build (5875). A one-digit mismatch fails every login.data/vmaps. Rerun the extractor and assembler in order.sql/updates/ in filename order — they are not idempotent out of sequence.License terms you inherit
This core carries copyleft terms from its lineage. Anything you distribute travels under the same license, with source.
Serving a modified core publicly counts as distribution under the stricter terms. A private realm does not trigger it.
Bundles are issued per operator and are not transferable. Do not rehost them or pass them on.
Maps, DBC, and art stay under the publisher's terms. Extract from a client you own; never redistribute them.