About This Article
This article breaks down the Patent filed for Spatial Management of Objects Using Hierarchical Structures as presented by Cloud Imperium Rights LTD. This patent is interesting because it proposes the following:
"A method for spatial management of objects, comprising:
- providing, in a memory, a hierarchical tree structure with a root node and a plurality of nodes on a plurality of depth levels, wherein a node represents a cell of a spatial subdivision of the multi-dimensional space
- encoding, by an encoder, coordinates of an object in a multi-dimensional space into a code, the code including a sequence of successive sections, each section including interleaved one or more successive bits of the coordinates from each dimension of the multi-dimensional space
- associating, by a processing unit, the object with a node of the plurality of nodes based on the code, wherein objects located within a cell of the spatial subdivision share a common node at a corresponding depth level in the hierarchical tree structure
- storing the object in an object array of the associated node in the memory."
As described by the patent filed in November of 2024 and published July 2025.
This article breaks down the patent and provides information about how this patent relates to Star Citizen and gaming as a whole and also provides an easy-to-read breakdown of the patent.
Terms Used / Glossary
The patent referenced in this article contains some terms that we list and explain here to make it easier to read before resorting to AI translators:
View Frustum
An area of 3D space that will be rendered for an object. Think of it as the geometry the camera view sees. In this case the entire object does not need to be rendered, nor do the objects within the node. Only the parts of the object that the camera can actually see, therefore saving computation as the entire object does not need rendering.
Interleaving
Takes a 3D space and turns it into a one dimensional number. In this case, an object, node, or even multiple nodes can be referenced quickly by referencing interleaved bits of data. An encoder is also used for mapping that makes interleaving reliable and reusable.
Encoder
The coordinates of an object (or other aspects such as the dimension or level) can be extracted into a binary representation and then interleaved into a single string of bits. The closer two points are in the original space the more leading bits they share.
Bit Mask
Used to shift bits in order to deal with specific bits within the 64 bits for example selecting the coordinate bit sequence to then derive node indices. These operations are supported by CPUs and GPUs and makes searching for objects much faster.
Processing Units
CPU or GPU activity required to perform one step in the process such as encoding or mapping.
Summary For Star Citizens
This Patent describes a way to handle objects and spaces in virtual 3D worlds using 64 bits. While Video Game engines can offer 64 bits (also called Double) precision for spatial areas, the operations for the simulation are usually happening in 32 bits. This patent makes claims on using 64 bits to make operations on objects in the game engine. Essentially, the methods used make objects behave more like memory in terms of searching or editing. By using the full 64 bit register an object´s position, dimension and other characteristics can be accessed very quickly. Connected nodes can also be walked very quickly which leads to improvements in rendering and search times to name just two benefits.
As the Patent's title reads, it describes methods for how to manage objects in memory spaces using 64 bits.
Detailed Description
The main benefit of encoding and interleaving object data into a 64-bit string is fast memory referencing. The following sections of this article will look at each method mentioned in the patent and explain how it relates to Star Citizen in terms of performance benefits.
Spatial Indexing Structure
A computer memory tree that divides the game universe into cells. This helps the game engine quickly access which objects need to be processed at a player location. Instead of using a double float for 64 bit precision, the object's location is now handled by a memory tree.
Spatial Coding
The virtual world coordinates for an object are turned into spatial code by interleaving bits for X, Y and Z (for example). This is different to just using coordinates represented by 32 or 64 bits. It allows for nearby objects to also be nearby in memory.

Object Placement
An object is stored in a node who's spatial code matches the object's code. Each node also keeps an object array of objects that belong to it. This allows for things to be within things in Star Citizen and also for faster retrieval access to objects in memory. For example, object codes for items within a ship can be located near each other in memory if the spatial code matches the object's code. Nodes for objects can be hierarchically walked quickly as the interlaced codes replace the need for other data structures.

Tree Levels as Code Sections
Every depth level of the tree corresponds to one section of the spatial code. Depth levels can be used to increase fidelity at higher levels (level 20) and can represent a universe at the lower levels closer to the root. In a way this creates multi dimensional universes based on the depth level with each level having its own meter scale.
Octree Specifics
When using an octree, each level splits space into eight children recursively. Two consecutive splits can be represented by a six‑bit section. 2 raised to the third power gives 8 3D cells which can be used as quadrants in 3D space. This helps fix the scale problem allowing Star Citizen to locate where an object is (at which scale) quickly. Irrelevant branches of the tree can be culled easily for example to avoid rendering objects out of view or too far. It also allows for moving objects to be moved to different nodes easily. Servers are also able to host sub-octrees so that clients only talk to the server that the client is moving in. The octree is also responsible for the hierarchy of objects allowing the game to run smoothly even with millions of objects and players.

