Universal Primitives are an exercise in abstraction
In this article we’ll dive a bit deeper into Universal Primitives (UPs), and how they are related to abstraction.
Remember to check out our previous articles in this series, if you haven’t: The Universal Asset framework series.
Syntactic and semantic meaning of objects
In a virtual world, virtual objects such as weapons, armor & clothing, items… have both a syntactic and semantic meaning. Syntactic, in the sense that they are data structures that can be faithfully interpreted, rendered, manipulated, and displayed by the engine of the virtual world. And semantic, in a relational sense, to other objects in that world and the underlying game-mechanics — contextual and functional meaning. Achieving syntactic interoperability of virtual objects across worlds is certainly much easier than semantic interoperability. The standardization of data types, file formats, and other syntactic primitives is pretty straightforward once everyone agrees to a common description language.
There is however as of today, no such thing as semantic interoperability (in the sense described above), since the rules that govern any virtual world are different and independent from those of other worlds made by different creators. The full relational context and behavioral/functional details of any given object with its virtual world of origin, has no faithful translation into a different world where such meanings may be different, contradictory, undefined, or uninterpretable.
This is why most current discussions around Metaverse interoperability focus exclusively on achieving syntactic interoperability, aka, being able to bring an object from one world into another (and render it), but absent of complex functionality besides some barebones integration. To the virtual world it’s almost as if it doesn’t exist, even though we might see the object on screen, it barely interacts — if at all — with the systems or objects of that world. But if we want interoperability that goes beyond syntactic interoperability, into semantic interoperability territory, we need to do things differently. This is where we need to do an exercise in abstraction.
The power of abstraction
Abstraction is a very useful tool, it allows us to blur away details, simplify, and in doing so we can gain clarity and notice how seemingly unrelated things are equivalent to one another. One can apply abstraction to almost anything, start with something that’s very intricate, detailed, complex, and start simplifying it, in a way that it still preserves some properties or structure from the fully unabstracted concept/object we started with. One can keep abstracting, until the point that all that’s left can be just that, a point.
Complete abstraction is not useful, because it erases all details, conversely too little abstraction is not very enlightening. We want the right amount for our needs. One benefit of abstraction though, is that at a certain level, sets of priorly different objects (when looked in detail), become identical or indistinguishable from one another. This could be something we might leverage, as a form of interoperability.
In the same way our organic bodies can be abstracted for example, to the level of our skeletons, we might be able to do the same for virtual objects in the Metaverse. The skeletons of these virtual objects however would not be physical bones, they would be something more abstract, digital, probably relating to some geometric and other type of properties. These object skeletons are what so far we have been calling Universal Primitives (UPs). In the same way every human body has the same type of skeleton, and several things can be deduced about humans from our skeletons, what if every virtual interoperable object also had a skeleton?
An exercise in abstraction
We take a family of similar but not entirely identical objects, such as for example a bunch of virtual swords, each one with their own shape, color, size… and we abstract them (basically simplify and forget details), up to the point we end up with a very basic skeleton, that looks identical for all of these swords. We ask ourselves the question, what makes a sword a sword? Not in a physical sense, but in a digital sense, in the context of a virtual world. This allows us to eliminate a lot of syntactical detail.
Unlike the full description of these swords, their skeletons are much simpler and look the same for all of them, meaning, they are much easier to standardize and make interoperable. This is what we want to do, we want to make interoperable object skeletons (Universal Primitives), with some minimal syntactic and semantical meaning. The remaining details can be left blank, so that asset creators or world-builders can fill them as they wish. We must do this for every type of object we want to be interoperable, each class of object needs to be represented by at least 1 skeleton/UP.
These skeleton objects are the starting point of any interoperable object we want to create or integrate. We don’t start from scratch, our first step is always to pick an existing skeleton/UP (or create a new one if necessary), and continue from there. Luckily the family of object skeletons should be in the range of dozens to hundreds, not millions or trillions of unique bespoke assets. If we make it so that all interoperable objects need to have a skeleton, world-builders can simply integrate them from the beginning, and later on users can import any asset that is built on top of a compatible skeleton.
These skeletons/UPs have already some semantical meaning, the minimum required to make them truly interoperable across different virtual worlds. This meaning is unchanging, preserved. In a sense, virtual worlds care exclusively about these skeletons, additional details such as aesthetics, or additional functionality are up to asset creators and world-builders to decide.
How we build these skeletons
In order to build these skeletons, once we’ve figured out the relevant abstract qualities that make an object, that class of object, it would be wise to devise a constructive modular framework of simple building blocks, that when composed together can give us each of the different classes of skeleton objects we want. These building blocks should then be fairly easy to standardized, and new classes of objects and skeletons can be built, by simply composing them differently.
We haven’t gone into the details in this article, but I believe these building blocks will probably be mostly volumetric/geometrical, with some additional information. Might be as simple as some sort of unit-cubes, that when composed form a polycube shape (the skeleton). This is what we must investigate, what form do we need to give to these building blocks, in order for them to give use useful skeletons/UPs.
