Changelog

2.0.2 stable 2026-10-12

A natively lowered @dream/intern lookup no longer reads a slot table the pool has freed, and the @dream/data definitions say what a span’s kind is.

Fixed

• Interning a key a pool already held, through the binder, while the pool sat at its load limit (12, 24, 48 … identities) grew the slot table before looking the key up, and did not tell native code the table had moved, because the pool’s length had not changed. Until the next new key, a lowered pool:find or pool:intern on an annotated dream_intern_Pool read the freed table: wrong tokens, nil for a key the pool held. A pool now looks a key up first and grows only to add one, so a key it holds moves nothing. Unannotated pools were never affected.
• The @dream/data definitions gave gather, scatter and add a kind: dream_data_Kind parameter, the union of receiver classes, where the runtime takes the layout string every other span takes; and they typed a span’s kind as the eight bare kinds, so the documented strided form ("f32@16+12") was a type error under --!strict. A span’s kind is now a dream_data_Layout, dream_data_ElementKind | string, in every signature, and the strict-script gate that checks the definitions against the runtime covers @dream/data, which it had left out.
• data.fill’s description said the value converts as buffer.write<kind> converts. It is written as every data-plane write is: a number, truncated toward zero and wrapped to the width, saturating first beyond 2^63. The description says so now; the behaviour is unchanged.

Migration

Nothing to change. A pool annotated dream_intern_Pool that also receives keys through unannotated code was the exposed case, and is correct after an upgrade. A strict script that cast a strided layout to pass it to @dream/data can drop the cast.

2.0.1 stable 2026-10-12

A sink or slice statement may open a function body, and the @dream/luau definitions declare the record pattern nodes the tree has carried since 2.0.0.

Fixed

• A statement that begins with a sink or a slice (into(out)[for x in xs => x], grid[2:3][1][1] = 5) failed to compile as the first statement of a function body, with Expected identifier when parsing expression, got ';': the lowering separated it from a statement that was not there. A body’s first statement now gets no separator, whatever the header ends with, and where a return type ends is decided by Luau’s parser, not estimated.
• The @dream/luau definitions did not declare StatLocalPattern, PatternRecord, PatternField or PatternIdentifier, and typed ExprFunction.args and ComprehensionGenerator.bindings as lists of dream_luau_Local although a record pattern can stand in either. They are declared now, dream_luau_StatLocalPattern is a member of dream_luau_Stat, and a slot that may hold a pattern is a dream_luau_Binding, dream_luau_Local | dream_luau_PatternRecord.

Migration

A strict script that reads name off an element of ExprFunction.args or of a generator’s bindings refines it by kind first, "Local" or "PatternRecord". Nothing changes at run time.

2.0.0 stable 2026-10-11

A dialect of Luau whose comprehensions, reducers, sinks, slices and record patterns lower to the handwritten loop with tooling in original coordinates; a bulk-data plane over typed buffer spans with native loops; raw TCP, DNS and verified TLS; locales, plural rules and decimal formatting; Luau 0.742; and the renames and defaults that needed a major version to change.

Breaking changes

• @dream/net is @dream/udp: the extension is dream.udp, the Rust module l3i::udp, the type UdpExtension, the C symbols dream_udp_*. The capability is still network.transport.
• TcpExtension and TlsExtension are no longer unit structs. .extension(TcpExtension) becomes .extension(TcpExtension::default()); TlsExtension::new() or ::default() likewise.
• noDelay defaults to true on tcp.connect and tcp.listen: Nagle’s algorithm is off unless a script passes { noDelay = false }.
• luau.parse defaults to the l3i dialect, so comprehensions, slices and record patterns come back as source nodes; { dialect = "luau" } selects strict stock syntax.
• Luau 0.742 (from 0.740). ffi::lua_setbuffercage is lua_setmemorycage; disable_native_execution_for_function is gone with Luau’s own; LuauNoDuplicateBinaryPrefix and LuauCompileIifeInline graduated and left the flag list.
• Coroutine finalizers are chosen on the builder: RuntimeBuilder::coroutine_finalizers(bool) replaces Runtime::enable_coroutine_finalizers, and Thread::finalizer_function(scope, close) replaces Runtime::finalizer_function(). The first runtime built in a process decides for the process.
• DnsExtension::new lets 8 of a runtime’s lookups occupy a shared resolver by default, not 2.
• The growable public types new since 1.3.1 are #[non_exhaustive]: tcp::StreamState, tls::TlsState, dns::LookupError, dns::ResolverConfig, data::Kind, data::Layout, data::ReductionOp, data::Reduction, intl::Grouping, intl::DecimalOptions, intl::FormatterError, intl::Operand, intl::NumberError, intl::LocaleError, intl::UnsupportedLocale. Matches need a wildcard arm; the structs are built with ResolverConfig::new(workers, queue), Layout::new(kind, stride, offset), Reduction::new(op, filter) and DecimalOptions::new().grouping(..).fraction_digits(min, max).

