Template systems catalogue

A map of the Template's runtime and developer systems, their owning modules, feature switches, saved data and source notes in the Template vault.

Roblox Template

The Template already contains saving, networking, interface, support tools and optional gameplay kits. This catalogue maps each system to its owner, switch and source note. The detailed notes named below are paths in the Template repository's docs/systems/ folder; they are not pages in the platform vault.

Paths beginning Services/, Controllers/, UI/, Config/, Rules/, Util/ and Roblox/ are relative to src/core/server/, src/core/client/ or src/core/shared/ as appropriate, and bootstrap/ to src/core/. server/Roblox/ names the server's engine wrappers (Http, MemoryStore, MessagingBus), which have no lifecycle and are not services. Server-only config is explicitly named. The current switches and their defaults are in src/core/shared/Config/Features.luau; off skips the system's lifecycle and associated interface. Required core systems have no switch.

Saving, replication and the player session

These are the shared foundations most gameplay services use. See Data and saving and Server authority for their contracts.

Data

Core, always on. Services/DataService (a folder module: init.luau and its private parts) owns ProfileStore profiles, sandboxed copies, shared values and ordered stores; shared PlayerData, AccountData and Util/Migrations define their data. While Roblox's DataStores are down, a load waits (ProfileStore retries until the player leaves) instead of kicking. Source note: docs/systems/Data.md.

Save slots

Core, configured through Config/Saves rather than a feature switch. DataService and SaveService own slot profiles and transitions; UI/Screens/SavePicker presents the choice. Each slot is a complete save, while Rules/Saves summarizes available slots; the slot being played is listed from memory, the others are read. Source note: docs/systems/Save Slots.md.

Save support

Core, with admin. Four developer commands (saveversions, savepreview, saverestore, saveedit) list a save's stored versions, compare one with the save now, roll the save back and set one allowlisted field in an offline player's save. Every write is a new stored version, so a rollback can be rolled back, and the purchase ledger is kept. They read and write the real store only. DataService/Versions and Rules/SaveSupport hold the logic. Source note: docs/systems/Save Support.md.

Account data

Core, always on. DataService loads the separate PlayerAccounts profile, exposed privately as ClientState.accountData. It stores once-per-account facts such as code use, daily rewards and referrals independently of the selected slot. A reward taken once per account (a code, a daily reward, a referral payout or welcome, a subscription period, the Premium bonus, the group reward, a staff support grant) is a claim through Services/ClaimService and Rules/Claims: one account write records the marker and the claim in AccountData.claims, the payment waits for a confirmed account save (DataService.saveAccountAndConfirm), then one RewardService.grant pays every reward whole with a claim-<id> receipt in the slot. A reward that does not fit (RewardService.fits: at_cap, inventory_full and the rest) is refused with nothing written. A real claim forces two saves; a test-mode claim none. Source note: docs/systems/Account Data.md.

Networking

Core, always on. Shared.Remotes declares guarded intents, queries, facts and traps; Roblox/RemoteGuard validates their arguments before each owning service's handler checks meaning. Source note: docs/systems/Networking.md.

MemoryStore

Core, not a service. server/Roblox/MemoryStore is the only caller of MemoryStoreService: it hands out sorted maps, hash maps and queues whose calls check Roblox's limits before any request, retry a throttled request with backoff, count their request units for budgets and answer a Result instead of throwing. PlatformService, ExperienceNotificationService and ReservedServerService go through it. Source note: docs/systems/MemoryStore.md.

Messaging bus

Core, not a service. server/Roblox/MessagingBus is the only caller of MessagingService: every cross-server topic is declared with a payload check and a publish rate, a message that does not fit is refused before it reaches Roblox, a failed publish is retried, and a failed subscription is tried again every 60 seconds until Roblox accepts it. Each server subscribes once per topic and hands each valid message to every local handler; the function subscribe returns removes the handler, and the server unsubscribes once a topic's last handler is gone. Players never send or see these messages. Source note: docs/systems/Messaging.md.

Http

Core, not a service. server/Roblox/Http is the only caller of HttpService for outbound requests and experience secrets: it keeps the server under Roblox's limits (500 requests a minute to any host, plus 2,500 to Open Cloud) with a per-host share from Config/Http, retries what Rules/Http says is worth retrying, counts requests by host for budgets, and reads secrets once without printing them. A request the budget refuses comes back limited. PlatformService and ExperienceNotificationService send through it. Source note: docs/systems/Http.md.

State sync

Core, always on. Services/SyncService replicates SharedState and each player's private saved or optional state through sync.start and sync.patch. SyncController populates client atoms; the sync layer is not another saved store. Source note: docs/systems/State Sync.md.

Session

Core, always on. Services/SessionService tracks visits, timestamps and playtime through DataService, and publishes session facts in SharedState. Saved keys include createdAt, lastSeenAt, sessions and playtimeSeconds. Source note: docs/systems/Session.md.

Characters

Core, always on. Services/CharacterService owns player characters: Config/Characters sets Players.CharacterAutoLoads (off by default, so the service spawns on join and respawns 5 seconds after a death, retrying a failed load), and game code calls respawn, places spawns with setSpawnPicker (a place in the void is ignored) and waits on the ready signal. Unused Humanoid states (FallingDown, Flying, Ragdoll, StrafingNoPhysics) are disabled on the server and, through CharacterController, on the owning client; climbing and swimming are on, so trusses and water work, and a game without them turns them off in Config/Overrides/Characters. descriptionFor, applyDescription and restoreDescription handle avatars. Source note: docs/systems/Characters.md.

AFK

Core, always on. AfkService and AfkController mark a player with no input for Config/Afk.afkSeconds (two minutes) as AFK, from the client's idle hint stamped with server time: other players see an AFK row on the player's overhead, staff see it in the inspector and with afk, and playtime rewards stop counting. A phone's motion sensors do not clear it, so an idle phone stays AFK, and the client listens to input only while the player is reported AFK or warned. A warning toast comes before Roblox's 20-minute idle kick; the game never moves or kicks an AFK player. SharedState.afkUsers is public; nothing is saved. Source note: docs/systems/AFK.md.

Settings

