Monday, 27 July 2026

How to Use ElevenLabs for Game Development: AI Voice Acting, NPC Dialogue, and Sound Design

Most indie games ship without voice acting. Not because developers do not want it, but because hiring voice actors is expensive, scheduling them is slow, and revising recorded lines after the script changes means paying them again. So the game gets subtitles and silence, and it is a little bit flatter for it.

ElevenLabs has made this calculation genuinely worth revisiting. The voice quality is not "pretty good for AI." On certain voice types and delivery styles it is difficult to distinguish from a recorded human performance without a direct A/B comparison. It is not perfect across the board, but it is good enough that the question "should I voice my game?" now has a different answer for solo developers than it did two years ago.

This guide covers what ElevenLabs can and cannot do for game development specifically, how the credit and pricing system actually works, how to set up a voice cloning workflow for consistent character voices, and how to get the audio into Unity.



What ElevenLabs Does

ElevenLabs converts text to speech using AI models trained on large amounts of human voice recordings. You type a line of dialogue, pick a voice, and get an audio file back. The voices have natural variation in pacing, emphasis, and emotional tone — not the flat robotic cadence of older TTS systems.

There are three main ways to get voices:

  • Pre-made voices — a library of built-in voice options across different accents, ages, and tones. No setup required.
  • Voice Design — generate a synthetic voice with specific characteristics (age, accent, tone, gender) without providing any recording. Good for creating unique character voices that do not sound like a specific real person.
  • Voice Cloning — upload recordings of a real voice (your own, a voice actor's with permission, or a custom character recording) and generate new lines in that voice.

For game development, Voice Design and Voice Cloning are where the practical value lives. The pre-made voices are fine for narrators and generic NPCs, but any character who appears repeatedly needs a consistent, distinctive voice — which means either picking one pre-made voice and sticking to it, or cloning a voice specifically for that character.



Pricing and the Credit System

ElevenLabs bills based on credits. Credits are consumed by every generation, with different models and quality settings costing different amounts per character of text. The relationship between credits and usable audio time is not straightforward, and the pricing page is not the most transparent thing to read.

Here is what the relevant tiers actually get a solo game developer, as of mid-2026:

Plan Monthly Price Credits Approx. Audio Commercial Rights Voice Cloning
Free $0 10,000/month ~10 min (Multilingual) or ~20 min (Flash) No — attribution required No
Starter $5/month 30,000/month ~30 min (Multilingual) or ~60 min (Flash) Yes Instant cloning only
Creator $22/month 100,000/month ~100 min (Multilingual) Yes Professional cloning
Pro $99/month 500,000/month ~500 min Yes Professional cloning

Two things about this table worth flagging before you make any decisions.

First: the free plan has no commercial usage rights. Content created on the free plan requires ElevenLabs attribution and cannot be used in a monetized product, client work, or anything revenue-adjacent. For a game you plan to sell or distribute through any store, you need at minimum Starter at $5/month. This trips up a lot of people who test the free tier, like the results, and then discover the fine print when they try to ship.

Second: instant voice cloning versus professional voice cloning is a meaningful quality difference. Instant cloning works from a minute or two of audio and is available on Starter. Professional cloning requires more training data and is available from Creator upward — it produces more stable, natural results across long dialogue sessions. For a main character who speaks hundreds of lines, professional cloning is worth the upgrade. For a minor NPC with a dozen lines, instant cloning is probably fine.

Annual billing saves roughly 17% across all tiers. Always verify current pricing at elevenlabs.io before subscribing — plans and credit allocations change frequently and the pricing page is the authoritative source.



Part 1: Setting Up a Character Voice

The fastest way to get started is using one of the pre-made voices from the Voice Library. Go to the Voices section, browse by category (narrator, villain, young adult, and so on), preview them, and save the ones that feel right for your character types. Each saved voice appears in your generation panel.

For characters who need a distinctive, custom voice, Voice Design is the better option.

Voice Design Workflow

  1. Go to Voices > Voice Design in the ElevenLabs interface.
  2. Describe the voice in the text prompt: "A gruff middle-aged man, slightly raspy, slight Eastern European accent, sounds like he has seen too much war." ElevenLabs generates multiple voice variants matching that description.
  3. Preview each variant with a sample line. Generate more variants until one fits.
  4. Save the voice to your voice library. It now appears in every generation panel as a selectable option.

Voice Design voices are synthetic — they are not trained on or derived from any specific real person's recordings. They are consistent across generations, unlike a cloned voice that can sometimes drift slightly on unusual phoneme combinations.

Instant Voice Cloning (Starter and Above)

If you want to record your own voice and use it as a character voice, or if you have hired a voice actor for a short session and want to generate additional lines without rebooking:

  1. Go to Voices > Add a New Voice > Instant Voice Clone.
  2. Upload 1-3 minutes of clean audio with minimal background noise. A phone recording works; a recording with music underneath does not.
  3. Name the voice and save it.
  4. Generate new lines in that voice.

For instant cloning, one to three minutes of clean mono audio at 22 kHz or higher produces a usable clone. The voice holds up for short lines but can sound slightly off on very long sentences or unusual phrases. Test across a range of your actual dialogue before committing to it for a main character.

Part 2: Generating Dialogue

Go to Text to Speech in the navigation. Select your character voice, paste a dialogue line, and generate. The output is a .mp3 or .wav file you can download immediately.

Settings That Change the Output

Setting What It Does Game Dev Starting Point
Model Eleven Multilingual v2 for best quality; Flash v2.5 for faster/cheaper generation at slightly lower quality. Use Multilingual for final lines, Flash for draft review.
Stability Higher stability = more consistent but flatter delivery. Lower = more expressive but can drift between generations. 0.4-0.6 for most NPC dialogue. Lower for emotional scenes.
Similarity Boost For cloned voices, how closely the output matches the original recording. Higher values can cause artifacts. 0.7-0.8. Above 0.9 often sounds unnatural.
Style Exaggeration Emphasizes the speaking style in the voice. Can add character but also amplify oddities. 0-0.3 for normal dialogue. Higher for stylized characters.

The Speaker Boost checkbox is worth enabling for any voice that sounds slightly muddy on playback — it adds a processing pass that clarifies the audio. It costs slightly more credits per generation.

Directing Delivery Through Text

ElevenLabs does not have a separate emotion selector for most models. You direct the emotional delivery through the text itself — punctuation, pacing cues, and in some cases explicit stage direction in brackets.

These techniques actually work:

  • Ellipsis for hesitation: "I... I don't know what to say."
  • Capitalization for stress: "I told you NOT to open that door."
  • Dashes for interrupted speech: "Wait, before you go — listen to me."
  • Brackets for tone direction (Eleven v3): "[whispering] They're still out there."

The bracket-based direction is a v3 feature and not available on all models. Test which techniques work on your specific voice and model combination rather than assuming all of them apply.

Part 3: Getting Audio Into Unity

Unity supports .mp3 and .wav imports directly. The workflow is simple but there are a few things that will save you time at scale.

Basic Import

  1. Download generated audio as .wav (higher quality, larger file) or .mp3 (smaller, fine for most dialogue).
  2. Drag into a designated folder in your Unity Project window — something like Assets/Audio/Dialogue/CharacterName/.
  3. Select the imported clip and check the Inspector settings: set Compression Format to Vorbis for dialogue (better compression than PCM), set Load Type to Streaming for long files or Decompress on Load for short lines.
  4. Assign to an AudioSource component in your NPC's script, or reference it in your dialogue system's audio playback logic.

Managing a Large Dialogue Library

A game with dozens of NPCs and hundreds of dialogue lines generates a lot of audio files. A naming convention from the start prevents the folder from becoming unmanageable:

NPC_Guard_Line001_Idle.wav
NPC_Guard_Line002_Alert.wav
NPC_Merchant_Line001_Greeting.wav

If your dialogue system uses a ScriptableObject-based structure (covered in the ScriptableObjects guide from this series), you can store AudioClip references directly in the dialogue data assets alongside the text. This keeps dialogue text and audio tied together in the same place rather than scattered across separate folders that drift out of sync as the script changes.

What Works Well and What Does Not

ElevenLabs is genuinely impressive for certain voice types and delivery styles. Calm narration, conversational NPC chatter, villain monologues with measured delivery, elderly characters with gravelly voices — these tend to come out well without much tweaking.

It struggles with:

  • Shouting and extreme emotion. Screaming, rage, and intense fear often come out sounding strained or artificial. These are the lines worth recording with a real voice actor if any lines in your game are.
  • Non-English phonemes in otherwise English text. A character name like "Xrathul" or a place name like "Aelionthar" will be mispronounced in ways that vary between generations. Test proper noun pronunciation early.
  • Very long lines without natural pause points. Lines over 200-300 characters sometimes have pacing issues. Break long dialogue into multiple shorter generations and edit them together in an audio editor if needed.
  • Singing. ElevenLabs has a music feature but it is not designed for character singing in the way game vocals usually work. For anything sung, a real recording remains the practical option.

The Sound Effects Generator is worth knowing about but is not a replacement for a proper game audio library. It generates short sound effects from text prompts — "heavy wooden door creaking open," "distant thunderstorm," "coins dropping on stone floor." The results are inconsistent. Sometimes usable, sometimes clearly artificial. Worth testing on any specific sound you need and cannot source elsewhere, but not something to build a full audio pipeline around.



ElevenLabs vs Alternatives

Tool Strengths Weaknesses Price
ElevenLabs Best overall voice quality in 2026, voice cloning, large voice library, good emotional range on supported delivery styles. No commercial rights on free tier, credit system is confusing, struggles with extreme vocal delivery. Free; $5/month (Starter); $22/month (Creator)
Murf AI Clean interface, good for narration and corporate-style voices, integrated editing tools. Lower emotional range than ElevenLabs, less convincing for character acting versus narration. Free tier; paid from $19/month
Play.ht Wide voice selection, API-friendly for automation, good multilingual support. Quality ceiling slightly below ElevenLabs on character voices. Free tier; paid from $31/month
Real voice actors Authentic delivery, natural extreme emotion, human direction, fully licensable. Cost, scheduling, revision cycles, not scalable for large NPC casts on indie budgets. $100-500+ per hour session

The honest comparison to real voice actors is worth thinking through rather than dismissing. For a protagonist with 500+ lines across 20 hours of gameplay, ElevenLabs is not going to produce the same emotional performance a professional actor would. For 50 lines of ambient dialogue across 30 different minor NPCs, it absolutely is the practical choice.

Common Problems

The voice sounds right sometimes but inconsistent across multiple generations of the same line.

Stability is too low. Raise the Stability slider toward 0.6-0.7. If consistency still varies, the voice itself may be inherently unstable on this model — try a different model (Multilingual v2 tends to be more consistent than Flash for character work) or regenerate and use the most consistent take.

Proper nouns and character names are being mispronounced.

Spell them phonetically in the text input. "Xrathul" becomes "Zrathool" or "Zr-ath-ul" depending on which phonetic spelling produces the correct sound on your specific voice. Test phonetic spelling early in production — going back through hundreds of lines to fix a name pronunciation is slow.

The audio has a slight robotic or unnatural quality at certain points.

Speaker Boost is the first thing to try — it adds clarity and reduces the uncanny valley quality on some voices. Also check whether the model is set to Flash (faster, lower quality) rather than Multilingual v2. For voice clones specifically, lowering Similarity Boost from above 0.85 to around 0.75 often improves naturalness.

Free tier audio cannot be used in the game.

This is not a technical problem, it is a terms of service issue. The free tier has no commercial usage rights. Upgrade to at least Starter ($5/month) before generating any audio you intend to include in a distributed or monetized game.



A Practical Dialogue Pipeline for Solo Developers

This is the workflow that makes ElevenLabs actually manageable when you have more than a handful of lines to generate.

  1. Finalize the script first. Generate audio for lines that are locked. Generating audio for dialogue that later changes costs credits twice and creates file management headaches.
  2. Create one voice per major character. Either a pre-made voice you have tested across a range of line types, a Voice Design voice you have generated and saved, or a cloned voice. Stick to it throughout production.
  3. Generate in batches by character. Generate all lines for one character in one session while the settings and voice are loaded. Switching between characters mid-session wastes time on setup and makes it harder to catch inconsistencies.
  4. Name files consistently from the start using the convention described above. No renaming later.
  5. Keep a generation log. A simple spreadsheet with line ID, text, voice used, generation date, and Unity file path. When the script changes and you need to regenerate specific lines, you can find exactly which file needs replacing without listening through everything.

What to Do With It Now

Create a free account at elevenlabs.io — no credit card required. Generate ten lines using the pre-made voice library to get a feel for quality before worrying about custom voices or cloning. Try the same line with different Stability settings to see how much that single slider changes the output. Then try Voice Design with a specific character concept from your current project.

If the quality is good enough for your game's dialogue needs, upgrade to Starter before generating anything you plan to actually ship. Five dollars a month for commercial rights and thirty minutes of high-quality dialogue audio per month is genuinely good value for an indie developer.

Next Topics To Learn

Friday, 24 July 2026

How to Build Unity Games for iOS: Xcode Setup, Player Settings, and App Store Submission

iOS builds are more complicated than Android builds. Not dramatically more, but there is one constraint that catches every Windows developer off guard: Xcode is only available on macOS, so if your development machine does not run macOS, you cannot build an iOS application locally. You need either a Mac or Unity Build Automation, which handles the Xcode step in the cloud.

That aside, the Unity side of the setup is straightforward. The hard parts are almost always Apple-specific — provisioning profiles, signing certificates, bundle identifiers that have to match exactly across three different places, and Xcode's occasional tendency to refuse to trust a connected device for no obvious reason. None of those are Unity problems. They are Apple problems.

This guide covers the full pipeline: installing iOS Build Support, configuring Player Settings correctly, running on a physical device for testing, signing for the App Store, and fixing the errors that show up on every first iOS build. It pairs directly with the Android Build guide from this series — same structure, iOS-specific details throughout.



What You Need Before Starting

  • A Mac running macOS. Xcode only runs on Mac. An M1/M2/M3/M4 Mac Mini is the cheapest viable option if you are buying specifically for iOS development — they run Xcode without any issues and are significantly faster than older Intel Macs for IL2CPP builds.
  • Xcode 15 or later. Unity recommends Xcode 15 or later for iOS development. Apps submitted to the App Store must be built with Xcode 16.0 or later and the iOS 18 SDK. Install Xcode from the Mac App Store — it is free but large (around 15GB).
  • iOS Build Support module installed through Unity Hub.
  • An Apple ID for local device testing (free). An Apple Developer Program membership ($99/year) for App Store distribution.
  • A physical iPhone or iPad for testing. The iOS Simulator in Xcode runs on your Mac but does not test actual GPU performance, touch input, or device-specific behavior accurately enough to replace real hardware.

If you are on Windows and cannot access a Mac, Unity Build Automation can build iOS applications for you in the cloud. You still need to register for an Apple Developer account, generate certificates and provisioning profiles through the Apple Developer portal, and upload your credentials to Unity Build Automation. That workflow is worth knowing about but is more advanced than a local build — for a first iOS build, a Mac is the significantly simpler path.


 

Part 1: Installing iOS Build Support

  1. Open Unity Hub.
  2. Go to the Installs tab.
  3. Click the gear icon next to your Unity version and select Add Modules.
  4. Check iOS Build Support.
  5. Click Install and wait for the download.

Unlike Android, iOS Build Support has no sub-modules to check — there is no separate SDK or NDK to worry about. Apple's toolchain lives entirely in Xcode. The Unity module just adds the ability to generate an Xcode project from your Unity project. Xcode then handles the actual compilation.

After installation, confirm it worked by opening Unity and going to File > Build Settings. iOS should now appear in the platform list. If it is missing or shows "Install with Unity Hub," the module did not install correctly — go back to Hub and try again.

Part 2: Switching Platform to iOS

  1. In Unity, go to File > Build Settings.
  2. Select iOS from the platform list.
  3. Click Switch Platform.

This reimports your assets for iOS — same process as Android, same warning about it taking a while on larger projects. After the switch, the iOS icon appears next to scene files in the Project window confirming the active platform changed.

Part 3: Player Settings That Matter

Open through Edit > Project Settings > Player, then select the iOS icon tab.

Bundle Identifier

This is the most important iOS-specific setting and the one that causes the most pain when it is wrong. The bundle identifier is the unique ID for your app across Apple's entire ecosystem — it must match exactly between Unity, Xcode, and the Apple Developer portal. If any of the three disagree, the build fails or the app cannot be signed.

Format: com.yourcompany.gamename — same reverse domain notation as Android's package name, same rules: lowercase, no spaces, globally unique for App Store distribution.

Set this before doing anything else. Changing it mid-project is possible but requires updating it in multiple places simultaneously, which is how mismatches happen.

Signing Team

This is your Apple Developer Team ID. You can leave it blank for local device testing with a free Apple ID, but it must be set for any App Store build. It appears as a dropdown once you have signed into Xcode with your Apple ID — set it in Unity Player Settings to match what Xcode will use, or let Xcode manage it automatically by checking "Automatically manage signing" in the Xcode project settings.

Target iOS Version

The minimum iOS version your app supports. Setting it lower means more devices can install it; higher lets you use newer iOS features. For most games in 2026, iOS 15 or 16 as the minimum covers the vast majority of active iPhones while still giving access to modern APIs. Check Apple's App Store analytics for current device distribution if you want data to back the decision.

Architecture

Set to ARM64. All iPhones and iPads from 2017 onward use 64-bit ARM processors. There is no reason to support ARMv7 for new projects — Apple dropped 32-bit app support in iOS 11. ARM64 only.

Scripting Backend

IL2CPP is the only option for iOS — Mono is not supported on iOS due to Apple's restrictions on just-in-time compilation. This is already the default. You cannot accidentally use Mono on iOS; Unity will not let you.



Part 4: Generating the Xcode Project

Unity does not compile your game directly into an iOS app. Instead, it generates an Xcode project, and then Xcode builds that project into the final application. This two-step process is important to understand because it means you will sometimes need to make changes in Xcode rather than in Unity.

  1. In Build Settings, click Build (not Build and Run — we will get to that).
  2. Choose an output folder. Create a new folder called something like "iOSBuild" outside your Unity project folder.
  3. Unity generates the Xcode project files in that folder. It does not install anything to a device yet.
  4. Navigate to that folder in Finder and open the .xcodeproj file. Xcode opens the generated project.

If you use Build and Run instead of Build, Unity generates the project AND tells Xcode to compile and install it to a connected device in one step. Build and Run is faster once everything is set up correctly. Use Build first until you have confirmed the Xcode project generates without errors.

The Replace vs Append Dialog

Every subsequent build to the same output folder shows a dialog asking whether to Replace or Append the existing Xcode project.

  • Replace — completely overwrites the Xcode project. Use this during normal development. Any manual changes you made to the Xcode project are lost.
  • Append — merges Unity's new output into the existing Xcode project, preserving manual changes you added. Use this if you have edited the Xcode project directly to add frameworks or capabilities that Unity does not handle automatically.

Most beginners should always choose Replace until they have a specific reason to edit the Xcode project directly.

Part 5: Testing on a Physical Device

With a Free Apple ID (No Developer Program)

  1. Open the generated .xcodeproj in Xcode.
  2. Connect your iPhone or iPad via USB.
  3. In Xcode, go to Signing & Capabilities and sign in with your Apple ID if prompted.
  4. With a free Apple ID, Xcode creates a personal team that allows you to install apps on up to 3 devices with a 7-day certificate validity. The app will stop working after 7 days and needs to be reinstalled.
  5. Select your connected device from the device dropdown at the top of Xcode.
  6. Press the Play button (or Cmd+R) to build and install.
  7. The first time, your iPhone will show a prompt about trusting the developer — go to Settings > General > VPN & Device Management and trust your Apple ID there.

The 7-day limit is annoying during active development but works fine for quick tests. The Apple Developer Program ($99/year) removes the limit and enables App Store distribution.

With an Apple Developer Program Account

Log into your Apple Developer account at developer.apple.com, register your device's UDID, and create a Development provisioning profile for your bundle identifier. In Xcode, under Signing & Capabilities, either let Xcode manage signing automatically (simplest) or manually select the provisioning profile you created. The certificate validity extends to one year rather than seven days.



Part 6: App Store Submission

Getting to the App Store requires a few steps beyond just building correctly.

Archive the Build in Xcode

  1. In Xcode, set the target device to Any iOS Device (arm64) — not a specific connected device.
  2. Go to Product > Archive.
  3. Xcode builds the app and adds it to the Archives list in the Organizer window.

Upload to App Store Connect

  1. In the Xcode Organizer, select the archive and click Distribute App.
  2. Choose App Store Connect and follow the wizard.
  3. Xcode validates and uploads the build to App Store Connect.

TestFlight First

Before submitting for App Store review, test through TestFlight. Any build uploaded to App Store Connect is automatically available for TestFlight testing with external testers. Testing with real users on TestFlight before App Store submission catches device-specific bugs that neither the Unity editor nor Xcode's simulator will surface.

App Store review typically takes 24 to 48 hours for a new app with no prior rejections. Apple reviews both the app's functionality and its metadata — screenshots, description, and privacy disclosures. Rejections almost always come with an explanation and are fixable.

Common Errors and How to Fix Them

Error: "No profiles for [bundle identifier] were found"

Cause: The bundle identifier in Unity Player Settings does not match what is registered in the Apple Developer portal, or no provisioning profile exists for this identifier.

Fix: Confirm the bundle identifier matches exactly — including case — across Unity, Xcode, and the Apple Developer portal. If using automatic signing, let Xcode create the profile. If using manual signing, create the profile at developer.apple.com and download it.

Error: "IL2CPP C++ code builder is unable to build C++ code. In order to build C++ code for Mac, you must have Xcode installed."

Cause: Xcode is installed but its Command Line Tools are not configured, or Xcode is installed in a non-standard location.

Fix: Open Terminal and run sudo xcode-select --switch /Applications/Xcode.app to point the system to the correct Xcode location. Also open Xcode once and accept the license agreement — it is required before any command-line tools work.

Error: Build succeeds but app crashes immediately on device.

Cause: A script or plugin has a runtime error that does not surface in the editor, or a missing capability (like Push Notifications or Camera access) causes an immediate termination.

Fix: Connect the device to Xcode, go to Window > Devices and Simulators, select your device, and open the device log while reproducing the crash. The actual exception appears there. For missing capabilities, add them under Signing & Capabilities in the Xcode project.

Error: "Untrusted Developer" when opening the app on device.

Cause: The signing certificate is from a free Apple ID and has not been trusted on this device yet.

Fix: On the iPhone, go to Settings > General > VPN & Device Management, find your Apple ID under Developer App, and tap Trust.

Error: App Store submission rejected for privacy reasons.

Cause: The app uses a system API (camera, microphone, location, contacts) without including the corresponding privacy usage description string in Player Settings, or without declaring data collection in App Store Connect's privacy nutrition label.

Fix: In Unity Player Settings > Other Settings, fill in every usage description string for APIs your app uses. In App Store Connect, complete the App Privacy section accurately before submission. Apple's rejections here are specific — they tell you exactly which API triggered the issue.



iOS vs Android Build: Key Differences

Area iOS Android
Build machine requirement Mac required for local builds Windows, Mac, or Linux
Build output Xcode project, then .ipa via Xcode APK or AAB directly from Unity
Scripting backend IL2CPP only — Mono not supported Mono for dev, IL2CPP for release
Signing for device testing Free Apple ID, 7-day certificate Debug keystore auto-generated, no expiry
Store distribution fee $99/year Apple Developer Program $25 one-time Google Play fee
Review process Manual review, 24-48 hours typical Largely automated, hours to days
Primary graphics API Metal (Apple's API, only option) Vulkan or OpenGL ES

Best Practices

  • Set the bundle identifier before your first build. Changing it later means updating it in Unity, Xcode, and the Apple Developer portal simultaneously — missing any one causes signing failures.
  • Use automatic signing in Xcode during development. Switch to manual signing only when you need specific provisioning profiles for distribution.
  • Test on at least two physical devices before App Store submission — an older model and a current one. Performance that looks fine on an iPhone 15 can be unacceptable on an iPhone XR that your players still use.
  • Archive builds in Xcode using the Any iOS Device (arm64) target, not a connected device. Archiving to a specific device creates a build that cannot be distributed.
  • Use TestFlight for beta testing before App Store submission. It finds real-device bugs that nothing else catches.
  • Fill in all privacy usage description strings in Player Settings before building. Missing them causes App Store rejection, and adding them requires a full rebuild and resubmission.
  • Keep your Apple Developer certificates backed up. Certificate expiration mid-submission cycle is a preventable headache.

What Comes Next

Getting the build pipeline working is the foundation. Once you have a device build running, the next iOS-specific considerations are performance profiling using Xcode's Instruments tool (far more detailed than Unity's Profiler for GPU-side issues on Metal), implementing iOS-specific features like Game Center achievements and leaderboards through Unity's Services, and setting up automatic builds using Unity Build Automation or a CI system like GitHub Actions so you are not manually triggering Xcode builds every time you need a test build.

The Mobile Optimization guide from this series covers the Unity-side performance work. The GitHub Actions guide teased at the end of the Git tutorial covers the automation side. Both are worth reading once this build pipeline is stable.

Next Topics To Learn

How to Use ElevenLabs for Game Development: AI Voice Acting, NPC Dialogue, and Sound Design

Most indie games ship without voice acting. Not because developers do not want it, but because hiring voice actors is expensive, scheduling ...