Conditional Compilation

Unity’s support for the C# language includes the use of directives, which allow you to selectively include or exclude code from compilation, based on whether certain scripting symbols are defined or not defined.

For more information on how these directives work in C#, refer to Microsoft’s documentation on C# preprocessor directives.

Unity has a range of built-in scripting symbols that you can use in your 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 to selectively include or exclude sections of code from compilation. For example, the built-in scripting symbol that’s set when a Player is built for Windows standalone platform is UNITY_STANDALONE_WIN. You can check whether this symbol is defined using a special type of if statement using the following query:

#if UNITY_STANDALONE_WIN

  Debug.Log("Standalone Windows");

#endif

The hash (#) character in front of if and endif indicates that these statements are directives that are handled during the compilation process, rather than at runtime.

In the above example, the Debug line is only included for compilation in the Windows standalone build of the project. When compiled in the Unity Editor or in other target builds, it’s omitted entirely. This is different to using a regular if .. then .. else structure, which might only bypass the execution of certain part of code at runtime.

There are several built-in scripting symbols which allow you to selectively compile or omit code based on the selected Platform, the Editor Version, and other system environment scenarios.

In addition, you can define your own scripting symbols either using the Unity Editor UI(User Interface) Allows a user to interact with your application. Unity currently supports three UI systems. More info
See in Glossary, via scripting, or via an asset file, which allows you to control compilation of portions of your code based on arbitrary definitions. For more information, check Custom scripting symbols.

Note: Scripting symbols are also referred to as define symbols,preprocessor defines, or just defines.

Platform scripting symbols

Unity automatically defines certain scripting symbols based on the authoring and build target platform. These are as follows:

Editor version Scripting symbols

Unity automatically defines certain scripting symbols based on the version of the Unity Editor that you’re currently using.

Given a version number X.Y.Z (for example, 2019.4.14), Unity exposes three global scripting symbols in the following formats: UNITY_X, UNITY_X_Y and UNITY_X_Y_Z.

Here is an example of scripting symbols exposed in Unity 2019.4.14:

You can also compile code selectively based on the earliest version of Unity required to compile or execute a section of code snippet. Following the same version format as above (X.Y), Unity exposes one global #define in the format UNITY_X_Y_OR_NEWER, that you can use for this purpose.

Other scripting symbols

The other scripting symbols Unity defines are:

Test precompiled code

The following example shows how to test your precompiled code. It also prints a message based on the platform selected for the target build.

To test the compiled code:

1. Open the Build Settings window (menu: File > Build Settings).
2. Choose the target platform you want to test your code in and click Switch Platform.
3. Create a script and copy/paste the following code:

  using UnityEngine;
  using System.Collections;
  public class PlatformDefines : MonoBehaviour {
  void Start () {

    #if UNITY_EDITOR
      Debug.Log("Unity Editor");
    #endif

    #if UNITY_IOS
      Debug.Log("Unity iOS");
    #endif

    #if UNITY_STANDALONE_OSX
        Debug.Log("Standalone OSX");
    #endif

    #if UNITY_STANDALONE_WIN
      Debug.Log("Standalone Windows");
    #endif

  }          
  } 

1. In the Game view toolbarA row of buttons and basic controls at the top of the Unity Editor that allows you to interact with the Editor in various ways (e.g. scaling, translation). More info
   See in Glossary, click the Play mode. Confirm that the code works by checking for messages relevant to the platform selected in the Unity console. For example, if you choose iOS, the messages Unity Editor and Unity iOS appear in the console.

Note: In C# you can use a CONDITIONAL attribute which is a more clean, less error-prone way of stripping out functions. For more information, refer to ConditionalAttribute Class. Common Unity callbacks such as Start(), Update(), LateUpdate(), FixedUpdate(), Awake() aren’t affected by this attribute because they’re called directly from the engine and, for performance reasons, it doesn’t take them into account.

In addition to the basic #if compiler directive, you can also use a multiway test in C# in the following way:

#if UNITY_EDITOR

    Debug.Log("Unity Editor");

#elif UNITY_IOS

    Debug.Log("Unity iOS");

#else

    Debug.Log("Any other platform");

#endif

Additional resources

• How to create and use scripts in Unity
• Custom scripting symbols