I've used Devuan and others with runit, sysV, s6 and openrc. And honestly, openrc is the better alternative from an user perspective.

Nevertheless, it is hard to argue against systemd when the critical mass is there, and you run into eventual problems.

Still, I find alternatives such as runit and openrc easier to reason about than systemd. Perhaps this is due to the need to fully grok them, so you're able to fix issues yourself. Contrast that with systemd, where there are plenty of drag and drop solutions out there, so that requirement is lessened. You could also argue the real reason is systemd's complexity, but personally that doesn't feel like the core reason.

Either way, it's good that there are alternatives. I like how heterogenous the whole Linux ecosystem can be, it helps mitigate large scale security issues.

IMHO all it does is drive fragmentation and marginalisation. Either your alternative is successful enough that third parties are compelled to care about it (making the integration work on their part more painful, which is often "solved" by using Electron); or it isn't, so you have to bring in your own integration (aka glue).

Sorry but Ballmer was right: developers, developers, developers. Users add value, developers multiply it.

But I don't see it as fragmentation, but as competition. The better idea tends to prevail, and it's nice that the environment allowed alternatives to even try :)

hell, systemd itself happened as a esult of this environment :)

Experimentation is OK. DNF started as a yum fork, with a different solver algorithm. IMHO yum should've just adopted the algorithm, but Fedora/CentOS ended up switching. That's mostly fine (people had to update docs, retrain their muscle memory).

The level of "competition" we see in package managers, desktop environments, initrd builders (!), resolv.conf managers (!!!), is just wasted effort. There's no "pick the winner", it's "everyone is a loser".

<https://tailscale.com/blog/sisyphean-dns-client-linux>

I've used runit, openrc, briefly upstart (what a trashfire that was), and I don't miss a single thing about them while writing systemd unit files.

I've used GNU Shepherd on Guix, and honestly, meh, systemd feels way more pragmatic.

I've also used systemd-networkd as well as NetworkManager, and feel like they both still have a few warts, but overall prefer systemd-networked on servers.

I've used grub, refit, and systemd-boot, and gotta say systemd-boot is my preference there too.

I haven't really used systemd portable services, but I've used docker and don't like it, and my overall impression is I'll probably like portable services more.

Are there other alternatives I have to use before I'm allowed to have an opinion? What alternatives have you used which made you feel so enlightened?

I didn't mean to seem like I feel so enlightened.

My experience is that when not using systemd, I regularly get screwed by what I would call the "imperialist culture" of systemd, for lack of better words: it doesn't feel like you can relatively easily extract subcomponents of systemd and use it standalone. And more and more projects depend on a particular subcomponent of systemd, meaning that they require systemd.

So it's not so much that I believe systemd is technically worse than the alternatives. It's more the philosophy that I don't like.

It's when i meet against some awful design choices in systemd, like how it decides to wait forever rather than hard fail, and by wait forever, i mean wait for 30 seconds, no, 1 minute 30 seconds, no 5 minutes... you get it.

Or you can easily lock yourself out when there's a typo in /etc/fstab.

Or the hardcoded 5 minute timeout for sysv-generator: https://github.com/systemd/systemd/blob/main/src/sysv-genera...

God forbid you used cgroupsv1 for anything when poettering unilaterally decided to punish everyone with a 30 second delay for using it.

If you stray off of the intended opinionated path, be prepared for the least user-friendly experience linux has to offer. You might even get some abuse from the developers if you try to ask for help, but they've probably toned it down since CoC became a thing (I hope).

Intentional time-delays are a nice middle ground. Yes, it is annoying to the users who've ignored all prior deprecation warnings, but it's better than those same users being "surprised" when support is removed entirely. Maybe you'd consider it less of a "punishment" if systemd dropped support for cgroupsv1 outright instead of inserting a time delay, I believe the opposite.

The reality to many is its the simplest simple way to handle some very complex tasks, and the vast majority of it is still all so very very much optional even in the most 'systemd heavy' distros.

The major difference is, in SMF you specify services, their dependencies and whatever else you need. Then SMF looks at the whole desired system, computes the dependency tree and boot order, validates everything and writes a boot plan that can be executed in a static and deterministic fashion. You can look at the plan, execute that exact same plan each boot. You therefore know that if the system came up once using that plan it will again.

