Skip to main content

What is a Steam manifest file, and how do you use it with SteamTools?

The complete guide to Steam manifest files, the matching Lua unlock script, and the four-step workflow to get a game into SteamTools. Designed as the front door for new users; deep dives live on the linked pages.

Last updated: 2026-07-05

If you have ever searched for "how to use SteamTools" or "what is a steam manifest" and ended up reading five different Discords and three GitHub issues, this page is for you. It is the front door to the rest of the site. It answers the two questions that everyone asks first, links to the deep-dive pages for everything else, and leaves you with a working file on your disk by the end of the section that matters.

The 30-second answer

A Steam manifest file is a small text file in Valve's "ACF" format that tells the SteamTools desktop client which depots of a Steam game to download and how to verify them. A manifest file is always paired with a small Lua script that tells SteamTools which branch to prefer and how to authenticate against Steam's servers. Together, the two files let SteamTools install a game for offline play without going through the official Steam client.

You can generate a manifest + Lua pair for any Steam App ID at the home page. The rest of this guide explains what the files are, how they work, where to put them, and what to do when something breaks.

What is a Steam manifest file?

A manifest file is a text file named appmanifest_<APPID>.acf. It looks like this for Portal (AppID 400):

"AppState"
{
    "appid"         "400"
    "name"          "Portal"
    "installdir"    "Portal"
    "StateFlags"    "4"
    "UpdateLocalTime"   "Wed Jan  1 12:34:56 2025"
    "buildid"       "1234567"
    "LastOwner"     "12345678901234567"
    "BytesToDownload"   "1234567890"
    "BytesDownloaded"   "1234567890"
    "AutoUpdateBehavior"    "0"
    "AllowOtherDownloadsWhileRunning"  "0"
    "InstalledDepots"
    {
        "400"  "1234567890123456789"
    }
}

The shape is fixed by Valve. The interesting fields are appid (which game), installdir (where SteamTools should put the files), buildid (which build of the game), and the InstalledDepots block (which depot IDs to download and the manifest IDs that unlock them). Every other field is bookkeeping that SteamTools mostly ignores.

If you want the full field-by-field breakdown — what StateFlags actually does, why LastOwner looks like a 17-digit number, and how the manifest IDs in the InstalledDepots block relate to Steam's CDN — the deep dive is on the manifest files explained page. The short version: if appid, installdir, buildid, and InstalledDepots are correct, SteamTools will install the game. Everything else is metadata.

What is the Lua file for?

The Lua file is the partner to the manifest. It is a small script (typically 10-30 lines) that tells SteamTools three things:

  1. Which branch to prefer. Steam games have multiple branches — public, beta, ptb, experimental, staging. The Lua file tells SteamTools which one the manifest was generated for. If you do not specify a branch, the generator defaults to public.
  2. How to authenticate against Steam's CDN. The script asks SteamTools to sign the manifest against Steam's public content servers and confirm that the depot IDs in the manifest match a real, downloadable build.
  3. What to do with the depot data after download. Some games need a small post-install step (unpack an archive, move a file into the right place, set a config). The Lua file can include that step.

The Lua file is not optional. SteamTools will refuse to install a game if the manifest is present but the Lua file is missing. The two files always come as a pair from this generator.

The end-to-end workflow — what the Lua file actually does, what each line means, and what happens when a Lua script throws an error — is on the how it works page. The page also has a four-step flow diagram you can follow.

How the two files work together

The mental model is: the manifest says what to install, the Lua says how to install it. SteamTools reads the manifest first to know which depots of which build to fetch. Then it runs the Lua script to know which branch, which authentication path, and which post-install steps to apply. If either file is missing, SteamTools bails out early and writes a line to its log directory explaining what was missing.

The two files are also version-locked to each other. A manifest generated against public branch will not work with a Lua script generated for beta branch, and vice versa. The generator always returns the two files as a matched pair; do not mix and match files from different sources.

Step-by-step: from AppID to installed game

