nosystemd.org

An init system is the first process the Linux kernel starts, so it runs as PID 1 and is responsible for spawning the other daemons the OS needs — networking, cron, syslog, and so on. systemd is one such init daemon, and it is the default on most major distributions; if you want to avoid it, the actively developed alternatives include SysVinit, OpenRC, runit, s6, Shepherd, finit, dinit, and a handful of smaller projects. The choice matters most if you care about keeping PID 1 small and single-purpose, or if you have been affected by systemd's bug and security history.

What an init daemon actually does

The kernel hands PID 1 to the init daemon at boot. From there it:

• Starts the services the system needs to become usable (networking, logging, scheduled jobs).
• Stays running as the parent of those processes, reaping orphans and supervising restarts.
• Acts as the fallback process that must never exit — if PID 1 dies, the kernel panics.

That is the whole job in the traditional model. Everything else — device management, login sessions, DNS resolution, containers — was historically handled by separate tools.

What systemd is, and how it differs from SysVinit

systemd claims to be a good and modern replacement for SysVinit. The difference is scope rather than just mechanism:

The criticism is not that systemd is an init system — it is that it is a large, tightly coupled suite occupying PID 1, where a bug in any component can take down the whole system.

The main criticisms and documented problems

The site's case against systemd rests on a list of notable bugs and security issues, several with real-world impact:

• A Datadog outage costing 5 million dollars was caused by a systemd upgrade.
• A widespread Azure outage occurred when systemd 237-3ubuntu10.54 was published to the bionic-security pocket — instances could no longer resolve DNS queries, breaking networking.
• CVE-2018-16864, CVE-2018-16865, and CVE-2018-16866 — a systemd-journald exploit chain.
• CVE-2018-15688 — out-of-bounds write in systemd-networkd DHCPv6 option handling.
• CVE-2017-15908 — a loop on packets with pseudo DNS types in resolved.
• #5644 — tmpfiles: R! /dir/.* destroys root.
• #6381 — booting with an encrypted root partition fails instantly in systemd-cryptsetup.
• #11810 — can't suspend again after suspending once.
• #8579 — systemd breaks my mouse.
• #2460 — systemctl status can take more than 10 seconds when the disk journal is used.
• #6237 — systemd can't handle process privileges for usernames starting with a number, such as 0day.
• #4863 — systemd-journald drops all bytes after a \0.
• #6620 — services writing to stdout become silent after a journal restart.
• #2402 — mounts efivarfs read-only.
• #1596 — journalctl -r -n flags processed incorrectly.
• #1312 — restarting a systemd service on dependency failure.
• #1143 — PID 1 gets stuck printing systemd[1]: Time has been changed continuously.
• #437 — timeX.google.com provides non-standard time.
• #6078 — applying systemd-networkd configuration disconnects all other interfaces.
• #6369 — hostnamed does not like FQDNs with trailing dots.
• #6478 — systemctl treats active→failed as a successful operation.
• systemd user manager interferes with ecryptfs, leaving the private directory unmounted.

The pattern is that because systemd is monolithic, a defect in a peripheral component (DNS, journal, networkd) can break core system behavior.

Active alternative init systems

These are the projects with current development activity:

• SysVinit — the traditional init; simple, well understood, still maintained.
• OpenRC — dependency-based init used by Gentoo, Alpine, and others; keeps service supervision separate from the rest of the system.
• runit — small, fast, supervision-focused; popular on Void Linux.
• s6 — a suite of small tools built around process supervision, designed for composability rather than a monolith.
• Shepherd — the GNU Guix System init, written in Scheme.
• finit — a small, fast init with dependency handling.
• dinit — a service manager and init with dependency support.
• superd, 31init, procd, dmaster, prometheus — additional projects listed as active.

Inactive projects to avoid

The site explicitly marks these as having had no development activity for several years:

• uselessd
• Upstart
• InitNG
• cinit
• minit
• Epoch

If you are choosing an init system for a new install, picking one of these means adopting an unmaintained component.

