Separate a Unity failure into the stage where it happens: project import or Editor compilation, Player build, Player launch, or gameplay after launch. Then capture the first relevant error, verify the exact Editor version and target, and test that stage directly. A build that completes but will not launch needs a different investigation from a build that never finishes.
First, identify which stage is failing
Unity’s Build command creates a Player. Build and Run creates it and then opens it on the selected target. That distinction gives you a useful first test: if Build succeeds but Build and Run fails, focus on launching the Player and the target environment; if Build itself fails, start with the Editor’s build output and configuration.
- Project import or Editor compile: Does the project open, and do scripts compile without errors?
- Player build: Does the build process complete and produce a Player?
- Player launch: Does the generated Player start on the selected device, computer, or browser?
- Runtime behavior: Does it launch but crash, behave incorrectly, or run poorly?
Before changing code or upgrading Unity, write down the Unity Editor version, target platform, whether the Editor opens the project, the failing stage, and the first relevant error with the surrounding log context. Without those details, a specific fix would be guesswork.
Check version, machine, and target support
Verify requirements for the exact Editor version
Unity documents Editor requirements separately from the requirements for a built Player. Check the page for the Unity version you actually use and the platform you are targeting; requirements for one release should not be treated as universal. For example, Unity’s Unity 6.0 system requirements list Windows 10 version 21H1 (build 19043) or newer for the Windows Editor, macOS Big Sur 11 or newer for the macOS Editor, and Ubuntu 22.04 or 24.04 for Linux Editor use. The same page recommends at least 8 GB of RAM for the Unity 6.0 Editor and notes that project size and complexity can require more.
#1 Best Overall
Confirm the build support module is installed
If the target platform’s build support is missing, the Platform Browser identifies that state and offers an installation route through Unity Hub. Install the matching module, then restart the Editor. Check the documentation for your specific Unity version and target for additional SDK or toolchain requirements; installing Unity’s module alone does not establish that every external target prerequisite is satisfied.
Check scenes and build configuration
Open the Build Settings window and verify the selected target and the scenes that will be included:
- Make sure the intended scenes appear under Scenes in Build and are enabled.
- If the list is empty, add the open scenes using the controls in the window.
- Review target-specific options against the platform you intend to build for.
These checks catch configuration problems before you investigate unrelated runtime behavior. Use Build to determine whether Unity can produce the Player; use Build and Run when you also need to test whether that Player starts on the chosen target.
Find the log that corresponds to the failure
Start with the first relevant error, not just the last line shown after a failure. Preserve nearby messages and the full output where possible: a final error can be a consequence of an earlier one.
Editor and Unity tooling
The Console can open the Editor log. Unity also documents separate logs for the Package Manager, licensing, development Players, and Unity Hub. Use the log for the component or stage that failed rather than assuming every error is recorded in the Console.
Unity’s log file documentation describes the relevant log types and locations. For a Windows Player, the log is under the user’s AppDataLocalLowCompanyNameProductNamePlayer.log path. macOS and Linux Players have their own user log locations.
Rank #4
Player logs on Android and WebGL
- Android: Read runtime output in
logcat. - WebGL: Read runtime output in the browser’s JavaScript console.
A successful Editor build does not guarantee that a target Player will start. When launch fails, the target’s runtime log may show a problem that the Editor build output cannot.
Reproduce the build consistently
If you need to compare repeated builds or remove variation from a manual workflow, Unity documents command-line builds. Its command-line arguments documentation identifies -projectPath and -quit as required arguments for a command-line build, and recommends -batchmode, -logFile, and either -buildTarget or -activeBuildProfile.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Best Value
Use the target configuration that matches the failing build and save the log. This makes it easier to compare runs and see whether the same failure reproduces outside the usual Editor workflow. A command-line build is a way to reproduce and capture a failure, not a fix for it.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Test Editor logic separately from target behavior
Unity’s Test Framework supports Edit Mode and Play Mode tests. They answer different questions, and neither should be mistaken for proof that a built Player works on its intended target.
| Test | What it helps check | What it does not establish on its own |
|---|---|---|
| Edit Mode | Code behavior that can be verified in the Editor. | That runtime behavior or a target Player launches correctly. |
| Play Mode | Runtime behavior exercised in the Editor. | That the selected platform’s Player works in its target environment. |
| Target Player | Whether the built game behaves on the intended platform or device. | It does not replace focused tests of individual code behavior. |
The Unity Test Framework package reference covers Edit Mode and Play Mode testing. Make sure test assemblies reference the code under test and the required test assemblies; setup details depend on the project’s Editor and package versions. If the failure may depend on the target environment, run the Player on that target as well. A green Editor test alone cannot establish that the target build launches correctly.
Profile only after the Player runs
If the game launches but performs poorly, treat that as a runtime performance problem rather than a build failure. Unity’s Profiler documentation describes attaching the Profiler to a running Player built with Development Build enabled. Profiling can help investigate performance after launch; it will not diagnose a build that never completes.
Recommended Free Tools
Choose the next check from the evidence
Use the failing stage, target platform, Unity version, error source, and whether the issue reproduces in a command-line build to narrow the next investigation. The exact fix cannot be determined without the project’s version, target, complete error output, and relevant Editor or Player logs. Requirements, package behavior, SDK needs, and menu labels can change, so verify instructions against documentation for the precise Editor version in use.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
