Roblox

If you've built games on Roblox, there are some key differences you'll need to know to get started on All Out!

If you’re coming from Roblox Studio + Lua, this page will help you translate your mental model to All Out + CSL (All Out’s scripting language).

The big differences (at a glance)

• Entities + components (not Instances + Services): worlds are built out of entities in the Hierarchy, and behavior comes from adding components (built-in or scripted).

• Multiplayer is “built in”: CSL is designed so most gameplay code can be written like singleplayer while the engine syncs relevant state.

• Editor workflow is closer to “scene editing”: you place entities, tweak their components in the Inspector, and reuse groups via Prefabs.

• CSL is statically typed: it will feel closer to Go/Odin than Lua. (See Getting Started with CSL.)

---

Roblox → All Out cheat sheet

Roblox concept	All Out / CSL concept	Notes
Roblox Studio	All Out Editor	You launch it from the Creator Portal (see Launching The Editor).
Place / Experience	All Out Game project	Your local project folder includes a scripts directory for .csl files.
Explorer / Workspace	Hierarchy	The hierarchy shows all entities in the current world/scene.
Instance / Model / Part	Entity	“Folder-like” organization is done by parenting entities (see “Folders” in Hierarchy).
Properties window	Inspector	Where you edit entity/component fields and add components.
Attributes	Serialized component fields	Expose fields to the editor with @ao_serialize (example below).
Model reuse	Prefabs	Prefabs are early and don’t yet support per-instance custom fields besides position (see Prefabs).
ProximityPrompt / ClickDetector	Interactable component	Add Interactable-derived component and implement can_use/on_interact (see Interactables).
Touched / Region3 / GetPartsInPart	Range queries (for now)	Collision enter/exit callbacks aren’t exposed yet; use Scene.get_all_components_in_range (see Navmesh & Collision).
Tools / abilities / mobile buttons	Abilities	Built-in mobile/PC friendly button UI + cooldown patterns (see Abilities).
DataStoreService	Save + JSON + economy systems	See Save System and JSON Serialization.
ScreenGui / GuiObjects	All Out UI system	See UI Fundamentals.

---

Your first hour (recommended path)

1. Follow the “apple collection” walkthrough in Building a Basic Game.

2. Skim CSL basics in Getting Started with CSL (especially ao_start, ao_update, and creating components).

3. Learn how to attach your new components to world objects via the Inspector.

---

Scripting mental model (Lua → CSL)

In Roblox you often write a Script/LocalScript that finds objects (Workspace.Foo.Bar) and connects events. In All Out, you typically:

• Write component classes in CSL (behavior).

• Attach them to entities in the editor (or spawn entities and add components at runtime).

• Store tunable values on the component with @ao_serialize (so you can tweak per-entity in the inspector).

Here’s a small example that feels like “a Script parented under an object”, but expressed as a CSL component:

import "core:ao"

// Attach this component to an entity in the editor.
Coin_Pickup :: class : Interactable {
    coins: s64 @ao_serialize;
    used: bool;

    ao_start :: method() {
        this->set_listener(this);
        this->set_text("Collect");
        radius = 1.25;
        required_hold_time = 0.0;
    }

    can_use :: method(player: Player) -> bool {
        return !used;
    }

    on_interact :: method(player: Player) {
        if used return;
        used = true;

        Economy.deposit_currency(player, "Coins", coins);
        entity->destroy();
    }
}

If you want a “game script” that runs once per server/session, you’ll typically put it in your main lifecycle procs (ao_start, ao_update, etc). See the template in Getting Started with CSL.

---

Interactions you’ll recognize (and how they translate)

ProximityPrompt → Interactable

If you used ProximityPrompt.Triggered in Roblox, the closest equivalent is an Interactable-derived component. Start here:

• Interactables

“Touched” pickups / trigger zones

Roblox’s BasePart.Touched is a very common pattern for pickups, damage zones, and checkpoints. In All Out, collision enter/exit callbacks are not yet implemented in CSL, so the standard approach is:

• Query nearby players/components

• Do a simple distance check

• Track who was “inside” last frame if you need enter/exit events

See “Pseudo collision behavior” in:

• Navmesh & Collision

---

Player actions (Tools / keybinds / mobile controls)

If you’re used to Roblox “tool” scripts or hand-rolled input + cooldown systems, use Abilities instead. They’re designed to work well on both mobile and PC with consistent UI.

• Abilities

---

Saving data (DataStoreService → Save system)

For persistence (currencies, unlocks, progression, cosmetics), start with:

• Save System

• JSON Serialization

• Economy

• Cross-Game Products/Data

---

UI (ScreenGui → All Out UI)

Roblox UI often starts with ScreenGui and Frame/TextButton hierarchies. In All Out, start here:

• UI Fundamentals

---

Common porting gotchas for Roblox devs

• No “workspace services” tree: don’t look for ReplicatedStorage/ServerScriptService equivalents—use the editor’s hierarchy + your project’s scripts folder.

• Don’t wait for Touched events: use range queries until collision callbacks are available in CSL (link above).

• Prefab instances aren’t fully parameterized yet: if you need many copies with different values, you may need to “unlink” or author unique entities (see Prefabs).

• Think “components” instead of “tags”: where you’d use CollectionService tags, you’ll often add a marker/behavior component instead.

---

Where to go next

• Build your first game: Building a Basic Game

• Learn the editor basics: Introduction/Scene View

• Learn scripting basics: Getting Started with CSL

• Learn core gameplay building blocks: Interactables, Inventory, Abilities