Brickadia
Clips from Devlog #7 and screenshots from the Steam store page.
Brickadia is a multiplayer building game made in Unreal Engine 5 and self-published on Steam for Windows and Linux. Players control an avatar in first or third person. It began in 2017 as an independent student project, entered Early Access in July 2025, and has more than 1,000 positive reviews and tens of thousands of copies sold.
I'm a founding developer, partner and director, a principal programmer and one of the game designers, and I help lead the team and manage the project. I take features from design through engine-level C++ and Blueprints, which the game uses heavily, in our custom Unreal Engine build to shipping, then watch players use them and iterate. I've submitted more than 3,500 changelists to the project since 2018. Alongside the systems work, I designed and built much of the game's UI, from the brick catalog and colour picker to the tutorial hints and server settings screens.
In Exhaustive Detail (no NDA since I'm a founder)
Leadership and project management
As a founding partner and a principal programmer, I help lead a small team and plan and ship its releases.
- Releases: I helped scope and plan the Next Fest, Early Access 2 and Early Access 3 releases.
- Scope: I often make scope calls, such as holding thrusters back from the Next Fest demo until they were ready.
- Other disciplines: I build hooks for our sound designer and artists, such as audio events across the building tools and wire connector, and port data for oriented particle effects. I also land player-facing text early so it can be localised.
Game Designer
Rebuilding the building system around how players think
In Devlog #6 I set out what was wrong with the Alpha 5 building tools and how the redesign would fix it:
- Placing a brick now resizes it as you drag, on every axis, instead of stamping rows and fixing sizes with a separate tool.
- You point where a brick should face instead of cycling through orientations.
- Sizes are labelled on each edge in the world, like Valve's Hammer editor, not as a number on the HUD.
- One merged inventory replaces separate brick and item inventories.
- On-screen hints follow what you're doing and your own key or gamepad bindings.
Designing from playtests
As Devlog #7 describes, I went back to a single quickbar after playtests showed new players struggled with several, and added a starter car-building kit after watching convention visitors stall at an empty inventory.
Wires: making creations work, not just look right
I pitched wires in Interactive Brickadia: Next Steps (2021) so players could make things work without scripting. A switch can open a door, and logic gates handle cases like two switches fighting over one door. In the shipped design, covered in Devlog #7, wires are colour-coded by data type and convert between types automatically. Players have built Conway's Game of Life, Connect 4 and Othello with them.
Cars that drive the way they're built
For player-built vehicles, my aim in Devlog #7 was for the game to work out as much of the driving as possible from what the player builds, drawing on Robocraft and Spore. A seat sends controls to a wheel engine, which steers and powers whatever wheels are attached. Each part is optional and tunable. The same approach now extends to aircraft, which fly in a forgiving Arcade mode by default, with simulated handling available.
Game modes and rules
Game modes are made from small rules, such as rounds, lives, time limits, infection and restricted items, that admins combine and edit in game, with per-team overrides. I designed and built modes on top of them, from Bricktionary (a Pictionary-style building game with word lists and forfeit rules) to deathmatch with lives, allied teams and auto-balance. I also added Builder Mode, which lets an admin step outside the rules to fix a map mid-game.
Onboarding new players
We built the tutorial world on the game's own logic system. I made the Placer's features possible to switch on one room at a time, and rewrote the hint system with text ready for localisation. Advanced logic gates sit behind an "Advanced" catalogue view, with beginner-friendly tooltips. I also folded the hammer into the Placer and turned precision mode off by default after watching new players get lost.
Fair play without friction
Anti-griefing limits are tuned so normal players never notice them while spammers are slowed down. Examples are cooldowns that scale with prefab size, quotas and timeouts enforced inside transactions, and fire-rate caps for non-admins.
Principal Programmer
Replication
Brickadia streams bricks over a custom Unreal net channel (UChannel) rather than actor replication. Clients subscribe to world chunks prioritised by distance, and brick data is delta-compressed and bit-packed. On top of that channel I built replication for brick components, wires and entities, and moved brick owner tables into the same chunk subscriptions. Elsewhere, the game uses Unreal's Iris replication with custom NetSerializers, some of which I wrote, plus push-model dirty tracking. Edits go through a transaction system built by another developer, in which each action records its own inverse for per-player undo and redo. I wrote many of those actions.
Wire logic engine
My original implementation of wires was the successor to my Master's thesis project at Lancaster University, where I built a functional visual programming language. Wires run on the server as a change-driven directed acyclic graph. It keeps an incremental topological sort, splits into islands that merge and split as wires change, and only re-evaluates dirty nodes. Ports are statically typed with automatic conversion, cycles are rejected when a wire is connected, and microchips nest whole circuits inside one brick. In 2025 I rewrote it as Wires V2, adding event-driven execution flow, variables, branches, game-mode events (round start, player spawn, death and so on) and strongly typed custom events, with automatic migration of existing builds. The current version, Wires V4, improves on this design by moving gate logic back out of the graph into brick components while keeping the graph for execution order.
GPU wire renderer
Wires are drawn by Render Dependency Graph (RDG) passes injected with an FSceneViewExtension. The vertex shader builds each wire from its vertex and instance IDs as a Bézier ribbon, with no vertex buffer, and draws them instanced. Wire data lives in a GPU-keyed map over a structured buffer. Only changed entries are sent, as scatter uploads, and the buffer grows by committing reserved (tiled) memory. Updates are batched on the GPU with a compute shader, and drawing wires in screen space at four vertices per segment halved vertex throughput. It has been stress-tested with 8 million wires, and per-grid GPU transforms keep them attached to moving vehicles.
Procedural brick meshes
Resizable bricks are assembled from artist-made parts (corners, edges, faces and centre, 27-slice style) at any size. Each axis can stretch or repeat, UVs and normals are corrected after scaling, and the result is built with FMeshDescription. An editor import pipeline brings the parts in from Blender.
Vehicles and flight
For background: Brickadia runs on PhysX 5 in our Unreal Engine build, with physics integration by another developer. Each brick grid is a single custom collision shape (PxCustomGeometry) with SIMD separating-axis contact tests and a loose-octree broad phase.
I built all the joints players use to make working machines on top of it: bearings, motors, sliders, wheel joints with suspension, and servos that switch from velocity to position control near their target, which makes lifts and sliding doors behave. Joints replicate to clients even before the bricks they attach to arrive.
I built the Wheel Engine that drives player-built vehicles. It discovers what it should drive from the build (wheels, thrusters, gyroscopes and aerodynamic surfaces). It steers with Ackermann geometry and an automatic turning circle, or tank steering, and it flies aircraft with Arcade and simulated handling modes, a stall model and environmental wind. Problems with a vehicle are diagnosed on the server and shown as text above it in the world.
Building tools and gizmos
I built nearly all of the game's building tools:
- Placer: assembled from swappable control, alignment and placement modes, including mirror and hollow placement. Mirror flips whole builds using mirror meshes cooked for every brick.
- Selector: copy and paste as prefabs, and splitting bricks off into their own physics object.
- Resizer: its selection box is a gizmo for moving, rotating and resizing several bricks at once.
- Painter and Hammer.
- Connector: wiring wire ports together, with fuzzy search and in-world port selection on most wireable bricks.
- Manipulator: grabbing and attaching objects.
Gizmos use Unreal's Interactive Tools Framework, which is normally editor-only, running inside the game. Tools aim and preview on the client and send server-validated RPCs, which become undoable transactions. Ghost previews are replicated to other players.
Game UI
I designed and built many of the game's interfaces, including:
- the colour and material picker
- the brick catalog, a reusable family of widgets with search that other menus embed
- the player list, with role editing and user actions that depend on your permissions
- HUD control hints that follow what you're doing and update when you rebind keys
- the current radial tool menu
- the wire port selector, with fuzzy search
- the Edit Game screens for server settings, role permissions, bans and role members, which work for players who are offline
- the gamemode editor, for rules, teams and limits
Click a screenshot to see it full size.
Weapons and movement netcode
I wrote much of the current weapon prediction, building on a weapon system another developer created. Weapons simulate deterministically from a seeded random stream. The client predicts, and the server reconciles and resimulates. On top of it I added data-driven ammo and weapon resources with predicted counts, networked homing projectiles and server-side hit validation. In character movement, I made teleports keep players' orientation and velocity across the network without a frame of rotation flicker.
Server security, permissions and moderation
I built the roles and permissions system: hierarchical permissions on Gameplay Tags, role overrides that can grant or deny, and bans checked at authentication. I also built the in-game tools to manage roles and bans for players who aren't online. I hardened the server against abuse, fixing privilege-escalation bugs, validating and rate-limiting RPCs, capping expensive requests, and closing crash exploits.
Game modes
Game-mode rules are replicated objects that hook the game mode's events, stored per game mode and per team, and edited live in game. Old minigame saves migrate to the new format.
Items and inventory
I built Brickadia's current inventory system. The inventory is server-authoritative, item actors are pooled, and items are registered with Unreal's Asset Manager.
Remote browsing and prefabs
I built copy and paste as prefabs, with thumbnails generated in parallel, plus a converter that brings old saves into the new world format. Admins can browse, revise and transfer server worlds remotely over a chunked bulk-data channel.
R&D: the Behaviors scripting language
From 2019 to 2023 I designed and built Behaviors, a scripting language for bricks, through several rewrites. It had a lexer and parser, a static type system with native struct support, and an IR with compile-time evaluation. An emit-link compiler with a code generator and assembler targeted a register-style bytecode VM, and runtime errors gave stack traces from the bytecode's debug info. Scripts ran as brick components with wire inputs and outputs, and hot reload migrated live instances. Native bindings were first generated by a modified Unreal Header Tool, then by a template-based binding generator. It reached testers but was not released.
In development: voxel terrain
A networked, editable voxel terrain designed to extend to the horizon, with a planet-curved horizon. Terrain chunks replicate through subscriptions, like bricks. Edits are signed-distance-field (SDF) strokes written on worker threads into sparse, quantised chunks, then remeshed incrementally with surface nets, with collision built in parallel. Chunks use distance-based LOD with stitched seams and support Lumen and ray tracing. It has biomes, roads kept to drivable slopes, and a sculpting drill with crease, sharp and pinch modes. It's covered by Unreal automation tests.
The terrain tools in action, a crater blasted with dynamite, and generated caves.
Composer
I also wrote music for the game, including the tracks Thunderpunch, Custard, El Duo, Fountaintail, Morning Dream and Solution Not Forthcoming.