2. Fork the upstream project (optionally remove other -- now useless :^) -- build scripts),

    Make / GNUMake / CMake / autoconf / bash scripts / batch scripts / powershell scripts: Zig is a complete build system that works on all supported platforms and can do everything those other tools do.

i am begging people to please stop doing this genre of "compatibility" initiative.

[0] https://fonts.google.com/specimen/Shantell+Sans

personally, i used gentoo throughout most of my teenage years, and now use nixos viewing it as a successor, since you can screw around using the thing as a meta-distribution, but roll back when you hose your system.

gentoo freebsd existed for a while for funsies but nobody cared and now it's dead, same with gentoo openbsd. each was portage integrated a little more intentionally on top of a respective bsd than just "bung it in /usr/local/bin and call it a day". practically speaking, they were implementations of gnu/k*bsd.

nixbsd similarly exists (nix deeply integrated into freebsd), with heroic efforts made to transfer nixos's abstraction over init systems for system-wide configuration; last commit was two months ago so i guess not dead yet?

you can run nix on gentoo, or gentoo prefix on nixos with nix-ld turned on if you feel like it

void's claim to fame with xbps is a bunch of sandboxing and bind mounts for build environments. nix already has to sandbox just to get off the ground wrt reproducibility.

void, gentoo, and nixos all offer some degree of libc freedom. on void it's first-class, on gentoo it nearly is, and on nixos it's here be dragons. libc freedom doesnt really jive with using a bsd as a base; vertical integration is kind of one of the contemporary selling points.

so to answer your question, the result would be nixbsd in an alternate timeline where nixpkgs's analogues to USE flags/eselect/profiles are not hot garbage (i say this with love as a user), and void would fail to exert a phenotype.

back in my time as an (inadvisably) precociously online kid, the only real age barrier was having a credit card, so i had to beg/borrow/steal my way to someone on irc giving me a shell to a vps, and pay some other rando with a steam gift card to buy a domain then transfer it to my registrar account. and like that, i could start developing a presence in whatever online communities i insinuated myself into by acting mature enough nobody gave my age a second thought. physical realities like divorce and school troubles came and went, but moving and shaking online gave me my most steadfast friends and s/o to this day.

shift the timeframe a couple decades and i would have instead been gated by an id upload. bleak.

i recently made use of plenty of ugly tricks in this vein to take a single authoritative table of macro invocations that defined a bunch of pixel formats, and make them graduate from defining bitfield structs to classes with accessors that performed good old fashioned shifts and masks, all without ever specifying the individual bit offsets of channels, just their individual widths, and macro magic did the rest. no templates, no actual c++, could just as feasibly produce pure c bindings down the line by just changing a few names.

getting really into this stuff makes you stop thinking of c function-like macros as functions of their arguments as such, but rather unary functions of argument lists, where arity roughly becomes the one notion vaguely akin to typing in the whole enterprise, or at least the one place where the compiler exhibits behaviour resembling that of a type checker. this was especially true considering the entries in the table i wound up with were variadic, terminating in variably many (name, width) parenthesised tuples. and i just... had the means to "uncons" them so to speak. fun stuff.

this is worth it, imo, in precisely one context, which is: you want a single source of truth that defines fiddly but formulaic implementations spread across multiple files that must remain coordinated, and this is something you do infrequently enough that you don't consider it worthwhile introducing "real" "big boy" code gen into your build process. mind, you usually do end up having to commit to a little utility header that defines convenient macros (_Ex and such in the article), but hey. c'est la vie. basically x macros (https://en.wikipedia.org/wiki/X_macro) on heart attack quantities of steroids.

which is basically ideal, no? for all the buy-in that the systemd stapling-svchost.exe-onto-cgroups approach asks of us, at the very least we have sufficiently expressive system to do that sort of thing. where something on the machine has a notion of what wants what from what, and you can issue a command to see whether that dependency is satisfied. like. we are there. good. nice. hopefully ops guys are content to let sleeping dogs lie, right?

...right?

if argon tickles your fancy, you might also be interested in fragment mono (https://github.com/weiweihuanghuang/fragment-mono) a similar free software “helvetica mono”.

the tragedy of both argon and fragment mono, though, is that the latter comes in one width, and the former inexplicably supports obscenely wide proportions without letting you condense it down from the bog-standard 1x2ish. most condensed options out there are these pill-shaped straight-walled monstrosities that blur together (the iosevkas and pragmatas of the world), with a few notable exceptions (the old osdn releases of mplus).

i wonder what would happen if you went in and extrapolated the width scaling for monaspace backwards into super narrow range.

having used all the 3.0 RCs up till now, i can assure you all gtk3 has done is made life nicer on all major platforms. for gimp's faults (now markedly fewer) it's an image editor, a thing with a distinct purpose and pretty immediate feedback on indulgent changes nuking productivity. the cancerous low-information-density, look-over-feel trends that we associate with new gtk versions by way of gnome's visionless bikeshedding blessedly does not translate to this new gimp. pinky promise. go use it. you'll like it.

it's my go-to for lining up pixel-perfect uv maps for more geometric/mechanical 3d assets -- the recursive nature means you can have an easy time hitting, say, the exact corners or centers of luxels if you feel the need.