Build worlds.
Make them PSX.

Author one code-declared class per .lua file, extend eligible C++, Blueprint or Lua parents, and use the same Inspector, defaults, attachment and spawning contracts.

Choose project-wide Native C++, VM bytecode or VM source execution. The same statically checked script and generated C++ subclass work in every mode.

ProjectSettings/LuaClasses.epoksettings keeps editor-assigned class UUIDs stable across managed file moves and renames; member IDs derive predictably and may be pinned.

Plain literals and explicit Epok constructors declare editable properties; Lua Language Server annotations declare callable parameters and results shared with other providers.

Move 3D/2D Actors or UI layouts and call input, scene, spawn, ownership, audio, texture and effect operations without project-specific C++ helper classes.

Registry refresh writes .epok/lua/epok.d.lua and creates .luarc.json, covering native, Blueprint and Lua inheritance, properties, events, records, enums and builtins.

Bytecode and source modes reserve fixed 96 KiB and 128 KiB arenas by default, with measured peaks, explicit exhaustion and a generated project override.

A host cooker emits target-format chunks and checks its header byte-for-byte against the pinned 32-bit runtime instead of assuming host and PSX layouts match.

Lifecycle events begin disconnected and dimmed, preserve parent behavior until implemented, and offer an explicit event-specific Call Parent action.

Reflected parameters require meaningful names, overrides inherit base labels and saved pin identities survive later SDK naming improvements.

Group rigid vertices by bone and submit visible ranges directly through the GTE after conservative animation-envelope culling; this is the default import mode.

Compile 30 Hz clips into independent compressed vertex frames to avoid runtime bone evaluation, trading target archive space within a 512 KiB per-model budget.

Add Component and new C++/Blueprint component dialogs filter parents by the selected Actor domain and compatibility rules before authoring begins.

Switch an instance among the engine cube, editable meshes and skeletal meshes while preserving Actor identity and leaving shared project assets untouched.

Keep the last valid shadows and AO visible while editing, show an amber stale-cache warning and rebuild explicitly from the top-level Build menu.

Read MTL and texture dependencies beside an external OBJ, copy them into project-owned destinations and reject paths that escape the allowed source boundary.

Skip an optional byte order mark at the start of a script and explain how to replace the retired metadata-table declaration when encountered.

Camera-relative digital movement, directional turning, acceleration, braking and normalized diagonals in editable native C++.

Grounded Cross-button jumps, gravity, weaker airborne steering and bounded step-up for ledges.

Shoulder-button orbit and elevation, a following camera boom and gradual alignment behind forward travel. No camera-obstacle avoidance.

Slope rise and X/Z axis settings let movement follow a ramp's standing height. Height-field behavior, not general inclined-plane physics.

Reduced unnecessary subdivision keeps the generated greybox cheaper to draw while its seven mesh packages remain editable.

Separate 3D, world 2D and UI modes with domain-aware hierarchy filtering and context-preserving ancestors.

Choose positive or negative X, Y or Z views while preserving the Scene View pivot and distance.

Create reflected native or Blueprint Actor classes from domain-grouped Hierarchy menus, with compatible roots and defaults.

Rename, duplicate, delete and logically reparent Actors. Branch operations include children; cross-domain conversion is not offered.

Add/remove instance components through Inspector with root, inheritance, cardinality and required/excluded-component checks.

Edit reflected instance values and distinguish authored overrides from class defaults in Inspector.

Actor ownership/activation and component transform attachment have separate validated contracts and cycle checks.

Begin Play, Tick and End Play for the new class families, alongside the existing Behaviour graph lifecycle.

ActorRef, ComponentRef, ObjectRef, Get Owner and bounded Actor spawning connect reflected class identity to visual gameplay.

Edit the map-owned SceneScriptActor graph from Map Settings; validate class changes and compile with the project.

Scene graphs can target local Actors, Components and entities with checked identity, type and map ownership.

Per-bank Actor/component/override/scene-script tables and bounded runtime instances. Dedicated console acceptance remains incomplete.

Inspect alive, peak, rejected, spawned and deferred counts plus component, scene-script and loaded-bank counters.

Grid, pan, cursor-centered zoom, topmost picking and drag movement of labeled Actor footprints, with one undo step per drag.

Native parent-relative transforms, deterministic degree-based math and independent world/screen projection at 32 pixels per unit.

Native layer, draw-order and creation-index sorting plus bounded picking helpers. The editor currently displays placement footprints.

Box/circle overlap, raycasts, sliding movement, masks and triggers. Sweeps are conservative; no rigid-body solver.

A native editor_preview hook shows code-created menus in UI mode without a MIPS build or gameplay lifecycle execution.

