khtsly/Luau-Coder-1.0-0.5B-Base
Text Generation • 0.5B • Updated • 709 • 1
source large_stringlengths 17 66 | seed large_stringclasses 1
value | crawled_at timestamp[us, tz=UTC]date 2026-10-01 05:58:55 2026-10-01 05:58:59 | content large_stringlengths 52 88.5k | tokens int64 16 21.9k | content_hash large_stringlengths 64 64 |
|---|---|---|---|---|---|
https://luau.org/ | https://luau.org/ | 2026-10-01T05:58:55.360000 | 
# Luau
Luau (lowercase *u*, /ˈlu.aʊ/) is a small, fast, and embeddable programming language based on Lua with a gradual type system.
[Get Started](/getting-started/) [News](/news/) [Try Luau online](ht... | 622 | 3ed4d1c052611afe6cd10c0fe588f69f8906afc651a5a04af17d708dcdcd518a |
https://luau.org/news | https://luau.org/ | 2026-10-01T05:58:55.812000 | # News
The latest news from the Luau team! Stay up to date with new features, performance improvements, and language updates.
[Luau Recap for 2025: Runtime
Posted December 19, 2025](/news/2025-12-19-luau-recap-runtime-2025)[Recap: July 2024
Posted July 23, 2024](/news/2024-07-23-luau-recap-july-2024)[Recap: October... | 1,351 | fecd0cc7be6a9072b53d2fcea199fb19c5ce0ef1b8ad4d27f8788205efe3629d |
https://luau.org/syntax | https://luau.org/ | 2026-10-01T05:58:55.853000 | # Luau syntax by example
Luau uses the baseline [syntax of Lua 5.1](https://www.lua.org/manual/5.1/manual.html#2). For detailed documentation, please refer to the Lua manual, this is an example:
```luau
local function tree_insert(tree, x)
local lower, equal, greater = split(tree.root, x)
if not equal then
... | 3,716 | 7ff7ea0b3909817f0656e365eaa29e61c734d229053de3d4b8c66bf15bc1fcbb |
https://luau.org/types/type-functions | https://luau.org/ | 2026-10-01T05:58:55.896000 | # Type Functions
Type functions are functions that run during analysis time and operate on types, instead of runtime values. They can use the [types](../../types-library) library to transform existing types or create new ones.
Here’s a simplified implementation of the builtin type function `keyof`. It takes a table t... | 364 | 88d84679e351a90774ff47d25e0c58fbdd3f7af929540abc3da836caf4fdedae |
https://luau.org/types/type-refinements | https://luau.org/ | 2026-10-01T05:58:55.908000 | # Type Refinements
When we check the type of any lvalue (a global, a local, or a property), what we’re doing is we’re refining the type, hence “type refinement.” The support for this is arbitrarily complex, so go at it!
Here are all the ways you can refine:
1. Truthy test: `if x then` will refine `x` to be truthy.
2... | 659 | 97a389fe1728cc7816072a67401a92b536b2528cfadb4aae239cbeb2f7306c88 |
https://luau.org/types | https://luau.org/ | 2026-10-01T05:58:55.930000 | # An introduction to Luau types
Luau supports a gradual type system through the use of type annotations and type inference. These types are used to provide warnings, errors, and suggestions for our developers. Type checking helps you find bugs early - while you’re writing code - rather than discovering when your progr... | 1,327 | c44951788f294ee5c94dc45623df322993c60363e7332410f7c87c3054723afc |
https://luau.org/brand | https://luau.org/ | 2026-10-01T05:58:55.939000 | # Brand Guidelines
We want developers to build tools, libraries, runtimes, integrations, and other projects for (or with) Luau, to be able to clearly describe those projects as working with Luau. At the same time, people should be able to easily distinguish projects that are part of Luau itself from independent projec... | 923 | 09a216c8712db555603e374cb687b8d7be7aa61e0bd4bd5f888df82dacec5248 |
https://luau.org/getting-started | https://luau.org/ | 2026-10-01T05:58:55.950000 | # An introduction to Luau
Luau is a fast, small, safe, gradually typed embeddable scripting language derived from Lua 5.1. Luau ships as a command line tool for running, analyzing, and linting your Luau scripts, and is also integrated with Roblox Studio. Roblox developers should also visit our [Creator Docs Luau Secti... | 1,180 | b65b891a8f4db5575336190e096e0125275ed494396ec2404760d6a40379f4b8 |
https://luau.org/compatibility | https://luau.org/ | 2026-10-01T05:58:55.981000 | # Compatibility with Lua
Luau is based on Lua 5.1, and as such incorporates all features of 5.1, except for ones that had to be taken out due to sandboxing limitations. Because of backwards compatibility constraints, we don’t remove features deprecated by later versions (e.g. we still support `getfenv`/`setfenv`). Lat... | 3,107 | d71079653a304dc761c629db20069e1761080a49974ef4cbd8112690a0e8bdf2 |
https://luau.org/news/2025-12-19-luau-recap-runtime-2025 | https://luau.org/ | 2026-10-01T05:58:56.303000 | # Luau Recap for 2025: Runtime
December 19, 2025
Hello everyone!
It has been a while since the last recap and we wanted to go over changes we have made in Luau since the last update.
Because of the amount of time that passed, in this part of the recap, we are going to focus on the runtime changes: new library funct... | 2,921 | a557f6410224cfe4b14728498bb2dca478b8b2fee021430b7af364da395e87ad |
https://luau.org/news/2024-07-23-luau-recap-july-2024 | https://luau.org/ | 2026-10-01T05:58:56.340000 | # Recap: July 2024
July 23, 2024
Hello everyone!
While the Luau team is actively working on a big rewrite of the type inference and type checking engines (more news about that in the near future), we wanted to go over other changes and updates since our last recap back in October.
## Official Luau mascot
Luau has ... | 2,306 | 5fe93274612d2c848e3ed049dceeabb640146b28307db80d1255773b55de04e5 |
https://luau.org/news/2022-11-30-luau-recap-november-2022 | https://luau.org/ | 2026-10-01T05:58:56.380000 | # Recap: November 2022
November 30, 2022
While the team is busy to bring some bigger things in the future, we have made some small improvements this month.
## Analysis improvements
We have improved tagged union type refinements to only include unhandled type cases in the `else` branch of the `if` statement:
```lua... | 730 | 7a1e276982bc239c3fe8b3a956bf9b1400facf4007912004dd1f56d5b812c231 |
https://luau.org/news/2023-02-02-luau-string-interpolation | https://luau.org/ | 2026-10-01T05:58:56.391000 | # String Interpolation
February 2, 2023
String interpolation is the new syntax introduced to Luau that allows you to create a string literal with expressions inside of that string literal.
In short, it’s a safer and more ergonomic alternative over `string.format`.
Here’s a quick example of a string interpolation:
... | 287 | c83881998adf23967da1887ede790bb4da9c0d1272deffbbcd9d3b34b39c84e0 |
https://luau.org/news/2023-03-31-luau-recap-march-2023 | https://luau.org/ | 2026-10-01T05:58:56.404000 | # Recap: March 2023
March 31, 2023
How the time flies! The team has been busy since the last November Recap:working on some large updates that are coming in the future, but before those arrive, we have some improvements that you can already use!
## Improved type refinements
Type refinements handle constraints place... | 1,446 | 8202df5b61b85b10cccd9d4a24042ff8dbf256348e4dd4b58c398a4f04388178 |
https://luau.org/news/2023-11-01-luau-recap-october-2023 | https://luau.org/ | 2026-10-01T05:58:56.421000 | # Recap: October 2023
November 1, 2023
We’re still quite busy working on some big type checking updates that we hope to talk about soon, but we have a few equally exciting updates to share in the meantime!
Let’s dive in!
## Floor Division
Luau now has a floor division operator. It is spelled `//`:
```luau
local a... | 2,016 | ebdd1ff40abd0ae3c6f239bf77c4f294b2cbab9515b7acaf338f4a1565c15231 |
https://luau.org/news/2022-11-04-luau-origins-and-evolution | https://luau.org/ | 2026-10-01T05:58:56.445000 | # Luau origins and evolution
November 4, 2022
At the heart of Roblox technology lies [Luau](https://luau-lang.org), a scripting language derived from Lua 5.1 that is being [developed](https://github.com/Roblox/luau) by an internal team of programming language experts with the help of open source contributors.
It pow... | 4,388 | be0e933564c0d8b0f8d9a7a7da499caf79ee686463c84304ea26489ccd0501a8 |
https://luau.org/news/2023-07-28-luau-recap-july-2023 | https://luau.org/ | 2026-10-01T05:58:56.446000 | # Recap: July 2023
July 28, 2023
Our team is still spending a lot of time working on upcoming replacement for our type inference engine as well as working on native code generation to improve runtime performance.
However, we also worked on unrelated improvements during this time that are summarized here.
## Analysi... | 764 | 4abb04125d1464476722d3aa5d4aa4adb0428a561a2ba1b89f41b02c7eeef5f7 |
https://luau.org/news/2022-11-01-luau-recap-september-october-2022 | https://luau.org/ | 2026-10-01T05:58:56.761000 | # Recap: September & October 2022
November 1, 2022
## Semantic subtyping
One of the most important goals for Luau is to avoid *false
positives*, that is cases where Script Analysis reports a type error,
but in fact the code is correct. This is very frustrating, especially
for beginners. Spending time chasing down a ... | 665 | d76c0b2733e316e2eee83795328dd5e15e150b7e947bcf56e3da55645740f824 |
https://luau.org/news/2022-10-31-luau-semantic-subtyping | https://luau.org/ | 2026-10-01T05:58:56.788000 | # Semantic Subtyping in Luau
October 31, 2022
Luau is the first programming language to put the power of semantic subtyping in the hands of millions of creators.
## Minimizing false positives
One of the issues with type error reporting in tools like the Script Analysis widget in Roblox Studio is *false positives*. ... | 4,556 | 265cb1aeb7d8ffbef502b30b36f3771589fa8f4c3e9e0986f1c8cd15903848dd |
https://luau.org/news/2022-03-31-luau-recap-march-2022 | https://luau.org/ | 2026-10-01T05:58:56.890000 | # Recap: March 2022
March 31, 2022
## Singleton types
We added support for singleton types! These allow you to use string or
boolean literals in types. These types are only inhabited by the
literal, for example if a variable `x` has type `"foo"`, then `x == "foo"` is guaranteed to be true.
Singleton types are parti... | 778 | 94fd436e2c993f2aa0f37607c3a28dfeeec1fcb1c47da1be0887c1d248eb9efa |
https://luau.org/news/2022-07-07-luau-recap-june-2022 | https://luau.org/ | 2026-10-01T05:58:56.897000 | # Recap: June 2022
July 7, 2022
# Lower bounds calculation
A common problem that Luau has is that it primarily works by inspecting expressions in your program and narrowing the *upper bounds* of the values that can inhabit particular variables. In other words, each time we see a variable used, we eliminate possible ... | 867 | cdcd0669913eacf574f0f5d2011261e8a645c933c857a61dbb5983eaee11b307 |
https://luau.org/news/2022-06-01-luau-recap-may-2022 | https://luau.org/ | 2026-10-01T05:58:56.910000 | # Recap: May 2022
June 1, 2022
This month Luau team has worked to bring you a new language feature together with more typechecking improvements and bugfixes!
## Generalized iteration
We have extended the semantics of standard Lua syntax for iterating through containers, `for vars in values` with support for general... | 954 | bd39f92a76ce03a0f9c58ac4549a88ca9f9ef96a89e1f2991a8ac0c781da3935 |
https://luau.org/news/2022-02-28-luau-recap-february-2022 | https://luau.org/ | 2026-10-01T05:58:56.926000 | # Recap: February 2022
February 28, 2022
## Default type alias type parameters
We have introduced a syntax to provide default type arguments inside the type alias type parameter list.
It is now possible to have type functions where the instantiation can omit some type arguments.
You can provide concrete types:
``... | 1,194 | 841296d52cb543fa7e822f18f47a40b70f55acdf9b36f3c66c96269f0b9e31fa |
https://luau.org/news/2022-05-02-luau-recap-april-2022 | https://luau.org/ | 2026-10-01T05:58:56.937000 | # Recap: April 2022
May 2, 2022
It’s been a bit of a quiet month. We mostly have small optimizations and bugfixes for you.
It is now allowed to define functions on sealed tables that have string indexers. These functions will be typechecked against the indexer type. For example, the following is now valid:
```luau
... | 395 | 2d8e1b90729cc5c040d9c74402b6ad8f2bb50e915edb0387f790b61798850c4c |
https://luau.org/news/2022-08-29-luau-recap-august-2022 | https://luau.org/ | 2026-10-01T05:58:56.956000 | # Recap: July & August 2022
August 29, 2022
[Cross-posted to the [Roblox Developer Forum](https://devforum.roblox.com/t/luau-recap-july-august-2022/).]
## Tables now support `__len` metamethod
See the RFC [Support `__len` metamethod for tables and `rawlen` function](https://github.com/Roblox/luau/blob/master/rfcs/l... | 2,340 | 3ca6c97ca0e2d9f033aa46bcb79ace9ce1c54fb09dac7462a8849b532e13c0be |
https://luau.org/news/2022-01-27-luau-recap-january-2022 | https://luau.org/ | 2026-10-01T05:58:57.184000 | # Recap: January 2022
January 27, 2022
## Performance improvements
The implementation of `tostring` has been rewritten. This change replaces the default number->string conversion with a
new algorithm called Schubfach, which allows us to produce the shortest precise round-trippable representation of any
input number ... | 1,083 | 529752d241c54c5643f649db3fe0875d9bcc78d321db2112b1d31c3eac370b71 |
https://luau.org/news/2021-11-29-luau-recap-november-2021 | https://luau.org/ | 2026-10-01T05:58:57.247000 | # Recap: November 2021
November 29, 2021
## Type packs in type aliases
Type packs are the construct Luau uses to represent a sequence of types. We’ve had syntax for generic type packs for a while now, and it sees use in generic functions, but it hasn’t been available in type aliases. That has changed, and it is now ... | 1,145 | aae67945226e169a38bc6046d986fbc82f84d1f130816ebbd50babf1d4ff205d |
https://luau.org/news/2021-09-30-luau-recap-september-2021 | https://luau.org/ | 2026-10-01T05:58:57.356000 | # Recap: September 2021
September 30, 2021
## Generic functions
The big news this month is that generic functions are back!
Luau has always supported type inference for generic functions, for example:
```luau
type Point<X,Y> = { x: X, y: Y }
function swap(p)
return { x = p.y, y = p.x }
end
local p : Point<number... | 1,363 | 42a09cac85440fb5c28a02ec41abdf475bf4f0370cfb4cd4b1a55c8249a1f23d |
https://luau.org/news/2021-10-31-luau-recap-october-2021 | https://luau.org/ | 2026-10-01T05:58:57.373000 | # Recap: October 2021
October 31, 2021
## `if-then-else` expression
In addition to supporting standard if *statements*, Luau adds support for if *expressions*.
Syntactically, `if-then-else` expressions look very similar to if statements.
However instead of conditionally executing blocks of code, if expressions condi... | 1,457 | a6d9785364d56101fc95bb062e1b1861e8a1bb255df4f76a100742fcb42a3d24 |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 113
Models trained or fine-tuned on khtsly/luau-org-web-text