Managed plug-ins
Building plug-ins for desktop platforms

Native plug-ins

Unity has extensive support for native 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
, which are libraries of native code written in C, C++, Objective-C, etc. Plug-ins allow your game code (written in Javascript or C#) to call functions from these libraries. This feature allows Unity to integrate with middleware libraries or existing C/C++ game code.

In order to use a native plug-inA platform-specific native code library that is created outside of Unity for use in Unity. Allows you can access features like OS calls and third-party code libraries that would otherwise not be available to Unity. More info
See in Glossary
you firstly need to write functions in a C-based language to access whatever features you need and compile them into a library. In Unity, you will also need to create a C# script which calls functions in the native library.

The native plug-in should provide a simple C interface which the C# script then exposes to other user 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
. It is also possible for Unity to call functions exported by the native plug-in when certain low-level renderingThe process of drawing graphics to the screen (or to a render texture). By default, the main camera in Unity renders its view to the screen. More info
See in Glossary
events happen (for example, when a graphics device is created), see the Native plug-in interface page for details.

Example

A very simple native library with a single function might have source code that looks like this:

    float FooPluginFunction () { return 5.0F; } 

To access this code from within Unity, you could use code like the following:

    using UnityEngine;
    using System.Runtime.InteropServices;

    class SomeScript : MonoBehaviour {

       #if UNITY_IPHONE
   
       // On iOS plugins are statically linked into
       // the executable, so we have to use __Internal as the
       // library name.
       [DllImport ("__Internal")]

       #else

       // Other platforms load plugins dynamically, so pass the name
       // of the plugin's dynamic library.
       [DllImport ("PluginName")]
    
       #endif

       private static extern float FooPluginFunction ();

       void Awake () {
          // Calls the FooPluginFunction inside the plugin
          // And prints 5 to the console
          print (FooPluginFunction ());
       }
    }

Note that when using Javascript you will need to use the following syntax, where DLLName is the name of the plug-in you have written, or “__Internal” if you are writing statically linked native code:

    @DllImport (DLLName)
    static private function FooPluginFunction () : float {};

Creating a native plug-in

In general, plug-ins are built with native code compilers on the target platform. Since plug-in functions use a C-based call interface, you must avoid name mangling issues when using C++ or Objective-C.

Further Information

Did you find this page useful? Please give it a rating:

Managed plug-ins
Building plug-ins for desktop platforms