Xamarin.iOS errors

Article
03/06/2018

MT0xxx: mtouch error messages

E.g. parameters, environment, missing tools.

MT0000: Unexpected error - Please fill a bug report at https://github.com/xamarin/xamarin-macios/issues/new

An unexpected error condition occurred. Please file a new issue on GitHub with as much information as possible, including:

Full build logs, with maximum verbosity (e.g. -v -v -v -v in the Additional mtouch arguments);
A minimal test case that reproduce the error; and
All version informations

The easiest way to get exact version information is to use the Visual Studio for Mac menu, About Visual Studio for Mac item, Show Details button and copy/paste the version informations (you can use the Copy Information button).

MT0001: '-devname' was provided without any device-specific action

This is a warning that is emitted if -devname is passed to mtouch when no device-specific action (-logdev/-installdev/-killdev/-launchdev/-listapps) was requested.

MT0002: Could not parse the environment variable *.

This error happens if you try to set an invalid environment key=value variable pair. The correct format is: mtouch --setenv=VARIABLE=VALUE

MT0003: Application name '*.exe' conflicts with an SDK or product assembly (.dll) name.

The executable assembly's name and the application's name can't match the name of any dll in the app. Please modify the name of your executable.

MT0004: New refcounting logic requires SGen to be enabled too.

If you enable the refcounting extension you must also enable the SGen garbage collector in the project's iOS Build options (Advanced tab).

Starting with Xamarin.iOS 7.2.1 this requirement has been lifted, the new refcounting logic can be enabled with both Boehm and SGen Garbage Collectors.

MT0005: The output directory * does not exist.

Please create the directory.

This error is not generated anymore, mtouch will automatically create the directory if it doesn't exist.

MT0006: There is no devel platform at *, use --platform=PLAT to specify the SDK.

Xamarin.iOS cannot find the SDK directory at the location mentioned in the error message. Please verify that the path is correct.

MT0007: The root assembly * does not exist.

Xamarin.iOS cannot find the assembly at the location mentioned in the error message. Please verify that the path is correct.

MT0008: You should provide one root assembly only, found # assemblies: *.

More than one root assembly was passed to mtouch, while there can be only one root assembly.

MT0009: Error while loading assemblies: *.

An error occurred while loading the assemblies from the root assembly references. More information may be provided in the build output.

MT0010: Could not parse the command line arguments: *.

An error occurred while parsing the command line arguments. Please verify that they are all correct.

MT0011: * was built against a more recent runtime (*) than MonoTouch supports.

This warning is typically reported because the project has a reference to a class library that was not built using the Xamarin.iOS BCL.

The same way an app using the .NET 4.0 SDK may not work on a system only supporting .NET 2.0, a library built using .NET 4.0 may not work on Xamarin.iOS, it may use API not present on Xamarin.iOS.

The general solution is to build the library as a Xamarin.iOS Class Library. This can be accomplished by creating a new Xamarin.iOS Class Library project and add all the source files to it. If you do not have the source code for the library, you should contact the vendor and request that they provide a Xamarin.iOS-compatible version of their library.

MT0012: Incomplete data is provided to complete *.

This error is not reported anymore in the current version of Xamarin.iOS.

MT0013: Profiling support requires sgen to be enabled too.

SGen (--sgen) must be enabled if profiling (--profiling) is enabled.

MT0014: The iOS * SDK does not support building applications targeting *.

This can happen in the following circumstances:

ARMv6 is enabled and Xcode 4.5 or later is installed.
ARMv7s is enabled and Xcode 4.4 or earlier is installed.

Please verify that the installed version of Xcode supports the selected architectures.

MT0015: Invalid ABI: *. Supported ABIs are: i386, x86_64, armv7, armv7+llvm, armv7+llvm+thumb2, armv7s, armv7s+llvm, armv7s+llvm+thumb2, arm64 and arm64+llvm.

An invalid ABI was passed to mtouch. Please specify a valid ABI.

MT0016: The option * has been deprecated.

The mentioned mtouch option has been deprecated and will be ignored.

MT0017: You should provide a root assembly.

It is required to specify a root assembly (typically the main executable) when building an app.

MT0018: Unknown command line argument: *.

Mtouch does not recognize the command line argument mentioned in the error message.

MT0019: Only one --[log|install|kill|launch]dev or --[launch|debug]sim option can be used.

There are several options for mtouch that can't be used simultaneously:

--logdev
--installdev
--killdev
--launchdev
--launchdebug
--launchsim

MT0020: The valid options for '' are ''.

MT0021: Cannot compile using gcc/g++ (--use-gcc) when using the static registrar (this is the default when compiling for device). Either remove the --use-gcc flag or use the dynamic registrar (--registrar:dynamic).

MT0022: The options '--unsupported--enable-generics-in-registrar' and '--registrar' are not compatible.

Remove both the options --unsupported--enable-generics-in-registrar and --registrar. Starting with Xamarin.iOS 7.2.1 the default registrar supports generics.

This error is no longer shown (the command-line argument --unsupported--enable-generics-in-registrar has been removed from mtouch).

MT0023: Application name '*.exe' conflicts with another user assembly.

The executable assembly's name and the application's name can't match the name of any dll in the app. Please modify the name of your executable.

MT0024: Could not find required file '*'.

MT0025: No SDK version was provided. Please add `--sdk=X.Y` to specify which iOS SDK should be used to build your application.

MT0026: Could not parse the command line argument '':

MT0027: The options '' and '' are not compatible.

MT0028: Cannot enable PIE (-pie) when targeting iOS 4.1 or earlier. Please disable PIE (-pie:false) or set the deployment target to at least iOS 4.2

MT0029: REPL (--enable-repl) is only supported in the simulator (--sim).

REPL is only supported if you're building for the simulator. This means that if you pass --enable-repl to mtouch, you must also pass --sim.

MT0030: The executable name () and the app name () are different, this may prevent crash logs from getting symbolicated properly.

When Xcode symbolicates (translates memory addresses to function names and file/line numbers) the process may fail if the executable and app have different names (without the extension).

To fix this either change 'Application Name' in the project's Build/iOS Application options, or change 'Assembly Name' in the project's Build/Output options.

MT0031: The command line arguments '--enable-background-fetch' and '--launch-for-background-fetch' require '--launchsim' too.

MT0032: The option '--debugtrack' is ignored unless '--debug' is also specified.

MT0033: A Xamarin.iOS project must reference either monotouch.dll or Xamarin.iOS.dll

MT0034: Cannot include both 'monotouch.dll' and 'Xamarin.iOS.dll' in the same Xamarin.iOS project - '' is referenced explicitly, while '' is referenced by '*'.

MT0036: Cannot launch a * simulator for a * app. Please enable the correct architecture(s) in your project's iOS Build options (Advanced page).

MT0037: monotouch.dll is not 64-bit compatible. Either reference Xamarin.iOS.dll, or do not build for a 64-bit architecture (ARM64 and/or x86_64).

MT0038: The old registrars (--registrar:oldstatic|olddynamic) are not supported when referencing Xamarin.iOS.dll.

MT0039: Applications targeting ARMv6 cannot reference Xamarin.iOS.dll.

MT0040: Could not find the assembly '', referenced by ''.

MT0041: Cannot reference both 'monotouch.dll' and 'Xamarin.iOS.dll'.

MT0042: No reference to either monotouch.dll or Xamarin.iOS.dll was found. A reference to monotouch.dll will be added.

MT0043: The Boehm garbage collector is currently not supported when referencing 'Xamarin.iOS.dll'. The SGen garbage collector has been selected instead.

Only the SGen garbage collector is supported with Unified projects. Ensure there are no additional mtouch flags specifying Boehm as the garbage collector.

MT0044: --listsim is only supported with Xcode 6.0 or later.

Install a newer Xcode version.

MT0045: --extension is only supported when using the iOS 8.0 (or later) SDK.

MT0047: The minimum deployment target for Unified applications is 5.1.1, the current deployment target is '*'. Please select a newer deployment target in your project's iOS Application options.

MT0049: .framework is supported only if deployment target is 8.0 or later. features might not work correctly.

The specified framework is not supported in the iOS version the deployment target refers to. Either update the deployment target to a newer iOS version, or remove usage of the specified framework from the app.

MT0051: Xamarin.iOS * requires Xcode 5.0 or later. The current Xcode version (found in ) is .

Install a newer Xcode.

MT0052: No command specified.

No action was specified for mtouch.

MT0054: Unable to canonicalize the path '':

This is an internal error. If you see this error, please file a new issue on github.

MT0055: The Xcode path '*' does not exist.

The Xcode path passed using --sdkroot does not exist. Please specify a valid path.

