Onboarding for developers

This page covers the Roblox fundamentals that engineers coming from other engines most often need in their first weeks. Each section explains the core idea and links to the detailed guide.

Common terms

• Game: A collection of places that players join through the game's start place. Data stores, secrets, analytics, and in-game purchases are all scoped to the game, which you might also see called an experience or a universe.
• Place: A scene or zone within a game, with its own data model. Each server runs one place, and moving players between places requires a teleport.
• Instance: A node in the data model, with properties, methods, and events. Parts and Models are the most common instances for building physical objects.
• Asset: Uploaded content with a globally unique asset ID, such as an image, mesh, sound, or animation. Some asset types, like models and animations, can be updated in place, while others, like images and sounds, require uploading a new asset.
• Script: Code stored as an instance in the data model. Copying a script makes a full, independent copy, not a reference to a source file.

For more on how games and places relate, see Games and places.

Data model structure

The data model is the tree of instances that makes up a place. Its top-level services each have a specific purpose and replication behavior:

The hierarchy in the Explorer is mostly organizational:

• Parts use world-space transforms, not transforms relative to their parent. To attach parts to each other, use constraints, most commonly a WeldConstraint. For details, see Mechanical constraints.
• Attachments are an exception, because they position relative to their parent part.
• Models use their PrimaryPart as the reference point for moving and pivoting the whole model.

Scripting model

In most cases, you only need two kinds of scripts:

• A Script with its RunContext set to Server or Client.
• A ModuleScript, which returns a value that other scripts load with require(). Use modules for shared libraries, functions, and data.

Avoid the Legacy run context and LocalScripts. Their behavior depends on where they're placed, which makes code harder to organize. For recommended locations, see Script types and locations.

Server scripts never replicate to clients. Modules replicate to clients when they're in a container that clients can access, like ReplicatedStorage. Keep server-only modules in ServerScriptService or ServerStorage.

Networking and replication

Roblox uses a client-server model:

• Changes the server makes to instances, including properties, attributes, and tags, replicate to clients automatically.
• Changes a client makes don't replicate to the server, with a few exceptions. The main exceptions are physics for parts the client owns, such as its own character, and input from the input action system.
• The engine distributes physics simulation between the server and clients. Clients simulate the parts they own and send positions and velocities to the server.

To communicate between the client and server, use remote events and callbacks:

• RemoteEvent and RemoteFunction are reliable and ordered.
• UnreliableRemoteEvent is unreliable and unordered, for frequent updates where a dropped message doesn't matter.
• Remotes aren't secured by default. Always validate data that the server receives from clients.

Server authority

For competitive games, server authority makes the server authoritative over physics and gameplay, while clients predict their own characters and nearby physics objects. When a client mispredicts, it rolls back and resimulates.

Input

Handle input with the input action system. You define actions, like jump or sprint, in InputContext instances and bind them to keys, buttons, and touch controls with InputBinding instances. When you use server authority, each InputContext must be a descendant of a Player so that the engine knows which player owns it. One approach is to keep your contexts in ReplicatedStorage and clone them to each player from a server script. For details, see Input actions.

Streaming

Instance streaming loads parts of the workspace onto each client as players move through the world, which keeps load times and memory low on all devices.

• Instances in ReplicatedStorage replicate in full when a player joins, before scripts run, so they're safe to access immediately.
• Instances in the workspace stream in and out. Client code must handle instances that aren't loaded yet.
• Instances connected by constraints stream together to keep physics stable.

Each Model has a ModelStreamingMode that controls how it streams:

Assets like textures, meshes, and audio also stream at runtime. Images load at a low resolution first and then improve based on the device and how large they appear on screen.

Data persistence

DataStoreService saves player data across sessions. Its APIs are low level, so read Data stores and Player data and purchasing before you design your save system. These guides cover common pitfalls like rate limits, session locking, and handling purchases safely.

Data stores are scoped to the game. To keep test data out of production, use a separate game for development. For details, see Environments.

Solve common tasks

Reuse behavior across instances

Because copied scripts are independent copies, avoid putting a copy of the same script in every instance that needs it. Instead, tag instances with CollectionService and write one script, backed by a ModuleScript, that attaches behavior to every tagged instance.

Use a custom character

Characters can use the platform avatar, the platform rig with a custom look, or an entirely custom rig. To keep the default spawn system but replace the character, place a model named StarterCharacter in StarterPlayer.

Override the default control scripts

Roblox adds default camera and control scripts to each player. To replace them:

1. Enable Workspace.PlayerScriptsUseInputActionSystem, which moves the default player scripts under StarterPlayer.
2. Set StarterPlayer.CreateDefaultPlayerModule to false so that the default camera and control scripts aren't added.
3. Add your own camera and control scripts.

Create shader-like effects

Roblox doesn't support custom shaders. Instead:

• Use SurfaceAppearance or MaterialVariant for PBR materials.
• Use SurfaceAppearance or the Neon material for emissive surfaces.
• Use the ForceField material for intersection effects.
• For special cases, generate dynamic textures and geometry with EditableImage and EditableMesh.

Performance

Performance on Roblox depends mostly on the content you add and the time your scripts take each frame. Test regularly on your target hardware, and set budgets early for scene complexity (triangles, draw calls, and dynamic lights), physics, replication, and script time per frame. Most performance problems come from content that's configured incorrectly, and fixing them late often means reworking assets.

• Automatic quality: Most players use automatic graphics quality, which has 10 levels. As the level drops to keep frame rates up, the engine lowers render distance, geometry quality such as level of detail and SLIM, shading quality, lighting quality, shadows, particle emission, and streaming radius. Draw distance never drops below 500 studs, shadows turn off below level 4, and terrain water and beams look the same at every level. Roblox tunes these values continually, so don't design around exact numbers. To preview, change Editor Quality Level in Studio settings, and test at both the lowest and highest levels. For details, see Graphics quality levels.
• Texture streaming: Textures stream and scale automatically to fit memory budgets and on-screen size.
• Occlusion culling: The engine automatically skips draw calls for parts, meshes, and terrain hidden behind other objects. Structuring levels with walls and other view blockers lets you manage scene complexity. Simple hidden block parts inside walls make occlusion tests cheaper than relying on detailed meshes. For more ways to reduce draw calls, see Rendering.
• Scripting: Luau is fast enough for complex, dynamic gameplay code. You don't need to avoid garbage collection or pool objects, and creating instances at runtime is fast.
• Lighting: Scenes can use many lights. Roblox scales lighting quality automatically by device, and falls back to a lower-cost lighting path in complex scenes.

For tools to measure and fix problems, see Performance optimization.

Tools and AI

• External editors: Use VS Code or another editor with Script Sync or Rojo. Add the Luau Language Server and the selene linter for type checking and linting. For team setups, see Compare file-based workflows.
• Studio MCP server: Most professional developers will want to use their own AI tools and agent harness, like a coding agent in a terminal or editor. The Studio MCP server connects those tools to Studio so they can build and test directly in your open session.
• Assistant: Assistant is Studio's built-in AI helper for writing code and building, for when you want AI help without setting up your own tools.