Sapphire Multilauncher

Sapphire Multilauncher is the native Rust replacement for the original C# Sapphire / Project Meteor launcher in this repository. It currently manages and launches two Final Fantasy XIV client protocols from one interface:

• FFXIV 3.3 (Heavensward) for Sapphire-compatible servers
• FFXIV 1.23b for Project Meteor-compatible servers

It also contains a preservation-only Twin Saga protocol adapter. That adapter consumes a PrivateServer-RS profile and verifies discovery, the complete http://SERVER/login.html URL, patch hashes and sizes, login, world, and zone endpoints. It deliberately does not execute the preserved Twin Saga binary; executable launching remains blocked until the recovered client adapter has independent behavioral evidence.

The primary flow is deliberately small: choose the game language, enter a PrivateServer-RS host or discovery URL, and launch. The launcher fetches the server's published profile, selects Sapphire or Meteor, and applies the advertised lobby, login, and patch endpoints. Source paths, manual endpoint overrides, login details, and recovery controls live under Client and server details.

PrivateServer-RS discovery

PrivateServer-RS publishes a versioned profile at:

http://SERVER/.well-known/mmo-preservation.json

Meteor uses its configured web port, normally http://SERVER:8080/.well-known/mmo-preservation.json. A bare host is enough: RustClient tries the expected Sapphire and Meteor locations in client-appropriate order. An explicit HTTP(S) JSON URL is also accepted.

For Sapphire, the generated profile contains the complete http://SERVER/login.html page URL, /sapphire-api/lobby/login API URL, and lobby host/port. RustClient logs in against that API and uses the returned session and lobby endpoint. For Meteor, it consumes the published /login_su/login.php URL and the existing v3 login protocol.

Build and run

Requirements:

• Windows 10 or later
• Rust 1.92 or later with the MSVC toolchain
• Visual C++ runtime required by the game clients themselves

cargo build --release
.\target\release\sapphire-multilauncher.exe

Run the read-only manifest and supplied-media verification:

cargo run -- --verify

Prepare either or both retail payloads without opening the graphical launcher:

cargo run --release -- --prepare sapphire
cargo run --release -- --prepare meteor
cargo run --release -- --prepare all

Run the full test suite:

cargo test --all-targets

Exercise a locally running PrivateServer-RS Twin Saga oracle without launching legacy code:

cargo run -- --twin-saga-loopback http://127.0.0.1:PORT/.well-known/mmo-preservation.json

Supplied media and fixed targets

The launcher auto-detects the client files supplied beside this repository under ..\assets\FFXIV.

Target	Required source	Final version	Patch chain
Sapphire	ARR boot 2013.06.18.0000.0000, game 2013.06.29.0004.0000	FFXIV 3.3 / Heavensward	41 ZiPatch files, 32.68 GiB
Meteor	FFXIV 1.0 boot/game 2010.07.10.0000	FFXIV 1.23b, game 2012.09.19.0001	52 legacy ZiPatch files, 5.87 GiB

The Meteor target is 1.23b, not 1.23a. Its final retail patch, launch-token format, and process compatibility offsets all correspond to 2012.09.19.0001.

Both targets are built as managed, side-by-side clones. Original media is never patched. The default library and shared caches remain compatible with the previous launcher location:

%LOCALAPPDATA%\SapphireLauncher\clients

Settings are stored in %LOCALAPPDATA%\SapphireLauncher\rust-settings.json. Passwords and active session IDs are not persisted.

After a client is prepared, RustClient atomically publishes %LOCALAPPDATA%\SapphireLauncher\server-assets.json and a portable server-assets.json in the managed client-library root. It identifies the verified Sapphire game\sqpack tree and Meteor staticactors.bin (or its preserved legacy filename), together with absolute and library-relative paths, versions, and patch-cache locations. When both programs share the controller filesystem, leaving the matching PrivateServer-RS source-path setting blank enables automatic detection. When the Windows library is exposed to the Linux manager through a mounted share, set that source-path field to the portable JSON file (or its containing library folder); the manager resolves the relative path and sends the required runtime asset through its pinned-SSH transfer.

Automatic patching and recovery

Clicking Launch prepares the selected client when necessary, then starts it. Prepare / Resume client performs the same installation without launching.

The installer provides:

• immutable, ordered manifests for both supported targets;
• resumable HTTP downloads and a shared per-target cache;
• expected byte-length checks for all patches;
• CRC-32 verification for the complete Meteor retail chain;
• per-chunk CRC and structural validation for modern ZiPatch files;
• patch path-containment and symlink/junction checks;
• side-by-side source cloning and disk-space checks;
• resumable installation state between patches;
• safe cancellation after an active patch finishes;
• interrupted-patch detection and an explicit partial-client reset that retains downloads.

The original Meteor URL is retained as a configurable default. If it is unavailable, set a working HTTP(S) mirror that preserves the manifest paths or pre-populate clients\.patch-cache\ffxiv-1.23b. Sapphire mirrors use the preserved Square Enix repository layout below their configured base URL. The original Square Enix 3.3 endpoint is HTTP-only, so the launcher validates every ZiPatch before applying it. PrivateServer-RS can advertise either mirror through discovery.

Launch behavior

Sapphire launch arguments reproduce the previous launcher contract: eight lobby routes, the configured lobby port, language index, region, SqPack mode, expansion entitlement, frontier host, and optional extra arguments. When discovery supplies a login API, RustClient posts the entered credentials and launches with Sapphire's returned session, lobby host, and lobby port. A zero developer session remains available when no login API is configured.

Meteor mode supports the v3 JSON login protocol when a login URL is configured and uses a credential-free debug session when it is empty. It generates the Project Meteor Blowfish token and starts ffxivgame.exe suspended before applying the required 1.23b compatibility changes:

• lobby IPv4 address;
• fixed encryption time;
• high logical-processor affinity initialization;
• VFX worker limits.

The process resumes only after every patch succeeds.

Repository layout

src/catalog.rs          Fixed client definitions and patch manifests
src/installer.rs        Shared clone/download/resume/finalization workflow
src/modern_patch.rs     Current ZiPatch validation and application
src/legacy_patch.rs     FFXIV 1.x ZiPatch parser and applier
src/launch/             Sapphire arguments and Meteor token/process launch
src/auth.rs             Sapphire and Meteor authentication
src/media.rs            Source discovery and exact-version validation
src/server.rs           PrivateServer-RS discovery and endpoint validation
src/server_assets.rs    Verified client-to-server asset handoff
src/twin_saga.rs        Preservation-only discovery/patch/login/world/zone oracle
src/ui.rs               Native Rust launcher interface

The launcher is fully native. It does not load CefSharp, WPF, .NET, or the former C# executable. The retired server-hosted web UI/JavaScript bridge and Meteor Theme.json presentation layer are intentionally replaced by the direct native client/language/server flow.

Future game clients

The current client boundary is ClientKind plus its catalog, source inspector, installer format, and launch adapter. New decompiled clients should be added behind the same boundary so the primary language/server flow remains unchanged while client-specific patching and process setup stay isolated.

Final Fantasy XIV © 2010–2017 SQUARE ENIX CO., LTD. This project is not affiliated with Square Enix.