Arkona

Steam

Operating systems: Windows / Linux. Steamworks and SteamStub: Goldberg, GBE fork, GSE fork, ALI213, CODEX, SSE, LumaEmu, RevEmu and Steamless. Linux: Goldberg and the GBE/GSE forks, depending on build architecture. The other guides mainly cover Windows.

Before starting

A Steamworks emulator is enough for many Steam games. Some also need a SteamStub tool, and games with another protection require a solution specific to that protection. These tools do not all do the same job.

Close the game, back up its original DLLs, executable and saves, and show file extensions. Match the game's architecture, not just your Windows version: x86 for a 32-bit game, x64 for a 64-bit game. Install one emulator for each API at a time. To undo a change, remove only the files you added and restore your backups.

Steamworks · ALI213

The setup below follows the ALI213 tutorial in my original file. Its old Uptobox download is no longer available.

  1. Locate steam_api.dll or steam_api64.dll in the game folder or a subfolder such as bin. Back it up, then put the corresponding ALI213 DLL and SteamConfig.ini in that directory.
  2. Open SteamConfig.ini with Notepad. Set AppID to the game's Steam App ID, and Language to a supported Steam language name. If this package uses API, take its value from the original Steam DLL's file version.
  3. For DLCs, add one DLC ID=name entry per line in [DLC]. UnlockListedDLCOnly=1 restricts the list to those entries; missing DLC files still need to be installed. Save the INI and launch the game executable.

Steamworks · CODEX

Use the emulator/configuration supplied with the relevant CODEX release. The old standalone AnonFiles archive in my file is gone.

  1. Install the game, then open the release's CODEX folder and read its NFO. Copy its contents into the installed game folder while preserving the folder structure; this is the game installation, not the mounted ISO.
  2. If supplied, open steam_emu.ini or the configuration named in the NFO. Keep the release's AppId, edit Language only to a language installed with the game, and preserve its DLC entries.
  3. Launch the installed game. If it opens Steam, check that the copied files reached the correct subfolder and were not quarantined. Do not mix DLLs from unrelated game versions.

Steamworks · Mr_Goldberg

The original Goldberg emulator supports offline play and compatible Steamworks multiplayer over LAN. These instructions cover the original version; forks may use different settings.

  1. Back up the game's steam_api.dll / steam_api64.dll, then replace it with the matching emulator DLL. On Linux, use the appropriate libsteam_api.so build.
  2. Create steam_appid.txt beside the emulator DLL, containing only the game's App ID.
  3. steam_settings is an optional folder beside the emulator DLL for this game's configuration files. You do not need to create it to use the default settings. It lets you force a supported language, choose a player name and customise other settings. See the README linked below for the details.
  4. You can now launch the game. If it is an older game that uses an older version of the Steam API, you may need to create a steam_interfaces.txt file. To do this, use the utility in the tools folder with the game's original DLL, then place the generated file beside the emulator DLL. If you want to play over LAN, make sure everyone has the same version of the game. Each player must use a different Steam ID, but everyone must use the same listening port.

Steamworks · GBE fork (Detanup01)

GBE fork is Detanup01's fork of Mr_Goldberg's Steamworks emulator. It is a separate project, not an official replacement. Its configuration differs from the original Goldberg version; keep the instructions for the build you choose.

  1. Choose a build from this repository's Releases for your OS and the game's architecture. Check the release notes, especially the actual architecture of Linux assets.
  2. Back up the original library and saves. Follow README.release.md for the DLL/.so and steam_settings layout, using this fork's INI examples.
  3. Run generate_interfaces on the game's original Steam library. Put the resulting steam_interfaces.txt inside steam_settings, not beside it as in the original Goldberg guide.

Steamworks · GSE fork (alex47exe)

GSE fork is alex47exe's fork of Detanup01/gbe_fork, itself derived from Goldberg. It has its own changes and releases, including documented tools for Steam stats conversion and a Linux steamclient loader. This is another branch, not a guarantee of better compatibility for every game.

  1. Download the appropriate build from alex47exe's Releases and read its notes. Back up the game files, settings and saves before changing forks; do not combine binaries from different packages.
  2. Use this fork's README.release.md and INI examples. Put steam_appid.txt containing the game's App ID inside steam_settings; adapt configs.user.ini for your player settings.
  3. Generate steam_interfaces.txt from the game's original Steam library with generate_interfaces, then place it inside steam_settings. Follow this fork's documentation for loader and networking options.

Steamworks · SmartSteamEmu (SSE)

SSE launches a game through its own Steam client emulation. Keep the game's original Steam API DLL; its newer networking interfaces are not all implemented.

  1. Extract SmartSteamEmu into the game folder or a separate directory. Restore the original steam_api.dll if another emulator had replaced it.
  2. Open SmartSteamEmu.ini and adapt the supplied game's executable path, App ID, player name and language settings. Preserve the section names and option spelling from that package.
  3. Run SmartSteamLauncher.exe rather than the game EXE. A different INI can be passed as the launcher's argument. Use Shift+Tab for the overlay on supported games; configure LAN/online options there.

Steamworks · LumaEmu

LumaEmu uses a launcher and steamclient library. Choose all files from the same x86 or x64 package.

  1. For x86, copy steamclient.dll, LumaGameLauncher_x86.exe, LumaGameLauncher_x86.dll and LumaEmu.ini into the game directory. For x64, use steamclient64.dll and the corresponding _x64 launcher files.
  2. Edit LumaEmu.ini using its included settings, then create steam_appid.txt or LumaAppID.txt containing the game's App ID.
  3. Start LumaGameLauncher_x86.exe or LumaGameLauncher_x64.exe. Dedicated-server layouts are different; do not apply their bin folder instructions to an ordinary game client.

Steamworks · RevEmu

RevEmu is especially associated with Source games and dedicated servers. Client and server packages have different layouts; the first post refers to the package's own instructions.

  1. Choose the client package for playing, or the server package for hosting, matching your game/engine version. Extract it separately and identify its rev.ini and included readme before replacing files.
  2. Copy files into the locations shown by that package, retaining its root/bin structure. In rev.ini, adapt the executable and game settings from the supplied example, then launch via the loader supplied for the client or the dedicated-server executable for the server package.

SteamStub · Steamless

Steamless unpacks supported SteamStub executables. It does not replace the Steamworks API and does not remove Denuvo or Steam CEG.

  1. Extract the release archive with its plugins. Start Steamless and select a copy of the game's protected executable.
  2. Run the unpack operation and read the log. Use the produced unpacked file only if the operation succeeded; keep the untouched EXE as a backup, and give the output the original EXE name in a test copy of the game.
  3. Test the game. If it still requires Steamworks, configure an appropriate API emulator separately. An unsupported-signature message is not solved by renaming an unrelated DLL.

SteamStub · Steam Stub Patcher

Voksi's historical 32/64-bit patcher. Its 32-bit version documents support for SteamStub V3 and V4, not every revision.

  1. Make a separate copy of the protected EXE and select the patcher for its architecture.
  2. Open that EXE with the patcher and apply its patch. Check the result before replacing the test copy's executable. Other protections and Steam API emulation remain separate.