How to get rid of systemd

The practical route is to choose a distribution that ships an alternative init by default rather than trying to swap init on an existing systemd install. The site's "How do I get rid of systemd?" section and its useful links point to distributions built around SysVinit, OpenRC, runit, and s6. Migrating an already-installed systemd distribution is the harder path, because so many components (logging, device management, session handling) assume systemd is present.

Choosing between them

• If you want maximum familiarity and minimal change, SysVinit is the closest to the traditional model.
• If you want dependency-based service management without a monolith, OpenRC is the common choice.
• If you want small, supervision-first tooling, runit or s6 fit that description.
• If you want a modern small init with dependency handling, dinit or finit are the active options.

The decision usually comes down to which distribution you are willing to run, since the init system is effectively fixed by that choice.

systemd is an init daemon and service manager: it runs as PID 1, the first process the kernel starts, and it brings up the rest of the system — networking, cron, syslog, and other daemons. It is the default on most mainstream Linux distributions, but it is not the only option. Alternatives include SysVinit, OpenRC, runit, s6, dinit, and others, and some distributions ship without systemd entirely. If you are choosing a distribution or trying to remove systemd from an existing install, the decision usually comes down to how much of your system depends on systemd-specific interfaces.

What systemd actually does

The kernel spawns one process at boot and gives it PID 1. That process is responsible for starting everything else the OS needs. systemd fills that role and expands it well beyond a classic init: it also handles service supervision, logging (journald), device management (udev), network configuration (systemd-networkd), name resolution (systemd-resolved), timers, and user session management.

That breadth is the core of the disagreement. A traditional init starts services and gets out of the way. systemd absorbs many separate components into one project, so replacing it means replacing or reconfiguring several subsystems at once, not just swapping one daemon.

Common criticisms

The No systemd resource collection frames its case around two things: scope and reliability.

• Scope creep. systemd replaces many independent tools with components from a single project, which critics argue reduces modularity and choice.
• Bug and security history. The site lists a long series of issues, including:
  • A Datadog outage reported to have cost $5 million, attributed to a systemd upgrade.
  • A widespread Azure outage after systemd 237-3ubuntu10.54 was published to the bionic-security pocket, where instances could no longer resolve DNS queries.
  • CVE-2017-15908 (resolved loop on packets with pseudo DNS types), CVE-2018-15688 (out-of-bounds write in systemd-networkd DHCPv6 option handling), and CVE-2018-16864/16865/16866 (a systemd-journald exploit chain).
  • Functional bugs such as systemctl reporting slow status (>10s) with a disk journal, services going silent after a journal restart, and a tmpfiles rule that could destroy root.

These are the specific, checkable items the source raises. Whether they outweigh systemd's benefits is a judgment call — the point is that the criticism is grounded in named incidents and CVE numbers rather than general dislike.

Init alternatives

The source lists these init daemons, marking inactive ones where development has stopped for several years:

For most people looking to move away from systemd, the practical shortlist is OpenRC, runit, s6, and dinit — all actively developed and used by real distributions.

How to get rid of systemd

The source's own section on this is titled "How do I get rid of systemd?" and the honest answer is that it ranges from easy to impractical depending on your starting point.

The reliable path: install a distribution that doesn't use systemd. This avoids fighting a package manager and init system that assume systemd is present.

The hard path: convert an existing system. This means replacing PID 1, rebuilding or reconfiguring packages that ship systemd units, and handling the services systemd was managing for you (logging, networking, DNS, timers). Expect breakage in anything that calls systemctl, reads the journal, or depends on systemd-specific unit features.

A reasonable order of operations if you attempt a conversion:

1. Identify every service currently managed by systemd (systemctl list-units) and find its equivalent unit or script for your target init.
2. Replace the logging path if you relied on journald.
3. Replace network and DNS management if you used systemd-networkd or systemd-resolved.
4. Install and configure the new init, then switch the bootloader/kernel command line to use it.
5. Verify by rebooting and confirming PID 1 is the new init and that networking, logging, and your critical services come up.