The full workflow takes about three minutes once you have your AppID. The condensed version:

  1. Find the App ID. It is the number in the Steam store URL — for example, Portal is https://store.steampowered.com/app/400/, so the App ID is 400. If you cannot find it in the URL, the how to find a Steam App ID page has three reliable methods.
  2. Search and confirm. Type the game name or App ID on the home page. The search runs against the live Steam store, so DLC, soundtracks, and unlisted-but-published apps all show up.
  3. Generate. Press the button. The generator queries the upstream ManifestHub3 cache and returns a ZIP containing the .acf and .lua files. The response is usually under 1.5 seconds.
  4. Place the files. Drop the .acf file into <SteamTools>/depotcache/ and the .lua file next to the SteamTools binary. Restart SteamTools. The game appears in your library.

The detailed walkthrough — including where <SteamTools> lives on Windows, macOS, and Linux, what to do if SteamTools does not see the files, and how to read the SteamTools log — is on the how it works page.

How to find a Steam App ID

Three reliable methods, in order of how often they work:

  1. From the Steam store URL. Open the game's store page. The number between /app/ and the next / is the App ID. Example: https://store.steampowered.com/app/400/Portal/ → 400.
  2. From SteamDB. Search for the game at steamdb.info. The canonical store URL at the top of the page contains the App ID.
  3. From your local Steam install. If you have the game installed, look in <Steam>/steamapps/. Every installed game has a file called appmanifest_<APPID>.acf in that directory. The number in the filename is the App ID.

The full guide — including how to find the App ID for delisted games, DLC, soundtracks, and unlisted-but-published apps — is on the how to find a Steam App ID page.

Common problems and fixes

The five things that go wrong most often, in order of frequency:

1. The downloaded ZIP is empty. Usually one of three things. Either the AppID is in the Steam catalogue but not yet in the ManifestHub3 cache (the page should show a "not in our download database yet" notice with a Discord link), the SteamTools client is filtering the file (check the log directory), or a local security tool is stripping the response. If none of those fit, open an issue with the App ID and a copy of the ZIP.

2. SteamTools does not see the files after I drop them in. The most common cause is wrong folder. On Windows the path is <SteamTools>\depotcache\ for the .acf and <SteamTools>\ for the .lua. On macOS and Linux the paths are analogous. Restart SteamTools after copying; it does not hot-reload.

3. "App not found in the Steam store" error. The number is usually a package ID, depot ID, or build ID — not an App ID. Confirm against the canonical store URL. Delisted games whose AppIDs no longer resolve in /appdetails cannot be generated at all.

4. "429 rate limit" error. The generator enforces 1.5 seconds between calls per IP. If you are scripting, exponential backoff with a 10-second cap is the right pattern. There is no API key and no elevated tier.

5. The Lua script throws an error on launch. Either the file is corrupted (re-download) or it was generated for a different branch than the manifest. Always use the matched pair from a single generator call.

For the full long-tail of problems — branch mismatches, regional locks, anti-cheat interactions, edge cases with proton, what to do when a build is delisted between manifest generation and SteamTools restart — the FAQ has 20 entries covering the long tail of "I tried X, what do I do now?".

SteamTools vs alternatives

The most common "vs" questions, briefly:

  • SteamTools vs the official Steam client. SteamTools is an unofficial, open-source Steam fork maintained by SteamTools-Team. It is not distributed or endorsed by Valve. It extends the official client with offline library management, multi-account switching, and the ability to apply community-published manifest + Lua unlocks. This site (SteamTools.games) is an independent generator that produces the manifest + Lua pair SteamTools consumes — it is not a fork and not a client.
  • Watt Toolkit vs Steam++ vs SteamTools. They are the same project at different points in time. SteamTools was the original name; the Chinese-language community called it Steam++; it was later renamed to Watt Toolkit. All three names refer to the same desktop client at github.com/SteamTools-Team/SteamTools.
  • SteamTools vs GreenLuma. GreenLuma is a separate community project with a different manifest + Lua format. The two ecosystems are not interchangeable. SteamTools.games produces files specifically for the SteamTools client; if you are a GreenLuma user, this generator is not the right tool for you.
  • SteamTools in 2026. For new users, SteamTools + this generator is the lightest-weight path. The other ecosystem (GreenLuma and a small number of paid unlockers) is not recommended for new users; the tools are less maintained, less documented, and have higher malware risk.

