Unity Game Engine Series Part 8: Building & Publishing

1. Build Pipeline

Unity's build pipeline transforms your project's assets, scenes, and scripts into a platform-specific executable. Understanding each step of this pipeline gives you control over build size, performance, and compatibility.

1.1 Build Settings Window

The Build Settings window (File > Build Settings or Ctrl+Shift+B) is your central control panel for builds. It contains three critical sections:

// Automated build script — essential for CI/CD pipelines
using UnityEditor;
using UnityEditor.Build.Reporting;
using UnityEngine;

public class BuildAutomation
{
    // Called from command line: Unity -executeMethod BuildAutomation.BuildWindows
    [MenuItem("Build/Windows 64-bit")]
    public static void BuildWindows()
    {
        BuildPlayerOptions options = new BuildPlayerOptions
        {
            scenes = GetEnabledScenes(),
            locationPathName = "Builds/Windows/MyGame.exe",
            target = BuildTarget.StandaloneWindows64,
            options = BuildOptions.None
        };

        BuildReport report = BuildPipeline.BuildPlayer(options);
        BuildSummary summary = report.summary;

        if (summary.result == BuildResult.Succeeded)
        {
            Debug.Log($"Build succeeded: {summary.totalSize / (1024 * 1024):F1} MB");
            Debug.Log($"Build time: {summary.totalTime.TotalSeconds:F1}s");
            Debug.Log($"Warnings: {summary.totalWarnings}, Errors: {summary.totalErrors}");
        }
        else
        {
            Debug.LogError($"Build failed with {summary.totalErrors} errors");
            foreach (var step in report.steps)
            {
                foreach (var msg in step.messages)
                {
                    if (msg.type == LogType.Error)
                        Debug.LogError($"[{step.name}] {msg.content}");
                }
            }
        }
    }

    [MenuItem("Build/Android APK")]
    public static void BuildAndroid()
    {
        // Set Android-specific settings
        PlayerSettings.Android.bundleVersionCode++;
        EditorUserBuildSettings.buildAppBundle = false; // APK for testing

        BuildPlayerOptions options = new BuildPlayerOptions
        {
            scenes = GetEnabledScenes(),
            locationPathName = "Builds/Android/MyGame.apk",
            target = BuildTarget.Android,
            options = BuildOptions.None
        };

        BuildPipeline.BuildPlayer(options);
    }

    private static string[] GetEnabledScenes()
    {
        var scenes = new System.Collections.Generic.List<string>();
        foreach (var scene in EditorBuildSettings.scenes)
        {
            if (scene.enabled)
                scenes.Add(scene.path);
        }
        return scenes.ToArray();
    }
}

1.2 IL2CPP vs Mono — Scripting Backends

The scripting backend determines how your C# code is compiled and executed at runtime. This is one of the most impactful build decisions you'll make:

// link.xml — Preserve types from IL2CPP code stripping
// Place in Assets/ folder
/*
<linker>
    <!-- Preserve entire assembly -->
    <assembly fullname="MyGameAssembly" preserve="all"/>

    <!-- Preserve specific types used via reflection -->
    <assembly fullname="Assembly-CSharp">
        <type fullname="MyNamespace.SaveData" preserve="all"/>
        <type fullname="MyNamespace.NetworkMessage" preserve="all"/>
    </assembly>

    <!-- Preserve JSON serialization types -->
    <assembly fullname="Newtonsoft.Json" preserve="all"/>
</linker>
*/

1.3 Player Settings & Build Compression

Player Settings (Edit > Project Settings > Player) contain platform-specific configuration that affects how your build appears and behaves:

// Setting Player Settings programmatically for CI/CD
using UnityEditor;

public static class BuildConfigurator
{
    public static void ConfigureForRelease()
    {
        // Scripting backend
        PlayerSettings.SetScriptingBackend(
            BuildTargetGroup.Standalone, ScriptingImplementation.IL2CPP);

        // API compatibility
        PlayerSettings.SetApiCompatibilityLevel(
            BuildTargetGroup.Standalone, ApiCompatibilityLevel.NET_Standard_2_0);

        // Managed stripping for smaller builds
        PlayerSettings.SetManagedStrippingLevel(
            BuildTargetGroup.Standalone, ManagedStrippingLevel.High);

        // Version
        PlayerSettings.bundleVersion = "1.0.0";

        // Resolution defaults
        PlayerSettings.defaultIsNativeResolution = true;
        PlayerSettings.fullScreenMode = FullScreenMode.FullScreenWindow;

        // Strip engine code for smaller builds
        PlayerSettings.stripEngineCode = true;
    }

