kiwi VS tl

Nucleic also makes Kiwi one of the fastest Cassowary Constraint implementations. It is very useful for implementing custom GUIs as it can make building internal component layouts and general layout systems fairly straightforward and it’s very performant.

I highly encourage taking a look at it and it has also been ported to a wide range of language.

I’m using Nim kiwi with my own GUI library now. I’ll have to take a peak at how enaml is using kiwi for its layouts.

https://kiwisolver.readthedocs.io/en/latest/

https://github.com/alexbirkett/kiwi-java

https://github.com/PongoEngine/jasper

https://github.com/yglukhov/kiwi

If any of the Luau devs are watching this, please flesh out the metamethods. I'd switch almost everything to Luau if they were improved.

They're the biggest PITA right now as designed in PUC-Rio, and I see that while you've improved upon __eq, other metamethods are still lacking.

In PUC-Rio, boolean equality operators FORCE a boolean result, regardless of what you return. Ideally they would allow returning any result type, which then can be coerced to boolean later (e.g. by an `if` statement), just like the arithmetic operators do.

Further, `__neq`, `__ge` and `__gt` do not exist. They should.

The lack of a proper metamethod design means that binding to e.g. Kiwi[0] is impossible without some incredibly fugly hacks. It has been a long-standing annoyance with Lua in an otherwise beautiful little scripting language (that I use frequently).

This looks quite nice - lots of attempts in this space but nothing that attempts to match Lua to this degree.

[0] https://github.com/nucleic/kiwi

it's based off MIR, does it have something to do with https://mlir.llvm.org/ ?

for typed lua, there is another effort https://github.com/teal-language/tl in addition to the mentioned typescript approach: https://github.com/andremm/typedlua

I had the pleasure of working with Lua 5.1 back in the late noughties. For me it's replaced Tcl whenever I want something I can configure above a C library. At the time I used it I found it quite nice but I'll also not forget the hours I wasted tracking down nil table corruptions which could have easily been caught by a type checker.

I had some hope that Luau https://luau-lang.org or Teal https://github.com/teal-language/tl would make things better but with the following example

    function foo(x: number): string

I wonder why the author doesn't use Teal [0] - a typed dialect of lua.

[O] https://github.com/teal-language/tl

Check out Teal

There is already https://github.com/teal-language/tl, which is typed Lua. I think fennel exists to serve a different niche-- personally I use it not for any type features; I just like the syntax better, and others may find certain features like the macro system useful.

There's also some languages made to compile straight to Lua: - MoonScript is the most popular Lua wrapper - it's built to be more Python-like, featuring indentation-based scopes, function calls without parentheses, lambda syntax, list comprehension, and much more. - Yuescript is a modern update to MoonScript that adds more features (I haven't used it myself, so I'm not entirely sure exactly how it differs from MS). - Teal is a version of Lua that adds static typing for better code standards.

Terra and Nelua are both very different in goals than Teal. Teal is literally gradual types integrated into Lua keeping as many of Lua's idioms as possible (to a fault[1]). Terra and Nelua are both very metaprogrammable systems programming languages. Nelua's goals are primarily to soften C's rough edges, comparable to something like Nim.

There's another one you missed in Pallene[2]. But again, it's goal was to optimize the stack sharing involved in using the C API. It also adds types though and maintains Lua idioms as much as possible.

[1]: https://github.com/teal-language/tl/discussions/339

[2]: https://github.com/pallene-lang/pallene