How to Upload a Video to Steam 2018

Beneath is a guide to using SteamPipe, Valve'south tool for delivering content to Steam. For more than data on best practices for updating your game, meet 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 individual "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 come across the update size of a build before setting it alive.
  
• Ability to share content between multiple applications.
  
• Ability to build installer discs from public or beta content.
  
• Games/apps stay bachelor offline even later on an update download has been started.
  
• All content is e'er encrypted, and non-active versions are non visible to customers.
  
• A SteamPipe Local Content Server which tin be used during development.

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

Steamworks Video Tutorial - Building Your Game in Steampipe

This tutorial introduces SteamPipe and steps through building a sample awarding for Steam via the Steamworks tools.
https://www.youtube.com/scout?v=SoNH-v6aU9Q

Steamworks Video Tutorial - Adding New Platforms and Languages

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

SteamPipe Technical Details

SteamPipe uses the HTTP protocol for content commitment. Since downloads are regular web traffic, whatsoever third-party HTTP cache betwixt the customer and Steam servers volition increment download speed. Content can be hosted by external CDN providers, which tin 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, only changing the modified portions of existing content files. When this content is updated, only these deltas demand be sent. This means both programmer and user transfers are smaller and faster. Near partners will find that using a SteamPipe Local Content Server not necessary since they tin efficiently patch builds on private branches.

Steam Build Account

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

Any administrator of your Steamworks business relationship can add together a Steam account and grant the necessary permissions. More data on this process can exist institute in the Managing Your Steamworks Account documentation. An example of what this business relationship might look like is:

Initial Setup for New SteamPipe Apps

Follow these steps to set upwardly new SteamPipe apps:

1. Find the app ID for your application (this tin be plant by selecting the awarding on your homepage in Steamworks)
   
2. Go to the Full general Installation Settings page for your app.
   
3. Define at to the lowest degree 1 launch selection (the path and optionally, any arguments required to launch the game). Hover over the (?) to learn more about each field.

   The example below shows v launch options, ii for Windows, 2 for macOS and 1 for Linux.
   Launch option 3 volition only be shown on Windows if the user too owns the DLC specified.

   