Optional navigation with Pause, Resume, Step and Restart in an isolated desktop process; cards are temporary and audio silent.

The same bounded Q12 layout, clipping, text and nine-slice primitive compiler serves desktop preview and target rendering.

Sfx, Music, Ambience and Dialogue roles are independent of Auto, Resident and Stream residency; target incompatibility is explicit.

Import SMF 0/1 MIDI, retain original bytes and identity, inspect programs, tempo, note activity, loops and logical polyphony.

Map imported AudioClips to programs/key/velocity zones with tuning, pan, gain, envelopes and source-frame sample loops.

Generate an original MIT-provenance triangle sample and program-0 bank for a minimal music test. No hidden GM fallback.

Explicit per-sequence bank selection or a project default, with dependency-aware invalidation when either changes.

Import compatible complete SoundFont libraries as one source-preserving bank; inspect required instruments, coverage and layers.

Install the checksum-identified FluidR3Mono GM 2.315 library with its MIT notice from the sequence settings.

Bank selection, RPN bend/fine/coarse tuning and supported controller semantics; old assets keep Legacy v1 until explicitly upgraded.

Compact/Balanced/High and Custom settings for rate, ADPCM effort, loops, release, filters, effects, headroom and budgets.

Analyze exact draft cook costs asynchronously, with contextual parameter help and no publication of a failed candidate.

A bounded sample-rate search proposes a recipe. Adopt it into the draft explicitly, then save; required layers are not silently removed.

Compare original samples with actual cooked sequence/bank payloads after saving. Host Target Preview omits wet reverb and hardware latency.

Four sequence instances, configurable music voice limits and priority/age allocation across the PSX's 24 physical voices.

Separate sequence RAM, bank metadata/sample copies and SPU sample costs, with build-bound identities and adaptation diagnostics.

Batched chord/layer key-ons, bounded transfer acknowledgements and reduced library modulation cadence address real-console playback costs.

Recognize supported SEQ/SEP and VAB layouts and preserve source parameters/companions. VAB instrument playback remains unavailable.

Edit without launching a MIPS build on every source change. Observation still refreshes resources and invalidates stale output.

PlayBuild.epokcache receipts allow executable/disc reuse only for matching scenes, profiles, resources, scripts and tracked inputs.

Build a chosen set of maps with inclusion checkboxes and an initial-scene choice, within the 16-bank total limit.

Memory reports enabled by default, open-last-report workflow and provenance-aware executable/external-data sizes with stale warnings.

Independent FPS, CPU, GTE, GPU command DMA and SPU sample-memory displays; metric definitions explicitly avoid utilization claims.

Smooth supported entity/camera translations between fixed simulation steps; does not raise FPS or interpolate every visual system.

Stage a chunk's projected vertices in the PSX scratchpad to reuse projection work without promising a universal speedup.

Owned resident/host sessions with acknowledged Pause, Continue and Reset, bounded timeouts and explicit resynchronization.

Guarded host setup verifies and restores bundled tools with progress, cancellation and installation locking.

Host-aware setup/profile scripts and optional Desktop shortcuts for the development editor; not a packaged app or a new reflection toolchain.

scene_actors, scene_add_actor, scene_remove_actor and scene_set_actor extend the local authenticated editor interface to 24 tools.

--add-actor resolves native class names including namespaces and validates the destination map and Actor contract.

Start without --project to create, find, open and remove projects from the recent list. Projects are independent folders rather than content stored inside the editor repository.

A root .epokproject YAML 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.

New-project choices are Basic, Sample game and Third Person. Creation claims a new directory and never merges into existing content.

Legacy manifests and JSON documents remain readable. Migration is explicit, keeps backups and has recovery choices for an interrupted migration. See Projects and formats.

The editor keeps a per-user recent list. Windows can register .epokproject for the current user with the supplied script without replacing an unrelated default silently.

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.

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.

Scene, Game, Hierarchy, Inspector, Project/Content Browser, Console and specialized asset editors can be docked and restored.

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.

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.

Edit materials, scripts and typed script properties, cameras, meshes, collision, lighting, shadows, sprites, particle emitters, skeletal animation, audio, timelines, effects and HUD components.

Numeric properties accept direct text entry and click-drag adjustment with the appropriate cursor feedback.

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.

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.

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.

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.

Save folder shortcuts and named sets of asset paths per project. Collections reference content without moving it and follow in-editor moves.

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.

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.

Raw and imported textures show aspect-correct thumbnails and a larger checkerboard preview. The Inspector preview supports fit/reset and wheel zoom.

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.

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.

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.

Importable source media is hidden by default once processed and can be shown for comparison. C++ source stays visible.

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.

Delete moves content to a project trash directory with a restore manifest. The last session batch can be restored without overwriting existing paths.

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.

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.

