Kyro Forge online
Architecture

We build
worlds
that run.

Game enginesSpatial XRWebGPU 3D128Hz netcodeVirtual worlds

We don't build screens. We build systems.

We engineer interactive realities from first principles: custom WebGL and WebGPU render pipelines, deterministic multiplayer physics, and spatial architectures that hold a 16ms frame budget on native hardware.

PipelineCustom ECS + shaders
Spatial engine6DoF / OpenXR native
State modelDeterministic sim
Render target16 MS · 90 HZ
ArchitectureECS + WebGPU + WASM
Netcode sync128Hz tick · <30ms RTT
InfrastructureGlobal edge mesh

We don't build screens.
We build systems.

Precision runtime engine, low-level graphics compilation, and deterministic distributed netcode.

Target frame time
16 MSLocked
Base refresh ceiling
90 HZStereo
Latency target
< 40 MSUnder 40ms

Seven subsystems, one continuous frame.

Pick a subsystem to read what it holds to and how we verify it.

Node 01 / SimulationLOCKED_DETERMINISTIC

Engine architecture

Deterministic ECS loops on a tick budget that never allocates.

Our simulation core runs at a fixed 128Hz, decoupled from the display refresh rate, so physics stays identical on a 60Hz laptop and a 165Hz monitor. WebAssembly memory pools keep the heap quiet: nothing allocates mid-tick, so there is no collection stutter to hide behind.

WASMECS coreSharedArrayBufferSIMD
Verified in productionPhantom Drift — 118fps
Read the implementation
Runtime benchmarks● Live
Clock frequency
128.4 Hz
Latency budget
< 7.4ms tick
Subsystem status
LOCKED_DETERMINISTIC
System invariants
Memory pooling
Ring buffer allocations with zero heap garbage
State reconciliation
Client prediction with rollback historical buffers
Cross-compilation
Targeting WebGL 2.0, WebGPU, and native C++ runners

Live topology matrix.

HIERARCHICAL SYSTEM TOPOLOGY · 6 CORE SUBSYSTEMS · ACTIVE RUNTIME BUS
Kyro Forge · subsystem matrix
Capability

Deterministic ECS loops & zero-allocation tick architecture

Specification

A custom-built game loop operating at fixed 128Hz intervals. Decouples state simulation from variable display framerates, utilizing WebAssembly memory pools to eliminate JavaScript garbage collection stutters.

TECHNOLOGIES
C++WebAssemblyTypeScriptECS ArchitectureTypedArray Pools

Engines we shipped, and what they run on.

View all case files
RAYCAST_SUSPENSION: 4.2 kNFIG 01 // WEBGPU_PHYSICS_SOLVERDELTA_TIME: 8.33 MS (120 HZ)NET_TRANSPORT: WEBRTC_UNRELIABLEDISPATCH_DRAWS: 32 INSTANCESSTATE_SYNC: AUTHORITATIVE_EDGE
GAMES
No. 001
Open case file
Case 0012025

Phantom Drift

High-octane browser racing engine with sub-40ms authoritative multiplayer netcode.

Active Racers80K+
Open case file↗
INTERPUPILLARY: 64 MMVOLUMETRIC_VIEWPORT_01REFRESH: 90 HZ STEREOMTP_LATENCY: 9.8 MSSTATUS: 6DOF_LOCKEDFIG 02 // 6DOF_STEREOSCOPIC_PIPELINEAPI: WEBXR / OPENXR / ARKITFOV: 110° STEREOSCOPIC
XR
No. 002
Open case file
Case 0022025

Nebula Station

Volumetric space exploration and workstation platform for Meta Quest and Apple Vision Pro.

Refresh Target90 HZ
Open case file↗
TICK_1280TICK_1296TICK_1312TICK_1328TICK_1344TICK_1360TICK_1376HISTORICAL_REWIND: 250 MSSTATE_DELTA_VERIFICATIONPACKET_SIZE: 3.4 KB (BIT-PACKED)INTEGRITY_CHECK: SHA-256_HASH_RINGDESYNC_TOLERANCE: 0.004%FIG 03 // DETERMINISTIC_ECS_NETCODETICK_FREQUENCY: 128.4 HzAUTHORITY: EDGE_RELAY_MESH
GAMES
No. 003
Open case file
Case 0032024

Echo Protocol

Competitive tactical multiplayer engine with anti-cheat state verification.

Server Tick Rate128 HZ
Open case file↗
VOLUMETRIC_ANCHORFIG 04 // SPATIAL_VOLUMETRIC_ANCHORPIPELINE: WEBAR / VISIONOS / CADOCTREE_LOD: 8 SUBDIVISIONS
XR
No. 004
Open case file
Case 0042024

Spatial Canvas

Shared augmented reality workspace for collaborative 3D CAD inspection.