    public static void ConfigureForAndroid()
    {
        PlayerSettings.SetScriptingBackend(
            BuildTargetGroup.Android, ScriptingImplementation.IL2CPP);

        // Target ARM64 for modern devices (required by Google Play)
        PlayerSettings.Android.targetArchitectures = AndroidArchitecture.ARM64;

        // Minimum API level
        PlayerSettings.Android.minSdkVersion = AndroidSdkVersions.AndroidApiLevel24;

        // App bundle for Google Play (smaller downloads via split APKs)
        EditorUserBuildSettings.buildAppBundle = true;

        // Texture compression targeting
        PlayerSettings.Android.textureCompressionFormats =
            new[] { TextureCompressionFormat.ASTC, TextureCompressionFormat.ETC2 };
    }
}

2. Build Optimization

Optimization is the art of doing more with less. For builds targeting mobile and WebGL, every megabyte and every draw call matters. Even on powerful PCs, optimization separates professional releases from amateur ones.

2.1 Draw Call Batching

A draw call is a command sent from the CPU to the GPU to render a mesh with a specific material. Each draw call has overhead — reducing them is one of the most impactful optimizations you can make. Think of draw calls like trips to the grocery store: it's far more efficient to buy everything in one trip than to make 500 separate trips for each item.

// GPU Instancing example — render 10,000 objects efficiently
using UnityEngine;

public class GPUInstancingDemo : MonoBehaviour
{
    [SerializeField] private Mesh instanceMesh;
    [SerializeField] private Material instanceMaterial; // Must have "Enable GPU Instancing" checked
    [SerializeField] private int instanceCount = 10000;

    private Matrix4x4[][] batches;
    private MaterialPropertyBlock propertyBlock;
    private static readonly int ColorID = Shader.PropertyToID("_Color");

    private void Start()
    {
        // GPU instancing supports max 1023 instances per draw call
        int batchCount = Mathf.CeilToInt(instanceCount / 1023f);
        batches = new Matrix4x4[batchCount][];

        int remaining = instanceCount;
        for (int b = 0; b < batchCount; b++)
        {
            int count = Mathf.Min(remaining, 1023);
            batches[b] = new Matrix4x4[count];

            for (int i = 0; i < count; i++)
            {
                Vector3 pos = new Vector3(
                    Random.Range(-50f, 50f),
                    0f,
                    Random.Range(-50f, 50f)
                );
                Quaternion rot = Quaternion.Euler(0, Random.Range(0f, 360f), 0);
                Vector3 scale = Vector3.one * Random.Range(0.5f, 1.5f);

                batches[b][i] = Matrix4x4.TRS(pos, rot, scale);
            }
            remaining -= count;
        }

        propertyBlock = new MaterialPropertyBlock();
    }

    private void Update()
    {
        // Render all batches — each batch is a single draw call!
        foreach (var batch in batches)
        {
            Graphics.DrawMeshInstanced(
                instanceMesh, 0, instanceMaterial,
                batch, batch.Length, propertyBlock
            );
        }
        // 10,000 objects rendered in ~10 draw calls instead of 10,000
    }
}

2.2 LOD System (Level of Detail)

The LOD (Level of Detail) system automatically swaps high-poly meshes for lower-poly versions as objects move further from the camera. This is one of the most effective GPU optimization techniques — why render 50,000 triangles for a tree that's 200 meters away when 500 triangles look identical at that distance?

// Programmatically configure LOD Groups
using UnityEngine;

public class LODConfigurator : MonoBehaviour
{
    [SerializeField] private Mesh highPolyMesh;   // 10,000 triangles
    [SerializeField] private Mesh medPolyMesh;    // 3,000 triangles
    [SerializeField] private Mesh lowPolyMesh;    // 500 triangles
    [SerializeField] private Material sharedMaterial;

    private void Start()
    {
        LODGroup lodGroup = gameObject.AddComponent<LODGroup>();

        // Create LOD renderers
        LOD[] lods = new LOD[3];

        // LOD 0: Full detail when taking 60%+ of screen
        var lod0Go = CreateLODChild("LOD0", highPolyMesh);
        lods[0] = new LOD(0.6f, lod0Go.GetComponentsInChildren<Renderer>());

        // LOD 1: Medium detail at 30-60%
        var lod1Go = CreateLODChild("LOD1", medPolyMesh);
        lods[1] = new LOD(0.3f, lod1Go.GetComponentsInChildren<Renderer>());

        // LOD 2: Low detail at 10-30%, culled below 10%
        var lod2Go = CreateLODChild("LOD2", lowPolyMesh);
        lods[2] = new LOD(0.1f, lod2Go.GetComponentsInChildren<Renderer>());

        lodGroup.SetLODs(lods);
        lodGroup.RecalculateBounds();
    }

