A list of important terms and concepts used in coherence

Authority defines which Client or Simulator is allowed to make changes to the synced properties of a networked entity, and in general defines who "runs" that entity.

In some cases, authority can be divided between State authority and Input authority. When a Client or Simulator has both (which is the default behaviour), we say it has "Full authority".

The process of generating network code for your GameObjects. It does two things: schema generation and code generation. This process is done automatically by coherence.

Bandwidth usage

The data that Game Clients exchange with the cloud-hosted Replication Server to sync Rooms or Worlds and all the players and other game objects within them.


A binding represents a relation between the property of a connected Prefab and a field on the corresponding network entity. In practice, it's what tells coherence to sync a specific property, which Unity component to read/write to, how often, and to what precision.

Bindings are usually assigned using the Configuration window included by the Unity SDK, and are saved in the CoherenceSync component. When the user initiates the Baking process, they contribute to create the schema – so that coherence knows that when the game is running and that particular entity is in the scene, it has to sync that property.

CCU hour

In plain terms, CCU hour is the number of connection slots for a World/Room, times the number of hours the World/Room was online. The calculation is based on the maximum player capacity these are reserved for, regardless of how many players are active within them.

Represents a Client or a Simulator in a game. Client Connections can be used to communicate between players because they are always visible to everyone connected, regardless of the users' LiveQueries.

The ability for Clients to host their own game sessions and connect to each other in a peer-to-peer fashion, without the need of hosting the Replication Server in the cloud. The SDK for Unity achieves this by bundling the Replication Server binary and the schemas needed for the project within the built game.

Code generation

The process of generating network code for CoherenceSync Prefabs. Part of the baking process.


A component that represents a connection to the Replication Server. It makes sure CoherenceSyncs are linked to their networked representations, serving as an interface between Unity's GameObjects and coherence's network. When you place a CoherenceSync in your Unity scene, the Bridge detects it and makes sure objects in the scene are synchronized.

A platform for hosting and scaling the backend for your multiplayer game. The coherence Cloud can host a Replication Server, but also Simulators.

CoherenceInput is a Unity component that enables a Simulator to assume authority over the simulation of another Client's objects, enabling server-authoritative setups. The objects only accept inputs from one specific Client (the object’s Input Authority), and the Simulator elaborates the state.

Use CoherenceInput when a) you want a centralized simulation of all inputs b) Clients have low processing power c) determinism is important for your project.


CoherenceSync is a Unity component that should be attached to every Prefab you want to network, and allows to define what properties to sync.

A Prefab that has a CoherenceSync component becomes a network entity, and can be seen – and synchronised – by the Replication Server.


See Network command.

Distributed authority

A flexible way to architect a game so that authority over entities is distributed among Clients (and possibly Simulators). Each Client who creates an entity initially has authority over it. During the game, Clients can request authority over entities, or relinquish it, according to gameplay needs.

This is a cheap way of running a networked game and is suited to co-op or non-competitive games. It is opposed to a model where authority is centralised on one side (often a Simulator), which is usually referred to as server-authoritative setup.


See networked entity.

Useful features for multiplayer games that coherence offers, like Key-value store and Authentication Service (Player Accounts).


In networking, a host is generally a Client with special powers that controls and simulates gameplay, and that other Clients connect to. Sometimes this concept overlaps with that of a server.

In coherence, we don't enforce an actual host, and often the authority of entities is distributed among Clients. In some cases, a Simulator can be connected as part of a server-authoritative setup, and while sometimes users might refer to it as "the host", it's not.

Note: We do provide the ability to establish a connection to the Replication Server "as a host". That allows a regular Client to get Simulator powers, taking control of server-side only entities. This is an experimental feature.

Host migration

Because of what described in the Host section, host migration has a slightly different meaning: to ensure that a game is not interrupted, the Replication Server needs to keep running.

If it's hosted in the coherence Cloud, we take care of that. If it's Client-hosted, migration is achieved by having one of the game Clients run the Replication Server again locally, and the other clients reconnect to it. This needs to be implemented in game code, specifically for each game.

Input Authority

A Client has Input Authority over a networked entity when the game is configured with a server-authoritative setup. In this scenario, the Simulator (server) retains State Authority for that entity.

See also CoherenceInput.

(key-value store, KV store)

Provides a simple persistence layer. The KV Database matches a short key (identifier) to a specific value (data payload) held in a simple, unstructured database. For example, KV store can be used to store the player's score, email address, or any other data. There are no limits to the total number of key/value pairs as long as the total size stays under 256KB.


