Getting Started

Steam Manifest Downloader (SMD) is a modern Tauri v2 desktop application built with Rust and WebView. It walks you through five steps:

1. Parse a .lua / .vdf / .st file or search by Steam App ID across all configured sources
2. Pick the depots you want, with platform / arch / language tags pulled live from Steam's PICS info
3. Download the selected manifests via the embedded DepotDownloaderMod engine
4. Optionally: create Desktop / Start-Menu shortcuts (Windows) or add the game to your Steam library with grid art (Linux + 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

System Requirements

• .NET 9.0 Desktop Runtime — Required by the embedded DepotDownloaderMod engine on Windows. Download .NET 9.0 Desktop Runtime
• Mono (Linux/macOS, optional) — Only needed if you want to use step 5's DRM removal feature, since Steamless is a .NET Framework tool: pacman -S mono / apt install mono-runtime / brew install mono
• Windows 10+ — Windows 10 version 1803 or later (with WebView2)
• Linux — Most modern distributions with GTK3 and WebKit2GTK (for AppImage: FUSE support or APPIMAGE_EXTRACT_AND_RUN=1)
• Internet connection — Required for searching and downloading manifests
• Disk space — ~20 MB for the app itself; additional space for downloaded depots

Installation

Windows (NSIS Installer)

1. Download the latest .exe installer from the Releases page
2. Run the installer and follow the setup wizard
3. Launch Steam Manifest Downloader from your Start Menu or Desktop

Linux (AppImage)

1. Download the latest .AppImage file from the Releases page
2. Make it executable:

chmod +x SteamManifestDownloader_*.AppImage
./SteamManifestDownloader_*.AppImage

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 UI is already auto-localised based on your OS / browser language (so a German system starts in German); if neither matches, English is used as the fallback. The picker just lets you override that. Saved immediately; you can change it later via Settings → Language (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; you can change your choice anytime under Settings → Advanced Settings

If you installed a build with the bundled archive.org sources (the default for GitHub / installer / AUR-source builds), two depot-source URLs are seeded automatically so search works out of the box. The Flatpak build does not seed them — 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
• Open Settings → Advanced Settings to tune retry count, speed limit, proxy, or to add/remove depot sources

Usage Guide

The pipeline has five steps. Steps 1–3 (upload, select, download) are always required; steps 4 (shortcuts & Steam library) and 5 (emulator patch) are optional and only appear when relevant for your platform / game.

Step 1: Upload a File

Start by providing a manifest data file. You can either:

• Drag & drop a .lua, .vdf, or .st file onto the upload area
• Click the upload area to open a file picker

The application will parse the file and extract all depot IDs, manifest IDs, app IDs, and depot keys contained within.

Step 2: Select Manifests

After parsing, the app displays a list of all discovered depots and their manifest IDs. From here you can:

• Select / deselect individual depots using the checkboxes
• Use Select All or Deselect All for bulk actions
• Search / filter depots by ID or name using the search bar
• View app details fetched from the Steam Store API (game name, icon, etc.)

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 / macOS
• Arch tag — 32-bit or 64-bit
• Language tag — only shown for language-specific depots (e.g. German, French)

The metadata is cached per app ID for 7 days in your app-data dir, so subsequent visits are instant. If api.steamcmd.net is unreachable the tags simply don't appear — the rest of the UI is unaffected.

Step 3: Download

Click the Download button to begin. Behind the scenes, the application performs several operations:

1. Manifest search — Queries ManifestHub API and multiple GitHub repositories to locate .manifest files for each selected depot
2. Manifest download — Downloads all found .manifest files to a local directory
3. Depot keys generation — Creates a steam.keys file containing all known depot decryption keys
4. DepotDownloaderMod execution — Launches the embedded DepotDownloaderMod binary with the correct arguments to download the actual depot files

You'll see real-time progress tracking with:

• A progress bar showing overall completion
• Download speed (MB/s)
• ETA estimates
• Per-depot status updates

When the download succeeds the app automatically progresses to step 4 (or step 5 on Linux without Steam installed). The history entry is only persisted once you reach "Go to Home" — closing the app mid-flow leaves no trace.

Step 4: Shortcuts & Steam Library (optional)

Step 4 has two platform-specific variants. SMD picks the right one automatically based on whether you're on Windows or Linux and whether Steam is detected.

Windows: Create Desktop / Start-Menu Shortcuts

The app scans the download folder for executables, scores them (size + name match against the folder hint + blacklist of installers / 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 (see next section)

Shortcuts are created via PowerShell using the WScript.Shell COM object, with user-derived values passed through environment variables (no string interpolation, no script injection).

Linux: Add to Steam Library

The app detects your Steam installation (~/.steam/steam/, ~/.local/share/Steam/ or the Flatpak path) and the active user (via loginusers.vdf's MostRecent=1 flag). When you click Add to Steam it will:

1. Download 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 correct naming Steam expects (<shortcutid>.jpg, <shortcutid>p.jpg, <shortcutid>_hero.jpg, <shortcutid>_logo.png, <shortcutid>_icon.jpg)
3. Parse the existing binary shortcuts.vdf file (with backup), append a new shortcut entry, and write it back
4. Generate the shortcut AppID as CRC32(exe_path + app_name) | 0x80000000 — Steam-compatible and deterministic

The Linux step also supports launch options (e.g. %command%) and a display name field. After adding, restart Steam fully (right-click tray → Exit) for the new entry to appear. For Windows games on Linux: right-click the new entry in Steam → Properties → Compatibility → enable Proton.

Footer buttons are minimal: Skip (proceed without adding) and Add to Steam (which 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 — no manual setup. It only appears when the app finds steam_api*.dll (Windows) or libsteam_api.so (Linux) in the download folder.

Variant Picker

Two gbe_fork variants are offered side-by-side:

• Regular — 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, extracted into the app-data cache ($APP_DATA/gbe_fork_cache/<release-tag>/) and copied over the game's steam_api*.dll. 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 — no external generate_interfaces.exe required.

DRM Detection & 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 — 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
• On Windows: runs Steamless.CLI.exe directly
• On Linux: runs it via mono (install via pacman -S mono / apt install mono-runtime / brew install mono); MONO_PATH is set to the Plugins/ dir so plugin assemblies resolve correctly
• Replaces the original .exe with the unpacked version, keeps the original as .exe.drm.bak

The full Steamless log is shown inline if anything fails, with a one-click copy button.

Steam API Check Bypass (optional toggle)

Some games perform additional integrity / size checks on steam_api*.dll at runtime — those reject the gbe_fork swap even when it loaded. Enabling the bypass toggle installs Steam-API-Check-Bypass alongside gbe_fork:

• The matching arch DLL (x64 for steam_api64.dll, 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; 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 / 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).

21 Emulator Settings (Accordion)

Below the variant picker is a collapsible accordion with 5 sections of user-tunable gbe_fork options. Only fields you actually fill in are written to disk — 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 & Compatibility — offline mode, Steam Deck mode, disable networking, disable LAN-only
• Stats & Achievements — record playtime, achievements bypass, force SteamHTTP success, Steam pre-owned IDs, free-weekend flag
• Overlay — enable experimental overlay, hide popups, always show FPS / playtime, hotkey, font size

Settings are written as INI files (configs.user.ini, configs.main.ini, 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.

History Actions (per game)

After applying, the game appears in your Download History (via Go to Home) with two extra action buttons:

• Edit emulator settings (⚙) — re-opens step 5 in edit mode: variant picker 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
• Launch lobby_connect (▶) — spawns the gbe_fork lobby_connect binary in the game folder with SteamAppId env var set; useful for testing local-multiplayer connectivity without launching the game itself

If you delete the game folder externally, the Edit / Launch actions show 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 canceled:

• The DepotDownloaderMod process is terminated immediately
• Partially downloaded files are deleted to avoid incomplete or corrupted data
• The UI returns to the selection screen so you can start a new download

Supported File Formats

SMD can parse three different file formats to extract depot and manifest information.

.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 recognizes 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 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) — 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

-- 3-arg setManifestid carries the install size in bytes
setManifestid(1392863, "4398981003384795747", 13789896785)

.vdf / Key.vdf Files

Valve Data Format (VDF) files use a nested key-value structure. The Key.vdf file typically contains depot keys in the following format:

"depots"
{
    "1995891"
    {
        "DecryptionKey"    "a1b2c3d4e5f6..."
    }
    "1995892"
    {
        "DecryptionKey"    "f6e5d4c3b2a1..."
    }
}

The parser extracts each depot ID and its associated decryption key from the VDF structure.

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

Settings & 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 — UI language. English and German are bundled; the picker also runs on first launch
• Auto-Update — toggle whether SMD checks GitHub for new releases on startup and offers an in-app update prompt

Advanced Settings (collapsible)

Click "Advanced Settings" to expand the section. It contains:

DepotDownloader Arguments

• Extra Arguments — appended verbatim to the DepotDownloaderMod CLI. Internal default is -max-downloads 8 -verify-all; your input is added on top
• Max Retries on Error — how often a failed depot is retried before SMD gives up
• Download Speed Limit (MB/s) — optional global cap
• HTTP Proxy — proxy URL forwarded to DepotDownloaderMod for environments that require one

Manifest Sources

The list of depot sources searched in step 2. Add a URL (auto-detected formats: GitHub repo, archive.org, plain HTTPS folder) and click Add; remove by clicking the ✕. Sources installed by the app are tracked separately — 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.

Notification Sound

Toggles a short system notification sound when a download completes (separate from the OS desktop notification itself).

Anonymous Telemetry (opt-in)

SMD can send anonymous usage counters (which features get used) to the maintainer's server to help prioritise development. Events are end-to-end encrypted with an embedded public key — only the maintainer's server can decrypt. Disabled by default; the choice is asked on first launch and 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.

Download Location

Where downloaded depot files are saved. Default: Documents/SteamDownloads inside your home folder. Each download creates a subdirectory named after the app ID. The path is remembered between sessions.

ManifestHub API Key (optional)

If you have a ManifestHub API key, paste it here to query that database as an additional source.

Emulator Settings Persistence

The 21 emulator options in step 5 (display name, language, offline mode, overlay tweaks, etc.) are not stored in the global settings file. Instead they're saved to the browser's localStorage after each successful Apply and pre-filled the next time you reach step 5. Settings opened via History (Edit mode) read live from the game's steam_settings/ INI files instead.

Manifest Sources

SMD lets you plug in any number of depot sources via Settings → Advanced Settings → Manifest Sources. Every search hits all configured sources in parallel and merges their results — if source A has depots 1–10 and source B has 5–15, you see the union (1–15) with keys / sizes / manifest IDs deduplicated.

Supported Source Formats

• GitHub repos — auto-detected from https://github.com/<owner>/<repo> URLs; 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 (from each source that has them) and merges:

• <appid>.lua — depot IDs, manifest IDs, depot keys and optional install-size hints
• key.vdf — additional depot decryption keys
• <appid>.json — depot manifest metadata + per-manifest install / download sizes
• <depot>_<manifest>.manifest — the actual manifest payload, only downloaded for the depots you select

Depot Metadata (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 / 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/.

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

• Rust (latest stable) + Cargo — Install via rustup
• Tauri CLI — Install via Cargo:

cargo install tauri-cli

• .NET 9.0 Desktop Runtime — Required to run the embedded DepotDownloaderMod. Download .NET 9.0 Desktop Runtime

Linux Additional Dependencies

# Debian/Ubuntu
sudo apt install libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf

# Arch/CachyOS
sudo pacman -S webkit2gtk-4.1 libappindicator-gtk3 librsvg patchelf

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.

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 DepotDownloaderMod-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)

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

Then copy publish-linux/DepotDownloaderMod to DepotDownloaderMod-linux-full/DepotDownloaderMod in the project.

Step 2: Building the Tauri App

Windows

cargo tauri build

Output locations:

• NSIS installer: src-tauri/target/release/bundle/nsis/
• Portable executable: src-tauri/target/release/steam-manifest-downloader.exe

Linux (Arch/CachyOS/etc.)

NO_STRIP=true APPIMAGE_EXTRACT_AND_RUN=1 cargo tauri build

Output: src-tauri/target/release/bundle/appimage/Steam Manifest Downloader_<version>_amd64.AppImage

Step 3: Project Structure (for reference)

The include_bytes! macro in src-tauri/src/services/embedded_tools.rs embeds the DDM binaries at compile time:

• Windows build reads from DepotDownloaderMod-Windows/
• Linux build reads from DepotDownloaderMod-linux-full/

Troubleshooting / FAQ

Common issues and how to resolve them.

Legal Notice

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.