Anchor Drift< 2mm
Open case file↗
FIG 05 // PROCEDURAL_VOXEL_SYNTHESISALGORITHM: DUAL_CONTOURING // OCTREEWORKER_DISPATCH: BACKGROUND_STREAMSTABILITY: 99.2% FRAME_LOCK
GAMES
No. 005
Open case file
Case 0052024

Void Runners

Infinite procedural spatial maze runner optimized for mobile GPU architectures.

FPS Stability99.2%
Open case file↗
FIG 06 // CLUSTERED_PBR_LIGHTINGPIPELINE: WEBGPU // CLUSTERED_FORWARD+LIGHT_BUDGET: 512 DYNAMIC_LIGHTSINITIAL_LOAD: 780 MS
XR
No. 006
Open case file
Case 0062024

Holo Gallery

Universal browser-accessible virtual museum with raytraced spatial audio.

Initial Load780 MS
Open case file↗

Visuals and cinematics we render live.

Realtime 3D, cinematics, procedural worlds, and spatial computing.

REALTIME 3D
16:9·120 FPS
WEBGPU // CLUSTERED_PBRPASS: ANISOTROPIC_SPECULAR · 120 FPS
Inspect spec

Kinetic Exoskeleton

Clustered PBR compute shaders and multi-layer microfacet metallic reflections.

PIPELINE: WebGPU Compute
RES: 3840x2160
CINEMATICS
21:9·60 FPS CINEMATIC
CINEMATIC // 21:9 ANAMORPHICCOLOR: ACEScg · AP0 GAMUT · 60 FPS
Inspect spec

Orbital Ascent

Real-time virtual production camera rig with physical optical lens distortion.

PIPELINE: Unreal / Custom GL
RES: 5120x2160 (21:9)
VFX
16:9·120 FPS UNLOCKED
GPU_PARTICLES // 1.5M BUFFERSSOLVER: NAVIER-STOKES · DISPATCH: 0.86 MS
Inspect spec

Supernova Hydrodynamics

1.5 million GPU particles driven by Navier-Stokes fluid velocity vectors.

PIPELINE: WebGPU Compute Buffers
RES: 1920x1080
PRODUCT VISUALIZATION
16:9·60 FPS INTERACTIVE
PRODUCT_VIZ // DUAL_LOBE_CLEARCOATMATERIAL: CARBON_ANISOTROPIC · 320K POLYS
Inspect spec

Aero-Chassis Carbon Weave

Photorealistic carbon fiber weave with dual-layer clearcoat refraction.

PIPELINE: WebGL 2.0 / Three.js
RES: 3840x2160
DIGITAL WORLDS
21:9·90 FPS
DIGITAL_WORLDS // PROCEDURAL_LODPIPELINE: OCTREE_STREAMING · 90 FPS
Inspect spec

Voxel Biosphere Horizon

Infinite procedural voxel landscape streaming with dynamic octree LOD.

PIPELINE: Custom C++ Engine / WASM
RES: 3440x1440 (21:9)
INTERACTIVE EXPERIENCES
16:9·90 HZ SPATIAL
INTERACTIVE_XR // AUDIO_FFT_MATRIXINPUT: 6DOF_GESTURAL · 90 HZ SPATIAL
Inspect spec

Synesthetic Sound Matrix

Audio-reactive volumetric field responding to live FFT frequency spectrums.

PIPELINE: WebXR / VisionOS
RES: Dual 2064x2208
Color accuracy: Rec.2020 / DCI-P3 calibrated
Shaders: no runtime compilation stutter

Experimental systems.

Experimental graphics, parallel netcode, and spatial algorithms.

BUILD_25.04.1Benchmarked
WEBGPU_COMPUTE_BUFFER // DISPATCH_01
DISPATCH TIME: 0.86 MS
WebGPU2025.Q1

Compute Particle Vector Fields

Stress test evaluating 1.5 million particles simulated in WebGPU compute shaders. Calculates 3D curl noise and velocity advection fields in under 0.86ms per frame.

WebGPUWGSLCompute BuffersCurl Noise
BUILD_24.11.8Active
DUAL_CONTOURING // OCTREE_MESH
CHUNK EXTRACTION: 3.2 MS
Procedural2024.Q4

Dual-Contouring Voxel Extractor

A multi-threaded Web Worker implementation of the Dual Contouring algorithm. Preserves sharp mechanical creases and geometric features while generating continuous isosurfaces.

TypeScriptWeb WorkersDual ContouringWASM
BUILD_25.02.3Prototype
FOVEAL_EYE_VECTOR // GAZE_TRACK
SHADING LOAD: -44%
XR2025.Q1

Dynamic Foveated Multiview Pass

Stereoscopic single-pass multiview rendering pipeline integrated with eye-tracking gaze vectors. Concentrates GPU shading power in the foveal region for high-density spatial displays.

