Glossary

Reflection specific

Reflection: What lets the engine look at your types while it's running: to save them, show them in the Inspector, send them over the network and call them from scripts. Types opt in with HYP_CLASS, HYP_STRUCT and HYP_ENUM, and methods with HYP_METHOD.
CodeGen Tool: The tool that reads the engine's headers and writes the reflection, serialization and scripting bindings for them. It runs whenever CMake configures, and its output goes in Source/Generated/. See building.
Object: Anything built on Hyperion's object system. It gets reflection, ref counting, serialization and a unique ID. Those IDs only last for the current run, so don't save them anywhere.
Class: Runtime info about a type: its name, fields, methods and parents. Mark a class with HYP_CLASS() and CodeGen takes care of the rest.
Handle: A strong reference to an object. When the last handle goes away, so does the object. Make one with MakeHandle<T>(). WeakHandle is the non-owning version.

Scenes and what's in them

World: The top-level object your game draws and simulates. A world is made of scenes, and scenes are made of nodes. You can have several worlds, but only one is active at a time.
World flags: Switches saved with a world, like IsReplicated. Plugins can also limit their systems to worlds with certain flags.
Scene: A level, or a region of your world. Scenes can be streamed in and out, and each one keeps an octree for spatial queries and culling. A scene is a tree of nodes, some of which are entities.
Node: Something with a position, rotation and scale that can have children. Children move with their parent.
Entity: A node you can attach components to. Most things in your game will be entities. See entities & components.
Component: A chunk of data attached to an entity, like a mesh or a transform. Components describe what an entity is, and systems decide what it does.
EntityTag: A marker on an entity which doesn't hold any actual data. Example of an EntityTag in the engine to look at is Replicated, which allows an Entity with this EntityTag to opt into matching its state on a client to an authoritive server. Systems can use tags to pick which entities they work on.
System: Code that runs over every entity with a certain set of components, in parallel. Components are the data, systems implement the logic. Systems live on the world and run over every scene in it. See writing a system.
Subsystem: World-wide logic that isn't tied to entities or components, like a day/night clock. It gets an Update() call every frame, and a world has at most one of each type.
Transform: An entity's position, rotation and scale. Local values are relative to the parent node, and world values are global and not relative to the parent.
Camera, Light: Entities that view the scene and light it.
View: What a camera sees: the slice of your scene that gets rendered. You can have a few at once, like one for the main camera and one for shadows.
Swatch: A saved variation of your world, like Noon or Dusk. A swatch overrides some entity properties and shares the rest, and each one has its own baked lighting. Every world starts with one called Default. See swatches.
Override: A property value that belongs to one swatch rather than the whole world. With Override Edits on, your edits are saved as overrides for the active swatch.
Prefab: A reusable group of nodes, saved as an asset, that you can drop into any scene. Each copy you place is a prefab instance, and Sync Prefab syncs an instance's changes back to the prefab. See prefabs.

World streaming

World grid: The grid every world uses to decide what's loaded. It's made of one or more layers. See world streaming.
Layer: One grid of streaming cells, with its own cell size and load distance. Scenes and terrain each get their own layer.
Streaming cell: One square of a layer. Cells close to a streaming volume are loaded, the rest are unloaded.
Streaming volume: The area around something that keeps cells loaded. Cameras have one, and in multiplayer the server keeps one around each player
Streaming centroid: The grid cell a scene belongs to. Set in the Scene's properties, designates where in the world the scene is located, and which streaming cells it will be loaded into.

Rendering

Backend: The graphics API the renderer runs on. That's DirectX 12 by default on Windows, Vulkan everywhere else, and WebGPU in the browser.
Render proxy: Rendering runs on its own thread. Scene objects hand their data over through render proxies: the game thread writes, the render thread reads.
Clustered shading: How the renderer handles lots of lights at once. The screen is split into clusters, and each pixel only looks at the lights in its cluster. Opaque surfaces use the deferred path. Translucent ones use a forward pass.
Material: Applied to an Entity with a MeshComponent, handles color, roughness, metalness, normals and so on. Materials use a standard PBR model, initially based on Google Filament's implementation. See materials.
Bucket: The group a material belongs to, such as: Opaque, Translucent, Sky, etc. It decides which pass draws it.
Shader: A program that runs on the GPU. Hyperion's shaders are written in HLSL, compiled with DXC (soon zdxc), and listed in Config/Shaders.hmf. See writing shaders.
Permutation: One variant of a shader, compiled with a particular set of defines. They're declared at the top of the shader file.
Global illumination (GI): Indirect light: light that bounces off surfaces before reaching your eye. See global illumination.
Glimmer: Hyperion's realtime GI. Glimmer doesn't need ray tracing hardware or an offline bake pass, and it relights the scene as soon as the sun or sky changes. It covers static geometry,so moving objects receive its light but don't affect it.
Probe: A point in the world that records light from all directions, which objects can then sample to get indirect light. Probes can be baked or realtime, and they can be irradiance probes or reflection probes.
Lightmap: A texture holding baked light for static geometry. The editor generates the UVs for you via xatlas
Lightmap volume: A box marking the area the lightmapper should bake. LightmapVolumes are an Entity in the world, and you can have more than one in a scene
Static, dynamic: Static objects don't move, so their lighting and shadows can be baked or cached. Dynamic objects can move, and are lit and shadowed every frame.
Fog volume: A region of fog that light scatters through. Light from static lights in it can be baked.

