Create in a tab
A full 3D editor — hierarchy, inspector, gizmos, script editor, timeline, terrain tools — running on a web page. Open a link and you are building.
Editor in open beta · platform in development
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 — scripting, physics, navigation, animation, terrain — and the worlds you make run the same way for everyone who joins them.
The editor is in active beta — a free account opens it. The game platform it publishes to is still in development.
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
16 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
Once published, worlds run in server-authoritative rooms — fixed tick, delta-compressed state, client prediction, with physics and scripts executing on the server rather than on trust. Hosting arrives with the platform.
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 and vertex 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 — or wire the same logic visually with Event Sheets. 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, no server involved. It executes the same shared simulation code a published build does, so what you see in the editor is what players get.
- 04
Publish or export
Push a version to the platform with a changelog, keep it unlisted while you test, or export a self-contained standalone build you host yourself.
The editor · open beta
A real engine editor, on a web page
Not a level viewer or a block placer — an entity-component editor with a script runtime, a physics engine and a navigation system behind it. Pick an area to see what is actually in there.
The editing surface you already know
A hierarchy on the left, an inspector on the right, and a viewport you can actually work in. Undo and redo run across the editing surface, and panels float where you want them.
- Move, rotate and scale gizmos with local/world and pivot/centre toggles
- Grid snapping, vertex snapping 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 deliberately mirrors shapes engine developers already know — Vector3, Mathf, Time, Input — so the patterns transfer even though you are writing TypeScript.
- 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 — the same shared code path in all three.
- 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 actually 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 — then split a project across 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 pieces you need to make a world look deliberate rather than default.
- 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, not a 3D engine with sprites bolted on
Sprites, tilemaps and a pixel-perfect orthographic camera, plus two complementary ways to build interfaces.
- 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 — without a separate build pipeline for each.
- Publish a version straight from the editor, with a changelog
- 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
Sixteen kits, 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, eight gems to find, 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 six 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 truck
The platform · in development
Where the worlds will 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 still being built, so there is nothing to sign up for yet — here is what it is being built to do.
Discover & play
A browser of published worlds with search, categories and tags, featured picks, ratings and reviews, and live player counts — 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 requests, direct messages, parties, teams and emotes, plus chat with moderation, profiles and notifications.
FriendsChat
Economy
An in-game currency, an avatar shop, per-game passes and developer products, trading and gifting, and item rarity tiers.
CurrencyGame passes
Creator tools
Publish and version with changelogs, keep builds private or unlisted while testing, allow forking, and track visits, playtime and ratings in an analytics dashboard.
VersioningAnalytics
Player data
Per-experience saves, leaderboards, badges and achievements, and experience points — persisted for every player without you running a database.
SavesLeaderboards
Safety
Reporting and blocking, a moderation review queue, content filtering and account enforcement built into the platform rather than bolted on per game.
ModerationReporting
Where things stand
Built in the open, shipped in stages
Galatrix is an ongoing build. The editor is usable today; the platform around it 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 In progress
Accounts, publishing, discovery, avatars, social and economy systems are in active development ahead of a public launch.
Public launch Planned
Open sign-ups and a hosted game browser where published worlds can be found and played. Follow along on LinkedIn for the announcement.
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 — you need a free account to open it. The game platform it publishes to is still in development, so treat the editor as a preview rather than somewhere to ship a finished game today.
Do I need game engine experience?
No. If you have used a mainstream 3D engine before, the model will look familiar straight away — entities with components, a Start and Update lifecycle, and APIs like Vector3, Mathf, Time and Input — so your habits carry over, though you write TypeScript here rather than C#. If you have not, the bundled starter kits are working games you can open, play and take apart. And if you would rather not write code at all, Event Sheets cover the same ground visually.
What does it actually 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 can be exported as a standalone build — a single HTML file or a ZIP — that you host wherever you like. Unused engine subsystems are stripped from the export so the download stays small.
Does multiplayer really run on the server?
In published multiplayer, 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. To be clear about what you can use today: the editor’s own play-test runs entirely in your browser tab, with no server involved. Hosted multiplayer arrives with the platform.
What about mobile and controllers?
Multi-touch input is wired through the same input API as mouse and keyboard, and gamepads are readable from scripts. Full mobile UI and controller mapping are on the roadmap rather than 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. The editor is in beta and genuinely does have rough edges — a report is most useful when it comes with your browser, the steps you took, and an exported map that reproduces it.
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. Platform launch news goes out on LinkedIn.