Init(args) is a straightforward and type-safe solution for providing your components with all the objects that they depend on.

Here are some reasons why Init(args) could be the ideal choice to power the architecture of your next game…

It’s Simple

Init(args)’s Inspector and attribute-based workflow is incredibly intuitive – the basics can literally be learned in a matter of minutes.

[Service(FindFromScene = true)] // <- Register a service
class Player : MonoBehaviour { ... }

class Enemy : MonoBehaviour<Player>
{
   protected override void Init(Player player) { ... } // <- Receive the service
}

Thanks to this all developers in your team can use Init(args) to connect objects together – no software engineering degree required.

It’s Inspector-Integrated

Services that clients will receive are visualized in the Inspector and support click-to-ping – just like you’re used to with serialized fields!

It’s Dependable

Clients always receive the services they depend on before their Awake event – regardless of whether they’re loaded as part of a scene, instantiated from a prefab, or created using AddComponent.

class Enemy : MonoBehaviour<Player>
{
   Player player;

   protected override void Init(Player player) => this.player = player;

   protected override void OnAwake() => Debug.Log($"Player: {player.name}"); // <- this is safe
}

It’s Debuggable

Forgot to register a service that is required by a client?

Init(args) will display a warning in the Inspector and log a warning in Edit Mode, and throw an exception and visualize unserialized fields in the Inspector in Play Mode.

It’s Highly Flexible

Global and local services, full interface support, cross-scene references, value providers… don’t let Init(args)’s ease-of-use mislead you into thinking it’s lacking in the power department!

It’s Fast

The simple and type-safe injection pipelines at the heart of Init(args) don’t depend on reflection, IL post-processing or source generators, while delivering class-leading performance.

Main Features

1. Global Services – simply add the [Service] attribute to create a global service.
2. Local Services – simply use the context menu in the Inspector Window to create a local service.
3. Full Interface Support – assign components, scriptable objects and plain C# objects into the same interface fields.
4. Cross-Scene References – just drag-and-drop an Object reference from one scene to another.
5. Prefab Instance References – just drag-and-drop a prefab asset and pick ‘Prefab Instance’.
6. Value Providers – localized strings, randomized values, addressable assets…
7. Wrappers – attach plain old C# objects to GameObjects and make unit testing a breeze.
8. Instantiate with arguments – pass arguments when instantiating an Object.
9. Add Component with arguments – pass arguments when attaching a component to a GameObject.
10. Create ScriptableObject with arguments – pass arguments when creating a ScriptableObject.
11. new GameObject with arguments – create a new GameObject and initialize its components.
12. Type-safe and reflection-free injection
13. Asynchronous Initialization Support – Want to load services from Addressables to avoid stuttering? Init(args) has got you covered.
14. Deferred Initialization Support – A service is not ready yet when a client is being loaded? Init(args) can automatically delay its initialization!

Let Init(args) take care of all the dirty plumbing work, and allow yourself to fully focus on just creating a great game!