.epokmap files describe the environment and an ordered entity hierarchy. Empty entities are valid transform/group nodes and every component is validated before native staging.

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.

Editable faces are converted to bounded PSX chunks with UV/material data, visibility bounds and optional external page locations.

Import triangular or quad OBJ geometry and material colors into editable assets with configurable scale. See Static OBJ import.

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.

Asset/template links refresh through the same typed component applicator used at authoring time, preserving explicit instance overrides.

A reflected class tree with four families (Object, Actor, Component, Level/World) alongside the original Behaviour family. Actor3D, Actor2D and UIActor are the placeable actors; SceneScriptActor is the per-map script the level loader creates.

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.

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. AudioComponent is shared by all three domains.

EPOK_CLASS(Blueprintable, Placeable, Spawnable, Domain=World3D, Id="…") and EPOK_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.

Each map owns one SceneScriptActor class, edited from Map Settings, compiled with the project, and able to name actors, components and entities of its own map by identity.

Existing entities and Behaviours are unchanged and are additionally presented as a derived actor view; a Behaviour on an actor runs through a compatibility component, and an entity carrying both 3D and UI data is reported as a pending conversion rather than split.

Actors, components, overrides and the scene script are cooked into per-bank tables with a bounded slot registry, and actor_stats reports alive/peak/rejected/spawned/deferred counts.

Convert source PNGs into portable .epokasset packages with a source snapshot, 8-bit indexed pixels and a 256-color CLUT. Reimport keeps the UUID. See Textures.

The editor places texture pixels and palettes alongside framebuffers and reserved HUD/loading regions, validating each scene bank against the 1 MiB address space.

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.

Project resolution and progressive/interlaced NTSC frame clear/display behavior are generated into the runtime. PAL output is not exposed by the current runtime.

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.

Directional and point lights support Baked, Realtime and Mixed modes, color, intensity, range and priority.

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.

A bounded renderer selects local light sources and shades geometry through the GTE-aware runtime path.

Static bake occlusion and moving blob shadows are implemented with explicit triangle/resource counters. See Lighting.

Per-scene depth fog affects supported geometry; the runtime also exposes a full-screen fade used directly and by transitions.

Material UV scrolling supports water-like motion, and palette animators cycle imported CLUT entries. See Environment effects and Palette animation.

The first active camera is the default; gameplay can select another active camera. FOV and world-to-framebuffer projection are available natively.

Fixed, upright and spherical billboards support texture regions, tint, blend/depth settings and clipping/culling statistics.

Flipbook clips have per-frame duration, looping, pause/resume, completion and a bounded event queue.

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.

A .particle-effect.json contains 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.

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 and quantized 30 Hz clips. 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.

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.

Q12 curves support Linear, Step, Smoothstep, Ease In and Ease Out interpolation. Typed adapters read/apply native or Blueprint component properties and validate required component availability.

Invoke reflected functions with cooked typed arguments. Marker/event dispatch handles multiple crossings and bounded diagnostics.

Play, stop, pause, resume, seek and query bounded handles. Scene and transient effect directors each have measured capacity.

Blueprint nodes play Timeline/Effect assets, bind slots, wait for a marker or completion/cancellation, subscribe to repeated markers and control/burst active playback.

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.

Canvas and RectTransform provide anchored parent-relative layout in the editor's UI mode and native HUD renderer.

Solid rectangles, atlas images, nine-slice borders, text and progress bars support color and bounded ordering.

The bundled bitmap font covers printable ASCII plus documented Spanish characters, wrapping and fixed rows/columns. Generated C++ exposes mutable text.

Static HUD packets can be retained between frames while dynamic text/value changes invalidate the appropriate output.

Focus<N> and layout_list provide allocation-free selection and list layout for game-owned menus.

WAV, MP3, FLAC, OGG/Vorbis and PCM sources can be decoded on the host. Imported metadata includes usage, channels, rate, trim, normalization and looping.

Convert to PSX SPU ADPCM, stage a shared bank and play through AudioSource with clip, volume, pitch, looping, autoplay and runtime controls. The bank observes typed clip selections rather than unrelated transform/data changes.

Encode/interleave disc XA, generate the disc manifest and drive asynchronous ISO/CD playback with loop/end/error state.

Scene transitions multiply authored audio gain during fade-out/fade-in and stop outgoing sources safely after pending callbacks.

Resident audio is validated against the 512 KiB SPU budget with a runtime reserve. See Assets, import and audio.

Create project classes, derive from eligible native or generated classes and implement reflected lifecycle/event methods. Exported classes compile directly into the MIPS executable.

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.

Bool, signed/unsigned integer, fixed point, vectors, transforms, strings, entity/class references and typed asset references have checked defaults and instance overrides where supported.

