There's also IronLua, which is written in F#: https://ironlua.codeplex.com/

Would be cool to see performance comparison in future.

I'm a user of NLua[0]. Why would I switch to using this instead?

[0] http://nlua.org/

As this post title says: "completely managed".

NLua still relies on native code.

There are a few advantages to being completely managed, rather than using native code. Portability (eg. mobile devices, different OSes), and functional code access security are two reasons that come to mind for me.

Are both portable class libraries? In case that matters.

Well done! Is it a specific version of Lua?

Very interesting! I'm curious about the parser's error reporting for malformed input -- does it use Irony's default error reporting, or a custom solution? Are error reports good, bad, or lacking in any way?

I've not had a chance to look too deep into it but if you find out let me know.

Very interesting. If you don't mind me asking, how difficult was it to parse the grammar of Lua? I see you mention "Irony", but I've never heard of it. Is it a parser generator?

I'll be "that kid"... what does "completely managed" mean?

Runs entirely on the Common Language Runtime: the .NET VM. So no native code is used.

So, being pedantic, really it means you rely entirely on the GC for memory management. You can run unmanaged code on the CLR.

That's not correct. Unmanaged code, by it's definition, is not run on the CLR. It's run natively by the OS, and is compiled to machine code, not IL.

Managed code, on the other hand, by MS' own definition: "All of these languages share a unified set of class libraries and can be encoded into an Intermediate Language (IL). A runtime-aware compiler compiles the IL into native executable code within a managed execution environment that ensures type safety, array bound and index checking, exception handling, and garbage collection." [0]

[0] http://msdn.microsoft.com/en-us/library/windows/desktop/bb31...

EDIT: I should add, that while unmanaged code does not run on the CLR, the CLR does act as a bridge between managed and unmanaged code.

To expand on this... "So no native code is used." was probably somewhat misleading.

More specifically, no native code is explicitly used. IL may be compiled down to e.g. x86-64, but you won't have a C DLL being PInvoked from your C# (or other .NET language), nor a C++/CLI DLL compiled against x86-64 specifically.

Among other advantages, this usually implies:

  - Less interop overhead (unmanaged <-> managed transitions are expensive)
  - Easier dependency management (just include the assembly instead of assembly + native DLLs via installer or whatever)
  - Portable (more likely to run on e.g. the Mono Runtime on a Linux box with an ARM processor without requiring a build specific to ARM and possibly to Linux)

That's one aspect, but probably not the most important, given that Lua already has GC without the CLR.

Is the Irony parser also managed .net?