Every PSX memory space
Inspect 2 MiB Main RAM, per-scene VRAM, 512 KiB SPU audio, the 1 KiB scratchpad and the files that actually ship.

ORIGINAL PLAYSTATION DEVELOPMENT
A standalone visual editor.
A native PlayStation runtime.
Your next game starts here.
v0.10.0 release notes Download for Windows
Windows x64 + macOS Apple Silicon + Linux x86_64 · Open source · Experimental
More worlds. More ways to create.Explore videos & screenshots
PLAYABLE PSX DEMO / v0.10.0
Enter Reactor Station, find the access key and take down the guardian. This is the PlayStation build of the third-person action template shipped with Epok.
Click the game screen to focus it. Use Control Settings to remap inputs.
The PocketStation companion requires the Epok editor or a PocketStation. Demo credits
SMALL CONSOLE. A LOT OF POSSIBILITIES.
World building to the last byte.
Find a capability. See how it works.
202 of 202 features
EXPAND TO EXPLOREPlay 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.
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.
Bind controller inputs to named actions. Let gameplay, menus and conversations take turns handling the same buttons through temporary contexts.
Place and extend reflected actors for examination, NPC dialogue, pickups, doors and switches in any of the three gameplay languages.
Author conversations with lines, choices, conditions and actions. Present them through a UIActor derived from DialoguePresenter.
Configure camera follow and aiming through shared rigs and projection helpers.
Apply damage and healing with shared, bounded health arithmetic through HealthState and HealthLibrary.
Fire and update projectiles from a bounded pool backed by the 3D collision system.
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, 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.
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.
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 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. 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.
Keyboard, mouse and pad bindings are edited against a controller illustration whose button regions scale with the image.
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.
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.
Editable faces are converted to bounded PSX chunks with UV/material data, visibility bounds and optional external page locations.
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 DungeonKey and DungeonDoor scripts 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.
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. PlacedOnly withdraws an inherited Spawnable, for a class that exists once in its scene.
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.
Previous Entity/Behaviour maps, older Blueprint versions and .epokscript sidecars are rejected without automatic conversion. Recreate them as Actor-based projects.
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.
Indexed 4/8-bit .tim sources import through the same Texture workflow and keep every index and all 16 bits of each palette entry.
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.
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 and is authorable from C++, Blueprint and Lua through the Scene group, 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.
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.
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.
Actor and chunk positions are 32-bit Q12 with camera-relative projection; there is no absolute ±128 world limit. See World and camera coordinates.
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, 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.
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.
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.
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.
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.
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.
Actor2D actors 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.
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.
Box and circle colliders with 32-bit layers and masks, solid, trigger and one-way modes; move_and_slide with floor, wall and ceiling detection and floor snapping; Enter/Stay/Exit overlaps delivered to the actor's overlap_2d event and to its components; raycast_2d and overlap_box_2d queries.
Follow with drag margins, limits, smoothing, offset, zoom, rotation, shake and the background colour the game clears to.
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, ...).
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.
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.
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.
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.
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.
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.
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.
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).
Paths, lines and polygons are edited on the canvas: drag, insert, add and delete points, curve handles, smoothing; particle emitters preview live.
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.
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.
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.
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, 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.
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.
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.
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.
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.
Static HUD packets can be retained between frames while dynamic text/value changes invalidate the appropriate output.
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.
Convert a MIDI and SoundFont into a resident MusicSequence and 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.
Encode/interleave disc XA, generate the disc manifest and drive asynchronous ISO/CD playback with loop/end/error state.
Import MP4, MOV, AVI, MKV, WebM, MPEG and GIF clips as Video assets encoded to MDEC/XA .STR streams; 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 and epok.play_video stream 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.
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.
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.
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 over seventeen Q12 curves with delay and loop plans, scalar and Vector3, 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.
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.
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.
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.
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. A compound collider holds up to 2,048 boxes on one actor; every query tests its parts.
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.
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.
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.
The project's scene table marks which scenes stay in the EXE. With CD or PC data, the others are saved as checked SCENEnn.BIN files and load into one shared RAM region behind the loading screen, with a progress bar of the bytes read. See Scenes outside the executable.
Produce a PS-X EXE; package ISO or BIN/CUE with XA/external geometry and a user-supplied system-area license when required.
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.
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. A Geometry Draw Distance rejects chunks wholly beyond a camera-space distance before loading them.
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.
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.
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.
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.
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.
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, math and print libraries, with line-accurate errors and suggestions. Assembly files add functions Pocket Lua calls directly.
ARM and Thumb with literal pools, local labels, includes and automatic relaxation of far Thumb branches; whole programs can be assembly.
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).
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/.bin export for real hardware.
Every app is embedded in the game build; epok::pocketstation (C++), the Start/Install app Blueprint nodes and Lua builtins, and the epok.pocketstation library probe, install, start, message and share 16 values with Pocket Lua programs.
Play places the editor's emulated PocketStation in memory card slot 1 through the emulator bridge.
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.
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_manage and dungeon_generate cover inspection, guarded scene/actor/file edits, screenshots, imports, camera paths, visibility bakes, dungeon generation, 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, --export-ps-exe
--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
--generate-dungeon, --dungeon-seed, --dungeon-settings, --dungeon-new-style, --dungeon-new-recipe, --dungeon-seed-bench, --open-dungeon-room, --open-dungeon-seeds, --open-dungeon-volumes
--bake-lighting, --profile-scene, --profile-scene-cpu, --profile-editor, screenshot commands and bounded --steps / --stop-after execution
--new-pocketstation-app, --pocketstation-template, and for screenshots --open-pocketstation, --pocketstation-run, --pocketstation-play, --pocketstation-tab, --screenshot-delay
--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.
Try another term, choose All features, or reset the filters.
Implemented does not mean unlimited or production-ready. Each guide explains its limits and validation status. Read the boundaries ↗
UNDER THE HOOD / BEYOND THE FRAME
A visual workspace on your computer.
A native game on original hardware.
Typed contracts · target conversion
Build-time work stays on the host.
Only prepared code and data ship.
C++20 · fixed point · bounded pools
PS-X EXE / disc · emulator or console
See target requirements ↗
Some familiar hardware is still just a silhouette.