    private GameObject CreateLODChild(string name, Mesh mesh)
    {
        var child = new GameObject(name);
        child.transform.SetParent(transform, false);
        var filter = child.AddComponent<MeshFilter>();
        filter.mesh = mesh;
        var renderer = child.AddComponent<MeshRenderer>();
        renderer.material = sharedMaterial;
        return child;
    }
}

2.3 Addressables & Asset Management

The Addressables system is Unity's modern approach to asset loading and management. It replaces the old Resources folder with a powerful, flexible system that supports remote hosting, content updates without app store resubmission, and memory-efficient loading.

// Addressables — load assets on demand
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class AddressableLoader : MonoBehaviour
{
    // Load a single asset by address
    public async void LoadPrefab(string address)
    {
        AsyncOperationHandle<GameObject> handle =
            Addressables.LoadAssetAsync<GameObject>(address);
        await handle.Task;

        if (handle.Status == AsyncOperationStatus.Succeeded)
        {
            Instantiate(handle.Result, transform.position, Quaternion.identity);
            Debug.Log($"Loaded: {address}");
        }
        else
        {
            Debug.LogError($"Failed to load: {address}");
        }
    }

    // Load all assets with a label (e.g., "level_01_assets")
    public async void LoadLevelAssets(string label)
    {
        var handle = Addressables.LoadAssetsAsync<GameObject>(
            label, (obj) => {
                // Called for each loaded asset
                Debug.Log($"Loaded asset: {obj.name}");
            });
        await handle.Task;
        Debug.Log($"All {label} assets loaded: {handle.Result.Count} items");
    }

    // Unload when done to free memory
    public void UnloadLevel(AsyncOperationHandle handle)
    {
        Addressables.Release(handle);
        Debug.Log("Level assets released from memory");
    }

    // Download remote content (DLC, updates)
    public async void DownloadRemoteContent(string label)
    {
        // Check download size first
        var sizeHandle = Addressables.GetDownloadSizeAsync(label);
        await sizeHandle.Task;

        long downloadSize = sizeHandle.Result;
        if (downloadSize > 0)
        {
            Debug.Log($"Downloading {downloadSize / (1024 * 1024):F1} MB...");
            var downloadHandle = Addressables.DownloadDependenciesAsync(label);

            while (!downloadHandle.IsDone)
            {
                float progress = downloadHandle.PercentComplete;
                Debug.Log($"Download progress: {progress * 100:F0}%");
                await System.Threading.Tasks.Task.Yield();
            }
        }
    }
}

3. Testing & QA

3.1 Debug vs Release Builds

Understanding the difference between debug and release builds is critical for both development efficiency and shipping quality:

// Conditional compilation for debug-only code
using UnityEngine;
using System.Diagnostics;

public static class DebugHelper
{
    // [Conditional] attribute completely strips the method in release
    [Conditional("DEVELOPMENT_BUILD"), Conditional("UNITY_EDITOR")]
    public static void Log(string message)
    {
        UnityEngine.Debug.Log($"[DBG] {message}");
    }

    [Conditional("DEVELOPMENT_BUILD"), Conditional("UNITY_EDITOR")]
    public static void DrawGizmoBox(Vector3 center, Vector3 size, Color color)
    {
        UnityEngine.Debug.DrawLine(
            center - size / 2, center + size / 2, color, 0.1f);
    }

    // Use preprocessor directives for blocks of code
    public static void InitializeDebugSystems()
    {
#if DEVELOPMENT_BUILD || UNITY_EDITOR
        // In-game debug console
        GameObject.Instantiate(Resources.Load("DebugConsole"));
        // FPS counter
        GameObject.Instantiate(Resources.Load("FPSCounter"));
        // Cheat system
        CheatManager.Enable();
#endif
    }
}

3.2 Deep Profiling & Device Testing

The Unity Profiler is your primary tool for identifying performance bottlenecks in builds. Connecting to a development build running on a target device gives you accurate performance data that editor profiling cannot provide.

// Custom profiler markers for detailed performance analysis
using Unity.Profiling;
using UnityEngine;

