SmokeAPI: DLC ownership emulation for legitimately owned Steam games

The problem SmokeAPI solves, and who it is actually for

Steamworks exposes DLC ownership through its SDK, and a game can ask the SDK whether the current account owns a given app ID. SmokeAPI sits between the game and that check and answers yes. The README describes it as "Legit DLC ownership emulation for Steamworks", which is a narrower claim than it first appears: the game itself is expected to be legitimately owned in Steam, and only the DLC entitlement is emulated. Everything else the Steamworks SDK provides, including multiplayer, achievements and the rest of the API surface, is left alone according to the project's own description.

The audience follows from that. This is not a piracy tool for full games, and it is not a general Steam emulator. It is for someone who owns a base game and wants its DLC content to load without buying the DLC, on a game whose DLC gate is implemented purely through Steamworks. The README spends most of its introduction explaining when that is not the case, which is a fair signal of how often it is not.

How the emulation actually loads into a game process

SmokeAPI ships as a DLL, smoke_api32.dll or smoke_api64.dll, and it has to end up loaded inside the game process. The README documents two installation modes with different mechanisms.

In proxy mode, you take the game's own steam_api.dll or steam_api64.dll, rename it to steam_api_o.dll or steam_api64_o.dll, and put SmokeAPI's DLL in its place under the original name. The game loads what it thinks is the Steamworks library, SmokeAPI forwards the calls it does not touch to the renamed original, and it intercepts the ownership queries it does handle. This is why proxy mode is described as guaranteed to load: the game is asking for that filename by definition. The cost is that a game update that replaces steam_api.dll overwrites the proxy, so you reinstall after patches.

Hook mode works differently. You rename SmokeAPI's DLL to version.dll, winhttp.dll or winmm.dll and drop it next to the game executable. Windows resolves those names through its normal DLL search, so the game loads SmokeAPI as a side effect of loading a system library it already wanted. Nothing is renamed or replaced, so game updates do not undo it, and the README notes hook mode can sometimes bypass DLL integrity checks. The trade-off is that not every game imports those particular DLLs, and when it does not you need an external injector such as Koaloader or Special K to get SmokeAPI into the process. The README's advice is to try hook mode first and fall back to proxy mode.

Installing SmokeAPI in proxy mode on Windows

Proxy mode is the more predictable of the two, so it is the better first attempt when hook mode has already failed. The steps below follow the README's proxy mode section. You need the latest release zip from the project's releases page, and you need to know whether the game is 32-bit or 64-bit: the README suggests opening Task Manager, going to the Details tab, right-clicking the column headers, choosing Select columns and ticking Platform while the game is running.

Start by renaming the game's existing Steamworks library so SmokeAPI can forward to it.

mv steam_api.dll steam_api_o.dll

Then extract the matching DLL from the release zip and rename it to the filename the game expects. On a 64-bit game that means steam_api64.dll; on a 32-bit game, steam_api.dll.

cp smoke_api64.dll steam_api64.dll

Place the renamed file next to steam_api_o.dll, in the same directory as the game's executable. Launch the game and check whether the DLC content is present. If the game ships DLC files separately and only downloads them after purchase, the README says installing SmokeAPI is not enough on its own: you also have to obtain those files and put them in the game folder, and it points to the game's own topic for them.

Self-hook mode when you want a single DLL in the folder

Self-hook is the lightest setup the README describes, adding exactly one file to the game folder and no injector. You extract smoke_api32.dll or smoke_api64.dll from the release zip depending on the game's bitness, rename it to version.dll, winhttp.dll or winmm.dll, and place it next to the game's .exe. The README lists those three names as the ones a game will load on its own, and it recommends trying them before reaching for anything else.

cp smoke_api64.dll version.dll

If the game does not import any of those three, the README's next step is Koaloader as an injector. The example it gives assumes the game loads d3d11.dll: extract d3d11.dll from the d3d11-32 or d3d11-64 folder of the Koaloader release depending on bitness, put it next to the game's .exe, then place smoke_api32.dll or smoke_api64.dll beside it without renaming. Special K is mentioned as a third option for games with protections that break hook mode, injected as a custom plugin. Note that these are two separate downloads from two separate repositories, and SmokeAPI's own README does not document Koaloader's configuration beyond the placement steps.

Configuration, and what the README does not tell you

