Production Recovery / Build Pipeline

Unity IL2CPP Build and Crash Recovery

An IL2CPP build failure is not a single class of defect. Compiler toolchain problems, native plug-ins, managed stripping, AOT constraints and platform-specific API behavior require different investigation paths.

Best forTeams blocked by a failed CI build, player startup crash, native exception or IL2CPP-only regression.
DeliverableA reproducible failure signature, isolated cause, corrected build path and documented regression test.
What we do not promiseA successful Editor Play Mode run is not proof that a target IL2CPP player is stable.

Classify the failing stage before modifying source code

We distinguish import/asset processing failures, managed compilation, IL2CPP conversion, native compiler/linker errors, packaging, launch and runtime faults. A stack trace at startup may come from the first invoked native plugin; a linker error may be an unsupported architecture; a stripped method can fail only after an optimized build starts.

Failure pointPrimary evidenceCommon cause family
C# compile before conversionCompiler messages and assembly definitionsInvalid API use, conditional compilation, package version
IL2CPP conversion or native linkEditor log, build output, symbol names and target toolchainAOT/generic constraints, duplicate symbols, unsupported plugin binaries
Startup on deviceCrash logs, first managed/native stack, initialization orderNative plug-in load, missing asset, static initialization
Runtime crash under loadSymbolicated call stack, scene and input sequenceLifetime fault, native bridge, race, unsafe code
Only Release/stripped build failsLinker output, managed stripping settings, reflection usageMissing preserved types or dynamically invoked code

Minimal reproducible build investigation

  1. Capture exact Unity editor and package versions, IL2CPP target, architecture, build options and CI environment.
  2. Freeze a failing commit and keep the full editor/build logs, not a screenshot of the last error line.
  3. Identify first causal failure in the chain. Secondary errors often cascade after one missing symbol or incompatible package.
  4. Compare Mono and IL2CPP only where supported, without assuming the difference automatically identifies an AOT bug.
  5. Temporarily isolate the smallest plugin, assembly or scene to reproduce the failure while preserving a rollback branch.
  6. Fix the root dependency or code path and re-run the original CI/player scenario on every affected target.

For reflection-heavy serialization or dynamically loaded types, investigate linker preservation and code stripping with the project's actual build requirements. Disabling stripping globally may hide a defect but can create size and maintainability costs. Treat that as a diagnostic experiment, not the final architecture.

Native plug-ins, interop and architecture edges

Native/managed boundaries deserve careful scrutiny. P/Invoke signatures, calling conventions, pointer ownership, memory pinning, structure layout and 32/64-bit assumptions can all fail at runtime in ways that do not resemble ordinary C# exceptions. A mismatch may appear platform-specific because the native binary, compiler settings or runtime representation differs.

Where a crash originates outside symbols available to us, we distinguish known facts from an unverified hypothesis. Symbolication, native debug information and a reliable crash repro can be prerequisites. We do not promise to fix a closed-source plug-in with no diagnostic access.

Managed stripping

Verify preserved types, reflection paths and serialized factories against the actual optimized build.

AOT and generics

Review dynamic code generation assumptions and combinations instantiated only at runtime.

Library compatibility

Check architecture, importer platform flags, plugin dependencies and vendor-provided binaries.

Initialization timing

Investigate scene boot, service registration, async initialization and the order of native plug-in setup.

Stabilize the build pipeline, not only one local machine

A recovery is incomplete if the build runs on a developer's workstation but fails in CI. We record required environment variables, installed modules, target SDK tooling and build steps without checking secrets into version control. The goal is reproducibility with the least environment-specific state.

  1. Create a known-good build manifest and lock the relevant package versions.
  2. Apply small isolated changes that preserve asset references and scene integrity.
  3. Run the original failing scenario plus clean-build and incremental-build checks.
  4. Verify startup, critical gameplay flows, scene transitions and quitting on target device.
  5. Document what remains dependent on unavailable vendor symbols, confidential SDKs or external infrastructure.

Where a crash fix changes serialization, script execution or platform defines, regression tests must cover save compatibility and gameplay behavior as well as boot success.

What is delivered

The agreed handoff includes a root-cause note, changed scripts or configuration, CI/build instructions, log signatures that should disappear, an exact verification scenario and any remaining environment constraints. If the problem is in a vendor package, we can document a safe workaround or actionable bug report rather than silently patching unsupported binaries.

We can start with a triage-only milestone when the codebase is large or the suspected failure requires access not yet provided.

Send us the blocker

Provide Unity version, full Editor.log/build log, console output or crash dump, exact platform/architecture and the last known good commit. State whether the build fails deterministically or only under a particular gameplay sequence. This determines the investigation scope and whether native toolchain access is required.

What you receive

Capture manifest

A record of device, scene route, build hash and profiling configuration so the measurements can be reproduced by your team.

Bottleneck register

The top issues ranked by player impact, estimated fix risk, dependency and confidence in the diagnosis.

Before/after protocol

A repeatable test definition and acceptance criteria for each proposed fix, not an unexplained FPS screenshot.

Delivery roadmap

A practical order for high-confidence corrections, investigations requiring more data and architectural work needing a larger milestone.

An audit is distinct from a full optimization implementation. If you want us to carry out the fixes, we can agree a second milestone based on what the measurements actually reveal.

How this connects to production visuals

Rendering optimizations cannot be evaluated independently of the game's presentation. A replay camera needs believable shadows, a hero weapon needs high-fidelity surface response, and an outdoor environment needs sufficient depth to preserve visibility. Our background in Unity presentation and optimization makes those visual constraints part of the acceptance review rather than an afterthought.

See our Lacrosse 26 contribution for a real example of the kind of scene-presentation work Fyros has performed. This page does not claim a specific measured improvement from that project.

What we need from your team

Provide a player build or source access, target device list, a repeatable performance complaint, the frame-rate and image-quality requirements, and the next release milestone. If you already have captures, include them even if they are incomplete.

For private console hardware or SDK-dependent problems, all access remains subject to the platform holder's developer program and the client's authorization. The first conversation establishes whether a review is viable and what access is required.

Engagement and acceptance criteria

A focused engagement starts with a problem statement and ends with work your team can test. We agree on scope, deliverables, review milestones, data access and acceptance criteria before implementation. Outcome depends on the state of the project and measured constraints.

For a technical assessment or delivery proposal, describe your current build, Unity version, target platforms, exact reproduction steps, deadline and what a successful outcome would look like. You can engage Fyros for a defined milestone without committing to full-cycle development.
REQUEST A TECHNICAL ENGAGEMENT

Questions production teams ask

Does IL2CPP cause all native crashes?

No. A crash may arise in native plugins, unsafe code, initialization or platform integration. The failing stage and stack trace must be isolated.

Can you diagnose failures that occur only in Release?

A scoped investigation can compare stripping, AOT behavior, optimization and deployment settings while preserving production constraints.

Will you disable code stripping to make the build work?

Only as a diagnostic experiment when justified. We aim to address the actual preservation or compatibility issue.

Can you fix a crash without a reproducible case?

Investigation is possible with logs and dumps, but confidence and estimated effort improve dramatically with reliable reproduction.

Technical references and further reading

Relevant vendor documentation for validating version-specific behavior. These links are references, not claims of a measured result from an undisclosed project.

Unity project rescue | Request a technical review

Explore other specialist Unity engagements or learn about co-development for active productions.

Get the problem fixed, not just diagnosed

Fyros Games Studio works with studios and publishers on scoped Unity engineering, rendering, optimization and production tasks. Share the technical blocker and we will discuss a measurable work package.

TALK TO FYROS