MT0056: Cannot find Xcode in the default location (/Applications/Xcode.app). Please install Xcode, or pass a custom path using --sdkroot <path>.

MT0057: Cannot determine the path to Xcode.app from the sdk root '*'. Please specify the full path to the Xcode.app bundle.

The path passed using --sdkroot does not specify a valid Xcode app. Please specify a path to an Xcode app.

MT0058: The Xcode.app '' is invalid (the file '' does not exist).

The path passed using --sdkroot does not specify a valid Xcode app. Please specify a path to an Xcode app.

MT0059: Could not find the currently selected Xcode on the system: *

MT0060: Could not find the currently selected Xcode on the system. 'xcode-select --print-path' returned '*', but that directory does not exist.

MT0061: No Xcode.app specified (using --sdkroot), using the system Xcode as reported by 'xcode-select --print-path': *

This is a informational warning, explaining which Xcode will be used, since none was specified.

MT0062: No Xcode.app specified (using --sdkroot or 'xcode-select --print-path'), using the default Xcode instead: *

This is a informational warning, explaining which Xcode will be used, since none was specified.

MT0063: Cannot find the executable in the extension * (no CFBundleExecutable entry in its Info.plist)

Every Info.plist must have an executable (using the CFBundleExecutable entry), however an entry should be generated automatically during the build.

This usually indicates a bug in Xamarin.iOS; please file a new issue on github with a test case.

MT0064: Xamarin.iOS only supports embedded frameworks with Unified projects.

Xamarin.iOS only supports embedded frameworks when using the Unified API; please update your project to use the Unified API.

MT0065: Xamarin.iOS only supports embedded frameworks when deployment target is at least 8.0 (current deployment target: * embedded frameworks: *)

Xamarin.iOS only supports embedded frameworks when the deployment target is at least 8.0 (because earlier versions of iOS does not support embedded frameworks).

Please update the deployment target in the project's Info.plist to 8.0 or higher.

MT0066: Invalid build registrar assembly: *

This usually indicates a bug in Xamarin.iOS; please file a new issue on github with a test case.

MT0067: Invalid registrar: *

This usually indicates a bug in Xamarin.iOS; please file a new issue on github with a test case.

MT0068: Invalid value for target framework: *.

An invalid target framework was passed using the --target-framework argument. Please specify a valid target framework.

MT0070: Invalid target framework: . Valid target frameworks are: .

An invalid target framework was passed using the --target-framework argument. Please specify a valid target framework.

MT0071: Unknown platform: *. This usually indicates a bug in Xamarin.iOS.

This usually indicates a bug in Xamarin.iOS; please file a new issue on github with a test case.

MT0072: Extensions are not supported for the platform '*'.

This usually indicates a bug in Xamarin.iOS; please file a new issue on github with a test case.

MT0073: Xamarin.iOS * does not support a deployment target of * (the minimum is *). Please select a newer deployment target in your project's Info.plist.

The minimum deployment target is the one specified in the error message; please select a newer deployment target in the project's Info.plist.

If updating the deployment target is not possible, then please use an older version of Xamarin.iOS.

MT0074: Xamarin.iOS * does not support a minimum deployment target of * (the maximum is *). Please select an older deployment target in your project's Info.plist or upgrade to a newer version of Xamarin.iOS.

Xamarin.iOS does not support setting the minimum deployment target to a higher version than the version this particular version of Xamarin.iOS was built for.

Please select an older minimum deployment target in the project's Info.plist, or upgrade to a newer version of Xamarin.iOS.

MT0075: Invalid architecture '' for projects. Valid architectures are: *

An invalid architecture was specified. Please verify that architecture is valid.

MT0076: No architecture specified (using the --abi argument). An architecture is required for * projects.

This usually indicates a bug in Xamarin.iOS; please file a new issue on github with a test case.

MT0077: WatchOS projects must be extensions.

This usually indicates a bug in Xamarin.iOS; please file a new issue on github with a test case.

MT0078: Incremental builds are enabled with a deployment target < 8.0 (currently *). This is not supported (the resulting application will not launch on iOS 9), so the deployment target will be set to 8.0.

This is a warning informing that the deployment target has been set to 8.0 for this build so that incremental builds work properly.

Incremental builds are only supported when the deployment target is at least 8.0 (because the resulting application will not launch on iOS 9 otherwise).

MT0079: The recommended Xcode version for Xamarin.iOS * is Xcode * or later. The current Xcode version (found in ) is .

This is a warning informing that the current version of Xcode is not the recommended version of Xcode for this version of Xamarin.iOS.

Please upgrade Xcode to ensure optimal behavior.

MT0080: Disabling NewRefCount, --new-refcount:false, is deprecated.

This is a warning informing that the request to disable the new refcount (--new-refcount:false) has been ignored.

The new refcount feature is now mandatory for all projects, and it's thus not possible to disable anymore.

MT0081: The command line argument --download-crash-report also requires --download-crash-report-to.

MT0082: REPL (--enable-repl) is only supported when linking is not used (--nolink).

MT0083: Asm-only bitcode is not supported on watchOS. Use either --bitcode:marker or --bitcode:full.

MT0084: Bitcode is not supported in the simulator. Do not pass --bitcode when building for the simulator.

MT0085: No reference to '*' was found. It will be added automatically.

MT0086: A target framework (--target-framework) must be specified when building for TVOS or WatchOS.

This indicates a bug in Xamarin.iOS. Please file a new issue on github.

MT0087: Incremental builds (--fastdev) is not supported with the Boehm GC. Incremental builds will be disabled.

MT0088: The GC must be in cooperative mode for watchOS apps. Please remove the --coop:false argument to mtouch.

MT0089: The option '' cannot take the value '' when cooperative mode is enabled for the GC.

MT0091: This version of Xamarin.iOS requires the * SDK (shipped with Xcode *). Either upgrade Xcode to get the required header files or set the managed linker behaviour to Link Framework SDKs Only (to try to avoid the new APIs).

Xamarin.iOS requires the header files, from the SDK version specified in the error message, to build your application. The recommended way to fix this error is to upgrade Xcode to get the required SDK, this will include all the required header files. If you have multiple versions of Xcode installed, or want to use an Xcode in a non-default location, make sure to set the correct Xcode location in your IDE's preferences.

A potential, alternative solution is to enable the managed linker. This will remove unused API including, in most cases, the new API where the header files are missing (or incomplete). However this will not work if your project uses API that was introduced in a newer SDK than the one your Xcode provides.

A last-straw solution would be to use an older version of Xamarin.iOS, one that supports the SDK your project requires.

MT0093: Could not find 'mlaunch'.

MT0095: Aot files could not be copied to the destination directory {dest}: {error}

MT0096: No reference to Xamarin.iOS.dll was found.

MT0099: Internal error *.

This error message is reported when an internal consistency check in Xamarin.iOS fails.

This usually indicates a bug in Xamarin.iOS; please file a new issue on github with a test case.

MT0100: Invalid assembly build target: '*'.

This error message is reported when an internal consistency check in Xamarin.iOS fails.

This usually indicates a bug in Xamarin.iOS; please file a new issue on github with a test case.

MT0101: The assembly '*' is specified multiple times in --assembly-build-target arguments.

The assembly mentioned in the error message is specified multiple times in --assembly-build-target arguments. Please make sure each assembly is only mentioned once.

MT0102: The assemblies '' and '' have the same target name (''), but different targets ('' and '*').

The assemblies mentioned in the error message have conflicting build targets.

For example:

  --assembly-build-target:Assembly1.dll=framework=MyBinary --assembly-build-target:Assembly2.dll=dynamiclibrary=MyBinary

This example is trying to create both a dynamic library and a framework with the same make (MyBinary).

MT0103: The static object '' contains more than one assembly (''), but each static object must correspond with exactly one assembly.

The assemblies mentioned in the error message are all compiled to a single static object. This is not allowed, every assembly must be compiled to a different static object.

For example:

--assembly-build-target:Assembly1.dll=staticobject=MyBinary --assembly-build-target:Assembly2.dll=staticobject=MyBinary

This example tries to build a static object (MyBinary) comprised of two assemblies (Assembly1.dll and Assembly2.dll), which is not allowed.

MT0105: No assembly build target was specified for '*'.

When specifying the assembly build target using --assembly-build-target, every assembly in the app must have a build target assigned.

This error is reported when the assembly mentioned in the error message does not have an assembly build target assigned.

See the documentation about --assembly-build-target for further information.

MT0106: The assembly build target name '' is invalid: the character '' is not allowed.

The assembly build target name must be a valid filename.

For example these values will trigger this error:

--assembly-build-target:Assembly1.dll=staticobject=my/path.o