4. Get to the Depots folio and add 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 proper name (such every bit "Base Content" or "Windows Content").
      
   2. Leave the language set to [All languages] unless this is a language-specific depot.
      
   3. Exit the Bone fix to [All OSes] unless this is an Bone-specific depot (if the app is all-in-one, or is simply PC or merely Mac, it should be left to [All OSes]. Only specify for OS-specific game depots.
      
   4. Click Add New Depot to create additional depots.
      
   5. Click Save Changes to salvage any changes made.
      
5. Once you are done defining your depots, publish the changes that you accept made from the Publish folio.
   
6. Your newly defined depots will demand to be included in a bundle to grant you lot ownership of them. Each game on Steam should take a Developer Comp parcel which is automatically granted to the accounts listed within your publisher group.
   You can add together the new depots to that packet (and/or other packages that should accept these depots) on the Associated Packages & DLC page.

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

Platform Note: Every bit shown to a higher place, macOS applications may exist launched past specifying either an app bundle (Game.app) or a script/binary (Game.app/Contents/MacOS/Game). In general the app bundle format should be preferred if possible as information technology 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 bundle on Apple tree Silicon devices will launch the best architecture bachelor in the awarding whereas direct binary launches will use the aforementioned architecture as the Steam procedure (currently x86_64).

Setting up the SDK for SteamPipe uploads

Download and unzip the latest version of the Steamworks SDK on the machine you volition be uploading builds on.

The SteamPipe tools tin can exist found within the SDK in the tools folder which contains 2 relevant sub-directories.

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

• builder - 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 be built into depots.
  
• output - This directory volition exist the location for build logs, chunk cache, and intermediate output. Annotation: This folder can be deleted or emptied at any time, but subsequently it's deleted, the next upload time volition take longer.
  
• scripts - This directory is where yous'll place all of your build scripts for building your game depots.

Information technology's recommended that you run steamcmd.exe directly in the builder folder for your platform once to bootstrap your build organisation. This should populate your builder 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 practise and then.

SteamCmd on macOS

To enable SteamCmd on macOS you must consummate the post-obit steps:

1. From the terminal, browse to the tools\ContentBuilder\builder_osx\osx32 binder
   
2. Run chmod +x steamcmd
   
3. Scan upwardly 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 y'all in the SteamCmd prompt
   
6. Type exit and press return to exit the prompt

You lot tin then follow the residue of this documentation (substituting paths equally 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 lot must create scripts which describe your build and each depot that will be included in information technology. The example scripts shown here are in the Tools\ContentBuilder\scripts folder in the Steamworks SDK.

SteamPipe GUI Tool

If you're running on Windows and would adopt a GUI tool to help create these config files and upload your builds you can use the SteamPipeGUI which is available in the tools binder of the Steamworks SDK. Included in the zip are additional instructions to go y'all started.

If you choose to apply the GUI tool then reading the following sections is still recommended to help yous become more than familiar with how the SteamPipe system works.

Simple Build Script

Allow'due south starting time with the virtually basic build script possible. In our case nosotros have a game (AppID 1000) that has ane depot (DepotID 1001) and desire to upload all files from a content binder and information technology'due south subfolders. We just demand a single build script for that, take a look at "simple_app_build.vdf" included in the SDK :

"AppBuild" { "AppID" "thousand" // your AppID "Desc" "This is a simple build script" // internal clarification 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" "one" // include all subfolders } } } }

Accommodate the AppID and DepotID for your game as needed. To kick off a build you demand 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

NOTE: Your first attempt at running a build may neglect due to Steam Guard. If the login fails due to Steam Guard, bank check your email for the Steam Baby-sit lawmaking, and run steamcmd as: steamcmd.exe "set_steam_guard_code <code>", and endeavor again. After logging in with Steam Guard once, a sentry file is used to verify the login is genuine.

If you are using steamcmd from a machine or VM that gets re-imaged frequently, you should include the picket and config file in your image so you won't be prompted for a Steam Guard 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 volition update itself to the latest version.
   
2. Steamcmd.exe is logging into the Steam backend using the given architect Steam account.
   
3. The app build commencement is registered with the MDS (Principal 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 binder and the filter rules defined in depot build config file.
   
5. Each file is scanned and divided into minor chunks of about 1MB. If the depot has been built before, this sectionalization will preserve as many of the unchanged chunks as possible.
   
6. New file chunks are compressed, encrypted, and so uploaded to the MDS.
   
7. A last manifest is generated for this depot version; each manifest is identified by a unique 64-chip manifest ID.
   
8. One time all depots take been processed, the MDS finishes this app build and assigns it a global BuildID.
   
9. After the build is washed, in that location may be *.csm and *.csd files in the build ouput binder. These are temporary and can exist deleted, only they speed upward subsequent build times.

Once the build is complete you lot can run across information technology on your app builds page, in this example it would be https://partner.steamgames.com/apps/builds/chiliad. There you can set that build live for the default branch or any beta co-operative and users volition 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 lot can create a depot build script for each depot which volition be referenced by the app build script. Offset let'due south accept a wait at bachelor parameters in the app build script:

• AppID - The AppID of your game. The uploading Steam partner account needs 'Edit App Metadata' privileges
  
• Desc - The clarification is merely visible to you in the 'Your Builds' section of the App Admin panel. This can be inverse at any time subsequently 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 volition exist the location for build logs, depot manifests, chunk caches, and intermediate output. For all-time operation, use a separate 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 skilful way to iterate on your upload scripts and make certain your file mappings, filters and properties work equally 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 let you 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. Notation that the 'default' branch can non be set live automatically. That must be done through the App Admin panel.
  
• Depots - This section contains all file mappings, filters and file properties for each depot or references a dissever script file for each depot

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

"AppBuild" { "AppID" "grand" // Your AppID "Desc" "Your build description here" // internal description for this build "Preview" "1" // brand this a preview build simply, cipher is uploaded "Local" "..\..\ContentServer\htdocs" // put content on local content server instead of uploading to Steam "SetLive" "AlphaTest" // set this build alive on a beta co-operative "ContentRoot" "..\content\" // content root folder relative to this script file "BuildOutput" "D:\build_output\" // put build cache and log files on different bulldoze for better performance "Depots" { // file mapping instructions for each depot are in split script files "1001" "depot_build_1001.vdf" "1002" "depot_build_1002.vdf" } }

This app build script references two 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 department is included directly into the app build script).

• DepotID - The DepotID for this department
  
• ContentRoot - Lets you optionally override the ContentRoot folder from the app build script on a per depot basis
  
• FileMapping - This maps a unmarried file or a ready of files from the local content root into your depot. At that place 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 also use to matching files in subfolders if Recursive is enabled. The DepotPath parameter specifies where the selected files should appear in the depot (use just '.' for no special mapping)
  
• FileExclusion - volition excluded mapped files once again and can besides contain wildcards like '?' or '*'
  
• InstallScript - volition marking a file equally install scripts and will sign the file during the build procedure. The Steam client knows to run them for whatever application which mounts this depot.
  
• FileProperties - volition marker 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 - Like to userconfig, nonetheless if the file is updated in the depot, information technology will exist overwritten locally when the user's game updates. Only 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\high german\audio\*" "DepotPath" "sound\" } "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 will exist modified during runtime } }

NOTE: You tin can name these scripts what ever you want, but nosotros apply the names app_build_<AppID> and depot_build_<DepotID> for consistency. If you lot know that yous'll exist building apps on this machine, it might be a good idea to create sub-directories in your scripts directory for each application, to assistance 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's ever a practiced idea to exam information technology before shipping it 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 lot should expect in your output directory for fault information, not the console where the build script was run. Nearly error information can be found in the *.log files.
Y'all can use these Steam customer commands and customer-side files to debug bug:

• "app_status [appid]" - Shows the current country 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 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 country of this app (KeyValues).

Building Efficient Depots for SteamPipe

The erstwhile Steam content arrangement would patch updates on a file level, which meant that if a unmarried byte in a file changed, the entire new file would be downloaded by 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 tin easily exceed 1 GB, so updates often led to unnecessarily large 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 problem by splitting each file into roughly 1-MB chunks. Each clamper is and so compressed and encrypted before being distributed by the Steam content organisation. If the game content has large redundant parts, these chunks are reused and the user merely has to download each repeated chunk once. Notwithstanding, 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 y'all modify or inject a few bytes in a big file, the user only has to download the changes.

This works well in virtually cases, but there are still a few pitfalls that need to be avoided when designing the content layout of a game. You may not desire to compress or encrypt your game data. This is already done for in-flight downloads and retail discs by the Steam content system. If you do information technology too, it can reduce the effectiveness of delta patching. Compression and encryption are only advised if each individual asset within a package file is separately compressed and/or encrypted. Otherwise, a change to one asset volition ever crave downloading several other potentially unchanged avails.

If yous parcel multiple assets in a single pack file, make sure that with each re-packaging, no unnecessary changes are made. I problematic practice is including the full proper name of the original source files on disk, because the names may change, depending on the build car. Another bad blueprint is including build time stamps for each file. If possible, always add new content to the terminate of your pack files and go along the order of existing files. Also, keep your pack file'due south metadata (offset and sizes to individual assets) in one place and don't intersperse information technology with the asset information. Use a binary difference tool similar BeyondCompare to look at two builds of your pack files to make certain that hundreds of unwanted changes don't show up.

If y'all follow these rules you will minimize patch sizes and only new content will demand to be downloaded. Your customers will thanks for that and y'all volition 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 procedure, please contact your Valve representative and we can expect into enabling advanced features to aid with this.

Building Retail Install Discs

To build retail install disc for SteamPipe games, you must first setup a build project file.
In this example, the SKU file is called "sku_goldmaster.txt":

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

Some tips to keep in mind:

• Create a new folder where the retail disc images will be written to, east.g., "D:\retail_disks". Only depots in the included_depots sections are added; there is no exclude section anymore.
  
• You can employ Steam.exe (with the -dev and -panel control-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 you want to put on the retail disc. Otherwise, the business relationship doesn't demand special rights, so anyone can build installer discs.
  
• If you use Steam.exe, stop all other downloads.
  
• Go to the console page 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 fourth dimension.
  
• If you lot'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 Deejay' and local game backups are basically the same.
  
• Once you lot see "Backup finished for AppID...", the install disk images are ready. You can detect more details about the fill-in build in logs\backup_log.txt.
  
• There are new folders (Disk_1, Disk_2, and then on) in "D:\retail_disks", each not bigger than 640 MB, every bit specified with "disk_size_mb". Each deejay binder contains a "sku.sister" file and a .csd and .csm for each depot. Bigger depots span across multiple disks. All retail install deejay content is always encrypted (unlike local game backup files). Re-create 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 name of the install app, make 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 book proper noun becomes part of the mount path, and if the names don't match the installer won't be able to find the side by side disc.

Optionally building a retail installer from a beta branch

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

build_installer <projection 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 only a few changes.
In "sku_goldmaster.txt", include the DLC AppIDs under the "included_depots" section. Once you have run the "build_installer" process, find the generated sku.sister file for the installer and open up information technology with a text editor.
Add the DLC AppID in the "apps" section. For example, if I had a game with AppID chiliad and DLC AppID 1010, I would suit the "apps" section as follows:

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

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

Edifice a retail installer for multiple App IDs on a single disc/install bundle

To build a GM containing multiple Steam Pipage apps. Build each app installer one by ane but point 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 gilded master for more details on customizing your retail install disk.

Preloading Games before Release

By default, all content is ever encrypted, on all retail discs and on all content servers. Switching a game to preload mode means owners can download the content, merely it stays encrypted on the users' disk and can't exist played. Once the game becomes officially released, Steam will 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 bachelor (0-24-hour interval piracy).
  
• Games that run a pre-buy and are larger than 20GBs in size.

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

Edifice DLC

DLC is congenital as a depot of the base game. See 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:

• Bank check the email associated with the business relationship you 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 <code>
  
• Re-Endeavor login from steamcmd: Steam>login <buildaccount> <password>

General Troubleshooting for Download Bug

• Restart figurer, modem, router, etc.
  
• Verify firewall settings. The new system 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. Information technology should match your location.
  
• Terminate the download, uninstall, and reinstall the game (clear manifest caches).
  
• Exit Steam, delete the two folders appcache and depotcache in your Steam install binder.
  
• Endeavour to fix 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 lot may encounter a situation where the build deploys on Windows simply doesn't deploy any files on Mac or Linux despite your SteamPipe process beingness setup to upload Mac and/or Linux depots. There is a step that is easily missed which involves adding your alternate Depots to the Package being deployed. You can bank check what depots are included in a package via the following 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 title of the Package you're attempting to download
   
4. Review the Depots Included section
   
5. Employ the Add/Remove Depots to ensure the correct set of Depots are assigned to the Package

There are a number of discussion threads nearly this that may also help:

• Empty binder 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 exist online to update. Delight confirm your network connection and try again."

Resolution: Become to Cyberspace Options->Connections->Lan Settings and check Automatically discover settings.

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

Possible Causes:

• Business relationship does non have permissions for the app.
  
  • Cheque that the app ID is correct in the app_build.vdf.
    
  • Check that the build account has proper permissions to the app ID.
    
• Steamcmd cannot find the depot contents.
  
  • Cheque 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 following error: "ERROR! Failed to get application info for app NNNNN (check login and subscription)"

This ways that Steam tin can't retrieve data near the app, either because it doesn't be or the user doesn't have access to the app.

• Cheque 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 information technology is a new app ID, check that the Steamworks app admin configuration has been published. New apps should have a Steam Pipe 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, make sure that your account owns the app ID.

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

Possible Causes:

• No build has been set live on the branch yous're trying to install from.
  Resolution: Prepare your build live on a branch by going to https://partner.steamgames.com/apps/builds/<YourGameAppId>, and select that branch in the Steam client (every bit described hither).
  
• 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>.
  
• Y'all don't own the Depot IDs that make up the game.
  Resolution: Make certain the necessary depots are added to the development subscription (Meet Editing packages for additional details).

"Error code 15" at launch time

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

"The Steam Servers are too busy to handle your request... Error Code (ii)" at launch time

This is the CEG servers declining to find a matching CEG exe. Double cheque that you accept a working CEG executable on the CEG tab of your app admin. Click the 'status' button to make certain that it'southward propped.

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

Utilise the 'detect' command in steamcmd to search for any steamcmd control. It will do partial matching on the command name and information technology will listing out the control syntax.

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

gossexamated.blogspot.com

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

Share this post