Steamworks Belgeleri
Steam'e Yükleme Yapmak
Aşağıda, Valve'in Steam'e içerik gönderme aracı olan SteamPipe'ı kullanma rehberi yer almaktadır. Oyununuzu güncellemek için en iyi yöntemler hakkında şuraya bakın: Oyununuzu Güncellemenin En İyi Yöntemleri.

SteamPipe İçerik Sistemi'ne Giriş

SteamPipe, Steam'e güç veren, oyun/uygulama içerik sistemidir. SteamPipe aşağıdaki özellikleri içerir:
  • Hızlı ve etkili içerik gönderme.
  • Public and private "beta" branches, allowing multiple builds to be tested.
  • Basit web temelli derleme yönetimi. Yeni bir derleme yayınlayın veya bir önceki derlemeyi birkaç tıklama ile geri alın.
  • Derlemeyi yayınlamadan önce güncelleme boyutunu görebilme.
  • İçeriği çoklu uygulamalar arasında paylaşabilme.
  • Herkese açık veya beta içeriğindenyükleme diskleri oluşturabilme imkânı.
  • Bir güncelleme indirmesi başlasa bile oyunlara/uygulamalara çevrim dışı erişilebilme imkânı.
  • Bütün içerikler her zaman şifre ile korumalıdır ve aktif durumda olmayan sürümler müşterilere erişilebilir olmaz.
  • Geliştirme sürecinde kullanılabilen bir belgelendirme bulunmaktadır.
NOT: SteamPipe'a dâhil olan birkaç konsept vardır. Başlamadan önce Uygulamalar belgelendirmesinde belirtilen bütün konseptlere aşina olmalısınız. Bu konseptlerde temel bir anlayışınız bile olsa ürününüzü Steam'e yüklerken çok kullanışlı olacaktır.

Game Content Structure - Best Practices

SteamPipe was designed for both efficient downloading of initial game installs and efficient patching of updates. In general, it works well for a wide variety of game content structures. However, there are some important things to know in terms of optimization and avoiding situations that can cause inefficiency.

Note: If your game uses Unreal Engine, please see the notes specific to these pack files at the end of this section.

SteamPipe initially splits each file into roughly one megabyte (MB) chunks. Each chunk is then compressed and encrypted before being upload to the Steam content-delivery system. They remain compressed and encrypted until downloaded by each client, where they are decrypted and expanded and placed in the necessary file location(s).

When SteamPipe is processing an update for an existing game, it searches to find any such chunks that match the previous build of the game. This way, ideally only the new or modified portions of any file are turned into "new" chunks, and those new chunks are the only pieces a client must download to update their game.

Many game engines use "pack" files to coalesce game assets, and improve load times by allowing more efficient disk access. In general, this works well with SteamPipe. However, some pack file systems use or enable using behaviors that can cause problems. The effect of these problems is almost always that updates are much larger than necessary. They can also result in a quick download but a slow update process as large amounts of local disk IO are necessary.

If your game uses pack files, here are some general guidelines.

  • Ensure asset changes are localized within the pack file as much as possible
  • Avoid shuffling asset ordering with a pack file
  • limit pack file size
  • group assets by level / realm / feature into their own pack files, and consider adding new pack files for updates instead of modifying existing ones
  • do not include any original filenames or file / build timestamps for each asset

The first point above refers to the scope of what bytes are changed within a file when a single asset is modified. If that asset's data is modified and/or grows or shrinks within the same location of the pack file, that is ideal. SteamPipe will only create new chunks for the portions of the file containing the asset data. However, all pack files need some sort of Table of Contents (TOC) as well so that the engine can locate the asset data. The structure of this TOC can have a large impact on the efficiency of SteamPipe patching. Ideally, there is one TOC or TOC tree near the beginning or end of the file. Because other assets may shift byte position within the file, their TOC entries will change as well. In this situation, SteamPipe will make new chunks for the modified asset data and the modified portions of the TOC.