Added

• The l3i dialect: [for e in entities if e.active => e.id] comprehensions with range, enumerate, zipShortest and zipStrict generators; #, sum, min, max, any and all consumers that allocate no result; into(destination) table sinks and into(buffer, "kind"[, offset]) buffer sinks; inclusive slices t[a:b] of tables and buffers and typed slices buf[1:n, "f32@16"]; and record patterns local {x, y} = p in declarations, parameters and generator slots. One frontend built on Luau’s lexer lowers all of it to the same-contract handwritten loop, one setup instruction apart, and compilation is strict while Analysis and @dream/luau recover unfinished constructs.
• Original coordinates everywhere: Analysis diagnostics and autocomplete, analysis::parse, @dream/luau trees, compile errors, runtime errors, tracebacks, breakpoints and coverage all report the source you wrote, through a source map the frontend records as it lowers.
• @dream/data (feature data): reductions, comparisons into reusable selections, selection algebra, gather, scatter, fill, add, scale, clamp, stable argsort with optional caller scratch, and partition over typed, optionally strided buffer spans, bound once per operation with no per-element callback. Typed receivers data.u8() through data.f64() lower their thirty-nine reductions and selects to unrolled native loops under jit, and the dialect’s recognized reductions over buffer slices call the plane automatically.
• @dream/tcp (feature tcp): nonblocking listeners and byte streams over numeric addresses, readInto into caller buffers with end of stream kept apart from would-block, partial writes with no hidden queue, half-close, and a bounded, level-triggered poller that never calls Luau and watches only what has something to report. Behind network.tcp.connect, network.tcp.listen and network.tcp.public.
• @dream/dns (feature dns): host name resolution through the OS resolver on a bounded worker pool: one-shot requests that never block the script, IDNA names, both address families in the OS’s order, deadlines and cancellation, watchable by the TCP poller. Behind network.dns.resolve.
• @dream/tls (feature tls): verified TLS 1.3 and 1.2 client and server sessions over TCP streams with rustls, the platform trust store or explicit roots, name verification independent of the address, ALPN and SNI, bounded buffers, close_notify kept apart from truncation, nonblocking and watchable. There is no way to skip verification.
• @dream/intl (feature intl): BCP 47 locale identity, CLDR cardinal and ordinal plural categories that see visible fraction digits, and locale-aware decimal formatting from ICU4X’s compiled data; no catalog and no current locale.
• ExtensionDescriptor::widen_type_alias, so an extension can add its handle type to a union another extension declared without that extension knowing it; dream_tcp_Watchable is widened by dream.dns and dream.tls.
• Luau 0.741’s GC heap-shrink pacing fix and 0.742’s compiler and code generator fixes are on, each with its reason beside its name in flags::LUAU_FLAGS.

Changed