Whereas systemd does everything on the fly, the boot order is computed anew with each boot, all the services on the same tree level are started at the same time and just have to fight it out. Thus the actual boot order varies greatly with each boot and will fail randomly, wait randomly (hands up: who wasn't annoyed by the systemd-rememberance-minute-and-a-half popping up like an inopportune windows update?) and will be hard to debug because you just cannot reproduce anything that lead to that. Your boot will be littered with 'wait-for-something' units, 'sleep-for-10s-because-that-magically-makes-it-work' and additional dependencies to maybe clean up the tree which the maintainers forgot about. Sometimes intentionally because "systemd is about making it boot fast, and it works on my laptop".

It isn't all bad, but for systems that I need to boot and shutdown reliably, systemd is a step back even over init scripts because of the nondeterminism. You can "fix" things by just watchdog-rebooting when the system doesn't come up, and the downtime will just be a little longer. But it is annoying. And it is a design bug that will never be fixed.

Systemd uses a dependency graph by the way. There is little magic. Provided you have properly setup what depends on what, everything will boot just fine and it’s somehow resilient enough than even if you messed up somewhere there is a good chance it manages to bring everything up after some hiccups.

It has some problems: it's more complicated, it can actually slow things down compared to starting a service as soon as possible, and it has new error cases because of course "pretending that a service is running" doesn't have exactly the same effect as actually having the service running.

I don't think "pretending that a service is running" is a fair description of what it does however. It's just buffering. It has advantages in some case which is why it exists. It doesn't "kinda suck".

Which makes sense for systemd if their goal is to kill the "competition". But that's not my vision of how open source should work.

Exactly. I expect a modular fork of systemd when people get annoyed enough. I still don't understand why people treat systemd as the second coming of the Christ.

Disclosure: I'm managing large number of servers for the last 20 years. Don't tell me that init scripts were bad. I won't buy it. Don't tell me systemd is fast, again, I won't buy it.

That's exactly the case with elogind, used by e.g. Alpine, Void, and Gentoo.

> I still don't understand why people treat systemd as the second coming of the Christ.

FWIW it managed to pull most distros in a single direction, decreasing ecosystem fragmentation. The outliers are well, outliers.

Just to be clear: it's not an endorsement from my side; there's enough criticism of systemd which I will not repeat. But the fragmentation aspect is what kills so much momentum, and it just runs too deep: Gnome was started because KDE's dependency on Qt wasn't kosher; Qt later got relicensed, but both projects kept pulling in different directions. It feels like any compatibility between anything is coincidental.

Both desktop environments pull in different directions in appearance only. Esp. KDE team works their heads off to be compatible with GNOME and to support/build standards which work equally well on both systems. For example, ".desktop" file specification. Another notable example is, every KDE release comes with identical GTK themes for flagship Qt theme, plus numerous others which I can't remember now.

So, the underlying standards of many Desktop Environments are the same, because there are standards which many don't see, know, care (and this is a good thing). Vaxry is a case study here, and I exclude his creations.

I know this, because, I took part in developing a Debian derivative distro for ~5 years or so.

> FWIW it managed to pull most distros in a single direction, decreasing ecosystem fragmentation. The outliers are well, outliers.

On the other hand, every distribution selects parts of systemd, patches part of the selected set and configures this set, hence integrates systemd differently in different levels. This creates behavioral differences in systems and their systemd installations.

IOW, systemd didn't reduce fragmentation to the level people wanted them to believe.

Moreover, pulling from that 20+ experience with Linux systems, their behavior was already this consistent since forever. RedHat had a wrapper called "service" on top of "/etc/init.d" system, but the scripts were portable. Some config files unrelated to systemd/init.d were in different places (and still are). e.g. apache/httpd, /etc/network/interfaces vs. /etc/sysconfig/network-scripts, etc.

So, the defragmentation by systemd is an illusion. Since forever, I had to either look for /etc/{redhat,debian}_version or type apt/yum/dnf and press enter to see which distro I'm on. The rest is basically the same, across hundreds of installations.

Nope, no. KDE has a dozen toggles for every feature, half of which don't make sense. It has OK/Cancel/Apply, as if Windows 95 was peak UX. Konsole uses the same color theme regardless of whether you pick light/dark; I've tried to hack together a script, but the CLIs/APIs don't make sense: you have to detect the light/dark preference by parsing the current system theme name. Good luck if it's something like some variation of "PurPurDay"/"PurPurNight". I also couldn't find a way to get programmatically notified about the theme changing - but KDE still shoves useless notifications in my face, like "button X was removed from the panel", which you have to disable one by one. KDE can't tell "powerful" from "overwhelming".

Gnome has a top bar. It has three buttons, the rest is wasted space. The "dock" can't be moved to the left/right screen edge - more precious vertical space taken away. It has no desktop icons, even though there's a "Desktop" folder in Nautilus. It can't set up different screen dim/lock timeouts on battery vs AC. Meanwhile I was watching a PR[1] that would add iCloud integration to system accounts - it got rejected, because "users can just set up IMAP/SMTP". Gnome can't tell "simple" from "simplistic".

I could go on, but please use macOS for a week, and try to draw a fair comparison.

[1]: https://gitlab.gnome.org/GNOME/gnome-online-accounts/-/merge...

> KDE team works their heads off to be compatible with GNOME [...].

Here we go. In the other thread, I was arguing that "competition" in this space is just wasted effort.

> So, the underlying standards of many Desktop Environments are the same [...].

So if I want to write a native application, which toolkit should I target? On macOS, it's Cocoa. On Windows, it's "whatever Windows is doing in this release", but at least I can still run programs that weren't touched since 1997.

On Linux, I have a choice of plain Qt vs KDE, plain GTK (2/3/4) vs Adwaita, and so on. Apps written with one look and behave out of place when used with the other. Every time glibc breaks something, the app needs to be rebuilt. OK, so I want to provide users with a self-contained package. The choices are Flatpak, Snap, and AppImage, all of which are built differently. I could go on.

> Another notable example is, every KDE release comes with identical GTK themes for flagship Qt theme [...].

Design is not how it looks, it's how it works.

> Moreover, pulling from that 20+ experience with Linux systems [...].

Yeah, I've also used Linux on the desktop for 20 years. Then I tried macOS for a month. Then tried OS X 10.5 for a comparison. I remember considering a MacBook in 2007, I regret not getting one back then.

> Since forever, I had to either look for /etc/{redhat,debian}_version or type apt/yum/dnf and press enter to see which distro I'm on.

I've inherited and managed a heterogenous fleet of Debian, Ubuntu, Fedora, CentOS, OpenBSD, etc, (many on different releases), and had to write a lot of Ansible roles by hand, because few existing roles could handle all of these. The quirks and hacks only piled and piled. It's insane.

/rant

It went from "shells have too much syntax, which creates security issues" straight into "forth with blocks". My idea: runit already provides chpst, which folds things like cd, chroot, nice, etc into a single command; so let's put it all into a block with named parameters. Like this:

    run {
        dir: /usr/src/foo
        script: {
            ./configure
            make -j(nproc)
            make install
        }
        nice: 20
        ionice: idle
    }

I'm not exactly sure about the syntax, but that's the general direction.

systemd does a lot more than just init. You can preach about whatever alternative inits all you like, but they don't do even 10% of what systemd does.

I didn't mean to preach about alternative inits.

My personal criticism of systemd is that it tries to take over everything, limiting the choice.

I want to have a choice, that's all. And systemd doesn't do anything to help there.

systemd-resolved: can be disabled and replaced with your DNS resolver of choice

systemd-timesyncd: can be disabled and replaced with your NTP daemon of choice

systemd-networkd: can be disabled and replaced with your own networking scripts

On a fully-systemd system you can opt out of systemd features. But you cannot opt in to systemd features on a non-systemd system.

How do you catch device events on very early startup (e.g., between start of pid1 and when processes start to fire?) if the thing that manages the devices isn't integrated with pid1 at a deep level?

The difference with a plain `open` is that logind will allow only one process at a time to have access, and only for sessions that logged in physically (tracked using PAM), and does not require the process to have direct file access (which could enable key-logging). It will also revoke the file descriptors when switching sessions.

logind's other random features like dock and power button triggers can be done whenever logind is running and ready - the underlying API reports levels and are not timing critical.

The only thing logind really uses at runtime from systemd is temporary storage of file descriptors that it can get back after restart for graceful upgrades.

Projects like elogind and eudev exists that painstakingly strip out the systemd portions while retaining the functionality, but it's an uphill battle to constantly redo every time there's a change.

Can you run those 3 standalone?

Actually it's the first time you have stated that, but I'll bite.

How do you propose that would work, and why would you even want to do that? The entire point of having these modules is for them to plug in to core systemd, which enables a lot of magic that would otherwise require an amalgam of shitty shell scripts. If you don't want to use systemd, why not just use chronyd for NTP, dnsmasq for DNS, and so on? Your problem is completely imaginary.

Fair point, I said it in another comment :-).

> How do you propose that would work

I don't. I merely state the fact that I don't like the way it's going with systemd, which is that many projects now assume that you have systemd and depend on it. And if you don't have systemd, you're screwed.

Similar to projects that assume that you have Ubuntu and depend on Ubuntu specificities.

And again I'm not saying that it should be illegal; just that I don't like it.

That is why RedHat wants it. What does it help on the laptop that I am writing this?

And what happens when you upgrade that fleet (unless you're doing clean installs) and sytemd-resolved is not resolving anything? (Just the most recent thing I've had)