This event is a request to the process to create as many outputs as possible given current information. On each successive call to this event, more inputs will be available on the input interface.


This event is called multiple times, interleaved with calls to the same event on other Processes in the System. This iterative connection process allows Processes to choose whether to create outputs, and the type and structure of those outputs, based on the inputs it receives. The iterative process is as general as possible, but certain simplifications can be made by most Processes.

In its most general form, the procedure in response to this event is as follows, on each call:

Check which inputs are available (and validate them if necessary).

Create as many outputs as possible.

The iterative process will continue until the Process has seen all of its inputs, so on the last call to this event all inputs will be available, and the Process should have created all of its outputs when it returns. On earlier calls, any number of inputs may be available, depending on the context (the System). However, more inputs will always be available on each successive call. Therefore, a Process that receives three inputs will receive, at most, four calls, with 0, 1, 2 and 3 inputs available on each call, in that order. Depending on context, the same Process may receive one call with 3 inputs available, or two calls, with 0 to 2 inputs available on the first and 3 available on the second, etc. A Process that takes no inputs (e.g. a data source) will receive exactly one call to this event, by the same logic.

Many processes will be able to simplify this iterative process in one of two ways. The first case is if the process cannot create any outputs until it has seen all of its inputs. This is not, in fact, a very common case, but can be a useful shortcut to get started developing a Process. Such a Process should set F_NEEDS_ALL_INPUTS, and the framework will then send it exactly one call to this event, with all of its inputs available. The downside, the reason you shouldn't generally set this flag, is that if all Processes set it, a connected System can never be instantiated, and you will get Deadlock when you try to run it.

The second, more common case, is a Process that can create all of its outputs without seeing any of its inputs (if the output number, type and structure are all implicit). Such a Process can create all of its outputs in the first call to this event, and validate all of its inputs in the last, without considering how many times the event is actually called (note that the first and last call may be the same call).


  • Examine and validate newly available inputs.
  • Create as many outputs as possible. It is important that you create outputs as early as possible (i.e. as soon as you have enough information) since failure to do so will make some systems uninstantiable (cause Deadlock) unnecessarily.