Windows: launcher without VCRUNTIME140.dll, a clear message without Vulkan, import checks in CI

The Windows launcher was built without crt-static and imported VCRUNTIME140.dll,
which only the Visual C++ redistributable installs: players without it got a
missing-DLL dialog before anything started. The game itself links only system
DLLs (vulkan-1.dll is loaded at run time).

- launcher.yml links the C runtime on Windows.
- tools/check_imports.py reads PE import and delay-import tables (and ELF
  loader, needed libraries and run paths); release.yml and launcher.yml fail
  when a Windows binary imports a non-system DLL.
- release.yml builds Linux on Ubuntu 22.04: the NixOS-made Linux release asked
  for a /nix/store loader, so it ran nowhere but NixOS.
- No adapter: the game says the Vulkan driver is missing and what to install,
  and on Windows keeps the console open until Enter.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-13 15:02:15 +02:00
parent 59fd98dea4
commit 1a10d4efe8
5 changed files with 198 additions and 3 deletions
+8
View File
@@ -27,7 +27,12 @@ jobs:
- os: windows-latest
asset: horizon-launcher-windows-x64.zip
binary: horizon-launcher.exe
# The C runtime linked in: without it the launcher asks for VCRUNTIME140.dll,
# which only the Visual C++ redistributable installs.
rustflags: -C target-feature=+crt-static
runs-on: ${{ matrix.os }}
env:
RUSTFLAGS: ${{ matrix.rustflags }}
defaults:
run:
working-directory: launcher
@@ -48,6 +53,9 @@ jobs:
run: grep -qx "version = \"${GITHUB_REF_NAME#launcher-v}\"" Cargo.toml
- run: cargo test --release --locked --lib
- run: cargo build --release --locked
- name: Only system libraries
if: runner.os == 'Windows'
run: python ../tools/check_imports.py target/release/${{ matrix.binary }}
- name: Package
run: |
mkdir -p dist
+26 -2
View File
@@ -1,7 +1,9 @@
name: release builds
# Started by hand: gh workflow run release.yml --ref <branch>
# Builds the Windows x64 client and uploads the playable folder as an artifact.
# Linux and macOS builds are made on the development machines.
# Builds the Windows x64 and Linux x86_64 clients and uploads the playable folders as artifacts.
# macOS builds are made on the development machines. Linux is built here, on an older Ubuntu,
# so the binary uses the standard loader and runs on any recent distribution (and on NixOS
# through nix-ld): a build made on NixOS asks for a /nix/store loader no other system has.
on:
workflow_dispatch:
permissions:
@@ -18,6 +20,10 @@ jobs:
env:
RUSTFLAGS: -C target-feature=+crt-static
run: cargo +stable build --release --locked -p horizon-client --bin horizon-client
- name: Only system DLLs
# Vulkan and the rest are loaded at run time; a linked non-system DLL is a
# "DLL not found" dialog on some players' machines.
run: python tools/check_imports.py target/release/horizon-client.exe
- name: Package
shell: bash
run: packaging/package.sh target/release/horizon-client.exe dist/horizon-windows-x64
@@ -25,3 +31,21 @@ jobs:
with:
name: horizon-windows-x64
path: dist/horizon-windows-x64
linux:
runs-on: ubuntu-22.04
steps:
- uses: actions/checkout@v4
- name: Install Rust toolchain
run: rustup toolchain install stable --profile minimal
- name: ALSA headers
run: sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev
- name: Build the client
run: cargo +stable build --release --locked -p horizon-client --bin horizon-client
- name: Standard loader and libraries only
run: python3 tools/check_imports.py target/release/horizon-client
- name: Package
run: packaging/package.sh target/release/horizon-client dist/horizon-linux-x86_64
- uses: actions/upload-artifact@v4
with:
name: horizon-linux-x86_64
path: dist/horizon-linux-x86_64
+14 -1
View File
@@ -214,6 +214,18 @@ fn mip_chain(pixels: &[u8], size: u32, layers: u32) -> (Vec<u8>, u32) {
}
(out, levels)
}
/// What to tell a player whose system offers no usable graphics adapter.
/// Vulkan is loaded at run time (the game links no graphics library), so a
/// missing driver shows here rather than as a missing-DLL dialog.
#[cfg(target_os = "windows")]
const NO_GPU_DRIVER: &str = "No Vulkan graphics driver found: Horizon needs a GPU driver with Vulkan \
(vulkan-1.dll comes with it). Install the latest driver for your NVIDIA, AMD or Intel GPU \
and start the game again";
#[cfg(target_os = "macos")]
const NO_GPU_DRIVER: &str = "No Metal graphics device found";
#[cfg(not(any(target_os = "windows", target_os = "macos")))]
const NO_GPU_DRIVER: &str = "No Vulkan graphics driver found: Horizon needs the Vulkan loader \
(libvulkan.so.1) and a Vulkan driver for your GPU (Mesa's, or NVIDIA's)";
impl Renderer {
pub async fn new(
window: Arc<Window>,
@@ -234,7 +246,8 @@ impl Renderer {
force_fallback_adapter: false,
..Default::default()
})
.await?;
.await
.map_err(|e| format!("{NO_GPU_DRIVER} ({e})"))?;
let info = adapter.get_info();
eprintln!(
"Horizon renderer: {} ({:?}, {:?})",
+7
View File
@@ -5,6 +5,13 @@ mod game;
fn main() {
if let Err(error) = game::run() {
eprintln!("Horizon: {error}");
// Started from Explorer, the console window closes with the game:
// keep the message on screen until it is read.
#[cfg(windows)]
if std::io::IsTerminal::is_terminal(&std::io::stdin()) {
eprintln!("Press Enter to close.");
let _ = std::io::stdin().read_line(&mut String::new());
}
std::process::exit(1);
}
}
+143
View File
@@ -0,0 +1,143 @@
#!/usr/bin/env python3
"""Fail when a release binary needs a library its players may not have.
Windows .exe: every DLL in the import and delay-import tables must ship with
Windows (no VCRUNTIME140.dll, vulkan-1.dll, ...): Vulkan and the like are
loaded at run time, so a missing driver is an error message, not a dialog.
Linux ELF: the loader must be the standard one (not a /nix/store path) and the
needed libraries the ones every desktop distribution has.
"""
import argparse
import struct
import sys
from pathlib import Path
# DLLs that are part of Windows 10 and 11. api-ms-win-* and ext-ms-win-* API
# sets resolve inside Windows too.
WINDOWS_SYSTEM = {
"advapi32.dll", "bcrypt.dll", "bcryptprimitives.dll", "cfgmgr32.dll", "combase.dll",
"comctl32.dll", "comdlg32.dll", "crypt32.dll", "d2d1.dll", "d3d11.dll", "d3d12.dll",
"d3dcompiler_47.dll", "dbghelp.dll", "dcomp.dll", "dwmapi.dll", "dwrite.dll", "dxgi.dll",
"gdi32.dll", "hid.dll", "icuuc.dll", "imm32.dll", "iphlpapi.dll", "kernel32.dll",
"kernelbase.dll", "mfplat.dll", "mmdevapi.dll", "msvcrt.dll", "ncrypt.dll", "ntdll.dll",
"ole32.dll", "oleaut32.dll", "opengl32.dll", "propsys.dll", "secur32.dll", "setupapi.dll",
"shcore.dll", "shell32.dll", "shlwapi.dll", "ucrtbase.dll", "user32.dll", "userenv.dll",
"uxtheme.dll", "version.dll", "winmm.dll", "ws2_32.dll", "xinput1_4.dll",
}
LINUX_LOADER = "/lib64/ld-linux-x86-64.so.2"
LINUX_SYSTEM = {
"libc.so.6", "libm.so.6", "libgcc_s.so.1", "libdl.so.2", "libpthread.so.0", "librt.so.1",
"ld-linux-x86-64.so.2", "libasound.so.2",
}
def windows_allowed(name):
name = name.lower()
return name in WINDOWS_SYSTEM or name.startswith(("api-ms-win-", "ext-ms-win-"))
def pe_imports(data):
"""DLL names in a PE32+ file's import and delay-import tables."""
pe = struct.unpack_from("<I", data, 0x3C)[0]
if data[pe:pe + 4] != b"PE\0\0":
raise ValueError("not a PE file")
sections_count, optional_size = struct.unpack_from("<H12xH", data, pe + 6)
optional = pe + 24
magic = struct.unpack_from("<H", data, optional)[0]
directories = optional + (112 if magic == 0x20B else 96)
sections = [struct.unpack_from("<8xIIII", data, optional + optional_size + 40 * i)
for i in range(sections_count)]
def offset(rva):
for size, address, raw_size, raw in sections:
if address <= rva < address + max(size, raw_size):
return rva - address + raw
raise ValueError(f"RVA {rva:#x} outside every section")
def name_at(rva):
start = offset(rva)
return data[start:data.index(b"\0", start)].decode("ascii")
names = []
# Directory 1: imports (20-byte descriptors, name at +12); 13: delay imports (32 bytes, name at +4).
for index, size, name_field in ((1, 20, 12), (13, 32, 4)):
rva = struct.unpack_from("<I", data, directories + 8 * index)[0]
if not rva:
continue
at = offset(rva)
while any(data[at:at + size]):
names.append(name_at(struct.unpack_from("<I", data, at + name_field)[0]))
at += size
return names
def elf_needs(data):
"""The interpreter and DT_NEEDED libraries of a little-endian ELF64 file."""
if data[:4] != b"\x7fELF" or data[4] != 2:
raise ValueError("not an ELF64 file")
phoff, phentsize, phnum = struct.unpack_from("<Q", data, 32)[0], *struct.unpack_from("<HH", data, 54)
interpreter, dynamic, loads = None, None, []
for i in range(phnum):
kind, _, offset, vaddr, _, filesz = struct.unpack_from("<IIQQQQ", data, phoff + i * phentsize)
if kind == 3:
interpreter = data[offset:offset + filesz].rstrip(b"\0").decode()
elif kind == 2:
dynamic = (offset, filesz)
elif kind == 1:
loads.append((vaddr, offset, filesz))
def file_offset(address):
for vaddr, offset, size in loads:
if vaddr <= address < vaddr + size:
return address - vaddr + offset
raise ValueError(f"address {address:#x} outside every segment")
entries = []
if dynamic:
for at in range(dynamic[0], dynamic[0] + dynamic[1], 16):
tag, value = struct.unpack_from("<qQ", data, at)
if tag == 0:
break
entries.append((tag, value))
strtab = next((file_offset(v) for t, v in entries if t == 5), None)
def string(index):
start = strtab + index
return data[start:data.index(b"\0", start)].decode()
needed = [string(v) for t, v in entries if t == 1]
runpath = [string(v) for t, v in entries if t in (15, 29)]
return interpreter, needed, runpath
def check(path):
data = Path(path).read_bytes()
problems = []
if data[:2] == b"MZ":
names = pe_imports(data)
problems += [f"imports {n}, which Windows does not ship" for n in names if not windows_allowed(n)]
summary = ", ".join(sorted(set(n.lower() for n in names)))
else:
interpreter, needed, runpath = elf_needs(data)
if interpreter not in (None, LINUX_LOADER):
problems.append(f"loader is {interpreter}, not {LINUX_LOADER}")
problems += [f"needs {n}, which not every distribution has" for n in needed if n not in LINUX_SYSTEM]
problems += [f"has a run path to {p}" for p in runpath if "/nix/store" in p]
summary = f"{interpreter}; " + ", ".join(needed)
print(f"{path}: {summary}")
for problem in problems:
print(f" {path} {problem}", file=sys.stderr)
return not problems
def main():
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
parser.add_argument("binaries", nargs="+")
args = parser.parse_args()
ok = all([check(path) for path in args.binaries])
sys.exit(0 if ok else 1)
if __name__ == "__main__":
main()