Wiki menu

Old World Order: a tour of the repository

A tour of the public Old World Order mod: its folders, the manifest field by field, building it with install.bat, and using it as a template.

Last updated for v0.5.35
On this page

Old World Order is a complete mod for Global Protocol whose source is public. It moves the start of the game to 1450 AD and replaces the countries, units, buildings, research, events and interface colours to match. This page shows you around its repository so that you can find things, build it yourself and copy its structure for a mod of your own. The five pages after it take the mod apart area by area.

What Old World Order is

The repository’s README calls it “a historical total conversion mod”: you play the world as it was in 1450 AD. The README asks for Global Protocol v0.5.10 or later.

What the files on main contain:

AreaIn the mod
Countries137 nations added, the base game’s modern countries removed
Military33 unit types (8 shared, 25 exclusive to one nation), 141 starting army stacks and 34 fleets
ResearchSeven doctrine branches replaced, three hidden, plus three research tracks and 15 specialists
EconomyA roster of 15 medieval buildings, 31 resources disabled, money shown in florins and 16 other currencies
Story60 events, national goals for 26 nations and nine endings of its own
InterfaceFour toolbar buttons, a gold-on-brown HUD theme and a start-of-game briefing
TextOne file per language, 13 in all; the English file has 1,202 rows
The game running the Old World Order mod on 1 January 1450 as the Ottoman Empire, with the Overview page open beside the map and the treasury counted in the mod's currency.
Old World Order: the game on 1 January 1450, played as the Ottoman Empire.

The folder map

The repository holds two kinds of file: the mod itself, which is copied into the game, and the tools and sources around it, which stay in the repository.

What ships to the game

PathWhat it is
mod.jsonThe manifest. Explained field by field below.
scenario/The 1450 world in 16 JSON files: the header, countries, province ownership and data, starting armies and fleets, diplomacy, goals, endings, currencies, and the unit, building and resource rosters. See the scenario.
overrides/Changes to the game’s rule files: doctrines.json, laws.json, interest_groups.json, game_settings.json and military_markers.json, plus map-marker art in Art/Units/. See content.
Content/events/, images/events/, localization/, ui/, research_tracks.json, specialists.json, demography/seeds.json and portraits/specialists/. It also holds the script sources, which are left out of the deployed copy.
flags/137 flag images, 128×80 pixels, named by country code (OTT.png).
icons/Pictures named after the id they belong to: buildings/, units/, doctrines/, and the research-track icons.
images/events/Event pictures. The game reads this folder and Content/images/events/.
portraits/leaders/ (20 starting leaders) and specialists/ (15).
logo.png, thumbnail.pngThe images named by iconPath and thumbnailPath. The thumbnail is also the Workshop preview.

What stays in the repository

PathWhat it is
install.batBuilds the script, checks the scenario files and copies the mod into the game’s mod folder or a staging folder.
publish_workshop.batUploads the staging folder to the Steam Workshop with SteamCMD.
Content/shared/, Content/mod-csharp/, Content/wasm-as/, Content/wasm-dotnet/The script’s source, written for three runtimes. See scripting and interface.
sdk/Compile-time stubs of the game’s C# mod API, so the script builds without the game installed. The stub DLL is not shipped.
dev/The two helpers install.bat runs (validate_scenario.ps1, set-runtime-settings.ps1), the province tools with their data (province_registry.json, province_curation.json), and Python scripts that generated goals, event text and country colours.
scripts/audit_inventory.py (lists missing icons) and process_image.py (turns an art file into an icon).
docs/modding/A copy of the game’s modding reference, guides and JSON schemas, synced from the game. Do not edit it there.
docs/images/screenshots/The screenshots the README shows.
.github/workflows/release.ymlBuilds a release zip when a version tag is pushed.
OldWorldOrder.sln, .vscode/tasks.jsonEditor conveniences for the C# projects and for running install.bat.
AGENTS.md, CLAUDE.md, .github/copilot-instructions.md, .github/copilot/The repository’s conventions, written for AI coding assistants.
.gitignore, .gitattributes, LICENSE, README.md.gitattributes forces LF line endings on the .csv files.

Three things you will look for and not find, because .gitignore leaves them out: the compiled Content/mod.wasm, the workshop_content/ staging folder, and every bin/ and obj/ folder. All three are build output.

mod.json, field by field

