The Roblox Template

What the Blockout Roblox Template is, what a copy of it gives a new game on day one, and how its code is laid out across places and sides.

Roblox Template

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.md and 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/ becomes ReplicatedStorage.Shared (core) or ReplicatedStorage.Place (a place): the contract both sides read (remotes, config, rules, saved data's shape).

  • server/ becomes ServerScriptService.Server (core) or Server.Place: services, the authority.

  • client/ becomes StarterPlayerScripts.Client (core) or Client.Place: controllers and the Fusion interface.

  • core/bootstrap/ becomes ReplicatedFirst: 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.

How a Template game is built and runs. Rojo builds the source slices, src/core and the place's own slice, into a place. In the place, the shared side becomes ReplicatedStorage, the server side ServerScriptService and the client side StarterPlayerScripts. The server and the client both require the shared side and never each other. The client sends intents to the server through the remotes, and the server's state reaches the client as CharmSync patches.

The tools a Template game is built with

Tool or packageWhat it does in the Template
RokitInstalls every other tool at the version pinned in rokit.toml
Rojo 7.7.1Syncs src/ into Studio and builds place files
WallyInstalls the ten packages in wally.toml
Lune 0.10.5Runs the project scripts in .lune/ and the unit tests
Fusion 0.3The interface
Charm, CharmSyncState atoms and their replication from server to client
Remo, tTyped remotes and the checks on every argument a client sends
ProfileStoreSession-locked player saves
Promise, Trove, SignalAsync sequences, cleanup, and events between modules
TopbarPlus 3.5.0Icons in Roblox's top bar, only through UI/Topbar.luau
Selene, StyLua, luau-lspLint, format and strict type checking
Asphalt, rbxcloudUploading 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 in docs/testing/, upgrade steps in docs/upgrading/. The Template ships docs/decisions/, the board and docs/cards/ empty: they hold a game's own decision records (001 onwards) and work.

A README in every folder

What the folder holds and its rules.

Pages in this section

  • Getting started

    Install the tools, run doctor, serve into Studio, start a new game, choose its systems.

  • Architecture

    Slices and sides, the Loader, the dependency direction and the boundary rules.

  • Services

    How a service is written and added, feature switches, server-only config, Result.

  • Remotes and server authority

    Intents, queries, facts and traps; guards, throttles, and what the client never decides.

  • Data and saving

    DataService, PlayerData and AccountData, migrations, receipts confirmed before Roblox's acknowledgement.

  • The interface

    Fusion screens over Charm state, Theme tokens, and phone, gamepad, console and VR.

  • The HUD layout

    Widgets placed so nothing overlaps, zones and modes, and the players' layout editor.

  • Config and features

    Config/Game, the feature switches and their dependencies.

  • Testing and tooling

    Lune tests, coverage, lint-boundaries, check, build, publish and release-please.

  • Working with agents

    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.

  • The admin suite

    Staff roles, the panel and console, commands, audits and server migration.

  • Anti-cheat

    Server detections, suspicion scores, responses and the shared watchlist.

  • Economy and monetization

    Currencies, purchases, codes and large-number leaderboards.

  • Analytics and notifications

    Roblox events, economy batching and in-game toasts.

  • The platform bridge

    The Template as the SDK: what the game-key connection gives a game today, and what is coming.

  • Systems catalogue

    Find every other system's owner, feature switch and Template vault note.

  • Inside PlatformService

    The HTTP boundary, shared read cache and MemoryStore lease.

Updated