The iOS project builds on your Windows or Linux machine, but signing and archiving stop when the workflow reaches Xcode.
Fastest route: let Unity generate the iOS Xcode project, transfer a complete and secure working copy to macOS, then use Xcode to configure signing, build, archive, and validate it. Treat upload acceptance and App Store review as separate outcomes.
This guide is for you if you develop a Unity 6.6 game without a local Mac and need to prepare an iOS release.
It also covers small teams moving a manual Unity build into a repeatable remote Mac process.
Start by confirming what Unity exports
Unity’s iOS workflow has two distinct stages: Unity generates an Xcode project, then Xcode builds the native project. The final Xcode build requires macOS; exporting the project does not perform the later signing and archiving work for you. Check the Unity 6.6 iOS environment setup and Unity’s iOS build and delivery workflow for the documented process.
Before exporting, make release decisions that will carry through to Xcode:
- Confirm the intended iOS device target and release purpose, such as testing or distribution.
- Set the Bundle Identifier you intend to use for the app. Avoid changing it casually between export and signing.
- Review the Unity iOS build settings, including the project’s version and build values, and record what you selected. The Unity 6.6 iOS build settings reference describes the relevant settings.
- List native plugins, custom source files, and build scripts that the exported project depends on. A project that relies on native code needs those dependencies available on the remote Mac too.
- Confirm that your project’s Unity version and intended Xcode version are supported by the documentation for the specific releases you will use. Do not assume that every plugin or project configuration works with every toolchain combination.
Unity 6.6 is documented as release 6000.6 in Unity’s versioned manual. That identifies the documentation set; it does not guarantee compatibility for your specific Xcode version, plugin mix, or signing setup. Verify those against the relevant official guidance and a build of your project.
Decision branches before export
- If the project uses only managed assets and its required configuration is captured in the project, export and prepare to transfer that project.
- If it includes native plugins, CocoaPods, custom scripts, or generated files, first identify how each dependency is restored or generated. Reproduce that step on the remote Mac before treating the export as ready.
- If you cannot identify a dependency’s setup instructions, stop before signing. Find its official instructions or reproduce the project’s setup successfully rather than guessing at the remote build.
Prepare a complete, reproducible transfer
An exported Xcode project is more than a single .xcodeproj file. Unity’s Xcode project structure documentation describes the project structure. Use it to understand what Unity generates, then include the files your own project and plugins require.
Create a consistent copy using version control or a secure file-transfer method. For a repository-based workflow, commit the project changes you need, then check out the intended revision on the remote Mac. For a direct transfer, copy the complete exported folder and verify that the transfer finished before opening it. In either case, keep a record of the revision or exported project that you are building.
Do not put signing private keys or certificate files into a source repository just to make transfer easier. Apple describes certificate types and their protection in its certificate overview. Arrange access to signing material separately, use only the credentials needed for the task, and follow your team’s security process. If you need to understand how VPSOmni handles service information, review its data privacy information before moving project data.
On the remote Mac, check that the transferred project is intact before changing signing settings. Look for the expected Xcode project or workspace, Unity-generated source and resources, plugin files, and any configuration that your build scripts expect. If the project uses a dependency manager or a custom preparation script, follow that dependency’s own instructions and record what was run. Do not assume that a missing file will be recreated automatically.
A quick inventory can help you catch a partial transfer:
find "YourExportFolder" -maxdepth 2 -type f | sort
This is only a file listing, not a Unity validation command. Compare the result with the project structure and the files your build depends on. If the project has deeper folders or custom dependencies, inspect those too.
Check Xcode and native dependencies on the remote Mac
Open the project or workspace that matches its dependency setup. A project that integrates native dependencies through a generated workspace may need that workspace opened instead of the project file. Use the dependency’s documentation and the project’s actual generated files to decide; do not switch between them by trial and error during release signing.
Record the installed Xcode version and inspect the available project schemes:
xcodebuild -version
xcodebuild -list -project "Unity-iPhone.xcodeproj"
The output is specific to the Mac and project you are using. The scheme shown here is an example name only; use the scheme that xcodebuild -list reports for your export. If your project is opened through a workspace, inspect that workspace instead:
xcodebuild -list -workspace "YourProject.xcworkspace"
Before proceeding, establish that Xcode opens the intended project, dependencies resolve as expected, and the required target and scheme are present. If the project uses CocoaPods, a native plugin, or a custom build script, use its official instructions or reproduce the setup from the project’s own build process. Do not invent a compatibility rule based only on the Unity version number.
A useful checkpoint is a successful build before you introduce release-specific signing changes. It helps separate a missing dependency or compile error from a later signing failure. Save the build log and note the project revision and toolchain used; that evidence makes it easier to reproduce the result if the final archive fails.
Match signing settings before the release build
Signing involves several pieces that must agree: the app identifier, the selected team, the signing certificate, the provisioning profile where applicable, and the entitlements required by the app. Unity project settings help define the exported app, but Xcode’s target and configuration also matter. Check both.
Apple’s guidance for a development provisioning profile explains that profiles are tied to the app and signing setup they authorize. For distribution, follow the configuration and signing requirements for your intended distribution method. Apple’s Xcode distribution preparation documentation is the relevant reference for checking a project before distribution.
In Xcode, inspect the target used by the app and the build configuration you intend to archive. Confirm that:
- The Bundle Identifier matches the identifier expected by the signing setup.
- The selected team is the team authorized to sign this app.
- The certificate and profile are valid for the chosen build purpose.
- The app’s entitlements match the capabilities configured for the app.
- Any extension or additional target has its own appropriate signing configuration.
- The version and build values match the release record you are preparing.
Do not confuse an App Store Connect API key with code-signing credentials. An API key may authorize certain App Store Connect operations, but it does not replace the certificate and provisioning setup used to sign an app. Never paste real private keys, passwords, or certificate contents into a tutorial, build log, or source file.
If you use automatic signing, verify that Xcode has the account access and configuration required to manage signing for the intended target. If you use manual signing, confirm that the selected profile and certificate match the app’s identifier and entitlements. Apple’s documentation is the authority for the applicable signing behavior; your project’s actual target settings determine what is configured.
Choose the next action based on what you find
- If the app identifier, team, profile, certificate, and entitlements agree, run a representative build and move to archiving.
- If the project compiles but reports a signing error, stop and correct the specific target or credential mismatch. Do not repeatedly change unrelated settings.
- If a plugin adds capabilities or targets, review those additions before continuing. A signing setup that works for the main app target may not cover every target in the project.
Build and archive, then diagnose by stage
Once the project and signing setup are ready, build using the scheme and configuration you verified. For a project that supports command-line archiving, a command can look like this:
xcodebuild \
-project "Unity-iPhone.xcodeproj" \
-scheme "YourVerifiedScheme" \
-configuration "Release" \
-destination "generic/platform=iOS" \
-archivePath "$PWD/build/YourGame.xcarchive" \
archive
This is a template, not a universal command. Replace the project path, scheme, configuration, and archive location with values confirmed for your project. Use -workspace instead of -project if the project’s dependency setup requires a workspace. If your team uses Xcode’s interface for archiving, select the same intended target and configuration there. Apple documents the Xcode archive and distribution workflow.
When an archive fails, locate the first meaningful error and classify it before making changes:
- Unity export or missing-file failure: check that the complete exported project and required native files reached the Mac.
- Dependency or compile failure: check the project’s dependency setup, plugin instructions, and selected Xcode toolchain.
- Signing failure: check the affected target’s identifier, team, certificate, profile, and entitlements.
- Archive or distribution failure: inspect the selected scheme and configuration, then use Xcode’s reported validation details to identify what is missing.
Save the full build log, the project revision, the Xcode version, and the relevant build settings with the result. These records let you distinguish a repeatable configuration problem from a one-off transfer or environment issue. A “build succeeded” line only confirms the operation that produced it; it is not proof that the archive is valid for your intended distribution.
Validate the archive before you upload
Open the archive in Xcode Organizer and inspect its app identity and signing information. Run the validation available for the distribution method you intend to use. Resolve any reported issue before uploading instead of assuming that a successful archive will pass the next check.
Check the release details against the task you are preparing: Bundle Identifier, version, build value, selected signing setup, and any required entitlements. Keep the archive associated with the source revision and build record you saved earlier. If the archive does not match the intended release, create a corrected build rather than relying on an informal note to explain the mismatch later.
After upload, verify the build’s status in App Store Connect. Apple’s build and metadata status guidance explains where to review uploaded builds. Upload completion, processing status, and review outcome are separate checkpoints. Do not tell your team that a release is ready merely because Xcode created an archive or completed an upload.
For team handoff, provide the archive location, source revision, Xcode version, signing method used, validation result, and App Store Connect status. Share only the information teammates need to continue the release process; do not include secret signing material in a handoff note.
If you are setting up access for a new remote Mac, VPSOmni’s onboarding guide can help you review the service access process. Confirm that the Mac environment and access method fit your project before starting a release build.
Frequently asked questions
How do I transfer a Unity 6.6 iOS project to a remote Mac?
Transfer the complete exported Xcode project and the files your build depends on, including required native plugin code and project-specific configuration. Use a version-controlled checkout or secure file transfer to create a consistent working copy. Keep signing certificates and private keys out of the repository; arrange signing access separately on the Mac, then confirm the copied project opens and resolves its dependencies.
How do I create an iOS archive after Unity exports the Xcode project?
Open the exported project or its workspace in Xcode, based on how its native dependencies are integrated. Confirm the active scheme and build configuration, resolve the project’s dependencies, then use Xcode’s archive workflow for the intended distribution method. Treat the archive as a build artifact to inspect. It does not prove App Store Connect has accepted an upload or that the app has passed review.
Which signing settings should I check for a remote Mac build?
Check that the Bundle Identifier matches the signing setup, the intended development team is selected, and the certificate and provisioning profile support the target and its entitlements. Inspect the relevant Xcode target and configuration rather than relying only on Unity settings. An App Store Connect API key is not a code-signing credential, and private keys should not be included in the project repository.
How do I confirm a Unity iOS archive is ready for App Store Connect?
Inspect the archive in Xcode Organizer and run the validation available for your distribution method. Compare the app identity, version and build values, signing information, and entitlements with the release you intend to prepare. After upload, check the build’s processing status in App Store Connect. Archive creation, upload completion, processing, approval, and release are distinct steps.
If you currently depend on a Windows or Linux machine alone, you cannot complete the final Xcode build there; borrowing a Mac can also make release work dependent on another person’s availability, credentials, and environment consistency. A remote Mac gives you a dedicated macOS place to run Xcode and retain the build artifacts without adding a Mac purchase to a short release task. If you only need a temporary build or validation environment, compare your project’s Xcode, dependency, signing, and access requirements with the VPSOmni Mac options before choosing. For a long-running workload that needs physical peripherals or continuous local access, owning a Mac may be the better fit.
Frequently asked questions
How do I transfer a Unity 6.6 iOS project to a remote Mac?
Transfer the complete exported Xcode project and the files your build depends on, including any required native plugin code and project-specific configuration. Use a version-controlled checkout or secure file transfer to create a consistent working copy. Keep signing certificates and private keys out of the repository; provision signing access separately on the Mac and confirm the copied project opens as expected.
How do I create an iOS archive after Unity exports the Xcode project?
Open the exported project or its workspace in Xcode, depending on how your native dependencies are integrated. Confirm the active scheme and build configuration, resolve required dependencies, then use Xcode’s archive workflow for the intended iOS distribution target. An archive is a build artifact to inspect; it does not by itself mean that App Store Connect has accepted the upload or that the app has passed review.
Which signing settings should I check when building Unity for iOS on a remote Mac?
Check that the app’s Bundle Identifier matches the identifier used by the signing setup, that the intended development team is selected, and that the certificate and provisioning profile support the target build and its entitlements. Also inspect the relevant Xcode target and configuration rather than assuming Unity’s project settings alone control signing. Never treat an App Store Connect API key as a code-signing certificate or private key.
How can I tell whether a Unity iOS archive is ready to upload to App Store Connect?
Inspect the archive in Xcode Organizer and run the validation available for your distribution method. Confirm the app identity, version and build values, signing details, and entitlements against the release you intend to prepare. After upload, check the build’s processing status in App Store Connect. A successful local archive or upload is not the same as processing completion, approval, or release.
Sign and Archive Your Unity iOS Build on VPSOmni
Bring your exported Xcode project to VPSOmni and sign and archive it on a dedicated physical Mac.
Rent a Remote Mac