The full comparison, including why some paid unlockers appear to work but should not be trusted, is on the FAQ page.

For developers

The generator exposes a public REST API at /api/search (look up an AppID from a game name) and /api/generate (produce the manifest + Lua pair). Both are unauthenticated, both are subject to a per-IP rate limit, and both are documented at the developers page. An OpenAPI 3.1 spec is downloadable from the same page.

If you are integrating SteamTools into a larger automation, the right pattern is:

  • Use /api/search to resolve a user-typed game name to an App ID.
  • Use /api/generate with that App ID and a branch parameter.
  • Respect the 1.5-second rate limit. Exponential backoff with a 10-second cap.
  • Cache the result. Manifest + Lua pairs are versioned to the upstream build ID; they do not need to be re-fetched unless the upstream cache changes.

For batch generation of 50+ titles at once, the faster path is to ask in the Discord and have the maintainers add them to ManifestHub3 in one go, which is what the curated "Popular Games" list on the home page reflects.

The complete set of related pages

If you want to read one more page, pick from these based on what you need:

  • About SteamTools.games — what this site is, who runs it, what it is not. Read this if you want to know who is behind the generator.
  • How it works — the full four-step flow with the diagram, the four-step visual, and the deep dive on what the Lua script does line-by-line. Read this if you want to understand the workflow before doing it.
  • Manifest files explained — every field in the appmanifest_*.acf file, what it does, and why SteamTools needs each one. Read this if you want to read your manifest by hand.
  • How to find a Steam App ID — three reliable methods, plus the edge cases (delisted, DLC, soundtracks). Read this if you have a game but no App ID.
  • FAQ — 20 long-tail questions covering the "I tried X, what do I do now?" surface. Read this when something breaks.
  • Citation — the canonical, machine-readable identity card for this site. Read this if you are citing SteamTools.games in a research paper or AI answer.
  • Developers — the API documentation, the OpenAPI spec, and the rate-limit details. Read this if you are writing a script.
  • Changelog — what changed and when. Read this if you want to know if a recent site update affects your workflow.
  • Blog — guides, deep dives, and product notes. Read this if you want to go deeper on a specific topic.

Background: what SteamTools actually is

SteamTools (also called Watt Toolkit, formerly called Steam++) is an open-source Steam fork maintained by the SteamTools-Team. It is not a plugin for the official Steam client — it is a full fork that replaces the Steam binary on your machine. It runs on Windows, macOS, and Linux.

SteamTools extends the official Steam client in three ways that matter for this guide:

  1. Offline library management. SteamTools can maintain a fully functional offline Steam library, including games you have already started playing online. When the Steam servers are unreachable, SteamTools falls back to its local copy of the depot data plus the manifest + Lua files you have placed in its config directory.
  2. Multi-account switching. SteamTools can run multiple Steam accounts in parallel on the same machine, with isolated depots and isolated save data. The official Steam client does not support this.
  3. Community-published unlocks. This is the part that needs manifest + Lua files. SteamTools reads a manifest file from its depotcache directory, runs the Lua script to authenticate against Steam's public content servers, and downloads the depot data into a folder that the official Steam client can later use as a "local content server". The community-published manifest + Lua pairs (and the data cache that backs them) are what the upstream ManifestHub3 project provides.

If you want a longer write-up of what SteamTools is, who maintains it, how it relates to Steam++ and Watt Toolkit, and where the boundaries are between this generator and the desktop client, the about page has the full entity definition.

Common misunderstandings

A few things that come up often enough to pre-empt:

"A manifest file is a crack or a hack." It is a configuration file. The data it points at is already on Steam's public CDN; the manifest is a recipe that tells SteamTools which depots to fetch and how to verify them. The manifest itself does not contain any copyrighted content.

"If I have a manifest, I can get any game for free." No. A manifest only works for games you have legitimately purchased on Steam. SteamTools' offline mode requires that the underlying depot data is one you have already paid for; the manifest is a pointer, not a substitute for the purchase.

"SteamTools and this site are the same project." They are not. SteamTools is the desktop client, maintained by SteamTools-Team at github.com/SteamTools-Team. This site is an independent generator, maintained by the SteamTools.games team, that produces one of the inputs SteamTools consumes. The two projects share a name and a goal but have separate codebases, separate maintainers, and separate release cadences.

"If a game is not in the upstream cache, I should give up." No — the page will tell you that explicitly and link to the Discord to request it. Most popular titles end up in the cache within days of request; niche titles may take a release cycle. The "not yet in the cache" message is the right signal, not a dead end.

"I can use a GreenLuma manifest with SteamTools." No, the formats are different. The two ecosystems are not interchangeable. A GreenLuma manifest will not load in SteamTools and a SteamTools manifest will not load in GreenLuma.

When NOT to use this generator

The generator is the right tool when you want to use SteamTools to install a game you already own for offline play. It is the wrong tool when:

  • You have not purchased the game. The manifest only describes how to fetch depot data; it does not bypass the purchase. There is no such thing as a "free manifest" — manifests describe already-purchased content.
  • You are using GreenLuma, Goldberg, or another non-SteamTools client. Those ecosystems have their own manifest formats. The files this generator produces are SteamTools-specific.
  • You want to play online. SteamTools' offline mode is for offline play. Online play goes through the official Steam client as normal; SteamTools' role there is just the multi-account switching.
  • The game is delisted and the App ID no longer resolves. Steam's /appdetails endpoint is the source of truth; if the App ID returns nothing, the generator cannot help. SteamDB keeps a record, but the actual depot data is no longer fetchable from Steam.

Glossary

A short reference for the terms used in this guide and the linked pages.

App ID. A 6-8 digit number that uniquely identifies a Steam application. It is the number in the Steam store URL after /app/. Example: 400 for Portal.

Branch. Steam games can have multiple build branches — public is the default and what you usually want; beta, ptb, experimental, and staging are common alternates. The Lua file tells SteamTools which branch the manifest was generated for.

Build ID. A 6-10 digit number that identifies a specific build of a game. The manifest includes the build ID; SteamTools downloads the depot data for exactly that build.

Depot. A unit of downloadable content within a Steam app. A typical game has 1-5 depots (the main game, the OST, language packs, etc.). The manifest names each depot and the manifest ID that unlocks it.

Manifest ID. A 19-digit number that identifies a specific version of a specific depot. The InstalledDepots block in the manifest maps depot IDs to manifest IDs.

ManifestHub3. The open-source, MIT-licensed community cache of manifest + Lua pairs. The generator reads from ManifestHub3. The data is auditable, forkable, and not dependent on this site.

SteamTools. The desktop client. Maintained by SteamTools-Team at github.com/SteamTools-Team. Distinct from this site.

SteamTools.games. This site. A thin generator that produces the manifest + Lua pair SteamTools consumes. Not affiliated with SteamTools-Team.

Watt Toolkit. The current Chinese-language name for the SteamTools client. The project was previously called Steam++.

ACF. Valve's "Application Configuration File" format. A key-value text format with section headers, similar to INI. Manifests use ACF.

See it in action

The manifest + Lua workflow works for every game in the Steam catalogue. To see what a generated file looks like, the popular games index on the home page has well-known AppIDs ready to generate. Some of the most-requested:

If your game is not on that list, search for it on the home page — if it is in the Steam catalogue, the generator will return a result. If the upstream ManifestHub3 cache does not have it yet, the page will say so and give you a Discord link to request it.