
CoreRT – .NET Core runtime optimized for AOT compilation - jeswin
https://github.com/dotnet/corert
======
romanovcode
I don't get it. Wasn't this already released under MIT like two years ago?

~~~
davidpelaez
I would also appreciate a little comment on this because the readme doesn't do
much explaining what it is, why it's important, how it's different from .NET
Core 2 compiler? To put it in another way, why is this so relevant?

~~~
pjmlp
It is the POSIX version of .NET Native, for AOT compilation into native code.

Using a much better compiler backend than NGEN, similar to Mono when targeting
iOS.

Additionally, it is also adding WASM as target "CPU".

.NET Core only does JIT currently, the generated binary is a mini-bootstrap
code that starts the runtime and feeds the main application Assembly into it.

~~~
titanix2
Thanks for the explanation. It’s good to see that Microsoft finally decided to
port .net native to other platforms than uwp.

------
michaeljchou
More info in `Documentation` folder:

[https://github.com/dotnet/corert/blob/master/Documentation/i...](https://github.com/dotnet/corert/blob/master/Documentation/intro-
to-corert.md)

[https://github.com/dotnet/corert/blob/master/Documentation/h...](https://github.com/dotnet/corert/blob/master/Documentation/high-
level-engineering-plan.md)

------
tybit
I would love to see more of a road map on where this project is going. It's
exciting, but not clear where it's heading.

------
wehadfun
So using this a .Net application run without the .net framework?

~~~
jsingleton
The framework is included with the application, so no install is needed. You
can already generate a self-contained platform-agnostic deployment that
includes the framework, but it contains lots of files. You need to specify the
platform, yet that is just for the bootstrapper. There are also some pre-
requisites that have to be installed, such as SSL libs.

.NET Native (a.k.a. CoreRT) is more like what you get with Go, a single native
binary. You need to know the CPU architecture ahead-of-time, but it has
performance advantages. You can also strip out unused code with IL Linker and
do things like Profile Guided Optimisation.

Keep in mind that if you're using Docker containers then you probably want to
share the framework, otherwise this will increase the size.

There's some more discussion around this in the .NET Core talks that I've
given: [https://unop.uk/talks/](https://unop.uk/talks/)

~~~
tree_of_item
> .NET Native (a.k.a. CoreRT) is more like what you get with Go, a single
> native binary.

I think this really needs to be emphasized, it's a great feature and this was
the one question I had when I clicked the link, but I didn't get the answer
until I came here.

