The UBF framework is made up of three distinct parts, all revolving around a shared open standard.
UBF-fundamentals

​
The Open Standard

At the core of UBF lies a publicly accessible specification known as the UBF Standard. This standard clearly defines what a UBF blueprint can contain and how its data must be structured. As a result, any blueprint conforming to these guidelines can be accurately parsed and executed by interpreters, or modified by compatible tools that implement the same specification. Because the UBF Standard is open and publicly accessible, it provides a foundation on which developers, creators, and other stakeholders can build. While Futureverse offers reference implementations and tooling for key UBF components (covered later in this documentation), adopting the UBF Standard does not lock you into using these particular solutions. You are free to develop your own interpreters, editors, or pipelines as long as they adhere to the specification. This ensures that multiple engines and tools can reliably create, interpret, and execute blueprint data across the entire UBF ecosystem. The official, publicly accessible specification for the UBF Standard is available at https://www.ubfstandard.com

​
The Blueprints

Blueprints are engine-agnostic instructions that describe how to load and assemble any 3D asset or functionality within an experience—regardless of the underlying engine. While a common use case is orchestrating how different meshes, materials, and accessories come together to form a final character or prop, blueprints are not limited to visual assets. They can be thought of as modular, dynamic code capable of injecting additional functionality into any environment that implements a UBF interpreter — effectively, a runtime-injected function into your project. Just like functions in conventional programming, blueprints can define inputs (parameters) and outputs (returns). For instance, a blueprint that spawns a character might accept color or accessory parameters, eliminating the need for separate blueprints to handle each variation. Blueprints can also execute other blueprints, allowing complex behaviors to be divided into sub-blueprints. A character with multiple accessories (e.g., hats, jackets, or props) can be handled by separate blueprints, and then assembled under a single “master” blueprint. This approach maximizes reusability and keeps your logic organized.
NOTE: While the initial focus is on rendering and composing 3D assets, the blueprint system was designed to be inherently flexible. Future iterations could leverage blueprints to define interactions, special abilities, or behavior triggered by user input. Anything that can be described as a sequence of instructions—whether visual or functional—can be handled by a UBF blueprint.

​
The Interpreters

Interpreters are engine-specific plugins or SDKs that read a blueprint’s generic, engine-agnostic instructions and convert them into the native commands required by that particular engine. While each interpreter may carry out different tasks under the hood, the overarching goal is the same: to translate a generic blueprint into a functionally equivalent result within its own domain. Because no two engines handle rendering in the exact same way, interpreters ensure that the end results are as close as possible in each environment, without guaranteeing pixel-perfect parity. In other words, a character might look slightly different due to unique rendering pipelines between Unity and Unreal, but it will remain consistent in its core design and behavior. Currently, Futureverse provides two interpreter implementations:
  • Unity Interpreter (for Unity)
  • Unreal Interpreter (for Unreal Engine 5)
Additional engine or tech-stack interpreters may be introduced in the future. Moreover, because the UBF Standard is publicly accessible, anyone can create their own interpreter implementation, provided they adhere to the specification. This ensures flexibility and opens the door for UBF’s continued expansion across the broader ecosystem.

​
UBF Studio

UBF Studio is a standalone editor application designed to facilitate the creation, modification, and maintenance of UBF projects and artifacts such as blueprints and blueprint instances. It provides a user-friendly, visual scripting environment where instruction sets are assembled by connecting pre-built functional nodes—allowing users to define complex asset compositions and behaviors without the need to write raw code. By leveraging this node-based workflow, UBF Studio makes blueprint creation accessible to all areas of expertise, empowering artists, designers, and technical users alike to build and modify assets efficiently. Although blueprints are compiled and stored as JSON files under the hood, and can technically be created or modified manually, UBF Studio significantly streamlines the process, reducing the risk of errors and improving efficiency with a structured, intuitive interface. As with all components of UBF, Studio is not a required tool—it is simply an implementation of a UBF project editor provided by Futureverse. Since UBF is built on an open standard, other parties are free to develop their own tools for creating and managing blueprints.