The verification step matters: a system that boots but silently loses DNS or logging is a common failure mode, and it mirrors the Azure incident above.

Distributions without systemd

The site's stated purpose is to help you "find Linux distributions without systemd." That list is the fastest route to a working non-systemd system, since the distribution maintainers have already done the integration work. If your goal is simply to run Linux without systemd rather than to convert a specific machine, start there rather than with a manual conversion.

Choosing between them

• Want minimal disruption and a supported path? Pick a distribution that ships your preferred init.
• Want a small, simple init? runit and dinit are lightweight; OpenRC is a common middle ground with broad distro support.
• Want a supervision toolkit you can compose? s6 is built around that model.
• Need to keep an existing install? Budget for replacing logging, networking, and DNS alongside PID 1, and test the reboot before trusting it.

sysvinit is the traditional Unix System V-style init system: it is the first process the kernel starts (PID 1) and is responsible for bringing the rest of the operating system up. It reads /etc/inittab to decide which runlevel to enter, then runs the scripts in /etc/init.d (linked from runlevel directories such as /etc/rc3.d) in a fixed sequence to start daemons like networking, cron, and syslog. It is a good fit if you want a small, script-driven, predictable boot process, or if you are maintaining older distributions and hardware. It is a poor fit if you need parallel service startup, socket activation, or integrated logging, which is where systemd differs most.

What sysvinit actually does

The init daemon is the first process spawned by the kernel, so it holds PID #1 and is responsible for spawning the other daemons the OS needs to operate — networking, cron, syslog, and so on. sysvinit performs that role in a deliberately simple way:

• Runlevels. /etc/inittab defines what each runlevel means (single-user, multi-user, graphical, reboot, shutdown) and which scripts run for each.
• Sequential scripts. Each service is a shell script in /etc/init.d. Symlinks in /etc/rcN.d named S##name (start) and K##name (kill) determine order by their numeric prefix.
• No built-in supervision. If a daemon crashes, sysvinit does not automatically restart it unless the script or an external tool does so.
• Plain-text logs. Services typically write to syslog or their own files; there is no unified journal.

Because ordering is encoded in filenames and scripts run one after another, boot time grows with the number of services, but the behavior is easy to trace by reading the scripts.

How systemd differs

systemd replaces the script-and-runlevel model with declarative unit files and a central manager. The practical differences:

The trade-off is the same one the source frames as the core dispute: systemd claims to be a good and modern replacement for SysVinit, but it concentrates many responsibilities (init, logging, networking, device management) into one project, which is exactly what critics object to.

Alternatives to both

The init landscape is wider than sysvinit vs systemd. The source lists these init daemons, with several marked inactive (no development activity for several years):

• Active: systemd, SysVinit, OpenRC, runit, s6, Shepherd, finit, Hummingbird, superd, 31init, Dinit, procd, dmaster, prometheus
• Inactive: uselessd, Upstart, InitNG, cinit, minit, Epoch

If your goal is simply to avoid systemd, OpenRC, runit, and s6 are the commonly cited replacements; if your goal is minimal change from a classic setup, staying on sysvinit or a compatible script-based init is the smallest step.

Why people move away from systemd

The source's case against systemd is built on a list of notable bugs and security issues rather than on architecture alone. Examples it cites include:

• A Datadog outage costing 5 million dollars caused by a systemd upgrade.
• A widespread Azure outage when systemd 237-3ubuntu10.54 was published to the bionic-security pocket, after which instances could no longer resolve DNS queries, breaking networking.
• CVE-2017-15908 (resolved loop on packets with pseudo DNS types), CVE-2018-15688 (out-of-bounds write in systemd-networkd DHCPv6 option handling), and CVE-2018-16864/16865/16866 (a systemd-journald exploit).
• Operational issues such as PID 1 getting stuck printing "Time has been changed" continuously, systemctl status taking over 10 seconds when the disk journal is used, and systemctl treating active→failed as a successful operation.