public class GameplaySystem : MonoBehaviour
{
    // Create custom profiler markers
    static readonly ProfilerMarker s_AIUpdateMarker =
        new ProfilerMarker("GameplaySystem.AIUpdate");
    static readonly ProfilerMarker s_PhysicsQueryMarker =
        new ProfilerMarker("GameplaySystem.PhysicsQueries");
    static readonly ProfilerMarker s_PathfindingMarker =
        new ProfilerMarker(ProfilerCategory.Ai, "Pathfinding");

    private void Update()
    {
        // Wrap expensive operations with profiler markers
        using (s_AIUpdateMarker.Auto())
        {
            UpdateAllEnemyAI();
        }

        using (s_PhysicsQueryMarker.Auto())
        {
            PerformEnvironmentQueries();
        }
    }

    private void UpdateAllEnemyAI()
    {
        // Each sub-system gets its own marker for drill-down
        using (s_PathfindingMarker.Auto())
        {
            // Expensive pathfinding calculations
            // Now visible as a named block in the Profiler timeline
        }
    }

    private void PerformEnvironmentQueries() { /* ... */ }
}

4. Publishing Platforms

4.1 PC: Steam, Epic, itch.io

PC remains the most accessible platform for indie developers. Each store has unique requirements and opportunities:

// Steamworks integration example (using Steamworks.NET)
using Steamworks;
using UnityEngine;

public class SteamManager : MonoBehaviour
{
    private static SteamManager instance;
    private bool initialized;

    private void Awake()
    {
        if (instance != null) { Destroy(gameObject); return; }
        instance = this;
        DontDestroyOnLoad(gameObject);

        // Initialize Steam API
        if (!Packsize.Test())
        {
            Debug.LogError("Steamworks Packsize test failed!");
            return;
        }

        try
        {
            initialized = SteamAPI.Init();
            if (initialized)
            {
                string playerName = SteamFriends.GetPersonaName();
                Debug.Log($"Steam initialized. Welcome, {playerName}!");
            }
        }
        catch (System.DllNotFoundException e)
        {
            Debug.LogError($"Steam DLL not found: {e.Message}");
        }
    }

    // Unlock a Steam Achievement
    public static void UnlockAchievement(string achievementId)
    {
        if (!instance.initialized) return;
        SteamUserStats.SetAchievement(achievementId);
        SteamUserStats.StoreStats();
    }

    // Save to Steam Cloud
    public static void CloudSave(string filename, byte[] data)
    {
        if (!instance.initialized) return;
        SteamRemoteStorage.FileWrite(filename, data, data.Length);
    }

    private void Update()
    {
        if (initialized) SteamAPI.RunCallbacks();
    }

    private void OnApplicationQuit()
    {
        if (initialized) SteamAPI.Shutdown();
    }
}

4.2 Mobile: iOS & Android

Mobile publishing has the highest barrier to entry in terms of store requirements, but reaches the largest audience — over 3 billion active mobile gamers worldwide.

4.3 Console & WebGL

Console publishing requires formal developer relationships and certification processes:

WebGL builds run directly in the browser but come with significant limitations:

• No multithreading — JavaScript is single-threaded, so Job System and async operations behave differently
• Memory limited — browsers typically cap WASM memory at 2GB (browser-dependent)
• No file system access — use IndexedDB or PlayerPrefs for persistent data
• Shader limitations — WebGL 2.0 supports most features, but compute shaders and some post-processing effects are unavailable
• Compression essential — use Brotli compression for smallest download, Gzip as fallback. Server must send correct Content-Encoding headers

5. Monetization

5.1 Ads & In-App Purchases

Unity provides first-party solutions for both advertising and in-app purchases, making monetization integration straightforward:

// Unity Ads integration — rewarded video ads
using UnityEngine;
using UnityEngine.Advertisements;

public class RewardedAdsManager : MonoBehaviour, IUnityAdsLoadListener, IUnityAdsShowListener
{
    [SerializeField] private string androidAdUnitId = "Rewarded_Android";
    [SerializeField] private string iOSAdUnitId = "Rewarded_iOS";

    private string adUnitId;

    private void Awake()
    {
#if UNITY_IOS
        adUnitId = iOSAdUnitId;
#elif UNITY_ANDROID
        adUnitId = androidAdUnitId;
#endif
    }

    public void LoadAd()
    {
        Debug.Log("Loading rewarded ad...");
        Advertisement.Load(adUnitId, this);
    }

    public void ShowAd()
    {
        Advertisement.Show(adUnitId, this);
    }

    // IUnityAdsLoadListener
    public void OnUnityAdsAdLoaded(string placementId)
    {
        Debug.Log($"Ad loaded: {placementId}");
    }

