Skip to content
hikari
RenderingEditorAIToolchainDocumentation
Download

© 2026 Flying Rat Studio.
All rights reserved.

Explore the engineDocumentationContributorsDownloadLicenseBack to top
Documentation / Overview
Browse docs
Overview
Tutorials17
OverviewPlay, Edit, and scenesFirst UI documentFirst game projectFirst entityComponent properties and the inspectorFirst mesh and materialFirst physics body and triggerFirst character controllerFirst session servicesFirst UIFirst input actionFirst messagesFirst runtime spawnFirst motionFirst skeletal animationAssets in Play (soft refs and hot reload)Dynamic editor recompile
Guides25
OverviewWorking in the editorDevelopment guideGameplay APIActor and component lifecycleThreads, jobs, events, and routinesGameplay AI tasksGame AI: perception and movement playgroundBrain assetsBrain execution for swarm populationsLocalizationGame cursorsChoosing component storageBuild and packagingProject filePluginsHikari Plugin APIData-driven content, JSON, and pathsScripting with KawaShader authoringChoosing and scaling shadowsTime of dayUser interfaceUI layoutUI widgetsMigration from Unity / Unreal
Systems32
OverviewArchitectureApplication lifecycleFrontends and driversPlatforms and supportSession services and cross-scene stateScenes and gameplayActor communication (hi.actors)Game-facing refsSave / replication wire versionCoordinate space and camera conventionsRenderingRenderer architecture mapFrame governorPipeline compilationSkeletal animationGPU particlesVisual ZonesVolumetric mediaInputAudioPhysicsMotion KitTemporal KitUI documentsAssets and ShinraPrefabsAsset residencyAsset formats (Shinra pipeline)Document schemasUI and editorEditor asset hot reloadEditor Project Selector
Language reference3
OverviewAkari GPU ABIAkari language referenceKawa language reference
Engine overview
Start exploring
  • No matching sections. Try fewer words or another topic.
NavigateEnter Openesc Close
Overview
Tutorials17
OverviewPlay, Edit, and scenesFirst UI documentFirst game projectFirst entityComponent properties and the inspectorFirst mesh and materialFirst physics body and triggerFirst character controllerFirst session servicesFirst UIFirst input actionFirst messagesFirst runtime spawnFirst motionFirst skeletal animationAssets in Play (soft refs and hot reload)Dynamic editor recompile
Guides25
OverviewWorking in the editorDevelopment guideGameplay APIActor and component lifecycleThreads, jobs, events, and routinesGameplay AI tasksGame AI: perception and movement playgroundBrain assetsBrain execution for swarm populationsLocalizationGame cursorsChoosing component storageBuild and packagingProject filePluginsHikari Plugin APIData-driven content, JSON, and pathsScripting with KawaShader authoringChoosing and scaling shadowsTime of dayUser interfaceUI layoutUI widgetsMigration from Unity / Unreal
Systems32
OverviewArchitectureApplication lifecycleFrontends and driversPlatforms and supportSession services and cross-scene stateScenes and gameplayActor communication (hi.actors)Game-facing refsSave / replication wire versionCoordinate space and camera conventionsRenderingRenderer architecture mapFrame governorPipeline compilationSkeletal animationGPU particlesVisual ZonesVolumetric mediaInputAudioPhysicsMotion KitTemporal KitUI documentsAssets and ShinraPrefabsAsset residencyAsset formats (Shinra pipeline)Document schemasUI and editorEditor asset hot reloadEditor Project Selector
Language reference3
OverviewAkari GPU ABIAkari language referenceKawa language reference
Engine overview
Overview4 min read

Engine documentation

From your first scene to the frame on screen.

On this page
On this pageHow this tree is organizedStart with your roleGuidesSystems (engine behaviour)Runtime and sessionPresentation and simulationAssetsEditor hostReferenceReportsConventions Back to top
01 / TutorialsYour first project02 / GuidesBuild & ship

Public documentation for implemented engine behavior. Public pages are published by the Hikari website; proposals, roadmaps, maintainer checklists, and design archives are excluded from publication.

How this tree is organized

FolderAudienceContents
tutorials/New game authorsShort onboarding paths
guides/Artists, game developers, and engine developersHow to build, configure, author, extend
systems/Engine / gameplay systems workHow subsystems behave and compose
reference/Language authorsAkari and Kawa language references
reports/Engine developersMeasured benchmark records with reproduction commands

Paths in these pages are relative to the repository root unless noted.


Start with your role

You want to…Start hereContinue with
Build levels, import art, tune a scene, or design UI without codeWorking in the editorUI documents, Localization, Time of day
Write gameplay or extend a gameFirst project, then First entityGameplay API, Tutorials, Build and packaging
Change the engine, editor, or build toolsArchitecture, then DevelopmentLifecycle, Systems, and the relevant subsystem reference