The feature list includes "Optional configuration", and the repository has a static/ directory and a sync.json at the top level, which suggests the shipped config is generated or templated rather than hand-maintained. That is about as far as the material goes. The README does not document a config file name, a path, a schema, or any key. Anyone searching for how to configure SmokeAPI will not find an answer in this README, and the honest position is that the forum topic is where that information lives, since the project links to it as its homepage.

The same silence applies to uninstallation and to logging. There is no documented way to confirm that SmokeAPI loaded successfully other than observing whether DLC content appears in the game, and no documented rollback procedure beyond deleting the DLL you added or restoring the original steam_api.dll from its renamed copy. For a tool that modifies a game directory, that is a real gap, and it is the kind of thing that pushes users toward the forum thread rather than the repository.

Where SmokeAPI fails, and when it is the wrong tool

The README's list of unsupported cases is longer than its feature list, and it deserves to be read as the primary documentation. Games that do not ship steam_api.dll or steam_api64.dll are not supported at all. Games with third-party DRM such as Ubisoft or Rockstar titles will not work. Games using Denuvo SecureDLC most likely will not work. Free-to-play games are unlikely to unlock anything because their player data and entitlement checks live on the game server. Games with additional ownership protection or an alternative DLC verification mechanism will not work. Games with anti-cheat are unlikely to work, because anti-cheat software typically detects tampered DLLs and executables, and the README notes that disabling anti-cheat usually costs you online play.

Two further cases matter. Some games bundle DLC files in the base install regardless of ownership, which is the case where SmokeAPI does what you want. Others download DLC files only after purchase, which means SmokeAPI alone changes nothing visible and you need the files from elsewhere. And some games have no DRM at all, in which case the README says SmokeAPI is useless and you simply place the DLC files in the game folder. The warning at the top of the usage section is unambiguous: usage entails breaking one or more terms of service, which might result in a permanent loss of your account.

SmokeAPI compared with CreamAPI and Koaloader

The searches around this project consistently pair it with CreamAPI, and the difference is architectural rather than cosmetic. CreamAPI also emulates DLC ownership, but it does so by replacing the Steamworks library and reading its own configuration file that lists the DLC app IDs to unlock. SmokeAPI's README does not present a DLC list as the mechanism; it describes emulating ownership, with configuration marked optional. That is a meaningful distinction: a list-based approach requires you to enumerate app IDs per game and edit that list when DLC is added, while an emulation approach that answers ownership queries generically does not. The README does not spell out this comparison, so treat the distinction as a difference in documented design, not a claim about which works on more games.

Koaloader is not a competitor at all. It is an injector, and the README names it as a dependency for hook mode when a game does not load version.dll, winhttp.dll or winmm.dll on its own. KoalaBox appears in the repository layout as a submodule and in the README's generated-file comment, which ties the build tooling together, but the README does not describe KoalaBox's role in the runtime. Special K is the third option, a broader game-modding framework that can host SmokeAPI as a custom plugin for games where hook mode breaks.

Licence, build and the cost of keeping up

SmokeAPI is released under the Unlicense, and the repository carries UNLICENSE.txt. That is a public-domain dedication rather than a permissive licence with conditions, so there is no attribution requirement and no copyleft obligation attached to the source. It says nothing about the legal status of using the tool with a game, which is governed by the game's and Steam's terms of service, and the README's own warning is the relevant statement there. Nothing here is legal advice.

The source is C++ with CMakeLists.txt, a build.ps1 script, .clang-tidy and a KoalaBox submodule, so building from source is a CMake project rather than a single-file compile. The last push to the repository was on 2026-06-21, and the most recent release listed is v4.1.3 from 2026-01-18. Upgrade cost is low in practice: releases are self-contained DLLs, and updating means extracting the new smoke_api32.dll or smoke_api64.dll over the old one. In proxy mode you redo the rename after each game update; in hook mode you generally do not. The larger maintenance burden is not the tool but the research, since the README requires you to check the game's topic before assuming any unlock will work.

Editorial conclusion

SmokeAPI is for people who already own a game on Steam and want its Steamworks-gated DLC content to load, on a game whose forum topic confirms the unlock works. Skip it if the game uses Denuvo SecureDLC, third-party DRM, an anti-cheat, or server-side entitlement checks, because the README says those cases fail or are unlikely to work. Before installing, verify that steam_api.dll or steam_api64.dll exists in the game folder, that the game's bitness matches the DLL you extract, and read the warning that usage entails breaking one or more terms of service and might result in permanent loss of your account.

Frequently asked questions

Official sources

1. acidicoala/SmokeAPI on GitHub
2. License: Unlicense
3. Project website
4. README
5. Releases