5

Unity's documentation has this line:

By default, the Awake, OnEnable and Update functions of different scripts are called in the order the scripts are loaded (which is arbitrary).

So I have two questions here:

  1. What does "Arbitrary" mean in this context? Is it random?
  2. Does this also include Start() alongside Awake(), or does Start() have its own special behaviour that doesn't follow the script execution order, even if that order has been altered in the project settings?

I've wondered for a while how Unity "decides" how it behaves when it runs, especially since it seems like something will work some of the time but the rest of the time it causes a crash or something with little to no explanation, but the documentation doesn't really mention it much and I can't seem to find much info elsewhere.

Improve this question
4
  • 1
    could you not find this out by setting some debug output in these methods and running your game script, so that Awake prints something, and Start prints something else and you can read the logs as to then clarify which occurs first Commented Nov 1, 2016 at 11:02
  • answers.unity3d.com/questions/217941/… Commented Nov 1, 2016 at 14:13
  • I'm not sure if a bug from 4 and a half years ago is relevant to this question Commented Nov 1, 2016 at 14:51
  • See also question and answer of stackoverflow.com/questions/36252189/… Commented Nov 2, 2016 at 13:59

2 Answers 2

Reset to default
4

That statement is somehow confusing.

Awake, OnEnable and Update will always be called in order.

1.What does "Arbitrary" mean in this context? Is it random?

Yes, its random. Although, it is not talking about the Awake, OnEnable and Update functions. It is talking about scripts. The scripts are randomly chosen to execute.

2.Does this also include Start() alongside Awake(), or does Start() have its own special behaviour that doesn't follow the script execution order, even if that order has been altered in the project settings?

Answer #1 should also answer question #2. This does not affect the callback functions such as Start() Awake(), or OnEnable().

I've wondered for a while how Unity "decides" how it behaves when it runs, especially since it seems like something will work some of the time but the rest of the time it causes a crash or something with little to no explanation

Yes, this is true. This has happened to me in the past too. This is more prone to happen when you have large project with many scripts. The scripts are called randomly. Sometimes, you can get null exception error because GetComponent failed to work. This is why the Script Execution Order Settings is made so that you can always set the order in which your scripts execute.

What I do to fix problems like this is to perform GetComponent in a coroutine function. After that, I check if it is null. If it is null, wait for one frame then try GetComponent again.

Again, this applies to the order in which your scripts are executed not order in which callback functions are invoked/called.

Improve this answer
Sign up to request clarification or add additional context in comments.

12 Comments

To clarify: The execution order of e.g. all your Start-functions in your different scripts is random by default. Sometimes Start from Script A is executed first, sometimes Start from Script B, but all Awake-functions will be executed before the very first Start-function.
I know about the order of event functions, ie Awake -> Start -> OnEnable -> Update, with every Awake function across all scripts being called before any Start function is. What I wanted to know about was how Unity decides what the order of "Awake" functions is, for example. And you've answered that, it's random, which frankly I think is pretty dumb, but that's Unity I suppose. Thanks.
Yes, its random. That randomness event starts when a random script is chosen. The chosen random script will then call its Awake function. To correct you, the order is Awake -> OnEnable-> Start-> Update. @GunnarB I think that's correct and that depends on the script that is chosen to run.
It could be added that Awake and Start are clearly different, Awake is like a ctor since MB does not expose a ctor. Start is called the first time the script is run. So if you use AddComponent, you get Awake called, if you disable the following line, you get no Start until it gets enabled the first time (along OnEnable). Start will not be run again while OnEnable will.
And it's dumb because it isn't consistent. I can live with it if something crashes 100% of the time because of something I have or haven't done. But when something crashes 1% of the time because script order is chosen AT RANDOM, it's very difficult to replicate, even with Debugging. I just feel like there should be some consistent default that means the order is the same every time your app is run, even if that order is bad.
|
1

Question 1

According to https://docs.unity3d.com/Manual/class-ScriptExecution.html you can set the order the scripts load manually. If you don't set an order my guess is that Unity uses some predefined order (random, alphabetical or something)

Question 2

Awake() allways runs before Start() and is called when the script is loaded https://docs.unity3d.com/ScriptReference/MonoBehaviour.Awake.html.

To load the scripts in a specific order you need to use the script execution order. To make sure you run the Start() function of each object in a specific order you need to make a "Manager" object that instantiates the objects in the order you wish.

Improve this answer

4 Comments

Apparently if you don't set anything the order is random. I know that Awake() runs before Start(), I simply meant is Start() affected by the script execution order, because the documentation implies that it isn't.
I don't quite understand the question. Start() is run as soon as an object enables a script, right before the Update() is run. So the order in which the different Start() are run is determined by the order you enable the scripts
Well exactly, it's confusing. Documentation says "Awake, OnEnable and Update Functions" are called in the script execution order, but doesn't mention Start(), so when a scene first starts up, after all the Awake functions are called, what happens with the Start() functions. Are they called in the same order, or is their order arbitrary anyway, which would make it a different order to the awake functions?
Well, ok. Objects already in the scene I am unsure about. Can you test this by logging something in the different Start() functions and see if it seems random or not? This is why I wrote that to guarantee the order you need to use some sort of "Manager" object that instantiates your objects when pressing play.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.