I used to use Lua and later LuaJIT in Lumix Engine. I switched to Luau because of its type system. However, it's apparent it was not meant to be used outside Roblox, as it has many rough corners. The documentation is not great, and the community is basically nonexistent - I got zero results when searching for any issues I encountered. Also, it's huge compared to Lua or LuaJIT, causing my project to compile 7x slower. The API is not great (e.g., an async API that blocks, using STL in the API, leaking STL headers). I encounter bugs with analysis/LSP often. Overall, I consider moving away from it.

Something that’s REALLY interesting is that Roblox is working on a Node.js style desktop runtime for Luau:<p><a href="https://github.com/luau-lang/lute" rel="nofollow">https://github.com/luau-lang/lute</a>

I liked what I read, although the size of the original Lua embedded interpreter has a particular aesthetic that any type inference feature takes away (in return, you get type safety, it's a fair trade-off).<p>But when I tried it without reading to much, I got this (bug or feature)?<p>Code:<p><pre><code> --!strict local x: number = 2; print("Hello World!") x="test" print(x) </code></pre> Output:<p><pre><code> Hello World! test </code></pre> There wasn't any error message or warning when I pressed the run button, and that certainly violated my expectations, regardless whether the code and behavior may be considered "correct" (=documented) or not.

Luau seems to be significantly more complex than Lua - I'm not sure it can still be called "small". Looking at the relative size of the implementations: Luau's is 120,000 lines of C++ [0], an order of magnitude larger than Lua 5.1's 14,000 lines of C.<p>But I think that complexity is unavoidable for a gradually- or statically-typed language. Any language with a reasonably-complete type system is inevitably going to be much more complex than a dynamically-typed scripting language.<p>[0] Counting *.cpp files in the "Analysis", "AST", "Compiler" and "VM" directories

I can recommend that people check out Lune [1], it's a Luau runtime which includes a small but nice standard library. It's very easy to create something like a webserver in it. [2]<p>[1]: <a href="https://lune-org.github.io/docs/" rel="nofollow">https://lune-org.github.io/docs/</a><p>[2]: <a href="https://lune-org.github.io/docs/the-book/5-networking/#running-a-web-server" rel="nofollow">https://lune-org.github.io/docs/the-book/5-networking/#runni...</a>

>>> Luau interpreter can be competitive with LuaJIT interpreter depending on the program<p>To me, this is the more interesting bit of luau<p>The performance page[1] contains a pretty good explanation of the work they have done. Pretty impressive engineering if you ask me.<p>[1] <a href="https://luau.org/performance" rel="nofollow">https://luau.org/performance</a>

How does Luau compare to Teal [0], which is described similarly as a "statically-typed dialect of Lua"?<p>[0] <a href="https://teal-language.org/" rel="nofollow">https://teal-language.org/</a>

It's a shame that Lua did not evolve in a more backwards-compatible manner. In addition to Roblox, lots of others projects started adopting Lua 5.1 as a scripting language in the late 00s. Lua itself is now at 5.4, but it did not keep backwards compatibility. LuaJIT and related projects pretty much only support 5.1. It's similar to the situation Python had with 2.x/3.x, except that the majority of Lua users I am aware of are preferring to stay with the older 5.1.

I learned about Luau via my 13 years old who is looking into Roblox Studio. That's how I ended up visiting luau.org and I'm quite impressed by Roblox's engineering on this.

This has been posted here a while ago but I'm pretty excited about bolt: <a href="https://github.com/Beariish/bolt" rel="nofollow">https://github.com/Beariish/bolt</a> - I've been looking for a statically typed language which could integrate well around something with a strong type system and good meta programming facilities for generating bindings. Bolt has the benefit of being a pretty small library with the downside of being nascent.

Typed Lua is something I've always wanted, but writing a very comprehensive type-checker and LSP for another dynamic language is pretty difficult. All dynamic languages have similar problems to those TypeScript encountered, as most dynamic languages have a sort of structural typing in the form of dictionaries or objects.<p>I do wonder if we could reuse TypeScript in other dynamic languages.<p>Transform Luau to a subset of TypeScript, check with tsc, transform errors and results back to Luau. In the same way, one could reuse a TypeScript language server. This way of utilising TypeScript's engine could jump-start many other type checkers for other dynamic languages.

I actually came across <a href="https://github.com/PlutoLang/Pluto" rel="nofollow">https://github.com/PlutoLang/Pluto</a> and it seems to be all the things you would want from Luau but without the connection to Roblox

I know everyone hates bringing up naming conflicts, but I'm just going to say I think it's pretty lame to name a language so deeply <i>inspired</i> by another language, a name that is also insanely close to said language. Even the logo... I mean there's paying homage, then there's whatever this is.

It is an impressive achievement.<p>Unfortunately, there is not a Luau distribution of windows like Luarocks.<p>Eventually we may see something in this place.<p>The well known libraries, IUP, CD, IM have not been ported to Luau.<p>But code is Free Open Source, who knows.

Coward, make it statically-typed!

Does it fix array indexing starting from 1?