Epok Engine

ORIGINAL PLAYSTATION DEVELOPMENT

Build worlds.
Make them PSX.

A standalone visual editor.
A native PlayStation runtime.
Your next game starts here.

Windows x64 + macOS Apple Silicon + Linux x86_64 · Open source · Experimental

PLAYABLE PSX DEMO / v0.10.0

Dungeon Template

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.

Explore the template

Keyboard and controller
Move
Arrow keys / D-pad or left stick
Camera
I J K L / right stick
Jump or interact
X / Cross
Shoot
S / Square
Aim or lock on
Q E / L1, R1
Inventory / close
A Z / Triangle, Circle
Retry
Enter / Start

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

REACTOR STATION

SMALL CONSOLE. A LOT OF POSSIBILITIES.

Explore the engine.
Every little superpower.

World building to the last byte.
Find a capability. See how it works.

Feature explorer202 capabilities
Full reference ↗

202 of 202 features

EXPAND TO EXPLORE
World buildingv0.10.0Dungeon 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.

Blueprints & codev0.10.0Six 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.

Gameplay & Actorsv0.10.0Gameplay actions and input contexts

Bind controller inputs to named actions. Let gameplay, menus and conversations take turns handling the same buttons through temporary contexts.

Gameplay & Actorsv0.10.0World interaction helpers

Place and extend reflected actors for examination, NPC dialogue, pickups, doors and switches in any of the three gameplay languages.

UI & HUDv0.10.0Dialogue widgets

Author conversations with lines, choices, conditions and actions. Present them through a UIActor derived from DialoguePresenter.

Gameplay & Actorsv0.10.0Shared 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.

Rendering & animationv0.10.0Gameplay camera rigs

Configure camera follow and aiming through shared rigs and projection helpers.

Gameplay & Actorsv0.10.0Health helpers

Apply damage and healing with shared, bounded health arithmetic through HealthState and HealthLibrary.

Gameplay & Actorsv0.10.0Pooled projectiles

Fire and update projectiles from a bounded pool backed by the 3D collision system.

Gameplay & Actorsv0.10.0Shared 3D query context

Use a reflected component to perform 3D gameplay queries through the existing collision backend.

Editor & projectsProject Hub

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.

Editor & projectsProject descriptors

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.

Editor & projectsTemplates

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.

Editor & projectsTemplate 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.

Editor & projectsDependencies 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.

Editor & projectsLegacy 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.

Editor & projectsRecent projects and optional file association

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.

Editor & projectsBranded 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.

Editor & projectsPortable 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.

Editor & projectsDockable workspace

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

Editor & projectsScene 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.

Editor & projectsHierarchy 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.

Editor & projectsComponent 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.

Editor & projectsControl bindings

Keyboard, mouse and pad bindings are edited against a controller illustration whose button regions scale with the image.

Editor & projectsNumeric editing

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

Editor & projectsConsole

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.

Editor & projectsArtifact 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.

Editor & projectsResponsive 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.

Assets & importsNative 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.

Assets & importsFavorites and Collections

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

Assets & importsNative 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.

Assets & importsFile 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.

Assets & importsImage preview

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

Assets & importsAudio 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.

Assets & importsModel 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.

Assets & importsBounded 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.

Assets & importsProcessed-source visibility

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

Assets & importsSafe 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.

Assets & importsRecoverable deletion

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

Assets & importsIdentity-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.

Assets & importsReference 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.

World buildingYAML scenes

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

World buildingEditableMesh / 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.

World buildingHeightmap 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.

World buildingSpatial compilation

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

World buildingDungeon 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 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.

World buildingStatic OBJ/MTL import

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

World buildingScene 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.

World buildingLinked scene and template data

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

Gameplay & ActorsObject / Actor / Component classes

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.

Gameplay & ActorsDomains

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.

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

Gameplay & ActorsC++ and Blueprint chains

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.

Gameplay & ActorsScene Blueprint per map

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.

Gameplay & ActorsOlder project compatibility

Previous Entity/Behaviour maps, older Blueprint versions and .epokscript sidecars are rejected without automatic conversion. Recreate them as Actor-based projects.

Gameplay & ActorsCooked tables and counters

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.

Rendering & animationPNG import

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.

Rendering & animationNative TIM import

Indexed 4/8-bit .tim sources import through the same Texture workflow and keep every index and all 16 bits of each palette entry.

Rendering & animationVRAM 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.

Rendering & animationMaterials

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.

Rendering & animationDisplay 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.

Rendering & animationPSX 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.

Rendering & animationLight components

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

Rendering & animationVertex-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.

Rendering & animationNative realtime lighting

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

Rendering & animationShadows

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

Rendering & animationFog and screen fade

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.

Rendering & animationAnimated surfaces

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

Rendering & animationCameras

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

Rendering & animationCamera 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.

Rendering & animationLarge 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.

Rendering & animationWorld sprites

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

Rendering & animationSprite animation

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

