The Horizon Editor

Orientation

Editor Layout

The editor is a single window built from dockable panels around a central Scene viewport. Double-clicking assets opens additional full-size asset editor tabs (material graphs, widget designer, particle graphs …) alongside the Scene tab.

The footer bar holds Undo/Redo buttons on the left, the status text in the centre, and the current resolution and FPS on the right. Log output is written to HorizonEngine.log next to the executable (truncated each launch).

Starting point

Project Hub

The editor launches into the Project Hub: a list of known projects plus a New Project form. Creating a project asks for a template, a scripting language, a name and a directory.

Templates

Scripting language

The language is a whole-project choice, fixed at creation. It gates which gameplay-logic assets the Content Browser offers and which components appear:

Where you live

Scene Viewport

The Scene panel renders the world through the editor camera and carries an inline toolbar: a mode selector (View / Landscape), the gizmo buttons Move / Rotate / Scale, a gizmo-space combo (Local / World), a Screen ring toggle for the rotate gizmo, and the centred Play / Stop button.

Camera navigation

Gizmos

W / E / R switch between translate, rotate and scale (mirrored by the toolbar buttons). The space combo toggles manipulation in local or world axes; Screen ring adds the view-axis outer ring to the rotate gizmo. Gizmos are suppressed while flying, while Alt is held, and in Landscape mode. Every edit is undoable (Ctrl/Cmd+Z).

Static-mesh assets can be dragged from the Content Browser into the viewport to spawn an entity at the drop point.

Hierarchy

World Outliner

The Outliner shows the entity hierarchy of the active scene. Drag an entity onto another to reparent it. Right-click the background for Create Entity; right-click an entity for Create Child Entity, Rename, Save as Prefab and Delete.

The special Sky and Weather entities (added through the Environment window) appear here like any other entity — select them to edit the full sky and weather settings in the Details panel. The Sun and Moon are children of the Sky entity and are driven automatically.

Properties

Details Panel

The Details panel lists every component on the selected entity with full property editors, and ends with the Add Component button. Components you can add directly: Transform, Transform 2D, Mesh, Skeletal Mesh, Nav Mesh, Nav Agent, Material, Camera, Light, Rigid Body, Collider, Script (Lua/Python projects), Audio Source, Audio Listener, Particle System, LOD and Foliage.

Additional components appear with full editors when an entity carries them through other workflows — the Animator family (Animator, Animator Blend, Animator State Machine, Property Animator), Character Controller, Terrain, the in-world UI components, and the Environment/Weather editors on the Sky and Weather entities.

The complete component reference — every property of every component — lives on Scenes & Entities.

Assets

Content Browser

A folder tree on the left, an asset grid on the right. There are up to three roots:

• Content — your project's assets.
• Engine — built-in default assets (read-only).
• Source — the C++ class tree (C++ projects only).

Creating assets