An optimization technique to adjust the resources spent on networking entities, based on distance. CoherenceSync Prefabs can define LODs, which are applied subtractively: each level can compress the information sent (less data, but also less quality) and also stop sending data altogether.

(areas of interest, queries)

Used for filtering network entities by distance, as an optimization measure. LiveQuery area is shaped like a box, and the distance is measured from the middle to the edges. See also TagQuery.


Multi-Room Simulators are Room Simulators which are able to simulate multiple game Rooms at the same time. A great tool to optimise Room-based games, but they require additional setup.

(command, RPC, Remote Procedure Call)

A request to invoke a method on another Client or Simulator (other solutions may refer to this mechanism as RPC). Can be used to act on entities that the current Client is not authority on (the responding authority can of course deny the action).

Network entity

(entity, networked entity)

An object that is networked, and whose properties are set to sync over the network. The Replication Server – being engine agnostic – doesn't think in objects/Prefabs/Actors, but in entities.

In our Unity SDK, each connected Prefab instance corresponds to an entity. Instantiating the same Prefab 3 times would mean that the Replication Server sees 3 entities.

Online Dashboard

The front-end of the coherence Cloud, used for managing your coherence projects. Can be found at when logged in.


In the context of the Online Dashboard, the organization that uses coherence for its project(s).


An entity is said to be an orphan when no Client or Simulator has State authority over it. Only persistent entities can become orphans, non-persistent ones get destroyed.

coherence supports persistence out of the box. Connected Prefabs (entities) can be marked as persistent on their CoherenceSync.

When their authority disconnects, their networked properties will be automatically saved in a database. Whenever someone assumes authority over them again, the saved values will be used and the entity's state restored.



A way of connecting clients to each other, without a server. Still requires a relay for the clients to find each other. See Client-hosting.


In the context of the Online Dashboard, a project identifies a specific game or application within the coherence Cloud. Projects are owned by an Organization.


A fundamental piece of the coherence architecture. It's an executable that replicates entities across the network between Clients and Simulators. It comes as a binary provided by the coherence SDK, and can be used for development or distribution, and hosted on our cloud, locally, or even inside of the game as part of a client-hosting setup.

Short-lived multiplayer environments. Perfect for quick session-based matches. For accommodating more players, see Worlds.


A file that defines which data is networked, generated automatically by coherence as part of the Baking process. It defines network components, commands, inputs and archetypes.

In general, you shouldn't worry about schemas unless you have advanced needs.

SDK for Unity

A package distributed through UPM, that allows developers to use coherence to develop multiplayer games in the Unity engine. The SDK takes care of bridging GameObjects and Prefabs and make them visible, as network entities, to the Replication Server.

See how to install the Unity SDK.


See Simulator.

(Simulator server, servers)

A Simulator is a headless client that can run game logic. It can be a way to make your multiplayer game logic tamper-proof; or to run a physics simulation all on one machine, ensuring coherence results even when non-deterministic physics are available.

Note that even when a Simulator is used, it still has to connect to a Replication Server – exactly like all Clients do.

Simulator slug

A string of text that uniquely identifies an uploaded Simulator, making it easy to differentiate between various World or Room Simulators during deployment. The Simulator slug should be descriptive for ease of use purposes, although coherence supports any string value.

State authority

When a Simulator or a Client has State authority over an entity, it means they can change its state.

In server-authoritative games, Clients give State authority to a Simulator for anti-tampering reasons and only keep Input authority. But for non-competitive games, State authority can lie with Clients that create the entities. However, coherence allows for flexibility as well - for example, state authority can be configured so it can be transferred to other Clients or Simulators, and reassigned continuously in the course of the game.

See also Input Authority.

State replication

A job for the Replication Server: determining the state of the game and then syncing it to all the connected Clients and Simulators.


Storage relates to the cost of keeping data on coherence cloud. It is measured in terabytes (TB) per hour.

In addition to the LiveQuery, coherence also supports filtering objects by tag. This is useful when you have some special objects that should always be visible regardless of World position.

Note that TagQuery is a coherence component, and has no relation with Unity GameObject tags.

Entities can be made unique, to ensure that only one copy of that specific entity can exist at a given time. If a Client or Simulator tries to instantiate that entity when one still exists, it will be denied by the Replication Server, and their copy will immediately be destroyed.

Long-lived and permanent multiplayer environments for thousands of players. Best suited for MMO-type games. For more smaller player counts, see Rooms.

Last updated