    public void OnUnityAdsFailedToLoad(string placementId, UnityAdsLoadError error, string msg)
    {
        Debug.LogError($"Ad load failed: {error} - {msg}");
    }

    // IUnityAdsShowListener
    public void OnUnityAdsShowComplete(string placementId, UnityAdsShowCompletionState state)
    {
        if (state == UnityAdsShowCompletionState.COMPLETED)
        {
            // Player watched the full ad — grant reward
            Debug.Log("Ad completed! Granting reward.");
            GameEconomy.AddGems(50);
            LoadAd(); // Pre-load next ad
        }
    }

    public void OnUnityAdsShowFailure(string placementId, UnityAdsShowError error, string msg)
    {
        Debug.LogError($"Ad show failed: {error} - {msg}");
    }

    public void OnUnityAdsShowStart(string placementId) { }
    public void OnUnityAdsShowClick(string placementId) { }
}

// Unity IAP (In-App Purchases) integration
using UnityEngine;
using UnityEngine.Purchasing;
using UnityEngine.Purchasing.Extension;

public class IAPManager : MonoBehaviour, IDetailedStoreListener
{
    private static IAPManager instance;
    private IStoreController storeController;

    // Product IDs (must match App Store Connect / Google Play Console)
    private const string PRODUCT_GEMS_100 = "com.studio.game.gems100";
    private const string PRODUCT_REMOVE_ADS = "com.studio.game.removeads";
    private const string PRODUCT_VIP_PASS = "com.studio.game.vipmonthly";

    private void Awake()
    {
        if (instance != null) { Destroy(gameObject); return; }
        instance = this;
        DontDestroyOnLoad(gameObject);
        InitializePurchasing();
    }

    private void InitializePurchasing()
    {
        var builder = ConfigurationBuilder.Instance(StandardPurchasingModule.Instance());

        // Consumable — can be purchased multiple times
        builder.AddProduct(PRODUCT_GEMS_100, ProductType.Consumable);

        // Non-consumable — purchased once, persists forever
        builder.AddProduct(PRODUCT_REMOVE_ADS, ProductType.NonConsumable);

        // Subscription — recurring payment
        builder.AddProduct(PRODUCT_VIP_PASS, ProductType.Subscription);

        UnityPurchasing.Initialize(this, builder);
    }

    public void OnInitialized(IStoreController controller, IExtensionProvider extensions)
    {
        storeController = controller;
        Debug.Log("IAP initialized successfully");

        // Check if player already owns non-consumable
        if (HasPurchased(PRODUCT_REMOVE_ADS))
            AdManager.DisableAds();
    }

    public PurchaseProcessingResult ProcessPurchase(PurchaseEventArgs args)
    {
        string productId = args.purchasedProduct.definition.id;

        if (productId == PRODUCT_GEMS_100)
        {
            GameEconomy.AddGems(100);
            Debug.Log("Purchased 100 gems!");
        }
        else if (productId == PRODUCT_REMOVE_ADS)
        {
            AdManager.DisableAds();
            PlayerPrefs.SetInt("AdsRemoved", 1);
            Debug.Log("Ads removed!");
        }

        return PurchaseProcessingResult.Complete;
    }

    public bool HasPurchased(string productId)
    {
        var product = storeController?.products.WithID(productId);
        return product != null && product.hasReceipt;
    }

    public void OnInitializeFailed(InitializationFailureReason error) { }
    public void OnInitializeFailed(InitializationFailureReason error, string message) { }
    public void OnPurchaseFailed(Product product, PurchaseFailureDescription desc) { }
}

5.2 Business Models

6. History & Evolution of the Build Pipeline

Exercises & Self-Assessment

Conclusion & Next Steps

You now understand the complete journey from Unity project to published product. Here are the key takeaways from Part 8:

• IL2CPP is the production scripting backend — use Mono for fast iteration, IL2CPP for release builds. Watch for AOT limitations with reflection
• Draw call optimization (static batching, GPU instancing, SRP Batcher) is often the single biggest performance win
• LOD systems give you free GPU performance — invest in creating LOD meshes for every 3D asset
• Addressables replace the Resources folder for professional asset management, enabling on-demand loading and remote content updates
• Always profile on target hardware — editor performance is misleading. Use development builds with the Profiler connected
• Each platform has unique requirements — from Apple's strict review process to Sony's TRC checklist to WebGL's threading limitations
• Monetization strategy should be decided early — it affects game design, not just business