Game Development Standards

Overview

This standard covers game development — primarily Roblox experiences with Luau scripting, but structured to expand into Unity, Godot, or Unreal as you grow. Game development follows different engineering patterns from web or app development: server-authoritative architecture, data-driven design, asset pipeline management, and platform-specific constraints.

Prerequisites: General Standards (file structures, Git, a11y, privacy).

What this covers:

• Roblox game development (Luau scripting, Studio tooling)
• Toolchain setup (Rojo, Rokit, version control for game code)
• Roblox map/module/tool development
• General game dev patterns (future: Unity, Godot, Unreal)

Tech Stack (2026)

Why Rojo + Rokit:

• Version control for Luau scripts (real Git diffs, not binary .rbxl files)
• CI/CD pipeline for automated builds and testing
• Multiple environment support (development, staging, production)
• Integration with VS Code for a proper coding environment
• Collaboration via Git-based workflows

Project Scaffolding

File Structure (Rojo-based Roblox Project)

project-root/
├── src/
│   ├── ReplicatedStorage/        # Shared: client + server
│   │   ├── Modules/               # Shared Luau modules
│   │   │   ├── Types.luau        # Type definitions
│   │   │   ├── Constants.luau    # Game constants and configuration
│   │   │   └── Utils.luau        # Pure utility functions
│   │   ├── Data/                  # Game data (tables, JSON)
│   │   └── UI/                    # Shared UI components (if applicable)
│   ├── ServerScriptService/       # Server-only scripts
│   │   ├── GameManager.luau      # Core game loop logic
│   │   ├── EconomyService.luau   # Currency, rewards, progression
│   │   ├── DataStoreService.luau # Persistence and data stores
│   │   └── ServerEvents.luau     # RemoteEvent definitions
│   ├── StarterPlayer/
│   │   └── StarterPlayerScripts/ # Client-only scripts
│   │       ├── ClientManager.luau
│   │       ├── InputHandler.luau
│   │       └── ClientEvents.luau
│   ├── Workspace/                 # Place scripts (attached to parts/models)
│   │   └── ProceduralGenerator.luau # World generation (if applicable)
│   └── SoundGroup/                # Audio configuration
├── assets/
│   ├── models/                    # .rbxm model files
│   └── textures/                  # Image assets
├── tests/                         # Luau unit tests
├── .github/
│   └── workflows/
│       └── build.yml             # Rojo build + deploy pipeline
├── default.project.json          # Rojo project definition
├── rokit.json                     # Rokit tool version config
└── README.md

Rojo Configuration

{
  "name": "aura-depths",
  "tree": {
    "$className": "DataModel",
    "ReplicatedStorage": {
      "$className": "ReplicatedStorage",
      "Modules": {
        "$path": "src/ReplicatedStorage/Modules"
      }
    },
    "ServerScriptService": {
      "$className": "ServerScriptService",
      "Server": {
        "$path": "src/ServerScriptService"
      }
    },
    "StarterPlayer": {
      "$className": "StarterPlayer",
      "StarterPlayerScripts": {
        "$path": "src/StarterPlayer/StarterPlayerScripts"
      }
    }
  }
}

Initial Setup Checklist

• rokit init — initialize Rokit toolchain
• rojo init — initialize Rojo project
• VS Code with Luau LSP configured
• Git repository initialized (excluding .rbxl files)
• default.project.json configured with source folders
• GitHub Actions workflow: build + deploy to Roblox
• Module structure established (Types, Constants, Utils)
• RemoteEvent/RemoteFunction definitions created

Architecture & Design Patterns

Roblox Project Architecture

Client (StarterPlayerScripts)
  ↓ RemoteEvents/RemoteFunctions
Server (ServerScriptService)
  ↓ DataStoreService
Roblox Cloud (Persistence)

Key Engineering Patterns

Data-Driven Design:

• Use external data tables (JSON/ModuleScripts) for game configuration — item stats, spawn rates, prices, etc.
• Separate data from logic for easier tuning and testing
• Version data schemas to handle migrations

Module-Based Architecture:

• Every major system is a ModuleScript
• Services are singletons (require once, use everywhere)
• Clear dependency graph (no circular dependencies)

Server-Authoritative Design:

• Critical game logic runs on the server
• Clients send requests via RemoteEvents; server validates and responds
• Never trust client input — validate all remote event arguments
• Use RemoteFunctions for request-response patterns when immediate feedback is needed

Procedural Generation (from Aura Depths)

-- Pattern: Weighted RNG with seeded generation
local function generateChunk(seed: number, config: ChunkConfig): ChunkData
    local rng = Random.new(seed)
    local chunk = {
        Resources = {},
        Obstacles = {},
        Terrain = {},
    }
    
    for x = 1, config.Size.X do
        for y = 1, config.Size.Y do
            local roll = rng:NextNumber(0, 1)
            -- Weighted probability based on config
            for _, tier in ipairs(config.ResourceTiers) do
                if roll <= tier.Probability then
                    table.insert(chunk.Resources, {
                        Position = Vector2.new(x, y),
                        Type = tier.Type,
                        Value = tier.BaseValue * rng:NextNumber(0.8, 1.2),
                    })
                    break
                end
            end
        end
    end
    
    return chunk
end

Performance Standards

Roblox-Specific Optimization

• Use GetAttribute/SetAttribute instead of IntValue/StringValue objects for lightweight data
• Pool parts — reuse parts instead of creating/destroying frequently
• Minimize network events — batch data into fewer, larger packets
• Use collections — CollectionService for tagging instead of searching the entire Workspace
• Avoid WaitForChild in hot paths — use events or direct references
• Instance streaming — leverage Roblox’s streaming system for large worlds

CI/CD Pipeline

GitHub Actions Workflow

name: Build & Deploy
on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: Roblox/setup-foreman@v1
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
      - name: Run rojo build
        run: rojo build default.project.json -o build.rbxl
      - name: Deploy to Roblox
        if: github.ref == 'refs/heads/main'
        run: |
          # Deploy via Roblox API or manual process
          echo "Build ready for deployment"

Roblox-Specific Standards

Luau Coding Conventions

• Strict type checking — Use --!strict in all ModuleScripts
• Naming:
  • Services: PascalCase (GameManager, EconomyService)
  • Functions: camelCase (getChunkData)
  • Events: PascalCase with Event/Function suffix (OnPlayerJoined)
  • Constants: UPPER_CASE (MAX_PLAYERS)
• Error handling — pcall() on DataStore and network operations
• Documentation — --[[ function description ]] above public APIs

Security Patterns

• Validate all RemoteEvent arguments on the server
• Use RemoteFunction:InvokeClient sparingly (race conditions)
• Implement rate limiting on RemoteEvents (anti-exploit)
• Never trust the client for game-critical state
• Use HttpGetAsync only from the server (never the client)

Review & Shipping Checklist

• All scripts use --!strict type checking
• RemoteEvent validation on the server for all arguments
• Rate limiting on all client-server communication
• DataStore error handling (pcall, retry logic)
• Performance targets met (FPS, memory, network)
• Rojo build succeeds cleanly
• CI/CD pipeline verified (build + deploy)
• Privacy review: no unnecessary data collection
• Game settings optimized (streaming, lighting, physics)
• Tested on low-end device (covers Roblox’s user base)
• Error logging (server-side) for debugging production issues

Trends to Watch (2026+)

• Luau type system maturity — More robust static analysis and IDE support
• AI-assisted Roblox development — GenAI for procedural assets, dialogue, quest generation
• Cross-platform Roblox — Growing console and desktop user base
• Creator Store monetization — Selling plugins, models, and scripts
• Procedural everything — Runtime-generated content becoming standard in multiplayer games

Project Templates

• Aura Depths — Reference: Rojo-based Roblox project with procedural generation, CI/CD, and weighted RNG systems

References

• Aura Depths project page — Real-world Rojo toolchain and procedural generation architecture
• Arc Architects: Building Roblox Loading Maps — Detailed architecture documentation
• External: Rojo Documentation, Luau Documentation, Roblox Creator Documentation, Roblox Luau Style Guide