How to Upload Exe Files to Steam

Below is a guide to using SteamPipe, Valve'southward 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 System

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

• Efficient and fast content delivery.
  
• Public and private "beta" branches, allowing multiple builds to be tested.
  
• Simple web-based management of builds - push out a new build or rollback to a previous build with but a few clicks.
  
• Ability to see the update size of a build earlier setting it alive.
  
• Ability to share content betwixt 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 non-agile versions are not visible to customers.
  
• A SteamPipe Local Content Server which can be used during development.

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

Steamworks Video Tutorial - Building 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/sentry?v=SoNH-v6aU9Q

Steamworks Video Tutorial - Calculation New Platforms and Languages

This tutorial walks you through adding new platforms and languages to your game by 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 web traffic, any third-party HTTP cache between the customer and Steam servers will increase download speed. Content tin be hosted past external CDN providers, which can be easily added to our content network. Most consumer firewalls let HTTP traffic and won't block downloads.

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

Steam Build Account

Earlier you can create any builds on Steam, you must take a Steam account in your Steamworks account with the "Edit App Metadata" and "Publish App Changes To Steam" permissions granted. For security reasons it'south recommended that you have a dedicated build account with but those permissions, you may create a new Steam account for this purpose at https://store.steampowered.com/bring together.

Any administrator of your Steamworks account tin can add a Steam account and grant the necessary permissions. More information on this procedure can be constitute in the Managing Your Steamworks Business relationship documentation. An example of what this business relationship might look like is:

Initial Setup for New SteamPipe Apps

Follow these steps to set upwards new SteamPipe apps:

1. Notice the app ID for your awarding (this tin can exist found by selecting the application on your homepage in Steamworks)
   
2. Become to the General Installation Settings page for your app.
   
3. Ascertain at least i launch option (the path and optionally, any arguments required to launch the game). Hover over the (?) to learn more than about each field.

   The instance below shows v launch options, 2 for Windows, two for macOS and 1 for Linux.
   Launch option iii volition just be shown on Windows if the user too owns the DLC specified.

   

