Version: 2022.3
Language : English
Deep linking for macOS
Build and distribute a macOS application

Use IL2CPP with macOS

Describes the use of plug-insA set of code created outside of Unity that creates functionality in Unity. There are two kinds of plug-ins you can use in Unity: Managed plug-ins (managed .NET assemblies created with tools like Visual Studio) and Native plug-ins (platform-specific native code libraries). More info
See in Glossary
for macOS applications using Intermediate Language To C++ (IL2CPP).

IL2CPP is a fully supported scripting back end that you can use as an alternative to Mono when building projects for macOS Player.

When you use IL2CPP to build a project, Unity converts Intermediate Language (IL) code from scriptsA piece of code that allows you to create your own Components, trigger game events, modify Component properties over time and respond to user input in any way you like. More info
See in Glossary
and assemblies to C++ before creating a native binary. Refer to IL2CPPA Unity-developed scripting back-end which you can use as an alternative to Mono when building projects for some platforms. More info
See in Glossary
for more information.

C++ source code plug-ins for IL2CPP

You can add C++ (.cpp) code files directly into a Unity Project when using the IL2CPP scripting back end. These C++ files act as plug-ins within the InspectorA Unity window that displays information about the currently selected GameObject, asset or project settings, allowing you to inspect and edit the values. More info
See in Glossary
. If you configure the C++ files to be compatible with macOS Player, Unity compiles them together with C++ code that gets generated from managed assemblies. Refer to Import and configure plug-ins for more information on plug-in configuration.

Generated C++ code links the functions together, removing the need for a separate Dynamic Link Library (DLL). Instead of using the DLL name, use the "__Internal" keyword to make the C++ linker responsible for resolving functions rather than loading them at runtime. For example:

private static extern int
CountLettersInString([MarshalAs(UnmanagedType.LPWStr)]string str);

You can define this kind of function in NativeFunctions.cpp as follows:

extern "C" __declspec(dllexport) int __stdcall CountLettersInString(wchar_t* str)
    int length = 0;
    while (*str++ != nullptr)
    return length;

When the linker resolves the function call, errors in the function declaration on the managed side result in a linker error rather than a runtime error. This means that no dynamic loading needs to happen during runtime, with the function called directly from C#. This decreases the performance overhead of a P/Invoke call.

Additional resources

Deep linking for macOS
Build and distribute a macOS application