lewurm

If you have an Apple Silicon machine you can run a Windows Insider build via UTM in a VM.

What's the difference between the stage2 and stage3 binary? Does stage1 produce different binaries for the same input compared to stage2/stage3?

OTOH social distancing and wearing masks has shown recently that (most) people are fine with changing their behavior, if necessary.

It's experimental currently, no profile guided optimizations _yet_

.NET is the platform. There are different implementations for it doing different things.

JIT compilation is still different to AOT even without profile guided optimizations. Simple example: In AOT code you can't embed pointers easily and is often solved with indirection (e.g. something like GOT in ELF).

In general this is true, here however, we are targeting LLMV IR which is register based with infinite registers; so it's kinda easy again :-) The hard part, register allocation, is actually done by LLVM.

This class implements the conversion: https://github.com/lambdageek/mono/blob/mjit/mcs/class/Mono....

FWIW, both use Graal as a compiler.

Graal VM is based on HotSpot, which is sort of "bloated" for the specific use case that Truffle has.

Do you need to care as an application? Ideally no :-) It should be transparent to the user and it's the runtime's job to do the best available thing for you. (Sure, the runtime can be tweaked for specific workloads etc.)

In Mono we aren't there yet: the interpreter is currently useful for restricted targets like iOS, where a JIT can't be used due to security concerns and AOT comes with certain limitations (that is, loading assemblies at runtime and execute them). If you want to use Mono's Interpreter to run roslyn, you can explicitly tell the runtime to do so, but it doesn't make much sense today, because it will give you less performance than the available JIT; we don't support switching the execution engine on the fly for single methods yet (it's also called tiered compilation).