Complete feature catalog
START WITH THE BIG PICTURE
What does this part of Epok do?
This is the big map of Epok: editor tools, content pipelines, gameplay systems, Play targets and the native runtime. Use it to discover what already exists before building a system from scratch.
- 01Choose a capability
- 02Open its focused guide
- 03Check its PSX budget and limits
What is happening under the hood?
- Every production Rust module is represented in the source coverage table.
- Every native runtime header is mapped to a capability area.
- Experimental and partial boundaries are stated explicitly instead of being marketed as finished.
Field note: Start with what your game needs this week. Reading all 500 lines in one sitting is an optional boss fight.
This page inventories the capabilities implemented in Epok Engine's develop
branch. It is the broad map of the product; the linked guides contain the exact
workflow, limits and native API. A feature appears here only when there is an
editor/runtime implementation or a checked build path in the repository.
Epok has two cooperating products:
- a Rust desktop editor for authoring, previewing and building a game; and
- a C++20/PsyQo runtime generated and compiled as native MIPS code for the original PlayStation.
The project is experimental. "Implemented" does not mean that a feature is unbounded or validated on every host and console. See Known boundaries.
v0.10.0 highlights
See the release notes for compatibility and validation details.
- Dungeon Complete. Play or customize Reactor Station, a third-person action game with robot guards, a boss, inventory, upgrades and a PocketStation minigame. Choose C++, Blueprint or Lua for the game rules. Guide.
- Six starters in three languages. Create Basic, Sample, Third Person, Platformer 2D, Dungeon or Dungeon Complete in C++, Blueprint or Lua. All three variants share the same scenes and assets. Lua gameplay compiles ahead of time to native C++ for PSX. Guide.
- Gameplay actions and input contexts. Bind controller inputs to named actions. Let gameplay, menus and conversations take turns handling the same buttons through temporary contexts. Guide.
- World interaction helpers. Place and extend reflected actors for examination, NPC dialogue, pickups, doors and switches in any of the three gameplay languages. Guide.
- Dialogue widgets. Author conversations with lines, choices, conditions and actions. Present them through a UIActor derived from DialoguePresenter. Guide.
- Shared character movement and animation. Drive 2D and 3D character movement with shared motors and use gameplay state to select animation. The starter languages use the same underlying components. Guide.
- Gameplay camera rigs. Configure camera follow and aiming through shared rigs and projection helpers. Guide.
- Health helpers. Apply damage and healing with shared, bounded health arithmetic through HealthState and HealthLibrary. Guide.
- Pooled projectiles. Fire and update projectiles from a bounded pool backed by the 3D collision system. Guide.
- Shared 3D query context. Use a reflected component to perform 3D gameplay queries through the existing collision backend. Guide.
Projects, startup and workspace
- Project Hub. Start without
--projectto create, find, open and remove projects from the recent list. Projects are independent folders rather than content stored inside the editor repository. - Project descriptors. A root
.epokprojectYAML document stores the game name, startup scene, Play profile and transition settings. Paths passed to the editor can be either the folder or descriptor. Canonical path resolution and a per-project lock prevent the same project being edited twice. - Templates. New-project choices are Basic, Sample, Third Person and Platformer 2D, each with a C++, Blueprint or Lua gameplay flavor that decides only the starter implementation. Creation claims a new directory and never merges into existing content.
- Template browser and project defaults. New project presents a thumbnail, title and summary per template with a large preview, and a Project Defaults block holding the gameplay flavor and target platform. Template, flavor and platform are independent choices; the flavor decides only which starter source is written and is not recorded in the descriptor. Creation is transactional and removes a folder it claimed if a template fails part way.
- Dependencies pane. External tool setup is a Hub pane beside Projects and New project, drawn from the same page the editor shows inside Preferences, with a platform tab bar for the tools a target needs.
- Legacy migration and recovery. Legacy manifests and JSON documents remain readable. Migration is explicit, keeps backups and has recovery choices for an interrupted migration. See Projects and formats.
- Recent projects and optional file association. The editor keeps a
per-user recent list. Windows can register
.epokprojectfor the current user with the supplied script without replacing an unrelated default silently. - Branded asynchronous startup. Project preparation happens behind a compact splash/loading presentation. Previous docking layouts are restored only when their panels remain valid. Long build, installation, analysis and transfer operations use a modal progress surface and block conflicting edits.
- Portable configuration. Project settings travel with the game; editor, MCP, emulator, serial-adapter and Content Browser preferences remain local. The editor installation owns its pinned tools independently of the current working directory. See Settings.
Desktop editor
- Dockable workspace. Scene, Game, Hierarchy, Inspector, Project/Content Browser, Console and specialized asset editors can be docked and restored.
- Scene View. A GPU preview supports perspective and orthographic/2D modes, orbit, pan, fly navigation, framing, grid and wireframe display. Picking selects scene objects without changing authored data.
- Hierarchy and transforms. Create, duplicate, delete, rename and parent entities. Position, rotation and scale are local to the parent; transform gizmos edit the selected object. Scene changes have dirty-state prompts and normal save shortcuts.
- Component Inspector. Edit materials, scripts and typed script properties, cameras, meshes, collision, lighting, shadows, sprites, particle emitters, skeletal animation, audio, timelines, effects and HUD components. The panel is a dense two-column property grid whose sections are full-width bands; each band carries its own command menu, and a renderer section owns both its geometry selection and how it is drawn.
- Control bindings. Keyboard, mouse and pad bindings are edited against a controller illustration whose button regions scale with the image.
- Numeric editing. Numeric properties accept direct text entry and click-drag adjustment with the appropriate cursor feedback.
- Console. Build, import, emulator and serial output is available in a read-only selectable text view. Every displayed line carries a local timestamp with millisecond precision; native command-echo noise is filtered while real compiler/transport output remains visible. Auto-scroll follows new output, pauses when scrolling up, resumes at the bottom, and is forced during builds.
- Artifact dependencies. A read-only dependency view traces generated artifacts to authored scenes, assets, reflection data and native inputs. It retains stale reasons and supports cycle-safe transitive paths instead of certifying old output.
- Responsive source observation. Source and external-tool inputs are polled in the background with bounded caches. Relevant changes invalidate stale builds without automatically invoking the PSX compiler; unrelated damaged assets do not stop an independent document preview or build.
See Using the editor for controls and architecture for ownership boundaries.
Content Browser and asset management
- Native project browser. Browse the real
assets/tree in tiles or a Name/Type/Path table, including empty folders. Use Back/Forward, breadcrumbs, parent navigation, recursive search, type filters, sorting, resizable source tree and adjustable thumbnail size. - Favorites and Collections. Save folder shortcuts and named sets of asset paths per project. Collections reference content without moving it and follow in-editor moves.
- Native type presentation. Blueprint, Scene, Texture, Mesh, Skeleton, Audio, Animation, Material, Timeline and Particle Effect files use distinct icons. Presentation names hide compound Epok suffixes without renaming files.
- File Inspector. Single selection shows path, size, type and available package/import metadata. A file selection never replaces the selected scene object or assigns a component accidentally.
- Image preview. Raw and imported textures show aspect-correct thumbnails and a larger checkerboard preview. The Inspector preview supports fit/reset and wheel zoom.
- Audio preview. WAV, MP3, FLAC and OGG sources and imported clips show a waveform, duration and Play/Stop. Imported auditions apply the saved trim, channel, rate and normalization settings before PSX compression.
- Model preview. Editable meshes, model packages and raw FBX/OBJ files have a GPU preview with orbit, zoom and frame/reset. Skeleton and animation assets use the associated model bind pose.
- Bounded background cache. Visible previews decode off the UI thread, refresh after file/reimport changes and release GPU/audio resources on eviction or project close. A bad preview does not disable ordinary file operations.
- Processed-source visibility. Importable source media is hidden by default once processed and can be shown for comparison. C++ source stays visible.
- Safe file operations. Create folders, rename, move, copy, duplicate, copy a path and reveal content in the OS file manager. Multi-item drag/drop preflights collisions, self-nesting and project boundaries. Session Undo reverses the last move.
- Recoverable deletion. Delete moves content to a project trash directory with a restore manifest. The last session batch can be restored without overwriting existing paths.
- Identity-aware duplication. Supported imported packages, Timeline assets and Particle Effects receive new UUIDs. Operations that would duplicate a C++ or Blueprint class identity are rejected in favor of their creation/import workflows.
- Reference safety and reconciliation. Asset UUIDs survive moves and reimports. Missing sources can be relinked; external moves are reconciled by identity; referenced assets cannot be trashed through guarded asset operations.
The complete interaction and preview contract is in the Content Browser guide. Import package rules are in Assets, import and audio.
Scenes, entities and geometry
- YAML scenes.
.epokmapfiles describe the environment and an ordered entity hierarchy. Empty entities are valid transform/group nodes and every component is validated before native staging. - EditableMesh / Blockout. Create Box, Plane, Ramp and Stairs primitives or a custom mesh document. Edit vertices, faces and material slots; extrude, inset, bevel, subdivide and build ramps. Geometry editing has local Undo/Redo and preserves stable asset UUIDs. See Blockout.
- Heightmap terrain. Sculpt and paint a grid of up to 256 x 256 cells whose corner heights are stored in Q8 and whose materials autotile their own borders from the four edge neighbours. The grid bakes into the same chunk format as blockout geometry, so it inherits culling, retained packets, visibility, streaming and the lighting bake, and an optional heightfield collider samples it bilinearly in Q12. See Terrain.
- Spatial compilation. Editable faces are converted to bounded PSX chunks with UV/material data, visibility bounds and optional external page locations.
- Dungeon Generator. Place a generator in a 3D or 2D map, choose a seed and
rooms-and-corridors settings, and generate: rooms are joined by a spanning tree plus
optional loops, with corridors routed around other rooms. 3D output is a few
EditableMesh sections, one compound collider, navigation volumes and spawn/goal
actors; 2D output is one TileMapLayer solved with Floor and Wall terrains. The
Inspector shows the layout in the Scene view, warnings with fixes and the PSX budget
the map will use; generation is deterministic and one undo step. A Dungeon Style
asset, edited in a node graph with live preview, decides what every spot (floor,
wall, door, doorway, solid, corner, room, spawn, goal) becomes: blockout geometry,
merged meshes, actors of any class and baked lights in 3D, terrains and decoration
tiles in 2D, with chance, priority, area and limit per piece. A Dungeon Recipe asset
grows the layout instead from steps (lattice, main path, branches and loops, items by
depth and place in the room, keys and locks, one-way doors, cellular caves, rooms
with cut corners, floor levels joined by flights of stairs), edited as a step list with a live
room-graph preview; rooms of chosen paths can be Dungeon Rooms built by hand in any map
(a room asset with its footprint, doors and key spots, edited on a floor plan), turned
to fit their links, their static pieces merged into the dungeon's geometry and
collision and their lights and scripted actors copied; every key-and-lock placement
is checked to be solvable and the grid layout keeps locked doors from being walked
around. Keys, locks, one-way doors
and items become style spots, style pieces can keep to one path's rooms, and actors
placed on keys and locks receive their lock number. Ready-made Key and Door pieces
(backed by
DungeonKeyandDungeonDoorscripts installed into the project) make keys that only the generator's Player picks up and doors that open when their key is taken, in 3D and 2D. The built-in 3D look is sized for the Third Person character (or fitted to any Player), closed by a ceiling, and dressed in sci-fi panel textures drawn for the console. Game code asks about the generated rooms (the room an actor is in, the way to the goal, keys, locks, free spots, a seed-bound random stream) through the Dungeon gameplay library in C++, Blueprint and Lua. A console minimap, set up in the generator band, fills in as the player explores (rooms on entering, corridors when walked), marks the player, keys, locked doors and the goal, follows the player or fits the dungeon, and opens as a full map from game code. A seed bench measures hundreds of seeds against the console's budget (actors, quads, collision, navigation, tiles, recipe attempts) with histograms, picks one or exports the seeds that fit. Generation volumes, drawn on the grid in their own window, keep the dungeon out of an area or inside one, force a room or mirror the rooms. See Dungeon Generator. - Static OBJ/MTL import. Import triangular or quad OBJ geometry and material colors into editable assets with configurable scale. See Static OBJ import.
- Scene banks. Register up to 15 maps in addition to startup bank zero. Banks share immutable textures/audio and one reusable object pool while keeping independently validated VRAM layouts. See Runtime services.
- Linked scene and template data. Asset/template links refresh through the same typed component applicator used at authoring time, preserving explicit instance overrides.
Actors, components and the class model
- Object / Actor / Component classes. A reflected class tree with four families
(Object, Actor, Component, Level/World) alongside the original Behaviour family.
Actor3D,Actor2DandUIActorare the placeable actors;SceneScriptActoris the per-map script the level loader creates. - Domains. Each actor and component belongs to the 3D world, the 2D world, the UI or none. The domain comes from the class, drives the editor's 3D/2D/UI hierarchy filtering and gates which components an actor may own.
- Components with contracts. A component declares its owner domains, whether it
can be an actor's root, its cardinality, its required/excluded companions and the
target capability it needs.
AudioComponentis shared by all three domains. - C++ and Blueprint chains.
EPOK_CLASS(Blueprintable, Placeable, Spawnable, Domain=World3D, Id="…")andEPOK_COMPONENT(Root, Name="…")declare actors and their default components; Blueprints derive from them with Begin Play / Tick / End Play, typed actor/component references and a Spawn Actor node.PlacedOnlywithdraws an inheritedSpawnable, for a class that exists once in its scene. - Scene Blueprint per map. Each map owns one
SceneScriptActorclass, edited from Map Settings, compiled with the project, and able to name actors, components and entities of its own map by identity. - Older project compatibility. Previous Entity/Behaviour maps, older Blueprint versions and
.epokscriptsidecars are rejected without automatic conversion. Recreate them as Actor-based projects. - Cooked tables and counters. Actors, components, overrides and the scene script
are cooked into per-bank tables with a bounded slot registry, and
actor_statsreports alive/peak/rejected/spawned/deferred counts.
Actor-based templates build and run through the supported PlayStation workflow; see their guides for the exact validation scope. See Actors and components and Migrating an existing project.
Textures, materials and display
- PNG import. Convert source PNGs into portable
.epokassetpackages with a source snapshot, 8-bit indexed pixels and a 256-color CLUT. Reimport keeps the UUID. See Textures. - Native TIM import. Indexed 4/8-bit
.timsources import through the same Texture workflow and keep every index and all 16 bits of each palette entry. - VRAM packing and validation. Builds cook textures to 4 bits per texel when every index fits, pad rows to even words and pack pixel rectangles and CLUT rows offline with deterministic MaxRects orderings, without a count-based texture limit. Authored HUD fonts share the packer. Each scene bank is validated against the 1 MiB address space. See PSX texture cooking.
- Materials. Per-object/face tint, unlit mode, texture assignment, UV region, depth bias, UV scrolling and Cutout/Average/Add/Subtract/AddQuarter blend modes compile to native GPU packets.
- Display configuration. Project resolution and progressive/interlaced NTSC frame clear/display behavior are generated into the runtime. PAL output is not exposed by the current runtime.
- PSX raster path. The native renderer uses Q12 transforms, GTE projection, Gouraud triangles, ordering tables, near/far clipping, backface/frustum tests and optional retained packet caches for unchanged geometry.
Lighting, shadows and environment
- Light components. Directional and point lights support Baked, Realtime and Mixed modes, color, intensity, range and priority.
- Vertex-light bake. Bake static mesh lighting in the editor, fingerprint the result and reject stale bakes. Meshes choose baked or realtime reception and expose subdivision/shadow controls.
- Native realtime lighting. A bounded renderer selects local light sources and shades geometry through the GTE-aware runtime path.
- Shadows. Static bake occlusion and moving blob shadows are implemented with explicit triangle/resource counters. See Lighting.
- Fog and screen fade. Per-scene depth fog affects supported geometry and is
authorable from C++, Blueprint and Lua through the
Scenegroup, which rejects an invalid distance range without mutating anything; the same group reads and writes the full-screen fade, clamped to 0–255 and shared with transitions. - Animated surfaces. Material UV scrolling supports water-like motion, and palette animators cycle imported CLUT entries. See Environment effects and Palette animation.
Cameras, sprites, particles and skeletal animation
- Cameras. The first active camera is the default; gameplay can select another active camera. FOV and world-to-framebuffer projection are available natively.
- Camera background. A flat sky color, or a sky gradient with horizon and ground colors split at the true horizon, so gaps below the horizon read as ground. See Fog, water and texture animation.
- Large worlds. Actor and chunk positions are 32-bit Q12 with camera-relative projection; there is no absolute ±128 world limit. See World and camera coordinates.
- World sprites. Fixed, upright and spherical billboards support texture regions, tint, blend/depth settings and clipping/culling statistics.
- Sprite animation. Flipbook clips have per-frame duration, looping, pause/resume, completion and a bounded event queue.
- Particle emitters. Scene emitters and effect-owned emitters share a global 256-particle pool, bounded per-emitter creation, deterministic seeds, bursts and dropped/peak counters. See Sprites and particles.
- Particle Effect assets. A
.particle-effect.jsoncontains up to eight editable layers and an embedded Timeline. Presets, bursts, typed overrides, scene components, transient playback handles and a native-kernel editor preview are implemented. See Using the VFX editor. - FBX skeletal import. Import a mesh, armature and clips as a UUID-linked ModelSource package, inspect the skeleton, preview clips and place a character. The PSX profile supports up to 64 bones, 512 vertices and 1,024 triangles with one rigid bone per vertex, quantized 30 Hz clips and up to 32 clips per model. Each model can compile to bone-grouped direct GTE skinning or compressed baked vertex frames; conservative animation envelopes cull characters before pose/decode work. See Skeletal characters.
- Textured skeletal characters. Each skeletal triangle carries optional per-corner texture coordinates that keep atlas seams distinct without duplicating shared cooked positions, cooked through the same texture-page helper as static meshes. Assign a texture and edit material state in the model window; legacy untextured models remain readable and render unchanged.
Timelines and sequenced effects
- Timeline assets and scene directors. Create reusable typed sequences or attach an automatic Timeline component to an entity. Assets have stable UUIDs, configurable timebase/loop/restore behavior, slots, tracks, markers and events.
- Native sequencer. A dedicated Scene/Sequencer layout edits a Timeline asset in place with a frame ruler, searchable track tree, snapping, box selection, multi-key editing, reverse and looping transport, a curve editor and a live scene-camera preview that scrubs onto a disposable scene clone. The preview auto-binds only unambiguous targets and never mutates the authored scene.
- Property tracks and sections. Q12 curves support Linear, Step, Smoothstep, Ease In and Ease Out interpolation and up to 256 keys. A property track may be split into non-overlapping sections, each with a source offset and a rational playback rate for time remapping, and vector properties expand into per-lane X/Y/Z/W channels. Typed adapters read/apply native or Blueprint component properties and validate required component availability.
- Event tracks. Invoke reflected functions with cooked typed arguments. Marker/event dispatch handles multiple crossings and bounded diagnostics.
- Playback control. Play, stop, pause, resume, seek and query bounded handles. Scene and transient effect directors each have measured capacity.
- Blueprint integration. Blueprint nodes play Timeline/Effect assets, bind slots, wait for a marker or completion/cancellation, subscribe to repeated markers and control/burst active playback.
- Dependency-safe cooking. Precise source, reflection, member, resource and generated-header footprints prevent changed or ambiguous content from certifying stale output. Unsaved open documents participate in Play using the documented save/discard rules.
See the complete Timeline reference and the troubleshooting guide.
2D worlds
- 2D nodes.
Actor2Dactors with a pixel-based, Y-down 2D transform carry engine Sprite2D, TileMapLayer, Collider2D, CharacterBody2D, Camera2D, Parallax2D, Path2D, PathFollow2D, Line2D, Polygon2D, Particles2D, AudioPlayer2D, VisibleOnScreenNotifier2D, RemoteTransform2D, Skeleton2D, NavigationRegion2D, NavigationAgent2D, RigidBody2D, Joint2D, SubViewport2D, SplitScreen2D, CanvasLayer2D, CanvasModulate2D and Depth2D components, plus any C++, Blueprint or Lua component. Ready-made presets, grouped by purpose, create each kind of node in one click. - Sprites and animation. Texture regions, sprite-sheet cells, offset, centring, flips, modulate, the console blend modes, z-index and y-sort; named frame animations with speed, looping, autoplay, per-frame durations and events.
- Physics. Box and circle colliders with 32-bit layers and masks, solid, trigger
and one-way modes;
move_and_slidewith floor, wall and ceiling detection and floor snapping; Enter/Stay/Exit overlaps delivered to the actor'soverlap_2devent and to its components;raycast_2dandoverlap_box_2dqueries. - Camera2D. Follow with drag margins, limits, smoothing, offset, zoom, rotation, shake and the background colour the game clears to.
- Tile maps. TileSet assets cut a texture into tiles with full, partial or one-way
collision, animation, probabilities, custom data and saved patterns; terrain sets
(corners and sides, sides or corners) autotile as you paint. TileMapLayers cook only
their used 16 x 16-cell chunks, collide with bodies, rays and overlap queries, and
can be read and changed at runtime (
set_cell,get_cell_custom_data, ...). - Paths, shapes and effects. Curved Path2D paths with PathFollow2D followers that loop, ping-pong or stop and carry the bodies standing on them (moving platforms); Line2D polylines with width and colour gradients editable at runtime; textured or flat Polygon2D shapes; CPU Particles2D emitters with shapes, bursts, gravity, damping, scale and colour over life; additive PointLight2D glows; AudioPlayer2D sounds that fade and pan with the camera; on-screen notifiers that can pause nodes; remote transforms; colliders fitted to a sprite's visible pixels.
- Cut-out skeletons. Skeleton2D animates attached parts as bones with pose keys (shorter-arc rotation blending, loops and one-shots) and up to two two-bone IK chains with a chosen elbow side; the editor keys poses from a timeline on the skeleton or on any bone, previews them and draws the bones and IK targets.
- Rigid bodies and joints. Box and circle RigidBody2D bodies swept through tiles and colliders with restitution, friction, damping, per-body gravity, momentum exchange, sleeping, rolling circles and character pushing; rod, rope and spring Joint2D links; Line2D lines that follow nodes draw ropes and chains.
- Navigation. Grid regions built from tile collision and static bodies (A* with no corner cutting and line-of-sight smoothing) or navmesh outlines (A* plus the funnel algorithm); agents follow a target node or position, drive their CharacterBody2D or node, and stop at the closest point when the target is unreachable; the editor draws regions and predicted paths.
- Pictures and split screen. SubViewport2D draws a camera's view (or one canvas layer) into a 15-bit VRAM picture every few frames, which any Sprite2D can show: minimaps, monitors, group transparency; SplitScreen2D shows two cameras side by side or stacked with a divider, the HUD drawn once on top.
- Parallax and canvas layers. Parallax2D scrolls attached nodes against the camera with autoscroll and screen-filling repeats; CanvasLayer2D draws nodes on their own layer in screen pixels or world space; CanvasModulate2D tints a whole canvas.
- 2D with the 3D world. A CanvasLayer2D drawn Under 3D puts a background behind all 3D geometry; a Depth2D inserts sprites and tile layers into the 3D ordering table at a camera distance or an anchor actor's depth, plus a bucket bias, so cut-outs of a pre-rendered background hide the 3D characters walking behind them.
- Native renderer. Exact-texel hardware rectangles for unscaled sprites and tiles (fixed-size 8 x 8 and 16 x 16 rectangles for tiles) and textured quads otherwise, sorted by canvas and a stable radix key, drawn over the 3D world and under the HUD (or under and inside the 3D world, as above) from a cooked, per-project packet budget; Native PC Play composes the same frame. Projects without 2D content compile none of it.
- 2D editor. Select, move, rotate, scale and pan tools with shortcuts, grid and rotation snapping, pixel rulers, real texture and animation previews, collider and camera gizmos, drag-and-drop sprite creation, a sprite region editor and a sprite-sheet frame slicer, and a visual 2D Inspector. Add 2D Node and Add Component search by name, group or purpose, with the project's recent nodes first; node and texture pickers with many choices search too. A node that cannot work as set up shows a warning sign in the Hierarchy and the reasons in its Inspector, with one-click fixes (a collider fitted to the sprite, a picture shown on the HUD, a navigation region over the ground).
- Shape editing. Paths, lines and polygons are edited on the canvas: drag, insert, add and delete points, curve handles, smoothing; particle emitters preview live.
- Tile editing. Paint, line, rectangle, bucket fill, picker, eraser and selection tools with random scatter, flips and quarter turns; a palette with tiles, patterns and terrains under the view; a TileSet editor for collision, terrains, animation and custom data with its own undo.
- Dungeon template. The Third Person character and camera in a generated sci-fi dungeon with stairs between floors, a handmade Reactor room and a working key and locked door, in C++, Blueprint or Lua, lit and ready to play. See Dungeon template.
- Platformer 2D template. A playable side-scroller in C++, Blueprint or Lua, built from tile layers, layered parallax scenery and a screen-space HUD canvas, with a cut-out guide using IK, a navigating companion, a pushable crate, a garland on rope joints and ambient particles, grouped by purpose so a game can start by deleting what it does not need.
See 2D worlds.
HUD and 2D interface
- Canvas hierarchy. Canvas and RectTransform provide anchored parent-relative layout in the editor's UI mode and native HUD renderer.
- Widgets. Solid rectangles, atlas images, nine-slice borders, tiled panel images, text and progress bars support color and bounded ordering. The editor's UI menu creates Canvas, Panel, Image, Label, Text Area, Progress Bar, Button, Check Box, Slider and layout containers, with anchor presets and eight resize handles.
- Layout containers. Horizontal, Vertical, Grid, Margin and Center containers with per-element fill/expand/shrink flags, minimum size and stretch, measured and arranged by the same code in the editor and on the console.
- Focus and rotation. Focusable elements with explicit neighbours and a highlight tint move focus with the D-pad; Cross presses the focused element, a check box flips, Left/Right move a slider by its step, and gameplay reads the pressed, changed and cancelled events. Rect rotation about the pivot is inherited by children.
- Text. The bundled bitmap font covers printable ASCII plus documented Spanish
characters, wrapping and fixed rows/columns. Imported TrueType/OpenType fonts
become 4bpp glyph atlases with per-glyph advance and Left/Center/Right
alignment.
[color=#rrggbb]tags recolour part of a text. Generated C++ exposes mutable text. - Localization. A project string table (keys × languages, CSV import and
export, untranslated counts) feeds keyed texts; the editor previews any
language and gameplay switches it at runtime with
set_language. - Retained rendering. Static HUD packets can be retained between frames while dynamic text/value changes invalidate the appropriate output.
- Navigation utilities.
Focus<N>andlayout_listprovide allocation-free selection and list layout for game-owned menus.
See HUD and 2D entities.
Audio
- Source formats. WAV, MP3, FLAC, OGG/Vorbis and PCM sources can be decoded on the host. Imported metadata includes usage, channels, rate, trim, normalization and looping.
- Resident SFX. Convert to PSX SPU ADPCM, stage a shared bank and play through
AudioSourcewith clip, volume, pitch, looping, autoplay and runtime controls. The bank observes typed clip selections rather than unrelated transform/data changes. - Native music sequences (Epok Pulse). Convert a MIDI and SoundFont into a
resident
MusicSequenceand cook it entirely on the host into a bounded, absolute-timestamped SPU command stream, so the console only dispatches register commands to the hardware voices. A software-synthesizer reference driver remains selectable, a Target Preview auditions the cooked result, and a sequence can be rendered to a PCM WAV as a bridge to streamed disc audio. Import automatically fits the sample bank to the PSX budget. - XA background music. Encode/interleave disc XA, generate the disc manifest and drive asynchronous ISO/CD playback with loop/end/error state.
- Full-motion video. Import MP4, MOV, AVI, MKV, WebM, MPEG and GIF clips as
Video assets encoded to MDEC/XA
.STRstreams; every frame is checked with the console's decoder at import. The File Inspector previews the clip as the console decodes it and reports picture, duration, disc space and player RAM. Blueprint Play/Stop/Is video playing nodes andepok.play_videostream it from CD at double speed, decode it with the MDEC into the frame buffer, letterbox it in 320 x 240, pause gameplay, skip on START/✕ and expand TV-range levels for free. See Full-motion video. - Transition audio. Scene transitions multiply authored audio gain during fade-out/fade-in and stop outgoing sources safely after pending callbacks.
- Capacity. Resident audio is validated against the 512 KiB SPU budget with a runtime reserve. See Assets, import and audio.
Native C++ gameplay and reflection
- Unified gameplay API. A single engine-owned facade defines every public gameplay operation once in annotated C++, and the registry derives Blueprint nodes, Lua definitions, native adapters and VM bindings from it. Values, lifecycle order, failure handling and skeletal sampling behave identically on the C++, Blueprint and Lua (native, VM bytecode and VM source) surfaces, and each operation's capability requirements are tracked into the cook manifest.
- C++20 Actors and components. Create project classes, derive from eligible native or generated classes and implement reflected lifecycle/event methods. Exported classes compile directly into the MIPS executable.
- Semantic reflection. A pinned libclang extractor records stable class IDs, inheritance, editable properties, functions, parameter directions and Timeline metadata. Versioned manifests and caches are validated against source/tool inputs.
- Inspector values. Bool, signed/unsigned integer, fixed point, vectors, transforms, strings, entity/class references and typed asset references have checked defaults and instance overrides where supported.
- Lifecycle. All bindings and properties exist before
start; active scripts receiveon_enable, then fixed-stepupdate, and lateron_disable/on_destroy. Default-constructible, assignable Behaviour state is restored on bank reload. - Runtime utilities. Allocation-free Tween easing over seventeen Q12 curves with delay and loop plans, scalar and Vector3, bounded EventQueue, timed Sequence, UI Focus and list-layout helpers are included.
See C++ scripting and exports.
Lua gameplay scripting
- Reflected Lua classes. Author
assets/scripts/*.luaclasses by extending eligible C++, Blueprint or Lua parents. The shared class registry exposes them to the Inspector, parent pickers, defaults, attachment, spawning and Blueprint inheritance instead of maintaining a separate Lua-only object model. - Code-first declarations and stable identity. A class is declared with code
such as
local Guard = epok.Actor3D:extend(). Plain assignments define typed Inspector properties, Lua Language Server annotations describe new callables, andProjectSettings/LuaClasses.epoksettingspreserves class UUIDs across source-file renames. - Three project-wide execution modes. Native C++ lowers the typed script IR to C++ and links no interpreter. Lua VM bytecode cooks a verified 32-bit chunk on the host and links the no-parser archive; Lua VM source packages normalized text and links the parser archive. Play, Build and export use exactly the saved mode and invalidate incompatible artifacts.
- Shared engine operations. Intrinsic spatial/UI fields and typed builtins cover input, scene requests, validity/casts, spawning, ownership, audio, textures and component sequence/effect playback. Actor and ActorComponent operations are reflected once for C++, Blueprint and Lua callers.
- Bounded target runtime. VM modes use fixed arenas (96 KiB for bytecode and 128 KiB for source by default), keep 64-bit identities outside the VM's int32 boundary and route numeric operations through the Blueprint runtime contract.
- Editor definitions and diagnostics. Registry refresh writes
.epok/lua/epok.d.luaand creates.luarc.jsonwhen absent, exposing native, Blueprint and Lua inheritance, properties, events, records, enums and builtins to Lua Language Server tooling.
See Lua scripting and the Lua VM runtime.
Blueprint visual gameplay
- Native compiled graphs.
.epokbpclasses compile ahead of time to generated C++ and then native MIPS code. No graph interpreter runs on the console. - Creation and inheritance. Create a class with a native or Blueprint parent, persistent class identity, inherited variables/functions/components and defaults, event overrides and explicit Call Parent.
- Graph authoring. Components, My Blueprint, canvas and contextual Details panes support typed execution/data wires, contextual creation by right-dragging from a compatible pin, a categorized action menu, node search, reroutes and graph navigation.
- Typed values and pins. Literal and connected bool, integer, unsigned, fixed-point, vector, transform, string, entity, class and asset values are validated. Composite pins can split and recombine; inline values are edited generically by type.
- Flow and expressions. Events, function entry/return, Branch, Delay, variables, casts, arithmetic/comparison, reflected calls, Blueprint calls, transform/input/entity/audio/scene helpers and Timeline/VFX playback are lowered through a typed IR with saturating console arithmetic where documented.
- Functions and cross-instance calls. Define Blueprint functions with typed inputs/outputs, call them on self or compatible instances and validate execution connectivity, cycles, missing returns and class assignability.
- Entity templates. Capture component hierarchies as reusable class templates, inherit/override them, refresh linked instances, place classes and spawn a class dynamically from a bounded 32-slot runtime pool.
- Debugging. Instrumented Play provides per-node breakpoints, continue, pause, step and typed value snapshots/traces. Release builds omit the instrumentation.
- Editor history and safety. Graph/template Undo/Redo, atomic writes, dependency invalidation and compile diagnostics prevent a stale graph from being treated as current native output.
Start with Your first Blueprint, then use the Blueprint reference.
Input, collision and runtime object services
- Controller input. Four logical pads — a multitap's Pad1a to Pad1d on hardware, the matching virtual pads under Native PC — expose connected, held, pressed, released and frame-edge state for the standard PSX buttons. The embedded Game view owns focus and releases buttons when focus is lost. An opt-in analog-controller mode adds signed Q12 stick axes for both sticks with an exact center and no dead zone.
- Controller rumble. The reflected Input library requests finite DualShock large/small motor pulses from C++, Blueprint and Lua Gameplay profile 2. PSX uses the shared SIO0 owner; Native PC uses individually assigned devices and bounded host effects. Controls exposes device support and a short rumble test, while Play preferences and in-game settings can mute output. See controller rumble for platform limits and the acceptance status.
- Measured fixed step. Host frame time feeds a fixed 60 Hz simulation with bounded catch-up, pause, single-step, tick counters and interpolation data.
- AABB collision. Collider layers/masks, solid and trigger modes, overlap, swept movement and trigger Enter/Stay/Exit events run in bounded storage. Collision is conservative and not a rigid-body solver. A compound collider holds up to 2,048 boxes on one actor; every query tests its parts.
- Baked navigation (NavLite). Bake a bounded walking graph from box colliders, collider ramps and navigation surfaces inside authored volumes under one shared profile, then move agents over it within a fixed console search budget. Authored jump and climb links, moving obstacles, a cached editor preview of the selected volume and automatic rebaking on fingerprint changes are included. Version 1 supports flat surfaces and obstacles. See NavLite.
- Entity handles. Slot-plus-generation handles detect destroyed/reused objects. Runtime creation, subtree destruction, activation and lookup are bounded.
- Scene lifetime. Deactivation affects descendants and rendering/audio/ collision participation without deleting authored data. Destruction invalidates handles, particles and dynamic bindings.
See Input, time and collision and Runtime services.
Play, emulation and physical-console workflow
- Native PC runtime. Play the generated C++ gameplay on the host with the same fixed 60 Hz clock as the console. It runs out of process and returns only bounded actor and HUD snapshots to the editor renderer; the PlayStation runner choice is retained while it is active.
- Persistent Play profile. Choose destination (embedded PCSX-Redux, separate
emulator window or PSX through serial), content (current open scene including
unsaved edits or whole game from startup) and data source (in executable, CD on
demand or PCDrv host on demand). Choices are saved in
.epokproject. - Integrated Game view. Epok launches its own PCSX-Redux process, receives the actual 16/24-bit framebuffer through an authenticated loopback adapter, forwards controller state and supports Play, Stop, Pause and Step.
- Owned external emulator. Windowed mode uses the same built output while the editor tracks and cleans up only the process/session it launched.
- PSX over NOTPSXSerial. Enumerate/select a serial adapter, install a pinned hash-verified nops package and keep a resident debug/TTY session for executable and PC-on-demand builds. Pause, Continue and Reset use the owned monitor; PC-on-demand also serves PCDrv. Play verifies the handler after runtime startup. Adapter identity and speed are user settings.
- Safe installation and transfer. Downloads are cancellable, installed packages are replaced transactionally, an installation lock prevents competing repairs and offline serial bundles are supported. Epok does not install Unirom.
- Critical-operation locking. Builds, tool preparation, checks and uploads preserve unsaved work while blocking project mutations, external drops and shutdown until their worker reaches a safe terminal state.
Build, memory analysis, loading and distribution
- Generated native project. Validate the selected scenes/assets, generate C++ tables and explicit source lists, stage embedded runtime/scripts and invoke pinned Make/GCC/Nugget tools. Unchanged staged files preserve timestamps for incremental compilation.
- Input provenance. Scene snapshots, settings, assets, Blueprints, timelines, generated headers, native sources/includes, compiler/linker flags, tools and SDK inputs are captured before/after work. Changes during a job prevent launch or publication of stale output.
- Private SDK builds. The editor and standalone launchers build certified private Nugget objects/archives without overwriting shared SDK outputs; a host lock rejects conflicting builds.
- Memory Analyzer. Builds generate reports by default. Open the last report, build first when needed, or analyze an existing compilation without launching it. The status bar shows current EXE and external-data sizes; stale reports retain a warning. Inspect Main RAM, VRAM, SPU/audio, scratchpad and generated files. The UI provides capacity bars, a clickable treemap, allocation table, breadcrumbs, symbol/source attribution, stale detection and asset location. JSON is written beside the build.
- Scene transitions. Requests fade picture and audio, display a resident black loading frame with configurable text/64x64 RGB555 image, retire the old bank, warm streamed geometry, load the new bank and fade in. Failed reads stay muted and allow retry. C++ can override transition options per request.
- Scenes outside the executable. The project's scene table marks which scenes
stay in the EXE. With CD or PC data, the others are saved as checked
SCENEnn.BINfiles and load into one shared RAM region behind the loading screen, with a progress bar of the bytes read. See Scenes outside the executable. - Executable and disc packaging. Produce a PS-X EXE; package ISO or BIN/CUE with XA/external geometry and a user-supplied system-area license when required.
- PS-EXE packages. Export a verified ZIP holding the executable, the PCDrv files it reads, a manifest, launch instructions and notices, for PCDrv-compatible loaders. See Export PS-EXE.
- Standalone export. Generate a relocatable C++/PsyQo project with runtime, scripts, assets, Make launchers, manifests, guides, licenses and notices. It can rebuild without the Rust editor, libclang extractor or original authoring tree.
- Version/release policy.
developcarries the next version,releasecarries the released version and tag workflows verify the repositoryVERSION, Cargo metadata, version progression and bounded job timeouts. See Release process.
See Play targets and loading, standalone runtime and performance.
Geometry streaming and performance
- Optional geometry archive. External EditableMesh chunks are packed into
checked 64 KiB
GEOMETRY.BINpages with a configured bounded RAM pool. - CD or PCDrv backend. Runtime page lookup, reservation, pin/unpin, prefetch, synchronous fallback and scene warmup share the same pool contract. Required reads can stall and CD geometry can interact with XA playback.
- Visibility. Precomputed chunk bounds, frustum outcodes, cached basis/bounds tests and spatial chunks reduce submitted geometry. A Geometry Draw Distance rejects chunks wholly beyond a camera-space distance before loading them.
- Camera visibility tracks. For guided cameras, the build stores which faces each camera sample sees and which pages it needs now and next; the streamer loads exactly those. Optional static-world cooking removes seams between meshes.
- Prepared packet order. Per-sample draw lists, already in draw order, let the renderer skip visibility tests, sorting and per-polygon material setup for static unlit scenery. See World optimization techniques.
- Camera paths and visibility bake. Build > Camera Path authors a guided camera's route from Scene view keys on a timeline; Build > Bake Visibility computes each sample's visible faces on the GPU, optionally from cameras recorded while playing, and generates the packet order.
- Retained geometry/HUD. Optional retained GPU packets reuse unchanged static work while preserving per-frame visibility and resource bounds.
- Counters. Runtime structures expose frame timing, dropped fixed steps, geometry/clip/lighting/sprite/particle/HUD/streaming counts, retained rebuilds, resource use and scene/spawn/playback capacity failures.
- Profiling tools. Headless CPU/GPU scene profiles, deterministic routes, runtime capture comparison, VRAM comparison and visibility benchmarks are included for maintainers.
See Geometry streaming and Native PSX performance.
Memory Card persistence
- Asynchronous service. Probe, read, write and list operations are serialized through a process-owned service with status, cancellation/owner safety and a PsyQo filesystem backend.
- Save format. Validate names and capacities, write title/icon metadata and use interrupted-write recovery so a failed replacement does not silently lose the previous save.
- Scene independence. Pending operations survive scene transitions and their callbacks are protected from destroyed game objects.
See Memory Card service.
PocketStation
- PocketStation apps. An authored asset (Add > PocketStation App...) holding Pocket Lua or ARM/Thumb assembly sources, editor-drawn sprites, the animated menu icon, the PlayStation memory card icon, the title and the card file name; three starting templates including the Star Catcher mini-game.
- Pocket Lua. A statically typed Lua subset compiled to Thumb code by Epok:
integers and booleans, flash tables, RAM arrays with bounds checks, multi-frame
sprites, tunes, typed functions, and the
screen,button,sound,clock,save,link,system,mathandprintlibraries, with line-accurate errors and suggestions. Assembly files add functions Pocket Lua calls directly. - Assembler. ARM and Thumb with literal pools, local labels, includes and automatic relaxation of far Thumb branches; whole programs can be assembly.
- Embedded emulator. ARM7TDMI CPU, flash banking, interrupts, timers, clock speeds, real-time clock, LCD, buttons, speaker, LED and the memory card connector, with Epok's own kernel and start-up menu (no console firmware).
- PocketStation window. Code, Sprites, Icons, App Settings and Card tabs; the
device with clickable buttons and keyboard control; Console, Problems, live
Variables, Debug (registers, source line, hardware differences) and a PlayStation
link tester;
.mcs/.binexport for real hardware. - Game integration. Every app is embedded in the game build;
epok::pocketstation(C++), the Start/Install app Blueprint nodes and Lua builtins, and theepok.pocketstationlibrary probe, install, start, message and share 16 values with Pocket Lua programs. - Play link. Play places the editor's emulated PocketStation in memory card slot 1 through the emulator bridge.
See PocketStation.
External tools / MCP integration
- Optional local server. Authenticated Streamable HTTP binds only to IPv4 loopback; a stdio bridge connects clients to the already-running editor. The feature is disabled by default and requires no specific client provider.
- Twenty-seven tools.
editor_state,logs_read,scene_read,scene_schema,scene_apply,scene_actors,scene_add_actor,scene_remove_actor,scene_set_actor,scene_history,scene_save,scene_open,actor_select,editor_view,viewer_screenshot,editor_control,camera_path,visibility_bake,game_input,project_settings,project_files,asset_list,asset_import,mesh_create,asset_document,asset_manageanddungeon_generatecover inspection, guarded scene/actor/file edits, screenshots, imports, camera paths, visibility bakes, dungeon generation, build/play and serial preparation. - Transactional guards. Scene batches are atomic and revision-checked; project-file writes require SHA-256 revisions and keep backups; queues and responses have limits/timeouts; cancelled queued calls cannot mutate later.
- Real captures and runtime control. Return full Scene, HUD, Game or editor PNGs, move the editor camera, inject bounded controller input and operate the editor/emulator asynchronously.
- Read-only resources. Clients can read the embedded guide, state, scene, schema and settings resources in addition to tool calls.
See Integrations / MCP for schemas, security and limits.
Command-line and automation surface
The editor exposes the following implemented headless families. Run them with
--project <folder-or-descriptor> unless the command is installation-wide.
| Family | Commands |
|---|---|
| Build and run | --build-psx, --play-psx, --use-play-profile, --blueprint-debug, --analyze-memory, --export-psx, --export-ps-exe |
| Projects | --create-project, --template, --migrate-project, --recover-project |
| Assets | --scan-assets, --import-texture, --import-obj, --import-fbx, --import-audio, --reimport-asset, --inspect-asset |
| Native gameplay | --reflect, --new-script, --parent, --new-blueprint, --compile-blueprints, --add-actor, --scene |
| Timeline and VFX | --new-timeline, --compile-timelines, --install-timeline-adapters, --new-particle-effect, --preset, --validate-particle-effects, --preview-particle-effect |
| Level generation | --generate-dungeon, --dungeon-seed, --dungeon-settings, --dungeon-new-style, --dungeon-new-recipe, --dungeon-seed-bench, --open-dungeon-room, --open-dungeon-seeds, --open-dungeon-volumes |
| Editor/runtime QA | --bake-lighting, --profile-scene, --profile-scene-cpu, --profile-editor, screenshot commands and bounded --steps / --stop-after execution |
| PocketStation | --new-pocketstation-app, --pocketstation-template, and for screenshots --open-pocketstation, --pocketstation-run, --pocketstation-play, --pocketstation-tab, --screenshot-delay |
| Integration | --mcp-stdio, --prepare-serial-tools, --list-serial-ports |
Most families have detailed examples in Getting started, Assets, Blueprints, Timelines and Play.
Validation and developer tooling
- Rust unit tests cover serialization, UI interaction harnesses, asset safety, Blueprint connectivity/split pins/action menus, Timeline compilation and the editor's pure logic.
- C++ host tests exercise fixed-point/runtime helpers, visibility, clipping, transforms, collision, lifecycle, transitions, streaming pools, particles, Timeline directors, Blueprint runtime/spawn/playback and Memory Card behavior.
- Python integration checks exercise project creation/migration, imports, reflection, staging, PSX builds, emulator captures, display/HUD/lighting, streaming/XA, Blueprint and VFX workflows, memory reports and Play profiles.
- Visual fixtures and curated captures cover the Content Browser, file Inspector, Blueprints, asset dialogs and branded startup. Performance scripts compare measured routes, runtime captures and VRAM output.
- Dependency manifests pin downloadable tools and validate hashes; setup scripts
keep portable tools under
.tools/and avoid changing global PATH.
See Testing and Shared resources.
Known boundaries
These are deliberate descriptions of the present implementation, not promised features:
- Windows x64, macOS Apple Silicon and Linux x86_64 are the supported editor targets. Blueprint reflection/authoring is available on Windows and Linux; macOS does not yet provision that toolchain. Linux editor and Play support, plus serial hardware paths outside Windows, remain experimental.
- Console builds and PCSX-Redux execution are validated. A short sequenced-music hardware smoke test is recorded, but broad physical-console timing, controllers, serial paths on every host and real Memory Card media still need validation.
- Skeletal source skinning is rigid: one bone per vertex. Target playback selects direct GTE bone ranges or compressed baked vertex frames. Skeletal material slots support assigned textures; blended weights and animation blending remain outside the current profile.
- Collision includes conservative AABB overlap/sweep, triggers and walkable X/Z ramp-height surfaces, not a rigid-body physics engine. The native 2D toolkit adds box/circle overlap helpers with conservative sweeps.
- The Hierarchy supports multiple Actor selection. Undo/Redo is not editor-wide. It is scoped to the open map's last 32 scene edits, Blueprint graphs/templates, Timelines/Effects, Blockout, Content Browser moves and MCP scene batches as documented by each tool.
- The Actor model has no Pawn/Character archetypes. 2D supports bounded spatial audio, collision, character movement, rigid boxes and joints; see the 2D guide for scope and limits. Actor hierarchy editing and compatible component add/remove are implemented; cross-domain conversion is not offered.
- Resident code, scripts, textures and audio must fit PSX memory. External scene data can share a bounded loading region; geometry streaming covers EditableMesh pages rather than arbitrary textures or audio.
- Sorting uses PSX ordering-table constraints. Intersecting polygons can still show ordering artifacts, and capacity validation is not a frame-rate guarantee.
- Windows portable packages are available; see the release guide for platform-specific packaging. A PlayStation system-area license, BIOS and Unirom are not distributed.
epok-luav1 is a deliberately bounded, statically checked profile rather than general Lua 5.2 compatibility. It has no coroutines, metatables, standard libraries, dynamic table growth or source-level debugger. Live native-code hot reload and general external-source packaging are not implemented.
Source coverage map
This map makes the catalog auditable when modules are added. Test-only modules live beside the corresponding implementation and are summarized under Validation and developer tooling.
| Capability | Rust editor modules |
|---|---|
| Application/workspace | main, platform, loading, branding, workspace, hub, editor, gui, busy_ui, document |
| Settings/project UI | settings, settings_ui, project, project_browser, console |
| Asset system | assets, asset_manager, asset_ui, asset_inspector, content_preview, import_settings, artifact_dependencies, artifact_dependency_ui |
| Texture/model/audio import | texture, model_import, obj_import, audio_decode, audio_import, preview_audio |
| Video | fmv, video_import, video_probe, video, video_preview |
| PocketStation | pocketstation, pocketstation_ui, and the epok-pocketstation crate (cpu, hw, rom, kernel, launcher, link, machine, card, file, asm, plua) |
| Scene and preview | scene, transform, viewport, scene_gpu, picking, gizmo, scene_bank, scene_dependencies, scene_view_mode |
| Object/Actor model | object_model, actor_document |
| 2D worlds | world2d, world2d_editor, platformer_template |
| Dungeon generation | dungeon, dungeon_rooms, dungeon_recipe, dungeon_random, dungeon_style, dungeon_bake, dungeon_editor, dungeon_style_editor, dungeon_recipe_editor, dungeon_room, dungeon_room_editor, dungeon_query, dungeon_minimap, dungeon_seeds, dungeon_volumes, dungeon_volumes_editor, dungeon_gameplay, dungeon_template |
| Geometry and rendering | mesh, mesh_ops, mesh_editor, mesh_compile, lighting, lighting_editor, shadows, effects, palette |
| Components and UI | bitmap_font, collision, collision_editor, hud, hud_editor, sprites, sprites_editor, particles, skeletal, skeletal_compile, skeletal_ui, third_person |
| Native scripting/reflection | scripts, script_values, script_backend, reflection, reflection_schema, header_extract, header_tool, native, native_metadata |
| Lua scripting | lua_aot, lua_api_stub, lua_asset, lua_bytecode, lua_compile, lua_dependencies, lua_frontend, lua_identity, lua_vm, script_ir |
| Blueprints | blueprint, blueprint_asset, blueprint_compile, blueprint_debug, blueprint_debug_ui, blueprint_dependencies, blueprint_editor, blueprint_ir, blueprint_playback, blueprint_refs, blueprint_spawn, blueprint_templates, blueprint_template_editor, blueprint_workflow, blueprint_action_menu, blueprint_inline_values, blueprint_split_pins |
| Timeline/VFX | timeline, timeline_adapters, timeline_compile, timeline_curve, timeline_editor, timeline_runtime, timeline_scene, particle_effect, particle_effect_editor, particle_effect_preview, particle_effect_scene, playback_staging |
| Build/play/export | build_inputs, staging_files, pipeline, play, play_ui, disc, export, export_ui, ps_exe_export, ps_exe_export_ui, bridge, dependencies |
| Physical console and analysis | serial, serial_support, serial_terminal, serial_ui, memory, memory_ui, streaming, music, audio |
| Assistant integration | mcp, mcp_tools, mcp_stdio |
| In-crate validation | mcp_tests, skeletal_tests, dungeon_tests, plus the Blueprint and Timeline test modules declared only for test builds |
| Native runtime area | C++ runtime files |
|---|---|
| Core scene/lifetime | epok.hpp, lifecycle.hpp, scene_service.hpp, affine.hpp, transform_cache.hpp, time.hpp, transition.hpp, loading_renderer.hpp, utility.hpp |
| Object/Actor model | object_model.hpp, actor_tables.hpp, actor_blueprint.hpp, world2d.hpp |
| 2D worlds | world2d.hpp, world2d_components.hpp, world2d_service.hpp, world2d_render.hpp |
| Rendering/resources | frame_clear.hpp, gte_geometry.hpp, frustum.hpp, polygon.hpp, visibility.hpp, retained.hpp, texture_types.hpp, texture.hpp, resources.hpp, lighting.hpp, shadows.hpp |
| Visual content | sprite_types.hpp, sprites.hpp, particle_types.hpp, particles.hpp, effect_types.hpp, effects.hpp, particle_effect_runtime.hpp, particle_effect_service.hpp, palette_types.hpp, palette.hpp, skeletal.hpp, hud.hpp, text.hpp |
| Dungeon generation | dungeon_random.hpp, dungeon_map.hpp, dungeon_minimap.hpp |
| Gameplay services | input.hpp, collision.hpp, audio.hpp, music.hpp, memory_card.hpp, memory_card_backend.hpp, streaming_pool.hpp, streaming.hpp |
| Video | fmv.hpp, fmv_bitstream.hpp, video_service.hpp |
| PocketStation | pocketstation.hpp, pocketstation_apps.hpp, pocketstation_service.hpp |
| Blueprint/Lua/Timeline | blueprint_api.hpp, blueprint_runtime.hpp, blueprint_debug.hpp, blueprint_spawn.hpp, blueprint_template.hpp, blueprint_playback_service.hpp, lua_runtime.hpp, playback_types.hpp, timeline.hpp, timeline_runtime.hpp, timeline_service.hpp |
runtime/main.cpp, runtime/Makefile, runtime/build.ps1, runtime/build.sh
and runtime/build-inputs.mk assemble these services into the generated native
application and its standalone build workflow.
When a new production module or runtime service lands, update this catalog and its focused guide in the same change.