because my/path.o is not a valid filename due to the directory separator character.

MT0107: The assemblies '' have different custom LLVM optimizations (), which is not allowed when they are all compiled to a single binary.

MT0108: The assembly build target '*' did not match any assemblies.

MT0109: The assembly '{0}' was loaded from a different path than the provided path (provided path: {1}, actual path: {2}).

This is a warning indicating that an assembly referenced by the application was loaded from a different location than requested.

This might mean that the app is referencing multiple assemblies with the same name, but from different locations, which might lead to unexpected results (only the first assembly will be used).

MT0110: Incremental builds have been disabled because this version of Xamarin.iOS does not support incremental builds in projects that include third-party binding libraries and that compiles to bitcode.

Incremental builds have been disabled because this version of Xamarin.iOS does not support incremental builds in projects that include third-party binding libraries and that compiles to bitcode (tvOS and watchOS projects).

No action is required on your part, this message is purely informational.

This warning is not reported anymore.

MT0111: Bitcode has been enabled because this version of Xamarin.iOS does not support building watchOS projects using LLVM without enabling bitcode.

Bitcode has been enabled automatically because this version of Xamarin.iOS does not support building watchOS projects using LLVM without enabling bitcode.

No action is required on your part, this message is purely informational.

There are multiple reasons code sharing can be disabled:

because the container app's deployment target is earlier than iOS 8.0 (it's *)).

Native code sharing requires iOS 8.0 because native code sharing is implemented using user frameworks, which was introduced with iOS 8.0.

because the container app includes I18N assemblies (*).

Native code sharing is currently not supported if the container app includes I18N assemblies.

because the container app has custom xml definitions for the managed linker (*).

Native code sharing requires is not supported for projects that use custom xml definitions for the managed linker.

because the bitcode options differ between the container app (*) and the extension (*).

Native code sharing requires that the bitcode options match between the projects that share code.
because the --assembly-build-target options are different between the container app (*) and the extension (*).

Native code sharing requires that the --assembly-build-target options are identical between the projects that share code.

This condition can occur if incremental builds are not either enabled or disabled in all the projects.
because the I18N assemblies are different between the container app (*) and the extension (*).

Native code sharing is currently not supported for extensions that include I18N assemblies.
because the arguments to the AOT compiler are different between the container app (*) and the extension (*).

Native code sharing requires that the arguments to the AOT compiler do not differ between projects that share code.
because the other arguments to the AOT compiler are different between the container app (*) and the extension (*).

Native code sharing requires that the arguments to the AOT compiler do not differ between projects that share code.

This condition occurs if the 'Perform all 32-bit float operations as 64-bit float' differs between projects.
because LLVM is not enabled or disabled in both the container app (*) and the extension (*).

Native code sharing requires that LLVM is either enabled or disabled for all projects that share code.
because the managed linker settings are different between the container app (*) and the extension (*).

Native code sharing requires that the managed linker settings are identical for all projects that share code.
because the skipped assemblies for the managed linker are different between the container app (*) and the extension (*).

Native code sharing requires that the managed linker settings are identical for all projects that share code.
because the extension has custom xml definitions for the managed linker (*).

Native code sharing requires is not supported for projects that use custom xml definitions for the managed linker.
because the container app does not build for the ABI * (while the extension is building for this ABI).

Native code sharing requires that the container app builds for all the architectures any app extension builds for.

For instance: this condition occurs when an extension builds for ARM64+ARMv7, but the container app only builds for ARM64.
because the container app is building for the ABI *, which is not compatible with the extension's ABI (*).

Native code sharing requires that all the projects build for the exact same API.

For instance: this condition occurs when an extension builds for ARMv7+llvm+thumb2, but the container app only builds for ARMv7+llvm.
because the container app is referencing the assembly '*' from '*', while the extension references a different version from '*'.

Native code sharing requires that all the projects that share code use the same versions for all assemblies.

MT0115: It is recommended to reference dynamic symbols using code (--dynamic-symbol-mode=code) when bitcode is enabled.

Xamarin.iOS projects will often reference native symbols dynamically, which means that the native linker might remove such native symbols during the native linking process, because the native linker does not see that these symbols are used.

Usually Xamarin.iOS will ask the native linker to keep such symbols (using the -u symbol linker flag), but when compiling for bitcode the native linker does not accept the -u flag.

Xamarin.iOS has implemented an alternative solution: we generate extra native code which references these symbols, and thus the native linker will see that these symbols are used. This is automatically done when compiling to bitcode.

If --dynamic-symbol-mode=linker is passed to mtouch, this alternative solution will be disabled, and Xamarin.iOS will try to pass -u to the native linker. This will most likely result in native linker errors.

The solution is to remove the --dynamic-symbol-mode=linker argument from the additional mtouch arguments in the project's Build options.

MT0116: Invalid architecture: {arch}. 32-bit architectures are not supported when deployment target is 11 or later. Make sure the project does not build for a 32-bit architecture.

iOS 11 does not contain support for 32-bit applications, so it's not supported to build for a 32-bit application when the deployment target is iOS 11 or later.

Either change the target architecture in the project's iOS build options to arm64, or change the deployment target in the project's Info.plist to an earlier iOS version.

MT0117: Can't launch a 32-bit app on a simulator that only supports 64-bit.

MT0118: Aot files could not be found at the expected directory '{msymdir}'.

MT0123: The executable assembly * does not reference *.

No reference could be found to the platform assembly (Xamarin.iOS.dll / Xamarin.TVOS.dll / Xamarin.WatchOS.dll) in the executable assembly.

This typically happens where there is no code in the executable project that uses anything from the platform assembly; for instance an empty Main method (and no other code) would show this error:

class Program {
    void Main (string[] args)
    {
    }
}

Using an API from the platform assembly will solve the error:

class Program {
    void Main (string[] args)
    {
        System.Console.WriteLine (typeof (UIKit.UIWindow));
    }
}

MT0124: Could not set the current language to '{lang}' (according to LANG={LANG}): {exception}

This is a warning, indicating that the current language couldn't be set to the language in the error message.

The current language will default to the system language.

MT0125: The --assembly-build-target command-line argument is ignored in the simulator.

No action is required, this message is purely informational.

MT0126: Incremental builds have been disabled because incremental builds are not supported in the simulator.

No action is required, this message is purely informational.

MT0127: Incremental builds have been disabled because this version of Xamarin.iOS does not support incremental builds in projects that include more than one third-party binding libraries.

Incremental builds have been disabled automatically because this version of Xamarin.iOS does not always build projects with multiple third-party binding libraries correctly.

No action is required, this message is purely informational.

MT0128: Could not touch the file '':

A failure occurred when touching a file (which is done to ensure partial builds are done correctly).

This warning can most likely be ignored; in case of any problems file a new issue on GitHub and it will be investigated.

MT0135: Did not link system framework '{0}' (referenced by assembly '{1}') because it was introduced in {2} {3}, and we're using the {2} {4} SDK.

To build your application, Xamarin.iOS must link against system libraries, some of which depend upon the SDK version specified in the error message. Since you are using an older version of the SDK, invocations to those APIs may fail at runtime.

The recommended way to fix this error is to upgrade Xcode to get the needed SDK. If you have multiple versions of Xcode installed or want to use an Xcode in a non-default location, make sure to set the correct Xcode location in your IDE's preferences.

Alternatively, enable the managed linker to remove unused APIs, including (in most cases) the new ones which require the specified library. However, this will not work if your project requires APIs introduced in a newer SDK than the one your Xcode provides.

As a last-straw solution, use an older version of Xamarin.iOS that does not require these new SDKs to be present during the build process.

MT10xx: Installer / mtouch

MT1001: Could not find an application at the specified directory

MT1002: Could not create symlinks, files were copied

MT1003: Could not kill the application '*'. You may have to kill the application manually.

MT1004: Could not get the list of installed applications.

MT1005: Could not kill the application '' on the device '': *- You may have to kill the application manually.

MT1006: Could not install the application '' on the device '': *.

MT1007: Failed to launch the application '' on the device '': *. You can still launch the application manually by tapping on it.

MT1008: Failed to launch the simulator

This error is reported if mtouch failed to launch the simulator. This can happen sometimes because there is already a stale or dead simulator process running.

The following command issued on the Unix command line can be used to kill stuck simulator processes:

$ launchctl list|grep UIKitApplication|awk '{print $3}'|xargs launchctl remove

MT1009: Could not copy the assembly '' to '': *

This is a known issue in certain versions of Xamarin.iOS.

If this occurs to you, try the following workaround:

sudo chmod 0644 /Library/Frameworks/Xamarin.iOS.framework/Versions/Current/lib/mono/*/*.mdb

However, since this issue has been resolved in the latest version of Xamarin.iOS, please file a new issue on github with your full version information and build log output.

MT1010: Could not load the assembly '':

MT1011: Could not add missing resource file: '*'

MT1012: Failed to list the apps on the device '':

MT1013: Dependency tracking error: no files to compare.

This indicates a bug in Xamarin.iOS. Please file a new issue on github with a test case.

MT1014: Failed to re-use cached version of '': .

MT1015: Failed to create the executable '':

MT1016: Failed to create the NOTICE file because a directory already exists with the same name.

Remove the directory NOTICE from the project.

MT1017: Failed to create the NOTICE file: *.

MT1018: Your application failed code-signing checks and could not be installed on the device '*'. Check your certificates, provisioning profiles, and bundle ids. Probably your device is not part of the selected provisioning profile (error: 0xe8008015).

MT1019: Your application has entitlements not supported by your current provisioning profile and could not be installed on the device '*'. Please check the iOS Device Log for more detailed information (error: 0xe8008016).

This can happen if:

Your application has entitlements that the current provisioning profile does not support. Possible solutions:
- Specify a different provisioning profile that supports the entitlements your application needs.
- Remove the entitlements not supported in current provisioning profile.
The device you're trying to deploy to is not included in the provisioning profile you're using. Possible solutions:
- Create a new app from a template in Xcode, select the same provisioning profile, and deploy to same device. Sometimes Xcode can automatically refresh provisioning profiles with new devices (in other cases Xcode will ask you what to do). -Go to the iOS Dev Center and update the provisioning profile with the new device, then download the updated provisioning profile to your machine.

In most cases more information about the failure will be printed to the iOS Device Log, which can help diagnosing the issue.

MT1020: Failed to launch the application '' on the device '': *

MT1021: Could not copy the file '' to '': {2}

A file could not be copied. The error message from the copy operation has more information about the error.

MT1022: Could not copy the directory '' to '': {2}

A directory could not be copied. The error message from the copy operation has more information about the error.

MT1023: Could not communicate with the device to find the application '' :

An error occurred when trying to lookup an application on device.

Things to try to solve this:

Delete the application from the device and try again.
Disconnect the device and reconnect it.
Reboot the device.
Reboot the Mac.

MT1024: The application signature could not be verified on device '*'. Please make sure that the provisioning profile is installed and not expired (error: 0xe8008017).

The device rejected the application install because the signature could not be verified.

Please make sure that the provisioning profile is installed and not expired.

MT1025: Could not list the crash reports on the device *.

An error occurred when trying to list the crash reports on the device.

Things to try to solve this:

Delete the application from the device and try again.
Disconnect the device and reconnect it.
Reboot the device.
Reboot the Mac.
Synchronize the device with iTunes (this will remove any crash reports from the device).

MT1026: Could not download the crash report * from the device *.

An error occurred when trying to download the crash reports from the device.

Things to try to solve this:

Delete the application from the device and try again.
Disconnect the device and reconnect it.
Reboot the device.
Reboot the Mac.
Synchronize the device with iTunes (this will remove any crash reports from the device).

MT1027: Can't use Xcode 7+ to launch applications on devices with iOS * (Xcode 7 only supports iOS 6+).

It is not possible to use Xcode 7+ to launch applications on devices with iOS version below 6.0.

Please use an older version of Xcode, or tap on the app manually to launch it.

MT1028: Invalid device specification: '*'. Expected 'ios', 'watchos' or 'all'.

The device specification passed using --device is invalid. Valid values are: 'ios', 'watchos' or 'all'.

MT1029: Could not find an application at the specified directory: *

The application path passed to --launchdev does not exist. Please specify a valid app bundle.

MT1030: Launching applications on device using a bundle identifier is deprecated. Please pass the full path to the bundle to launch.

It's recommended to pass the path to the app to launch on device instead of just the bundle id.

MT1031: Could not launch the app '' on the device '' because the device is locked. Please unlock the device and try again.

Please unlock the device and try again.

MT1032: This application executable might be too large (* MB) to execute on device. If bitcode was enabled you might want to disable it for development, it is only required to submit applications to Apple.

MT1033: Could not uninstall the application '' from the device '': *

MT1035: Cannot include different versions of the framework '{name}'

It is not possible to link with different versions of the same framework.

This typically happens when an extension references a different version of a framework than the container app (possibly through a third-party binding assembly).

Following this error there will be multiple MT1036 errors listing the paths for each different framework.

This error is reported only together with MT1036. Please see MT1036 for more information.

MT11xx: Debug Service

MT1101: Could not start app

MT1102: Could not attach to the app (to kill it): *

MT1103: Could not detach

MT1104: Failed to send packet: *

MT1105: Unexpected response type

MT1106: Could not get list of applications on the device: Request timed out.

MT1107: Application failed to launch: *

Please check if your device is locked.

If you're deploying an enterprise app or using a free provisioning profile, you might have trust the developer (this is explained here).

MT1108: Could not find developer tools for this XX (YY) device.

A few operations from mtouch require the DeveloperDiskImage.dmg file to be present. This file is part of Xcode and is usually located relative to the SDK that you are using to build against, in the Xcode.app/Contents/Developer/iPhoneOS.platform/DeviceSupport/VERSION/DeveloperDiskImage.dmg.

This error can happen either because you do not have a DeveloperDiskImage.dmg that matches the device that you have connected.

MT1109: Application failed to launch because the device is locked. Please unlock the device and try again.

Please check if your device is locked.

MT1110: Application failed to launch because of iOS security restrictions. Please ensure the developer is trusted.

If you're deploying an enterprise app or using a free provisioning profile, you might have trust the developer (this is explained here).

MT1111: Application launched successfully, but it's not possible to wait for the app to exit as requested because it's not possible to detect app termination when launching using gdbserver.

MT12xx: Simulator

MT1201: Could not load the simulator: *

MT1202: Invalid simulator configuration: *

MT1203: Invalid simulator specification: *

MT1204: Invalid simulator specification '*': runtime not specified.

MT1205: Invalid simulator specification '*': device type not specified.

MT1206: Could not find the simulator runtime '*'.

MT1207: Could not find the simulator device type '*'.

MT1208: Could not find the simulator runtime '*'.

MT1209: Could not find the simulator device type '*'.

MT1210: Invalid simulator specification: , unknown key ''

MT1211: The simulator version '' does not support the simulator type ''

MT1212: Failed to create a simulator version where type = * and runtime = *.

MT1213: Invalid simulator specification for Xcode 4: *

MT1214: Invalid simulator specification for Xcode 5: *

MT1215: Invalid SDK specified: *

MT1216: Could not find the simulator UDID '*'.

MT1217: Could not load the app bundle at '*'.

MT1218: No bundle identifier found in the app at '*'.

MT1219: Could not find the simulator for '*'.

MT1220: Could not find the latest simulator runtime for device '*'.

This usually indicates a problem with Xcode.

Things to try to fix this:

Use the simulator once in Xcode.
Pass an explicit SDK version using --sdk <version>.
Reinstall Xcode.

MT1221: Could not find the paired iPhone simulator for the WatchOS simulator '*'.

When launching a WatchOS app in a WatchOS simulator, there must be a paired iOS Simulator as well.

Watch simulators can be paired with iOS Simulators using Xcode's Devices UI (menu Window -> Devices).

MT13xx: [LinkWith]

MT1301: Native library `` () was ignored since it does not match the current build architecture(s) (*)

MT1302: Could not extract the native library '*' from '+'. Please ensure the native library was properly embedded in the managed assembly (if the assembly was built using a binding project, the native library must be included in the project, and its Build Action must be 'ObjcBindingNativeLibrary').

MT1303: Could not decompress the native framework '' from ''. Please review the build log for more information from the native 'zip' command.

Could not decompress the specified native framework from the binding library.

Please review the bulid log for more information about this failure from the native 'zip' command.

MT1304: The embedded framework '' in is invalid: it does not contain an Info.plist.

The specified embedded framework does not contain an Info.plist, and is therefore not a valid framework.

Please make sure the framework is valid.

MT1305: The binding library '' contains a user framework (), but embedded user frameworks require iOS 8.0 (the current deployment target is *). Please set the deployment target in the Info.plist file to at least 8.0.

The specified binding library contains an embedded framework, but Xamarin.iOS only supports embedded frameworks on iOS 8.0 or later.

Please set the deployment target in the Info.plist file to at least 8.0 to solve this error (or don't use embedded frameworks).

MT14xx: Crash Reports

MT1400: Could not open crash report service: AFCConnectionOpen returned *

An error occurred when trying to access crash reports from the device.

Things to try to solve this:

Delete the application from the device and try again.
Disconnect the device and reconnect it.
Reboot the device.
Reboot the Mac.
Synchronize the device with iTunes (this will remove any crash reports from the device).

MT1401: Could not close crash report service: AFCConnectionClose returned *

An error occurred when trying to access crash reports from the device.

Things to try to solve this:

Delete the application from the device and try again.
Disconnect the device and reconnect it.
Reboot the device.
Reboot the Mac.
Synchronize the device with iTunes (this will remove any crash reports from the device).

MT1402: Could not read file info for : AFCFileInfoOpen returned

An error occurred when trying to access crash reports from the device.

Things to try to solve this:

Delete the application from the device and try again.
Disconnect the device and reconnect it.
Reboot the device.
Reboot the Mac.
Synchronize the device with iTunes (this will remove any crash reports from the device).

MT1403: Could not read crash report: AFCDirectoryOpen () returned:

An error occurred when trying to access crash reports from the device.

Things to try to solve this:

Delete the application from the device and try again.
Disconnect the device and reconnect it.
Reboot the device.
Reboot the Mac.
Synchronize the device with iTunes (this will remove any crash reports from the device).

MT1404: Could not read crash report: AFCFileRefOpen () returned:

An error occurred when trying to access crash reports from the device.

Things to try to solve this:

Delete the application from the device and try again.
Disconnect the device and reconnect it.
Reboot the device.
Reboot the Mac.
Synchronize the device with iTunes (this will remove any crash reports from the device).

MT1405: Could not read crash report: AFCFileRefRead () returned:

An error occurred when trying to access crash reports from the device.

Things to try to solve this:

Delete the application from the device and try again.
Disconnect the device and reconnect it.
Reboot the device.
Reboot the Mac.
Synchronize the device with iTunes (this will remove any crash reports from the device).

MT1406: Could not list crash reports: AFCDirectoryOpen () returned:

An error occurred when trying to access crash reports from the device.

Things to try to solve this:

Delete the application from the device and try again.
Disconnect the device and reconnect it.
Reboot the device.
Reboot the Mac.
Synchronize the device with iTunes (this will remove any crash reports from the device).

MT16xx: MachO

MT1600: Not a Mach-O dynamic library (unknown header '0x'): .

An error occurred while processing the dynamic library in question.

Please make sure the dynamic library is a valid Mach-O dynamic library.

The format of a library can be verified using the file command from a terminal:

file -arch all -l /path/to/library.dylib

MT1601: Not a static library (unknown header ''): .

An error occurred while processing the static library in question.

Please make sure the static library is a valid Mach-O static library.

The format of a library can be verified using the file command from a terminal:

file -arch all -l /path/to/library.a

MT1602: Not a Mach-O dynamic library (unknown header '0x'): .

An error occurred while processing the dynamic library in question.

Please make sure the dynamic library is a valid Mach-O dynamic library.

The format of a library can be verified using the file command from a terminal:

file -arch all -l /path/to/library.dylib

MT1603: Unknown format for fat entry at position * in *.

An error occurred while processing the fat archive in question.

Please make sure the fat archive is valid.

The format of a fat archive can be verified using the file command from a terminal:

file -arch all -l /path/to/file

MT1604: File of type * is not a MachO file (*).

An error occurred while processing the MachO file in question.

Please make sure the file is a valid Mach-O dynamic library.

The format of a file can be verified using the file command from a terminal:

file -arch all -l /path/to/file

MT2xxx: Linker error messages

MT2001: Could not link assemblies

This error means that the managed linker encountered an unexpected error, e.g. an exception, and could not complete or save the assembly being processed. More information about the exact error will be part of the build log, e.g.

error MT2001: Could not link assemblies.
    Method: `System.Void Todo.TodoListPageCS/<<-ctor>b__1_0>d::SetStateMachine(System.Runtime.CompilerServices.IAsyncStateMachine)`
    Assembly: `QuickTodo, Version=1.0.6297.28241, Culture=neutral, PublicKeyToken=null`
Reason: Value cannot be null.
Parameter name: instruction

It is important to file a bug report for such issues. In most case a workaround can be provided until a proper fix is published. The above information is critical (along with a test case and/or the assembly binairy) to resolve the issue.

MT2002: Can not resolve reference: *

MT2003: Option '*' will be ignored since linking is disabled

MT2004: Extra linker definitions file '*' could not be located.

MT2005: Definitions from '*' could not be parsed.

MT2006: Can not load mscorlib.dll from: *. Please reinstall Xamarin.iOS.

This generally indicates that there is a problem with your Xamarin.iOS installation. Please try reinstalling Xamarin.iOS.

MT2010: Unknown HttpMessageHandler `*`. Valid values are HttpClientHandler (default), CFNetworkHandler or NSUrlSessionHandler

MT2011: Unknown TlsProvider `*`. Valid values are default or appletls.

The value given to tls-provider= is not a valid TLS (Transport Layer Security) provider.

The default and appletls are the only valid values and both represent the same option, which is to provide the SSL/TLS support using the native Apple TLS API.

MT2015: Invalid HttpMessageHandler `*` for watchOS. The only valid value is NSUrlSessionHandler.

This is a warning that occurs because the project file specifies an invalid HttpMessageHandler.

Earlier versions of our preview tools generated by default an invalid value in the project file.

To fix this warning, open the project file in a text editor, and remove all HttpMessageHandler nodes from the XML.

MT2016: Invalid TlsProvider `legacy` option. The only valid value `appletls` will be used.

The legacy provider, which was a fully managed SSLv3 / TLSv1 only provider, is not shipped with Xamarin.iOS anymore. Projects that were using this old provider and now build with the newer appletls one.

To fix this warning, open the project file in a text editor, and remove all `MtouchTlsProvider`` nodes from the XML.

MT2017: Could not process XML description.

This means there is an error on the custom XML linker configuration file you provided, please review your file.

MT2018: The assembly '' is referenced from two different locations: '' and '*'.

The assembly mentioned in the error message is loaded from multiple locations. Make sure to always use the same version of an assembly.

MT2019: Can not load the root assembly '*'

The root assembly could not be loaded. Please verify that the path in the error message refers to an existing file, and that it's a valid .NET assembly.

MT202x: Binding Optimizer failed processing `...`.

Something unexpected occurred when trying to optimize generated binding code. The element causing the issue is named in the error message. To fix this issue the assembly named (or containing the type or method named) will need to be provided in a new issue on github along with a complete build log with verbosity enabled (i.e. -v -v -v -v in the Additional mtouch arguments).

The last digit x will be:

0 for an assembly name;
1 for a type name;
3 for a method name;

MT2030: Remove User Resources failed processing `...`.

Something unexpected occurred when trying to remove user resources. The assembly causing the issue is named in the error message. To fix this issue the assembly will need to be provided in a new issue on github along with a complete build log with verbosity enabled (i.e. -v -v -v -v in the Additional mtouch arguments).

User resources are files included inside assemblies (as resources) that needs to be extracted, at build time, to create the application bundle. This includes:

__monotouch_content_* and __monotouch_pages_* resources; and
Native libraries embedded inside a binding assembly;

MT2040: Default HttpMessageHandler setter failed processing `...`.

Something unexpected occurred when trying to set the default HttpMessageHandler for the application. Please file a new issue on github along with a complete build log with verbosity enabled (i.e. -v -v -v -v in the Additional mtouch arguments).

MT2050: Code Remover failed processing `...`.

Something unexpected occurred when trying to remove code from BCL shipping with the application. Please file a new issue on github along with a complete build log with verbosity enabled (i.e. -v -v -v -v in the Additional mtouch arguments).

MT2060: Sealer failed processing `...`.

Something unexpected occurred when trying to seal types or methods (final) or when devirtualizing some methods. The assembly causing the issue is named in the error message. To fix this issue the assembly will need to be provided in a new issue on github along with a complete build log with verbosity enabled (i.e. -v -v -v -v in the Additional mtouch arguments).

MT2070: Metadata Reducer failed processing `...`.

Something unexpected occurred when trying to reduce the metadata from the application. The assembly causing the issue is named in the error message. To fix this issue the assembly will need to be provided in a new issue on github along with a complete build log with verbosity enabled (i.e. -v -v -v -v in the Additional mtouch arguments).

MT2080: MarkNSObjects failed processing `...`.

Something unexpected occurred when trying to mark NSObject subclasses from the application. The assembly causing the issue is named in the error message. To fix this issue the assembly will need to be provided in a new issue on github along with a complete build log with verbosity enabled (i.e. -v -v -v -v in the Additional mtouch arguments).

MT2090: Inliner failed processing `...`.

Something unexpected occurred when trying to inline code from the application. The assembly causing the issue is named in the error message. In order to fix this issue the assembly will need to be provided in a new issue on github along with a complete build log with verbosity enabled (i.e. -v -v -v -v in the Additional mtouch arguments).

MT2100: Smart Enum Conversion Preserver failed processing `...`.

Something unexpected occurred when trying to mark the conversion methods for smart enums from the application. The assembly causing the issue is named in the error message. In order to fix this issue the assembly will need to be provided in a new issue on github along with a complete build log with verbosity enabled (i.e. -v -v -v -v in the Additional mtouch arguments).

MT2101: Can't resolve the reference '', referenced from the method '' in '*'.

An invalid assembly reference was encountered when processing the method mentioned in the error message.

The assembly causing the issue is named in the error message. To fix this issue the assembly will need to be provided in a new issue on github along with a complete build log with verbosity enabled (i.e. -v -v -v -v in the Additional mtouch arguments).

MT2102: Error processing the method '' in the assembly '': *

Something unexpected occurred when trying to mark the method mentioned in the error message.

MT2103: Error processing assembly '':

An unexpected error occurred when processing an assembly.

MM2104: Unable to link assembly '{0}' as it is mixed-mode.

Mixed-mode assemblies can not be processed by the linker.

See Mixed (native and managed) assemblies for more information on mixed-mode assemblies.

MT3xxx: AOT error messages

MT3001: Could not AOT the assembly '*'

This generally indicates a bug in the AOT compiler. Please file a new issue on github with a project that can be used to reproduce the error.

Sometimes it's possible to work around this by disabling incremental builds in the project's iOS Build option (but it's still a bug, so please report it anyways).

MT3002: AOT restriction: Method '*' must be static since it is decorated with [MonoPInvokeCallback]. See developer.xamarin.com/guides/ios/advanced_topics/limitations/#Reverse_Callbacks

This error message comes from the AOT compiler.

MT3003: Conflicting --debug and --llvm options. Soft-debugging is disabled.

Debugging is not supported when LLVM is enabled. If you need to debug the app, disable LLVM first.

MT3004: Could not AOT the assembly '*' because it doesn't exist.

MT3005: The dependency '' of the assembly '' was not found. Please review the project's references.

This typically occurs when an assembly references another version of a platform assembly (usually the .NET 4 version of mscorlib.dll).

This is not supported, and may not build or execute properly (the assembly may use API from the .NET 4 version of mscorlib.dll that the Xamarin.iOS version does not have).

MT3006: Could not compute a complete dependency map for the project. This will result in slower build times because Xamarin.iOS can't properly detect what needs to be rebuilt (and what does not need to be rebuilt). Please review previous warnings for more details.

build or execute properly (the assembly may use API from the .NET 4 version of mscorlib.dll that the Xamarin.iOS version does not have).

MT3007: Debug info files (*.mdb) will not be loaded when llvm is enabled.

MT3008: Bitcode support requires the use of the LLVM AOT backend (--llvm)

Bitcode support requires the use of the LLVM AOT backend (--llvm).

Either disable Bitcode support or enable LLVM.

MT4xxx: Code generation error messages

MT40xx: Main

MT4001: The main template could not be expanded to `*`.

An error occurred when generating main.m. Please file a new issue on github.

MT4002: Failed to compile the generated code for P/Invoke methods.

Failed to compile the generated code for P/Invoke methods. Please file a new issue on github.

MT41xx: Registrar

MT4101: The registrar cannot build a signature for type `*`.

A type was found in exported API that the runtime doesn't know how to marshal to/from Objective-C.

If you believe Xamarin.iOS should support the type in question, please file an enhancement request on github.

MT4102: The registrar found an invalid type `` in signature for method ``. Use `*` instead.

This currently only happens with one type: System.DateTime. Use the Objective-C equivalent (NSDate) instead.

MT4103: The registrar found an invalid type `` in signature for method ``: The type implements INativeObject, but does not have a constructor that takes two (IntPtr, bool) arguments

This occurs when the registrar encounter a type in a signature with the mentioned characteristics. The registrar might need to create new instances of the type, and in this case it requires a constructor with the (IntPtr, bool) signature - the first argument (IntPtr) specifies the managed handle, while the second if the caller hands over ownership of the native handle (if this value is false 'retain' will be called on the object).

MT4104: The registrar cannot marshal the return value for type `` in signature for method ``.

A type was found in exported API that the runtime doesn't know how to marshal to/from Objective-C.

If you believe Xamarin.iOS should support the type in question, please file an enhancement request on github.

MT4105: The registrar cannot marshal the parameter of type `` in signature for method ``.

If you believe Xamarin.iOS should support the type in question, please file an enhancement request on github.

MT4106: The registrar cannot marshal the return value for structure `` in signature for method ``.

A type was found in exported API that the runtime doesn't know how to marshal to/from Objective-C.

If you believe Xamarin.iOS should support the type in question, please file an enhancement request on github.

MT4107: The registrar cannot marshal the parameter of type `*` in signature for method `+`.

A type was found in exported API that the runtime doesn't know how to marshal to/from Objective-C.

If you believe Xamarin.iOS should support the type in question, please file an enhancement request on github.

MT4108: The registrar cannot get the ObjectiveC type for managed type `*`.

A type was found in exported API that the runtime doesn't know how to marshal to/from Objective-C.

If you believe Xamarin.iOS should support the type in question, please file an enhancement request on github.

MT4109: Failed to compile the generated registrar code.

Failed to compile the generated code for the registrar. The build log will contain the output from the native compiler, explaining why the code isn't compiling.

This is always a bug in Xamarin.iOS; please file a new issue on github with your project or a test case.

MT4110: The registrar cannot marshal the out parameter of type `` in signature for method ``.

MT4111: The registrar cannot build a signature for type `` in method ``.

MT4112: The registrar found an invalid type `*`. Registering generic types with Objective-C is not supported, and may lead to random behavior and/or crashes (for backwards compatibility with older versions of Xamarin.iOS it is possible to ignore this error by passing `--unsupported--enable-generics-in-registrar` as an additional mtouch argument in the project's iOS Build options page. See developer.xamarin.com/guides/ios/advanced_topics/registrar for more information).

MT4113: The registrar found a generic method: '.'. Exporting generic methods is not supported, and will lead to random behavior and/or crashes.

MT4114: Unexpected error in the registrar for the method '.' -

MT4116: Could not register the assembly '':

MT4117: The registrar found a signature mismatch in the method '.' - the selector indicates the method takes * parameters, while the managed method has * parameters.

MT4118: Cannot register two managed types ('' and '') with the same native name ('*').

MT4119: Could not register the selector '' of the member '.*' because the selector is already registered on a different member.

MT4120: The registrar found an unknown field type '' in field '.*'.

This error indicates a bug in Xamarin.iOS. Please file a new issue on github.

MT4121: Cannot use GCC/G++ to compile the generated code from the static registrar when using the Accounts framework (the header files provided by Apple used during the compilation require Clang). Either use Clang (--compiler:clang) or the dynamic registrar (--registrar:dynamic).

MT4122: Cannot use the Clang compiler provided in the . SDK to compile the generated code from the static registrar when non-ASCII type names ('*') are present in the application. Either use GCC/G++ (--compiler:gcc|g++), the dynamic registrar (--registrar:dynamic) or a newer SDK.

MT4123: The type of the variadic parameter in the variadic function '*' must be System.IntPtr.

MT4124: Invalid * found on '*'.

This error indicates a bug in Xamarin.iOS. Please file a new issue on github.

MT4125: The registrar found an invalid type '' in signature for method '': The interface must have a Protocol attribute specifying its wrapper type.

MT4126: Cannot register two managed protocols ('' and '') with the same native name ('*').

MT4127: Cannot register more than one interface method for the method '' (which is implementing '').

MT4128: The registrar found an invalid generic parameter type '' in the method ''. The generic parameter must have an 'NSObject' constraint.

MT4129: The registrar found an invalid generic return type '' in the method ''. The generic return type must have an 'NSObject' constraint.

MT4130: The registrar cannot export static methods in generic classes ('*').

MT4131: The registrar cannot export static properties in generic classes ('.').

MT4132: The registrar found an invalid generic return type '' in the property ''. The return type must have an 'NSObject' constraint.

MT4133: Cannot construct an instance of the type '*' from Objective-C because the type is generic. [Runtime exception]

MT4134: Your application is using the '' framework, which isn't included in the iOS SDK you're using to build your app (this framework was introduced in iOS , while you're building with the iOS * SDK.) Please select a newer SDK in your app's iOS Build options.

MT4135: The member '.' has an Export attribute that doesn't specify a selector. A selector is required.

MT4136: The registrar cannot marshal the parameter type '' of the parameter '' in the method '.'

MT4138: The registrar cannot marshal the property type '' of the property '.*'.

MT4139: The registrar cannot marshal the property type '' of the property '.*'. Properties with the [Connect] attribute must have a property type of NSObject (or a subclass of NSObject).

MT4140: The registrar found a signature mismatch in the method '.' - the selector indicates the variadic method takes * parameters, while the managed method has * parameters.

MT4141: Cannot register the selector '' on the member '' because Xamarin.iOS implicitly registers this selector.

This occurs when subclassing a framework type, and trying to implement a 'retain', 'release' or 'dealloc' method:

class MyNSObject : NSObject
{
  [Export ("retain")]
  new void Retain () {}

  [Export ("release")]
  new void Release () {}

  [Export ("dealloc")]
  new void Dealloc () {}
}

It is however possible to override these methods if the class isn't the first subclass of the framework type:

class MyNSObject : NSObject
{
}

class MyCustomNSObject : MyNSObject
{
  [Export ("retain")]
  new void Retain () {}

  [Export ("release")]
  new void Release () {}

  [Export ("dealloc")]
  new void Dealloc () {}
}

In this case Xamarin.iOS will override retain, release and dealloc on the MyNSObject class, and there is no conflict.

MT4142: Failed to register the type '*'.

MT4143: The ObjectiveC class '*' could not be registered, it does not seem to derive from any known ObjectiveC class (including NSObject).

MT4144: Cannot register the method '*' since it does not have an associated trampoline..

This indicates a bug in Xamarin.iOS. Please file a new issue on github.

MT4145: Invalid enum '*': enums with the [Native] attribute must have a underlying enum type of either 'long' or 'ulong'.

MT4146: The Name parameter of the Registrar attribute on the class '' ('') contains an invalid character: '' ().

The name of an Objectice-C class can't contain whitespace, which means that the Register attribute on the corresponding managed class can't have a Name parameter can't contain whitespace either.

Please verify that the Register attribute on the managed class mentioned in the error message does not contain any whitespace.

MT4147: Detected a protocol inheriting from the JSExport protocol while using the dynamic registrar. It is not possible to export protocols to JavaScriptCore dynamically; the static registrar must be used (add '--registrar:static to the additional mtouch arguments in the project's iOS Build options to select the static registrar).

MT4148: The registrar found a generic protocol: '*'. Exporting generic protocols is not supported.

MT4149: Cannot register the method '.' because the type of the first parameter ('') does not match the category type ('').

MT4150: Cannot register the type '' because the Type property ('') in its Category attribute does not inherit from NSObject.

MT4151: Cannot register the type '*' because the Type property in its Category attribute isn't set.

MT4152: Cannot register the type '*' as a category because it implements INativeObject or subclasses NSObject.

MT4153: Cannot register the type '*' as a category because it's generic.

MT4154: Cannot register the method '*' as a category method because it's generic.

MT4155: Cannot register the method '' with the selector '' as a category method on '*' because the Objective-C already has an implementation for this selector.

MT4156: Cannot register two categories ('' and '') with the same native name ('*').

MT4157: Cannot register the category method '' because at least one parameter is required (and its type must match the category type '')

MT4158: Cannot register the constructor * in the category * because constructors in categories are not supported.

MT4159: Cannot register the method '*' as a category method because category methods must be static.

MT4160: Invalid character '' () found in selector '' for ''.

MT4161: The registrar found an unsupported structure '': All fields in a structure must also be structures (field '' with type '{2}' is not a structure).

The registrar found a structure with unsupported fields.

All fields in a structure that is exposed to Objective-C must also be structures (not classes).

MT4162: The type '' (used as {2}) is not available in * * (it was introduced in * ) Please build with a newer * SDK (usually done by using the most recent version of Xcode.

The registrar found a type which is not included in the current SDK.

Please upgrade Xcode.

MT4163: Internal error in the registrar (*).

This error indicates a bug in Xamarin.iOS. Please file a new issue on github.

MT4164: Cannot export the property '' because its selector '' is an Objective-C keyword. Please use a different name.

The selector for the property in question is not a valid Objective-C identifer.

Please use a valid Objective-C identifier as selectors.

MT4165: The registrar couldn't find the type 'System.Void' in any of the referenced assemblies.

This error most likely indicates a bug in Xamarin.iOS. Please file a new issue on github.

MT4166: Cannot register the method '' because the signature contains a type () that isn't a reference type.

This usually indicates a bug in Xamarin.iOS. Please file a new issue on github.

MT4167: Cannot register the method '' because the signature contains a generic type () with a generic argument type that isn't an NSObject subclass (*).

This usually indicates a bug in Xamarin.iOS. Please file a new issue on github.

MT4168: Cannot register the type '{managed_name}' because its Objective-C name '{exported_name}' is an Objective-C keyword. Please use a different name.

The Objective-C name for the type in question is not a valid Objective-C identifier.

Please use a valid Objective-C identifier.

MT4169: Failed to generate a P/Invoke wrapper for {method}: {message}

Xamarin.iOS failed to generate a P/Invoke wrapper function for the mentioned. Please check the reported error message for the underlying cause.

MT4170: The registrar can't convert from '{managed type}' to '{native type}' for the return value in the method {method}.

See the description of error MT4172.

MT4171: The BindAs attribute on the member {member} is invalid: the BindAs type {type} is different from the property type {type}.

Please make sure the type in the BindAs attribute matches the type of the member it's attached to.

MT4172: The registrar can't convert from '{native type}' to '{managed type}' for the parameter '{parameter name}' in the method {method}.

The registrar does not support converting between the mentioned types.

This is a bug in Xamarin.iOS if the API in question is provided by Xamarin.iOS. Please file a new issue on github.

If you run into this while developing a binding project for a native library, we're open to adding support for new combinations of types. If this is the case, please file an enhancement request on github with a test case and we'll evaluate it.

MT5xxx: GCC and toolchain error messages

MT51xx: Compilation

MT5101: Missing '*' compiler. Please install Xcode 'Command-Line Tools' component

MT5102: Failed to assemble the file '*'.

MT5103: Failed to compile the file '*'.

MT5104: Could not find neither the '' nor the '' compiler. Please install Xcode 'Command-Line Tools' component

MT5106: Could not compile the file(s) '*'.

This usually indicates a bug in Xamarin.iOS; please file a new issue on github.

MT52xx: Linking

MT5201: Native linking failed. Please review the build log and the user flags provided to gcc: *

MT5202: Native linking failed. Please review the build log.

MT5203: Native linking warning: *

MT5209: Native linking error: *

MT5210: Native linking failed, undefined symbol: *. Please verify that all the necessary frameworks have been referenced and native libraries are properly linked in.

This happens when the native linker cannot find a symbol that is referenced somewhere. There are several reasons this may happen:

A third-party binding requires a framework, but the binding does not specify this in its [LinkWith] attribute. Solutions:
- If you're the author of the third-party binding, or have access to its source, modify the binding's [LinkWith] attribute to include the framework it needs:
```
[LinkWith ("mylib.a", Frameworks = "SystemConfiguration")]
```
- If you can't modify the third-party binding, you can manually link with the required framework by passing -gcc_flags '-framework SystemFramework' to mtouch (this is done by modifying the additional mtouch arguments in the project's iOS Build options page. Remember that this must be done for every project configuration).
In some cases a managed binding is composed of several native libraries, and all must be included in the bindings. It is possible to have more than one native library in each binding project, so the solution is to just add all the required native libraries to the binding project.
A managed binding refers to native symbols that don't exist in the native library. This usually happens when a binding has existed for some time, and the native code has been modified during that time so that a particular native class has either been removed or renamed, while the binding has not been updated.
A P/Invoke refers to a native symbol that does not exist. Starting with Xamarin.iOS 7.4 an MT5214 error will be reported for this case (see MT5214 for more information).
A third-party binding / library was built using C++, but the binding does not specify this in its [LinkWith] attribute. This is usually fairly easy to recognize, because the symbols have are mangled C++ symbols (one common example is __ZNKSt9exception4whatEv).
- If you're the author of the third-party binding, or have access to its source, modify the binding's [LinkWith] attribute to set the IsCxx flag:
```
[LinkWith ("mylib.a", IsCxx = true)]
```
- If you can't modify the third-party binding, or you're linking manually with a third-party library, you can set the equivalent flag by passing -cxx to mtouch (this is done by modifying the additional mtouch arguments in the project's iOS Build options page. Remember that this must be done for every project configuration).

MT5211: Native linking failed, undefined Objective-C class: . The symbol '' could not be found in any of the libraries or frameworks linked with your application.

This happens when the native linker cannot find an Objective-C class that is referenced somewhere. There are several reasons this may happen: the same as for MT5210 and in addition:

A third-party binding bound an Objective-C protocol, but did not annotate it with the [Protocol] attribute in its api definition. Solutions:
- Add the missing [Protocol] attribute:
```
[BaseType (typeof (NSObject))]
[Protocol] // Add this
public interface MyProtocol
{
}
```

MT5212: Native linking failed, duplicate symbol: *.

This happens when the native linker encounters duplicated symbols between all the native libraries. Following this error there may be one or more MT5213 errors with the location for each occurrence of the symbol. Possible reasons for this error:

The same native library is included twice.
Two distinct native libraries happen to define the same symbols.

A native library is not correctly built, and contains the same symbol more than once. You can confirm this by using the following set of commands from a terminal (replace i386 with x86_64/armv7/armv7s/arm64 according to which architecture you're building for):

# Native libraries are usually fat libraries, containing binary code for
# several architectures in the same file. First we extract the binary
# code for the architecture we're interested in.
lipo libNative.a -thin i386 -output libNative.i386.a

# Now query the native library for the duplicated symbol.
nm libNative.i386.a | fgrep 'SYMBOL'

# You can also list the object files inside the native library.
# In most cases this will reveal duplicated object files.
ar -t libNative.i386.a

There are a few possible ways to fix this:

Request that the provider of the native library fix it and provide the updated version.
Fix it yourself by removing the extra object files (this only works if the problem is in fact duplicated object files)

# Find out if the library is a fat library, and which
# architectures it contains.
lipo -info libNative.a

# Extract each architecture (i386/x86_64/armv7/armv7s/arm64) to a separate file
lipo libNative.a -thin ARCH -output libNative.ARCH.a

# Extract the object files for the offending architecture
# This will remove the duplicates by overwriting them
# (since they have the same filename)
mkdir -p ARCH
cd ARCH
ar -x ../libNative.ARCH.a

# Reassemble the object files in an .a
ar -r ../libNative.ARCH.a *.o
cd ..

# Reassemble the fat library
lipo *.a -create -output libNative.a

Ask the linker to remove unused code. Xamarin.iOS will do this automatically if all of the following conditions are met:
- All third-party bindings' [LinkWith] attributes have enabled SmartLink:
```
[assembly: LinkWith ("libNative.a", SmartLink = true)]
```
- No -gcc_flags is passed to mtouch (in the additional mtouch arguments field of the project's iOS Build options).
- It's also possible to ask the linker directly to remove unused code by adding -gcc_flags -dead_strip to the additional mtouch arguments in the project's iOS Build options.

This error is reported only together with MT5212. Please see MT5212 for more information.

MT5214: Native linking failed, undefined symbol: . This symbol was referenced the managed member . Please verify that all the necessary frameworks have been referenced and native libraries linked.

This error is reported when the managed code contains a P/Invoke to a native method that does not exist. For example:

using System.Runtime.InteropServices;
class MyImports {
   [DllImport ("__Internal")]
   public static extern void MyInexistentFunc ();
}

There are a few possible solutions:

Remove the P/Invokes in question from the source code.
Enable the managed linker for all assemblies (this is done in the project's iOS Build options, by setting "Linker Behavior" to "All assemblies"). This will effectively remove all the P/Invokes you don't use from the app (automatically, instead of manually like the previous point). The downside is that this will make your simulator builds somewhat slower, and it may break your app if it's using reflection - more information about the linker can be found here )
Create a second native library which contains the missing native symbols. Note that this is merely a workaround (if you happen to try to call those functions, your app will crash).

MT5215: References to '*' might require additional -framework=XXX or -lXXX instructions to the native linker

This is a warning, indicating that a P/Invoke was detected to reference the library in question, but the app is not linking with it.

MT5216: Native linking failed for *.

This error is reported when linking the output from the AOT compiler.

This error most likely indicates a bug in Xamarin.iOS. Please file a new issue on github.

MT5217: Native linking possibly failed because the linker command line was too long (* characters).

Native linking failed, and it's possible this occurred because the linker command was too long.

Usually Xamarin.iOS will ask the native linker to keep such symbols using the -u symbol linker flag, but if there are many such symbols, the entire command-line might exceed the maximum command-line length as specified by the operating system.

There are a few possible sources for such dynamic symbols:

P/Invokes to methods in statically linked libraries (where the dll name is __Internal in the DllImport attribute [DllImport ("__Internal")]).
Field references to memory locations in statically linked libraries from binding projects ([Field] attributes).
Objective-C classes referenced in statically linked libraries from binding projects (when using incremental builds or when not using the static registrar).

Possible solutions:

Enable the managed linker (if possible for all assemblies instead of only SDK assemblies). This might remove enough of the sources for dynamic symbols so that the linker's command-line doesn't exceeded the maximum.
Reduce the number of P/Invokes, field references and/or Objective-C classes.
Rewrite the dynamic symbols to have shorter names.
Pass -dlsym:false as an additional mtouch argument in the project's iOS Build options. With this option, Xamarin.iOS will generate a native reference in the AOT-compiled code, and won't need to ask the linker to keep this symbol. However, this only works for device builds, and it will cause linker errors if there are P/Invokes to functions that don't exist in the static library.
Pass --dynamic-symbol-mode=code as an additional mtouch arguments in the project's iOS Build options. With this option, Xamarin.iOS will generate additional native code that references these symbols instead of asking the native linker to keep these symbols using command-line arguments. The downside to this approach is that it will increase the size of the executable somewhat.
Enable the static registrar by passing --registrar:static as an additional mtouch argument in the project's iOS Build options (for simulator builds, since the static registrar is already the default for device builds). The static registrar will generate code that references Objective-C classes statically, so there is no need to ask the native linker to keep such classes.
Disable incremental builds (for device builds). When incremental builds are enabled, the code generated by the static registrar won't be considered by the native linker, which means that Xamarin.iOS must still ask the linker to keep referenced Objective-C classes. Thus disabling incremental builds will prevent this need.

MT5218: Can't ignore the dynamic symbol {symbol} (--ignore-dynamic-symbol={symbol}) because it was not detected as a dynamic symbol.

The command-line argument --ignore-dynamic-symbol=symbol was passed, but this symbol is not a symbol that was recognized as a dynamic symbol that must be manually preserved.

There are two main reasons for this:

The symbol name is incorrect.
- Don't prepend an underscore to the symbol name.
- The symbol for Objective-C classes is OBJC_CLASS_$_<classname>.
The symbol is correct, but it's a symbol that's already preserved by normal means (some build options causes the exact list of dynamic symbols to vary).

MT53xx: Other tools

MT5301: Missing 'strip' tool. Please install Xcode 'Command-Line Tools' component

MT5302: Missing 'dsymutil' tool. Please install Xcode 'Command-Line Tools' component

MT5303: Failed to generate the debug symbols (dSYM directory). Please review the build log.

An error occurred when running dsymutil on the final .app directory to create the debug symbols. Please review the build log to see dsymutil's output and see how it can be fixed.

MT5304: Failed to strip the final binary. Please review the build log.

An error occurred when running the 'strip' tool to remove debugging information from the application.

MT5305: Missing 'lipo' tool. Please install Xcode 'Command-Line Tools' component

MT5306: Failed to create the a fat library. Please review the build log.

An error occurred when running the 'lipo' tool. Please review the build log to see the error reported by 'lipo'.

MT5307: Failed to sign the executable. Please review the build log.

An error occurred when signing the application. Please review the build log to see the error reported by 'codesign'.

MT6xxx: mtouch internal tools error messages

MT600x: Stripper

MT6001: Running version of Cecil doesn't support assembly stripping

MT6002: Could not strip assembly `*`.

An error occurred when stripping managed code(removing the IL code) from the assemblies in the application.

MT6003: [UnauthorizedAccessException message]

A security error occurred while stripping debugging symbols from the application.

MT7xxx: MSBuild error messages

MT7001: Could not resolve host IPs for WiFi debugger settings.

MSBuild task: DetectDebugNetworkConfigurationTaskBase

Troubleshooting steps:

try to run csharp -e 'System.Net.Dns.GetHostEntry (System.Net.Dns.GetHostName ()).AddressList' (that should give you an IP address and not an error obviously).
try to run "ping `hostname`" which might give you more information, like: cannot resolve MyHost.local: Unknown host

In some cases, it's a "local network" issue and it can be addressed by adding the unknown host 127.0.0.1 MyHost.local in /etc/hosts.