Hi everyone. Today's build of Elements 11, build .2771, brings a first glance at two new experimental features: the ability to run the Elements compiler on .NET Core and — more excitingly — the Water IDE, as well.

Of course, Elements has supported building apps for .NET Core, for a long time – ever since .NET Core was available. And as of the release of .NET Core 5.0 (redubbed as just ".NET 5.0", because Microsoft's naming team likes to keep things confusing ;), .NET Core has slowly started to become the standard version of the Common Language Runtime.

What this build adds is the ability to run the compiler and IDE itself on the new .NET Core runtime, rather than on classic .NET 4.8. What's the benefit of that? Mostly just performance.

Running EBuild and the Compiler on .NET Core

For a while now, we have shipped a separate set of the compiler toolchain, built for .NET Core, in the ./Bin/Core subfolder of the Elements install (and Mac & Linux zip Distro). While not 100% finished and perfect yet, and still considered "experimental", with 2771 be believe this version is ready to be tested by you.

Right now you have two ways to use the .NET Core version of EBuild (and with it, the compiler):

If you run EBuild from the command line, simpy run the version from ./Bin/Core explicitly, instead of the one in ./Bin that's on the system path. Elements ships four stub binaries for EBuild, named after the four CPU architectures supported by .NET Core: x86, x64, arm and arm64.

You will need to pick the executable that matches your system architecture and you will also need to have installed the matching version of the .NET Core 6 runtime or SDK, available here. It has to be .NET 6 (not 5. not 7, or 8. 6), because .NET Core isn't as lenient about forwards and backward compatibility as classic .NET was. For best performance, make sure you install the version matching your CPU architecture (although you can install any version that can be emulated by your system (e.g., Intel 64-bit systems can run 32bit, and Windows on ARM can run 32-bit and 64-bit Intel version as well — really, really slowly).

Once again, you will need to run the version of EBuild-*.exe that matches the .NET Core runtime you have installed (if you try to run the wrong one, the system will let you know), e.g. EBuild-win-arm64.exe on a 64-bit ARM PC.

This is the place where i usually drop a snide remark about what a mess dealing with CPU architectures is on the Windows platform. .NET Core seems to exasperate that even more.

If you use Water, regardless of Classic or on .NET Core as described below, there's a new option in "Tools|Preferences|Build & Debug" that lets you choose to use the (experimental) .NET Core-based compiler. The same caveats as above apply about needing the right version of the .NET Core 6 runtime installed, and this option is off, by default.

In my own tests, I've seen build speed improvements up to 2x and sometimes more, for even trivial projects, when using the .NET Core-based compiler compared to the one (same compiler code) running on Classic .NET 4.8 (or Mono) –  so that looks promising. Let us know what your experience is!

Note that there's a few build phases, depending on what's in your project, that will still fail on Core. We're working on that, but let us know what problems you encounter, if any!

Running Water on .NET Core

In the same fashion as for EBuild, Elements .2771 (and later) installs a separate copy of Water in the ./Bin/Core that is built for .NET Core 6. Again, there are four stubs provided, and you have to choose the one that matches your CPU Architecture and .NET Core runtime, to launch Water; for the best performance, make sure you use the most native version of .NET Core for your CPU.

As for benefits: as you might know from previous posts that personally, I myself do all my work on a MacBook Air with an Apple M1 chip, which is an ARM CPU. For the little work I do in Windows, I use Windows for ARM in a Parallels virtual machine, and let me tell you, running the Classic .NET version of Water was very slow, because classic .NET did not support ARM natively, so it ran emulated an x64, and was, unfortunately, basically unusable (to one of its own fault. It ran on the CLR running on an emulated Intel CPU in a virtualized Windows install, on an ARM MacBook, after all). The .NET Core version of Water, when run on the arm64 version of the NET Core runtime, is blazingly fast once again. At least as fast as it was on native Intel/Windows hardware, possibly faster.

I expect that every user of Water will see speed benefits from the .NET Core version (even if not as dramatic as for those on ARM machines).

Once again, we'd appreciate your own feedback on running this new build of Water (whether natively on Windows, Intel or ARM, or in virtualization).

To the best of my knowledge, all aspects of Water should be fully functional in the .NET Core version (aside from automated version checks; that is on the list to be fixed), but feedback on any issues would be appreciated.

Note that Water on .NET Core does not automatically use the .NET Core version of the compiler. It uses/honors the same setting as described above to enable the (off by default, for now) .NET Core-based compiler.

As always, Elements 11 build .2771 is a free update for all users with an active subscription. Elements is available starting at $69/month (including six languages and all platforms) and as free trial.

Read more about Elements here.