

Show HN: NetLua – Completely managed .NET Lua - Bambo
https://github.com/frabert/NetLua

======
profquail
There's also IronLua, which is written in F#:
[https://ironlua.codeplex.com/](https://ironlua.codeplex.com/)

~~~
CmonDev
Would be cool to see performance comparison in future.

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

[0] [http://nlua.org/](http://nlua.org/)

~~~
diego_moita
As this post title says: "completely managed".

NLua still relies on native code.

------
CmonDev
Well done! Is it a specific version of Lua?

------
mattfenwick
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?

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

------
yarou
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?

~~~
louthy
[http://irony.codeplex.com/](http://irony.codeplex.com/)

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

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

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

~~~
pionar
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...](http://msdn.microsoft.com/en-
us/library/windows/desktop/bb318664%28v=vs.85%29.aspx)

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.

~~~
MaulingMonkey
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)

------
malkia
Is the Irony parser also managed .net?

