How to Upload a Game to Steam Store

Beneath is a guide to using SteamPipe, Valve's tool for delivering content to Steam. For more information on best practices for updating your game, see Updating Your Game - All-time Practices.

Introduction to the SteamPipe Content Organisation

SteamPipe is the game/application content organisation that powers Steam. SteamPipe includes the following features:

• Efficient and fast content delivery.
  
• Public and private "beta" branches, allowing multiple builds to be tested.
  
• Uncomplicated web-based management of builds - push out a new build or rollback to a previous build with just a few clicks.
  
• Power to see the update size of a build before setting information technology alive.
  
• Power to share content between multiple applications.
  
• Power to build installer discs from public or beta content.
  
• Games/apps stay bachelor offline even after an update download has been started.
  
• All content is always encrypted, and not-active versions are non visible to customers.
  
• A SteamPipe Local Content Server which tin can be used during development.

NOTE: There are a few concepts which are integral to SteamPipe, before getting started yous should exist familiar with all of the concepts outlined in the Applications documentation. Having fifty-fifty a bones understanding of how these pieces fit together will exist very useful when uploading your production to Steam.

Steamworks Video Tutorial - Edifice Your Game in Steampipe

This tutorial introduces SteamPipe and steps through building a sample application for Steam via the Steamworks tools.
https://world wide web.youtube.com/sentinel?5=SoNH-v6aU9Q

Steamworks Video Tutorial - Adding New Platforms and Languages

This tutorial walks you through adding new platforms and languages to your game past adding depots to your app.
https://www.youtube.com/watch?five=PShS32hcing

SteamPipe Technical Details

SteamPipe uses the HTTP protocol for content delivery. Since downloads are regular spider web traffic, any third-political party HTTP cache between the customer and Steam servers will increase download speed. Content tin can be hosted past external CDN providers, which tin exist easily added to our content network. Near consumer firewalls let HTTP traffic and won't block downloads.

SteamPipe has an efficient patching algorithm based on binary deltas, merely changing the modified portions of existing content files. When this content is updated, only these deltas need be sent. This means both developer and user transfers are smaller and faster. Near partners will detect that using a SteamPipe Local Content Server non necessary since they tin can efficiently patch builds on private branches.

Steam Build Account

Before yous can create any builds on Steam, you must accept a Steam account in your Steamworks account with the "Edit App Metadata" and "Publish App Changes To Steam" permissions granted. For security reasons information technology's recommended that you take a dedicated build account with just those permissions, y'all may create a new Steam account for this purpose at https://shop.steampowered.com/join.

Any administrator of your Steamworks account can add a Steam account and grant the necessary permissions. More than information on this process can be establish in the Managing Your Steamworks Account documentation. An instance of what this business relationship might expect like is:

Initial Setup for New SteamPipe Apps

Follow these steps to set up new SteamPipe apps:

1. Observe the app ID for your awarding (this can be found past selecting the awarding on your homepage in Steamworks)
   
2. Become to the Full general Installation Settings page for your app.
   
3. Ascertain at least 1 launch option (the path and optionally, any arguments required to launch the game). Hover over the (?) to larn more about each field.

   The example beneath shows 5 launch options, 2 for Windows, two for macOS and one for Linux.
   Launch option 3 will only exist shown on Windows if the user also owns the DLC specified.

   

