Optimizing Script Performance

This page gives some general hints for how to improve script performance on iOS.

Reduce Fixed Delta Time

Use a fixed delta time of 15-25 fps. You can change this in Edit->Project Settings->Time. This reduces how often FixedUpdate is called and how often the physics engine has to perform collision detection and rigidbody updates. If you are using rigidbodies for the main character, you can enable interpolation in the Rigidbody Component to smooth out low fixed delta time steps.

Reduce `GetComponent` Calls

Using GetComponent or BuiltIn component accessors can have a noticeable overhead. You can reduce it by caching a direct reference to the component.

For example:

function Update () {
    transform.Translate(0, 1, 0);
}

You can optimize your script to this instead:

myTransform : Transform;
function Awake () {
   myTransform = transform;
}
function Update () {
    myTransform.Translate(0, 1, 0);
}

Avoid Allocating Memory

Minimize your allocations in scripts.
Use structs. Structs do not allocate memory, instead they are placed on the stack and are passed by value which is fast.

Reduce the GUI

Don't use GUILayout, use GUI functions instead and minimize the amount of GUI on screen
Use MonoBehaviour.useGUILayout = false; to minimize GUI overhead

function Awake () {
    useGUILayout = false;
}

Use iOS Script Call Optimization

Most of the functions in UnityEngine namespace are implemented in C/C++. Calling such functions from scripts has additional performance overhead. Consider using iOS Script Call optimization in Edit->Project Settings->Player to gain several extra milliseconds per frame:

Slow and Safe - default mono internal call handling with exception support.
Fast and Exceptions Unsupported - fast mono internal call implementation, but exceptions are not supported, so use it with care. A typical scenario when it could be useful: application deals a lot with Unity Engine and does not throw any exceptions. This option could save 1-4 ms / frame.

Optimizing Garbage Collection

As mentioned above ,try avoiding any allocations
If allocations can't be avoided then there are two allocation/collection strategies:
- small heap fast and frequent garbage collection
  This strategy might work well for games that have long action gameplay and needs smooth framerate.
  Typical heap for Unity iOS game which allocates small blocks for short period of time often is ~200 KB, garbage collection of such heap takes ~5ms (on iPhone 3G). With a 1 MB heap the duration of garbage collection increases to ~7 ms.
  Sometimes it can be useful to force garbage collection every Nth frame:
```
if (Time.frameCount % 30 == 0)
{
   System.GC.Collect();
}
```
  But use it with care, watch internal profiler statistics, and make decisions based on them.
- large heap slow and rare garbage collection
  This strategy might work for games that are have short to medium length smooth framerate demanding gameplay. The idea is to avoid garbage collection while gameplay is running and make garbage collections during gameplay pauses. It is good idea to preallocate some space on the heap during startup which is large enough to survive gameplay sessions yet small enough to avoid application killing by OS because of low system memory. Mono tries to expand the heap only when necessary, so sometimes it is good idea to force its expansion on startup:
```
function Start() {
	var tmp = new System.Object[1024];
	// make allocations in smaller blocks to avoid them to be treated in a special way, which is designed for large blocks
        for (var i : int = 0; i < 1024; i++)
		tmp[i] = new byte[1024];
	// release reference
        tmp = null;
}
```
  Later, you can force garbage collection when gameplay is paused:
```
System.GC.Collect();
```
  Use this with care, pay attention to internal profiler statistics, and make decisions based on the actual numbers.

Page last updated: 2010-09-24