• A tcp Poller:wait scans only the watches with something to report, so idle sockets cost it nothing: one ready stream among 8192 idle watches costs 0.4 µs, as among 1024. The event buffer starts at 256 entries and doubles as waits fill it, up to maxEvents, instead of being allocated at maxEvents up front.
• A tcp stream’s localAddress is asked of the OS on first use and remembered. Deadline-based readiness is judged once per wait, not per next().
• tls.clientConfig{ roots } with the platform store caches the verifier per distinct root set (8 sets of at most 256 KiB each per runtime) instead of reloading the store per call; the platform store alone is still loaded once per runtime. A TLS write whose socket has just refused bytes does not try the socket again in the same call.
• Pollers and TLS configurations are capped per runtime (TcpExtension::max_pollers 64, TlsExtension::max_configs 32), and the documentation says which native memory the VM’s memory limit does not see.
• A slice bound spelled as an integer literal skips its run-time check; a standalone slice of a 16-element table costs about 215 ns against 150 for a handwritten table.create plus table.move.
• Plain Luau that never uses the dialect is lexed once by the frontend, and only when it contains a [: about 17 to 20 percent over stock luau_compile on 16,000 lines with indexing in loops or calls inside brackets, nothing without a bracket.
• The fast-flag policy is documented as l3i’s own named list rather than as another project’s.

Fixed

• Standalone slices after a .name, :method(), call or index chain, slices of slices, and slices or comprehensions that use the enclosing function’s ... lowered to broken Luau; a slice that starts a statement was refused.
• zipStrict never compared the first argument’s length. any and all over a buffer slice past the end asked the data plane for a span at an out-of-range offset.
• Data span arithmetic could overflow (an abort when bound, a wrap when native); any/all consumers now guard an empty span like the other reductions.
• A handshaking TLS session reported a stale readable bit while rustls had unsent flight bytes, a latent busy loop. Poller:close leaked a descriptor. An accept refused for want of descriptors re-armed the listener on every wait.
• SIGPIPE from a TLS writev and from process.run’s stdin feeder killed the host; stack overflows in the location remapper and tree builder on deep shadow chains; quadratic prescans in the frontend; intl decimal exponents past 32767 overflowed an i16 in the parser.
• The comprehension nesting limit counted clause delimiters; parentheses and brackets inside a clause no longer count toward the 128 levels.

Migration

Downstream plans need one line per network extension: .extension(TcpExtension::default()) and .extension(TlsExtension::new()). Rename @dream/net requires and net compat globals to @dream/udp and udp. A match over any of the types listed above needs a wildcard arm. Tools that read @dream/luau trees and expect generated wrappers pass { dialect = "luau" } or, better, handle the dialect’s nodes. Scripts that relied on Nagle pass { noDelay = false }. Recompile cached bytecode to pick up original debug lines.

1.3.1 stable 2026-10-02

Luau can now create capability-gated dream.net servers and mint private-key-backed connect tokens, and l3i can emit a textual disassembly of the exact compiled bytecode.

Added

• net.server{ schema, address, protocolId, maxClients? } creates a dream.net server from Luau when network.transport is granted. The generated signing key remains private inside the server userdata; server:connectToken(clientId, expiresInSeconds?, timeoutSeconds?) returns only the token clients need.
• l3i::source::disassemble(source, options) emits Luau’s textual bytecode listing for every function, including instructions, source lines, locals and constants, using the same compiler options and library callbacks as source::compile.

1.3.0 stable 2026-10-01

Luau’s own parser for scripts with @dream/luau: the syntax tree with exact spans, comments, errors and the token stream, built as tables in native code and typed for strict walkers; and named Luau types for extensions whose values are plain tables.

Added

• @dream/luau (feature syntax): luau.parse(source, options?) runs Luau::Parser under the runtime’s fast flags and returns the tree as tables, every node with its kind and a 1-based span, one table per local shared by its declaration and every use, string quote styles, every comment and hot comment, parse errors as data with the recovered tree, and, with { tokens = true }, Luau’s token stream as a buffer of 12-byte records; { declarations = true } parses definition-file syntax.
• The tree costs 17205 instructions per source line built and collected, against 27861 for the parser and Luau’s own JSON encoding of it, which a script would still have to decode.
• ExtensionDescriptor::type_alias: a named Luau type an extension’s signatures refer to, for values that are plain tables, rendered as export type ahead of every module.
• @dream/bytes’s toBase64 and fromBase64: standard padded base64 of a range of a buffer or string in one call, and back, refusing anything that isn’t base64 by naming the byte.
• @dream/bytes’s frame: one native walk over a run of tag-length-payload chunks (RIFF, IFF, PNG, GLB, Bethesda records), the layout given as data, returning every chunk’s start and end as u32 pairs and, when it stops early, why and where; an inner layout checks that each payload’s chunks tile it. A megabyte of records and fields in 0.98 ms against 9.8 ms for the Luau walk.
• @dream/bytes’s regex (feature bytes-regex): a pattern compiled once over bytes, whose matchSpans tests every (start, end) range of a buffer in one call and answers with a byte per range, so a thousand small fields cost one call and no strings; isMatch and find over one range.
• @dream/fs (feature fs): the host filesystem over byte paths, with whole and positional reads, readers over a memory map, writers with positions and truncation, stat and lstat, a walk that returns parallel columns, recursive removal, renames, copies, hard and symbolic links, canonical paths and file identity, behind the filesystem.read and filesystem.write capabilities. What the OS refuses returns nil, the message and the error’s kind, the way io.open does.
• @dream/process (feature process): run starts a program with no shell, waits for it, and returns its exit code with its output passed through, captured or discarded, behind process.spawn; env behind process.environment; write and isTerminal for the standard streams.
• @dream/bytes’s translate(text, from, to, { collapse?, trimStart?, trimEnd? }?): bytes mapped like tr, runs of one byte collapsed, one byte trimmed from each end, and the text itself returned when nothing changes; folding a path’s case and separators costs 141 ns a call against 470 ns for string.lower plus string.gsub.
• @dream/intern’s rules policy, intern.new({ nocase?, replace?, collapse?, trimStart?, trimEnd? }): keys normalized inside the hash and the compare, so Meshes\\X//Rock.NIF and meshes/x/rock.nif are one token with no normalized string made; the byte map lowers to native code eight bytes at a time, 522 instructions for a duplicate 31-byte path against 5008 for string.lower plus string.gsub and a table read, and resolve returns the normal form.

1.2.0 stable 2026-09-30

Textual identity as dense numbers with @dream/intern, lowered so a repeated identity never leaves native code; a zstd encoder; a constant that says whether a build used the verified toolchain; a slow path for lowering hooks that stays native; and cheaper string, buffer and optional arguments for every binding.

Added

• @dream/intern (feature intern): pools that turn strings or buffer spans into dense number tokens under exact or ascii-nocase equality, folding case inside the hash and the comparison, so no lowered copy is made and a repeated identity allocates nothing. find, resolve to the first spelling seen, and interner() for interpreted code.
• Under jit, an annotated dream_intern_Pool’s intern and find lower to native code: a case-insensitive duplicate costs 315 instructions against 1378 for string.lower and a table lookup, and an insert or a bad argument runs the bound method without leaving native code.
• IrBuilder::namecall_call: the namecall and call Luau would have emitted, as a userdata namecall hook’s slow path.
• l3i::VERIFIED_TOOLCHAIN: true exactly when build.rs found the verified toolchain, whether or not L3I_UNVERIFIED_TOOLCHAIN was set, for hosts that publish performance numbers.
• @dream/bytes’s zstdCompress, through ruzstd’s one implemented level; any other level is refused by name.
• Runtime::registered_require_modules: every path registered with register_require_module, the plan’s included, in registration order.

Changed

• Q:fromXYZW lowers to native code: 93 instructions against the binder’s 459.
• String, buffer and string-or-buffer arguments are read straight from Luau’s value layout (54 instructions instead of 293), and a trailing optional argument is read once (two optional integers cost 335 fewer instructions).

Fixed

• A lowered rotation packs with the omitted component’s own sign, so a quarter turn whose two largest components tie with opposite signs no longer packs a different rotation.

1.1.0 stable 2026-09-30

Chunks load on any scope’s thread under the runtime’s native code policy, the code generator is reachable from a call, templates resolve their imports at load time, and a frame’s call site costs two debug fields.

Added

• source::LoadScope, implemented for every scope: load_bytecode and load_source load a chunk on the scope’s own thread, so Luau resolves its builtin imports against that thread’s safe globals, and compile it natively according to the runtime’s mode, so a require written in Rust needs neither the Runtime nor luau_load by hand.
• NativeCodeGen::for_scope: the runtime’s code generator from a bound function’s Call or any other scope of its VM.
• DebugScope::call_site: the chunk name and current line of a frame, asking Luau for those two fields only; Luau records lines, not columns.
• Templates load on a loader thread whose globals are the base environment, so Luau resolves their builtin imports when the template loads and every instance takes the fast import path from its first run.

1.0.0 stable 2026-09-29

First release: the whole Luau 0.740 C API under a scoped Rust layer, planned runtimes composed from extensions, sandboxes, the dream-net bridge in every VM, and native lowering hooks written in Rust.

Added

• The typed binder: Runtime::bind_function reads arguments straight from Luau’s 16-byte value layout, with the C++ binder’s optional, variadic and overload rules and its exact error wording.
• Tagged and untagged userdata per runtime: the same Rust type may be tag 8 in one VM, 17 in another, and untagged in a third; generated __index and __namecall dispatchers that cost one Luau call frame.
• Runtime plans: an Extension describes modules, userdata, packed kinds, services and capabilities without a VM, and RuntimePlan::finalize assigns tags, compiler slots, atoms and direct slots, validates every identifier and path, and renders the .d.luau for the composition.
• Sandboxes with the C++ binder’s prelude, per-script instances, and compiled templates cloned per script.
• The dream.net bridge in every plan: schemas, clients gated by the network.transport capability, host-created servers, and pollInto with one payload copy and no allocation.
• Packed 64-bit scalars with a kind registry: dream.quat rotations and animation keys, dream.raster colours and clip rectangles, and dream.soft_render behind the soft-render feature.
• Native code generation (jit): Luau’s CodeGen with lowering hooks written in Rust against an IrBuilder C ABI; quaternion, colour and vertex-writer paths that lower to IR with no C call.
• Luau’s Analysis frontend (analysis): type checker, linter and autocomplete over a source provider, definition files, and the gate that type checks a plan’s declared API against strict scripts.
• @dream/bytes (bytes) for parsing foreign file formats in script: searching, record strings, varints, big-endian, 24-bit and half-float reads with a receiver lowered to native code, and behind their own features the codecs (DEFLATE, LZ4, zstd, LZMA), the digests (CRC-32 to BLAKE3) and the text codepages, all pure Rust.
• Watchdog limits, memory categories, call scopes, collector control and the profiler plumbing a game engine needs, and every function in lua.h, lualib.h, luacode.h, luacodegen.h, luajitinliner.h and Require.h declared by hand.
• The clang, lld and cross-language thin LTO toolchain, enforced by build.rs and measured in TOOLCHAIN.md: a bound call within forty instructions of a bare C function.
• Templates load from any thread of the VM: Sandbox::load_template_in takes only the scope, so a require loader captures the sandbox and nothing else.
• Rust 1.92, clang and lld; dream-net 1.1.0.