However, what we have seen in some game engines is that the TOC information is distributed throughout the file. Even worse, it uses absolute byte-offset values. So if an asset at byte 3450 increases in size by 8 bytes, then the offset values for all assets after this in the file change. Even though each offset value is only 4 or 8 bytes in size, a change to an 8-byte number will result in a new 1MB chunk being created by SteamPipe. This can have catastrophic effects where even changing a few small assets in a pack file results in clients needing to download over half the entire file to update. If you know or suspect that your pack file structure is causing this issue, please contact your Valve representative as soon as possible. We have an alternate build algorithm that can help mitigate this issue, though it has tradeoffs.

Additionally, SteamPipe does not know about asset boundaries within a pack file. If sub-megabyte assets are shuffled, it will most likely not be able to detect this reordering as the previously determined 1-MB chunks will no longer be present within the file. So if, in the process of creating an update for your game, you wish to optimize load times by reordering assets within the pack file, be cognizant of the fact that it may result in a very large download for that update. We recommend only doing this if the performance improvements are significant.

Next - to update the pack file on a client device, SteamPipe builds the new version alongside the old version. When all new files are built, it then "commits" the update by deleting old files and moving the new files in. What this means is that to update a 25 GB pack file, SteamPipe will always build a new, 25GB file. If the update only requires 10 bytes of changes to that file, SteamPipe will need to copy almost the entire 25GB from the old file to the new file. Depending on the client storage hardware, this can be a very slow process. For this reason, we recommend two things.

First - limit the size of pack files. Probably one or two gigabytes (GB) is sufficiently large - more than enough to allow efficient disk reads when loading the game.

Second - keep the scope of assets within a single pack file fairly limited. Perhaps to a single game level, or unlockable feature. This way, updates that are focused on specific parts of your game don't cause the data from other parts to be copied around on the client machine. Additionally, when adding new functionality / levels / etc, these can and likely should be placed in their own new pack files. Clients downloading this update will have a simple download of new files, avoiding any of the issues mentioned above with pack file modifications.

When in doubt, you can use a local binary diff tool such as Beyond Compare to compare versions of your pack files. Verify that the differences shown are of the size you expect for the changed assets, and that there aren't perhaps dozens or hundreds of small changes spread out throughout the file. If what you see is unexpected, check your pack file tool settings.

Compression: Because Steam will compress all data for upload / storage / download, we generally don't recommend using general compression on pack files. However, if you are concerned about the on-disk size of your game, you may still want to use pack file compression. It will work OK with SteamPipe so long as the criteria listed above are met. Specifically, you should ensure that compression is per-asset as much as possible. Any compression that crosses asset boundaries will spread out changes and require clients to download more data than necessary.

Encryption: This is similar to compression - most likely unnecessary, and with the same risks mentioned above.

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

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

Unreal Engine - Special Notes

Some versions of the Unreal Engine use asset "padding alignment" in the pack files which can have a very large impact on the size of SteamPipe updates. This alignment can cause cascading asset shifts when building new versions, especially if pack file compression is enabled. Using a padding alignment of 1MB (1048576) will help ensure that re-alignments will shift assets by a multiple of the same blocksize that SteamPipe uses for delta calculations.

As an example, to change or specify your padding alignment when "cooking" your game pack files, you will need to change one line inside the file UnrealEngine/Engine/Source/Programs/AutomationTool/Win/WinPlatform.Automation.cs. That file contains a function GetPlatformPakCommandLine -- inside that function, change this line:

string PakParams = " -patchpaddingalign=2048";

to this:

string PakParams = " -patchpaddingalign=1048576 -blocksize=1048576";

With this change, you should be able to enable pack file compression and still get optimized SteamPipe update behavior.

Unreal Engine is Epic’s trademark or registered trademark in the US and elsewhere.

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.

Steamworks Video Tutorial - Adding New Platforms and Languages

This tutorial walks you through adding new platforms and languages to your game by adding depots to your app.

SteamPipe Teknik Detayları

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 can be hosted by external CDN providers, which can be easily added to our content network. Most consumer firewalls allow 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 need be sent. This means both developer and user transfers are smaller and faster. Most partners will find that using a SteamPipe Local Content Server not necessary since they can efficiently patch builds on private branches.