Physics

Jolt: Jolt Physics, the library Hyperion uses for rigid bodies and character controllers.
Rigid body: An entity that physics moves around. Add a RigidBodyComponent to make one. See rigid bodies.
Static body, dynamic body: A body with a mass of 0 is static: other things hit it, but it never moves. Give it a mass above 0 and it's dynamic.
Physics material: A body's mass, friction and restitution (how bouncy it is).
Collision shape: The volume physics uses for a body. It can be a simple shape like a box or capsule, a convex hull around a mesh, a compound of convex pieces, or a height field for terrain.
Character controller: A component for player-style movement: walking, running and jumping, with collision against the world. See character controllers.
Coyote time: A short grace period after walking off a ledge where a jump still works.
Jump buffer: How early before landing a jump press still counts.

Multiplayer

Dedicated server: A copy of the game that hosts a match without a player of its own. Any game executable can run as one with --server. See running a server.
Headless: Running with no window or rendering, like a dedicated server does.
Client: A copy of the game connected to a server. It sends the player's input and shows what the server sends back.
Authority: Having the final say over the game state. The server has authority, and so does a game that isn't connected to anything, like single player.
Replication: Sending entities from the server to clients and keeping them in sync. Entities with the Replicated tag are replicated. See replication & prediction.
Network ID: The ID the server gives a replicated entity, so the server and clients agree on which entity is which.
Interpolation: Clients render slightly in the past and blend between the last couple of server updates, so movement looks smooth even though updates don't arrive every frame.
Dead reckoning: Guessing where something is headed from its last known position and velocity, used when updates arrive late.
Client-side prediction: The client moves its own player straight away instead of waiting for the server, so input feels responsive.
Correction: When the server disagrees with the client's prediction, the client rewinds to the server's position, replays the moves since, and smooths out the difference. Big differences snap straight there.
Cache server: A small server that hands out a project's content. When the editor plays as a dedicated server, clients that connect get your saved project from it.

The editor and projects

Project: Everything that makes up your game, in one folder: scenes, assets, scripts and settings. The .hypproject file is the project itself. See working with projects.
Asset: Anything in your project's Content folder: meshes, textures, materials, prefabs, scripts and so on.
HMF: Hyperion's readable text format for assets and other data. Large binary data goes in .blob files next to them.
Inspector: The panel that shows whatever you've got selected: its components, tags, layers, script and properties.
Play-in-editor / Simulation: Running your game inside the editor, without making a separate build. Stopping puts everything back the way it was by setting the active project back to the in-memory one from before simulation started. See play-in-editor.
Game class: The class in your game project that the engine runs, with hooks like OnLaunch and OnUpdate. It's named after your project, with Game on the end.
Game module: The DLL your game's code builds into, like MyGameGame.dll. The editor loads it to run your game, and a small launcher executable loads it when the game runs on its own.
Hot reload: Loading new code into the editor without restarting it. The editor picks up a rebuilt game module by itself, and scripts recompile when you save them.

Settings and tools

CVar: A console variable: a global setting you can change while the engine runs, like Rendering.TAA. Most start out with values from Config/EngineConfig.json. See console & CVars.
Commandlet: A self-contained task, like precompiling shaders or baking lighting. Run one from the console, or with --exec on the command line.i
Device tier: Rules in Config/DeviceTiers.hmf that change settings depending on the device: its type (desktop, laptop or mobile), platform and grade (low to ultra). See device tiers.

Scripting

Script: Gameplay code attached to an entity with a ScriptComponent. Each entity gets its own copy of the script's state. See your first script.
Bindings: The generated code that lets scripts call into the engine. CodeGen writes them from reflected C++ types. See calling engine code.
Blittable: A struct made only of plain value fields, with no classes, strings or arrays. C# components have to be blittable.
NativeAOT: .NET's ahead-of-time compiler. Packaged C# games use it, so players don't need .NET installed.

Building and shipping

Cooking: Converting your project's content into compact, ready-to-load data for a packaged game.
Packaging: Cooking your content, precompiling its shaders, and putting everything into one folder that runs on its own. See packaging a build.

Plugins

Plugin: An optional feature you can turn on or off per project, like AnimToolkit. Plugins can add systems, components, content and editor tools. See plugins.
Module: One library in the build. Every folder under Source is one, and a plugin is made of one or more. Modules whose names end in Editor are only built into the editor.
Descriptor: A plugin's .hypplugin file, which holds its version, description and dependencies.
Editor extension: Editor-side code a plugin adds to the viewport, with hooks for updating, drawing and picking.
Import processor: Code a plugin runs after a model is imported, to add components or tweak the result.