Right-click the background (or an item's Create Asset submenu) to create an asset; a naming popup follows immediately. Always available:

Gameplay-logic assets depend on the project language: HorizonCode Class plus Player Controller / Player Character (HorizonCode projects), Script (Lua/Python projects), or C++ Class (C++ projects — writes a .h/.cpp pair under Source/).

Importing

Assets ▸ Import Asset… (or a folder's Import context item) dispatches by extension to the mesh, texture, audio, material and font importers. Audio import currently accepts WAV.

An imported asset remembers where it came from, so its right-click menu offers Reimport — it re-reads the original file and keeps the asset's identity, which means every reference to it survives. The entry is only there when a source path was actually recorded; nothing guesses one.

Finding things

The box above the grid searches the folder you are in and everything under it — a search that only looked at the level you already opened would require you to know the answer before asking the question. Beside it, a type filter narrows to scenes, materials, meshes, prefabs, widgets and the rest, and a single × clears both at once.

While a search or filter is active the grid shows matches from the whole subtree rather than the current folder's contents, so a hit three folders down is one click away.

Selecting, moving, renaming

Moving an asset carries everything that pointed at it — other assets' stored references, the asset's own embedded path, its thumbnail — over to the new location. A move that quietly broke those is how a project loses its materials.

With several assets selected, Rename becomes a pattern rename: find and replace inside the name, a prefix, a suffix, and a live preview of every resulting name before anything is written. Renaming twenty files one dialog at a time is the kind of task nobody does, so nobody tidies up.

Deleting, and what depended on it

Deleting asks first — a red menu entry is not a confirmation — and the confirmation says who still needs the file. The scan runs in the background over the whole project and reports each referrer, plus how it points at the asset: a stored path can be repaired by renaming instead, while a scene's stored id can only dangle once the asset is gone.

Deleting a folder scans everything inside it the same way. And when a file cannot be read, the dialog says so rather than reporting “nothing references it” — “I could not check” and “I checked and found nothing” are different answers, and only one of them is safe to act on.

Find References

The same scan is available on its own, from any asset's right-click menu, without having to threaten to delete something to see the answer. It reads both encodings a reference can take: the path stored inside another authored asset, and the UUID stored in a scene.

In a collaboration session

The content browser is part of a session. Creating is open to everyone; deleting, renaming and moving are requests the host answers; an asset somebody else is editing carries a padlock in their colour. See Assets in a Session.

Assets

Engine Content

The Engine root holds the assets that ship with the engine — default materials, primitive meshes, the fonts the editor draws with. They are read-only, and an engine asset resolves through three places in order.

Overriding one

Saving a change to an engine asset writes a copy under your project's Engine/ folder; the shipped original is never touched, and every other project on the machine keeps the version it had. The tile then offers Revert to Default, which removes your copy and lets the engine's own version show through again.

Assets that are not downloaded yet

The engine content library is larger than the install. Assets that live only on the server still appear in the browser as tiles — you can see what exists before deciding to pull it — and the first thing that needs one fetches it into the machine-wide cache.

A downloaded copy can be given back with Remove Local Copy. It is deliberately not called “Delete”: nothing is lost. The asset goes on existing on the server, the tile turns back into the remote-only placeholder it was before, and the next use fetches it again. What it reclaims is disk — the cache is shared by every project on the machine, so it only ever grows.

Feedback

Notifications

A bell in the footer collects the things that happened without you doing them: a background scan that could not read a file, an import that finished, a collaboration request nobody answered, a peer that refused a file. It carries a count of what you have not read, and clicking it expands a flyout with the list.

It is not a log. A log answers “what happened”; this answers “what still needs you” — entries are written in sentences, and the ones about a particular file carry its path. Repeated identical messages collapse into one row with a count, and when the list is full it drops the oldest message you have already read, so an unread problem is never pushed out by a run of chatter.

Deep dives

Asset Editor Tabs

Double-clicking an asset opens a dedicated editor tab next to the Scene tab. Material graphs, HorizonCode graphs, the Level Script, the Game Instance, particle graphs and animator state machines all share one node-graph canvas — learn it once (pan with the right mouse button, box-select with the left, zoom with the wheel) and every graph editor works the same way.

Terrain

Landscape Mode

Switch the viewport toolbar's mode selector to Landscape and the Quick Settings panel becomes the terrain tool.

Create Landscape

With no terrain in the scene the panel shows a creation form: Width (X), Depth (Z), Resolution (2–512), Height Scale, and procedural noise — Seed (0 = flat), Octaves, Frequency, Lacunarity, Gain — with a live grid preview. Creating adds a Terrain entity with a default terrain material. The seed noise is baked once into editable heights; from then on the terrain is a plain heightfield your brushes edit directly.

Sculpting

Six brush tools: Raise, Lower, Smooth, Flatten, Ramp, Roughen, with Radius (0.5–500 m), Falloff and Strength. Drag with the left mouse button in the viewport to sculpt — Flatten pulls toward the height under the drag-start point, Ramp blends between two dragged points. Reset Sculpting clears all edits. Strokes only regenerate the terrain chunks they touch, so sculpting stays fast on large terrains.

Terrain renders as a grid of chunk entities with automatic LOD meshes and skirt geometry — details under Rendering ▸ Performance. Scatter vegetation with the Foliage component.

Sky & weather

Environment Window

View ▸ Environment manages the two special scene entities:

• Sky — Add Sky / Remove Sky. The Sky entity carries the Environment component (atmosphere, day-night cycle, clouds, stars, fog …) and owns the Sun and Moon as child entities. Removing it leaves a flat background colour.
• Weather — Add Weather / Remove Weather. Requires a Sky to drive; carries the Weather component (presets, precipitation, auto-cycle).

The window only adds, removes and selects — the actual settings are edited in the Details panel. The full parameter reference is on Rendering & Environment.

Test it

Play Mode

The Play button in the Scene toolbar starts a play-in-editor session; Escape (or the Stop button) ends it. Entering play initialises physics, fires Play on Start audio, starts scripts and spawns HorizonCode player classes. While playing, physics steps at a fixed timestep, scripts receive onUpdate, collision events dispatch, widgets tick, and input actions fire.

The scene renders through the camera marked Main Camera (or the first camera found). On stop, the world is restored to its pre-play state and a Play Session Report window summarises the session. Animation, navigation and particle systems also run outside play mode so you can preview them while editing.

C++ projects

Building Game Logic

Build ▸ Build and Reload Game Logic compiles a C++ project's Source/ folder into its native GameLogic library and swaps the result into a running play session — the session keeps going, with the new code in it.

The compile runs in the same Build window the export uses, in two steps: Compile, then Reload. The second one either happened or it did not, because compiled and running are different answers and the window has to be able to say which one it got to. Compiler warnings and errors are listed as they arrive; Build Again repeats the module build, not a project export.

• Outside Play mode it only builds. That is not a failure — the module that was just built is exactly what the next Play loads.
• Entering Play loads the built module, hands it the engine service tables and calls onStart; leaving Play calls onStop and unloads it. With no module built yet, the log says which menu item builds one.
• Other project languages get a note instead of a build: Lua, Python and HorizonCode script their gameplay in a language that needs no compiler.
• Toolchain — needs CMake and a C++ compiler, and engine headers to compile against. Preferences ▸ Tools ▸ Status shows what was found and can install what is missing.

What the module can reach once it is loaded — physics, input, content and savegames, through the injected service tables — is described under Scripting ▸ Native C++.

Measure

Performance Profiler

View ▸ Performance Profiler opens the engine's built-in profiler. Three tabs:

Setup

Preferences

Edit ▸ Preferences (Ctrl/Cmd + ,) holds machine-level settings:

• Renderer — graphics backend picker (OpenGL everywhere; Metal on macOS; Direct3D 11/12 on Windows; Vulkan where enabled), VSync, GPU weather particles.
• Post-processing — Bloom (threshold, intensity) and ambient occlusion (method SSAO / HBAO / GTAO, radius, intensity). See Post-Processing.
• Source Control ▸ Repository — one page for both halves of git: what the machine has (git, Git LFS, your commit identity, the credential helper) and what the project has (initialise, remote, access token, auto-push). Commits and pushes themselves live in View ▸ Source Control.
• Tools ▸ Status — everything the editor needs from outside itself in one table: git and Git LFS, CMake and a C++ compiler, the local network and the router. Rows that are not green offer a Fix. A "C++ Toolchain Not Found" dialog also appears at startup when CMake or the compiler are missing, offering automatic installation — the toolchain is needed for C++ projects and for compiling HorizonCode at export.
• Collaboration — whether the editor announces and listens for sessions on the local network; whether it will carry large assets (off by default, and greyed out while a session is running); and the ceiling on a single transfer, 1–512 MiB. Your display name, colour and avatar are set in the Collaboration window itself.

Reference

Menu Reference

On macOS the same commands live in the native menu bar (⌘N, ⌘O, ⌘S, ⇧⌘S, ⌘,, ⌃⌘F …), plus the standard app and window menus.

Muscle memory

Shortcut Reference

In play mode the default fly camera uses W A S D, E/Space up, Q/Ctrl down and Shift for 3× speed.