qbe-rs VS Oberon

You can try buildling you own backend like llvm. A good example or starting point is probably QBE since it is extremely small but very functional.

How big is the whole backend? I've heard that it is small but I wanted to compare it to QBE which is around 8 KLoC and it is quite interesting too.

I think QBE might be what you're looking for?

https://c9x.me/compile/

As far as I know, there is QBE, which is actually kinda underrated, and Cranelift, mainly designed for JIT compilation

Before that, I had spent a bit of time working with QBE, which is much simpler and really easy to write a frontend for. I switched to libgccjit though, because I got frustrated with a few of the things lacking from QBE (like the ability to easily keep track of where different variables live on the stack). I think for many hobby language projects, QBE would be a good option (my project was off the ground very fast using QBE, and I got pretty far before I ran into limitations I couldn't easily work around).

If one of your parameters is size/complexity of the backend and you prefer something smaller, have a look at qbe and cwerg

The alternatives are generally hidden inside of another compiler. The big exception seems to be qbe (https://c9x.me/compile/) however since the author appears to have written this code without peer review, it's not easy to read it's source code.

So my question is this: if a backend like QBE (~12k Loc) was added to Zig and Zig only had to compile Zig code (no C, etc) for that QBE backend -- about how many LoC would that Zig need to be?

GCC is written in C++ these days, so something like QBE(https://c9x.me/compile/) would be needed.

> annoying aspects was requiring the .NET runtime ... OpenJDK is a blessed implementation in a way that Mono never was

Which is unjustified, because Mono CLR is just a single executable less than 5 MB which you can download and run without a complicated installation process (see e.g. https://github.com/rochus-keller/Oberon/#binary-versions ). AOT compilation on the other hand is a huge and complex installation depending on a lot of stuff including LLVM, and the resulting executables are not really smaller than the CLR + mscorlib + app.

After evaluating a lot of different technologies I'm e.g. using the Mono CLR for my Oberon+ IDE because it is lean, fast and has also excellent platform independent debugging features, and also an integrated, mostly standardized and platform independent FFI (see https://github.com/rochus-keller/Oberon). It is more stable than LuaJIT and the same benchmark suit runs twice as fast on Mono than on LuaJIT (see https://github.com/rochus-keller/Oberon/blob/master/testcases/Are-we-fast-yet/Are-we-fast-yet_results_linux.pdf). Mono is also still fast enough compared to more recent CLR versions (see https://www.quora.com/Is-the-Mono-CLR-really-slower-than-CoreCLR/answer/Rochus-Keller). For the AOT use-case my compiler generates C for another factor two in speed when compiled e.g. with GCC -O2. You could even use the AOT feature of Mono for the same purpose.

1: https://github.com/rochus-keller/Oberon/blob/master/testcases/Are-we-fast-yet/Are-we-fast-yet_results_linux.pdf

Oberon? see https://github.com/rochus-keller/Oberon/

My new BUSY build system specification language (https://github.com/rochus-keller/BUSY/blob/main/README.md) and of course Oberon+ (https://github.com/rochus-keller/Oberon/blob/master/README.m...).

My Oberon compiler (https://github.com/rochus-keller/Oberon) does exactly that. But the C transpiler is only used when development and debugging are done, because debugging based on the generated C code makes everything much more complicated and platform dependent. Instead my compiler also generates CLI IL so I can use the excellent, lean, and cross-platform Mono engine integrated with my IDE re-using the Mono performance and debugging features; this is transparent to the developer; just in the end he/she generates (platform independent) C code and compiles it using e.g. GCC, CLANG or MSVC.

Interesting, thanks for the links, I will have a look at them. I used both the J2EE and .NET frameworks in the past. My major current interest in .NET is the CLR and CIL which I use in https://github.com/rochus-keller/Oberon/. I wouldn't switch since the Mono CLR is very good, but if there was a lean, improved version of the JVM I might consider generating bytecode for it.

That sounds rather similar to what I did with my Oberon+ implementation (see https://github.com/rochus-keller/Oberon/). I'm using Mono instead of CoreCLR, because it is leaner and runs on more architectures. Some versions of Mono turned out to be even faster than CoreCLR (see https://www.quora.com/Is-the-Mono-CLR-really-slower-than-CoreCLR/answer/Rochus-Keller). My Oberon IDE includes the mono executable plus the mscorlib.dll (together less than 10 MB); the IDE communicates with the mono debugger via the official socket interface.

Did you have a look at Oberon? This is the language Prof. Wirth especially conceived for education of computer science students at ETH Zurich where it was successfully used for many years; also some other universities adopted it. If you don't like the original syntax, there is also a more modern version incl. IDE and debugger, still adhering to simplicity: https://github.com/rochus-keller/Oberon