{
  "id": "globalprotocol.old_world_order",
  "displayName": "Global Protocol: Old World Order",
  "iconPath": "logo.png",
  "thumbnailPath": "thumbnail.png",
  "era": "1450",
  "startYear": 1450,
  "version": "0.10.0",
  "workshopItemId": "3724318324",
  "description": "A historical scenario set in 1450 AD. Play as one of 137 nations from the late medieval period, commanding historically accurate armies, fleets, governments, and ambitions. Featuring the Ottoman Empire, Ming Dynasty, Portugal, France, England, Muscovy, the Timurids, and more.",
  "scenarioFolder": "scenario",
  "enabledByDefault": false,
  "wasmAbiVersion": 3,
  "runtimePolicy": "coexist",
  "enableComponentRuntime": true,
  "permissions": ["InjectUI", "FireTriggers", "WriteTreasury"],
  "entrypoints": {
    "wasm": "Content/mod.wasm",
    "ui": "Content/ui/inject.json"
  }
}
FieldWhat it does here
idThe mod’s unique id. install.bat deploys into a folder of the same name, which is what the game expects.
displayNameThe name on the mod’s row in MOD LOADOUT.
iconPath, thumbnailPathThe mod’s small icon and larger preview. Once a manifest names them, the game uses those paths and nothing else.
era, startYearOptional labels: an era tag and a suggested start year. The real start date is in scenario/scenario.json.
versionThe mod’s version, in MAJOR.MINOR.PATCH form.
workshopItemIdThe Steam Workshop item this mod updates. publish_workshop.bat reads it.
descriptionA short description, shown with the mod.
scenarioFolderSays the scenario is split over the files in scenario/.
enabledByDefaultfalse: the player switches the mod on.
wasmAbiVersionThe version of the script interface a WASM build of the script targets.
runtimePolicy, enableComponentRuntimeWhich script runtime the game may load. install.bat sets both for the build you choose: see the note below.
permissionsThe permissions the mod declares: InjectUI for interface elements and popups, FireTriggers for a script that fires events, WriteTreasury for a script that changes a treasury. What each one unlocks is on scripting and interface.
entrypoints.wasm, entrypoints.uiWhere the game finds the compiled script and the interface injection file.

The deployed manifest is not this one. install.bat copies mod.json and then runs dev/set-runtime-settings.ps1 on the copy. For the default C# build it sets runtimePolicy to csharp_only, sets enableComponentRuntime to false and removes entrypoints.wasm. For a WASM build it sets wasm_only and keeps the entry. Edit the manifest in the repository, never the deployed copy: the next deploy replaces it.

A manifest can also carry gameVersion, author, tags, dependencies and loadOrderHint, which this mod does not need. All five are described in Folder layout and manifest.

Clone, build and deploy

  1. Clone the repository. Put it anywhere except the game’s mod folder.

    git clone https://github.com/Dorlion-Interactive/Global-Protocol-Old-World-Order-Mod
    cd Global-Protocol-Old-World-Order-Mod
  2. Run install.bat. With no flags it asks what you want: [1] deploys to the game’s mod folder for testing, [2] builds the Workshop staging folder. Pressing Enter picks [1].

  3. Let it work. It builds the script, checks the scenario files, deletes the old copy at the target and copies a fresh one. The default build needs the .NET SDK on your PATH.

  4. Play. Start the game, click MODS, switch the mod on and start a NEW GAME.

The flags skip the question and choose the build:

FlagEffect
/localDeploy to %USERPROFILE%\AppData\LocalLow\Dorlion Interactive\Global Protocol\Mods\globalprotocol.old_world_order.
/workshopStage into workshop_content/ for publish_workshop.bat.
/sdkThe default: build the C# script into Mods/OldWorldOrder.ModCSharp.dll. /csharp means the same.
/asBuild the AssemblyScript script into Content/mod.wasm. Needs Node.js.
/skip-buildCopy data and art without compiling, and without the scenario check.

A flag the script does not know is ignored with a warning.

Keep the clone out of the mod folder. Before it copies anything, install.bat deletes the whole target folder. If your working copy were that folder, the script would delete the files it is running from.

The whole loop, with the validation and the publishing steps, is on build and publish.

Using it as a template

The repository is meant to be copied. A sensible order of work:

Rename

  • In mod.json: id, displayName, description, era, startYear, and version (start again at your own first version). Delete workshopItemId: without one, the first upload creates a new Workshop item, and the publish script then asks you to save the new id here.
  • In install.bat: the MOD_ID line near the top, which names the deploy folder. In publish_workshop.bat: MOD_ID, TITLE and DESCRIPTION. Leave APP_ID: it is the game’s Steam app id.
  • In the script: the ModId constant in Content/shared/OldWorldOrder.cs and MOD_ID in Content/wasm-as/mod.ts. The script compares incoming button clicks with it.
  • In scenario/scenario.json: scenarioId and displayName.
  • In .github/workflows/release.yml: the zip name and the links in the release text.

Delete or empty

  • The 1450 data you are not keeping: the entries in the scenario/ files, flags/, portraits/, the event files and their pictures, Content/research_tracks.json, Content/specialists.json, Content/demography/seeds.json.
  • The script sources you will not build. If you stay on the default C# build, Content/wasm-as/ and Content/wasm-dotnet/ can go.
  • The rows of the 13 localization files, but keep all 13 files.
  • docs/images/screenshots/ and the README text.

Keep

  • dev/validate_scenario.ps1 and dev/set-runtime-settings.ps1: install.bat calls both, and the release workflow calls the first.
  • sdk/, if you keep a C# script.
  • docs/modding/: the reference and the schemas your editor can validate against.
  • The fragment file names inside scenario/ (countries_add.json, units_deploy_armies.json and so on): the game looks for those exact names. The override files are named by the header, so those you may rename.
  • The province tools in dev/, if your mod redraws the map.

If you would rather fill in forms than edit JSON, the in-game Mod Builder writes the same files, and you can mix both ways of working.

Play Global Protocol: New World Order

Out now in Early Access on Steam, with online multiplayer for 2–8 players.