4. Become to the Depots page and add depots as needed for this app. Past default, a depot may already be configured for your application.
   
   1. Click the default depot and change the proper name of the depot to a proper and recognizable proper noun (such as "Base Content" or "Windows Content").
      
   2. Leave the language gear up to [All languages] unless this is a linguistic communication-specific depot.
      
   3. Leave the OS set up to [All OSes] unless this is an Bone-specific depot (if the app is all-in-one, or is just PC or just Mac, it should be left to [All OSes]. Only specify for Bone-specific game depots.
      
   4. Click Add New Depot to create additional depots.
      
   5. Click Save Changes to save whatever changes made.
      
5. Once y'all are washed defining your depots, publish the changes that you lot have made from the Publish page.
   
6. Your newly divers depots volition demand to be included in a package to grant you lot ownership of them. Each game on Steam should accept a Developer Comp bundle which is automatically granted to the accounts listed inside your publisher grouping.
   Y'all tin can add the new depots to that package (and/or other packages that should take these depots) on the Associated Packages & DLC page.

Notation: If your executable is in a sub-folder of the main installation folder, add the sub-folder proper noun in the Executable field. Don't employ leading slashes or dots.

Platform Note: As shown higher up, macOS applications may exist launched by specifying either an app bundle (Game.app) or a script/binary (Game.app/Contents/MacOS/Game). In general the app bundle format should exist preferred if possible as it allows macOS to more correctly make up one's mind launch parameters in the mode it would if launched manually outside of Steam.

One instance of this to note is that currently applications that are launched through an app bundle on Apple Silicon devices will launch the all-time compages available in the application whereas direct binary launches will use the same architecture as the Steam process (currently x86_64).

Setting up the SDK for SteamPipe uploads

Download and unzip the latest version of the Steamworks SDK on the auto you will be uploading builds on.

The SteamPipe tools tin can be plant inside the SDK in the tools binder which contains ii relevant sub-directories.

The ContentBuilder directory is where your game content and SteamPipe build tools will live. This directory contains the post-obit sub-directories:

• architect - This directory initially contains just steamcmd.exe which is the command line version of Steam.
  
• builder_linux - The linux version of steamcmd.
  
• builder_osx - The macOS version of steamcmd.
  
• content - This directory contains all game files that volition be built into depots.
  
• output - This directory will be the location for build logs, clamper cache, and intermediate output. NOTE: This binder can be deleted or emptied at any time, but afterwards it's deleted, the next upload time volition take longer.
  
• scripts - This directory is where you'll identify all of your build scripts for building your game depots.

It's recommended that you run steamcmd.exe directly in the architect folder for your platform once to bootstrap your build system. This should populate your architect directory with all the files it needs to build depots.

The ContentServer directory contains the tools for running your own SteamPipe Local Content Server if you choose to do so.

SteamCmd on macOS

To enable SteamCmd on macOS you must complete the following steps:

1. From the terminal, browse to the tools\ContentBuilder\builder_osx\osx32 binder
   
2. Run chmod +x steamcmd
   
3. Browse upwards to the parent folder (tools\ContentBuilder\builder_osx)
   
4. Type bash ./steamcmd.sh
   
5. SteamCmd volition then run and update to the latest build, leaving you in the SteamCmd prompt
   
6. Type exit and press return to exit the prompt

You can then follow the rest of this documentation (substituting paths as appropriate) to create depot and app config files for uploading your content to Steam.

Creating SteamPipe Build Config Files

To upload files for your app with SteamPipe, yous must create scripts which describe your build and each depot that will be included in it. The example scripts shown hither are in the Tools\ContentBuilder\scripts folder in the Steamworks SDK.

SteamPipe GUI Tool

If you lot're running on Windows and would adopt a GUI tool to assistance create these config files and upload your builds you can use the SteamPipeGUI which is available in the tools folder of the Steamworks SDK. Included in the nada are additional instructions to get you started.

If you choose to use the GUI tool and then reading the following sections is still recommended to assist you become more than familiar with how the SteamPipe arrangement works.

Elementary Build Script

Let's start with the almost basic build script possible. In our example we have a game (AppID 1000) that has ane depot (DepotID 1001) and desire to upload all files from a content binder and it's subfolders. We just need a single build script for that, take a look at "simple_app_build.vdf" included in the SDK :

"AppBuild" { "AppID" "1000" // your AppID "Desc" "This is a simple build script" // internal description for this build "ContentRoot" "..\content\" // root content folder, relative to location of this file "BuildOutput" "..\output\" // build output binder for build logs and build enshroud files "Depots" { "1001" // your DepotID { "FileMapping" { "LocalPath" "*" // all files from contentroot folder "DepotPath" "." // mapped into the root of the depot "recursive" "ane" // include all subfolders } } } }

Conform the AppID and DepotID for your game as needed. To kick off a build you need to run steamcmd and laissez passer a couple of parameters :

tools\ContentBuilder\builder\steamcmd.exe +login <account_name> <password> +run_app_build ..\scripts\simple_app_build.vdf +quit

Annotation: Your beginning attempt at running a build may neglect due to Steam Baby-sit. If the login fails due to Steam Baby-sit, check your email for the Steam Baby-sit code, and run steamcmd equally: steamcmd.exe "set_steam_guard_code <code>", and attempt again. Subsequently logging in with Steam Guard one time, a sentry file is used to verify the login is 18-carat.

If you are using steamcmd from a machine or VM that gets re-imaged frequently, you should include the lookout man and config file in your image so you won't exist prompted for a Steam Baby-sit every time. The sentry file is located in <Steam>\ssfn<hashOfNumbers>, and the config file is located in <Steam>\config\config.vdf.

The following steps occur during a SteamPipe build:

1. Steamcmd.exe will update itself to the latest version.
   
2. Steamcmd.exe is logging into the Steam backend using the given builder Steam account.
   
3. The app build offset is registered with the MDS (Master Depot Server), which will ensure the user has the proper privileges to modify this app.
   
4. For each depot included in the app build, a file list is generated based on the files in the content folder and the filter rules divers in depot build config file.
   
5. Each file is scanned and divided into small chunks of nearly 1MB. If the depot has been congenital before, this segmentation will preserve as many of the unchanged chunks as possible.
   
6. New file chunks are compressed, encrypted, and then uploaded to the MDS.
   
7. A final manifest is generated for this depot version; each manifest is identified past a unique 64-chip manifest ID.
   
8. Once all depots take been processed, the MDS finishes this app build and assigns it a global BuildID.
   
9. After the build is washed, there may exist *.csm and *.csd files in the build ouput folder. These are temporary and can be deleted, but they speed up subsequent build times.

Once the build is complete you lot tin can come across information technology on your app builds page, in this case it would be https://partner.steamgames.com/apps/builds/1000. At that place y'all can ready that build live for the default branch or whatever beta branch and users will be able to download this update with a couple of minutes.

Advanced Build Scripts

If your app has a lot of depots with circuitous file mapping rules, you can create a depot build script for each depot which will be referenced by the app build script. Get-go let'southward take a expect at available parameters in the app build script:

• AppID - The AppID of your game. The uploading Steam partner account needs 'Edit App Metadata' privileges
  
• Desc - The description is merely visible to yous in the 'Your Builds' section of the App Admin panel. This can be changed at any fourth dimension subsequently uploading a build on the 'Your Builds' page.
  
• ContentRoot - The root binder of your game files, tin be an absolute path or relative to the build script file.
  
• BuildOutput - This directory will exist the location for build logs, depot manifests, chunk caches, and intermediate output. For best performance, use a dissever disk for your build output. This splits the disk IO workload, letting your content root disk handle the read requests and your output disk handle the write requests.
  
• Preview - This type of build only outputs logs and a file manifest into the build output folder. Building preview builds is a good mode to iterate on your upload scripts and make sure your file mappings, filters and properties work as intended.
  
• Local - Set this to the htdocs path of your SteamPipe Local Content Server (LCS). LCS builds put content only on your own HTTP server and allow you lot to test the installation of your game using the Steam client.
  
• SetLive - Beta branch name to automatically set up live after successful build, none if empty. Annotation that the 'default' co-operative tin not be set alive automatically. That must be washed through the App Admin console.
  
• Depots - This section contains all file mappings, filters and file properties for each depot or references a separate script file for each depot

Instance app build script "app_build_1000.vdf" is using all options:

"AppBuild" { "AppID" "1000" // Your AppID "Desc" "Your build clarification here" // internal description for this build "Preview" "one" // make this a preview build simply, nothing is uploaded "Local" "..\..\ContentServer\htdocs" // put content on local content server instead of uploading to Steam "SetLive" "AlphaTest" // gear up this build live on a beta branch "ContentRoot" "..\content\" // content root binder relative to this script file "BuildOutput" "D:\build_output\" // put build cache and log files on unlike drive for better performance "Depots" { // file mapping instructions for each depot are in carve up script files "1001" "depot_build_1001.vdf" "1002" "depot_build_1002.vdf" } }

This app build script references ii depot build script files that specify all file mappings and file properties. The post-obit instructions are available in a depot build script ( and also if the section is included directly into the app build script).

• DepotID - The DepotID for this department
  
• ContentRoot - Lets you lot optionally override the ContentRoot folder from the app build script on a per depot ground
  
• FileMapping - This maps a unmarried file or a set up of files from the local content root into your depot. At that place can exist multiple file mappings that add files to the depot. The LocalPath parameter is a relative path to the content root folder and may contain wildcards similar '?' or '*'. It will too apply to matching files in subfolders if Recursive is enabled. The DepotPath parameter specifies where the selected files should appear in the depot (employ simply '.' for no special mapping)
  
• FileExclusion - volition excluded mapped files again and tin can also incorporate wildcards like '?' or '*'
  
• InstallScript - will mark a file every bit install scripts and will sign the file during the build procedure. The Steam client knows to run them for any application which mounts this depot.
  
• FileProperties - volition mark a file with special flags:
  
  • userconfig - This file is modified past the user or game. It cannot be overridden by an update, and it won't trigger a verification error if it's different from the previous version of the file.
    
  • versionedconfig - Similar to userconfig, however if the file is updated in the depot, information technology volition be overwritten locally when the user's game updates. But update the file in the depot when there is a necessary format change or bug ready.

Example depot build script depot_build_1002.vdf showing use of all options:

"DepotBuild" { "DepotID" "1002" "ContentRoot" "C:\content\depot1002" // override ContentRoot from app build script "FileMapping" { // all source files and folders in ".\bin" will be mapped into folder ".\executables" in depot "LocalPath" "bin\*" "DepotPath" "executables\" "Recursive" "1" // include all subfolders } "FileMapping" { // override audio files in \\audio with German versions "LocalPath" "localization\german\sound\*" "DepotPath" "audio\" } "FileMapping" { // copy install script for german version into depot root folder "LocalPath" "localization\german\german_installscript.vdf" "DepotPath" "." } "FileExclusion" "bin\server.exe" // exclude this file "FileExclusion" "*.pdb" // exclude all .PDB files everywhere "FileExclusion" "bin\tools*" // exclude all files under bin\tools\ "InstallScript" "localization\german\german_installscript.vdf" "FileProperties" { "LocalPath" "bin\setup.cfg" "Attributes" "userconfig" // this file volition be modified during runtime } }

NOTE: You can proper name these scripts what always you want, but we employ the names app_build_<AppID> and depot_build_<DepotID> for consistency. If you know that you'll be building apps on this machine, information technology might be a practiced idea to create sub-directories in your scripts directory for each application, to help organize each application'due south build scripts.

Managing Updates

After your app releases to customers, your customers will exist receiving the build marked as the Default build. When uploading a new build it'south e'er a skilful idea to test it before shipping information technology to your customers, for more information on how to successfully do this see Testing On Steam.

Debugging Build Issues

If your build wasn't successful, you should expect in your output directory for mistake data, not the console where the build script was run. Most error information can exist found in the *.log files.
Yous tin use these Steam customer commands and client-side files to debug issues:

• "app_status [appid]" - Shows the current state of the app on this client.
  
• "app_info_print [appid]" - Shows the current Steamworks configuration for this game (depots, launch options, etc.).
  
• "app_config_print [appid]" - Shows the electric current user configuration for this game (current language, install directory, etc.).
  
• file "logs\content_log.txt" - Lists all logged SteamPipe operations and errors.
  
• file "steamapps\appmanifest_[appid].acf" - Shows the current install land of this app (KeyValues).

Building Efficient Depots for SteamPipe

The sometime Steam content system would patch updates on a file level, which meant that if a single byte in a file changed, the entire new file would exist downloaded past all users. This was especially inefficient if the game used pack files, which are collections of game content files in a single big file. Pack files can easily exceed i GB, so updates oftentimes led to unnecessarily big downloads. A mutual mode to avoid these large downloads was to add new pack files that overrode content of already shipped pack files. That worked for updates, but it hurt new users long-term, since they ended up downloading unused, already-patched content.

The new content organization fixes this problem past splitting each file into roughly 1-MB chunks. Each chunk is and so compressed and encrypted before being distributed by the Steam content system. If the game content has large redundant parts, these chunks are reused and the user only has to download each repeated chunk once. However, the real forcefulness of this system is building efficient update patches. While the system is building a patch, the new content is scanned for already known chunks. If it finds them, information technology reuses them. This means if you change or inject a few bytes in a large file, the user but has to download the changes.

This works well in most cases, simply there are still a few pitfalls that demand to be avoided when designing the content layout of a game. You may not want to compress or encrypt your game information. This is already done for in-flying downloads and retail discs by the Steam content system. If you practise it besides, it can reduce the effectiveness of delta patching. Pinch and encryption are just advised if each individual nugget within a bundle file is separately compressed and/or encrypted. Otherwise, a change to one asset will always require downloading several other potentially unchanged avails.

If y'all package multiple avails in a single pack file, make sure that with each re-packaging, no unnecessary changes are made. One problematic practise is including the total name of the original source files on deejay, because the names may change, depending on the build machine. Another bad pattern is including build time stamps for each file. If possible, always add new content to the end of your pack files and keep the order of existing files. Also, keep your pack file's metadata (offset and sizes to private assets) in ane place and don't intersperse information technology with the nugget data. Use a binary departure tool similar BeyondCompare to expect at two builds of your pack files to make sure that hundreds of unwanted changes don't prove up.

If yous follow these rules you will minimize patch sizes and only new content will demand to exist downloaded. Your customers volition cheers for that and yous will be able to increase the quality of your product by shipping more than updates.

If you suspect that your game packaging is not interacting well with the SteamPipe update process, please contact your Valve representative and nosotros tin can await into enabling advanced features to assistance with this.

Edifice Retail Install Discs

To build retail install disc for SteamPipe games, you lot must get-go setup a build project file.
In this example, the SKU file is chosen "sku_goldmaster.txt":

"sku" { "name" "Test Game Installer" "appid" "202930" "disk_size_mb" "640" "included_depots" { "1" "202931" "2" "202932" } }

Some tips to keep in mind:

• Create a new folder where the retail disc images volition exist written to, e.g., "D:\retail_disks". Just depots in the included_depots sections are added; there is no exclude section anymore.
  
• Y'all tin can use Steam.exe (with the -dev and -console command-line parameters) or steamcmd.exe to build installer images. In both cases, apply the "build_installer" command.
  
• Log on with a Steam account that owns the game and all depots you want to put on the retail disc. Otherwise, the account doesn't need special rights, so anyone tin build installer discs.
  
• If yous use Steam.exe, terminate all other downloads.
  
• Go to the console page and run the build_installer control:

  build_installer sku_goldmaster.txt "D:\retail_disks"

  The build can take a while since all depots are re-downloaded the first time.
  
• If y'all're edifice a GM using a local content server, run:
  @localcontentserver "webserver"
build_installer sku_goldmaster.txt "D:\retail_disks" local
  The spew refers to 'Backup' since 'Retail install Disk' and local game backups are basically the aforementioned.
  
• In one case you see "Backup finished for AppID...", the install disk images are fix. You tin observe more details about the backup build in logs\backup_log.txt.
  
• There are new folders (Disk_1, Disk_2, and and then on) in "D:\retail_disks", each not bigger than 640 MB, equally specified with "disk_size_mb". Each disk folder contains a "sku.sis" file and a .csd and .csm for each depot. Bigger depots span across multiple disks. All retail install disk content is always encrypted (unlike local game fill-in files). Copy the SDK GM setup files (setup.exe, setup.ini, etc.) into the folder of your first disk and the retail disc installer is complete.
  
• When creating a GM for macOS be sure to open the goldmaster/disk_assets/SteamRetailInstaller.dmg image on a Mac. Then take the app that is in there and re-create it to the root of your media. You will probably want to change the proper name of the install app, brand the icon and decorate the window to only prove the installer.
  
• When creating a multi-disc GM for macOS, be certain the volume name for each disc matches. The volume name becomes part of the mountain path, and if the names don't friction match the installer won't be able to find the adjacent disc.

Optionally building a retail installer from a beta branch

The process above will create a retail installer based on the default branch. If you need to create an installer based on a beta branch, you must first create a beta branch named "baseline". Then use the following control to build from the baseline branch:

build_installer <project file> <target folder> <beta key> <beta pwd> steamcmd ex: build_installer sku_goldmaster.txt "D:\retail_disks" baseline superSecret script ex: steamcmd.exe +login user_name countersign +build_installer "..\Build\GameDataSku.txt" c:\destination beta_key beta_password +exit

Installing DLC from a retail installer

In some circumstances, you may wish to create a retail installer that includes your DLC packages. In such cases, the procedure to create the installer requires only a few changes.
In "sku_goldmaster.txt", include the DLC AppIDs under the "included_depots" section. Once yous have run the "build_installer" process, discover the generated sku.sis file for the installer and open up information technology with a text editor.
Add together the DLC AppID in the "apps" section. For example, if I had a game with AppID chiliad and DLC AppID 1010, I would adjust the "apps" department as follows:

"apps" { "0" "yard" "i" "1010" }

This will ensure that Steam checks for buying of the DLC and prompt the user for a key if the DLC is not endemic by the account that they are logging into on Steam.

Building a retail installer for multiple App IDs on a unmarried disc/install package

To build a GM containing multiple Steam Pipe apps. Build each app installer one past one but bespeak them all to the same output binder. Each build will merge itself with the already existing install image.

Customizing a Retail install disk

See Customizing a gold chief for more details on customizing your retail install disk.

Preloading Games before Release

Past default, all content is e'er encrypted, on all retail discs and on all content servers. Switching a game to preload manner means owners can download the content, merely it stays encrypted on the users' disk and can't be played. Once the game becomes officially released, Steam volition decrypt the preloaded content and the user can play the game.

Switching a game to preload mode is recommended in these cases:

• Shipping retail discs with production keys earlier the game is actually available (0-day piracy).
  
• Games that run a pre-purchase and are larger than 20GBs in size.

Please submit a ticket to Steam Publishing if y'all believe your game requires preloading.

Building DLC

DLC is built as a depot of the base of operations game. See the Downloadable Content (DLC) documentation for more information.

Troubleshooting SteamPipe

"Login Failure: Business relationship Login Denied Failed" when logging in via steamcmd

Crusade: Probably SteamGuard is preventing login. Resolution:

• Check the email associated with the business relationship you are trying to log on with and await for an email from Steam Back up. Copy the code from that email.
  
• Run the following steamcmd: set_steam_guard_code <code>
  
• Re-Attempt login from steamcmd: Steam>login <buildaccount> <password>

General Troubleshooting for Download Bug

• Restart computer, modem, router, etc.
  
• Verify firewall settings. The new arrangement requires port 80 (HTTP) and all other Steam ports, listed hither.
  
• Temporarily disable local Anti-Virus or Spam-Blocker programs.
  
• Check the Steam download region under Settings->Downloads. It should match your location.
  
• Terminate the download, uninstall, and reinstall the game (clear manifest caches).
  
• Get out Steam, delete the ii folders appcache and depotcache in your Steam install binder.
  
• Endeavor to set your Steam download region to some other location far abroad. This might work if a content server near you is serving bad data.

My Mac and/or Linux Builds aren't installing any files. Why?

If you're testing via Steam the installation of your game or application across multiple platforms, you may run into a situation where the build deploys on Windows but doesn't deploy any files on Mac or Linux despite your SteamPipe process being setup to upload Mac and/or Linux depots. There is a step that is easily missed which involves calculation your alternating Depots to the Parcel being deployed. You can check what depots are included in a package via the post-obit steps:

1. Navigate to your App Admin page
   
2. From the View Associated Items section, click All Associated Packages, DLC, Demos and Tools.
   
3. Click on the championship of the Packet you're attempting to download
   
4. Review the Depots Included section
   
5. Use the Add together/Remove Depots to ensure the right gear up of Depots are assigned to the Package

There are a number of discussion threads about this that may too aid:

• Empty folder later on installing the game
  
• Unity Builds for PC/Mac/Linux
  
• Preparing Content for Mac Packaging

Running steamcmd.exe results in the following mistake: "SteamUpdater: Error: Steam needs to be online to update. Delight confirm your network connection and try again."

Resolution: Go to Internet Options->Connections->Lan Settings and check Automatically find settings.

Running the app build results in the following error: "Mistake! Failed 'DepotBuild for scriptname.vdf' - status = 6."

Possible Causes:

• Account does non have permissions for the app.
  
  • Check that the app ID is right in the app_build.vdf.
    
  • Cheque that the build account has proper permissions to the app ID.
    
• Steamcmd cannot find the depot contents.
  
  • Bank check that the "contentroot" value in the app_build script is a valid path relative to the location of the script file.
    
  • Check that the "LocalPath" value in the depot_build script is a valid path relative to the path in the app_build script. Check that the path contains actual content.
    

Running the app build results in the following error: "Error! Failed to become application info for app NNNNN (cheque login and subscription)"

This means that Steam can't call back data about the app, either because information technology doesn't exist or the user doesn't have access to the app.

• Check that the NNNNN is the app ID you were assigned for the app.
  
• Cheque that the app ID is correct in the app_build.vdf.
  
• If it is a new app ID, check that the Steamworks app admin configuration has been published. New apps should have a Steam Piping install directory on the config tab, a depot on the depot tab, and all changes published on the publish tab.
  
• If all of that looks right, brand sure that your account owns the app ID.

"An error occurred while installing [AppName] (Invalid content configuration)" at launch time

Possible Causes:

• No build has been set live on the branch y'all're trying to install from.
  Resolution: Set up your build live on a branch past going to https://partner.steamgames.com/apps/builds/<YourGameAppId>, and select that co-operative in the Steam customer (as described here).
  
• Invalid game launch options.
  Resolution: Verify the launch options on the Installation tab in the app admin for your game https://partner.steamgames.com/apps/config/<YourGameAppId>.
  
• You don't ain the Depot IDs that make up the game.
  Resolution: Brand sure the necessary depots are added to the development subscription (See Editing packages for boosted details).

"Mistake code 15" at launch time

This is the CEG servers rejecting the request to CEG the exe. Check the release state on the game page. If it is not 'playable', you will need to request Steam keys that override the release state.

"The Steam Servers are likewise decorated to handle your request... Error Code (2)" at launch time

This is the CEG servers failing to find a matching CEG exe. Double check that you have a working CEG executable on the CEG tab of your app admin. Click the 'status' button to make sure that it'due south propped.

I tin can't recall what that steamcmd command was or how it worked

Apply the 'notice' command in steamcmd to search for any steamcmd command. It will do fractional matching on the command proper name and it will list out the command syntax.

Steam>find build_installer ConVars: Commands: build_installer : <project file> <target folder> <beta key> <beta pwd>

villagion1954.blogspot.com

Source: https://partner.steamgames.com/doc/sdk/uploading

Share this post