WebXRVisionOSOpenXRGLSL Shaders
BUILD_24.09.2Benchmarked
HERMITE_QUATERNION // REWIND_CURVE
DESYNC DRIFT: < 0.02°
Multiplayer2024.Q3

Hermite Quaternion Extrapolation Netcode

Authoritative network state extrapolation evaluating Hermite quaternion interpolation. Eliminates visual stutter and rotational snapping during simulated 80ms packet bursts.

WebRTCTypeScriptQuaternionsNetcode
BUILD_25.01.5Active
RAYCAST_SUSPENSION // SIMD_128
STEP LATENCY: 0.38 MS
Physics2025.Q1

SIMD Raycast Suspension Solver

A deterministic 4-wheel vehicle suspension solver compiled from C++ to WebAssembly with 128-bit SIMD vector intrinsics. Resolves multi-surface friction in under 0.4ms.

C++WebAssemblySIMDRaycasting
BUILD_24.12.1Benchmarked
CLUSTERED_AABB // 512_LIGHT_CULL
MAX LIGHTS: 512 ACTIVE
Realtime 3D2024.Q4

Clustered Forward+ Light Culler

GPU compute shader that slices the camera frustum into a 3D AABB grid (16x16x24 tiles) to evaluate up to 512 dynamic point lights with minimal draw overhead.

WebGL 2.0WebGPUClustered ShadingGLSL
BUILD_25.05.0Research
R&D PROTOTYPENEURAL_MESH_DISTILLATION // SPEC_INTAKE
STATUS: R&D INTAKE
AI experiments2025.Q2

Neural Radiance Field Mesh Distillation

[R&D PROTOTYPE] Investigating automated pipeline to bake 3D Gaussian splat radiance fields into compressed Draco polygonal meshes with baked spherical harmonics.

PyTorchGaussian SplattingDracoWebGPU
Not yet deployed
7 of 7 experiments compiled · continuous R&D
Stability: zero unhandled rejections

Engineering doctrine.

Realtime systems, deterministic code, and hardware performance budgets.

Who we are

Engineering Studio for Realtime Systems

A technical creative-engineering studio founded in 2024. We operate at the intersection of low-level graphics compilation, deterministic simulation loops, and spatial computing architectures.

Founded 2024 · discipline: systems & xr
What we build

Engines, Netcode & Spatial Realities

Authoritative multiplayer engines, stereoscopic WebXR/VisionOS platforms, GPU compute shaders, procedural terrain generation, and low-latency network protocols that run across browsers and native runtimes.

Output: engines / shaders / spatial
How we work

Deterministic & Performance-Constrained

Zero-allocation memory pooling, strict frame budgeting (<16ms Web, <11ms XR), SIMD mathematics, and direct engineering collaboration. We eliminate agency layers in favor of pure technical execution.

Frame target: 16ms · zero alloc pools
Where we operate

Global Infrastructure, Indian Roots

Operating from Coimbatore, India with global edge node deployments. We engineer and support continuous production titles across North America, Europe, and Asia-Pacific.

Global edge nodes · distributed mesh
Execution pipeline

The five stages we take a project through

Stage 1 of 5 active
Stage 01Boundary profiling

Discover

Rigorous hardware ceiling profiling, target display refresh audit (60Hz / 90Hz / 120Hz), and network transport bandwidth analysis before writing architecture.

  • Hardware ceiling matrix
  • Memory budget audit
  • Bandwidth SLA
Inspector: stage 01Audit phase
Verification
Deterministic
Tick constraint
Locked SLAs
Status
Ready for dispatch

Every stage holds the same zero-allocation and profiling invariants.

Engineering partnership

Ready to architect your next realtime engine?

Start a scoping call

Start a project.

SYS.INTAKE // SPECIFICATION DISPATCH

Tell us what you are
STRANGE.

Transmit your operational parameters. We architect custom engines, realtime 3D worlds, and spatial computing infrastructure with zero technical debt.

PROJECT TYPE *
BUDGET RANGE *
TIMELINE *
0 / 5000

DIRECT CHANNELS

PRIMARY COMLINKhello@kyroforge.com
HQ LOCATION

Coimbatore, Tamil Nadu, IN

RESPONSE SLA

Technical evaluation within 24 hours

ENGAGEMENT PROTOCOL

01
DISPATCH LOGGED

Parameters ingested and routed to lead system engineer.

02
TECHNICAL SCOPING

Feasibility sync covering frametime budgets, netcode, and shaders.

03
ARCHITECTURE PROPOSAL

Concrete milestone deliverables with fixed SLAs and profiling metrics.

SYSTEM STANDARDS
MEM_ALLOC:ZERO RUNTIME GC
SIMD & THREADING:LOCKED WORKERS
NDAs & IP:MUTUAL PROTECTED