Culling & Querying
While traversing the tree, nodes that fail visibility and other criteria are skipped (culled). Nodes that pass are queried for their objects. This allows efficient population of objects in the universe.

Node Data
A node contains a node array indexed by a bit-mask that points to child nodes as well as an object array that lists objects contained in the node. Think of your ship as being a node and all the items in the ship being contained in an object array for your ship object.

Tree Maintenance
Empty nodes are removed, and single‑child nodes are collapsed to keep the tree lean. This allows for the index to not grow out of control and preserve access speed advantages.
Dynamic Object Movement
When an object moves in 3D space the coordinates change and it can seamlessly be moved to another node. This allows for ships to traverse large regions of space seamlessly changing nodes and even servers (since the server handles many nodes).
Distributed servers
Large multiplayer sessions are handled by multiple dedicated servers, each responsible for a slice of the world. These servers can support many concurrent players and are not fixed to specific objects. A server can be a whole planet and its moons or a ship or both. Each server can be responsible for a slice of the world and what that slice is can change based on server resources or other criteria.
Terminal queries
The client’s rendering engine requests all objects in visible nodes from the server. This means, in theory, that only objects that need to be shown to the client are presented and processed. This can include all aspects from graphics rendering to mission information. When a client makes a Terminal Request the game servers will return Object ID's and other data such as position, rotation, scale, mesh ID, physics flags, script references, etc. It can also return delta data for only the parts that changed since the last request to further reduce packet size. This is important because the server has more control over what happens to an object in this setup. The terminal uses the data received from the server to perform physics, AI and UI local logic and if different players see the same thing then their clients will interpret it the same at the same time (of package receipt and decompress / decode).

Putting It All Together - Dynamic World‑Streaming via Terminal Queries
Octree‑based spatial partitioning allows for lower bandwidth and faster lookups. The patent also shows how to use 64 bits to achieve a seamless universe with high fidelity. Instead of whole world data being sent to every client, only cells that intersect a player's view are sent. Terminal query packets give the servers more control over objects, reduce latency and provide higher framerates. Server‑authoritative culling means the client does not have to guess about things and has a real-time view of the game universe. Objects are handled by the server and no trust is placed in the client causing cheating resistance. Delta compression & sequencing streamlines data sent in packets by only sending changed data thereby shrinking payloads to less than 2KB. Dynamic node routing allows for scalability to millions of players. The methods claimed in this patent lead to a 3D universe that has less cheating, lower latency, lower bandwidth and higher framerates.
Bonus Content - A Note From The Author
It is great to get a detailed look at the planned technology that is making Star Citizen a reality. Video game engines have been stuck using 32 bits for a long time. Even recent changes, such as using double float precision to increase game world sizes beyond 4GB maps, still fail to use many of the advantages provided by 64-bit technology. By spatially segmenting object data using 64 bits, gaming simulators are getting closer to taking full advantage of the 64 bit registers in modern CPUs and GPUs. By using shift bit operations instead of double float arithmetic, the performance drop that 64 bit double float operations have over 32 bit is avoided.
It is also pretty amazing for me to see objects in Star Citizen being used as memory for sorting, searching and updating. By leveraging the 64-bit register using the methods claimed in the patent Star Citizen can get the performance required for a seamless universe inhabited by millions of players and NPCs.
Using double floats for spatial reference now seems outdated and case-specific to me. Mapping your universe as memory with dimensional levels and a plurality of nodes is brilliant and I wonder if C++ direct memory access is what allows for this to be doable? Also, it seems very clever that this solution gets around computationally expensive double float operations and uses bit masks instead to handle coordinate changes.
Star Citizen still has many existing technologies to leverage, such as IPv6. 64‑bit technology has been available for a while, and everyone can benefit from its advantages today, whereas IPv6 is only accessible to a select few. Object generation from seed could also abstracted more generally and leveraged. To what degree seed gen is used throughout Star Citizen remains but a guess for me, even after examining this patent.
This technology brings full streaming capability for Star Citizen much closer and should address a lot of the cheating issues recently witnessed by players.
References
CLOUD IMPERIUM RIGHTS LTD. (2024). Spatial management of objects using hierarchical structures (EU Patent No. 24151433). WIPO. https://patentscope.wipo.int/search/en/detail.jsf?docId=EP459626877