All bindings and properties exist before start; active scripts receive on_enable, then fixed-step update, and later on_disable / on_destroy. Default-constructible, assignable Behaviour state is restored on bank reload.

Allocation-free Tween easing, bounded EventQueue, timed Sequence, UI Focus and list-layout helpers are included.

Author assets/scripts/*.lua classes 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.

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, and ProjectSettings/LuaClasses.epoksettings preserves class UUIDs across source-file renames.

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.

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.

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.

Registry refresh writes .epok/lua/epok.d.lua and creates .luarc.json when absent, exposing native, Blueprint and Lua inheritance, properties, events, records, enums and builtins to Lua Language Server tooling.

.epokbp classes compile ahead of time to generated C++ and then native MIPS code. No graph interpreter runs on the console.

Create a class with a native or Blueprint parent, persistent class identity, inherited variables/functions/components and defaults, event overrides and explicit Call Parent.

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.

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.

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.

Define Blueprint functions with typed inputs/outputs, call them on self or compatible instances and validate execution connectivity, cycles, missing returns and class assignability.

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.

Instrumented Play provides per-node breakpoints, continue, pause, step and typed value snapshots/traces. Release builds omit the instrumentation.

Graph/template Undo/Redo, atomic writes, dependency invalidation and compile diagnostics prevent a stale graph from being treated as current native output.

Two ports 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.

Host frame time feeds a fixed 60 Hz simulation with bounded catch-up, pause, single-step, tick counters and interpolation data.

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.

Slot-plus-generation handles detect destroyed/reused objects. Runtime creation, subtree destruction, activation and lookup are bounded.

Deactivation affects descendants and rendering/audio/ collision participation without deleting authored data. Destruction invalidates handles, particles and dynamic bindings.

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.

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.

Windowed mode uses the same built output while the editor tracks and cleans up only the process/session it launched.

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.

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.

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.

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.

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.

The editor and standalone launchers build certified private Nugget objects/archives without overwriting shared SDK outputs; a host lock rejects conflicting builds.

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.

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.

Produce a PS-X EXE; package ISO or BIN/CUE with XA/external geometry and a user-supplied system-area license when required.

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.

develop carries the next version, release carries the released version and tag workflows verify the repository VERSION, Cargo metadata, version progression and bounded job timeouts. See Release process.

External EditableMesh chunks are packed into checked 64 KiB GEOMETRY.BIN pages with a configured bounded RAM pool.

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.

Precomputed chunk bounds, frustum outcodes, cached basis/bounds tests and spatial chunks reduce submitted geometry.

Optional retained GPU packets reuse unchanged static work while preserving per-frame visibility and resource bounds.

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.

Headless CPU/GPU scene profiles, deterministic routes, runtime capture comparison, VRAM comparison and visibility benchmarks are included for maintainers.

Probe, read, write and list operations are serialized through a process-owned service with status, cancellation/owner safety and a PsyQo filesystem backend.

Validate names and capacities, write title/icon metadata and use interrupted-write recovery so a failed replacement does not silently lose the previous save.

Pending operations survive scene transitions and their callbacks are protected from destroyed game objects.

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 AI provider.

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, entity_select, editor_view, viewer_screenshot, editor_control, game_input, project_settings, project_files, asset_list, asset_import, mesh_create, asset_document and asset_manage cover inspection, guarded scene/actor/file edits, screenshots, imports, build/play and serial preparation.

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.

Return full Scene, HUD, Game or editor PNGs, move the editor camera, inject bounded controller input and operate the editor/emulator asynchronously.

Clients can read the embedded guide, state, scene, schema and settings resources in addition to tool calls.

--build-psx, --play-psx, --use-play-profile, --blueprint-debug, --analyze-memory, --export-psx

--create-project, --template, --migrate-project, --recover-project

--scan-assets, --import-texture, --import-obj, --import-fbx, --import-audio, --reimport-asset, --inspect-asset

--reflect, --new-script, --parent, --new-blueprint, --compile-blueprints, --add-actor, --scene

--new-timeline, --compile-timelines, --install-timeline-adapters, --new-particle-effect, --preset, --validate-particle-effects, --preview-particle-effect

--bake-lighting, --profile-scene, --profile-scene-cpu, --profile-editor, screenshot commands and bounded --steps / --stop-after execution

--mcp-stdio, --prepare-serial-tools, --list-serial-ports

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.

Windows x64, macOS Apple Silicon and Linux x86_64. Linux remains experimental; Blueprint reflection is provisioned on Windows/Linux, not macOS.

Original Epok code is MIT licensed. Bundled tools, SDKs and third-party assets retain their own notices; proprietary console BIOS/firmware are not distributed.