gopher-lua

Agreed, it made a lot more sense to write MaraDNS in C in 2001 though. The main advantage of writing in C over Rust here in 2026 is that C has two different Lua interpreters, and there isn’t a port of Lua to Rust yet; [1] yes, there are ways to use the C version of Lua in Rust, but that’s different. If I were to write a new server today, I could very well write it in Go, then use GopherLua for the Lua engine: https://github.com/yuin/gopher-lua Although, even here, the advantage of C is that I could increase performance by using LuaJIT: https://luajit.org/luajit.html [1] If I were to use Rust, I would consider using Rune as an embedded language as per https://rune-rs.github.io/

Surprised recent versions 1.18+ didn't see a jump in improvement, but might explain sumloop improvement for 1.19 I checked, they use switch on opcodes in vm.go. So would expect a recent improvement, but probably only <5%, & I didn't look close enough to see if awk is one of those languages where instruction dispatch matters less (like how APL tends to avoid issues since array ops avoid having dispatch in tight loops, or how Python avoids instruction dispatch overhead when using numpy) Indeed, they have a comment saying array of functions is faster for older versions of go: https://github.com/benhoyt/goawk/blob/158232a76856e12d680a53... For VMs Go had a problem for large switch statements: it would always use binary search instead of a jump table. This caused gopher-lua & go-lua to both take the route of having an array of functions which

Not the parent but there are several high quality native (meaning no CGO) Lua implementations for Go and it's a great choice if you want an embedded scripting language: https://github.com/yuin/gopher-lua https://github.com/Shopify/go-lua Unless you specifically need a JVM either of these will be a much more practical and mature choice for embedded scripting. Alternatively if you prefer JS then Otto is a good choice: https://github.com/robertkrimen/otto

python, Lua and JS These functions are implemented by these packages: github.com/dop251/goja github.com/yuin/gopher-lua go.starlark.net Go scripts (programs) are not subject to any restrictions. So there is no Go script support in the playground(debug)

I'm generally using Visual Studio Code for all my development. Really like it. I chose https://github.com/yuin/gopher-lua as the Lua engine because it is Golang-based, while the Nginx Lua VM is C, unless I'm mistaken. Using gopher-lua is just easier when I'm working in a Golang project. I only have to work in a single language and dev environment for all the backend work. Makes both development and testing easier. Moonscript I might have heard of, but I have no experience with it. I did not consider it here, and I would rarely consider any niche scripting language for a solution I want others to use. It just introduces an unnecessary barrier to adoption.

Some other implementations of Lua: https://github.com/yuin/gopher-lua Lua in Go https://github.com/fengari-lua/fengari Lua in Javascript https://github.com/moonsharp-devs/moonsharp Lua in C#

GopherLua [0] is a Lua implementation written in Go, not just a wrapper around the reference implementation (written in C). The main alternative seems to be Shopify’s go-lua [1], given that Microsoft’s golua [2] is no longer being developed. The main difference between these three implementations seems to be the supported Lua version - 5.1, 5.2 and 5.3 respectively. Of course, the reference implementation is now on version 5.4 - these are all considered different major versions of the language (Lua doesn’t use SemVer). [0] https://github.com/yuin/gopher-lua [1] https://github.com/Shopify/go-lua [2] https://github.com/Azure/golua

There are a couple different Lua implementations in Go. Has anyone researched the difference between them? https://github.com/yuin/gopher-lua https://github.com/Shopify/go-lua https://github.com/milochristiansen/lua https://github.com/afitz/golua

This seems to be a thin wrapper for the actual Lua VM implemented in Go: https://github.com/yuin/gopher-lua

There's also GopherLua [1], which is more active and supports features like coroutines and channels. [1] https://github.com/yuin/gopher-lua

Using GopherLua is a pleasant experience. Easily integrated and surprisingly fast. But the documentation is lacking. If you use it in a web server that executes Lua with requests, take a look at the LState pool pattern[1]. [1] https://github.com/yuin/gopher-lua#the-lstate-pool-pattern

From a quick glance at the source, it looks like this may be a port of the existing Lua VM for C into Go. For example, it appears to use the same opcodes and the main VM loop looks very similar: http://www.lua.org/source/5.1/lvm.c.html https://github.com/yuin/gopher-lua/blob/master/vm.go It's interesting because the Go source appears to be annotating certain patterns with comments where the C version uses a macro. Compare the C version: case OP_LOADK: { setobj2s(L, ra, KBx(i)); With the Go version: case OP_LOADK: Bx = int(inst & 0x3ffff) //GETBX reg.Set(RA, cf.Fn.Proto.Constants[Bx])