Rendering & animationParticle 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.

Rendering & animationParticle Effect assets

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.

Rendering & animationFBX 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.

Rendering & animationTextured 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 & VFXTimeline 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.

Timelines & VFXNative 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.

Timelines & VFXProperty 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.

Timelines & VFXEvent tracks

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

Timelines & VFXPlayback control

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

Timelines & VFXBlueprint 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.

Timelines & VFXDependency-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.

World building2D nodes

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.

World buildingSprites 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.

World buildingPhysics

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.

World buildingCamera2D

Follow with drag margins, limits, smoothing, offset, zoom, rotation, shake and the background colour the game clears to.

World buildingTile 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, ...).

World buildingPaths, 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.

World buildingCut-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.

World buildingRigid 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.

World buildingNavigation

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.

World buildingPictures 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.

World buildingParallax 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.

World building2D 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.

World buildingNative 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.

World building2D 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).

World buildingShape editing

Paths, lines and polygons are edited on the canvas: drag, insert, add and delete points, curve handles, smoothing; particle emitters preview live.

World buildingTile 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.

World buildingDungeon 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.

World buildingPlatformer 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.

UI & HUDCanvas hierarchy

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

UI & HUDWidgets

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.

UI & HUDLayout 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.

UI & HUDFocus 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.

UI & HUDText

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.

UI & HUDLocalization

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.

UI & HUDRetained rendering

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

UI & HUDNavigation utilities

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

Audio & musicSource 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.

Audio & musicResident SFX

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.

Audio & musicNative music sequences (Epok Pulse)

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.

Audio & musicXA background music

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

Audio & musicFull-motion video

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.

Audio & musicTransition audio

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

Audio & musicResident SPU sample capacity

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

Blueprints & codeUnified 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.

Blueprints & codeC++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.

Blueprints & codeSemantic 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.

Blueprints & codeInspector 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.

Blueprints & codeLifecycle

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.

Blueprints & codeRuntime 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.

Blueprints & codeReflected Lua classes

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.

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

Blueprints & codeThree 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.

Blueprints & codeShared 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.

Blueprints & codeBounded 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.

Blueprints & codeEditor definitions and diagnostics

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.

Blueprints & codeNative compiled graphs

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

Blueprints & codeCreation 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.

Blueprints & codeGraph 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.

Blueprints & codeTyped 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.

Blueprints & codeFlow 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.

Blueprints & codeFunctions 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.

Blueprints & codeEntity 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.

Blueprints & codeDebugging

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

Blueprints & codeEditor 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.

Gameplay & ActorsController 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.

Gameplay & ActorsController 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.

Gameplay & ActorsMeasured fixed step

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

Gameplay & ActorsAABB 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.

Gameplay & ActorsBaked 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.

Gameplay & ActorsEntity handles

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

Gameplay & ActorsScene lifetime

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

Build & deployNative 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.

Build & deployPersistent 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.

Build & deployIntegrated 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.

Build & deployOwned external emulator

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

Build & deployPSX 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.

Build & deploySafe 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.

Build & deployCritical-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 & deployGenerated 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.

Build & deployInput 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.

Build & deployPrivate SDK builds

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

Build & deployMemory 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.

Build & deployScene 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.

Build & deployScenes 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.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.

Build & deployExecutable 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.

Build & deployPS-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.

Build & deployStandalone 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.

Build & deployVersion/release policy

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.

Performance & memoryOptional geometry archive

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

Performance & memoryCD 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.

Performance & memoryVisibility

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.

Performance & memoryCamera 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.

Performance & memoryPrepared 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.

Performance & memoryCamera 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.

Performance & memoryRetained geometry/HUD

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

Performance & memoryCounters

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.

Performance & memoryProfiling tools

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

Gameplay & ActorsMemory Card: 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.

Gameplay & ActorsMemory Card: 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.

Gameplay & ActorsMemory Card: Scene independence

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

Gameplay & ActorsPocketStation 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.

Gameplay & ActorsPocket 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, math and print libraries, with line-accurate errors and suggestions. Assembly files add functions Pocket Lua calls directly.

Gameplay & ActorsAssembler

ARM and Thumb with literal pools, local labels, includes and automatic relaxation of far Thumb branches; whole programs can be assembly.

Gameplay & ActorsEmbedded 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).

Gameplay & ActorsPocketStation 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/.bin export for real hardware.

Gameplay & ActorsGame integration

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.

Automation & toolsOptional 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.

Automation & toolsTwenty-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_manage and dungeon_generate cover inspection, guarded scene/actor/file edits, screenshots, imports, camera paths, visibility bakes, dungeon generation, build/play and serial preparation.

Automation & toolsTransactional 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.

Automation & toolsReal 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.

Automation & toolsRead-only resources

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

Automation & toolsBuild and run CLI

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

Automation & toolsProjects CLI

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

Automation & toolsAssets CLI

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

Automation & toolsNative gameplay CLI

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

