SMD 1.5.0 Source

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.

  • Windows 10, 11 and Linux
  • Rust and Tauri v2
  • GPL-2.0
  • Nine sections

01 Reference

01 Getting started

three parts

Getting 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:

  1. Parse a .lua or .st file, or search by Steam App ID across your configured sources
  2. Pick the depots you want, with platform, architecture and language tags pulled live from Steam's PICS info
  3. Download the selected depots with the native Rust engine, straight from Steam's CDN
  4. Optionally create desktop and start menu shortcuts (Windows), or add the game to your Steam library with grid art (Linux and Windows)
  5. 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 mono or apt 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 #

  1. Download Steam.Manifest.Downloader_<version>_x64-setup.exe from the releases page
  2. Run the installer and follow the setup wizard. It installs per user and does not ask for admin rights
  3. 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 #

  1. Download Steam-Manifest-Downloader_<version>_windows-standalone.zip from the releases page
  2. 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 to C:\Program Files
  3. Start Steam Manifest Downloader.exe from that folder, and keep the third-party folder 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:

bash

# 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.

  1. Download the latest .AppImage file from the releases page
  2. Make it executable, then run it

bash

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:

  1. 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.
  2. 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 steps

Usage 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 .lua or .st file 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 German or French

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:

  1. Steam session. Signs in to Steam anonymously and pulls app and depot metadata via PICS
  2. 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
  3. Manifest decode. Unwraps the ZIP container, decrypts with AES-256 and parses the protobuf payload, encrypted filenames included
  4. Depot keys generation. Creates a steam.keys file containing all known depot decryption keys
  5. 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 .exe if 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:

  1. Download the banner, hero, logo and icon images from the Steam CDN, using the icon hash from api.steamcmd.net
  2. Save them into ~/.steam/steam/userdata/<user>/config/grid/ with the naming Steam expects: <shortcutid>.jpg, <shortcutid>p.jpg, <shortcutid>_hero.jpg, <shortcutid>_logo.png and <shortcutid>_icon.jpg
  3. Parse the existing binary shortcuts.vdf file, with a backup, append a new shortcut entry, and write it back
  4. 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.exe directly
  • On Linux: runs it via mono, installed with pacman -S mono or apt install mono-runtime, and MONO_PATH is set to the Plugins/ directory so plugin assemblies resolve correctly
  • Replaces the original .exe with 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.dll and x32 for steam_api.dll, is copied next to game.exe under three hijack names: version.dll, winmm.dll and winhttp.dll. Whichever the game imports gets loaded, and the others sit harmless
  • A SteamAPICheckBypass.json file is written next to game.exe with a file_redirect rule that points the first 3 CreateFile reads of steam_api*.dll to the .steam.bak file gbe_fork created, so integrity checks see the original bytes while the game uses the emulator
  • Any pre-existing version.dll, winmm.dll or winhttp.dll is backed up as <name>.bypass.bak and 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>.json into 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 inputs

Supported 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:

lua

-- 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 ID
  • addappid(depotId, 0, "hexKey") registers a depot with a decryption key
  • setManifestid(depotId, "manifestId") associates a manifest ID with a depot
  • setManifestid(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 .json sidecar is present

lua, 3-arg variant with size

-- 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:

vdf

"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

settings

Settings 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:port or socks5://host:port, with user: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 decides

Manifest 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 a branches/<appid>/ layout
  • archive.org items, detected from archive.org/download/... or view_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>.json and <depot>_<manifest>.manifest files

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 hints
  • key.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 binary

Terminal 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.

bash

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+Tab backwards
  • 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 F1 for 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 #

bash

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, linux or macos. In Docker the default is Linux, so use --platform windows for the Windows version
  • --languageWith --like-steam: game language as Steam names it, for example german or english. Defaults to the app language
  • --manifestDEPOT=ID pins 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 download stops with an error in that case
  • --speed-limitCaps the speed, for example 10MB/s or 100Mbit/s, also SMD_SPEED_LIMIT. 0 means 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.5 and 1.5.0
  • devLatest dev build from the dev branch, also <version>-dev and dev-<commit>

bash

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 /games must be writable for that UID, for example with sudo chown 1000:1000 games, or run with --user "$(id -u):$(id -g)" and mount host folders for both /data and /games
  • docker stop and Ctrl+C cancel the download cleanly with exit code 130, 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 -it and leave out the command. Without -it the 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 steps

Building 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 #

bash

cargo install tauri-cli

Linux additional dependencies #

bash

# 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 #

bash

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.exe
  • DepotDownloaderMod.dll
  • DepotDownloaderMod.deps.json
  • DepotDownloaderMod.runtimeconfig.json
  • SteamKit2.dll
  • protobuf-net.Core.dll
  • protobuf-net.dll
  • QRCoder.dll
  • System.IO.Hashing.dll
  • ZstdSharp.dll

Linux, self contained, no trimming #

bash

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 #

bash

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 #

bash

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 #

bash

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 answers

Troubleshooting 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.

10 Download

1.5.0

Version 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.

Colophon