Create in a tab
A full 3D editor on a web page: hierarchy, inspector, gizmos, script editor, timeline and terrain tools. Open a link and start building.
Editor and platform in open beta
Build worlds.
Build worlds.
Play together.
Galatrix is a game engine and a multiplayer platform that live entirely on the web. The editor runs in a browser tab, with scripting, physics, navigation, animation and terrain. The worlds you make run the same way for everyone who joins them.
The editor is in active beta and a free account opens it. The platform it publishes to is in open beta at play.galatrix.com.
Console Assets Terrain Event Sheets ▸ NavMesh baked — 3 levels
In the browser
No install, no engine download
Standalone export
Ship a build as a single HTML file
Starter kits
Whole genres, ready to take apart
What is Galatrix
One stack, from first cube to live game
Most engines make you download a toolchain, learn a build pipeline and find your own servers. Galatrix puts the editor, the runtime and the multiplayer backend on the same web stack.
Play together
Published worlds run in server-authoritative rooms on a fixed tick, with delta-compressed state and client prediction. Physics and scripts execute on the server, not on trust. Galatrix hosts the rooms; you never rent one.
Ship it anywhere
Publish to the platform, or export a standalone build as a single HTML file. Unused engine subsystems are stripped, so a small game stays a small download.
How it works
Four steps, one tab
There is no separate build step between making a change and playing it. The editor, the runtime and the servers all execute the same simulation code.
- 01
Build the world
Drop in primitives and glTF models, sculpt terrain, paint tilemaps, or import a Minecraft schematic. Transform gizmos, grid snapping, prefabs and full undo behave the way you expect.
- 02
Give it behaviour
Attach components, then write behaviour classes in the built-in script editor. Event Sheets wire the same logic visually for anyone who would rather not write code. Fields you declare appear in the Inspector as sliders and pickers.
- 03
Play-test instantly
Press Play and you are in the world, in the same tab, running locally with no server involved. The play-test executes the same simulation code a published build does, so what you see is what players get.
- 04
Publish or export
Publish the map to the platform, or export a self-contained standalone build you host yourself.
The editor · open beta
A real engine editor, on a web page
An entity-component editor with a script runtime, a physics engine and a navigation system behind it. Pick an area to see what it covers.
The editing surface you already know
A hierarchy on the left, an inspector on the right, and a viewport built for real work. Undo and redo cover every operation, and panels dock where you want them.
- Move, rotate and scale gizmos with local/world and pivot/centre toggles
- Grid snapping, snap to ground and a measure tool
- Multi-select, parenting, tags and layers
- Prefabs with instance overrides, apply and revert
- Ctrl+K command palette to jump to any object or command
- Camera preview inset, orientation gizmo and a frame-time profiler
Behaviour classes, with the lifecycle you expect
Scripts are classes with Awake, Start, Update and FixedUpdate, plus collision and trigger callbacks. The editor ships full type definitions, and the API mirrors names engine developers already know: Vector3, Mathf, Time, Input. The patterns transfer, even though you write TypeScript here.
- Monaco editor with autocomplete for every engine API
- Inspector-serialised fields with Header, Tooltip, Range and Entity decorators
- Coroutines, timers, events and cross-script calls
- Vector3, Quaternion, Mathf, Time, Input and Physics all behave as expected
- Event Sheets express the same logic as visual rows, and compile to a behaviour
export class Collectible extends Behaviour {
@Range(10, 360) spinSpeed = 120
onUpdate(dt: number) {
this.transform.Rotate(0, this.spinSpeed * dt, 0)
}
onTriggerEnter(other: Entity) {
const player = players.from(other)
if (!player) return
economy.addCoins(player, 5)
audio.play('pickup')
this.entity.destroy()
}
}Rapier, wired through every runtime
Rigid bodies, colliders and joints simulate identically in the editor play-test, in standalone exports and on the authoritative server. All three run the same code path.
- Dynamic, kinematic and static bodies whose mass stays exactly what you set, even after scaling
- Trigger volumes with Enter, Stay and Exit on any entity
- Fixed, hinge, ball and spring joints
- Per-surface friction and bounciness with average, min, max and multiply combine modes
- Raycasts, sphere casts and overlap queries with layer masks
- Ragdolls, and a per-layer collision matrix
onFixedUpdate() {
const grounded = physics.sphereCast(
this.transform.position, 0.4, Vector3.down, 0.6,
)
if (grounded && Input.GetButtonDown('Jump')) {
physics.applyImpulse(this.entity, [0, 9, 0])
}
}Pathfinding as an engine primitive, behaviour as your code
The engine bakes walkable space and steers agents along it. What those agents do is your script: the engine owns the movement, you own the behaviour.
- Walkability baked from level geometry, with agent-radius clearance
- Multi-level navigation — agents climb ramps onto stacked surfaces
- Obstacle carving for doors, lifts and debris
- Off-mesh links with automatic jump arcs
- Nav areas with costs, so agents prefer roads and avoid mud
- Agents tick on the server, so NPCs behave the same in multiplayer
export class ChaseAI extends Behaviour {
detectRange = 18
onUpdate() {
const target = players.nearest(this.transform.position)
if (!target) return agent.stop()
if (target.distance < this.detectRange) {
agent.setDestination(target.position)
}
}
}A timeline and a state machine, not just clip playback
Key transforms, opacity and colour on the root or on any bone, then drive those clips from a parameterised state machine that your scripts control.
- Keyframe timeline with record mode and per-key bezier curves
- Tracks on child entities and individual bones
- Animator state machine with typed parameters, conditions and crossfades
- Animation events that call back into your scripts on a frame
- Imported glTF clips and authored clips play through the same path
- Animated colliders carry the player — moving platforms just work
Terrain, voxels and multi-scene projects
Sculpt smooth voxel terrain by hand, generate it procedurally, or bring in existing voxel builds. A single project can span several full maps.
- Sculpt, smooth, erode, flatten and paint terrain with material layers
- Grass and tree layers painted straight onto the surface
- Procedural generation across biome presets, with caves and ore veins
- Minecraft schematic import: .schematic, .schem and .litematic
- Greedy meshing and texture atlasing, so imports render as static geometry
- Sub-maps: several full maps in one project, switched at runtime
Lighting, materials and effects
A physically-based renderer, with the lighting, material and post-processing controls a world needs to look art-directed.
- PBR materials, a shader editor and reflection probes
- Point, spot and directional lights with shadow control
- Skyboxes from flat colour and gradients to equirectangular and cubemaps
- Particle systems with lifetime gradients and death sub-emitters
- Decals that hug surfaces without z-fighting
- Bloom, SSAO, vignette and colour grading
A 2D pipeline in its own right
Sprites, tilemaps and a pixel-perfect orthographic camera, with two ways to build interfaces on top of them.
- Sprite renderer with flipbooks, flipping and tinting
- Tilemaps with generated colliders and a painting brush
- Pixel-perfect camera, sorting layers and masks
- A Canvas editor with anchoring, stretch and rect transforms
- A scripted HUD that can target a single player in multiplayer
- World-space labels for nameplates and floating prompts
One project, three ways out
The same map runs as an editor play-test, as a file you host anywhere, and as a hosted multiplayer room. None of them needs a separate build pipeline.
- Publish straight from the editor
- Export standalone as a single HTML file or a ZIP
- Unused subsystems are detected and stripped from the export
- Install the editor as a desktop app (it is a PWA)
- Drive a running editor from your terminal over the CLI bridge
- Describe a change in plain language and let the AI agent make it
Starter kits
Whole genres, bundled with the editor
Importable asset packs: prefabs, scripts and a demo scene for a whole genre. Bring one in and you have a working game to play, pull apart and rebuild as your own. Every behaviour is an editable map script, not locked engine code.
Obby
Checkpoints, kill bricks, spinners and jump pads, with a timed finish line.
Race circuit
A drivable car, ordered checkpoints, boost pads and a best-lap HUD.
Tower defense
Creeps walk the path in waves; build auto-firing towers to stop them.
Survival arena
Escalating monster waves, coins per kill, upgrades between rounds.
Adventure
A terrain island, gems hidden across it, and a buggy to find them in.
2D platformer
Run, jump and collect on a pixel-perfect orthographic camera.
Off-road rally
A terrain time trial: gates in order, boost pads, best time saved.
Endless runner
A one-button auto-runner that speeds up as your score climbs.
Farm sim
Plant, watch crops ripen, harvest for coins, under a day/night cycle.
Tycoon
Tiered collectibles on a conveyor, income multipliers and a rebirth loop.
And the building blocks
Systems rather than finished games — drop one into a project of your own and build on top of it.
Character controllerVehicle controllerNav controllerRagdoll physicsMonster truckCustom monster truckMobile controlsPost effectsCustom shaders
The platform · open beta
Where the worlds live
The platform is the other half of Galatrix: a place to publish what you build, and a place for players to find it. It is in open beta at play.galatrix.com.
Discover & play
A browser of published worlds with search and categories, sorted by most popular, newest, most active or top rated, with likes and play counts on every card. Everything is playable straight from the page.
BrowserRatings
Multiplayer rooms
Server-authoritative rooms with a fixed tick loop, delta-compressed state, client prediction and reconciliation, and routing across a pool of game servers.
AuthoritativeRooms
Avatars
A customisable character with skins, accessory slots and animation sets, carried across every world on the platform.
SkinsAccessories
Social
Friends and friend requests, chat with moderation built in, profiles and notifications.
FriendsChat
Economy
An in-game currency players spend on cosmetics for their avatar and on upgrades inside the games they play.
CurrencyCosmetics
Creator tools
Publish a map to the platform from inside the editor, and update it once it is live.
PublishingUpdates
Player data
Per-game saved progress for the games you build, persisted for every player without you running a database.
SavesPersistence
Safety
Reporting and blocking, a moderation review queue, content filtering and account enforcement, built into the platform instead of per game.
ModerationReporting
Where things stand
What is ready today
Galatrix is an ongoing build. The editor and the platform are both usable today, in beta, and the rest is still coming together.
Editor Beta
Open beta at editor.galatrix.com. Build worlds, script them, play-test them and export a standalone build today. A free account is required to open it.
Engine runtime Beta
One shared simulation drives editor play-test, standalone exports and hosted multiplayer, so a world behaves the same wherever it runs.
Game platform Beta
Open beta at play.galatrix.com. Sign up free or play as a guest, then find published worlds and play them straight from the browser. Avatars, chat and saved progress all work today.
Built with
A TypeScript stack end to end — the same language in the editor, the runtime and the servers.
TypeScriptThree.jsRapierReactViteNode.jsWebSocketsPostgresRedis
Questions
Straight answers
Can I use it right now?
The editor is in open beta at editor.galatrix.com, and a free account opens it. The platform it publishes to is in open beta at play.galatrix.com, where worlds can be found and played. Both are beta, so expect rough edges.
Do I need game engine experience?
No. If you have used a mainstream 3D engine, the model is familiar: entities with components, a Start and Update lifecycle, and APIs like Vector3, Mathf, Time and Input. Your habits carry over, though you write TypeScript here instead of C#. If you have not, the bundled starter kits are working games you can open, play and take apart. Event Sheets cover the same ground visually for anyone who would rather not write code.
What does it run on?
Three.js for rendering and Rapier compiled to WebAssembly for physics, all in TypeScript. Servers are Node.js talking WebSockets, with Postgres for persistence and Redis for room routing.
Is my game locked into the platform?
No. Any project exports as a standalone build, either a single HTML file or a ZIP, hosted wherever you like. Unused engine subsystems are stripped from the export, so the download stays small.
Does multiplayer really run on the server?
Yes. Physics, gameplay scripts and navigation agents all tick on an authoritative game server, and clients send input and interpolate the state they get back. One distinction: the editor’s play-test runs entirely in your browser tab with no server involved, so anything depending on server authority should be checked in a published room as well.
What about mobile and controllers?
Phones work: moving, looking, jumping and using the tool you are holding are all playable by touch, and multi-touch is wired through the same input API as mouse and keyboard. A world that leans on keys a phone does not have needs on-screen controls, which creators can add. Gamepads are readable from scripts, but controller mapping and key rebinding are not finished.
I found a bug, or I want to ask for something.
Both are welcome, and both are handled in the open. Bugs and feature requests go in Issues; questions, ideas and anything you have built fit better in Discussions. A report is most useful with your browser, the steps you took, and an exported map that reproduces the problem.
Import a kit and press Play
The fastest way to judge an engine is to play something built in it. Bring in a starter kit, take it for a run, then open the Hierarchy and see exactly how it was put together.
A free account opens the editor. The platform is in open beta at play.galatrix.com.