I heard a lot of good things about Godot Engine: https://godotengine.org/

Someone also mentioned here Grid Engine (which I never heard of): https://www.planimeter.org/grid-sdk/

2. These days, GNU Hurd isn't GNU's only kernel. GNU Linux-libre is a fork of the Linux kernel that removes support for non-free binary blobs, and is officially part of the GNU project.

3. There's a distribution called GuixSD, which takes the GNU package manager (GNU Guix) and the GNU init system (GNU Shepherd), and the choice of GNU kernels (GNU Hurd or GNU Linux-libre), and builds a complete system out of them. It's easy to make the case that GuixSD is the GNU system in everything but name. And even then, there's the ongoing possibility that GuixSD becomes "blessed" as the complete GNU system and renames to GNU.

Android is Linux without GNU, so it's not hard to imagine a different future (whether it's desirable is a different question). Android has no GNU in user space -- it's almost all Apache and BSD licensed.

And I'm pretty sure the build toolchain is Clang and not GCC.

Though I hope the values of GNU continue to be important in the software world. Linux and GNU have different viewpoints and I think we need them both.

Yes, Google took the effort of making Linux compilable with clang, then they deprecated gcc and with the latest NDK release (R18) gcc has gotten finally the boot from Android.

If you are a big on "purity" there are `make` flags to avoid bundling proprietary blobs. So its not like you are even giving up your ideological idealism using a GNU/Linux OS.

- Those running network infrastructure (router, firewall, VPN gateway, mail server, etc.)

- Those who want a simple Unix desktop with no gimmicks and low hassle

- Hardcore Unix geeks who don't like the other flavors for $REASONS

In a more general or vague sense, OpenBSD is often appealing to people who care more about cohesiveness and correctness than about the sheer magnitude of performance and features. If you've ever thought that you might prefer to have an indefinitely supported version of Windows 7 because Windows 10 seems to be crawling with gratuitous changes, bugs, and dubious "features", the appeal is a bit like the Unix equivalent of that.

This! When you are using OpenBSD, and wonder how a particular piece of the kernel works, you just open the source code, read it, and you can usually have a good idea of the inner workings with some days studying it. Trying to do the same thing with linux, you would need months to grasp any idea of how it works. Linux is developed by thousands of people all around the world at the same time. OpenBSD on the other hand is developed by a few power developers, which gives the code a unique consistency and readability.

I noticed this first hand in while submitting a patch for my macbook's touchpad to FreeBSD's wsp driver and then comparing to OpenBSD's driver... The approaches between FreeBSD's and OpenBSD's driver couldn't be more opposite: FreeBSD's is big, explicitly listing each hardware revision/model (hence the reason I had to go in there and add mine), OpenBSD's very minimal, implicitly inferring all hardware revision options so users don't have to add each and every one, it's also very neat and tidy which I think is an underrated quality in source.

Admittedly this is only one file from one small number of devs, far from the whole of FreeBSD, but the contrast matches much of what i've heard of OpenBSD's approach: minimise cruft and bad code, if it's shit and not easy to re-write then delete it, better to be minimal than buggy and insecure.

Full Disclosure: My comment may well be outdated since I moved away from FreeBSD for my desktop 2 years ago, I have nothing against it, I just needed (other) working drivers.

Also, installation was quite fast if you knew what you were doing.

I don't hack on the internals or build my own ports, I just use it. It stays out of my way and I like that.

I'm weird, dunno if others agree ~

I used these [0][1] repos as a starting point, I wrote a few helpers to update dynamic dns and a DNS ad blocklist for unbound. This replaced a pfSense install and I'm happy with it so far.

[0] https://github.com/elad/openbsd-apu2 [1] https://github.com/northox/openbsd-apu2

What I love about OpenBSD is the documentation. If An openbsd manpage describes it then it will work like that.

The only bummer is it’s a bit of a niche. I’m sure the majority of Linux distros dwarf its development team in warm bodies.

I stopped using OpenBSD when I tried installing it on my newer Core 2 Duo desktop in ~2008, but the OS would not boot, and I was told on IRC by OpenBSD developers that the hardware was too new for OpenBSD.

FWIW, now I use Arch Linux. I guess I'm in the target demographic.

Shameless self-promotion: I wrote a Lisp interpreter in a single assembly file for Raspberry Pi. It also starts from scratch at an even lower level, to the point of ignoring standard libraries.

https://github.com/marcpaq/arpilisp

I was inspired by jonesforth, which, if you haven't read it, is a beautiful piece of work.

This really makes me want to blow the dust off the RaspberryPi (we all bought one and never used it: admit it) and get this up and running, just to see it working.

  /* excerpt from builtin_op function */

  while (a->count > 0) {

    /* Pop the next element */
    lval* y = lval_pop(a, 0);

    if (strcmp(op, "+") == 0) { x->num += y->num; }
    if (strcmp(op, "-") == 0) { x->num -= y->num; }
    if (strcmp(op, "*") == 0) { x->num *= y->num; }
    if (strcmp(op, "/") == 0) {
      if (y->num == 0) {
        lval_del(x); lval_del(y);
        x = lval_err("Division By Zero!"); break;
      }
      x->num /= y->num;
    }

    lval_del(y);
  }

One thing that you might be interested in knowing about is that this book uses a few libraries which means you don't end up writing everything from scratch. For example, in the chapter on parsing, the grammar is implemented using a library called MPC (https://github.com/orangeduck/mpc) written by the author himself.

I didn't quite reach till the very end so didn't have a chance to implement Macros (the author does mention them in Chapter 16), so if that's something you can very keen on implementing then you might have to look someplace else.