Automation & toolsTimeline and VFX CLI

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

Automation & toolsLevel generation CLI

--generate-dungeon, --dungeon-seed, --dungeon-settings, --dungeon-new-style, --dungeon-new-recipe, --dungeon-seed-bench, --open-dungeon-room, --open-dungeon-seeds, --open-dungeon-volumes

Automation & toolsEditor/runtime QA CLI

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

Automation & toolsPocketStation CLI

--new-pocketstation-app, --pocketstation-template, and for screenshots --open-pocketstation, --pocketstation-run, --pocketstation-play, --pocketstation-tab, --screenshot-delay

Automation & toolsIntegration CLI

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

Automation & toolsRust unit tests

Rust unit tests cover serialization, UI interaction harnesses, asset safety, Blueprint connectivity/split pins/action menus, Timeline compilation and the editor's pure logic.

Automation & toolsC++ host tests

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.

Automation & toolsPython integration checks

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.

Automation & toolsVisual fixtures and curated captures

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.

Automation & toolsDependency manifests

Dependency manifests pin downloadable tools and validate hashes; setup scripts keep portable tools under .tools/ and avoid changing global PATH.

Editor & projectsWindows, macOS and Linux editor hosts

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

Editor & projectsOpen-source editor and native runtime

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

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

Built in layers.
Made to go further.

A visual workspace on your computer.
A native game on original hardware.

EPOK / SYSTEM MAP
Available today A future direction
  1. 01 AUTHOR / DESKTOP

    Epok Editor

    Rust · wgpu · dockable workspace

    Your project owns the source.
    The editor owns the workspace.

  2. 02 PREPARE / HOST TOOLS

    Reflect. Cook. Build.

    Typed contracts · target conversion

    Build-time work stays on the host.
    Only prepared code and data ship.

  3. 03 EXECUTE / ORIGINAL HARDWARE

    Epok Runtime

    C++20 · fixed point · bounded pools

    Scenes & lifetimeInput & collisionRendering & HUDAudio & effects
    Original PlayStationPsyQo / native MIPS

    PS-X EXE / disc · emulator or console
    See target requirements ↗

THE SOURCE STAYS. THE HORIZON MOVES.

Some familiar hardware is still just a silhouette.

NEXT SIGNAL / UNDISCLOSEDAnother era is calling.More retro horizons. Stay tuned.
The editor validates project data, generates native code and cooks target assets. The PSX runtime uses PsyQo to reach the hardware. PSX is the supported game target today; the next signal is a glimpse ahead, not an available export option.
Epok Scene View displaying the courtyard with textured geometry, characters and particles
Scene View captured directly from the Epok renderer.

SCENE VIEW

See your world
take shape.

Arrange objects, adjust lighting, and preview your world as you build.

Explore the editor

C++ / BLUEPRINTS / LUA

Write it. Wire it.
Run it on PSX.

Three authoring paths, one reflected Actor model.
Choose native code, typed graphs or statically checked Lua.

Epok Engine / Blueprint EditorREAL EDITOR CAPTURE
Epok Blueprint editor showing components, inherited variables, typed connections, branches and a Delay node
Blueprint authoring shown here. C++20, Blueprints and Lua classes share reflected parents, properties, events and the same native PlayStation runtime.
Start the Lua tutorial

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

Know where every
byte went.

A black screen is not a memory profiler.
Epok gives you the report before the surprise.

Epok Memory Analyzer showing the Main RAM capacity bar, proportional allocation treemap and byte-level resource table
Real editor capture: 1.92 MiB of the PlayStation's 2 MiB main RAM attributed across runtime pools, scene geometry, code, textures and other linked allocations.
01 / FIVE VIEWS

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.

02 / DRILL DOWN

From rectangle to resource

Click through the treemap and allocation table to linked symbols, byte counts, scene references and supported source assets.

03 / BUILD-BOUND

Numbers you can trace

Reports come from the linked ELF and selected staged assets. Source or profile changes mark old results as stale instead of quietly lying.

Explore the Memory Analyzer

Measures static build-time allocations. Runtime heap, stack and scene-transition peaks are not measured.

Native PSX output with a sprite character in a textured forest and portrait dialogue HUD
Demo under development. It will be included soon.

MADE WITH EPOK

Your world.
Your rules.

Bring your ideas to life with Epok Engine. Shape the world, define how it plays, and make every detail your own.

YOUR FIRST GAME

Clone. Create. Play.

Install the tools, open the Sample game template and bring your first scene to life.

Installation guide
PowerShellWindows x64
git clone https://github.com/epokengine/epok-engine.git Epok
cd Epok
powershell -ExecutionPolicy Bypass -File tools/setup.ps1
cargo run --locked

Windows commands shown; macOS and Linux setup are documented too.
Use a checkout path without spaces.

Built in the open. Still evolving.

Epok is experimental. Builds and emulator execution are validated; broader physical-console validation is ongoing. Original code is MIT licensed. Read the current limits →