terra VS lua-languages

Chapel has at least several full-time developers at Cray/HPE and (I think) the US national labs, and has had some for almost two decades. That's much more than $100k.

Chapel is also just one of many other projects broadly interested in developing new programming languages for "high performance" programming. Out of that large field, Chapel is not especially related to the specific ideas or design goals of Mojo. Much more related are things like Codon (https://exaloop.io), and the metaprogramming models in Terra (https://terralang.org), Nim (https://nim-lang.org), and Zig (https://ziglang.org).

But Chapel is great! It has a lot of good ideas, especially for distributed-memory programming, which is its historical focus. It is more related to Legion (https://legion.stanford.edu, https://regent-lang.org), parallel & distributed Fortran, ZPL, etc.

Terra is the language you're looking for: https://terralang.org/

Wow, amazing stuff. I love Lua, it was how I learned programming as a kid. Coincidently from the same world as the author. Open Tibia.

The author made a custom client (https://github.com/edubart/otclient) for the game that is still very much in active use by thousands of players. He's a very skilled developer.

Great to see AOT typed Lua, I know of the other solutions: Luau, Teal, TypeScriptToLua, Terra, etc., but this one is my favorite so far.

Love the simple compilation to C (and WASM support via Emscripten). Though Terra's JIT is enticing and good replacement for LuaJIT, this is for embedded systems, it's a good replacement for Lua PUC-Rio.

The World:

- https://luau-lang.org/

- https://terralang.org/

- https://github.com/teal-language/tl

- https://typescripttolua.github.io/

Terra is a language that can also do that, and uses Lua as the metaprogramming language. Types are just Lua values.

But unfortunately, there's a lot of work left kind of half-baked so using the language is a pain... if someone invested a lot of time to make Terra work properly and added some tooling around it, wrote proper docs and so on, it would be a really interesting language.

https://terralang.org/

(I am slightly familiar with a language called Terra (https://terralang.org), which couples C with Lua, where the Lua is basically used as the metaprogramming layer ... sort of like comptime in Zig. And making an SOA data structure is the kind of thing you could do in Lua in Terra. So that was partly the basis for my question).

> why can't the hardware designer do something simple and clean

If it was easy, it would not need firmware in the first place. Firmware is there because people expect certain features and quality of life. See softmodems.

> write some assembly (without abusing the assembler preprocessor...)

You want https://terralang.org/ and not "just C"/"just Assembler" instead ?

This post inspired me to look for an ML-like language that compiles to lua and I found this useful list: https://github.com/hengestone/lua-languages

There's a complete list of languages that compile to Lua available here: https://github.com/hengestone/lua-languages

There are a ton of different ways to do this but you haven't given enough information to give useful advice. What kind of language do you want to make? "as a module of smth else" doesn't really mean anything. https://github.com/hengestone/lua-languages

There's also gpanders/nvim-moonwalker, which advertises Fennel in it's readme but works for any x->lua language you return the lua code for, ie: teal, moonscript, uh... others?

I went on a several-weeks-long fact finding mission (the longest of its kind I've ever done in my 10 years as a professional software developer).

The option that won was to write all business logic (a few thousand lines of code) in Lua, then write the GUI in each platform's native language+ui-library combination and re-use the same business logic by embedding Lua.

Another option that made the shortlist was using Haxe instead of Lua, but after several weeks, it became clear that that was a bad idea, and with Lua, the developer experience is now so much better.

I definitely plan on continuing to use Lua as my main programming language.

This comes after 20 years of having python as my main programming language because I'm displeased with feature creep and bloat on python. With lua, I find that I barely miss any features/abilities from the vastly more complex python while the simplicity of lua means my code gets to "go places" where python can't go.

With lua, you find casual implementers making fully compatible alternative implementations (e.g. NeoLua for C#, Luna for Java, fengari for JavaScript, ...) With Python, alternative implementations seemingly just can't keep up with the pace at which CPython is introducing unnecessary new features and CPython-compatbility is de-facto the only meaningful python standard there is. Jython and IronPython would make the platform so much more appealing, but they appear dead in the water. Python implementations for the browser pop up every couple of years only to quietly disappear again.

What's more: Once you've settled on Lua as am embedding language, developers of Lua logic are free to use not just Lua, but they can pick from a host of cool transpile-to-Lua languages [1].

[1] https://github.com/hengestone/lua-languages

However, there are many languages to which this doesn’t apply (before Fennel I’ve tried to write Minetest mods in Haxe without success).

Maybe most of them are also small projects, but there are a lot of projects that compile other languages to Lua: https://github.com/hengestone/lua-languages .

Doubtful, but there is TypescriptToLua: https://typescripttolua.github.io/

Here's a whole list of languages that compile to Lua (many of them statically typed): https://github.com/hengestone/lua-languages

That's just because there are lots of lua transpilers. https://github.com/hengestone/lua-languages