Coming from another engine? Use Migration from Unity / Unreal for terminology, and Coordinate space for axes, cameras, and units.

Code samples use the current Hikari SDK. A complete file names its location; shorter fragments belong inside the callback or function described beside them. Commands run from the engine repository root unless a page says otherwise. hikari-games is a sibling repository; example paths name content from that separate checkout.


Guides

GuideCovers
Working in the editorOpen, place, edit, test, and save without code
DevelopmentChange seams, validation, hikari_std
Gameplay AI tasksTyped actions shared by Zig and Brain assets, safe completion and door encounter
Game AIFirst playable guard, game-contributed Noise Probe, and state/task kernel
Brain assetsShared AI programs, editor authoring, parameters, and decision history
Swarm AICompact population Brain execution, budgeted sensing and moving crowd example
Gameplay APIActors, components, callbacks, typed fields
ConcurrencyOS threads, worker jobs, events, and suspendable gameplay routines
Component lifecycleInitialization, updates, activation, and cleanup
LocalizationTranslation editor, catalogs, and game text
Component storageChoose attachable, embedded, or swarm, with examples
Build and packagingKaji flags, products, packages
Project filehikari.project.json, configs/, version axes
PluginsSource-composed packages, manifests, packaging
Plugin APIAuthor-facing editor/render/gameplay plugin contracts
Data, JSON, and moddingContentRef, path roots, loose resources/
Scripting with KawaEngine integration for scripts
Actor communicationhi.actors / Actors.* — find, messages, component fields
Shader authoringPackages, layouts, manifests, product pipeline
Choosing and scaling shadowsVSM, Hybrid and RT decisions, quality controls and performance
Time of dayAstronomical clock, atmosphere, sun/moon lights
User interfaceGame UI hub (lifecycle, themes, ownership)
UI layout · UI widgetsCoordinates/stacks · controls/focus/modals
Game cursorsCustom native sprites, UI hover roles, and game overrides
MigrationUnity / Unreal → Hikari concepts

Systems (engine behaviour)

Runtime and session

  • Architecture
  • Lifecycle
  • Frontends and drivers
  • Platforms
  • Session services
  • Scenes and gameplay — entities, active / enable trio
  • Actor communication — hi.actors / Actors.*, messages, name-keyed fields
  • Refs — AssetRef / ContentRef / SceneRef / PrefabRef / ActorRef
  • Replication wire version — current hook and codec limits

Presentation and simulation

  • Coordinate space — RH Y-up −Z-forward, reverse-Z, euler, view-right
  • Rendering — pipeline, G-buffer, composability contracts
  • Renderer architecture — layers, RHI, graph, sync
  • Frame governor — resolution / rays / indirect-resolution levers
  • Pipeline compilation — parallel asynchronous builds, deferred features, background warm-up, persistent caches
  • Skeletal animation — skeletons, clips, graphs, layers, events, foot IK, root motion, joint sockets
  • GPU particles — authoring, specialized SPT2 cook, simulation, indirect rendering
  • UI documents — .ui.json screens interpreted through the immediate UI: slots, events, animation, the designer window
  • Visual Zones — spatial / global look blending
  • Volumetric media — global fog and bounded smoke, lights, shadows
  • Input
  • Audio
  • Physics
  • Motion Kit · Temporal Kit

Assets

  • Assets and Shinra — pipeline, URIs, soft refs
  • Prefabs — expand/diff/variants, editor plane, runtime spawn
  • Asset residency — refcounts, budgets, scene replace
  • Asset formats
  • Document schemas — JSON Schema for every authored document kind; read before writing JSON

Editor host

  • UI and editor — chrome, contributions, Play/Edit, profiler
  • Editor asset hot reload
  • Editor project selector

Reference

  • Akari language — .akari language (EBNF)
  • Akari GPU ABI — buffer layout, alignment, and CPU/GPU packing rules
  • Kawa language and embedding

Reports

Point-in-time benchmark records. Each names its hardware and toolchain and includes the command that reproduces it.

  • Shared AI perception benchmark
  • Swarm Brain benchmark
  • Routine scheduler benchmark

Conventions

SurfaceLocation
Game-facing Zig APIsrc/hikari/sdk/src/hikari_game.zig
Engine/host API barrelsrc/hikari/src/hikari_api.zig
Thin SDK pack treesrc/hikari/sdk/
Product stdconst std = @import("hikari_std") — see Development

Docs describe implemented behaviour. A directory or future RHI type is not a shipping feature.

Next Routine scheduler benchmark

Documentation follows the current engine checkout.

Snapshot 86f12d68Source docs/README.md
On this pageHow this tree is organizedStart with your roleGuidesSystems (engine behaviour)Runtime and sessionPresentation and simulationAssetsEditor hostReferenceReportsConventions Back to top