Luau in Roblox: Scripting Language, Docs and Engine vs Cloud API

18 August 2026 · 6 min read

GameMapa editorial · how we check facts
Checked: Claude (AI) — fact-checked against the Ukrainian original; not proofread by a native speaker

The language used to write logic in Roblox is called Luau — that’s the name given by the platform’s own official documentation. Not “a Lua-like language,” not “Roblox’s scripting language” in vague terms, but a specific name from a specific source: create.roblox.com/docs/luau.

This isn’t pedantry. When you’re looking for an answer to a technical question, the name is the key to the right reference. Search for one term and you land in the official section; search for another and you end up on decade-old forum threads.

Below is what’s actually known from the primary source about the language and its documentation, how Engine API differs from Cloud API, and — separately — what we’re not claiming here.

What’s actually known

There aren’t many facts here that can be backed by official documentation, and we’ll list them plainly, without padding:

• Roblox’s official documentation calls the platform’s scripting language Luau.
• The Luau documentation lives in a dedicated section — create.roblox.com/docs/luau.
• For scripts running inside an experience, Roblox maintains a separate Engine API reference.
• Cloud API is a different set of interfaces from Engine API, with its own documentation section.

Everything else you might read about Luau elsewhere — syntax, types, performance, history — we’re not repeating here, because we can’t back it with our sources. The right place for that is the documentation section itself.

Why the language gets its own section

The structure of the documentation tells you something useful on its own. If the language is documented separately from the Engine API reference, that points to two different layers of knowledge:

• The language is how you write code in general: constructs, rules, syntax.
• The API is what your code talks to: the platform’s objects and interfaces.

The practical upshot is simple. When something doesn’t work, first figure out which layer the problem is in. A mistake in how you’ve written the code belongs to the Luau section. “I don’t know how to reach a particular thing in the game” belongs to Engine API. Confusing the two layers is what eats the most time for beginners.

Engine API and Cloud API are not the same thing

The most common trap when reading examples found online: someone takes a code snippet from one part of the ecosystem and tries to apply it in another.

What this means in practice:

If you’re writing logic inside your own experience, your reference is Engine API. If an example you’ve found sits in the Cloud API section, it isn’t “broken” or “outdated” — it’s simply about something else. Copying it into an experience’s script won’t get you anywhere.

⚠️ What we’re not claiming here: we don’t describe what Cloud API is actually for, or what its capabilities and limits are. Our sources only tell us that it’s a different set of interfaces with its own documentation. Anything more specific — read in the section itself, not in a summary of it.

How to use the docs without wasting time

An order that saves hours:

1. Frame your question as “language” or “platform.” A question about how to write a construct belongs to Luau. A question about how to reach something in the game belongs to the API.
2. Open the official section, not a search engine. The starting point for the language is create.roblox.com/docs/luau; for everything else, create.roblox.com/docs.
3. Check which section an example lives in. Before copying code, check its “home”: Luau, Engine API, or Cloud API.
4. Cross-check third-party material against the official docs. Videos and articles are handy for a first pass, but the documentation is the primary source. When they disagree, the documentation wins.
5. Don’t read absence as an answer. If something isn’t in the documentation, that doesn’t mean “impossible” — it means “not described in the place you looked.”

What we’re deliberately not covering here

This piece is narrow on purpose. We’re not including:

• code snippets or “typical patterns” — they go stale faster than articles do;
• comparisons of Luau with other languages;
• any numbers: versions, dates, sizes, function counts. If a number isn’t in a verified source, it isn’t in this text;
• advice on “which language to learn first” — that’s a choice, not a fact.

If what you actually need is a practical starting point in the editor rather than background on the language, that’s a different topic, and we’ve covered it separately: your first steps in Roblox Studio.

Who actually needs Luau

Not players. To run other people’s experiences, a client, an account, and a device that can handle the game are enough — on that last point, see our guide on which devices run Roblox.

The language matters if you’re building something of your own: logic, rules, how objects behave in an experience — all of that is written as scripts. And if the goal isn’t just “build it for myself” but “get others to play it, and have that lead somewhere,” the next topic is payouts — DevEx and converting Robux.

Note the order here: language and documentation first, results after. Not the other way round. People who start with “how much can I earn from this” usually never get to a first working script.

In short

Roblox’s scripting language is called Luau, its documentation lives in a dedicated section at create.roblox.com/docs/luau, and Engine API (for scripts inside an experience) and Cloud API are different sets of interfaces with different documentation sections. Before copying someone else’s code example, check exactly which section it came from.