The Roblox Template is the repository every Blockout Games experience starts as a copy of. It is not a blank project: it runs. Players load in behind the Powered by Blockout Games screen, earn and save currency, buy products and see the server's answer; staff open an admin panel from Roblox's top bar; the server checks every remote call and watches every character for cheating. A new game copies the loop, replaces the demo, and ships.
It is also the Blockout SDK: its platform service connects a game to the studio platform (market data, player feedback, the game's own analytics, the staff Platform tab) once platform is switched on, with no separate package to install.
It is written in strict Luau, synced into Roblox Studio with Rojo, tested with Lune, and shared by people and coding agents under one contract (AGENTS.md). The repository is Template in the studio's GitHub; this section documents its main branch, where the platform service lives.
What a copy of the Template gives a new game
On the first day, before any game code is written, a copy already has:
- A running loop
Loading screen, HUD, currency, saving with migrations, state sync to every client, toasts, purchases acknowledged to Roblox only after their receipts are confirmed saved, and leaderboards. The demo's "Tap for a coin" button exercises all of it end to end.
- A staff admin suite
A draggable panel in the top bar (live server graphs, player inspector, every command as a form, anti-cheat, watchlist, ban list, audit log) and a console on the ; key, with 134 typed commands. Staff roles come from the Blockout Games group, never from the game.
- A server-side anti-cheat
Speed, teleport, flight, noclip, fling, god mode, remote abuse, honeypots, economy spikes, auto-clickers and a verified client sensor, scored and answered.
- Every device
One interface scaled for phone, tablet, PC, console and VR, with gamepad selection, touch-sized targets and controller glyphs on buttons, and a HUD laid out so nothing overlaps, which players rearrange per device. Roblox's chat and player list come styled, or the Template's own.
- Optional systems behind switches
Daily rewards, codes, referrals, badges, quests, shop, events, rewarded ads, travel between places, the platform service (the Blockout SDK) and a dozen gameplay kits, each turned on or off in
Config/Features.- Checks without Studio
Lint, format, architecture boundaries, strict types, unit tests with 100% line coverage of the pure modules, and a spec for every service and controller over substitutes for the engine, all in
lune run check, the same command CI runs.- A workflow for agents
AGENTS.mdand the.agents/folder every tool reads: 19 shared skills, two reviewers and the hooks, plus a scaffolder and a cookbook, so a coding agent writes code the way the studio does.
The three rules every Template game keeps
How a Template game is laid out and runs
The source tree is cut into slices: src/core/ is built into every place of the experience, and src/main/ (the start place) and any other src/<place>/ into one place each. Every slice has the same sides, so a path says where code runs:
shared/becomesReplicatedStorage.Shared(core) orReplicatedStorage.Place(a place): the contract both sides read (remotes, config, rules, saved data's shape).server/becomesServerScriptService.Server(core) orServer.Place: services, the authority.client/becomesStarterPlayerScripts.Client(core) orClient.Place: controllers and the Fusion interface.core/bootstrap/becomesReplicatedFirst: the loading screen, which runs before anything else replicates.
Rojo builds a place file from the source (lune run build) or syncs it into Studio live (rojo serve). At run time the server and the client each require shared, never each other: the client sends intents through the remotes, and the server's state reaches the client through CharmSync patches. More on Architecture.
The tools a Template game is built with
| Tool or package | What it does in the Template |
|---|---|
| Rokit | Installs every other tool at the version pinned in rokit.toml |
| Rojo 7.7.1 | Syncs src/ into Studio and builds place files |
| Wally | Installs the ten packages in wally.toml |
| Lune 0.10.5 | Runs the project scripts in .lune/ and the unit tests |
| Fusion 0.3 | The interface |
| Charm, CharmSync | State atoms and their replication from server to client |
| Remo, t | Typed remotes and the checks on every argument a client sends |
| ProfileStore | Session-locked player saves |
| Promise, Trove, Signal | Async sequences, cleanup, and events between modules |
| TopbarPlus 3.5.0 | Icons in Roblox's top bar, only through UI/Topbar.luau |
| Selene, StyLua, luau-lsp | Lint, format and strict type checking |
| Asphalt, rbxcloud | Uploading assets, and publishing places through Open Cloud |
No package or tool is added without asking; one that is agreed gets a row in docs/engineering/Dependencies.md and a line in ARCHITECTURE.md's Decisions in the same change, and a game also records why in its own docs/decisions/.
Where the Template's own documentation lives
The Template carries its documentation with it, and the code wins when a note disagrees. These pages summarise it; the repository has the full text:
- README.md
The quick start, the layout, every command and the three rules.
- ARCHITECTURE.md
Where code goes, the dependency direction, the boundaries, and Decisions: every choice the Template rests on, one line each with its reason.
- AGENTS.md
The contract for every person and agent that writes code there;
.agents/holds its skills, reviewers and hooks.- docs/
An Obsidian vault: product, engineering notes (setup, places, server authority, testing, releases), one note per system in
docs/systems/, audits and the playtest checklist indocs/testing/, upgrade steps indocs/upgrading/. The Template shipsdocs/decisions/, the board anddocs/cards/empty: they hold a game's own decision records (001onwards) and work.- A README in every folder
What the folder holds and its rules.
Pages in this section
Install the tools, run doctor, serve into Studio, start a new game, choose its systems.
Slices and sides, the Loader, the dependency direction and the boundary rules.
How a service is written and added, feature switches, server-only config, Result.
Intents, queries, facts and traps; guards, throttles, and what the client never decides.
DataService, PlayerData and AccountData, migrations, receipts confirmed before Roblox's acknowledgement.
Fusion screens over Charm state, Theme tokens, and phone, gamepad, console and VR.
Widgets placed so nothing overlaps, zones and modes, and the players' layout editor.
Config/Game, the feature switches and their dependencies.
Lune tests, coverage, lint-boundaries, check, build, publish and release-please.
AGENTS.md, the 19 skills, cards, the board, decision records and the commit format.
The Template's platform service
The Blockout SDK: market reads through a shared cache, feedback, own-game reads and the Platform tab.
Staff roles, the panel and console, commands, audits and server migration.
Server detections, suspicion scores, responses and the shared watchlist.
Currencies, purchases, codes and large-number leaderboards.
Roblox events, economy batching and in-game toasts.
The Template as the SDK: what the game-key connection gives a game today, and what is coming.
Find every other system's owner, feature switch and Template vault note.
The HTTP boundary, shared read cache and MemoryStore lease.
Updated