These are the concrete observations behind the general complaint; they are worth reading directly if you are deciding whether the risk profile matters for your systems.

Migrating from systemd to sysvinit: what to watch

There is no in-place switch — you generally choose a distribution or image that ships the init you want, or rebuild the userland around it. When you do, expect these friction points:

1. Service definitions don't translate. A *.service unit has no direct sysvinit equivalent; you rewrite it as an /etc/init.d script with start, stop, restart, and status cases.
2. Dependencies become ordering. After=/Requires= must be expressed as S##/K## numbering, which is coarser and easier to get wrong.
3. No journal. You lose journalctl; plan for syslog or per-service log files and adjust any tooling that parsed the journal.
4. No socket/timer activation. Services that relied on systemd socket or timer units need another mechanism (inetd-style activation, cron, or an external supervisor).
5. Supervision is your job. If you depended on Restart=always, add a supervisor or a wrapper loop, or accept that a crashed daemon stays down.

Verify each step by rebooting into the target runlevel and checking that the expected daemons are running and that networking, logging, and cron behave as before.

Choosing between them

Pick sysvinit (or a compatible script-based init) when you want a small, readable, sequential boot process, are working with older or resource-constrained systems, or specifically want to avoid systemd's scope. Pick systemd when you need parallel startup, dependency management, socket/timer activation, cgroup-based resource control, and unified logging out of the box. If neither extreme fits, OpenRC, runit, or s6 sit between them and are the usual destinations for people leaving systemd without returning to classic SysV scripts.

Arx Libertatis is an improved, cross-platform, open-source engine for Arx Fatalis, the 2002 first-person RPG/dungeon crawler/immersive sim from Arkane Studios. To play on Linux, you install Arx Libertatis (official Linux builds are provided), then point it at a copy of the original Arx Fatalis game data — the engine itself does not include the game. You need to own or otherwise obtain Arx Fatalis or its demo before you can play.

What Arx Libertatis actually is

Arx Libertatis is a port and modernization of the Arx Fatalis engine, based on the publicly released Arx Fatalis source code and available under the GPL 3+ license. Version 1.2.1 supports modern systems, brings the game to new platforms, and removes bugs and limitations of the original release.

Two things follow from that:

• The engine is free and open source. You can download, inspect, and redistribute the code under the GPL.
• The game data is not included. The license covers the engine only. The art, audio, levels, and other assets remain part of the commercial game, so you must supply them yourself.

The game itself features crafting, melee and ranged combat, and a distinctive spellcasting system where you draw runes in real time to cast the spell you want.

What you need before installing

The original game is sold through storefronts such as GOG.com, the Microsoft Store, and the Bethesda Store, and it also has a demo. Any of these gives you the data files the engine needs.

Installing Arx Libertatis on Linux

Arx Libertatis provides official builds for Windows and Linux. Beyond those, it has been packaged for macOS (Homebrew), FreeBSD, DragonFly BSD, NetBSD, OpenBSD, Haiku, and Pandora, and will likely compile and work on other operating systems.

On Linux, you have two practical routes:

Option 1: Use a distribution package

Check whether your distribution ships Arx Libertatis in its repositories. If it does, install it through your normal package manager. This is the least manual path and keeps updates tied to your system.

Option 2: Use the official Linux build

Download the Linux build from the project's download page and unpack it. This works regardless of whether your distribution packages the engine, and it lets you run a specific version such as 1.2.1.

If neither fits, the source is available on GitHub, so you can build it yourself — the project notes it will likely compile on other systems too.

Pointing the engine at your game data

The engine needs to find the Arx Fatalis data files. The general flow is:

1. Install or unpack Arx Libertatis using one of the routes above.
2. Locate your Arx Fatalis data. If you bought the game from a storefront, the installer places the data files somewhere on disk; if you have the demo, it comes as its own set of files.
3. Tell Arx Libertatis where that data is when you first launch it, or place the data where the engine expects it.
4. Launch the game and confirm it reaches the main menu.

