Find a global, library, service, class, datatype or enum. Choose where your script runs: available members and behavior can differ between the client, Studio and a hosted server.
Read the context before using an API
Client scripts handle local input, UI and world presentation. Studio runs local playtests and authoring tools. Hosted scripts own shared gameplay, persistence and messages to players. A service name in one context does not promise the same members in another.
Read properties with a dot (part.Position), call methods with a colon (workspace:GetChildren()), and call library functions with a dot (Vector3.new(0, 0, 4)). Event values support subscriptions such as Players.PlayerAdded:Connect(callback). A ? marks an optional parameter or a possibly absent result.
Client catalog 2026.9.23, Studio catalog 2026.9.23; hosted API 0.4.0. The reference describes this release. Older installed clients and running servers may expose fewer members.
The hosted catalog describes the game-manager runtime. The standalone native host is an opt-in preview with a separately tested subset; matching service names do not establish complete native gameplay parity.
Client, Studio and hosted native string length/indexing use UTF-8 bytes. The desktop VM preserves incomplete byte fragments reversibly while retaining normal Unicode text for UI. Use unicode helpers for scalar-oriented operations.
globalScope
Each script retains its own normal globals. _G and shared are separate session-wide data namespaces across scripts in one Client, Studio or hosted runtime; they do not replicate or cross games. Session stop clears the stores and revokes old proxies.
sharedValues
Session-local live object graphs preserve nested table identity, aliases and cycles across script VMs. Nested writes are immediately readable by other scripts in the same runtime. Tables assigned into shared are adopted as proxies. Functions, threads and unsupported userdata remain rejected. This is not network replication or persistent storage.
sharedOperations
Indexed reads/writes, length, rawget/rawset, next/pairs/ipairs, and table clone/clear/find/insert/remove/sort/move/concat/unpack use the live graph. Session stop revokes proxies. Up to 4096 nodes are retained until session teardown so detached references remain valid.
unicode
unicode.len/char/codepoints/sub use Unicode scalar values on all runtimes and reject invalid UTF-8/UTF-16 and surrogate code points. They do not count grapheme clusters or normalize text. Native strings are byte-oriented on all runtimes.
random
Random.new explicit seeds produce the same Park-Miller gameplay stream across runtimes; seeds are finite exact-range numbers, floored and normalized modulo 2147483646. NextInteger supports inclusive int32 ranges; Clone copies state; NextUnitVector trigonometric rounding may differ slightly. Native math.random streams remain different. Not for secrets.
hostedLibraries
Global table.create/find/clone/clear/move/concat and table.unpack have portable entry/result limits. Global string.rep/split have portable output/input limits. Hosted native string method syntax such as value:rep resolves the readonly native metatable and does not use these wrappers. Other native library operations and operators are not newly bounded.
stringBudgetUnits
Portable string limits count UTF-8 bytes. Native Lua strings can contain arbitrary bytes, but JSONEncode, RPC values/map keys, StringValue/attributes, shared graphs and datastores require valid Unicode text and reject malformed byte strings; there is no binary network codec.
datatypes
NumberRange, UDim/UDim2, Vector2/Vector3 and CFrame are values. Hosted CFrame math uses the same Y-up center-space coordinates as desktop CFrames; legacy Bridge positions remain corner-based Z-up.
Globals Client
Values and functions available without retrieving a service. Constructor tables such as Vector3 are values; use their named functions.
Instance.new(className). Part/Block/WedgePart/Truss/SpawnLocation/Seat/MeshPart/BasePart/Brick all make a brick; ScreenGui/Frame/TextLabel/TextButton/ImageLabel/ImageButton/TextBox make GUI elements; ParticleEmitter makes an emitter. Anything else becomes a generic tree node.
Native indexing uses UTF-16 code units on desktop and UTF-8 bytes on hosted LuX; unicode helpers offer portable scalar indexing. Hosted string method syntax uses the native readonly metatable and bypasses the global rep/split limit wrappers.
Array and dictionary helpers. Portable create/find/clone/clear/move/concat helpers cap work at 100000 entries and use signed 32-bit indices; unpack caps results at 10000.
Shared data proxy across scripts in this runtime session. Plain data is copied on assignment and read; reassign nested edits. Isolated from shared, other sessions and the network. Functions, userdata, metatables and cycles are rejected.
Native indexing uses UTF-16 code units on desktop and UTF-8 bytes on hosted LuX; unicode helpers offer portable scalar indexing. Hosted string method syntax uses the native readonly metatable and bypasses the global rep/split limit wrappers.
Split on a literal separator (default comma), preserving empty fields. Empty separator splits native string units. All runtimes cap inputs at 1048576 native units and results at 100000.
table Client · library
Array and dictionary helpers. Portable create/find/clone/clear/move/concat helpers cap work at 100000 entries and use signed 32-bit indices; unpack caps results at 10000.
Server/Studio storage only; client calls explicitly error. Studio uses local JSON, local hosted play uses memory, and published servers use authenticated game-scoped persistence.
Nearest finite-segment hit against full-basis oriented Workspace brick bounds. Direction includes length; no exact mesh/player hits. At most 20,000 bricks.
Returns whether the given KeyCode is currently held.
PlayerGui Client · service
The local player's live on-screen UI. Hosted server scripts use player.PlayerGui for an isolated tree replicated only to that player; hosted StarterGui remains a shared live tree.
Free-form value slot. Backs the *Value classes (IntValue, StringValue, Vector3Value, Color3Value) - but it is untyped and present on every generic instance, so nothing enforces that an IntValue holds a number. Not replicated: it is local to the script's own instance tree.
A particle effect. Free-floating, or following a brick or a player. Emitters live in world space, so moving one leaves a trail rather than dragging its particles along.
Particles per second, minimum 0. Default 20. The pool is capped at 4000 particles per emitter, so a very large Rate stops scaling rather than stalling the client.
Assign PlayerGui for a ScreenGui, another element for anything else, nil to detach. A non-ScreenGui assigned to PlayerGui is refused and left detached.
Assign PlayerGui for a ScreenGui, another element for anything else, nil to detach. A non-ScreenGui assigned to PlayerGui is refused and left detached.
Assign PlayerGui for a ScreenGui, another element for anything else, nil to detach. A non-ScreenGui assigned to PlayerGui is refused and left detached.
Assign PlayerGui for a ScreenGui, another element for anything else, nil to detach. A non-ScreenGui assigned to PlayerGui is refused and left detached.
Assign PlayerGui for a ScreenGui, another element for anything else, nil to detach. A non-ScreenGui assigned to PlayerGui is refused and left detached.
Assign PlayerGui for a ScreenGui, another element for anything else, nil to detach. A non-ScreenGui assigned to PlayerGui is refused and left detached.
Fires when the cursor enters the element. Connecting or waiting on this is what makes the element take part in mouse picking at all - until something listens, clicks and camera movement pass straight through it to the world behind.
Assign PlayerGui for a ScreenGui, another element for anything else, nil to detach. A non-ScreenGui assigned to PlayerGui is refused and left detached.
Fires when the cursor enters the element. Connecting or waiting on this is what makes the element take part in mouse picking at all - until something listens, clicks and camera movement pass straight through it to the world behind.
Assign PlayerGui for a ScreenGui, another element for anything else, nil to detach. A non-ScreenGui assigned to PlayerGui is refused and left detached.
Fires when the cursor enters the element. Connecting or waiting on this is what makes the element take part in mouse picking at all - until something listens, clicks and camera movement pass straight through it to the world behind.
Assign PlayerGui for a ScreenGui, another element for anything else, nil to detach. A non-ScreenGui assigned to PlayerGui is refused and left detached.
Fires when the cursor enters the element. Connecting or waiting on this is what makes the element take part in mouse picking at all - until something listens, clicks and camera movement pass straight through it to the world behind.
Assign PlayerGui for a ScreenGui, another element for anything else, nil to detach. A non-ScreenGui assigned to PlayerGui is refused and left detached.
Fires when the cursor enters the element. Connecting or waiting on this is what makes the element take part in mouse picking at all - until something listens, clicks and camera movement pass straight through it to the world behind.
Assign PlayerGui for a ScreenGui, another element for anything else, nil to detach. A non-ScreenGui assigned to PlayerGui is refused and left detached.
Fires when the cursor enters the element. Connecting or waiting on this is what makes the element take part in mouse picking at all - until something listens, clicks and camera movement pass straight through it to the world behind.
Assign PlayerGui for a ScreenGui, another element for anything else, nil to detach. A non-ScreenGui assigned to PlayerGui is refused and left detached.
Fires when the cursor enters the element. Connecting or waiting on this is what makes the element take part in mouse picking at all - until something listens, clicks and camera movement pass straight through it to the world behind.
Text is updated before FocusLost(enterPressed, inputObject). Enter sets true; blur sets false. Hosted handlers receive nil inputObject and the authenticated player as a third argument. Hosted input is limited to 4096 UTF-8 bytes and rejected for another player's private tree or hidden/disabled UI.
Server-only. Yield until the selected connected client responds. Never trust client-returned gameplay decisions.
DataStore Client · class
Server/Studio JSON storage (4 MiB, depth 64, 100,000 values per payload). Hosted operations yield for IO; Studio completes locally. Each successful mutation has an opaque revision; revisions persist until explicitly removed. No Roblox retention/hourly-version policy or user metadata APIs.
List key revisions. Defaults Ascending and pageSize 50; size 1-100. Date bounds are inclusive Unix milliseconds. Pages are live keyset pages, not a snapshot.
Permanently delete a retained revision. Deleting the current revision removes the current value and never resurrects an older revision.
OrderedDataStore Client · class
Server/Studio integer store. Values must be exact integers between -9007199254740991 and 9007199254740991. No version-history APIs. Hosted operations yield; Studio completes locally.
List {key,value} entries sorted numerically, with key tie-break. Ascending is required; page size defaults to 50 and must be 1-100. Optional bounds are inclusive safe integers. Live keyset pages may reflect intervening writes.
DataStorePages Client · class
Paged ordered-store entries with key and value fields.
Construct identity, from a Vector3, from x/y/z, from position and target Vector3s, from x/y/z plus quaternion x/y/z/w, or from x/y/z plus nine row-major rotation entries.
Constant value, or a start/end pair, or a table: keypoints, {time, value} pairs, or plain numbers spaced evenly. An unrecognised argument yields an empty sequence, which every consumer treats as "no sequence".
Native indexing uses UTF-16 code units on desktop and UTF-8 bytes on hosted LuX; unicode helpers offer portable scalar indexing. Hosted string method syntax uses the native readonly metatable and bypasses the global rep/split limit wrappers.
Array and dictionary helpers. Portable create/find/clone/clear/move/concat helpers cap work at 100000 entries and use signed 32-bit indices; unpack caps results at 10000.
Shared data proxy across scripts in this runtime session. Plain data is copied on assignment and read; reassign nested edits. Isolated from shared, other sessions and the network. Functions, userdata, metatables and cycles are rejected.
Native indexing uses UTF-16 code units on desktop and UTF-8 bytes on hosted LuX; unicode helpers offer portable scalar indexing. Hosted string method syntax uses the native readonly metatable and bypasses the global rep/split limit wrappers.
Split on a literal separator (default comma), preserving empty fields. Empty separator splits native string units. All runtimes cap inputs at 1048576 native units and results at 100000.
table Studio playtest · library
Array and dictionary helpers. Portable create/find/clone/clear/move/concat helpers cap work at 100000 entries and use signed 32-bit indices; unpack caps results at 10000.
Connect to instances leaving this tag or being destroyed.
DataStoreService Studio playtest · service
Server/Studio storage only; client calls explicitly error. Studio uses local JSON, local hosted play uses memory, and published servers use authenticated game-scoped persistence.
Animate Part transforms/color/transparency and GUI Position, Size, AnchorPoint, background color/transparency and text color/size. ScrollingFrame offsets are currently client-only.
Animate Part transforms/color/transparency and GUI Position, Size, AnchorPoint, background color/transparency and text color/size. ScrollingFrame offsets are currently client-only.
Named RemoteFunction handles shared by hosted games and Studio play sessions.
DataStore Studio playtest · class
Server/Studio JSON storage (4 MiB, depth 64, 100,000 values per payload). Hosted operations yield for IO; Studio completes locally. Each successful mutation has an opaque revision; revisions persist until explicitly removed. No Roblox retention/hourly-version policy or user metadata APIs.
List key revisions. Defaults Ascending and pageSize 50; size 1-100. Date bounds are inclusive Unix milliseconds. Pages are live keyset pages, not a snapshot.
Server/Studio integer store. Values must be exact integers between -9007199254740991 and 9007199254740991. No version-history APIs. Hosted operations yield; Studio completes locally.
List {key,value} entries sorted numerically, with key tie-break. Ascending is required; page size defaults to 50 and must be 1-100. Optional bounds are inclusive safe integers. Live keyset pages may reflect intervening writes.
Saved with the place. True keeps the part fixed. The shared hosted solver supports false for boxes and uniform spheres; the standalone native host currently rejects false. Client scripts cannot control authoritative physics.
Text is updated before this event. Enter sets enterPressed=true; ordinary blur sets false. Hosted handlers receive nil inputObject and the authenticated player as the third argument. Hosted input is limited to 4096 UTF-8 bytes and rejected for another player's private tree or hidden/disabled UI.
Construct identity, from a Vector3, from x/y/z, from position and target Vector3s, from x/y/z plus quaternion x/y/z/w, or from x/y/z plus nine row-major rotation entries.
Shared data proxy across scripts in this runtime session. Plain data is copied on assignment and read; reassign nested edits. Isolated from shared, other sessions and the network. Functions, userdata, metatables and cycles are rejected.
Session-local live object graphs preserve nested table identity, aliases and cycles across script VMs. Nested writes are immediately readable by other scripts in the same runtime. Tables assigned into shared are adopted as proxies. Functions, threads and unsupported userdata remain rejected. This is not network replication or persistent storage.
Use these functions from hosted scripts and event callbacks. Spawn and defer queue work for the next scheduler turn. A task handle belongs to the script that created it.
Cancels an owned suspended task and releases its timer or signal waiter. Running or foreign tasks are rejected; completed or cancelled handles are harmless.
Get this service with game:GetService("Players"). Servers have no LocalPlayer. Register PlayerAdded and also process GetPlayers() when initializing already connected players.
Player Hosted server@if (!empty($entry['deprecated'])) · Deprecated compatibility@endif
Player properties are snapshots. Read a new player from Players for current state. Use explicit setters to change authoritative state; assigning a field changes only your local table. Character is a server-backed state view, not a physical rig.
Private server-authored UI tree, replicated only to this player and destroyed when they disconnect. Hosted access is through the Player, not game:GetService("PlayerGui"); desktop local scripts use game.PlayerGui.
Returns one of the supported children immediately or nil.
Character Hosted server@if (!empty($entry['deprecated'])) · Deprecated compatibility@endif
A server-backed character state view. It is not a replicated body-part graph or a custom rig. Direct field assignment changes only this script’s snapshot.
Stable Instance graph identity, parent-cycle checks, recursive clone/delete, authored folder/model imports and snapshot/delta replication. 20,000 nodes with bounded hierarchy depth. Workspace and ReplicatedStorage replicate. ServerStorage and detached physical parts are excluded from both graph snapshots and legacy map transport; private edits are not broadcast. Moving an already public object into ServerStorage cannot erase information previously sent to clients.
Saved with the place. True keeps the part fixed. The shared hosted solver supports false for boxes and uniform spheres; the standalone native host currently rejects false. Client scripts cannot control authoritative physics.
Return collidable Workspace parts whose oriented bounds overlap this collidable Workspace part. Does not return Players and does not apply query filter params.
Fires when another collidable Workspace part or live player begins overlapping this collidable part. Detection targets 20 Hz; fast movement between polls can be missed.
Authenticated sender for a published part click. Private/deleted parts are excluded and destruction disconnects listeners. The legacy secure flag is advisory: validate distance, cooldowns and game rules on the server.
Timing and execution context for the hosted server. Heartbeat targets 60 Hz and reports measured elapsed seconds; missed ticks are coalesced under load.
Computes bounded horizontal routes around static rectangular parts, including yaw-rotated walls. It does not navigate terrain, slopes, meshes or elevation changes.
Returns status, waypoints and exploredNodes. Positions use the hosted world x/y plane with z as height. options supports cellSize (0.5–8), agentRadius (0–8) and agentHeight (0.5–16). Routes are limited to 256 world units, 2,048 parts and 4,096 explored nodes. Unsupported heights or geometry fail with a status instead of guessing a route.
Moves an existing Workspace Part along a computed route on the hosted server. Returns a handle with Status, Waypoints and Stop(). options.speed is 0.5–32 studs per second; each script may have at most 16 active followers. The part itself is excluded from route obstacles. Character rigs, limb animation, moving-obstacle replanning and combat behavior are not supported.
Ownership checks and developer-product receipts scoped to this game. Ownership checks require a connected player. Purchases require the website checkout to be enabled; scripts must persist their own product grants before acknowledging a receipt.
Checks current catalog-item ownership on the site. Guests return false. Results are cached for 10 seconds; failed lookups raise an error rather than granting access. Fresh requests are capped at 120 per minute per game.
Checks permanent ownership of a pass belonging to this game. Guests and local playtests return false. Results are cached for 10 seconds; lookup failures raise an error. Item and pass lookups share a limit of 120 fresh requests per minute per game.
Receives a table with ReceiptId, BuyerId, ProductId, PriceBits and PurchasedAt. Receipts include offline buyers and may be delivered repeatedly or to multiple running servers. The host polls at most 100 receipts every 5 seconds. Persist an idempotent grant keyed by ReceiptId before acknowledging; returning from a callback does not acknowledge a purchase.
Acknowledges a receipt previously delivered to this game instance, using its verified buyer and product identity. Returns true after the website confirms acknowledgement; unknown receipt IDs or failed requests raise an error. Only acknowledge after the grant is stored durably.
Game-scoped messages between running hosted instances. Delivery is best effort; this is not persistent storage. Topics contain 1–64 letters, digits, underscores, dots, colons or dashes. Payloads are JSON-compatible and limited to 4,096 bytes.
Registers a callback receiving the payload for this topic. Call Disconnect on the returned connection to stop receiving. Instances poll approximately once per second; messages expire after two minutes and messages sent before an instance starts are not replayed.
Creates server-owned NPCs that do not appear in Players. Each script may own eight NPCs; each game may have 32 animated native characters. Both controllers support basic damage, healing and navigation around static horizontal obstacles.
Creates a Model of seven block parts with Health and MaxHealth values. Options: color (Color3), maxHealth (1–10,000), speed (0.5–32). The controller has Model, Root, Health, MaxHealth, Speed, Alive and Died. Limbs are not animated.
Creates a server-owned character using the client’s animated body renderer. Options: maxHealth (1–10,000), speed (0.5–32). The controller has Id, Position, Health, MaxHealth, Speed, Alive and Died. This is separate from a player account.
Returned by NPCService:CreateRig or CreateCharacter. Names contain 1–64 visible characters. Advanced combat decisions, custom rigs and dynamic physics navigation are not implemented.
Starts bounded path-following, replacing the previous movement. The returned handle has Status and Stop. Speed defaults to the controller’s Speed and must be 0.5–32.
Opt-in server-authoritative physics for boxes and uniformly sized spheres. Vectors use Y-up center coordinates. Existing parts remain anchored until configured otherwise. The world supports 64 dynamic bodies and 2,048 static colliders; character pushing, joints and mesh-triangle collision are not supported.
Updates Anchored, Mass (0.01–10,000), Friction, Restitution, LinearDamping and AngularDamping (each 0–1). Unsupported geometry or settings raise an error. Dynamic transforms are published at up to 20 Hz.
Runtime Folder/Model/Part tags replicate to connected and late-joining clients. ServerStorage logical nodes/tags are excluded from graph snapshots. Changes are session state, not automatically saved in published maps. Maximum 32 tags per graph node.
Returned by TweenService:Create. Starting a conflicting property tween cancels the older active or paused tween. Maximum 256 retained tweens per script and 4,096 per game; Destroy releases one.
Server side of named client/server messages. Payloads are JSON-compatible values, limited to 16 KiB, depth 32 and 4,096 values. Validate gameplay permissions, range, round state and cooldowns in the server callback.
Callback receives the authenticated Player and payload. Names start with a letter; remaining characters may be letters, digits, underscore, dot, slash, colon or hyphen; maximum 96 characters.
Sends to all connected players and returns the recipient count.
Teams Hosted server@if (!empty($entry['deprecated'])) · Deprecated compatibility@endif
Hosted team lookup and creation. Get this service with game:GetService("Teams"). These members do not imply matching desktop or native-preview support.
Creates a team, or returns the existing team with that name without changing its color. Names require 1–64 visible UTF-8 bytes without control characters. Color accepts Color3 or #RRGGBB and defaults to white.
Team Hosted server@if (!empty($entry['deprecated'])) · Deprecated compatibility@endif
Read-only hosted team view returned by Teams. Use player:SetTeam(team) to assign a connected player; this is not a freely parentable graph instance.
Hosted player-facing messages and authenticated input signals. Output text is limited to 1024 UTF-8 bytes; disallowed control characters are rejected. Targeted messages accept chat, top, center or bottom channels and a finite duration from 0 to 60 seconds, defaulting to chat and 5 seconds. This service does not provide cross-server delivery; use MessagingService for that.
Callback receives the authenticated Player, command string and unsplit argument string for ordinary non-reserved commands. Authorize any game action before applying it.
Hosted account-backed badges configured for this game. User and badge IDs must be positive safe integers. Guests and local playtests do not award account-backed badges or items. Handle backend failures with pcall; these members do not imply native-preview or client support.
Named/scoped standard and ordered stores, GetAsync/SetAsync/RemoveAsync/IncrementAsync/UpdateAsync, standard GetVersionAsync/ListVersionsAsync/RemoveVersionAsync and ordered GetSortedAsync. Versions retain mutation history and deletion tombstones; pages contain 1–100 rows. Ordered values must be safe integers; live keyset pages are not snapshot-stable during concurrent score changes. Existing SetAsync value return is preserved. Hosted CAS UpdateAsync retries at most 8 times and rejects yielding transforms. 4 MiB/value, depth64, 255-byte keys, 64 pending calls, budget600/minute burst120. Website migration is required. Studio persists locally; local host stores are ephemeral. Player clients cannot access storage directly.
Explicit hosted adapters for existing raw-key saves. These are not named, atomic or versioned stores, and GetGlobalDataStore does not refer to this namespace. Keys require 1–255 UTF-8 bytes without control characters. Handle failures with pcall; read/write pairs can race.
Global legacy handle only; player handles do not expose this method. Lists raw keys in the given scope, default global. Unpaged compatibility operation; not an atomic or versioned query.
Sends a sound playback request to compatible connected clients. Assets are first-party numeric IDs or HTTPS URLs; the client caps downloads at 16 MiB. Studio Sound authoring remains a separate surface.
Hosted values expose immutable component fields. The client datatype reference below is a separate surface; do not assume every client operation exists on the host.
Fields are Time, EasingStyle, EasingDirection, RepeatCount, Reverses and DelayTime. RepeatCount is additional cycles; -1 repeats forever. Delay precedes each cycle.
NumberRange.new(minimum = 0, maximum = minimum): NumberRange#
function
Immutable Min and Max fields. Components must be finite and minimum must not exceed maximum.
Deprecated compatibility for existing hosted scripts, not the preferred API for new code. Bridge remains available; deprecation does not remove published scripts. It uses plain snapshots with lower-case fields, unlike Player and Part wrappers. Calls return directly. Player snapshots include userId, username, position, health, maxHealth, speed, score and alive; brick snapshots include id, name, position, scale and color.
Deprecated compatibility events. Prefer the supported Players, RunService and remote signals for new code. Existing scripts can subscribe with Bridge.on("eventName", callback). Arguments are listed below. playerDied and playerRespawn require lifecycle support from the running game host.
Deprecated compatibility storage. Prefer DataStoreService for new data, but named stores use separate namespaces: existing Bridge keys are not automatically migrated. Persistent values are scoped to the game. Guest player data is process-local and disappears when the game stops. Read/write pairs are not an atomic increment; handle failures with pcall.
Deprecated compatibility badge calls, retained for existing hosted scripts. Uses badges configured for the game. Local playtests and guests do not award account-backed items. Do not infer native-preview support from this compatibility reference.
math Hosted server@if (!empty($entry['deprecated'])) · Deprecated compatibility@endif
Hosted math library. Call functions with a dot, for example math.abs(...). Hosted strings use byte positions; use utf8 for Unicode code points. Desktop bulk-operation limits do not apply to native hosted functions.
Global table.create/find/clone/clear/move/concat and table.unpack have portable entry/result limits. Global string.rep/split have portable output/input limits. Hosted native string method syntax such as value:rep resolves the readonly native metatable and does not use these wrappers. Other native library operations and operators are not newly bounded.
Literal separator split; empty separator splits bytes. Global wrapper caps input at 1 MiB and results at 100,000. Native method syntax has different limits.
Global table.create/find/clone/clear/move/concat and table.unpack have portable entry/result limits. Global string.rep/split have portable output/input limits. Hosted native string method syntax such as value:rep resolves the readonly native metatable and does not use these wrappers. Other native library operations and operators are not newly bounded.
Hosted coroutine library. Call functions with a dot, for example coroutine.close(...). Hosted strings use byte positions; use utf8 for Unicode code points. Desktop bulk-operation limits do not apply to native hosted functions.
Hosted bit32 library. Call functions with a dot, for example bit32.arshift(...). Hosted strings use byte positions; use utf8 for Unicode code points. Desktop bulk-operation limits do not apply to native hosted functions.
os Hosted server@if (!empty($entry['deprecated'])) · Deprecated compatibility@endif
Hosted os library. Call functions with a dot, for example os.clock(...). Hosted strings use byte positions; use utf8 for Unicode code points. Desktop bulk-operation limits do not apply to native hosted functions.
Hosted utf8 library. Call functions with a dot, for example utf8.char(...). Hosted strings use byte positions; use utf8 for Unicode code points. Desktop bulk-operation limits do not apply to native hosted functions.
Stable Instance graph identity, parent-cycle checks, recursive clone/delete, authored folder/model imports and snapshot/delta replication. 20,000 nodes with bounded hierarchy depth. Workspace and ReplicatedStorage replicate. ServerStorage and detached physical parts are excluded from both graph snapshots and legacy map transport; private edits are not broadcast. Moving an already public object into ServerStorage cannot erase information previously sent to clients.
Reparent within this game. Nil detaches; self/descendant cycles are rejected.
Model Hosted server@if (!empty($entry['deprecated'])) · Deprecated compatibility@endif
Hosted and desktop grouped PivotTo preserve complete CFrame translation, pitch, yaw and roll, including nested model pivots and clones. The client applies the replicated basis to visual and collision geometry. Hosted raycast/overlap/touch queries use oriented boxes. Opt-in part physics supports boxes and uniform spheres separately; grouped pivots do not create joints or constrained assemblies.
Authenticated RemoteFunction client InvokeServer and server InvokeClient support yielding callbacks, multiple/nil results, 10-second timeout, pending-call bounds and disconnect cleanup. Versioned values carry replicated graph Instance, Player and server GUI element identities inside arrays/string-keyed maps without interpreting ordinary tag-shaped user tables. Unreplicated, deleted, not-yet-resolved and another player's private GUI references become nil. GUI roots and client-only instances are not transferable. Visually hidden objects remain referenceable when their tree is replicated. Functions, cycles and mixed-key maps are rejected. Instance RemoteEvent uses the same typed codec and access checks; the older named RemoteEvents service remains plain JSON.
Authenticated RemoteFunction client InvokeServer and server InvokeClient support yielding callbacks, multiple/nil results, 10-second timeout, pending-call bounds and disconnect cleanup. Versioned values carry replicated graph Instance, Player and server GUI element identities inside arrays/string-keyed maps without interpreting ordinary tag-shaped user tables. Unreplicated, deleted, not-yet-resolved and another player's private GUI references become nil. GUI roots and client-only instances are not transferable. Visually hidden objects remain referenceable when their tree is replicated. Functions, cycles and mixed-key maps are rejected. Instance RemoteEvent uses the same typed codec and access checks; the older named RemoteEvents service remains plain JSON.
Authenticated RemoteFunction client InvokeServer and server InvokeClient support yielding callbacks, multiple/nil results, 10-second timeout, pending-call bounds and disconnect cleanup. Versioned values carry replicated graph Instance, Player and server GUI element identities inside arrays/string-keyed maps without interpreting ordinary tag-shaped user tables. Unreplicated, deleted, not-yet-resolved and another player's private GUI references become nil. GUI roots and client-only instances are not transferable. Visually hidden objects remain referenceable when their tree is replicated. Functions, cycles and mixed-key maps are rejected. Instance RemoteEvent uses the same typed codec and access checks; the older named RemoteEvents service remains plain JSON.
Supported graph classes expose lifecycle, property and attribute signals; server GUI objects have their separate, narrower event surface. ValueBase Changed receives the new value; other Changed signals receive the property name. Hosted events run on the deferred script scheduler. Attributes are capped at 128 entries with finite scalar/string/Vector3/Color3/CFrame values. Up to 2048 destroyed graph instances retain readonly tombstones for queued callbacks, not mutable access. Bindable events/functions cross server script VMs using bounded plain data and Instance references; functions cannot be passed as arguments. Hosted BindableFunction has a 10-second timeout.
Supported graph classes expose lifecycle, property and attribute signals; server GUI objects have their separate, narrower event surface. ValueBase Changed receives the new value; other Changed signals receive the property name. Hosted events run on the deferred script scheduler. Attributes are capped at 128 entries with finite scalar/string/Vector3/Color3/CFrame values. Up to 2048 destroyed graph instances retain readonly tombstones for queued callbacks, not mutable access. Bindable events/functions cross server script VMs using bounded plain data and Instance references; functions cannot be passed as arguments. Hosted BindableFunction has a 10-second timeout.
Named/scoped standard and ordered stores, GetAsync/SetAsync/RemoveAsync/IncrementAsync/UpdateAsync, standard GetVersionAsync/ListVersionsAsync/RemoveVersionAsync and ordered GetSortedAsync. Versions retain mutation history and deletion tombstones; pages contain 1–100 rows. Ordered values must be safe integers; live keyset pages are not snapshot-stable during concurrent score changes. Existing SetAsync value return is preserved. Hosted CAS UpdateAsync retries at most 8 times and rejects yielding transforms. 4 MiB/value, depth64, 255-byte keys, 64 pending calls, budget600/minute burst120. Website migration is required. Studio persists locally; local host stores are ephemeral. Player clients cannot access storage directly.
Named/scoped standard and ordered stores, GetAsync/SetAsync/RemoveAsync/IncrementAsync/UpdateAsync, standard GetVersionAsync/ListVersionsAsync/RemoveVersionAsync and ordered GetSortedAsync. Versions retain mutation history and deletion tombstones; pages contain 1–100 rows. Ordered values must be safe integers; live keyset pages are not snapshot-stable during concurrent score changes. Existing SetAsync value return is preserved. Hosted CAS UpdateAsync retries at most 8 times and rejects yielding transforms. 4 MiB/value, depth64, 255-byte keys, 64 pending calls, budget600/minute burst120. Website migration is required. Studio persists locally; local host stores are ephemeral. Player clients cannot access storage directly.
ScreenGui/Frame/TextLabel/TextButton/ImageLabel/ImageButton/TextBox/ScrollingFrame plus UIListLayout/UIPadding/UISizeConstraint/UIAspectRatioConstraint. Hosted player.PlayerGui is a private tree; StarterGui remains a live all-player UI source. Desktop local scripts use game.PlayerGui. FocusLost(enterPressed, nil, player) updates Text before invoking handlers with the authenticated private-tree owner or shared-tree viewer. Buttons and text inputs validate visibility and ancestry, but game rules still require server validation. Private trees are destroyed on player disconnect. Late-join snapshots, edits, reparenting and removal are supported below core menus. The 512-node cap is shared across the entire game, not per player; depth 64 and 4096 UTF-8 bytes per Text value. Only button activation and TextBox FocusLost are uplinked; hosted GUI signals expose Connect/Disconnect, not Once/Wait or graph lifecycle/attribute signals. Images require HTTPS URLs. Advanced flex/grid/wrapping, GUI tweens and automatic StarterGui template cloning remain separate features.
Supported graph classes expose lifecycle, property and attribute signals; server GUI objects have their separate, narrower event surface. ValueBase Changed receives the new value; other Changed signals receive the property name. Hosted events run on the deferred script scheduler. Attributes are capped at 128 entries with finite scalar/string/Vector3/Color3/CFrame values. Up to 2048 destroyed graph instances retain readonly tombstones for queued callbacks, not mutable access. Bindable events/functions cross server script VMs using bounded plain data and Instance references; functions cannot be passed as arguments. Hosted BindableFunction has a 10-second timeout.
Supported graph classes expose lifecycle, property and attribute signals; server GUI objects have their separate, narrower event surface. ValueBase Changed receives the new value; other Changed signals receive the property name. Hosted events run on the deferred script scheduler. Attributes are capped at 128 entries with finite scalar/string/Vector3/Color3/CFrame values. Up to 2048 destroyed graph instances retain readonly tombstones for queued callbacks, not mutable access. Bindable events/functions cross server script VMs using bounded plain data and Instance references; functions cannot be passed as arguments. Hosted BindableFunction has a 10-second timeout.
Supported graph classes expose lifecycle, property and attribute signals; server GUI objects have their separate, narrower event surface. ValueBase Changed receives the new value; other Changed signals receive the property name. Hosted events run on the deferred script scheduler. Attributes are capped at 128 entries with finite scalar/string/Vector3/Color3/CFrame values. Up to 2048 destroyed graph instances retain readonly tombstones for queued callbacks, not mutable access. Bindable events/functions cross server script VMs using bounded plain data and Instance references; functions cannot be passed as arguments. Hosted BindableFunction has a 10-second timeout.
Supported graph classes expose lifecycle, property and attribute signals; server GUI objects have their separate, narrower event surface. ValueBase Changed receives the new value; other Changed signals receive the property name. Hosted events run on the deferred script scheduler. Attributes are capped at 128 entries with finite scalar/string/Vector3/Color3/CFrame values. Up to 2048 destroyed graph instances retain readonly tombstones for queued callbacks, not mutable access. Bindable events/functions cross server script VMs using bounded plain data and Instance references; functions cannot be passed as arguments. Hosted BindableFunction has a 10-second timeout.
Supported graph classes expose lifecycle, property and attribute signals; server GUI objects have their separate, narrower event surface. ValueBase Changed receives the new value; other Changed signals receive the property name. Hosted events run on the deferred script scheduler. Attributes are capped at 128 entries with finite scalar/string/Vector3/Color3/CFrame values. Up to 2048 destroyed graph instances retain readonly tombstones for queued callbacks, not mutable access. Bindable events/functions cross server script VMs using bounded plain data and Instance references; functions cannot be passed as arguments. Hosted BindableFunction has a 10-second timeout.
A graph Instance or nil, not a Player or GUI object. Clone retargets references to cloned descendants. Unreplicated targets are hidden from client-facing records.
Supported graph classes expose lifecycle, property and attribute signals; server GUI objects have their separate, narrower event surface. ValueBase Changed receives the new value; other Changed signals receive the property name. Hosted events run on the deferred script scheduler. Attributes are capped at 128 entries with finite scalar/string/Vector3/Color3/CFrame values. Up to 2048 destroyed graph instances retain readonly tombstones for queued callbacks, not mutable access. Bindable events/functions cross server script VMs using bounded plain data and Instance references; functions cannot be passed as arguments. Hosted BindableFunction has a 10-second timeout.
Supported graph classes expose lifecycle, property and attribute signals; server GUI objects have their separate, narrower event surface. ValueBase Changed receives the new value; other Changed signals receive the property name. Hosted events run on the deferred script scheduler. Attributes are capped at 128 entries with finite scalar/string/Vector3/Color3/CFrame values. Up to 2048 destroyed graph instances retain readonly tombstones for queued callbacks, not mutable access. Bindable events/functions cross server script VMs using bounded plain data and Instance references; functions cannot be passed as arguments. Hosted BindableFunction has a 10-second timeout.
Supported graph classes expose lifecycle, property and attribute signals; server GUI objects have their separate, narrower event surface. ValueBase Changed receives the new value; other Changed signals receive the property name. Hosted events run on the deferred script scheduler. Attributes are capped at 128 entries with finite scalar/string/Vector3/Color3/CFrame values. Up to 2048 destroyed graph instances retain readonly tombstones for queued callbacks, not mutable access. Bindable events/functions cross server script VMs using bounded plain data and Instance references; functions cannot be passed as arguments. Hosted BindableFunction has a 10-second timeout.
ScreenGui/Frame/TextLabel/TextButton/ImageLabel/ImageButton/TextBox/ScrollingFrame plus UIListLayout/UIPadding/UISizeConstraint/UIAspectRatioConstraint. Hosted player.PlayerGui is a private tree; StarterGui remains a live all-player UI source. Desktop local scripts use game.PlayerGui. FocusLost(enterPressed, nil, player) updates Text before invoking handlers with the authenticated private-tree owner or shared-tree viewer. Buttons and text inputs validate visibility and ancestry, but game rules still require server validation. Private trees are destroyed on player disconnect. Late-join snapshots, edits, reparenting and removal are supported below core menus. The 512-node cap is shared across the entire game, not per player; depth 64 and 4096 UTF-8 bytes per Text value. Only button activation and TextBox FocusLost are uplinked; hosted GUI signals expose Connect/Disconnect, not Once/Wait or graph lifecycle/attribute signals. Images require HTTPS URLs. Advanced flex/grid/wrapping, GUI tweens and automatic StarterGui template cloning remain separate features.
ScreenGui parents to StarterGui or a player.PlayerGui root; other GUI nodes parent below a ScreenGui. Nil detaches. Cycles and excessive depth are rejected.
ScreenGui/Frame/TextLabel/TextButton/ImageLabel/ImageButton/TextBox/ScrollingFrame plus UIListLayout/UIPadding/UISizeConstraint/UIAspectRatioConstraint. Hosted player.PlayerGui is a private tree; StarterGui remains a live all-player UI source. Desktop local scripts use game.PlayerGui. FocusLost(enterPressed, nil, player) updates Text before invoking handlers with the authenticated private-tree owner or shared-tree viewer. Buttons and text inputs validate visibility and ancestry, but game rules still require server validation. Private trees are destroyed on player disconnect. Late-join snapshots, edits, reparenting and removal are supported below core menus. The 512-node cap is shared across the entire game, not per player; depth 64 and 4096 UTF-8 bytes per Text value. Only button activation and TextBox FocusLost are uplinked; hosted GUI signals expose Connect/Disconnect, not Once/Wait or graph lifecycle/attribute signals. Images require HTTPS URLs. Advanced flex/grid/wrapping, GUI tweens and automatic StarterGui template cloning remain separate features.
ScreenGui parents to StarterGui or a player.PlayerGui root; other GUI nodes parent below a ScreenGui. Nil detaches. Cycles and excessive depth are rejected.
ScreenGui/Frame/TextLabel/TextButton/ImageLabel/ImageButton/TextBox/ScrollingFrame plus UIListLayout/UIPadding/UISizeConstraint/UIAspectRatioConstraint. Hosted player.PlayerGui is a private tree; StarterGui remains a live all-player UI source. Desktop local scripts use game.PlayerGui. FocusLost(enterPressed, nil, player) updates Text before invoking handlers with the authenticated private-tree owner or shared-tree viewer. Buttons and text inputs validate visibility and ancestry, but game rules still require server validation. Private trees are destroyed on player disconnect. Late-join snapshots, edits, reparenting and removal are supported below core menus. The 512-node cap is shared across the entire game, not per player; depth 64 and 4096 UTF-8 bytes per Text value. Only button activation and TextBox FocusLost are uplinked; hosted GUI signals expose Connect/Disconnect, not Once/Wait or graph lifecycle/attribute signals. Images require HTTPS URLs. Advanced flex/grid/wrapping, GUI tweens and automatic StarterGui template cloning remain separate features.
ScreenGui parents to StarterGui or a player.PlayerGui root; other GUI nodes parent below a ScreenGui. Nil detaches. Cycles and excessive depth are rejected.
ScreenGui/Frame/TextLabel/TextButton/ImageLabel/ImageButton/TextBox/ScrollingFrame plus UIListLayout/UIPadding/UISizeConstraint/UIAspectRatioConstraint. Hosted player.PlayerGui is a private tree; StarterGui remains a live all-player UI source. Desktop local scripts use game.PlayerGui. FocusLost(enterPressed, nil, player) updates Text before invoking handlers with the authenticated private-tree owner or shared-tree viewer. Buttons and text inputs validate visibility and ancestry, but game rules still require server validation. Private trees are destroyed on player disconnect. Late-join snapshots, edits, reparenting and removal are supported below core menus. The 512-node cap is shared across the entire game, not per player; depth 64 and 4096 UTF-8 bytes per Text value. Only button activation and TextBox FocusLost are uplinked; hosted GUI signals expose Connect/Disconnect, not Once/Wait or graph lifecycle/attribute signals. Images require HTTPS URLs. Advanced flex/grid/wrapping, GUI tweens and automatic StarterGui template cloning remain separate features.
ScreenGui parents to StarterGui or a player.PlayerGui root; other GUI nodes parent below a ScreenGui. Nil detaches. Cycles and excessive depth are rejected.
ScreenGui/Frame/TextLabel/TextButton/ImageLabel/ImageButton/TextBox/ScrollingFrame plus UIListLayout/UIPadding/UISizeConstraint/UIAspectRatioConstraint. Hosted player.PlayerGui is a private tree; StarterGui remains a live all-player UI source. Desktop local scripts use game.PlayerGui. FocusLost(enterPressed, nil, player) updates Text before invoking handlers with the authenticated private-tree owner or shared-tree viewer. Buttons and text inputs validate visibility and ancestry, but game rules still require server validation. Private trees are destroyed on player disconnect. Late-join snapshots, edits, reparenting and removal are supported below core menus. The 512-node cap is shared across the entire game, not per player; depth 64 and 4096 UTF-8 bytes per Text value. Only button activation and TextBox FocusLost are uplinked; hosted GUI signals expose Connect/Disconnect, not Once/Wait or graph lifecycle/attribute signals. Images require HTTPS URLs. Advanced flex/grid/wrapping, GUI tweens and automatic StarterGui template cloning remain separate features.
ScreenGui parents to StarterGui or a player.PlayerGui root; other GUI nodes parent below a ScreenGui. Nil detaches. Cycles and excessive depth are rejected.
ScreenGui/Frame/TextLabel/TextButton/ImageLabel/ImageButton/TextBox/ScrollingFrame plus UIListLayout/UIPadding/UISizeConstraint/UIAspectRatioConstraint. Hosted player.PlayerGui is a private tree; StarterGui remains a live all-player UI source. Desktop local scripts use game.PlayerGui. FocusLost(enterPressed, nil, player) updates Text before invoking handlers with the authenticated private-tree owner or shared-tree viewer. Buttons and text inputs validate visibility and ancestry, but game rules still require server validation. Private trees are destroyed on player disconnect. Late-join snapshots, edits, reparenting and removal are supported below core menus. The 512-node cap is shared across the entire game, not per player; depth 64 and 4096 UTF-8 bytes per Text value. Only button activation and TextBox FocusLost are uplinked; hosted GUI signals expose Connect/Disconnect, not Once/Wait or graph lifecycle/attribute signals. Images require HTTPS URLs. Advanced flex/grid/wrapping, GUI tweens and automatic StarterGui template cloning remain separate features.
ScreenGui parents to StarterGui or a player.PlayerGui root; other GUI nodes parent below a ScreenGui. Nil detaches. Cycles and excessive depth are rejected.
ScreenGui/Frame/TextLabel/TextButton/ImageLabel/ImageButton/TextBox/ScrollingFrame plus UIListLayout/UIPadding/UISizeConstraint/UIAspectRatioConstraint. Hosted player.PlayerGui is a private tree; StarterGui remains a live all-player UI source. Desktop local scripts use game.PlayerGui. FocusLost(enterPressed, nil, player) updates Text before invoking handlers with the authenticated private-tree owner or shared-tree viewer. Buttons and text inputs validate visibility and ancestry, but game rules still require server validation. Private trees are destroyed on player disconnect. Late-join snapshots, edits, reparenting and removal are supported below core menus. The 512-node cap is shared across the entire game, not per player; depth 64 and 4096 UTF-8 bytes per Text value. Only button activation and TextBox FocusLost are uplinked; hosted GUI signals expose Connect/Disconnect, not Once/Wait or graph lifecycle/attribute signals. Images require HTTPS URLs. Advanced flex/grid/wrapping, GUI tweens and automatic StarterGui template cloning remain separate features.
ScreenGui parents to StarterGui or a player.PlayerGui root; other GUI nodes parent below a ScreenGui. Nil detaches. Cycles and excessive depth are rejected.
TextBox Text is updated first. Enter sets true; ordinary blur sets false. The sender must own the private tree or be viewing shared StarterGui. Only Connect/Disconnect are exposed on hosted GUI signals.
ScreenGui/Frame/TextLabel/TextButton/ImageLabel/ImageButton/TextBox/ScrollingFrame plus UIListLayout/UIPadding/UISizeConstraint/UIAspectRatioConstraint. Hosted player.PlayerGui is a private tree; StarterGui remains a live all-player UI source. Desktop local scripts use game.PlayerGui. FocusLost(enterPressed, nil, player) updates Text before invoking handlers with the authenticated private-tree owner or shared-tree viewer. Buttons and text inputs validate visibility and ancestry, but game rules still require server validation. Private trees are destroyed on player disconnect. Late-join snapshots, edits, reparenting and removal are supported below core menus. The 512-node cap is shared across the entire game, not per player; depth 64 and 4096 UTF-8 bytes per Text value. Only button activation and TextBox FocusLost are uplinked; hosted GUI signals expose Connect/Disconnect, not Once/Wait or graph lifecycle/attribute signals. Images require HTTPS URLs. Advanced flex/grid/wrapping, GUI tweens and automatic StarterGui template cloning remain separate features.
ScreenGui parents to StarterGui or a player.PlayerGui root; other GUI nodes parent below a ScreenGui. Nil detaches. Cycles and excessive depth are rejected.
ScreenGui/Frame/TextLabel/TextButton/ImageLabel/ImageButton/TextBox/ScrollingFrame plus UIListLayout/UIPadding/UISizeConstraint/UIAspectRatioConstraint. Hosted player.PlayerGui is a private tree; StarterGui remains a live all-player UI source. Desktop local scripts use game.PlayerGui. FocusLost(enterPressed, nil, player) updates Text before invoking handlers with the authenticated private-tree owner or shared-tree viewer. Buttons and text inputs validate visibility and ancestry, but game rules still require server validation. Private trees are destroyed on player disconnect. Late-join snapshots, edits, reparenting and removal are supported below core menus. The 512-node cap is shared across the entire game, not per player; depth 64 and 4096 UTF-8 bytes per Text value. Only button activation and TextBox FocusLost are uplinked; hosted GUI signals expose Connect/Disconnect, not Once/Wait or graph lifecycle/attribute signals. Images require HTTPS URLs. Advanced flex/grid/wrapping, GUI tweens and automatic StarterGui template cloning remain separate features.
ScreenGui parents to StarterGui or a player.PlayerGui root; other GUI nodes parent below a ScreenGui. Nil detaches. Cycles and excessive depth are rejected.
ScreenGui/Frame/TextLabel/TextButton/ImageLabel/ImageButton/TextBox/ScrollingFrame plus UIListLayout/UIPadding/UISizeConstraint/UIAspectRatioConstraint. Hosted player.PlayerGui is a private tree; StarterGui remains a live all-player UI source. Desktop local scripts use game.PlayerGui. FocusLost(enterPressed, nil, player) updates Text before invoking handlers with the authenticated private-tree owner or shared-tree viewer. Buttons and text inputs validate visibility and ancestry, but game rules still require server validation. Private trees are destroyed on player disconnect. Late-join snapshots, edits, reparenting and removal are supported below core menus. The 512-node cap is shared across the entire game, not per player; depth 64 and 4096 UTF-8 bytes per Text value. Only button activation and TextBox FocusLost are uplinked; hosted GUI signals expose Connect/Disconnect, not Once/Wait or graph lifecycle/attribute signals. Images require HTTPS URLs. Advanced flex/grid/wrapping, GUI tweens and automatic StarterGui template cloning remain separate features.
ScreenGui parents to StarterGui or a player.PlayerGui root; other GUI nodes parent below a ScreenGui. Nil detaches. Cycles and excessive depth are rejected.
ScreenGui/Frame/TextLabel/TextButton/ImageLabel/ImageButton/TextBox/ScrollingFrame plus UIListLayout/UIPadding/UISizeConstraint/UIAspectRatioConstraint. Hosted player.PlayerGui is a private tree; StarterGui remains a live all-player UI source. Desktop local scripts use game.PlayerGui. FocusLost(enterPressed, nil, player) updates Text before invoking handlers with the authenticated private-tree owner or shared-tree viewer. Buttons and text inputs validate visibility and ancestry, but game rules still require server validation. Private trees are destroyed on player disconnect. Late-join snapshots, edits, reparenting and removal are supported below core menus. The 512-node cap is shared across the entire game, not per player; depth 64 and 4096 UTF-8 bytes per Text value. Only button activation and TextBox FocusLost are uplinked; hosted GUI signals expose Connect/Disconnect, not Once/Wait or graph lifecycle/attribute signals. Images require HTTPS URLs. Advanced flex/grid/wrapping, GUI tweens and automatic StarterGui template cloning remain separate features.
ScreenGui parents to StarterGui or a player.PlayerGui root; other GUI nodes parent below a ScreenGui. Nil detaches. Cycles and excessive depth are rejected.
ScreenGui/Frame/TextLabel/TextButton/ImageLabel/ImageButton/TextBox/ScrollingFrame plus UIListLayout/UIPadding/UISizeConstraint/UIAspectRatioConstraint. Hosted player.PlayerGui is a private tree; StarterGui remains a live all-player UI source. Desktop local scripts use game.PlayerGui. FocusLost(enterPressed, nil, player) updates Text before invoking handlers with the authenticated private-tree owner or shared-tree viewer. Buttons and text inputs validate visibility and ancestry, but game rules still require server validation. Private trees are destroyed on player disconnect. Late-join snapshots, edits, reparenting and removal are supported below core menus. The 512-node cap is shared across the entire game, not per player; depth 64 and 4096 UTF-8 bytes per Text value. Only button activation and TextBox FocusLost are uplinked; hosted GUI signals expose Connect/Disconnect, not Once/Wait or graph lifecycle/attribute signals. Images require HTTPS URLs. Advanced flex/grid/wrapping, GUI tweens and automatic StarterGui template cloning remain separate features.
ScreenGui parents to StarterGui or a player.PlayerGui root; other GUI nodes parent below a ScreenGui. Nil detaches. Cycles and excessive depth are rejected.
ScreenGui/Frame/TextLabel/TextButton/ImageLabel/ImageButton/TextBox/ScrollingFrame plus UIListLayout/UIPadding/UISizeConstraint/UIAspectRatioConstraint. Hosted player.PlayerGui is a private tree; StarterGui remains a live all-player UI source. Desktop local scripts use game.PlayerGui. FocusLost(enterPressed, nil, player) updates Text before invoking handlers with the authenticated private-tree owner or shared-tree viewer. Buttons and text inputs validate visibility and ancestry, but game rules still require server validation. Private trees are destroyed on player disconnect. Late-join snapshots, edits, reparenting and removal are supported below core menus. The 512-node cap is shared across the entire game, not per player; depth 64 and 4096 UTF-8 bytes per Text value. Only button activation and TextBox FocusLost are uplinked; hosted GUI signals expose Connect/Disconnect, not Once/Wait or graph lifecycle/attribute signals. Images require HTTPS URLs. Advanced flex/grid/wrapping, GUI tweens and automatic StarterGui template cloning remain separate features.
Hosted and desktop grouped PivotTo preserve complete CFrame translation, pitch, yaw and roll, including nested model pivots and clones. The client applies the replicated basis to visual and collision geometry. Hosted raycast/overlap/touch queries use oriented boxes. Opt-in part physics supports boxes and uniform spheres separately; grouped pivots do not create joints or constrained assemblies.
Construct identity, from a Vector3, from x/y/z, from position and target Vector3s, from x/y/z plus quaternion x/y/z/w, or from x/y/z plus nine row-major rotation entries.
Workspace Raycast/GetPartBoundsInBox query published Workspace part oriented bounds in Y-up coordinates, with Include/Exclude descendant filters and optional RespectCanCollide. GetTouchingParts returns only collidable overlapping Workspace parts and requires the source to be collidable; Touched/TouchEnded additionally report live players. TouchEnded may pass nil if the other instance was destroyed or player disconnected. MaxParts 0 uses the 20,000 graph cap; filter lists <=256, watched parts <=256, touch polling targets 20 Hz without substeps. Only Default collision group; IgnoreWater has no effect because there is no water geometry. Invisible replicated parts remain queryable. Meshes/wedges use bounds, not triangle-accurate geometry. Fast motion between polls can be missed.
Workspace Raycast/GetPartBoundsInBox query published Workspace part oriented bounds in Y-up coordinates, with Include/Exclude descendant filters and optional RespectCanCollide. GetTouchingParts returns only collidable overlapping Workspace parts and requires the source to be collidable; Touched/TouchEnded additionally report live players. TouchEnded may pass nil if the other instance was destroyed or player disconnected. MaxParts 0 uses the 20,000 graph cap; filter lists <=256, watched parts <=256, touch polling targets 20 Hz without substeps. Only Default collision group; IgnoreWater has no effect because there is no water geometry. Invisible replicated parts remain queryable. Meshes/wedges use bounds, not triangle-accurate geometry. Fast motion between polls can be missed.
Workspace Raycast/GetPartBoundsInBox query published Workspace part oriented bounds in Y-up coordinates, with Include/Exclude descendant filters and optional RespectCanCollide. GetTouchingParts returns only collidable overlapping Workspace parts and requires the source to be collidable; Touched/TouchEnded additionally report live players. TouchEnded may pass nil if the other instance was destroyed or player disconnected. MaxParts 0 uses the 20,000 graph cap; filter lists <=256, watched parts <=256, touch polling targets 20 Hz without substeps. Only Default collision group; IgnoreWater has no effect because there is no water geometry. Invisible replicated parts remain queryable. Meshes/wedges use bounds, not triangle-accurate geometry. Fast motion between polls can be missed.
These limits come from the release capabilities. Handle rejected operations and check optional results before using them.
serviceBindings
Standard hosted services do not depend on the public Bridge global. Bridge remains a deprecated compatibility API for existing server scripts. The native C++ preview and desktop runtimes have separate capability limits; this hosted catalog does not claim native or desktop parity.
chat
Server-only ChatService broadcasts and sends to connected Players or game Teams using chat/top/center/bottom channels. Text is at most 1024 UTF-8 bytes, with control characters other than tab/newline rejected. Display duration is 0..60 seconds. Chatted and CommandReceived carry the authenticated sender; reserved engine commands are not delivered. This does not add filtering or a moderation system.
teams
Session-local hosted Teams exposes listing, exact-name lookup, creation, membership queries and Player:GetTeam/SetTeam. Names are 1..64 visible UTF-8 bytes; colors accept Color3 or #RRGGBB. A game has at most 255 teams. Creation returns an existing same-name team without changing its color. Team views are readonly; deletion, neutral teams and TeamAdded/Removed signals are not implemented.
badges
Hosted BadgeService uses the game's authenticated badge endpoints. AwardBadge returns success/already_owned/item_granted; UserHasBadge returns a boolean; GetGameBadges returns the game's badge rows. User and badge IDs must be positive integers. Guests produce a no-op award and own no badges. Scripts cannot create badges or grant another game's badges.
legacyStorage
GetLegacyDataStore and GetLegacyPlayerDataStore explicitly open the existing raw global/player-key save namespaces, not the hashed named-store namespace. GetAsync/SetAsync/RemoveAsync preserve those keys; SetAsync validates JSON up to 1 MiB. Only the global handle has GetKeys(scope), which is the old unpaged key list. These adapters have no UpdateAsync, version history, atomic increments or pagination. New games should use named standard stores.
partClicks
Hosted Part.Clicked(player, secure) maps the existing published-part click event to an authenticated Player. Private/deleted parts are excluded. Disconnect releases the script subscription. The secure flag is legacy advisory information, not authorization: validate distance, cooldowns and game rules yourself.
partPhysics
Opt-in authoritative boxes/uniform spheres in the shared hosted and Studio playtest host; existing parts stay anchored. PhysicsService Configure/GetState/SetGravity, Part Anchored/AssemblyMass/AssemblyLinearVelocity/AssemblyAngularVelocity/ApplyImpulse/ApplyImpulseAtPosition. Y-up centre-space vectors. Up to 64 dynamic parts, 2048 static colliders plus finite baseplate; 120 Hz bounded integration and up to 20 Hz transform publication. Mass .01..10000, friction/restitution/damping 0..1. Sleeping, private/destroyed cleanup and late-join transforms supported. Authored partPhysics metadata works without scripts. No character pushing, constraints, mesh-triangle collision, continuous collision detection, moving-platform carry or standalone native-host solver.
npc
NPCService.CreateCharacter creates a server-owned native bot rendered through the animated character path. CreateRig creates a seven-part block Model with Health and MaxHealth values. Both controllers support damage, healing, MoveTo, FollowPlayer, Stop, Destroy and a Died signal. Each script is limited to eight NPCs and each game to 32 native bots. Movement replans against static horizontal obstacles; advanced combat decisions and dynamic physics are not implemented.
messaging
MessagingService carries game-scoped JSON between live hosted instances. Topics use 1–64 letters, digits, underscores, dots, colons or dashes; payloads are at most 4096 bytes. A game may publish 120 messages per minute. Instances poll approximately once per second; messages expire after two minutes. Delivery is best effort and messages published before an instance starts are not replayed. This is not a durable queue.
commerce
UserOwnsItem and UserOwnsPass check a connected account's item or game-pass ownership; guests return false. Ownership results cache for 10 seconds and share a 120-check/minute budget. Lookup failure raises an error. ProductReceipt delivers up to 100 pending game-scoped receipts per 5-second poll, including offline buyers, and retries unacknowledged receipts. Persist a grant idempotently using ReceiptId before AcknowledgeProductReceipt. Multiple instances may receive the same receipt. No automatic grant or acknowledgement occurs. Scripts cannot prompt purchases or charge currency. Website pass checkout and developer-product checkout have separate default-off settings. These APIs are for the hosted LuX runtime, not the native C++ preview.
navigation
FindPath plans a horizontal route through at most 2048 static rectangular parts within 256 studs, with a 4096-node search limit. Yaw-rotated rectangles are supported; slopes, vertical routes, moving-obstacle replanning and full-basis collision are not. FollowPart moves an existing Workspace part on the server at 10 updates/second, speed 0.5–32, with at most 16 active followers per script. NPCService creates a separate block rig and supports basic path-following; limb animation and combat behavior are not supported.
instanceEvents
Supported graph classes expose lifecycle, property and attribute signals; server GUI objects have their separate, narrower event surface. ValueBase Changed receives the new value; other Changed signals receive the property name. Hosted events run on the deferred script scheduler. Attributes are capped at 128 entries with finite scalar/string/Vector3/Color3/CFrame values. Up to 2048 destroyed graph instances retain readonly tombstones for queued callbacks, not mutable access. Bindable events/functions cross server script VMs using bounded plain data and Instance references; functions cannot be passed as arguments. Hosted BindableFunction has a 10-second timeout.
leaderstats
Server-authoritative named values, maximum 8 per player; names 32 characters, values 64 characters. Replicated and replayed on join; not persisted automatically. Uses explicit Player methods, not Instance Folder/Value objects.
heartbeatTargetHz
60
commandInput
ChatService.CommandReceived receives an existing client COMMAND packet as authenticated Player, command, args. Reserved engine commands are suppressed. Game scripts must still validate round state, distance, and cooldowns. Bridge.on('command') remains a legacy snapshot compatibility alias.
remoteEvents
RemoteEvents.OnServerEvent(name), FireClient and FireAllClients use authenticated player identity, event-name validation, and a 16 KiB JSON payload limit. Server scripts must validate ability state, distance and cooldowns.
soundAssets
SoundService accepts a first-party numeric asset ID or HTTPS URL. The client resolves numeric IDs through the BrickBit asset endpoint and enforces a 16 MiB download cap.
heartbeatScheduling
Measured elapsed dt; missed ticks skipped and queued ticks coalesced under load
collectionScope
Runtime Folder/Model/Part tags replicate to connected and late-joining clients. ServerStorage logical nodes/tags are excluded from graph snapshots. Changes are session state, not automatically saved in published maps. Maximum 32 tags per graph node.
hierarchy
Stable Instance graph identity, parent-cycle checks, recursive clone/delete, authored folder/model imports and snapshot/delta replication. 20,000 nodes with bounded hierarchy depth. Workspace and ReplicatedStorage replicate. ServerStorage and detached physical parts are excluded from both graph snapshots and legacy map transport; private edits are not broadcast. Moving an already public object into ServerStorage cannot erase information previously sent to clients.
vectors
Immutable Vector2/Vector3 values provide arithmetic, Dot, Lerp, Magnitude and Unit; Vector3 also provides Cross and componentwise multiply/divide. Hosted Part Position/Size retain legacy Bridge axis conventions; CFrame uses the desktop center-space convention.
colors
Color3.new/fromRGB return immutable r/g/b and R/G/B values. Part Color also accepts #RRGGBB strings.
debris
Workspace parts only. AddItem default lifetime is 10 seconds; repeated scheduling keeps the earliest deadline. Maximum 1000 pending parts. Deletion survives the scheduling script ending but stops with the game.
tweens
Workspace parts only: Position, Size, Color, Transparency and numeric yaw Rotation. Play/Pause/Cancel/Destroy, PlaybackState and Completed(state) are supported with delay, repeat and reverse. Maximum 256 retained tweens per script and 4096 per game; Destroy releases unused tweens. Conflicting properties cancel the older tween.
httpEnabled
false
jsonMaxBytes
1048576
jsonMaxDepth
32
timersPerScript
1024
listenersPerScript
1024
pendingEvents
1024
serverScriptsPerGame
128
scriptMaxBytes
1048576
moduleSourceMaxBytes
4194304
modelPivot
Hosted and desktop grouped PivotTo preserve complete CFrame translation, pitch, yaw and roll, including nested model pivots and clones. The client applies the replicated basis to visual and collision geometry. Hosted raycast/overlap/touch queries use oriented boxes. Opt-in part physics supports boxes and uniform spheres separately; grouped pivots do not create joints or constrained assemblies.
remoteFunctions
Authenticated RemoteFunction client InvokeServer and server InvokeClient support yielding callbacks, multiple/nil results, 10-second timeout, pending-call bounds and disconnect cleanup. Versioned values carry replicated graph Instance, Player and server GUI element identities inside arrays/string-keyed maps without interpreting ordinary tag-shaped user tables. Unreplicated, deleted, not-yet-resolved and another player's private GUI references become nil. GUI roots and client-only instances are not transferable. Visually hidden objects remain referenceable when their tree is replicated. Functions, cycles and mixed-key maps are rejected. Instance RemoteEvent uses the same typed codec and access checks; the older named RemoteEvents service remains plain JSON.
dataStores
Named/scoped standard and ordered stores, GetAsync/SetAsync/RemoveAsync/IncrementAsync/UpdateAsync, standard GetVersionAsync/ListVersionsAsync/RemoveVersionAsync and ordered GetSortedAsync. Versions retain mutation history and deletion tombstones; pages contain 1–100 rows. Ordered values must be safe integers; live keyset pages are not snapshot-stable during concurrent score changes. Existing SetAsync value return is preserved. Hosted CAS UpdateAsync retries at most 8 times and rejects yielding transforms. 4 MiB/value, depth64, 255-byte keys, 64 pending calls, budget600/minute burst120. Website migration is required. Studio persists locally; local host stores are ephemeral. Player clients cannot access storage directly.
serverGui
ScreenGui/Frame/TextLabel/TextButton/ImageLabel/ImageButton/TextBox/ScrollingFrame plus UIListLayout/UIPadding/UISizeConstraint/UIAspectRatioConstraint. Hosted player.PlayerGui is a private tree; StarterGui remains a live all-player UI source. Desktop local scripts use game.PlayerGui. FocusLost(enterPressed, nil, player) updates Text before invoking handlers with the authenticated private-tree owner or shared-tree viewer. Buttons and text inputs validate visibility and ancestry, but game rules still require server validation. Private trees are destroyed on player disconnect. Late-join snapshots, edits, reparenting and removal are supported below core menus. The 512-node cap is shared across the entire game, not per player; depth 64 and 4096 UTF-8 bytes per Text value. Only button activation and TextBox FocusLost are uplinked; hosted GUI signals expose Connect/Disconnect, not Once/Wait or graph lifecycle/attribute signals. Images require HTTPS URLs. Advanced flex/grid/wrapping, GUI tweens and automatic StarterGui template cloning remain separate features.
spatialQueries
Workspace Raycast/GetPartBoundsInBox query published Workspace part oriented bounds in Y-up coordinates, with Include/Exclude descendant filters and optional RespectCanCollide. GetTouchingParts returns only collidable overlapping Workspace parts and requires the source to be collidable; Touched/TouchEnded additionally report live players. TouchEnded may pass nil if the other instance was destroyed or player disconnected. MaxParts 0 uses the 20,000 graph cap; filter lists <=256, watched parts <=256, touch polling targets 20 Hz without substeps. Only Default collision group; IgnoreWater has no effect because there is no water geometry. Invisible replicated parts remain queryable. Meshes/wedges use bounds, not triangle-accurate geometry. Fast motion between polls can be missed.
Not yet shared across contexts
Classes not listed in the versioned capability contract and their inherited APIs/events
Standalone native-host rigid-body physics, joints/constraints, character pushing and mesh-triangle collision
Advanced GUI flex/grid/wrapping and automatic StarterGui template cloning
Platform-managed datastore retention, metadata and snapshot-stable ordered pagination
Unified autocomplete context schema for every runtime-only member