Steam Build Account

Before you can create any builds on Steam, you must have a Steam account in your Steamworks account with the "Edit App Metadata" and "Publish App Changes To Steam" permissions granted. For security reasons it's recommended that you have a dedicated build account with just those permissions, you may create a new Steam account for this purpose at

Any administrator of your Steamworks account can add a Steam account and grant the necessary permissions. More information on this process can be found in the Steamworks Hesabınızı Yönetmek documentation. An example of what this account might look like is:


Initial Setup for New SteamPipe Apps

Follow these steps to set up new SteamPipe apps:
  1. Uygulamanızın app ID'sini bulun (Steamworks ana sayfanızda uygulamanızı seçerek bunu bulabilirsiniz).
  2. Uygulamanızın Genel Yükleme Ayarları sayfasına gidin.
  3. En az bir başlatma seçeneğini belirleyin (dizin ve opsiyonel olarak oyunu başlatmak için gerekli olan herhangi argüman). Hover over the (?) to learn more about each field.

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

  4. Depolar sayfasına gidin ve bu uygulama için gerekli olduğu kadar depo ekleyin. Uygulamanız için hâlihazırda ayarlanmış bir depo var olabilir.
    1. Varsayılan depoya tıklayın ve deponun adını daha düzgün ve tanınabilir bir isimle değiştirin (mesela "Ana İçerik" veya "Windows İçeriği").
    2. Eğer bu depo, dili belirli bir depo değilse dili [Bütün diller] olarak bırakın.
    3. Leave the OS set to [All OSes] unless this is an OS-specific depot (if the app is all-in-one, or is just PC or just Mac, it should be left to [All OSes]. Sadece işletim sistemi belirli oyun depolarında belirtme yapılmalıdır.
    4. Ek depolar oluşturmak için Yeni Depo Ekle butonuna basın.
    5. Yapılan herhangi bir değişikliği kaydetmek için Değişiklikleri Kaydet tuşuna basın.
  5. Depolarınızın tanımlaması bittikten sonra yaptığınız değişiklikleri Yayınla sayfasından yayınlayın.
  6. Yeni tanımlanmış depolarınızın sahipliğini alabilmeniz için bir paket içerisine alınması gereklidir. Steam'deki her oyunun bir Geliştirici Comp paketine sahip olması gerekir. Bu paket otomatik olarak yayıncı grubunuzun içerisinde listelenen hesaplara verilir.
    O pakete (ve/veya bu depolara sahip diğer paketlere) yeni depoları İlişkili Paketler ve DLC sayfasından ekleyebilirsiniz.
Note: If your executable is in a sub-folder of the main installation folder, add the sub-folder name in the Executable field. Başında eğik çizgi ya da noktalar kullanmayın.
Platform Note: As shown above, macOS applications may be launched by specifying either an app bundle ( or a script/binary ( In general the app bundle format should be preferred if possible as it allows macOS to more correctly determine launch parameters in the manner 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 best architecture 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 machine you will be uploading builds on.

The SteamPipe tools can be 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 will 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 will be the location for build logs, chunk cache, and intermediate output. NOTE: This folder can be deleted or emptied at any time, but after it's deleted, the next upload time will take longer.
  • scripts - This directory is where you'll place all of your build scripts for building your game depots.

It's recommended that you run steamcmd.exe directly in the builder folder for your platform once to bootstrap your build system. 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 do so.

macOS'de SteamCmd

To enable SteamCmd on macOS you must complete the following steps:
  1. From the terminal, browse to the tools\ContentBuilder\builder_osx
  2. hmod +x steamcmd komutunu çalıştırın.
  3. Type bash ./
  4. SteamCmd will then run and update to the latest build, leaving you in the SteamCmd prompt
  5. 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, you must create scripts which describe your build and each depot that will be included in it. The example scripts shown here are in the Tools\ContentBuilder\scripts folder in the Steamworks SDK.

SteamPipe GUI Aracı

If you're running on Windows and would prefer a GUI tool to help 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 zip are additional instructions to get you started.

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

Basit Derleme Betiği

Let's start with the most basic build script possible. In our example we have a game (AppID 1000) that has one depot (DepotID 1001) and want to upload all files from a content folder 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 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" "1" // 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

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. Uygulama derlemesi başlaması, MDS (Ana Depo Sunucusu) ile kayıtlıdır. Böylece kullanıcının bu uygulamayı değiştirmek için doğru izinlere sahip olduğundan emin olunur.
  4. Uygulama derlemesinde bulunan her depo için bir dosya listesi, içerik klasöründeki dosyalara ve depo derlemesi yapılandırma dosyasında belirlenen filtre kurallarındaki dosyalara bağlı olarak oluşturulur.
  5. Her dosya taranır ve yaklaşık 1MB boyutunda küçük parçalara bölünür. Eğer depo daha önceden derlendiyse bu bölümleme, değişmemiş öbekleri mümkün olduğunca korur.
  6. Yeni dosya öbekleri sıkıştırılır, şifrelenir ve daha sonra MDS’e yüklenir.
  7. Bu depo sürümü için son bir bildirim çıkartılır; her bildirim benzersiz bir 64-bit bildirim ID’si ile tanımlanır.
  8. Bütün depolar işlendikten sonra, MDS uygulama derlemesini bitirir ve ona bir global BuildID sağlar.
  9. Derleme bittikten sonra derleme çıktı klasöründe bazı *.csm ve *.csd dosyaları bulunabilir. Bunlar geçici dosyalardır ve silinebilirler. Ancak bu dosyalar daha sonraki derleme sürelerini hızlandırırlar.

Once the build is complete you can see it on your app builds page, in this case it would be There you can set that build live for the default branch or any beta branch and users will be able to download this update within a couple of minutes.

Gelişmiş Derleme Betikleri

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 be 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 only visible to you in the 'Your Builds' section of the App Admin panel. This can be changed at any time after uploading a build on the 'Your Builds' page.
  • ContentRoot - The root folder of your game files, can be an absolute path or relative to the build script file.
  • BuildOutput - This directory will be the location for build logs, depot manifests, chunk caches, and intermediate output. For best performance, 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 good way 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 to test the installation of your game using the Steam client.
  • SetLive - Beta branch name to automatically set live after successful build, none if empty. Note that the 'default' branch can not 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 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 description here" // internal description for this build "Preview" "1" // make this a preview build only, nothing is uploaded "Local" "..\..\ContentServer\htdocs" // put content on local content server instead of uploading to Steam "SetLive" "AlphaTest" // set 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 different drive for better performance "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 two depot build script files that specify all file mappings and file properties. The following 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 section
  • ContentRoot - Lets you optionally override the ContentRoot folder from the app build script on a per depot basis
  • 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 also apply 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 - will excluded mapped files again and can also contain wildcards like '?' 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 - will mark a file with special flags:
    • userconfig - This file is modified by 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, it will be overwritten locally when the user's game updates. Only update the file in the depot when there is a necessary format change or bug fix.

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\audio\*" "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 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 machine, 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.

Using SteamPipe In A CI/CD Environment

To setup steamcmd for continuous integration, or just on a machine or VM that will get re-imaged frequently, you'll need to include the config file that contains your login token. Follow these steps so that your initial login token is properly saved:

  1. Run "steamcmd.exe +login <username> on the machine that will be preforming the build"
  2. Enter your password, and the SteamGuard token
  3. Type "info", and you should see your account listed as connected
  4. Type "quit"
  5. For each future run, do not enter a password. Simply run "steamcmd.exe +login <username>"
  6. Be sure that the config file stored in <Steam>\config\config.vdf is saved and preserved between runs, as this file may be updated after a successful login

NOTE: If you do login again and provide your password, a new SteamGuard token will be issued and required to login.

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 always a good idea to test it before shipping it to your customers, for more information on how to successfully do this see Steam Üzerinde Test Etmek.

Debugging Build Issues

If your build wasn't successful, you should look in your output directory for error information, not the console where the build script was run. Most error information can be found in the *.log files.
You can use these Steam client 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 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).

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" "2" "202932" } }
Some tips to keep in mind:
  • Create a new folder where the retail disc images will be written to, e.g., "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 you want to put on the retail disc. Otherwise, the account doesn't need 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 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 see "Backup finished for AppID...", the install disk images are ready. You can find more details about the backup build in logs\backup_log.txt.
  • There are new folders (Disk_1, Disk_2, and so on) in "D:\retail_disks", each not bigger than 640 MB, as 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 backup 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 copy it to the root of your media. You 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 volume name for each disc matches. The volume name becomes part of the mount path, and if the names don't match the installer won't be able to find the next disc.

Bir beta dalından isteğe bağlı olarak fiziksel disk için yükleyici derlemek

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

Fiziksel diskteki yükleyiciden DLC yüklemek

In some circumstances, you may wish to create a retail installer that includes your DLC packages. In such cases, the process 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.sis file for the installer and open it with a text editor.
Add 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 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.

Tek bir disk/yükleme paketine birden fazla uygulama için fiziksel yükleyici derlemek

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

Bir perakende yükleme diskini özelleştirmek

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

Preloading Games before Release

By default, all content is always encrypted, on all retail discs and on all content servers. Switching a game to preload mode means owners can download the content, but it stays encrypted on the users' disk and can't be 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 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.

Building DLC

DLC is built as a depot of the base game. See the İndirilebilir İçerik (DLC) documentation for more information.

Troubleshooting SteamPipe

steamcmd aracılığıyla giriş yaparken alınan "Login Failure: Account Login Denied Failed" hatası

Cause: Probably SteamGuard is preventing login. Resolution:
  • Check the email associated with the account you are trying to log on with and look for an email from Steam Support. Copy the code from that email.
  • Run the following steamcmd: set_steam_guard_code <code>
  • Re-Attempt login from steamcmd: Steam>login <buildaccount> <password>

İndirme Sorunları İçin Genel Sorun Giderme

  • Restart computer, modem, router, etc.
  • Verify firewall settings. The new system requires port 80 (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.
  • Stop the download, uninstall, and reinstall the game (clear manifest caches).
  • Exit Steam, delete the two folders appcache and depotcache in your Steam install folder.
  • Try 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.

Mac ve/veya Linux derlemelerim hiçbir dosya yüklemiyor. Neden?

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 adding your alternate Depots to the Package being deployed. You can 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. Use the Add/Remove Depots to ensure the correct set of Depots are assigned to the Package
There are a number of discussion threads about this that may also assist:

steamcmd.exe’yi çalıştırmak şu hataya yol açıyor: "SteamUpdater: Hata: Steam’in güncellenmesi için çevrim içi olunması gerek. Lütfen ağ bağlantınızı kontrol edin ve tekrar deneyin."

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

Uygulamayı çalıştırmak şu hataya yol açıyor: "HATA! 'DepotBuild for scriptname.vdf' Başarısız- durum = 6."

Possible Causes:
  • Account does not have permissions for the app.
    • Check 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.
    • 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.

Uygulamayı çalıştırmak şu hataya yol açıyor: "HATA! Uygulama NNNNN için uygulama bilgisi alınamadı (giriş ve aboneliği kontrol edin)"

This means that Steam can't retrieve 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 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 Pipe install directory as well as a depot, both can be found in Edit Steamwork Settings; the installation directory is in General Installation under the Installation tab, and Depots is under the SteamPipe tab. All changes published is done through the publish tab.
  • If all of that looks right, make sure that your account owns the app ID.

Başlatılırken görülen ”[AppName] yüklenirken bir hata ile karşılaşıldı (geçersiz içerik ayarı)”

Possible Causes:

Bir steamcmd komutunun ne olduğunu veya nasıl çalıştığını hatırlamıyorum

Use the 'find' command in steamcmd to search for any steamcmd command. It will do partial matching on the command 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>