At the core of the Cavrnus platform are the Operations and Transients that are written to the Journal.
Operations
Operation are the updates performed within a Cavrnus Space that are synchronized to all connected users. These operations can be triggered by multiple commands and functions within the Cavrnus Spatial Connector, for example:
Post X Property
Bind X Property Value
Begin Transient X Property Update
Finalize (X)
The above examples are function calls specific, with multiple overloaded examples for the various datatypes that Cavrnus supports. In each example, the X refers to the specific data type supported by the overloaded function.
Transform
Boolean
Float
Integer
String
etc.
Color Vector
Transients
A Transient, is a communication sent by a user which is not permanently stored in the journal. Transient communications involve either temporary or unsynchronized state changes. When a new user joins the space, they will not be updated with any historical transient information; they only receive and process the permanent journal. This simplifies the data history in the Journal
Common transients include:
User metadata ( user entry and exit from the space, avatar position, camera position, mute state, streaming state )
Client to client application communications needed to synchronize certain systems.
Client pings to get other users attention.
Requests for other users to follow.
But the most important transient is most likely:
Operations in progress.
As an example, while a user is manipulating an object’s position, they will frequently send transient operations as they change the object’s values. When they release the object they will submit a finalized Operation. Or if they instead hit Escape or otherwise cancel, they will send a transient event cancelling the in-progress process.
Lastly, transient events are often echoed locally; they take effect immediately within the executing client’s application. Operations require guaranteed ordering, so they only ever are applied after a round trip to the Cavrnus API server. Since latency makes for bad UX, transients are applied locally immediately. The journalling system will ensure that the correct synchronized state is reached despite a potential order difference when multiple users manipulate the same fields simultaneously.
In short:
Operations are permanent changes.
Transients are temporary state transmissions and coordination systems.
In the Cavrnus Spatial Connector, transients are temporary or ephemeral objects that exist in a shared scene only as long as they’re needed, without permanently altering the persistent state of that environment. Below is an overview of how they work and why they’re used:
Example Transient Sequence:
Consider a user ‘A' dragging a slider for X to update a float value starting at 0 then releasing on 2.
User A: The local value of their interface changes consistently from 0 to 2 at the refresh rate of the application.
The Journal: Update operations are posted to the Journal from 0 to 2. This update occurs as fast as the network can handle, posting transient updates to the Journal. These values are marked in the Journal with a “T”.
User B: While the change is occuring, User B witnesses the updates live while connected to the Space copresent to User A.
User A: Releases the controller, and no longer actively changes the value. At this point, the system “Finalizes” the value at 2.
User B: Sees the final state of the value at 2.
User C: Logs into the Space after the property value is finalized. The Transient values are not visible. Only the final state of the property is visible.
Client applications will mark the transient events completed and reorder them to match the operation’s ordering, determined by the API server. In most cases, the live state will not need to be updated, as it is already correct.
Implementing Transient Updates in Unreal Blueprints:
