> For the complete documentation index, see [llms.txt](https://docs.allout.game/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.allout.game/coming-from-other-tools/roblox.md).

# Roblox

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](/using-the-editor/hierarchy.md), 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](/using-the-editor/inspector.md), and reuse groups via [Prefabs](/using-the-editor/prefabs.md).
* **CSL is statically typed**: it will feel closer to Go/Odin than Lua. (See [Getting Started with CSL](/scripting/syntax.md).)

***

### 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](/getting-started/first-game.md)).                                                                     |
| **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](/using-the-editor/hierarchy.md)).                                                |
| **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](/using-the-editor/prefabs.md)).                                      |
| **ProximityPrompt / ClickDetector**    | **Interactable component**        | Add `Interactable`-derived component and implement `can_use`/`on_interact` (see [Interactables](/core-engine-concepts/interactables.md)).                               |
| **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](/core-engine-concepts/navmesh-and-collision.md)). |
| **Tools / abilities / mobile buttons** | **Abilities**                     | Built-in mobile/PC friendly button UI + cooldown patterns (see [Abilities](/core-engine-concepts/abilities.md)).                                                        |
| **DataStoreService**                   | **Save + JSON + economy systems** | See [Save System](/data-and-persistence/save.md) and [JSON Serialization](/data-and-persistence/json.md).                                                               |
| **ScreenGui / GuiObjects**             | **All Out UI system**             | See [UI Fundamentals](/ui/fundamentals.md).                                                                                                                             |

***

### Your first hour (recommended path)

1. Follow the “apple collection” walkthrough in [Building a Basic Game](/getting-started/testing-and-publishing.md).
2. Skim CSL basics in [Getting Started with CSL](/scripting/syntax.md) (especially `ao_start`, `ao_update`, and creating components).
3. Learn how to attach your new components to world objects via the [Inspector](/using-the-editor/inspector.md).

***

### 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:

```go
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](/scripting/syntax.md).

***

### 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](/core-engine-concepts/interactables.md)

#### “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](/core-engine-concepts/navmesh-and-collision.md)

***

### 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](/core-engine-concepts/abilities.md)

***

### Saving data (DataStoreService → Save system)

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

* [Save System](/data-and-persistence/save.md)
* [JSON Serialization](/data-and-persistence/json.md)
* [Economy](/data-and-persistence/economy.md)
* [Cross-Game Products/Data](/data-and-persistence/cross-game-products-data.md)

***

### UI (ScreenGui → All Out UI)

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

* [UI Fundamentals](/ui/fundamentals.md)
* [https://github.com/All-Out-Games/allout/blob/master/src/csl/docs/ui/dialogs-and-buttons.md](https://github.com/All-Out-Games/allout/blob/master/src/csl/docs/ui/dialogs-and-buttons.md "mention")

***

### 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](/using-the-editor/prefabs.md)).
* **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](/getting-started/testing-and-publishing.md)
* Learn the editor basics: [Introduction/Scene View](/using-the-editor/introduction-scene-view.md)
* Learn scripting basics: [Getting Started with CSL](/scripting/syntax.md)
* Learn core gameplay building blocks: [Interactables](/core-engine-concepts/interactables.md), [Inventory](/core-engine-concepts/inventory.md), [Abilities](/core-engine-concepts/abilities.md)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.allout.game/coming-from-other-tools/roblox.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.