00 Reference, version 1.5.0
Documentation [ Reference ] install, use, configure, build
Everything the app does, written out. Requirements and installation, the five step pipeline, updating a game, the file formats it reads, every setting, how depot sources are queried, the terminal version and Docker, how to build from source, and what to do when something breaks.
01 Getting started
02 Usage guide
03 File formats
04 Configuration
05 Terminal and Docker
06 Development
07 Help
01 Reference
01 Getting started
three partsGetting started #
Steam Manifest Downloader (SMD) is a Tauri v2 desktop application built with Rust and a WebView front end, with a terminal version for servers, scripts and Docker.
It walks you through five steps:
- Parse a
.luaor.stfile, or search by Steam App ID across your configured sources - Pick the depots you want, with platform, architecture and language tags pulled live from Steam's PICS info
- Download the selected depots with the native Rust engine, straight from Steam's CDN
- Optionally create desktop and start menu shortcuts (Windows), or add the game to your Steam library with grid art (Linux and Windows)
- Optionally patch the game with the gbe_fork emulator so it runs without the Steam client, including DRM detection via Steamless and an API check bypass
A game you downloaded once can later be updated, checked and started from the history, see Download history. If you would rather not pick depots yourself, Like Steam mode does it for you. Besides the desktop app there is a terminal version with the same steps and a Docker image, see Terminal version and Docker.
System requirements #
- .net 9 .NET 9.0 Desktop Runtime, Windows, optional. Only needed if you switch Settings, Download engine back to the legacy DepotDownloaderMod path. The default native engine is pure Rust and needs no runtime. Download the .NET 9.0 Desktop Runtime
-
mono
Mono, Linux, optional. Only needed if you want to use the DRM removal in step 5, since Steamless is a .NET Framework tool:
pacman -S monoorapt install mono-runtime - windows Windows 10 version 1803 or later, with WebView2. Windows 11 is supported as well.
-
linux
Ubuntu 22.04, Debian 12 or newer, or a comparable distribution. The AppImage brings WebKitGTK along and needs FUSE support, or
APPIMAGE_EXTRACT_AND_RUN=1. The AUR packages use WebKitGTK from the system - terminal The terminal version needs nothing else with the default engine. The Linux build is static and runs on any distribution, Alpine included. The optional DepotDownloaderMod engine needs a glibc based distribution there.
- network An internet connection is required for searching and downloading manifests.
- disk About 20 MB for the app itself, plus space for the depots you download.
Installation #
Windows, NSIS installer #
- Download
Steam.Manifest.Downloader_<version>_x64-setup.exefrom the releases page - Run the installer and follow the setup wizard. It installs per user and does not ask for admin rights
- Launch Steam Manifest Downloader from your start menu or desktop
The installer downloads gbe_fork, Steamless and the Steam API check bypass from GitHub the first time you use the emulator step, after asking you.
Windows, standalone ZIP #
- Download
Steam-Manifest-Downloader_<version>_windows-standalone.zipfrom the releases page - Extract the whole ZIP into a folder of your own, for example
Documents\Steam Manifest Downloader. Do not run it from inside the ZIP and do not extract it toC:\Program Files - Start
Steam Manifest Downloader.exefrom that folder, and keep thethird-partyfolder next to it
Nothing is installed and no admin rights are needed. The third-party folder already contains gbe_fork, Steamless and the Steam API check bypass, so the emulator step works without downloading them, which helps on PCs where GitHub downloads or scripts are blocked. Instructions in English and German are inside the ZIP.
Linux, AUR #
On Arch, CachyOS and Manjaro, install one of the two AUR packages. They conflict with each other, so only one can be installed:
# Released binary, installs in seconds
paru -S steam-manifest-downloader-bin
# Builds locally
paru -S steam-manifest-downloader
The terminal version has its own package, steam-manifest-downloader-terminal-bin. It installs smd and works next to either desktop package, see Terminal version.
Updates come through your package manager, and the in-app updater points you there instead of fetching an AppImage.
Linux, AppImage #
The AppImage brings WebKitGTK and the other libraries it needs, so nothing has to be installed. It runs on distributions from Ubuntu 22.04 and Debian 12 on.
- Download the latest
.AppImagefile from the releases page - Make it executable, then run it
chmod +x Steam.Manifest.Downloader_*_amd64.AppImage
./Steam.Manifest.Downloader_*_amd64.AppImage
Note
If FUSE is not available on your system, you can run the AppImage with the environment variable APPIMAGE_EXTRACT_AND_RUN=1 set.
First launch #
The very first time you start SMD, two small prompts appear before the main interface:
- Language picker. Pick between English and German. Before you make the choice the interface is already localised from your OS or browser language, so a German system starts in German, and if neither matches, English is the fallback. The picker just lets you override that. It is saved immediately, and you can change it later under Settings, Language, where a restart prompt appears so the new translation applies cleanly.
- Anonymous telemetry consent. Opt in or decline. Telemetry counters are end to end encrypted with an embedded public key, and you can change your choice anytime under Settings, Advanced settings.
If you installed a build with the bundled archive.org sources, which is the default for the GitHub, installer and AUR source builds, two depot source URLs are seeded automatically so search works out of the box. The Flatpak build does not seed them, so there you need to add at least one source manually under Settings, Advanced settings, Manifest sources.
After the prompts the main interface is ready. Optional next steps:
- Set a custom download location on the download page (step 3) before your first download
- Configure a ManifestHub API key on the download page for additional manifest sources
- Set a speed limit under Settings if the download should leave room for the rest of your connection
- Open Settings, Advanced settings to tune the retry count, the number of parallel chunks or the proxy, or to add and remove depot sources
02 Usage guide
five stepsUsage guide #
The pipeline has five steps. Steps 1 to 3, upload, select and download, are always required. Step 4, shortcuts and Steam library, and step 5, the emulator patch, are optional and only appear when they are relevant for your platform and game.
Step 1: upload a file #
Start by providing a manifest data file. You can either:
- Drag and drop a
.luaor.stfile onto the upload area - Click the upload area to open a file picker
The file picker filters on those two extensions, and anything else is turned away with the message Please select a .lua or .st file.
The application then parses the file and extracts all depot IDs, manifest IDs, app IDs and depot keys contained within.
Tip
You can upload multiple files. Each new upload merges its data with any previously loaded depots.
Step 2: select manifests #
After parsing, the app displays a list of all discovered depots and their manifest IDs. From here you can:
- Select and deselect individual depots using the checkboxes
- Use Select all or Deselect all for bulk actions
- Search and filter depots by ID or name using the search bar
- View app details fetched from the Steam Store API, such as the game name and icon
Each depot entry shows the depot ID, the associated manifest ID, whether a depot key was found, and a row of metadata tags pulled live from Steam's PICS info via api.steamcmd.net:
- OS tag, Windows, Linux or macOS
- Arch tag, 32-bit or 64-bit
- Language tag, only shown for language specific depots, for example
GermanorFrench
The metadata is cached per app ID for 7 days in your app data directory, so later visits are instant. If api.steamcmd.net is unreachable the tags simply do not appear, and the rest of the interface is unaffected.
Like Steam mode #
By default you choose every depot yourself and each depot gets its own subfolder. Switch on Settings → Depot selection → Like Steam and SMD selects the depots Steam would install on this system instead: the base game, the right platform, 64-bit where there is a choice, and your game language. They are written into one game folder, so the game is complete and starts right away. If you change the selection by hand, Pick like Steam in the depot list brings the recommended choice back.
- Add DLC in the depot list adds the DLC depots, and Remove DLC takes them out again. DLC you download is marked as owned for gbe_fork in step 5
- Include DLC selects the DLC every time
- Platform is Auto, Windows, Linux or macOS. Auto uses the system SMD runs on, and when a game has no Linux build the Windows version is picked, which runs with Proton
- Game language follows the app language unless you pick another one
- Start the download right away starts it as soon as the depots are picked, unless you change the selection first
Download queue #
Add to Queue next to Download keeps the game with its selection in a queue instead of starting it. The queue button in the header shows the waiting downloads, where you can reorder, remove or clear them and press Start Queue. They run one after another and are kept on disk, also across restarts. The shortcut, Steam and emulator steps of each finished game are offered afterwards, one game after another. Shut down the PC waits for the last download of the queue. Cancelling a download stops the queue, and the rest stays in it. The desktop app and the terminal version share the same queue, which the terminal version shows at the top of the history page.
How sources are asked
The search asks your configured depot sources in the order you set. The check for whether an App ID exists stops at the first source that answers, so the order you choose is the order that decides which source supplies the depots, keys and sizes.
Step 3: download #
Click the Download button to begin. Behind the scenes the application performs several operations:
- Steam session. Signs in to Steam anonymously and pulls app and depot metadata via PICS
- Manifest fetch. Requests each depot's manifest from Steam directly. If that fails, SMD falls back to your configured depot sources or Hubcap, then to the ManifestHub API if you have a key set
- Manifest decode. Unwraps the ZIP container, decrypts with AES-256 and parses the protobuf payload, encrypted filenames included
- Depot keys generation. Creates a
steam.keysfile containing all known depot decryption keys - Chunk download. Keeps up to 8 chunk fetches in flight against Steam's CDN (configurable under Settings, 1 to 64), decodes VZ1 (LZMA) or VSZTD (zstd) payloads and verifies each one against its CRC32 and SHA-1 before writing. Writes to the same file are serialized so concurrent chunks do not interleave. Failed chunks retry up to 8 times with exponential backoff, rotating CDN servers between attempts
Before the download starts, the size of the selected depots is compared with the free space at the download location. When it does not fit, SMD asks whether to start anyway. Updates are not checked, since most of the game is already there.
When a depot cannot be downloaded, because its key or manifest is missing or the connection drops, it is reported as failed and the download continues with the next one. Connection problems are retried as often as Max retries on error says, 3 by default. If the first depots all fail with a connection error and nothing got through, SMD stops early and says that Steam cannot be reached, instead of trying every depot. Error messages name the actual cause, such as a refused connection, a DNS problem or a certificate error, and never contain API keys.
Chunks that already match on disk are verified and skipped, so a restarted download picks up where it left off instead of starting over. While it downloads, the native engine also writes a small checkpoint per depot, .smd-depot-<id>.resume.json in the game folder, that records up to which chunk everything is finished. It is deleted once the depot is complete.
Engines
This is the native engine and it is the default. If you switch Settings, Download engine back to DepotDownloaderMod, SMD instead collects the manifests and hands them to the embedded DDM binary, which requires the .NET runtime on Windows.
You will see real time progress tracking with:
- A progress bar showing overall completion
- Download speed in MB/s
- ETA estimates
- Per depot status updates
Where files land
The downloaded files are saved to your configured download location, by default Documents/SteamDownloads. Each download creates a subdirectory named after the app ID and the game name, for example 220 - Half-Life 2. Inside it every depot gets its own subfolder, or, in Like Steam mode, all depots go into the game folder itself. Chunks are decrypted in memory and written straight into that folder, so nothing is staged in a temporary directory on another drive.
Speed limit #
Under Settings, Speed limit you can cap the download speed, in MB/s or in Mbit/s. MB/s matches the speed shown during a download, and Mbit/s follows the convention of internet providers, so 100 Mbit/s is about 12 MB/s. A change applies at once, also to a download that is already running. The limit applies to the native engine.
Shut down after the download #
The download screen has a switch Shut down the PC when the download has finished. It is off by default and can be switched on while the download runs. When the download ends, including when it fails but not when you cancel it, a 60 second countdown appears with Cancel and Shut Down Now. The history entry is saved before the PC turns off, and if the download was complete, the next start asks whether you want to continue with the steps you skipped, shortcuts, Steam library and emulator. Windows shuts down with shutdown /s, Linux tries systemctl poweroff, loginctl poweroff and shutdown -h now in that order. If none of them works, the app says so instead of failing silently.
When the download succeeds, Next leads to step 4, or to step 5 on Linux without Steam installed. The history entry is only persisted once you reach Back to Start, so closing the app mid flow leaves no trace.
Step 4: shortcuts and Steam library, optional #
Step 4 has two platform specific variants. SMD picks the right one automatically based on whether you are on Windows or Linux and whether Steam is detected.
Windows: create desktop and start menu shortcuts #
The app scans the download folder for executables, scores them by size and by name match against the folder hint, against a blacklist of installers and redistributables, and suggests the most likely game executable. You can:
- Browse manually for the
.exeif auto detection picked the wrong one - Toggle Desktop shortcut and Start menu shortcut independently
- Toggle Also add to Steam library to chain the Steam integration, described in the next part
Shortcuts are written as .lnk files through the Windows Shell API, directly from the app. PowerShell, which is often blocked on managed PCs, is only used as a fallback if that fails, with user derived values passed through environment variables so there is no string interpolation and no script injection.
Linux: add to Steam library #
The app detects your Steam installation, at ~/.steam/steam/, ~/.steam/root/, ~/.local/share/Steam/, the Flatpak or the Snap path, and on Windows through the SteamPath and InstallPath registry values (no administrator rights needed) or Program Files, and the active user, via the MostRecent=1 flag in loginusers.vdf.
If Steam is installed somewhere else, choose the folder that contains steam.exe or steam.sh under Settings → Steam folder, or with Choose Steam folder right where the app says Steam was not found. The setting shows which installation and account it found, or why a folder does not work, for example when nobody has signed in to Steam there yet. In the terminal version the field is under Settings → Downloads.
Steam rewrites shortcuts.vdf when it exits, which would drop a freshly added entry. So before anything is written, SMD checks whether Steam is running. If it is, you can close Steam yourself and try again, or let the app close Steam, add the entry and start Steam again. This applies to the Windows toggle Also add to Steam library as well.
When you click Add to Steam it will:
- Download the banner, hero, logo and icon images from the Steam CDN, using the icon hash from
api.steamcmd.net - Save them into
~/.steam/steam/userdata/<user>/config/grid/with the naming Steam expects:<shortcutid>.jpg,<shortcutid>p.jpg,<shortcutid>_hero.jpg,<shortcutid>_logo.pngand<shortcutid>_icon.jpg - Parse the existing binary
shortcuts.vdffile, with a backup, append a new shortcut entry, and write it back - Generate the shortcut AppID as
CRC32(exe_path + app_name) | 0x80000000, which is Steam compatible and deterministic
The Linux step also supports launch options, for example %command%, and a display name field. The new entry appears the next time Steam starts. For Windows games on Linux: right click the new entry in Steam, open Properties, then Compatibility, then enable Proton.
Footer buttons are minimal: Skip proceeds without adding, and Add to Steam switches to a single Next button after success.
Step 5: emulator, optional #
Step 5 patches the game with the gbe_fork Steam emulator so it can run without the Steam client. The whole feature is bundled, with no manual setup. It only appears when the app finds steam_api*.dll on Windows or libsteam_api.so on Linux in the download folder.
Variant picker #
Two gbe_fork variants are offered side by side:
- Regular, the stable build, recommended for most games
- Experimental, newer features, may be unstable
The chosen variant's DLL is fetched from the latest gbe_fork GitHub release after you confirm the download, extracted into the app data cache at $APP_DATA/gbe_fork_cache/<release-tag>/ and copied over the game's steam_api*.dll. The Windows standalone ZIP ships gbe_fork in its third-party folder, so nothing is downloaded there. The original is backed up as steam_api*.dll.steam.bak. steam_interfaces.txt is generated natively in Rust by pattern matching against 37 known Steam interface names, so no external generate_interfaces.exe is required.
DRM detection and removal, via Steamless #
Before applying the emulator, SMD scans the game folder for executables protected by Steam DRM (SteamStub). Detection is a fast PE header scan looking for a .bind section, with no execution required.
If DRM is found, a yellow warning banner appears with the affected files. Clicking Remove DRM (via Steamless):
- Downloads Steamless v3.1.0.5 once into the app data cache, or uses the copy bundled in the Windows standalone ZIP
- On Windows: runs
Steamless.CLI.exedirectly - On Linux: runs it via
mono, installed withpacman -S monoorapt install mono-runtime, andMONO_PATHis set to thePlugins/directory so plugin assemblies resolve correctly - Replaces the original
.exewith the unpacked version and keeps the original as.exe.drm.bak
The full Steamless log is shown inline if anything fails, with a one-click copy button. For the common causes, a failed GitHub download, a write protected game folder or files removed by the antivirus, the error comes with a plain explanation of what to do.
Steam API check bypass, optional toggle #
Some games perform additional integrity or size checks on steam_api*.dll at runtime, and those reject the gbe_fork swap even when it loaded. Enabling the bypass toggle installs Steam API Check Bypass by SteamAutoCracks alongside gbe_fork:
- The matching arch DLL, x64 for
steam_api64.dlland x32 forsteam_api.dll, is copied next togame.exeunder three hijack names:version.dll,winmm.dllandwinhttp.dll. Whichever the game imports gets loaded, and the others sit harmless - A
SteamAPICheckBypass.jsonfile is written next togame.exewith afile_redirectrule that points the first 3CreateFilereads ofsteam_api*.dllto the.steam.bakfile gbe_fork created, so integrity checks see the original bytes while the game uses the emulator - Any pre-existing
version.dll,winmm.dllorwinhttp.dllis backed up as<name>.bypass.bakand restored on revert
The bypass is only relevant for Windows games. Linux libsteam_api.so targets are skipped automatically.
The 21 emulator settings, in an accordion #
Below the variant picker is a collapsible accordion with 5 sections of tunable gbe_fork options. Only fields you actually fill in are written to disk, and the rest stays at gbe_fork's defaults. The values are saved to localStorage and pre-filled on your next visit.
- Account, display name, 64-bit Steam ID, game language, IP country (ISO 3166-1)
- Saves, local save path, per game folder name
- Network and compatibility, offline mode, Steam Deck mode, disable networking, disable LAN only
- Stats and achievements, record playtime, achievements bypass, force SteamHTTP success, Steam pre-owned IDs, free weekend flag
- Overlay, enable the experimental overlay, hide popups, always show FPS and playtime, hotkey, font size
Settings are written as INI files, configs.user.ini, configs.main.ini and configs.overlay.ini, into a steam_settings/ folder next to the patched DLL, alongside steam_interfaces.txt, steam_appid.txt and installed_app_ids.txt.
When the download chose DLC in Like Steam mode, SMD remembers them in .smd-dlcs.json in the game folder and writes them into configs.app.ini under [app::dlcs] with unlock_all=0, one ID=Name line each, so the game sees exactly the DLC you have.
Patch an existing folder #
Step 1 has a tab Patch Existing Folder for games that are already on disk, so you can run step 5 on its own. Pick the folder and enter the App ID. When the folder is already patched, the step offers Save Settings to change the emulator settings in place and Revert Patch to restore the original files, and Apply becomes Re-apply Patch when everything selected is patched already.
Achievement notifications #
gbe_fork stores achievements locally, and its own overlay does not work in every game. For a notification when you unlock one, the emulator step points you to Achievement Watcher by xan105 for Windows. The original is no longer developed, the fork by darktakayanagi is still maintained. SMD only links to it and does not install it.
History actions, per game #
After applying, the game appears in your download history, reachable via Back to Start, with an extra action button:
- Edit emulator settings, the gear button, re-opens step 5 in edit mode. The variant picker is hidden, the accordion is populated from the existing INI files, the Apply button becomes Save settings and a red Revert patch button appears. Reverting restores the original DLL, deletes
steam_settings/and is gated by a confirmation modal
If you delete the game folder externally, the Edit action shows an inline error banner in the history modal instead of crashing.
Cancel a download #
You can cancel an in-progress download at any time by clicking the Cancel button. When a download is cancelled:
- All in-flight chunk downloads stop immediately, and queued chunks bail out without waiting for a slot. On the DepotDownloaderMod path, the DDM process is terminated instead
- Partially downloaded files are deleted to avoid incomplete or corrupted data, unless you enabled Keep downloaded files when cancelling in Settings
- The interface returns to the selection screen so you can start a new download
Careful
By default, cancelling a download deletes all partially downloaded files for that session. Turn on Cancel behaviour, Keep downloaded files when cancelling if you would rather resume later. The job then lands in your history as Resumable, with a Resume button.
Before resuming, SMD asks how to continue. Resume uses the checkpoint: chunks well before the point where the download stopped are taken as they are, the last 64 chunks before and after it are checked again and the rest is downloaded, so a large game is not read from disk again. Check Everything reads and verifies every file that is already there first, which can take several minutes for large games. Downloads without a checkpoint, from older versions or the DepotDownloaderMod path, and updates always check everything. The terminal interface asks the same question with a checkbox.
Update a downloaded game #
When a game you downloaded earlier gets a new version, you do not have to download it again. Open the history and click Update, the arrow button on the entry. SMD loads the current manifests and runs the usual steps, with a notice in step 2 that the download goes into the existing folder. Then:
- Unchanged depots are skipped. After each depot SMD writes a small
.smd-depot-<id>.jsoninto the game folder with the manifest ID and the file list. If the manifest ID did not change, the depot is reported as up to date and left alone, so an applied emulator patch stays untouched - Only changed parts are downloaded. Every chunk already on disk is verified and skipped
- Removed files are deleted. Files that belonged to the old version but not to the new one are removed, and empty folders with them. Case only renames are never deleted, and nothing outside the depot folder is touched
- Your files stay. Saves, emulator settings and anything else that was never part of the depot are left alone
For folders downloaded before this feature existed, SMD reads the old .manifest file in the folder to learn the previous file list. Cancelling an update never deletes the game folder, whatever Keep downloaded files when cancelling is set to, and the history entry of the folder is replaced instead of duplicated. The update folder is tied to its App ID, so starting a different game afterwards never writes into it.
Engines
Skipping unchanged depots and deleting removed files is done by the native engine. With DepotDownloaderMod the download still goes into the existing folder, and DepotDownloaderMod handles the files itself.
In the terminal version, use Update or the u key in the history, or smd download <source> --update <game folder>.
Download history #
The history, the clock button in the header, lists every download with the game's portrait cover from Steam's store API, cached for a week. Above the list you can search by name or App ID, filter by status and sort by date, name or size. Each entry has these actions:
- Play starts the game. The first time, SMD asks which program file starts it when there is more than one and remembers the choice per folder, right click picks another one. On Linux, native games start directly and Windows games start through their Steam shortcut so Steam can use Proton, or with Wine
- Update brings the game to the newest version, see Update a downloaded game. When the history opens, SMD asks Steam once which manifests are current, and games with a newer version get an Update available badge. This needs the install records of the native engine, so older downloads show it after their first update or check
- Check compares every file with the installed version and downloads only what is damaged or missing, without updating anything. The log says at the end whether everything was fine or how much was repaired
- Resume, download again, open folder, edit emulator settings and remove, optionally with the files
In the terminal version the keys are p play, u update, v check, r resume, d download again, o open folder, e edit emulator and x remove. Headless, smd download --update <game folder> --repair runs the check.
Keyboard shortcuts and taskbar #
- Ctrl+OOpen a .lua or .st file in step 1
- Ctrl+FFocus the search: App ID in step 1, depots in step 2, the history when it is open
- Ctrl+HOpen or close the history
- Ctrl+,Open the settings
While a download runs, its progress shows on the taskbar button and in the window title.
03 File formats
two inputsSupported file formats #
SMD accepts two input files, .lua and .st. A third format, key.vdf, is not something you drop in: SMD reads it from a configured depot source during a search.
.lua files #
Lua script files are the most common format. They contain function calls that define app IDs, depot keys and manifest IDs. The parser recognises the following patterns:
-- Register an app ID (no depot key)
addappid(1995890)
-- Register a depot with a hex decryption key
addappid(1995891, 0, "a1b2c3d4e5f6...")
-- Set the manifest ID for a depot
setManifestid(1995891, "3438272076824159257")
addappid(depotId)registers a depot IDaddappid(depotId, 0, "hexKey")registers a depot with a decryption keysetManifestid(depotId, "manifestId")associates a manifest ID with a depotsetManifestid(depotId, "manifestId", sizeBytes)is the same as above plus an explicit install size hint. SMD picks up the size and shows it next to the depot in step 2 if no.jsonsidecar is present
-- 3-arg setManifestid carries the install size in bytes
setManifestid(1392863, "4398981003384795747", 13789896785)
.st files #
The .st format is a binary file format used by certain sources. SMD includes a dedicated binary parser that can read and extract depot IDs, manifest IDs and depot keys from these files.
Note
.st files are detected automatically by their binary signature. Drag and drop them like any other supported file.
key.vdf from a depot source #
Valve Data Format (VDF) files use a nested key and value structure. The key.vdf file that SMD fetches from a configured depot source holds depot keys in the following shape:
"depots"
{
"1995891"
{
"DecryptionKey" "a1b2c3d4e5f6..."
}
"1995892"
{
"DecryptionKey" "f6e5d4c3b2a1..."
}
}
The parser extracts each depot ID and its associated decryption key from the VDF structure.
Not an input format
A .vdf file cannot be dropped into the app. The file picker filters on .lua and .st only, and anything else is rejected with the message Please select a .lua or .st file. key.vdf reaches SMD only through a configured depot source.
04 Configuration
settingsSettings and configuration #
Open the settings modal via the gear icon in the header. All values are persisted to the app's settings file between sessions.
Emulator specific settings live in step 5, see Step 5: emulator, and are remembered in localStorage.
Top level settings #
- Language, the interface language. English and German are bundled, and the picker also runs on first launch. It covers the whole program, including the download log and the error messages
- Auto-update, toggles whether SMD checks GitHub for new releases on startup and offers an in-app update prompt
- Speed limit, off by default. Switch it on and enter a value in MB/s or Mbit/s, see Speed limit. It applies to the native engine and takes effect at once, also for a running download
- Depot selection, the switch for Like Steam mode with its options for DLC, platform, game language and starting right away. Off by default
- Steam folder, empty means SMD finds Steam itself. Set it when Steam is installed somewhere else, see Step 4
Advanced settings, collapsible #
Click Advanced settings to expand the section. It contains the following.
Download engine #
Download directly from Steam (native, recommended) is on by default: an anonymous Steam login fetches manifests and chunks from Steam's CDN in process, with ManifestHub only as a fallback. Turn it off to force the legacy DepotDownloaderMod path, which needs the .NET runtime on Windows. The .NET warning only appears when that engine is selected.
Max concurrent chunks sets how many chunks the native engine downloads and decrypts at once, 8 by default and 1 to 64. Lower it if downloads make the system lag.
Cancel behaviour #
Keep downloaded files when cancelling is off by default. Enable it and cancelling leaves the partial files on disk. The job appears in your history as Resumable, and resuming it continues from where it stopped, see Cancel a download.
DepotDownloader arguments, DepotDownloaderMod path only #
- Extra arguments, appended verbatim to the DepotDownloaderMod CLI. The internal default is
-max-downloads 8 -verify-all, and your input is added on top
Retries and proxy #
- Max retries on error, extra attempts per depot, 3 by default and 0 to 10. The native engine retries when the connection fails, DepotDownloaderMod when it exits with an error
- Proxy, used for every download: Steam's CDN, the depot sources, ManifestHub, Hubcap, Ryuu, game images and updates, and handed to DepotDownloaderMod. The format is
http://host:port,https://host:portorsocks5://host:port, withuser:password@in front of the host if needed. Empty means the system proxy is used. The anonymous Steam login for depot information connects directly - Test next to the field connects to Steam through the proxy you entered and shows how long Steam took to answer, or why it failed, for example a wrong port, a proxy that wants a password or an antivirus that intercepts HTTPS. With an empty field it tests the direct connection
Manifest sources #
The list of depot sources searched in step 2. Add a URL, with the format auto detected as a GitHub repo, an archive.org item or a plain HTTPS folder, and click Add. Remove one with its close button. Sources installed by the app are tracked separately, so removing a default source triggers a confirmation modal warning that Search by App ID will stop working. Adding the same URL again clears that warning.
API keys, optional #
- Hubcap API key, when set, Hubcap shows up as a selectable App ID manifest source whenever it has data for the app you searched
- Ryuu API key, the same for Ryuu
The ManifestHub key is separate and lives on the download page, see ManifestHub API key under Download page options below.
Notification sound #
Toggles a short notification sound when a download completes or fails. This is separate from the OS desktop notification itself.
Anonymous telemetry, opt in #
SMD can send anonymous usage counters, meaning which features get used, to the maintainer's server to help prioritise development. Events are end to end encrypted with an embedded public key, so only the maintainer's server can decrypt them. It is disabled by default, the choice is asked on first launch, and it can be changed here anytime. Never sent: game IDs, depot IDs, file contents, IP addresses, account info.
Download page options #
These options appear on the download page, step 3, just above the download button. The switch to shut down the PC afterwards sits on the download screen itself, see Shut down after the download.
Download location #
Where downloaded depot files are saved. The default is Documents/SteamDownloads inside your home folder. Each download creates a subdirectory named after the app ID and the game name, and the path is remembered between sessions. When you update a game from the history, the existing folder is used instead.
ManifestHub API key, optional #
If you have a ManifestHub API key, paste it here. With the native engine it acts as the last fallback, used only when neither Steam directly nor your configured depot sources can supply a manifest. It is also required if you enter a custom manifest ID by hand.
Emulator settings persistence #
The 21 emulator options in step 5, such as display name, language, offline mode and the overlay tweaks, are not stored in the global settings file. Instead they are saved to the browser's localStorage after each successful Apply and pre-filled the next time you reach step 5. Settings opened via history, in edit mode, read live from the game's steam_settings/ INI files instead.
05 Configuration
order decidesManifest sources #
SMD lets you plug in any number of depot sources under Settings, Advanced settings, Manifest sources.
Every search asks those sources in the order you set. The check for whether an App ID exists stops at the first source that answers, so the order you choose is the order that decides.
Supported source formats #
- GitHub repos, auto detected from
https://github.com/<owner>/<repo>URLs and fetched via the Contents API with abranches/<appid>/layout - archive.org items, detected from
archive.org/download/...orview_archive.php?file=...URLs. SMD treats the zip's basename as a path prefix automatically - Plain HTTPS folders, any base URL that serves
<appid>.lua,key.vdf,<appid>.jsonand<depot>_<manifest>.manifestfiles
What gets fetched #
For each app ID, SMD fetches and merges the following files from the source that answers:
<appid>.lua, depot IDs, manifest IDs, depot keys and optional install size hintskey.vdf, additional depot decryption keys<appid>.json, depot manifest metadata plus per manifest install and download sizes<depot>_<manifest>.manifest, the actual manifest payload, only downloaded for the depots you select
GitHub rate limit
The GitHub API has rate limits, and unauthenticated requests are capped at 60 per hour per IP. SMD does not ship a token field for this. If you hit the cap, wait an hour or add a different source, such as archive.org or a plain HTTPS folder, which has no such limit.
Depot metadata, the step 2 tags #
Independent of the manifest sources, SMD queries the public Steam PICS mirror at api.steamcmd.net/v1/info/<appid> to render the OS, arch and language tags shown next to each depot in step 2. Results are cached per app ID for 7 days in $APP_DATA/depot_info_cache/.
06 Terminal and Docker
one binaryTerminal version and Docker #
smd is a single binary that brings the whole app into the terminal, with no WebView and no installer. Run it without arguments for the interactive interface, or use its commands on a server, in Docker or in scripts.
Download and start #
The releases page has one file per system: Steam-Manifest-Downloader-Terminal_<version>_linux-x64 and Steam-Manifest-Downloader-Terminal_<version>_windows-x64.exe. On Arch, CachyOS and Manjaro, paru -S steam-manifest-downloader-terminal-bin installs it as smd, and updates come through the package manager.
chmod +x Steam-Manifest-Downloader-Terminal_*_linux-x64
./Steam-Manifest-Downloader-Terminal_*_linux-x64
With the default native engine it needs nothing else: no .NET runtime, and the Linux build is static, so it runs on any distribution including Alpine. Only the optional DepotDownloaderMod engine has the same requirements as the desktop app. By default the terminal version uses the same settings, history and caches as the desktop app.
Interactive interface #
All five steps of the desktop app, upload or search, depot selection, download, shortcuts and Steam library, and emulator patching, plus history and settings. Everything is clickable, buttons, tabs, list rows and checkboxes, a double click opens a list entry, and the mouse wheel scrolls. The keyboard works just as well:
- TabMove between fields, buttons and lists,
Shift+Tabbackwards - arrowsMove inside lists, between buttons elsewhere
- Enter, SpacePress the focused button, toggle a checkbox, pick a list entry
- EscClose a dialog or go back one step
- F2 F3 F4Download, History, Settings, and
F1for help - PgUp, PgDnScroll long pages and the output log
- a n / dDepot selection: all, none, filter, start download
- p cWhile downloading: pause or resume, cancel
- p r d u v o e xHistory: play, resume, download again, update, check, open folder, edit emulator, remove
- Ctrl+Q, F10Quit, with a question first while a download runs
The download screen has a button Shut down after: on, off for the same shutdown with countdown as the desktop app. Dragging a .lua or .st file onto the terminal window loads it right away, since most terminals paste the path. The interface uses true color where the terminal supports it, including the Windows console, falls back to the 16 terminal colors otherwise and respects NO_COLOR.
Headless commands #
smd search "Half-Life 2" # find the App ID
smd search 220 --manifests 0 # sources and depots for an App ID
smd download 220 --list # show what would be downloaded
smd download 220 --depots 221,222 -o /data/games
smd download game.lua --json # progress as JSON lines
smd history
Options of smd download, with the matching environment variable where there is one:
- -oDownload folder, also
SMD_OUTPUT_DIR. Defaults to the one from the settings - --data-dirSettings, history and caches, also
SMD_DATA_DIR. Defaults to the desktop app's directory - --mh-keyManifestHub API key, also
SMD_MANIFESTHUB_KEY - --depotsOnly these depots, comma separated. Without it, every depot in the file is downloaded, each into its own subfolder
- --like-steamWorks like Steam: picks the depots Steam would install for the base game (platform, 64-bit, language) and puts them into one game folder. Also on when "Like Steam" is enabled in the settings
- --all-depotsEvery depot into separate subfolders, even when "Like Steam" is enabled in the settings
- --dlcWith
--like-steam: also downloads the DLC in the file. The emulator step later marks them as owned for gbe_fork - --platformWith
--like-steam:windows,linuxormacos. In Docker the default is Linux, so use--platform windowsfor the Windows version - --languageWith
--like-steam: game language as Steam names it, for examplegermanorenglish. Defaults to the app language - --manifest
DEPOT=IDpins a depot to a specific manifest, repeatable - --update
<GAME_DIR>updates an existing download in place, see Update a downloaded game - --repairWith
--update: checks every file and repairs what is damaged or missing, without updating - --listShows the depots that would be downloaded and stops
- --ignore-spaceStarts even when the download does not fit on the disk. Without it,
smd downloadstops with an error in that case - --speed-limitCaps the speed, for example
10MB/sor100Mbit/s, alsoSMD_SPEED_LIMIT.0means unlimited, and the setting is the default - --shutdownShuts the computer down when the download has finished, after 60 seconds. Ctrl+C aborts, and nothing happens when the download is interrupted
- --jsonMachine readable output, only JSON lines on stdout
- -vBackend diagnostics on stderr instead of the log file
The terminal version uses the language from the settings, or the system language from LANG when none is set, for its output and for smd --help. Machine readable --json output is the same in every language.
Exit codes of smd download: 0 complete, 1 failed, 2 partially downloaded and resumable, 130 interrupted.
Docker #
Images are published to the GitHub Container Registry for every release and every dev build. They are built for Intel and AMD processors, linux/amd64, and run on Linux as well as on Windows and macOS with Docker Desktop. ARM devices such as a Raspberry Pi are not supported yet.
- latestLatest stable release, also tagged with its version, for example
1,1.5and1.5.0 - devLatest dev build from the
devbranch, also<version>-devanddev-<commit>
docker run --rm \
-v smd-data:/data \
-v "$PWD/games:/games" \
ghcr.io/mcbabel/steam-manifest-downloader download 220
- Downloads go to
/games, settings, history and caches to/data. Mount both so they survive the container - The container runs as user
smd, UID 1000. A host folder mounted as/gamesmust be writable for that UID, for example withsudo chown 1000:1000 games, or run with--user "$(id -u):$(id -g)"and mount host folders for both/dataand/games docker stopand Ctrl+C cancel the download cleanly with exit code130, the same way as the cancel button- Pass a ManifestHub key with
-e SMD_MANIFESTHUB_KEY=... - The interactive interface works in a container too: add
-itand leave out the command. Without-itthe image prints the help - The image uses the native engine. DepotDownloaderMod needs glibc and does not run in it
To build the image yourself from source, run docker build -t smd . in the repository.
07 Development
four stepsBuilding from source #
This guide covers how to compile Steam Manifest Downloader from source. The project uses Tauri v2 with a Rust backend and an embedded .NET tool, DepotDownloaderMod.
Prerequisites #
- Rust, latest stable, and Cargo. Install via rustup
- Tauri CLI, installed via Cargo
cargo install tauri-cli
- .NET 9.0 Desktop Runtime, required to run the embedded DepotDownloaderMod. Download the .NET 9.0 Desktop Runtime
Linux additional dependencies #
# Debian/Ubuntu
sudo apt install libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf gstreamer1.0-plugins-base gstreamer1.0-plugins-good
# Arch/CachyOS
sudo pacman -S webkit2gtk-4.1 libappindicator-gtk3 librsvg patchelf gst-plugins-base gst-plugins-good
Step 1: building DepotDownloaderMod, optional #
The project embeds DepotDownloaderMod binaries at compile time. Pre-built versions are already included in the repository, so this step is only needed if you want to build them yourself.
Note
Pre-built binaries are located in src-core/vendor/ddm-windows/, which is framework dependent and requires the .NET runtime, and src-core/vendor/ddm-linux/, which is self contained and needs no runtime. You can skip this step if you do not need to modify them.
Source: github.com/SteamAutoCracks/DepotDownloaderMod
Windows, framework dependent #
git clone https://github.com/SteamAutoCracks/DepotDownloaderMod.git
cd DepotDownloaderMod
dotnet publish -c Release -o ./publish-windows
Then copy all files from publish-windows/ to src-core/vendor/ddm-windows/ in the project:
DepotDownloaderMod.exeDepotDownloaderMod.dllDepotDownloaderMod.deps.jsonDepotDownloaderMod.runtimeconfig.jsonSteamKit2.dllprotobuf-net.Core.dllprotobuf-net.dllQRCoder.dllSystem.IO.Hashing.dllZstdSharp.dll
Linux, self contained, no trimming #
git clone https://github.com/SteamAutoCracks/DepotDownloaderMod.git
cd DepotDownloaderMod
dotnet publish -c Release -r linux-x64 --self-contained true \
-p:PublishSingleFile=true -o ./publish-linux
Important
Do not use -p:PublishTrimmed=true. .NET trimming removes reflection metadata needed by SteamKit2 and protobuf-net, which causes "A task was canceled" errors at runtime.
Then copy publish-linux/DepotDownloaderMod to src-core/vendor/ddm-linux/DepotDownloaderMod in the project.
Step 2: building the Tauri app #
Windows #
cargo tauri build
Output locations:
-
nsis
The installer lands in
src-tauri/target/release/bundle/nsis/ -
portable
The portable executable is
src-tauri/target/release/steam-manifest-downloader.exe
Linux, Arch, CachyOS and similar #
NO_STRIP=true APPIMAGE_EXTRACT_AND_RUN=1 cargo tauri build
Output: src-tauri/target/release/bundle/appimage/Steam Manifest Downloader_<version>_amd64.AppImage
Tip
NO_STRIP=true prevents stripping symbols from the embedded .NET binary. APPIMAGE_EXTRACT_AND_RUN=1 is needed on some distributions for the AppImage bundler to work correctly.
Step 3: building the terminal version, optional #
cargo build --release -p smd-tui
Output: target/release/smd, or smd.exe on Windows. For a fully static Linux binary, add --target x86_64-unknown-linux-musl, which needs musl-tools.
Step 4: project structure, for reference #
The shared logic lives in src-core, the desktop app in src-tauri with its interface in public, and the terminal version in src-tui.
The include_bytes! macro in src-core/src/services/embedded_tools.rs embeds the DDM binaries at compile time:
-
windows
The Windows build reads from
src-core/vendor/ddm-windows/ -
linux
The Linux build reads from
src-core/vendor/ddm-linux/
Careful
The DDM binary files must be in place before you run cargo tauri build or cargo build -p smd-tui. The Rust compiler reads them via include_bytes! at compile time, so if the files are missing, the build fails.
08 Help
thirteen answersTroubleshooting and FAQ #
Common issues and how to resolve them.
".NET not found" warning
The warning only appears when you switched to the DepotDownloaderMod engine, which needs the .NET 9.0 Desktop Runtime. Either switch back to the default native engine under Settings, Advanced settings, Download engine, which needs no runtime, or install it: .NET 9.0.16 Desktop Runtime, Windows x64. After installing, restart SMD and the warning disappears.
"Connection timeout" during download, or the PC lags while downloading
This usually happens when the number of parallel connections overwhelms your network or disk, or when Steam servers are under heavy load. Check whether a VPN or proxy is interfering, and use Test next to the proxy field to see whether Steam answers at all. Lower Max concurrent chunks under Settings, Advanced settings from 8 to 4, or set a speed limit, which also takes effect for a running download.
"No connection to Steam or any manifest source"
Nothing got through to Steam, so SMD stopped early. The message names the cause: a refused connection, a DNS problem, a timeout or a certificate error. A certificate error usually means an antivirus or a company proxy intercepts HTTPS. If your network only lets traffic through a proxy, enter it under Settings, Advanced settings, Proxy and press Test. A VPN or another DNS server can also help when your provider blocks Steam's servers.
"Steam not found" when adding a game to the library
Steam is installed somewhere SMD does not look. Click Choose Steam folder and pick the folder that contains steam.exe or steam.sh, or set it under Settings, Steam folder. If the folder is right but SMD says nobody is signed in, start Steam once and sign in.
Download stuck at 0%
First, check your internet connection. If your connection is fine, make sure your firewall or antivirus is not blocking SMD. If you use the DepotDownloaderMod engine, it also has to allow DepotDownloaderMod.exe, and the .NET 9.0 Desktop Runtime must be installed.
Linux: the AppImage will not launch
AppImages require FUSE to run. If FUSE is not available on your system, set the environment variable before launching:
APPIMAGE_EXTRACT_AND_RUN=1 ./Steam.Manifest.Downloader_*_amd64.AppImage
Also make sure the file is executable: chmod +x Steam.Manifest.Downloader_*_amd64.AppImage. On NixOS, start it with appimage-run.
No manifests found for my game
Not all games have manifests available in the searched sources. Make sure your .lua or .st file contains the correct depot and manifest IDs. You can also try adding a ManifestHub API key on the download page for access to additional sources.
The app crashes or shows a white screen
On Windows, make sure the Microsoft Edge WebView2 Runtime is installed. It is included with Windows 10 1803 and later and with Windows 11. On Linux, the AppImage brings its own WebKitGTK. With the AUR packages, make sure webkit2gtk-4.1 is up to date. If the window stays white on Wayland, try starting SMD with WEBKIT_DISABLE_DMABUF_RENDERER=1.
Step 5 says "Removing DRM" but Steamless fails on Linux
Steamless is a .NET Framework 4.5.2 tool, so on Linux it needs mono. Install it via your package manager: sudo pacman -S mono on Arch, or sudo apt install mono-runtime on Debian and Ubuntu. After that, retry the DRM removal. SMD passes MONO_PATH automatically so Steamless's plugin assemblies resolve.
The patched game still refuses to start, gbe_fork applied but the game checks the API DLL
Some games verify the size or hash of steam_api*.dll at runtime and reject the gbe_fork swap. Open step 5 again via history, choose Edit emulator settings, scroll up and enable the Steam API check bypass toggle, then click Save. This installs the version.dll, winmm.dll and winhttp.dll hijacks next to game.exe, plus a SteamAPICheckBypass.json that redirects integrity check reads to the original .steam.bak.
"Add to Steam" added the game but no banner or hero is showing
Steam only re-reads shortcuts.vdf and the grid/ folder on a full restart. Closing the window is not enough: right click the Steam tray icon, choose Exit, then start Steam again. If the game has no Linux build, also right click the new entry in Steam, open Properties, then Compatibility, then enable a Proton version.
"Steam is running" when adding a game to the library
Steam rewrites shortcuts.vdf when it exits, so an entry added while it runs would be lost. Close Steam completely and try again, or let SMD do it: it closes Steam, adds the entry and starts Steam again.
Windows: the emulator step cannot download gbe_fork or Steamless
On managed PCs, downloads from GitHub are often blocked. Use the standalone ZIP, which already contains gbe_fork, Steamless and the Steam API check bypass. Also download games into a folder you own, such as Documents or the Desktop, not into C:\Program Files. If Windows Defender reports the emulator files as a threat and deletes them, they can be restored under Windows Security, Virus and threat protection, Protection history, which can require admin rights.
Edit emulator settings says "Folder not found"
The game folder was moved or deleted after SMD recorded it in history. Restore the folder or remove the history entry, which leaves disk files untouched. For partial cleanups, the history modal's confirm dialogs make destructive actions explicit.
No depot tags, Windows, Linux or 64-bit, appear in step 2
The tags come from api.steamcmd.net. If that service is rate limited or down, the request fails silently and the tags do not appear, and the rest of the interface is unaffected. Results are cached for 7 days in $APP_DATA/depot_info_cache/, so once they appear they stick.
09 Legal
GPL-2.0Legal notice #
This tool does not support piracy. SMD is intended to be used only with legally obtained Steam depot keys and manifests that you have the right to access.
Intended use #
This application is designed as a convenience tool for managing Steam depot downloads. It is the user's responsibility to ensure they comply with all applicable laws and terms of service.
Terms of service #
- Only use with your own legally obtained Steam keys. Do not use this tool to download content you do not own or have a license to access.
- Comply with Steam's terms of service. Your use of this tool must not violate Valve's Steam Subscriber Agreement.
- Comply with all applicable laws. Downloading copyrighted content without authorization is illegal in most jurisdictions.
Disclaimer #
The developers of Steam Manifest Downloader are not responsible for any misuse of this tool. By using this application, you agree that you are solely responsible for ensuring your use complies with all applicable laws, regulations and terms of service.
This project is licensed under the GPL-2.0 license.
10 Download
1.5.0Version 1.5.0 is on the releases page. #
Windows installer and standalone ZIP, Linux AppImage, AUR packages for Arch, CachyOS and Manjaro, the terminal version and a Docker image. Source under GPL-2.0.