4. Go to the Depots page and add together depots as needed for this app. By default, a depot may already exist configured for your application.
   
   1. Click the default depot and change the name of the depot to a proper and recognizable name (such as "Base of operations Content" or "Windows Content").
      
   2. Go out the language set to [All languages] unless this is a linguistic communication-specific depot.
      
   3. Leave the OS gear up to [All OSes] unless this is an Os-specific depot (if the app is all-in-one, or is merely PC or just Mac, it should be left to [All OSes]. But specify for Bone-specific game depots.
      
   4. Click Add New Depot to create boosted depots.
      
   5. Click Save Changes to save any changes made.
      
5. One time y'all are washed defining your depots, publish the changes that you have fabricated from the Publish page.
   
6. Your newly defined depots will need to be included in a package to grant y'all ownership of them. Each game on Steam should accept a Developer Comp package which is automatically granted to the accounts listed within your publisher group.
   You lot tin add together the new depots to that package (and/or other packages that should have these depots) on the Associated Packages & DLC page.

Note: If your executable is in a sub-folder of the master installation folder, add together the sub-folder name in the Executable field. Don't apply leading slashes or dots.

Platform Note: As shown above, macOS applications may be launched past specifying either an app package (Game.app) or a script/binary (Game.app/Contents/MacOS/Game). In full general the app package format should be preferred if possible every bit it allows macOS to more correctly determine launch parameters in the manner it would if launched manually exterior of Steam.

One instance of this to note is that currently applications that are launched through an app packet on Apple Silicon devices will launch the best architecture available in the application whereas directly binary launches will use the same architecture as the Steam procedure (currently x86_64).

Setting upwards the SDK for SteamPipe uploads

Download and unzip the latest version of the Steamworks SDK on the machine you will exist uploading builds on.

The SteamPipe tools can be plant within the SDK in the tools folder which contains two relevant sub-directories.

The ContentBuilder directory is where your game content and SteamPipe build tools will live. This directory contains the following 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 will exist built into depots.
  
• output - This directory will exist the location for build logs, clamper cache, and intermediate output. Annotation: This folder tin can be deleted or emptied at whatever fourth dimension, but subsequently it'southward deleted, the next upload time volition have longer.
  
• scripts - This directory is where y'all'll place 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 organisation. This should populate your builder directory with all the files information technology needs to build depots.

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

SteamCmd on macOS

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

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

You can then follow the rest of this documentation (substituting paths every bit 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, you 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're running on Windows and would prefer a GUI tool to aid create these config files and upload your builds you tin can apply the SteamPipeGUI which is bachelor in the tools folder of the Steamworks SDK. Included in the naught are additional instructions to get you started.

If you choose to use the GUI tool so reading the following sections is still recommended to aid yous become more familiar with how the SteamPipe system works.

Unproblematic Build Script

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

"AppBuild" { "AppID" "grand" // 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 folder for build logs and build cache 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 } } } }

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

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

Notation: Your first attempt at running a build may fail due to Steam Guard. If the login fails due to Steam Baby-sit, cheque your email for the Steam Baby-sit code, and run steamcmd as: steamcmd.exe "set_steam_guard_code <code>", and try again. After logging in with Steam Guard once, a lookout 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, y'all should include the sentry and config file in your image and so you won't exist prompted for a Steam Baby-sit every fourth dimension. The sentry file is located in <Steam>\ssfn<hashOfNumbers>, and the config file is located in <Steam>\config\config.vdf.

The post-obit 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 showtime 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 listing 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 most 1MB. If the depot has been built before, this partition volition preserve as many of the unchanged chunks equally 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 by a unique 64-flake manifest ID.
   
8. Once all depots have been processed, the MDS finishes this app build and assigns information technology a global BuildID.
   
9. After the build is done, there may be *.csm and *.csd files in the build ouput folder. These are temporary and tin be deleted, but they speed upward subsequent build times.

In one case the build is complete y'all tin can see it on your app builds page, in this example it would be https://partner.steamgames.com/apps/builds/1000. In that location you can set that build live for the default branch or any beta co-operative and users volition exist able to download this update with a couple of minutes.

Advanced Build Scripts

If your app has a lot of depots with complex file mapping rules, you can create a depot build script for each depot which will exist referenced by the app build script. First let's take a look 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 but visible to you in the 'Your Builds' section of the App Admin console. This can exist changed at any fourth dimension after uploading a build on the 'Your Builds' page.
  
• ContentRoot - The root folder of your game files, tin be an absolute path or relative to the build script file.
  
• BuildOutput - This directory will be the location for build logs, depot manifests, clamper caches, and intermediate output. For best operation, 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 binder. Building preview builds is a good manner to iterate on your upload scripts and make certain your file mappings, filters and properties work every bit 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 permit you to examination the installation of your game using the Steam client.
  
• SetLive - Beta branch proper noun to automatically prepare alive after successful build, none if empty. Note that the 'default' branch can non be prepare alive automatically. That must be washed through the App Admin panel.
  
• Depots - This department contains all file mappings, filters and file properties for each depot or references a separate script file for each depot

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

"AppBuild" { "AppID" "1000" // Your AppID "Desc" "Your build clarification here" // internal clarification for this build "Preview" "ane" // make this a preview build simply, zilch 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 folder relative to this script file "BuildOutput" "D:\build_output\" // put build cache and log files on unlike drive for better operation "Depots" { // file mapping instructions for each depot are in separate 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 following instructions are available in a depot build script ( and too if the section is included directly into the app build script).

• DepotID - The DepotID for this section
  
• ContentRoot - Lets you optionally override the ContentRoot folder from the app build script on a per depot footing
  
• FileMapping - This maps a single file or a set of files from the local content root into your depot. There can be 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 like '?' or '*'. It will likewise apply to matching files in subfolders if Recursive is enabled. The DepotPath parameter specifies where the selected files should appear in the depot (use merely '.' for no special mapping)
  
• FileExclusion - will excluded mapped files once again and can also comprise wildcards similar '?' or '*'
  
• InstallScript - will mark a file as install scripts and will sign the file during the build process. 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 by the user or game. It cannot be overridden by an update, and information technology 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, it will be overwritten locally when the user's game updates. Only update the file in the depot when at that place is a necessary format change or bug prepare.

Example depot build script depot_build_1002.vdf showing employ 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" "one" // include all subfolders } "FileMapping" { // override audio files in \\audio with German versions "LocalPath" "localization\german\sound\*" "DepotPath" "audio\" } "FileMapping" { // re-create 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 language\german_installscript.vdf" "FileProperties" { "LocalPath" "bin\setup.cfg" "Attributes" "userconfig" // this file will be modified during runtime } }

NOTE: You can name these scripts what ever you want, but we use the names app_build_<AppID> and depot_build_<DepotID> for consistency. If you know that you'll be building apps on this car, it might be a good idea to create sub-directories in your scripts directory for each application, to help organize each application's build scripts.

Managing Updates

After your app releases to customers, your customers will be receiving the build marked as the Default build. When uploading a new build it'southward e'er a adept thought to examination information technology earlier aircraft it to your customers, for more than data on how to successfully do this meet Testing On Steam.

Debugging Build Bug

If your build wasn't successful, yous should look in your output directory for error information, not the console where the build script was run. Near error data tin can be found in the *.log files.
You lot tin can utilize these Steam client commands and customer-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 state of this app (KeyValues).

Edifice Efficient Depots for SteamPipe

The onetime Steam content system would patch updates on a file level, which meant that if a single byte in a file inverse, 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 hands exceed 1 GB, so updates oftentimes led to unnecessarily big downloads. A mutual fashion 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 organisation fixes this trouble by splitting each file into roughly 1-MB chunks. Each chunk is and so compressed and encrypted before beingness distributed past the Steam content organisation. If the game content has big redundant parts, these chunks are reused and the user only has to download each repeated clamper once. However, the real strength 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, it reuses them. This means if you change or inject a few bytes in a big file, the user only has to download the changes.

This works well in about cases, simply there are nevertheless a few pitfalls that need to be avoided when designing the content layout of a game. You may non want to shrink or encrypt your game data. This is already done for in-flying downloads and retail discs by the Steam content system. If you practise information technology too, information technology tin can reduce the effectiveness of delta patching. Compression and encryption are only brash 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 assets.

If you packet multiple assets in a unmarried pack file, make sure that with each re-packaging, no unnecessary changes are fabricated. I problematic practice is including the full name of the original source files on disk, because the names may alter, depending on the build auto. Another bad pattern is including build fourth dimension stamps for each file. If possible, ever add new content to the end of your pack files and keep the club of existing files. Too, keep your pack file'due south metadata (get-go and sizes to individual assets) in 1 place and don't intersperse it with the asset information. Use a binary difference tool similar BeyondCompare to look at two builds of your pack files to make sure that hundreds of unwanted changes don't show upward.

If you follow these rules you will minimize patch sizes and merely new content will need to be downloaded. Your customers will give thanks you lot for that and you will be able to increase the quality of your product by aircraft more than updates.

If you lot doubtable that your game packaging is not interacting well with the SteamPipe update process, please contact your Valve representative and nosotros can look into enabling advanced features to help with this.

Edifice Retail Install Discs

To build retail install disc for SteamPipe games, you must first setup a build project file.
In this instance, the SKU file is called "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 will be written to, e.yard., "D:\retail_disks". Only depots in the included_depots sections are added; there is no exclude section anymore.
  
• You can use Steam.exe (with the -dev and -console command-line parameters) or steamcmd.exe to build installer images. In both cases, use the "build_installer" command.
  
• Log on with a Steam account that owns the game and all depots y'all want to put on the retail disc. Otherwise, the business relationship doesn't need special rights, so anyone tin build installer discs.
  
• If you use Steam.exe, stop all other downloads.
  
• Become to the console folio and run the build_installer command:

  build_installer sku_goldmaster.txt "D:\retail_disks"

  The build can take a while since all depots are re-downloaded the first time.
  
• If you're building 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 same.
  
• Once you lot see "Backup finished for AppID...", the install disk images are ready. You can observe more details about the backup build in logs\backup_log.txt.
  
• There are new folders (Disk_1, Disk_2, and and so on) in "D:\retail_disks", each non 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 (dissimilar local game backup files). Copy the SDK GM setup files (setup.exe, setup.ini, etc.) into the binder of your first disk and the retail disc installer is complete.
  
• When creating a GM for macOS exist sure to open the goldmaster/disk_assets/SteamRetailInstaller.dmg image on a Mac. Then take the app that is in at that place and re-create it to the root of your media. Yous will probably want to change the name of the install app, brand the icon and decorate the window to only show the installer.
  
• When creating a multi-disc GM for macOS, be sure the book name for each disc matches. The volume name becomes part of the mount path, and if the names don't friction match the installer won't be able to find the next disc.

Optionally edifice a retail installer from a beta co-operative

The procedure above will create a retail installer based on the default branch. If you lot need to create an installer based on a beta branch, you must outset create a beta branch named "baseline". Then use the following command 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 password +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 merely a few changes.
In "sku_goldmaster.txt", include the DLC AppIDs nether the "included_depots" department. Once you have run the "build_installer" process, find the generated sku.sister file for the installer and open it with a text editor.
Add together the DLC AppID in the "apps" section. For example, if I had a game with AppID 1000 and DLC AppID 1010, I would adjust the "apps" section as follows:

"apps" { "0" "1000" "1" "1010" }

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

Building a retail installer for multiple App IDs on a single disc/install parcel

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

Customizing a Retail install deejay

See Customizing a gold master for more than details on customizing your retail install deejay.

Preloading Games before Release

Past default, all content is ever encrypted, on all retail discs and on all content servers. Switching a game to preload mode ways owners tin can download the content, but it stays encrypted on the users' deejay 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 product keys before 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 you believe your game requires preloading.

Edifice DLC

DLC is congenital as a depot of the base game. Encounter the Downloadable Content (DLC) documentation for more information.

Troubleshooting SteamPipe

"Login Failure: Account Login Denied Failed" when logging in via steamcmd

Crusade: Probably SteamGuard is preventing login. Resolution:

• Check the email associated with the account yous are trying to log on with and look for an email from Steam Back up. Copy the lawmaking from that email.
  
• Run the following steamcmd: set_steam_guard_code <lawmaking>
  
• Re-Attempt login from steamcmd: Steam>login <buildaccount> <password>

General Troubleshooting for Download Issues

• Restart estimator, modem, router, etc.
  
• Verify firewall settings. The new system requires port fourscore (HTTP) and all other Steam ports, listed here.
  
• 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).
  
• Exit Steam, delete the ii folders appcache and depotcache in your Steam install folder.
  
• Endeavor to set your Steam download region to some other location far away. 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 see 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 pace that is hands missed which involves calculation your alternate Depots to the Package being deployed. You can cheque what depots are included in a package via the following steps:

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

There are a number of discussion threads about this that may as well help:

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

Running steamcmd.exe results in the following error: "SteamUpdater: Error: Steam needs to be online to update. Delight ostend your network connectedness and try once again."

Resolution: Go to Internet Options->Connections->Lan Settings and cheque Automatically discover settings.

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

Possible Causes:

• Account does not have permissions for the app.
  
  • Check that the app ID is correct in the app_build.vdf.
    
  • Bank check that the build account has proper permissions to the app ID.
    
• Steamcmd cannot find the depot contents.
  
  • Check that the "contentroot" value in the app_build script is a valid path relative to the location of the script file.
    
  • Bank 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 post-obit error: "ERROR! Failed to become application info for app NNNNN (check login and subscription)"

This means that Steam can't recollect information about the app, either because it 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.
  
• Check that the app ID is right in the app_build.vdf.
  
• If it is a new app ID, cheque that the Steamworks app admin configuration has been published. New apps should have a Steam Pipage 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 correct, make certain that your business relationship owns the app ID.

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

Possible Causes:

• No build has been set up live on the branch you're trying to install from.
  Resolution: Set your build live on a branch past going to https://partner.steamgames.com/apps/builds/<YourGameAppId>, and select that branch 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 brand up the game.
  Resolution: Brand sure the necessary depots are added to the evolution subscription (Encounter Editing packages for boosted details).

"Error lawmaking 15" at launch time

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

"The Steam Servers are likewise busy 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 yous have a working CEG executable on the CEG tab of your app admin. Click the 'condition' button to make certain that it'due south propped.

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

Use the 'find' command in steamcmd to search for any steamcmd command. It will do partial matching on the command name and it volition listing out the command syntax.

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

wesleythomong.blogspot.com

Source: https://partner.steamgames.com/doc/sdk/uploading?l=english

Share this post