Core, always on. SettingsService validates preferences and binding changes; SettingsWindow, SoundController, MusicController, InputController and GraphicsController apply the synced result. Values live in per-slot settings and bindings, defined by Config/Settings and Config/Input. Settings also opens the HUD layout editor (Customize layout), whose settings.requestLayout shares the settings bucket; SettingsService.saveLayout writes PlayerData.layout. Source note: docs/systems/Settings.md.

Collision groups

Core, always on. CollisionGroupService registers the groups in Config/CollisionGroups once at boot (checked by Rules/CollisionGroups: known groups, one answer per pair, Roblox's limit of 32 with Default) and keeps parts in them: player characters in Players, NPCs in Npcs, parts tagged CollisionEffects (or every part under a tagged model) in Effects. NPCs pass through each other; effects land on the world but never touch players, NPCs or each other; players collide with each other, as in Roblox, until a game sets Players.collides.Players = false in Config/Overrides/CollisionGroups. A game adds its own groups and tags there. Nothing is saved. Source note: docs/systems/Collision Groups.md.

Streaming

Core, always on. Every place streams its world: the baseline (StreamingEnabled, PauseOutsideLoadedArea, a 64-stud minimum and 512-stud target radius, opportunistic stream-out) is in the Workspace entry of each place's project file, and lune run build holds every place to it. Roblox/Streaming moves players and waits for parts safely under streaming. Nothing is saved. Source note: docs/systems/Streaming.md.

Interface and device systems

Screens compose shared components and read state rather than deciding rewards. See The Template UI for Fusion, Charm and device behavior.

UI and device facts

Core, always on. Client Device, DeviceController, UIController, UI/App, Theme, Topbar, Menu, components (charts in UI/Components/Charts, among them Sparkline) and screens own the interface. Device.device() describes input and device facts, and UI/Util/deviceState shares the common ones (touch, gamepad, vr, reducedMotion, scale, room) with every component through one subscription each; UI/Util/fromCharm bridges atoms into Fusion, UI/Util/keyed keeps list rows while their key stays, and UI/Util/rowWindow builds only the rows in view. Window has FitContent (a game's own form window sets it); Dropdown has Inline, SelectedMany (several picks, each with a tick) and Kind = "user" (people, with headshots and names). The top bar holds Settings, Feedback (while platform is on), Friends (while community or referrals is on), the custom player list's Players button on touch, with a controller and in VR, and staff tools; a game's own windows open from the menu. Source note: docs/systems/UI.md; handbook: the interface.

HUD layout

Core, always on; the players' editor is layoutEditor, on by default. Every HUD piece is a widget of Config/Layout that LayoutController places with the pure Rules/Layout.solve, so nothing overlaps on any screen; screens bind to their widget with UI/Util/widget. Roblox's chat window, thumbstick and jump button are kept clear where Roblox reports them. A game names regions or its own zones, "free" or "strict" mode, and adds its own widgets in Config/Overrides/Layout.luau. Players rearrange the unlocked widgets in Settings, Customize layout (Screens/LayoutEditor), saved per device class in PlayerData.layout through settings.requestLayout and SettingsService.saveLayout. Source note: docs/systems/Layout.md; handbook: the HUD layout.

Chat

Core, always on; Config/Chat.mode picks the window. "roblox" (the default) styles Roblox's own window, input bar, tabs and bubbles from the Theme (Theme.chat, messages and bubbles at 18 px); "custom" turns Roblox's off and draws the Template's (Screens/Chat, Components/ChatWindow) or a game's (ChatController.setWindow), on TextChatService; "none" shows no window. Names carry the role, Premium, subscription and title tags, and a role colours the name and bubble. Bubbles stand on the overhead's top row (Config/Overhead.anchor). The chat window is the layout's chat widget: Roblox's moves among the eight places Roblox can draw it (Rules/Chat), the Template's anywhere. Config/Chat.robloxWindow (how Roblox sizes its window) is read only by the layout, to keep the chat's area right on a resized screen. In custom mode D-pad Up puts the cursor in the bar while nothing is selected, and the bar's placeholder says so (chat.placeholderGamepad); with a selection the D-pad moves it, and A on the selected bar focuses it. A game restyles with ChatController.style and setMessageFormatter, which must keep the text Roblox delivered. The bar stays off while muted or when CanUserChatAsync says no. The controller is ready for Roblox's platform-integrated chat (required from May 2027), which hides message text from scripts: it notices (or Config/Chat.platformIntegrated says so), drops the tags, and in custom mode shows Roblox's TextChannelWindow in the Template's frame. Nothing is saved; no remote. Source note: docs/systems/Chat.md.

Player list

Core, always on; Config/PlayerList.mode picks the list. PlayerListService writes each player's leaderstats from Config/PlayerList.stats (a currency, a saved stat, or a value the game sets with PlayerListService.set) as text, so huge numbers fit, at most once per updateSeconds (1) and maxRowsPerSecond (100) rows a second across the server; test-mode players keep their real save's values. "roblox" (the default) uses Roblox's list, which cannot be styled; the columns keep config order through a Priority child. "custom" hides Roblox's and shows the Template's (Screens/PlayerList, Components/PlayerRow): a compact panel in a corner, one line per player with headshot, name, role and a column per stat, sorted and grouped by team, opened with Tab, ButtonR3 or a Players button in the top bar on touch, with a controller and in VR (assets.images.icons.players; a console has no Tab key, and nothing on screen names R3); a row pops out a player card (Components/PlayerCard) with Roblox's Add friend, View avatar and Block prompts, and a Trade button while trading is on with Config/Trading.entry.playerCard. A player who is already a friend has a small friends icon after the name on their row and a still Friends mark on the card where Add friend would be (FriendshipController: IsFriendsWithAsync once per player, from the list's first opening, kept current by Roblox's friended and unfriended events). PlayerListController.addColumn, removeColumn, setSort, setRow and refresh shape it from game code. "none" writes no stats. Nothing is saved; no remote. Source note: docs/systems/Player List.md.

Loading screen

Core, always on. bootstrap/Loading.client and bootstrap/LoadingScreen appear before packages replicate, always with the "Powered by Blockout Games" attribution (LICENSE.md, section 2). LoadingController preloads the critical tier of asset ids (Config/Loading.preload, Rules/Preload; the hud tier follows behind the screen, the background tier after spawn in small batches, a window's own assets on its first opening; an image goes to PreloadAsync as an ImageLabel showing it, because a bare id string fails for an uploaded image), preloads world instances tagged Preload once the place loads, and waits for the player's data, side by side under one timeout, using Config/Loading and Config/Brand. Source note: docs/systems/Loading Screen.md.

Overhead

Core, always on. OverheadController draws an overhead over each character's head (and over any model tagged Overhead, such as an NPC), with rows stacked from the head up: the name (10), the worn title (20, from TitleController) and the AFK tag (30, from AfkController). A game adds a row with OverheadController.addRow and calls refresh when its value changes. At most maxShown (20) are drawn, the nearest within maxDistance (60 studs), and only those hold a billboard, taken from a pool and handed on as others come nearer, so 100 characters cost 20 billboards; a repaint writes only what changed. Rows are rowStuds (0.5) tall, offset (2) studs over the head. The local player sees their own name and title (showOwn, ownRows). Every row is styled by Theme.overhead: Fredoka One, a thick outline in colors.overlay that scales with the text, and a light top-to-bottom shade. Each head holds an Attachment (Config/Overhead.anchor) at the top of the rows that show, which chat bubbles stand on. Settings are in Config/Overhead (a game's in Config/Overrides/Overhead.luau), rules in Rules/Overhead. Nothing is saved. Source note: docs/systems/Overhead.md.

Haptics

haptics, on by default. HapticController.play(name) plays a named pattern from Config/Haptics (Rules/Haptics lightens it under reduced motion) through Roblox's HapticEffect on phones, gamepads and Quest controllers that have a motor; success and error toasts and celebration effects use it, and game code may. Players turn it off with the Vibration setting (settings.haptics). No loop or remote. Source note: docs/systems/Haptics.md.

Capture

capture, on by default. CaptureController.offer takes a screenshot of a moment game code picks and opens Roblox's share prompt, or the save prompt where the regional policy's contentSharing gate is not allowed or not read yet, under a cooldown and a per-session cap from Config/Capture. Nothing is captured unless game code asks; nothing is saved. Source note: docs/systems/Capture.md.

Avatar

avatar, off by default. AvatarController and the AvatarWindow (a menu button) offer Roblox's save-outfit and save-avatar prompts for the look worn in the game; game code calls inspect(userId) and playEmote(name), and Config/Avatar.emotesMenu turns Roblox's emotes menu on or off. No remote, nothing saved. Source note: docs/systems/Avatar.md.

Main menu

mainMenu, off by default. A menu the player sees before playing and can reopen from the HUD's menu: a panel of pages from Config/MainMenu, each with a title, a body and buttons that play, change page, go back or open a window. A part tagged MenuCamera frames the view while it is up; a page that names a switch is left out while that switch is off. Play always hands back a camera that follows: a still camera type taken when the menu came up (Fixed before the character exists, or Scriptable) comes back as Custom, on the saved subject or else the player's own character; a game that wants a still camera after the menu sets it from its own MainMenuController.setBackground hook. The shipped pages are the Template's showcase composition, to replace. Source note: docs/systems/Main Menu.md.

Release notes

releaseNotes, off by default. lune run changelog bundles the public changes of CHANGELOG.md into the build, Roblox/ReleaseNotes.load() reads them, and the main menu's "What's new" page browses them. No service, remote or saved data. Source note: docs/systems/Release Notes.md.

Tutorial

tutorial, off by default. TutorialService walks a new player through the steps of Config/Tutorial on their first join: a panel with Next and Skip, and a highlight or ring on what a step points at. A step completes when the player does what it asks or game code signals it; progress is saved on the account (AccountData.tutorial) and logged as the onboarding funnel. tutorial restart|skip|finish is the test command. Source note: docs/systems/Tutorial.md.

Sounds

Core, always on. Controllers/SoundController plays named assets at the player's saved volume. Callers use shared assets rather than embedding asset ids. Source notes: docs/systems/Settings.md and docs/systems/UI.md.

Music and ambience

Core, silent until configured. Controllers/MusicController plays the highest-priority context asked for by game code (MusicController.request(reason, context)), the main menu or a part tagged MusicZone (attribute MusicContext). A context in Config/Overrides/Music.luau has a priority, a playlist of assets.sounds.music keys that crossfade, and an optional assets.sounds.ambience loop. The Music and Ambience sound groups follow the saved musicVolume and ambienceVolume; duck(reason, on) lowers them for a video or an ad. Ambient zones are checked only while a zone part is in the world. The Template ships no contexts: no instances, no loops, and no Music or Ambience slider. Source note: docs/systems/Music.md.

World sound

Core, always on. WorldSoundController.playAt(name, position or part) on the client, and WorldSoundService.playAt(name, position) on the server for the players in range, play a sound from a small pool of emitters under a voice cap and skip what is too far to hear. Parts tagged AmbientZone play a looped ambience that fades with distance. Names are Asphalt keys in assets/sounds/world/; volumes follow the Sounds and Ambience settings. Ambient sound zones are checked only while a zone part is in the world, and each sound's settings are worked out once and kept (Rules/WorldSound.settings). The Template ships no world sounds. Source note: docs/systems/World Sound.md.

World motion

Core, always on. WorldTweenController.play tweens world instances on the client: a tween replaces another moving the same property, and decorative tweens snap on a low graphics tier, far from the camera or over a cap. WorldTweenService.play sends a server tween intent once as attributes; every client plays it, and at the end the server sets the goal, clears the goal attributes and removes the tag. The timing attributes stay until the next intent overwrites them: clients follow only tagged instances. AnimationController.play plays animation tracks by asset key, cached per Animator under a cap. Source note: docs/systems/World Motion.md.

Graphics quality and lighting

Core, always on, client-only. Controllers/GraphicsController runs every client at a tier, low, medium or high: forced by the graphics command, else the saved graphicsQuality setting (Display, Graphics quality: Automatic, Low, Medium, High), else the player's Roblox graphics level, else the device (desktop high; console, tablet and VR medium; phone low). While automatic it times a few seconds of frames now and then and steps down a tier when the 95th percentile stays over Config/Graphics.autoStep.budgetMs, stepping back up slowly so it never flaps. A tier change switches Lighting.GlobalShadows, post effect classes (keyed by Roblox's class names, such as BloomEffect), the Rate of emitters tagged QualityParticles, the interface effects' particle cap and decoration tagged QualityDecor (hidden below its QualityMinimum attribute; hidden decoration whose area streamed out is let go while the tier stays low); nothing runs per frame otherwise. Config/Graphics.tiers is the one place a game changes what a tier does. The lighting preset in Config/Graphics.preset (the Template's neutral, a new place's defaults) is applied at boot, with per-tier variants; GraphicsController.setPreset blends to another. Game code reads GraphicsController.tier() for its own effects. Rules in Rules/Graphics. Source note: docs/systems/Graphics.md.

Localization

Core, always on. Every player-facing string is a key in Config/Strings read through Util/Localize.text; client/Localization installs Roblox's translator for the player's locale before the interface is built, Util/Format follows the locale's separators, and toasts carry keys with args. lune run strings exports the table for the Creator Hub; Config/Localization holds the pseudo-locale and number styles. Nothing is saved. Source note: docs/systems/Localization.md.

Effects

effects, on by default. EffectsController, UI/Screens/Effects, Config/Effects and Util/Particles provide interface particles and their sounds. Nothing is saved. Source note: docs/systems/Effects.md.

Notifications

Core, always on. NotificationService sends notifications.pushed; NotificationController keeps the toasts on screen, queues the rest and times each from when it shows, and UI/Screens/Notifications draws them at the top centre (the layout's toasts widget). The default time, the on-screen caps and the queue are Config/Notifications (defaultSeconds, maxVisible, maxVisibleTouch, maxQueued). No inbox is saved. Source note: docs/systems/Notifications.md; handbook: analytics and notifications.

Input and contextual touch actions

Base input is core; touchActions, off by default, enables its optional context/touch delivery. InputController, UI/Screens/TouchActions, Config/Input, Rules/Bindings and Rules/InputContexts own binding and context behavior. Saved binding edits go through SettingsService. Source notes: docs/systems/Input.md and Contextual Input.md.

Economy and account rewards

The economy and monetization page covers currency, receipts, passes, codes and rankings in depth.

Currency

Core, always on. CurrencyService alone changes PlayerData.currencies using Config/Currencies, Rules/Currencies and Rules/Pricing; exchange changes several balances and the owner's own record in one save update, and with whole refuses a reward that does not fit under the cap rather than paying part of it. Source note: docs/systems/Currency.md.

Rewards

Core, always on. One shape for what a player is given (currency, item, boost or title, one reward or a list, with the { currency, amount } shorthand) in every config that gives one, and one write path: RewardService.fits and grant, over the pure Rules/Rewards (the type) and Rules/Grants (the fits check and the change). Util/RewardLabel names a reward through the reward.* strings. An owned title is skipped; anything else that does not fit refuses the whole list. Source note: docs/systems/Rewards.md; handbook: one reward shape.

Monetization

Core, always on. MonetizationService (a folder module: Products, Gamepasses, Gifts) owns receipts and pass ownership; MonetizationController owns prompts. Config/Monetization supplies ids and keys (plain strings, so a game's own need no cast), what a product or pass grants (grants = { rewards }, no handler needed) and its place in the shop's Robux Store (store = <order>); MonetizationController.store, price and ownsGamepass feed the Store rows. Rules/Purchases combines history. Real purchases live in the selected save's purchases and gamepasses. Experience subscriptions (subscriptions, off by default) are decided by SubscriptionService with Rules/Subscriptions; the period record is in AccountData.stats. Source note: docs/systems/Monetization.md.

Regional policy

Core, always on. RegionPolicyService reads Roblox's policy for each player on join and gates what depends on it (Rules/Policy): paidRandomItems, paidItemTrading, ads, subscriptions and contentSharing. A restricted player is never offered what a gate covers, and the server refuses it if they ask anyway; the client reads its own view in ClientState.policy, and a field Roblox does not answer counts as restricted. waitFor is woken by ready or the player leaving, without polling. No link or handle is shown inside an experience (allowsLink is always false). It is core because every game that sells anything needs it. Nothing is saved. Source note: docs/systems/Regional Policy.md.

Rewarded ads

rewardedAds, off by default. RewardedAdService, AdController and the Shop window's rows offer each placement in Config/Ads: a fixed reward of any kind (never random) paid as a developer product after Roblox confirms the view, capped per player a day, offered only where Roblox has an ad and the regional policy allows ads (Rules/Ads). The day's views are counted in AccountData.stats. ads and adsim are the test commands. Source note: docs/systems/Rewarded Ads.md.

Premium perks

premium, off by default. PremiumService reads Roblox Premium membership on load and on change and publishes it in SharedState.premiumUsers. Each perk in Config/Premium is optional: currency multipliers game code asks for with multiplier (purchases, refunds and grants are never multiplied), a daily bonus (a once-per-account claim), a chat tag and a shop upsell that opens Roblox's prompt. premium on|off|real is the test command. Source note: docs/systems/Monetization.md.

Gifts

gifts, off by default, requires shop. GiftService lets a player buy a pass or a product's reward for another player in the server from the Shop window; each gift in Config/Gifts has a developer product of its own, and a gifted pass is an entitlement on the recipient's account. Orders and the outbox are in PlayerData.gifts, received gifts in AccountData.gifts; the same order asked again (a prompt closed and reopened for the same player) writes and saves nothing. Source note: docs/systems/Monetization.md.

Leaderboards

leaderboards, on by default. LeaderboardService publishes rankings for the Top window and world boards. Config/Leaderboards, Rules/Leaderboards and Util/BigNum define scores and storage encoding. The stats in the player list are no longer its own: they are the Player list system's (Config/PlayerList, PlayerListService), which runs whatever this switch says. Ordered stores are separate from PlayerData. Source note: docs/systems/Leaderboards.md.

Daily rewards

dailyRewards, on by default. DailyRewardService, DailyRewardController and DailyRewardWindow use Config/DailyRewards and Rules/DailyRewards for claim eligibility and streaks. The record is once per account in AccountData.daily, and each reward is a claim through ClaimService. With openOnJoin the window opens once per visit when today's reward waits; DailyRewardController.hold(reason, on) makes it wait (a showcase scenario holds it, and a game can for a cutscene or tutorial), and it opens when the last hold lets go. Source note: docs/systems/Daily Rewards.md.

Playtime rewards

playtimeRewards, off by default. PlaytimeService counts time played in this session on the server and pays each reward of Config/Playtime.rewards once claimed (playtime.requestClaim); every join starts the count again and nothing is saved but the pay. Rewards may be of any kind. playtime ready|reset is the test command. Source note: docs/systems/Playtime Rewards.md.

Season pass

seasonPass, off by default. SeasonPassService gives season points from claimed quests, playtime and the game's own moments (award), and each tier of a season in Config/SeasonPass gives a free reward and, with the premium track bought (seasonPremium), a paid one, claimed through seasonPass.requestClaim; the window shows a tier's two rewards on their own line. The playtime tick runs only during a season. Progress is in PlayerData.seasonPass; a new season is config only. seasonpass points|premium|reset is the test command. Source note: docs/systems/Season Pass.md.

Codes

codes, on by default. CodeService reads server-only Config/Codes and checks Rules/Codes and UTC dates from Util/Time; CodesWindow submits text. A redemption and its rewards are one claim through ClaimService: the code is recorded in AccountData.codes and the rewards are paid into the active slot after the account save, once per account. A code whose rewards do not fit (RewardService.fits) is refused and stays unused. The Template's WELCOME and BLOCKOUT are demo examples that stay live under demo = false; a game removes them in src/core/server/Config/Overrides/Codes.luau. Source note: docs/systems/Codes.md.

Referrals and invites

referrals, on by default. ReferralService, InviteController and the invite card of FriendsWindow (under the friends list: what an invite is worth, friends brought, and Roblox's invite prompt) use join data, account messages, Config/Referrals and Rules/Referrals, with who qualifies (the cap, account age, time played, friendship) in the server-only src/core/server/Config/Referrals. The qualifying wait is one timer per new player, cancelled when they leave. Records are in AccountData.referral; payouts and the welcome are claims through ClaimService. Source note: docs/systems/Referrals.md.

Community: favourite, group and friends

community, on by default. CommunityService, CommunityController and FriendsWindow use Config/Community and Rules/Community. The server times Roblox's favourite and group-join prompts, both off until configured, with a cooldown per account. It pays groupReward (any reward kind or a list; 0 coins by default, which pays nothing) once per account (a claim) after PermissionService reads the membership from Roblox, and never rewards a favourite. The Friends window opens from a person icon in Roblox's top bar (shown while community or referrals is on; the window is shared with Referrals' invite card) and lists friends in this experience, with Join for one in another public server, sent through TravelService. Friends in this very server come from FriendshipController (the cache the player list shares, read from the server's own players), so they show whatever Roblox's online list says of them and appear and go as they join and leave. A friend in another server of this very place is listed and joinable even while Config/Game.places does not list its id (before lune run init, or a developer's own test place): this server's game.PlaceId stands in for it. The server cannot read a friend's "who can join me" privacy, so a game that needs it sets friends.join = false in Config/Overrides/Community. No new field: the community.* keys of AccountData.stats and flags. Source note: docs/systems/Community.md.

Badges

badges, on by default. BadgeService, Config/Badges and Rules/Badges award badges through Roblox; Roblox owns their persisted ownership. A save watcher checks what is due; it stops once every badge with an id is owned, and is never started without badge ids or in Studio. No badge save field is needed. Source note: docs/systems/Badges.md.

Quests

quests, on by default. QuestService, QuestController and QuestsWindow use Config/Quests and Rules/Quests to track progress and validate claims. A claim is one RewardService.grant that records the quest claimed and pays the whole reward, of any kind; a reward that does not fit is refused and stays claimable. The save is watched only when a quest has a stat goal, and the playtime tick runs only while a loaded player has a playtime quest left to finish (a join, a slot or test-mode switch, the quest command or the daily reset starts it again). Per-slot state is in PlayerData.quests. Source note: docs/systems/Quests.md.

Shop

shop, on by default. ShopService, ShopController and ShopWindow use Config/Shop, Rules/Shop and Rules/Pricing for server-priced upgrades. The charge and the new level are one CurrencyService.exchange. ShopController.rows is a computed getter, priced only when read. Below the upgrades, the Store section sells the products and passes with a store order for Robux. Bought levels are in PlayerData.upgrades. Source note: docs/systems/Shop.md.

Optional gameplay kits

These kits provide specific foundations and have their own system notes. A built server foundation does not imply that every possible player tool or device playtest is complete.

Interactions

interactions, off by default. InteractionService, InteractionController and InteractionPrompt implement tagged nearby prompts with server-validated begin, cancel and completion. Config is Config/Interactions, rules are Rules/Interactions; no saved data. A tracked part's attributes are read when they change, not on every scan. The nearest target in range is prompted and kept until it leaves range or another is nearer by Config/Interactions.switchDistance (1 stud), and through a hold for as long as it stays in range, so the prompt never flicks between two targets about as far away; a target on the player's own character never prompts them. The prompt's look is a style, picked per target: the part's InteractionStyle attribute, else its action's style in Config/Interactions.actions, else default. Four ship in UI/Components/InteractionStyles (default, a bottom panel; pill, whose hold fills the pill itself; card, with the action's icon and description; ring, a billboard over the part), built from one set of parts so they read as a family: a key badge (a keycap, a gamepad button or a touch capsule; in VR the controller's button), the title, a "Hold" hint and a round-ended bar filling over a visible track. Pressed and waiting for the server, the badge lights in the accent and the hint reads "Starting…"; refused, they turn the danger colour. The hold bar is driven by the frame: the screen fills state.progress once a frame from when the hold began and how long it lasts (prompt.hold), evenly, with no spring, and a finished hold stays full until the key lifts or the target goes; a style fills it directly. A prompt's width is fixed when it shows, so it never changes size mid-hold; sizes are Theme.interactionPrompt and Theme.interactionStyles. A game adds or replaces a style with InteractionController.registerStyle(name, style) before the first prompt; a style draws and decides nothing. The interactionfixture test levers belong to this kit: each is a post with a handle that tilts to onColor or offColor when a server hold toggles it, and its style's name above it in the overheads' look (Config/Interactions.fixture, with labelFont, labelStroke and labelStrokeColor). spawn makes one per style in Config/Interactions.styles on the ground ahead of the caller, spawn <style> one in that style. It needs only interactions and refuses when the game registers its own activate action. Source note: docs/systems/Interactions.md.

Inventory

inventory, on by default. InventoryService, InventoryController and the demand-mounted InventoryWindow use Config/Inventory and Rules/Inventory for per-save items and equipment in PlayerData.inventory; item labels are Config/Strings keys. Config/Inventory ships five generic sample items: three stacks (material, ticket, giftBox) and two pieces of equipment (tool in the tool slot, trophy in the display slot). An item may name an icon (a key of assets.images.icons, checked by lune run catalog), tradable and paid. While demo is on, DemoService gives each save Config/Demo.starterItems once, under the demo source; without the demo nothing is granted on join. The window is a toolbar (search, and the Name, Quantity and Newest sorts), the equipment slots as tiles, and the owned items as a paged grid of tiles (Components/CollectionGrid, Theme.inventory.pageSize 16 to a page, L1 and R1 on a gamepad), so a full inventory builds no more than a small one; the pager shows only when there is a second page: a second press on an item equips it (a worn piece then reads Equipped under its name, in the success colour, and only stacks carry a ×N badge), and a press on a slot takes its item off. An inventory holding more entries than a lowered capacity still works: it spends, removes, equips, tops up a stack it holds and gives items away in a trade, and only what would add an entry is refused (inventory_full). InventoryService.equipped(player, slot) is checked once per save change, so a call on every hit is a table lookup. Rewards arrive under the rewards source; giveitem and takeitem are the staff commands. Turning it off preserves saved inventory. Source note: docs/systems/Inventory.md.

Trading

trading, on by default, needs inventory. TradeService, TradeController, TradeWindow and TradeRequest let two players in the same server swap inventory items, with Config/Trading and the pure Rules/Trade. One asks; the other accepts or declines within requestSeconds (30) on the TradeRequest dialog. Each then builds an offer from their own inventory in the trade window, any change to either offer clears both Readys, and once both are Ready a confirmSeconds (3) countdown runs before both Confirm. The server checks every call against the saves it holds: the item is owned, tradable = true in Config/Inventory and not worn, the two are within range (30 studs), neither is in test mode, and the whole swap fits both inventories. An item marked paid is refused unless both players' regions allow paidItemTrading. At the second Confirm the trade is removed first, so nothing can move twice; the swap is checked again; both saves change with no yield between them through InventoryService.apply under the trade source, the first put back if the second is refused; and both saves are forced. A trade is cancelled with nothing moved when a player leaves, starts to travel, changes save, respawns out of range or presses Cancel. Config/Trading.entry picks how a trade starts: a Trade button on another player's card in the custom player list (playerCard) and a hold-to-trade prompt on other players' characters (prompt, drawn through the interaction prompts, so only while interactions is on too); a game's own interface calls TradeController.request(player). Each player's requests and open trade sync to that player alone (ClientState.trade), and the six trade.* remotes are queries rate-limited per player. Staff list this server's recent trades with trades [user]. Nothing new is saved, and there is no cross-server trading. Source note: docs/systems/Trading.md.

Progression

progression, off by default. ProgressionService, ProgressionController and ProgressionWindow use Config/Progression and Rules/Progression: XP from quest claims and award(player, event) with a prestige bonus, levels, unlocks worked out from the level and prestige count (unlocked(player, id)), and prestige. ProgressionController.view is a computed getter (the prestige preview is worked out only when read) and ready is the menu dot. progression.requestPrestige names the count the player saw, so a repeat refuses; one CurrencyService.exchange starts the track over and resets exactly the currencies and shop upgrades prestige.reset sets true, keeping everything else. XP and prestiges are in PlayerData.progression; progression is the test command. Source note: docs/systems/Progression.md.

Boosts

boosts, off by default. BoostService, BoostController, BoostsWindow and the BoostBar HUD countdown use Config/Boosts and Rules/Boosts. A player holds boosts, bought with each boost's product (boostDoubleCoins) or given by game code with grant, and uses one with boosts.requestActivate, which names the stock the player saw so a repeat refuses. The end is a saved server timestamp, so a boost runs on wall-clock time, survives rejoins and server hops, and needs no server timer. Game code multiplies what it pays by multiplier(player, key). Stock and ends are in PlayerData.boosts; boosts is the test command. Source note: docs/systems/Boosts.md.

Titles

titles, on by default, needs no other switch. TitleService, TitleController and TitlesWindow use Config/Titles and Rules/Titles. A title is fixed text from config with a Theme.colors token and an unlock: a badge's rule met on the save, a quest claimed, a Progression level, a game pass, a role, or granted by game code (TitleService.grant). Badge, quest and level titles are kept in PlayerData.titles once met; pass and role titles count while they last. titles.requestEquip names one title (or none); the server checks ownership. The worn id replicates in SharedState.titles; clients draw a chat tag after any staff and Premium tag and a title row on each character's overhead (OverheadController), hidden for others by the "Other players' titles" setting. TitleController.view is a computed getter. title grant|revoke is the test command. Source note: docs/systems/Titles.md.

Text filter

Core, always on. TextFilterService.broadcast, forUser and chatForUser run Roblox's text filter for the right audience, cache each answer briefly (Rules/TextFilter) and budget calls per player (Config/TextFilter). A failed filter or an empty budget is a refusal, never unfiltered text. The admin suite and the staff Feedback list use it; any text a player types that others see should too. Source note: docs/systems/Text Filter.md.

NPC navigation

npcNavigation, off by default, needs no other switch. NpcService (a folder module with its Navigation part) and NpcController use Config/Npcs and Rules/Npcs. Game code spawns NPCs of a configured kind (spawn, within an agent cap and a cap per kind), sends them to a point or a part (walkTo) and hears how each walk ended: arrived, or one failed reason (unreachable, stuck, timeout, target_removed, busy). Every path request goes through one bounded queue with a limit on computations at once, retries and replans; a walk replans only when its target moved far enough, a waypoint ahead is blocked or a waypoint was missed. Stopping, a new walk, despawning, death and the target going cancel the queued work, connections and timers. Destinations come only from server code: there is no remote, and NPC physics stays with the server. NPCs disable the unused Humanoid states (Flying, StrafingNoPhysics and the rest). Clients bob the nearest visible NPCs within a distance and budget. Nothing is saved. A game's look is a model in ServerStorage.NpcModels; otherwise a plain placeholder rig. npcs fixture|stats|clear builds a crowd (NPCs of the walker kind walking between stations, with obstacles between them) and reports its path and cost counters. Source note: docs/systems/Npcs.md.

Offline production

offlineProduction, off by default, needs no other switch. OfflineProductionService uses Config/OfflineProduction and Rules/OfflineProduction. Game code that knows what a player produces sets a whole per-hour rate with setRate; it is saved in the player's slot (PlayerData.offline), because what produces is the game's own. Leaving stamps the server time on the real save; the next join of that slot pays the absence once, at most maximumSeconds of it, in one CurrencyService.exchange that also clears the stamp, and a toast explains the time away and the pay (Rules/OfflineProduction.message returns an offline.notice.* string key and its arguments). A clock behind the stamp pays nothing; pay the currency cap refuses waits as pending, up to one capped absence. ProfileStore's session lock keeps a slot's claim to one server; nothing runs while a player is away. offline rate|away sets a rate or claims a pretend absence. Source note: docs/systems/Offline Production.md.

Experience notifications

experienceNotifications, off by default, needs no other switch. ExperienceNotificationService and ExperienceNotificationController use Config/ExperienceNotifications and Rules/ExperienceNotifications. Game code sends a kind now or schedules it; game servers send through Open Cloud with the secret NotificationsApiKey, within a per-player limit shared by every server, and the server picks when Roblox's opt-in prompt is offered. Nothing new is saved but AccountData.stats.notificationOfferedAt; the schedule lives in MemoryStore. pushnotify prompt|send tests it. Source note: docs/systems/Experience Notifications.md.

Camera profiles

cameraProfiles, off by default. CameraProfilesController and Config/CameraProfiles provide native camera presets and named overrides without a frame loop. VR retains Roblox's camera. Source note: docs/systems/Camera Profiles.md.

Camera transitions

cameraTransitions, off by default. CameraTransitionController eases the camera between owners (a native profile change, a cinematic, a game's own camera) over Config/CameraTransitions.seconds, scaled by the player's camera-motion setting; Reduced Motion, VR and negligible moves cut. Game code calls capture() just before it takes or gives up the camera. Source note: docs/systems/Camera Transitions.md.

Seasonal events

events, on by default. EventService checks schedules in Config/Events using Rules/Events and publishes SharedState.event; EventBanner displays it. An event marked demo = true runs (and can be previewed) only while demo is on: the Template's example winter festival (winter2026) is one. No saved event field. Source note: docs/systems/Events.md.

Travel

travel, on by default. TravelService is the owner of cross-place teleports; TravelController covers transitions. Config/Game.places, Config/Travel, Rules/Places and Roblox/Place describe places. send with { server = jobId } joins one server of a place (a friend's), and options.reserve reserves a fresh server by a ReservedServerId of its own. A trip to another server of this very place needs no id in Config/Game.places: while its id there is 0, or this server's tier is unknown, game.PlaceId is used. When a teleport does not leave, the server fires travel.failed and the client takes the loading screen that covered the trip back down, so the player sees the failure toast. Trip data travels in teleport data, not a new save field. Source note: docs/systems/Travel.md.

Reserved servers and follow. Roblox joins a reserved server only with the access code its reservation returned (or the ReservedServerId it was made with), never by job id, and only the reserving server sees the code. ReservedServerService keeps a MemoryStore hash map (BlockoutReservedServers): whoever reserves a server calls ReservedServerService.record(privateServerId, accessCode) (TravelService, MigrationService and the admin privateserver command do; pass accessCode nil for a ReservedServerId server), the record lasts ten minutes, and the reserved server keeps job/<JobId> -> how to join it while it runs. The admin follow reads that one entry. A game that reserves its own servers must record each one when it sends players there, or staff are told the server was not recorded. Access codes never reach a client or a log.

Staff, security and integrations

These systems are shared operational tools. The platform bridge is on the Template's main, off until a game turns it on, as described on its own page.

Permissions

Core, always on. PermissionService, Config/Permissions and Rules/Permissions determine studio roles; ChatController and admin gating read the result. SharedState.playerRoles publishes only roles above player (a missing entry reads as player), so an ordinary join or leave writes nothing. Shared staff suspensions are saved through DataService.updateShared. Source note: docs/systems/Permissions.md.

Admin and performance diagnostics

admin, on by default. AdminService, MetricsService, AdminController, DiagnosticsController (the perf probe, perfscenario fixtures and stress ui, whose parts load on the first developer command that needs them, not at startup) and the panel and console in src/core/admin/ provide typed commands, dashboards, captures and support tools. AdminService is a folder module: init.luau, its parts (Registry, Targets, Audit, Remotes, Moderation, BanList, Watchlist, StaffGuard, Delivery) and one file per command group in Commands/. Delivery clones the panel and console from ServerStorage.AdminSuite into the PlayerGui of those who may use them only; an admin tab polls through Tab.poll, only while shown. Config is Admin/Perf, with the staff guard's limits in the server-only Config/Admin; shared saved values hold bans, watchlist and staff-guard counts. Source note: docs/systems/Admin.md; handbook: admin suite.

Client performance

clientPerf, on by default, with admin. ClientPerfService, PerfOverlayController, Screens/PerfOverlay, Config/Perf and Rules/ClientPerf own the staff performance overlay (overlay, F7) and the clients' frame reports kept in server memory (clients, ClientPerfService.summary()). Nothing is saved. Source note: docs/systems/Client Performance.md; handbook: client performance reports.

Anti-cheat

antiCheat, on by default. AntiCheatService, its Checks, AntiCheatController, RemoteGuard, the server-only Config/AntiCheat (thresholds, weights, messages; the shared one holds only the sensor's settings) and Rules/AntiCheat own checked detections and responses. Scores are per server; watchlist records use the admin shared value. Source note: docs/systems/Anti-Cheat.md; handbook: anti-cheat.

Voice

Core, always on. Roblox voice chat stays Roblox's. VoiceService.hasVoice says whether a player in this server has voice, and the admin mute also mutes their voice (through AudioDeviceInput.Muted), again if they rejoin while muted; setMuted watches only muted players for new voice inputs, so there is no per-player connection otherwise. Nothing in the Template needs voice; nothing is saved. Source note: docs/systems/Voice.md.

Server migration

serverMigration, on by default. MigrationService and Config/Migration move players through a holding server during shutdown or staff migration, behind the loading screen. Leaving the old server invokes ordinary saving. Source note: docs/systems/Server Migration.md; handbook: server migrations.

Test sessions

testMode, on by default. TestModeService, DataService's sandbox and purchase emulation run against disposable copies. Config/TestMode, Testing tab and TestPurchase screen expose the tools; SharedState.testModeUsers signals who is testing. Source note: docs/systems/Test Sessions.md.

Analytics

analytics, on by default. AnalyticsService alone sends Roblox events and batches ordinary economy events. Config/Analytics holds the registries: funnels (with first_session, logged by SessionService), economy reason prefixes and their transaction types, and custom event names; an unlisted funnel step or custom event is not sent, and a coverage spec fails a call the registries do not list. No custom analytics remote or saved event field. Source note: docs/systems/Analytics.md; handbook: analytics and notifications.

Live config

liveConfig, on by default. LiveConfigService, Config/LiveConfig and Rules/LiveConfig read allowlisted values and kill switches from Roblox's experience configs (ConfigService), check them against the build and mirror them in SharedState.liveConfig. The Template lists no key, so a new game reads nothing; a game opts in from Config/Overrides/LiveConfig.luau, and codes, dailyRewards and events honour a kill switch once listed. Nothing is saved. Source note: docs/systems/Live Config.md; handbook: live config and kill switches.

Error reports

errorReports, on by default: until something errors it costs one ScriptContext.Error connection and one idle timer per side. ErrorReportService and ErrorReportController catch server and client script errors; Rules/ErrorReports groups them by signature (the message without numbers, ids or players' names, plus the top stack frame) in one bounded table per server with counts and first and last seen; a repeated error's text is cleaned once, on both sides. Clients send batches through errorReports.report, limited per player a minute and cleaned again on the server. Staff read it with errors; every five minutes the server exports its new counts as script_error analytics events, one total per side. Nothing is saved. Source note: docs/systems/Error Reports.md.

Platform

platform, off by default. PlatformService (a folder module: Connection, Reads, Writes, Status), shared Rules/Platform (a folder module: Requests, Responses, Summaries, Cache), server Config/Platform, shared Config/Feedback, FeedbackWindow and its Feedback button in the top bar provide cached market reads, feedback writes, cross-game transfers and studio bans; feedback and transfer calls are also capped for the whole game (30 each a minute, counted in MemoryStore). Requests go through server/Roblox/Http. There is no PlayerData field; MemoryStore holds read cache entries. Source note: docs/systems/Platform.md; handbook: platform bridge.

Market board

marketBoard, off by default, requires platform. MarketBoardService reads the games a developer chose, and the platform's breaking-out list, through PlatformService once a minute for every server; the Market window shows players now, the change over the last hour and a 24-hour chart, marked stale while the platform cannot be reached. Source note: docs/systems/Market Board.md.

Developer tooling and the removable example

These run during development or demonstrate the foundations; they are not extra production services.

Module diagnostics

Developer-only .lune/modules.luau and .lune/lib/modules.luau inspect module metadata. No runtime switch or saved data. Source note: docs/systems/Module Diagnostics.md.

Catalog validation

Developer-only .lune/catalog.luau and .lune/lib/catalog.luau validate configured catalog data. No runtime switch or saved data. Source note: docs/systems/Catalog Validation.md.

Pure utilities

Core shared Util/* provides Result, cleanup-adjacent helpers, cooldowns, rate limiting, formatting, time and large numbers; Roblox/Observers owns Roblox-specific observation (every observeCharacter watch ends through one shared leave listener, so a leave runs only the leaver's cleanups). Util/Pool reuses short-lived instances (prewarm, cap, acquire and release, twice safely) and Roblox/Lifetime replaces Debris: destroyAfter or releaseAfter back to a pool, on one Util/Scheduler heap per side; the instances command shows both. RateLimiter:prune() forgets refilled buckets for a limiter keyed by something that outlives its player. Format.abbreviate turns scientific past 1e36, reads NaN as 0 and infinities as ∞; WeightedRandom weights must be finite. There is no feature switch or saved field. Source note: docs/systems/Utilities.md.

Demo

demo, on by default. DemoService, the HUD's demo buttons and coin effects (not built while demo is off), Config/Demo, the example product and pass (exampleCoins, granted from config, and exampleVip), the example codes WELCOME and BLOCKOUT, the winter2026 example event and the DemoLeaderboard part demonstrate the full request-to-save-to-interface loop. The interaction test lever is not part of the demo. Demo flags use flags.demoFirstClick; coins use CurrencyService. Switch it off when real gameplay replaces it, then follow the Template's delete-demo skill, which also removes the showcase: it turns demo and showcase off in Config/Overrides/Features.luau rather than removing the switches, removes the vip title with the example pass, leaves doubleCoins while boosts is off, and edits nothing in .lune/. Source note: docs/systems/Demo.md.

Showcase

showcase, off by default, needs mainMenu. Part of the demo composition: loads one example scenario from Config/Showcase.scenarios at a time from the main menu's Feature showcase page, with instructions, Reset and Exit, and removes everything it set up on exit. A scenario is a client view (the component gallery; effect, haptic, toast and capture triggers; the camera profiles), an admin fixture, a documented test flow, or planned; any of them may name a window (an Open button) and try console lines (a Run button each, shown only to a role whose catalog has the command). The registry covers the player-facing, staff, monetization, platform, performance and developer systems. The component gallery is a sidebar of sections (charts and stats, tables and grid, controls with both Dropdown modes, several picks at once and people, buttons, navigation, text, surfaces, feedback, overlays). Specs fail while a system note or feature switch has no scenario, a fixture or try line names no registered command, or a UI component is missing from the gallery, so a new system, switch, component or admin command adds its showcase entry with it. The stage is built on the first scenario load, not at startup. The delete-demo skill removes it with the demo. Source note: docs/systems/Showcase.md.

When adding a system, update the Template's docs/systems/Systems Index.md and the owning system note in the same change. The architecture page explains lifecycle and dependency direction; testing and tooling explains verification.

Updated