The following list provides the most common terms used in The Machinery.

The TruthThe Truth holds the authoritative data state of a The Machinery project and allows it to be shared between various systems. In particular, it supports the following features:

- Objects with properties (bools, ints, floats, strings).
- Buffer properties for holding big chunks of binary data.
- Subobjects (objects of other types belonging to this object).
- References to other objects.
- Sets of subobjects and references.
- Prototypes and inheritance.
- Change notifications.
- Safe multi-threaded access.
- Undo/redo operations (from multiple streams).

More information is available in the documentation.
Truth AspectAn "aspect" is an interface (struct of function pointers) identified by a unique identifier. The Truth allows you to associate aspects with object types. This lets you extend The Truth with new functionality.
Creation GraphThe Creation Graph system is a node-based way of creating various types of assets and primitives such as images, buffers, draw calls, etc. It can be used by both tech-artists to create shaders but also to setup data processing pipelines. More
Creation Graph GPU NodesCreation Graphs contain nodes that can execute on both the CPU and GPU. The GPU nodes usually become part of a shader program when the creation graph is compiled. There are nodes that transition data from the GPU and CPU and vice versa.
Entity GraphThe Machinery's Visual Scripting Language for game play. More
PrototypeA "template" The Truth object from which other The Truth objects can be instantiated, inherting the properties of the prototype. For more information on Prototypes. (Also called Prefabs in other Engines)
Properties TabWhenever an object gets focused in the asset browser or entity tree, properties of it can be edited from the properties tab.
Asset BrowserShows all assets in your project in an explorer-style fashion. An asset can be thought of as the equivalent of a file in the OS. Some assets such as entities can be dragged and dropped from the asset browser into the scene tab.
Graph Tab/ViewA tab that can either represent an Entity Graph or a Creation Graph.
Entity TreeHierarchical view of the Entity currently being edited in the Scene Tab.
In The Machinery, every entity has a parent except for the root entity of the world.
This Tab Allows the user to quickly reason about and re-organize the hierarchy by adding, removing, expanding and reordering entities.
Simulation EntryProvides gameplay to start, stop and update functions to the Simulation. This concept consists of two parts: The Simulation Entry Interface (tm_simulation_entry_i) and the Simulation Entry component. The interface is there to provide the functionality, component assigns the functionality to a specific Entity, so that it runs when that entity is spawned.
Engine (ECS)An engine is an update function that runs on all entities that have certain components. (Jobified)
System (ECS)A system is an update function that runs on the entire entity context.
Entity ContextThe object that hold the state of all entities. Can be thought of as holding the state of a "world"
EntityA world is built from different entities which in turn can contain child entities and components. The components create the building blocks of each entity and give them their meaning.
ComponentsProvides functionality and data to an Entity. Can be added / removed both from the editor as well as in runtime, during Simulation.
DCC AssetStands for Digital Content Creation Asset. This is our intermediate data format that contains meshes, materials and images. From these assets the user can extract entities and Creation Graphs that represent the materials and images.
PluginThe Machinery is built around a plugin model. All features, even the built-in ones, are provided through plugins. You can extend The Machinery by writing your own plugins. When The Machinery launches, it loads all the plugins named tm_*.dll in its plugins/ folder. If you write your own plugins, name them so that they start with tm_ and put them in this folder, they will be loaded together with the built-in plugins.
Plugin assetsA special type of asset that contains the library (executable code) for a plugin. This makes it possible to add compiled plugins without have to copy the DLL into a specific folder, instead you can just drag n drop DLLs into the project. The user will be asked for consent to run the code in the plugin.
ProjectIt is a self-contained directory or database file that holds all the game data used during the development.
tmsl.tmsl stands for The Machinery Shader Language. It is a data-driven json front-end to create a tm_shader_declaration_o. The tm_shader_declaration_o can be anything from a complete shader configuration (all needed shader stages, any states and input/output it needs, etc) that can be compiled and used when rendering a draw call (or dispatching a compute job), to just fragments of that. Typically a .tmsl file only contains fragments of what's needed and our shader compiler combines a bunch of them to build a functional shader. .tmsl files can define new Creation Graph nodes.