The expected result at each step is simple: the engine starts, finds the data, and loads the game rather than exiting with a "data not found" style error.

If the game does not run

Check these in order:

• Data path is wrong. The most common failure is the engine not finding the Arx Fatalis data. Re-check the path you gave it.
• You installed the engine but not the game. Arx Libertatis alone cannot run — it has no assets of its own.
• Graphics/driver problems. Since the engine targets modern systems, most rendering issues trace back to drivers or to running an old build. Try the current release (1.2.1).
• Wrong build for your system. Make sure you grabbed the Linux build, not the Windows one, if you installed manually.

Where to go next

The project plans to keep improving and modernizing the engine and to enable community customizations and mods. If you want to follow development or get help, the project links to its GitHub repository, Mod DB page, and community forums such as the TTLG Forum and the GOG.com forum. There are also community projects built around the game, including the Arx Insanity Mod and other Arx mods.

systemd is one of several init daemons — the first process the kernel starts (PID 1) — and it has drawn sustained criticism for its scope, design, and bug history. If you want to avoid it, maintained alternatives include SysVinit, OpenRC, runit, s6, Shepherd, finit, Dinit, and others; the practical choice depends on whether you're picking a distribution or replacing init on an existing install.

What an init system actually does

The kernel spawns the init daemon first, so it runs as PID 1. From there it starts and supervises the other daemons the OS needs — networking, cron, syslog, and so on. That's the whole job in the classic model: bring the system up, keep services running, shut them down cleanly.

systemd presents itself as a modern replacement for SysVinit in that role, but it bundles far more than service supervision.

The alternatives, and which are still alive

The No systemd project maintains a list of init daemons. The distinction that matters most when choosing is whether the project is still developed.

"Inactive" here means no development activity for several years — treat those as historical interest rather than something to build on.

Why people move away from systemd

The objections on No systemd fall into two buckets: design scope and concrete defects.

On design, the complaint is that systemd is not just an init — it grows into logging (journald), networking (networkd), name resolution (resolved), and more. That concentration is what critics mean by a monolithic design.

On defects, the site collects a long list of notable bugs and security issues, including:

• A Datadog outage reported to have cost 5 million dollars, caused by a systemd upgrade.
• A widespread Azure outage after systemd 237-3ubuntu10.54 was published to the bionic-security pocket, where instances could no longer resolve DNS queries, breaking networking.
• Multiple CVEs: CVE-2017-15908 (resolved loop on packets with pseudo DNS types), CVE-2018-15688 (out-of-bounds write in systemd-networkd DHCPv6 option handling), and CVE-2018-16864/16865/16866 (a systemd-journald exploit).
• Operational oddities such as systemctl treating active→failed as a successful operation, systemctl status taking over 10 seconds when the disk journal is used, and services writing to stdout going silent after a journal restart.

The pattern to take from this list isn't any single bug — it's that a component sitting at PID 1 and touching networking, logging, and resolution has a large blast radius when it fails.

How to get rid of systemd

The site frames this as its own question ("How do I get rid of systemd?"), and there are two routes:

1. Choose a distribution that doesn't ship systemd. This is the low-friction path — you get a supported init (OpenRC, runit, s6, SysVinit, and so on) without fighting the base system.
2. Replace init on an existing install. This is the harder path: you need your chosen init to bring up everything your system depends on, and you need to convert service definitions from systemd units to that init's format.

Either way, the decision comes down to which maintained init you're willing to operate and whether your distribution supports it as a first-class option.

Choosing between them

There's no single "best" alternative — the right pick depends on your constraints:

• If you want the smallest possible supervision layer, look at runit or s6.
• If you want dependency-based service management with a long track record, OpenRC is the common answer.
• If you want the traditional, minimal model, SysVinit still works.
• If you're on a distribution with its own init (Guix's Shepherd, OpenWrt's procd), staying with it is usually simpler than swapping.

Check the maintenance status first: an inactive init means you're on your own for fixes, which matters most for the process running as PID 1.