SCENE VIEW
Arrange objects, adjust lighting, and preview your world as you build.
Explore the editorC++ / BLUEPRINTS / LUA
Three authoring paths, one reflected Actor model.
Choose native code, typed graphs or statically checked Lua.

Blueprint reflection and authoring are available on Windows x64 and Linux x86_64. Lua uses the same reflected registry and can compile ahead of time or run in one of two bounded VM modes.
MEMORY ANALYZER / HARDWARE BUDGETS
A black screen is not a memory profiler.
Epok gives you the report before the surprise.

Inspect 2 MiB Main RAM, per-scene VRAM, 512 KiB SPU audio, the 1 KiB scratchpad and the files that actually ship.
Click through the treemap and allocation table to linked symbols, byte counts, scene references and supported source assets.
Reports come from the linked ELF and selected staged assets. Source or profile changes mark old results as stale instead of quietly lying.
Measures static build-time allocations. Runtime heap, stack and scene-transition peaks are not measured.

MADE WITH EPOK
Bring your ideas to life with Epok Engine. Shape the world, define how it plays, and make every detail your own.
YOUR FIRST GAME
Install the tools, open the Sample game template and bring your first scene to life.
Installation guidegit clone https://github.com/epokengine/epok-engine.git Epok
cd Epok
powershell -ExecutionPolicy Bypass -File tools/setup.ps1
cargo run --lockedWindows commands shown; macOS and Linux setup are documented too.
Use a checkout path without spaces.
Epok is experimental. Builds and emulator execution are validated; broader physical-console validation is ongoing. Original code is MIT licensed. Read the current limits →