Osaigbovo Omere

Tiling Engine Hot-Swapping in Hyprland

mail@osaigbovo.xyz (Osaigbovo Omere) — Fri, 01 May 2026 00:00:00 +0000

For a long time, I treated Hyprland’s default layout engine, Dwindle, as an unquestioned standard. It worked. You open a window, it splits the screen. You open another, it splits again. It is organic, fractal, and chaotic.

Recently, while building a landing page for a friend, that chaos became a liability. I needed a highly specific, static geometry: the browser dead centre, my terminal on the right, and my notes on the left. While you can manually resize and shove windows into a semblance of this layout using Dwindle, it lacks mathematical permanence. The moment you open a fourth window to check a reference, the fractal algorithm kicks in and destroys your geometry.

I needed mathematical accuracy. I needed the system to enforce the layout, rather than fighting the system to maintain it.

This led me to abandon Dwindle for structured work and adopt Hyprland’s Master layout, specifically configured for a centred orientation.

The Centred Master

The Master layout enforces a strict visual hierarchy. It designates a primary “master” zone that occupies a fixed mathematical percentage of the screen, and relegates all subsequent windows into subservient “stack” columns.

By setting the orientation to center, the master window is locked in the middle of the monitor, while the stacks form neat pillars in your peripheral vision on the left and right.

A mathematically precise workspace: 50% central focus, 25% peripheral reference columns.

Workspace Engine Swapping

I realised I did not have to choose between the predictable structure of the Master layout and the organic chaos of Dwindle. Hyprland allows you to declare global layout overrides on a per-workspace basis.

I hardcoded my environment to swap engines dynamically. The odd workspaces (1, 3, 5, 7, 9) are strictly governed by the Master layout for development and writing. The even workspaces (2, 4, 6, 8, 10) default to Dwindle for ad-hoc browsing and terminal tasks.

The Dwindle engine running on an even workspace, dividing space recursively.

The Configuration

Below is the exact appearance.conf required to achieve this environment. It enforces the centred master, dictates the workspace rules, and strips out all visual noise–no rounding, no blur, no drop shadows. Just functional geometry snapping into place.

# GENERAL
general {
 gaps_in = 2
 gaps_out = 2
 border_size = 1

 col.active_border = $foreground
 col.inactive_border = $background

 layout = master
}

# DECORATION
decoration {
 rounding = 0

 blur {
 enabled = false
 }

 shadow {
 enabled = false
 }
}

# ANIMATIONS
animations {
 enabled = yes
 bezier = sharp, 0.25, 1, 0.5, 1
 animation = windows, 1, 4, sharp, slide
 animation = windowsOut, 1, 4, sharp, slide
 animation = border, 1, 10, default
 animation = fade, 1, 5, default
 animation = workspaces, 1, 5, sharp, slide
}

# LAYOUT ENGINES
master {
 mfact = 0.50
 orientation = center
 new_on_top = true
 new_status = master
}

dwindle {
 pseudotile = yes
 preserve_split = yes
}

# WORKSPACES

# odds: master layout
workspace = 1, layout:master
workspace = 3, layout:master
workspace = 5, layout:master
workspace = 7, layout:master
workspace = 9, layout:master

# evens: dwindle layout
workspace = 2, layout:dwindle
workspace = 4, layout:dwindle
workspace = 6, layout:dwindle
workspace = 8, layout:dwindle
workspace = 10, layout:dwindle

# MISCELLANEOUS
misc {
 force_default_wallpaper = 0
 disable_hyprland_logo = true
}

Categorical Collapse

mail@osaigbovo.xyz (Osaigbovo Omere) — Thu, 30 Apr 2026 00:00:00 +0000

My timeline regularly fills with an absolutism that genuinely vexes me. People typing out rigid, marketable definitions of highly complex human states with the unearned certainty of a prophet. “Happiness comes from caring more about people.” “Happiness is choosing to see light.”

It is all bullshit.

They deliberately corrupt the category out of pure terror. Stripped of poetic nonsense and religious overlay, happiness, joy, or release is strictly mechanical. It occurs when an organism successfully executes its specific drive state and unburdens its tension.

To a nymphomaniac, sex is happiness. To a true academic, learning is happiness. To a semi-brainwashed human, reproducing is happiness. To a psychopath, killing is happiness. To a systems administrator, a perfectly structured environment is happiness.

The inputs cross every conceivable moral boundary. The mechanical result remains identical. An immediate, overwhelming release for the actor.

People hate this. Acknowledging that biology lacks a built-in moral compass leaves them completely alone in the void, forced to define their own existence without the comfort of a universal scorecard. To escape that terrifying autonomy, they smash a subjective chemical state into a thought-terminating cliché, package it as a pro-social achievement, and lock themselves securely inside it. Mass-produced cowardice masquerading as wisdom.

Firmware of Ruins

mail@osaigbovo.xyz (Osaigbovo Omere) — Thu, 30 Apr 2026 00:00:00 +0000

Watching an African fiercely defend the ideological software used to subjugate his own bloodline induces a very specific, exhausting nausea. You scroll through the timelines and watch them twist themselves into pathetic intellectual knots. They deploy frantic apologist acrobatics, claiming the text is merely a neutral hammer that was unfortunately misused. They point desperately to ancient, isolated sects in Ethiopia, as if a geographical technicality in the Horn of Africa somehow erases the brutal reality of the European gunships, slave ports, and missionaries that anchored on the western coast. It is the absolute highest form of subservience, paid by the asset to the extraction firm. You are watching a conquered people aggressively protect the monuments of their conquerors. They bare their teeth to defend the very chains that bind them.

Eventually, the pure anger burns out. What replaces it is a cold, heavy tragedy. You look at these people and realise you are not arguing with conscious, autonomous actors. You are observing a self-replicating script.

They have been intellectually hollowed out by a multi-generational formatting of their psychological hard drives. To simply call them fools feels insufficient, because a fool implies a poorly made choice. They made no choice. Their ontological framework was hijacked centuries ago. They defend this imported, alien god with such viciousness because they possess a profound, basal terror of the void. If they admit that the religion is a colonial implant–a weapon rather than a universal truth–the entire architecture of their reality collapses. They cling to the cross and the lockets because they have been meticulously conditioned to believe they cannot walk without them. They look at the absolute ruin of their environment and genuinely believe that discarding the white man’s mythology would somehow make them poorer. They are trapped in a psychological cell, and they absolutely love the walls.

To understand how a mind becomes this broken, we have to examine the cold mechanics of why the monsters brought this specific religion to the continent in the first place.

The invasion of Africa was never about saving souls. It was a brutal, sprawling logistical operation designed to feed the industrial engines of Europe. But extracting wealth through continuous physical violence is incredibly inefficient. Bullets cost money. Suppressing endless, bloody rebellion across a massive continent burns vast amounts of capital and manpower. A global extraction engine cannot function optimally if it has to continuously fight the labourers. The colonisers needed a frictionless mechanism to pacify the human substrate.

They needed to introduce a virus.

They imported a theology perfectly engineered to active pacification. The core mechanic of this software is delayed gratification weaponised at a geopolitical scale. You teach a population that poverty is holy. You teach them that the meek shall inherit the earth, conveniently leaving the present, physical earth entirely to the monsters who brought the book. You replace their indigenous, material-focused spiritualities with a system that completely divorces reward from physical reality. You convince an entire continent that physical suffering and the theft of their material resources is simply a down payment for an invisible mansion in the sky.

It was the most devastating psychological heist in human history. The colonisers smashed the local frameworks, hypocritically branding indigenous practices as “idol worship” whilst simultaneously demanding absolute reverence for Roman torture devices, holy water, and the ritualistic consumption of a foreign deity’s flesh. They executed a hostile takeover of the spiritual market because an indoctrinated slave is infinitely cheaper to maintain than a chained one. Fighting a colonial administrator or a corrupt governor becomes completely irrational when your actual, promised reward only activates after your biological processes cease.

The Europeans built physical, tangible heavens in London, Paris, and Lisbon using the blood, gold, and soil of Africa, all while convincing the Africans to patiently wait for a conceptual heaven in the clouds.

And the machine is still running. The foreign administrators left, but they handed the administrative access to local politicians and prosperity pastors who run the exact same firmware. They loot a dying continent, collapse the infrastructure, and tell their congregations to pray harder and wait for divine timing. The ultimate, sickening triumph of this colonial malware is that it successfully mutated the African psyche. We have completely rebranded our absolute political cowardice as spiritual resilience. We endure infinite humiliation and call it faith. We are not strong; we are simply the easiest population on earth to oppress.

The Friction of Babel

mail@osaigbovo.xyz (Osaigbovo Omere) — Wed, 29 Apr 2026 00:00:00 +0000

I am an Edo man who struggles to speak his own language fluently. I am a Nigerian who fumbles with Pidgin, and someone who also finds English a heavy, sometimes painful exercise to speak aloud. Of all the jagged tools available for expression, English happens to be the one I wield with the least resistance. For a long time, this personal disconnect made me shy away from any grand discussions about linguistics, assuming my desire for a monolingual world was simply the byproduct of my own inability to effortlessly absorb new vocabularies.

Yet, looking past that personal insecurity reveals a broader, objective reality: the fragmentation of human language is an exhausting, inefficient architecture.

At its core, language is a tool designed to build bridges between minds. Its fundamental purpose is connection. However, humanity relies on thousands of incompatible bridges, and we romanticise a system that is inherently broken by its own diversity. If the purpose of a tool is to simplify a task, a fragmented tool only introduces profound friction.

Consider the sheer effort we endure daily just to consume art, share information, or experience the world beyond our immediate borders. The fact that a sprawling, thousand-chapter cultivation epic must be placed on hold, leaving readers at the mercy of translators, is a tragedy of logistics. We are perpetually waiting for the rest of the world to be translated for us. When visual media is involved, the friction multiplies. Finding a brilliant foreign film often marks the beginning of a tedious hunt for subtitles. I have spent hours manually adjusting timestamps, even going so far as to write a programme to automate the synchronisation, only to realise that the true problem was the invisible barrier separating the filmmaker’s words from my understanding.

It is a maddening tax we pay simply because humanity cannot agree on a single lexicon.

The logical solution–a unified global language–would eradicate this friction instantly. It would make communication seamless. But this dream is an architectural impossibility, not because of logistics, but because of human nature. The ultimate roadblock to a monolingual world is the inevitable question: Whose language do we choose?

Language is inherently political. It carries the immense weight of history, culture, and dominance. To mandate a single global tongue is to elevate one culture’s operating system above all others. Most people would rightfully view a mandated language as an act of subservience to whichever nation claims ownership of it. We remain fragmented because we cannot agree on who gets to rule the conversation.

And so, the invisible barriers remain rigidly in place. To exist comfortably in China, one must learn Mandarin. For France, French. For Germany, German. We are forced to spend years memorising entirely new lexicons just to validate our existence across an imaginary line on a map.

The world is complex enough. Communication, our primary tool for connection, has simply become another source of modern exhaustion. There is a deep, unspoken weariness in constantly navigating the translation of human thought, and perhaps it is perfectly fine to admit that the endless linguistic fragmentation of our world is profoundly tiring.

A Mapmaker's Lie and Other Poems of April

mail@osaigbovo.xyz (Osaigbovo Omere) — Tue, 28 Apr 2026 00:00:00 +0000

A Mapmaker’s Lie

I am stuck in a mapmaker’s lie,
Where the unbuilt foundations run dry.
It’s a border of ink,
On a ruinous brink,
Just a corporate farm till we die.

Untitled

To smile is a single condition,
A heavily managed position.
But the methods of dying,
Of breaking and crying,
Are endless in their repetition.

The Fool’s Ledge

The candles wait upon the floor,
For steps that never cross the door.
They light a fire meant to blind,
To steal the silence from the mind.

A mirror shows the world ahead,
A crimson thread you learn to tread.
But as you touch the glass to speak,
The edges break, the wood is weak.

The jester’s smile is carved in stone,
While counting all that you have known.
He turns his back on morning light,
And leaves your ghost to face the night.

Untitled

The morning arrives with a glow,
Though progress feels heavy and slow.
With heart in the chase,
And steadying pace,
The seeds that you plant start to grow.

Untitled

There once was a man with no throne,
Who carved out a will of his own,
No figure to praise,
No past to upraise,
He stood and declared himself stone.

Protocols of Ruin

mail@osaigbovo.xyz (Osaigbovo Omere) — Mon, 27 Apr 2026 00:00:00 +0000

We build philosophical heuristics exactly how we build software abstractions. We construct them to protect our minds from the overwhelming, brutal complexity of the underlying machine. When the raw data of human behaviour becomes too heavy to process, we reach for a mental model to parse it for us. For decades, one of the most widely deployed of these models has been Hanlon’s Razor. It commands us to never attribute to malice that which is adequately explained by stupidity. It wears the aesthetic of profound rationality.

A recent observation by Matthew Lyon caused the entire architecture of that aphorism to collapse. Lyon stated cleanly that Hanlon’s Razor itself functions as an incompetent or malicious thought-terminating cliché for dealing with rhetoric. That single sentence dredged up a visceral, unhealed memory of 2023, providing a new framework for a betrayal I had long struggled to articulate.

I used Hanlon’s Razor extensively during that election year. I wielded it as a social sealant, a desperate rationalisation to justify my continued friendship with people who actively supported the ascension of an extraordinarily vile figure to the presidency. As I watched the political landscape curdle, I convinced myself that these friends were simply victims of profound cognitive failure. I forgave them by reducing their agency, deciding they were merely foolish.

The elected regime then proceeded to systematically dismantle every piece of half-functioning infrastructure we had left. It took a geography that had long been pretending to be a country and formally transformed it into a dead country.

In the ruins of that collapse, the truth of their support finally emerged. My friends had not been tricked by rhetoric, nor were they blinded by a lack of education. They supported the destruction because they had received private assurances. They expected to be fixed into positions where the profound failings of the government would simply bypass them. They willingly traded the architectural integrity of the nation for a promised spot in a personal bunker. I had thought them fools. They remain fools, because the political promises of immunity were ultimately empty. However, the core revelation stands. They were monsters operating in their own rational, devastating self-interest.

This exposes the fatal flaw of Hanlon’s Razor. Originally designed as an informal tool to prevent paranoia, it has been entirely weaponised into an alibi for complicity. Mandating that observers must assume incompetence before malice creates a system where malicious actors are highly incentivised to adopt the camouflage of stupidity. If a politician or an institution can destroy a nation’s future and be defended by philosophers insisting they simply did not know any better, incompetence ceases to be a failure state. It functions as a highly effective legal and moral shield. Hanlon’s Razor pardons this precise brand of monstrosity by framing it as a deficit of intelligence. It demands we treat calculated, systemic selfishness as innocent incompetence.

Surviving the modern era requires us to abandon the prosecution of intent. We spend an absurd amount of energy trying to peer into the hearts of corrupt administrators and failing institutions to determine their internal motivations. That distinction is a luxury we can no longer afford.

We must adopt the cybernetic principle articulated by Stafford Beer. POSIWID dictates that the purpose of a system is what it does. Intentions, stated goals, and original blueprints hold absolutely no weight when evaluating a functioning architecture. In systems engineering, if a script explicitly written to secure a database instead wipes the servers clean every Sunday at midnight, the intention of the developer is structurally irrelevant. The system is a deletion engine. Leaving the system running constitutes authorisation of the deletion.

Applied to human architecture–governments, economies, friendships–POSIWID acts as a brutal, clarifying lens. A political regime that consistently produces immiseration, extraction, and dead infrastructure must be judged exclusively by those outputs. We must stop asking if they are making mistakes. The purpose of their system is to extract and destroy. Intentions are invisible, unprovable, and easily fabricated. Consequences are physical, measurable, and inescapable. Action and result define the tool. A hammer that consistently shatters the wood rather than driving the nail must be categorised strictly as a wood-shattering device. Its identity is forged entirely in its physical friction with reality, completely divorced from the aspirations of the blacksmith who cast it.

We require a new heuristic to replace the outdated comfort of Hanlon. We can establish this as Lyon’s Razor. It dictates that whenever incompetence is consistently invoked to protect a harmful system, the invocation itself constitutes an act of malice. This razor removes the luxury of pleading ignorance. It recognises that incompetence, deployed at scale, serves as a calculated operational strategy. If the direct result of a supposedly foolish action repeatedly serves the actor’s self-interest at the expense of the wider ecosystem, that foolishness functions seamlessly as a calculated weapon.

Believing the world is broken simply because its administrators are stupid offers a terrifying comfort, implying the system can be fixed with education or better data. Malice, conversely, demands confrontation. I am done granting the benefit of the doubt to the architects of ruin. I am done using thought-terminating clichés to protect myself from the reality of the people around me. The razor is dull. We must now judge the machine strictly by its output.

What is The Fediverse?

mail@osaigbovo.xyz (Osaigbovo Omere) — Sat, 25 Apr 2026 00:00:00 +0000

The Fediverse is a collection of independent servers communicating via a shared protocol. The primary protocol is ActivityPub. It standardises the transmission of text, images, and user states across disparate hardware. This infrastructure eliminates the central authority of a single corporate entity, distributing server costs, moderation policies, and data ownership across the network participants.

The Nigerian digital landscape currently lacks native ActivityPub infrastructure. Users operating from Nigeria rely exclusively on foreign hardware. This manual establishes the structural architecture of the Fediverse, defining the specific hierarchy required to operate within it and detailing the operational differences between its software platforms.

The Structural Hierarchy

The network organises into three distinct tiers: Domains, Instances, and Communities.

Domains represent the foundational software platforms. Mastodon, Lemmy, and Pixelfed are Domains. They define the data structure–whether the platform processes micro-blogs, threaded forum discussions, or image galleries.

Instances are the physical or virtual servers running the Domain software. A Domain is a blueprint; the Instance is the deployed reality. Users register accounts on Instances, not Domains. The Instance dictates the moderation policy, the data storage limits, and the exact version of the Domain software in operation.

Communities exist exclusively within specific Domains–primarily Lemmy and PieFed. They are categorised data hubs. An Instance hosts the overall platform, while Communities segment the users and posts into subject-specific architectures.

The Protocol Interoperability Friction

The ActivityPub protocol enables cross-Domain communication. A user on a Mastodon Instance can follow and reply to a user on a Pixelfed Instance. The mechanical reality of this interaction is highly flawed.

Interacting across Domains requires heavy protocol translation. When a Mastodon Instance processes a post from a Lemmy Instance, it attempts to map a threaded, subject-based forum structure onto a chronological micro-blogging interface. The translation strips metadata. Threaded replies flatten into a single chronological timeline. Context is destroyed. Voting mechanics–such as Lemmy’s upvote and downvote system–fail to register on Mastodon, which only recognises ‘favourites’ and ‘boosts’.

Complete functionality requires native accounts within each Domain. To interact with the Lemmy network without data degradation, a user must operate a Lemmy account. Cross-Domain federation is a baseline fallback for visibility–it is not a substitute for native interaction.

The Microblogging Domain

Mastodon is the primary microblogging Domain. It processes short-form text, links, and media attachments. It broadcasts these data packets to followers in a strict chronological feed.

The core Mastodon software dictates specific limitations, leading to the creation of competing software forks. These forks operate on the same ActivityPub protocol but alter the local Instance capabilities.

Glitch-soc is a modified version of Mastodon. It adds local-only posting capabilities, allowing users to broadcast messages exclusively to their Instance without federating the post to the broader network. It includes advanced text formatting options and structural modifications to the user interface.

Hometown is another fork, built upon Glitch-soc. It prioritises localised interaction over global federation. It allows Instance administrators to restrict specific posts from leaving the Instance server, creating isolated digital environments while maintaining the ability to read external data.

Akkoma and Pleroma are lightweight microblogging alternatives to Mastodon. They demand significantly less server hardware to operate. They process data faster but feature brutalist user interfaces and lack some of Mastodon’s advanced filtering tools.

Connecting to the Microblogging Domain requires client software. Users access Mastodon and its forks via dedicated applications. Ice Cubes and Tusky pull data from the Instance via APIs, displaying the feed on mobile devices. The client software handles the interface; the Instance handles the data storage.

The Aggregation Domain

Lemmy structures data as threaded discussions. It is an aggregation Domain. Users submit links or text blocks, and the network ranks them based on user interactions.

The Lemmy architecture introduces the Community tier. A Community is established on a specific Lemmy Instance. Users from any Lemmy Instance can subscribe to that Community. The host Instance stores the original data; subscriber Instances cache copies of the data for local users.

Kbin is an alternative aggregation Domain. It attempts to merge the microblogging interface of Mastodon with the threaded structure of Lemmy. It allows users to post short-form microblogs alongside long-form threaded articles. This dual-structure creates database bloat and increases the difficulty of cross-Domain federation.

Client applications for the Aggregation Domain include Mlem and Voyager. These applications interpret the nested threading and voting mechanics specific to Lemmy and Kbin, presenting the data efficiently on mobile hardware.

The Visual Domain

Pixelfed processes image galleries. It mimics the interface of centralised image-sharing platforms. It applies filters, organises media into albums, and federates these images across the ActivityPub network.

PeerTube processes video data. It operates a peer-to-peer distribution model. When multiple users watch a video on a PeerTube Instance, the software utilises their local network bandwidth to share the video data among them, reducing the load on the host server.

Infrastructure and Deployment in Nigeria

The complete absence of Nigerian Fediverse Instances creates a dependency loop. Nigerian users generate data that is stored and monetised by foreign hardware operators. Establishing sovereignty requires local deployment.

Deploying an Instance requires a Virtual Private Server (VPS), a domain name, and an object storage bucket for media assets. The administrator configures a reverse proxy–typically Nginx or Caddy–to route incoming traffic to the ActivityPub software. The Instance stores user data in a PostgreSQL database.

Instances scale through horizontal federation, but database management dictates survival. Every time an Instance user follows an external account, the local database must process and store the incoming data packets from that external Instance. Without aggressive caching limits and automated media purging, the local database will exhaust the server’s storage capacity.

Security must focus on the infrastructure level. Dependency chains in software deployment present vulnerabilities. Relying on bloated package managers introduces supply chain risks. Administrators must utilise system-native build tools and restrict network access to the database layer via strict firewall configurations.

Moderation is a mechanical process. Spam and malicious data propagate through federation. The administrator executes server blocks (defederation) to sever the connection between the local Instance and the offending external Instance. This drops all incoming packets from the blocked server at the protocol level.

The Mechanical Failure of Cross-Domain Communication

The assertion that the Fediverse is a single, unified social network is a marketing fiction. It is a collection of disparate software architectures forced to communicate through a lowest-common-denominator protocol.

ActivityPub operates on a system of Actors, Inboxes, and Outboxes. When a user on a Mastodon Instance publishes a post, the software wraps the text and media in a JSON-LD data object. The Instance server then queries the database for every external Instance where a follower resides. It fires this JSON-LD object directly into the Inboxes of those external servers.

This works efficiently within the Microblogging Domain. Mastodon to Mastodon communication is native. Mastodon to Hometown communication is near-native. The database structures expect chronological, short-form data.

The structural failure occurs when data crosses Domains. Lemmy is an Aggregation Domain. It does not natively understand chronological timelines. It understands hierarchical trees–a root post, followed by nested replies, ranked by numerical scores.

When a Lemmy user comments on a Mastodon post, the Lemmy Instance wraps the comment in an ActivityPub object and sends it to the Mastodon Instance. Mastodon receives the object, fails to comprehend the nested threading context, strips the relational metadata, and appends the text as a flat, chronological reply.

When a Mastodon user attempts to participate in a Lemmy Community, the failure is reversed. Mastodon has no concept of ‘Communities’–it only understands ‘Users’. To interact with a Lemmy Community from Mastodon, the Mastodon user must address the Community as if it were a single user account (e.g., @technology@lemmy.world). The Mastodon software then blasts the reply into the Lemmy Community. The Lemmy software attempts to parse this, but because the Mastodon user cannot transmit an upvote or downvote, their interaction is structurally crippled. The Mastodon user is permanently locked out of the core mechanic of the Aggregation Domain.

To operate effectively across the Fediverse, users must establish separate accounts native to each Domain. A user requires a Mastodon account for microblogging, a Lemmy account for aggregation, and a Pixelfed account for image distribution. Treating ActivityPub as a universal translator destroys data fidelity.

Advanced Domain Analysis: Microblogging

The Microblogging Domain is saturated with Mastodon instances. Mastodon is written in Ruby on Rails. It is notoriously resource-heavy. It requires Redis for job queuing, PostgreSQL for data storage, and Node.js for streaming connections. This hardware requirement creates a barrier to entry for independent operators.

Pleroma and Akkoma solve the hardware bloat. They are written in Elixir. They require a fraction of the RAM needed by Mastodon. An Akkoma Instance can run on a single-core Virtual Private Server with 1GB of RAM, servicing dozens of users.

Akkoma introduces Custom Emoji Reactions–a feature absent from native Mastodon. When an Akkoma user reacts to a post with a custom emoji, the ActivityPub object transmits this reaction. If the receiving Instance is Mastodon, the Mastodon software silently drops the reaction because its database schema does not support it. This illustrates the core problem of protocol fragmentation: advanced features are trapped within specific software forks.

Misskey and FoundKey represent the hyper-interactive branch of the Microblogging Domain. They integrate complex drive storage systems, massive custom emoji integration, and widget-based dashboards. They generate extreme database traffic. A Misskey Instance federating with a standard Mastodon Instance often overwhelms the Mastodon server with reaction data and protocol requests.

Advanced Domain Analysis: Long-Form and Audio

WriteFreely and Plume define the Publishing Domain. They process long-form text. They do not operate on chronological feeds. They structure data as static blogs. When a WriteFreely article federates to Mastodon, Mastodon truncates the text and provides a hyperlink back to the host Instance. The interaction happens on Mastodon, but the reading happens on WriteFreely.

Funkwhale defines the Audio Domain. It is a decentralised audio hosting and streaming platform. Users upload music or podcasts, and the software structures the data into libraries. These libraries federate via ActivityPub. A Mastodon user can follow a Funkwhale library and receive audio tracks in their timeline, but they cannot natively browse the nested albums without accessing the Funkwhale interface directly.

The Nigerian Imperative: Server Sovereignty

Operating within the Fediverse without owning infrastructure is digital sharecropping. Nigerian users are currently generating data that populates European and American databases. The administrators of these foreign instances hold absolute power over the data. They can terminate accounts, purge databases, or sever federation links at their discretion.

To establish digital sovereignty, Nigerian operators must deploy native infrastructure.

Database Architecture and Hardware Reality

Deploying an Instance is an exercise in database management. PostgreSQL is the central organ of the Fediverse. Every text post, every image link, and every follower relationship is a row in a PostgreSQL table.

When an Instance connects to the wider Fediverse, the database balloons. A single user following 100 active accounts on external Instances will force the local server to download, process, and store thousands of JSON-LD objects daily.

Nigerian deployments must prioritise aggressive pruning. Administrators must configure scheduled tasks (cron jobs) to delete cached media and stale posts from external Instances. Without strict retention policies, a 100GB storage volume will fill in weeks.

Security and Supply Chain Isolation

System integrity is paramount. Relying on pre-packaged installation scripts obscures the software architecture and introduces external vulnerabilities.

Administrators should compile software from source or utilize strict, minimal containerization. The avoidance of vast, unregulated package registries–such as the Node Package Manager (npm)–is critical for securing the server environment against supply chain poisoning. Build from the metal up. Verify the source code.

Configure the server firewall to drop all incoming traffic except ports 80 (HTTP), 443 (HTTPS), and 22 (SSH). Isolate the database. Ensure PostgreSQL only listens on the localhost interface. Never expose the database to the open internet.

The Moderation Mechanic

The Fediverse lacks a central authority. Moderation is executed at the Instance level. It is a brutal, mechanical process.

Administrators wield two primary tools: Silencing and Suspending.

Silencing an external Instance hides its users from the local public timelines. The data still enters the local database, and local users can still explicitly follow those accounts, but the data is removed from public discovery.

Suspending an external Instance severs the ActivityPub connection entirely. The local server drops all incoming requests from the suspended server. The database ceases to store its data. This is the ultimate defensive mechanic against spam networks and malicious domains.

African instances must heavily utilize proactive suspension. The global Fediverse is saturated with automated scrapers and malicious actors. Maintaining a functional Instance requires an aggressive defederation policy. Connect only to trusted Instances. Cut the rest off at the protocol level.

My Arch Install

mail@osaigbovo.xyz (Osaigbovo Omere) — Wed, 22 Apr 2026 00:00:00 +0000

1. Pre-Flight

Boot the Arch live USB in UEFI mode. Confirm it:

ls /sys/firmware/efi/efivars

Set the keymap immediately. You will be typing a LUKS passphrase shortly, and the default US layout will silently mangle it.

loadkeys uk

Connect to the network and synchronise the clock:

ping -c 3 archlinux.org

# wireless if needed
iwctl
# station wlan0 scan
# station wlan0 connect <ssid>

timedatectl set-ntp true
timedatectl status

2. Storage Architecture

The partition layout is straightforward:

Partition	Size	Role
`/dev/nvme0n1p1`	1 GiB	EFI System Partition — vfat, unencrypted
`/dev/nvme0n1p2`	2 GiB	`/boot` — ext4, unencrypted
`/dev/nvme0n1p3`	~253 GiB	LUKS2 container

Inside the LUKS container, LVM carves out four volumes:

Volume	Size	Filesystem
`vg0/swap`	16 GiB	swap
`vg0/root`	50 GiB	XFS
`vg0/var`	20 GiB	XFS
`vg0/home`	~167 GiB	XFS

16 GiB of swap is twice the physical RAM. That covers hibernation without spilling.

2.1 Wipe the Drive

wipefs -a /dev/nvme0n1

2.2 Partition

parted -s /dev/nvme0n1 mklabel gpt

parted -s /dev/nvme0n1 mkpart ESP fat32 1MiB 1025MiB
parted -s /dev/nvme0n1 set 1 esp on

parted -s /dev/nvme0n1 mkpart primary ext4 1025MiB 3073MiB
parted -s /dev/nvme0n1 mkpart primary 3073MiB 100%

2.3 Encrypt the Root Partition

cryptsetup luksFormat --type luks2 --cipher aes-xts-plain64 --key-size 512 /dev/nvme0n1p3
cryptsetup open /dev/nvme0n1p3 cryptroot

/boot sits on its own unencrypted partition — GRUB reads it directly. GRUB_ENABLE_CRYPTODISK is not needed here.

2.4 LVM

pvcreate /dev/mapper/cryptroot
vgcreate vg0 /dev/mapper/cryptroot

lvcreate -L 16G -n swap vg0
lvcreate -L 50G -n root vg0
lvcreate -L 20G -n var vg0
lvcreate -l 100%FREE -n home vg0

2.5 Format

mkfs.vfat -F32 /dev/nvme0n1p1
mkfs.ext4 /dev/nvme0n1p2

mkfs.xfs /dev/vg0/root
mkfs.xfs /dev/vg0/var
mkfs.xfs /dev/vg0/home
mkswap /dev/vg0/swap

2.6 Mount

mount /dev/vg0/root /mnt
mkdir -p /mnt/{boot/efi,home,var}

mount /dev/nvme0n1p2 /mnt/boot
mount /dev/nvme0n1p1 /mnt/boot/efi
mount /dev/vg0/var /mnt/var
mount /dev/vg0/home /mnt/home
swapon /dev/vg0/swap

3. Base Installation

pacstrap -K /mnt \
 base base-devel linux linux-headers linux-firmware \
 intel-ucode \
 lvm2 cryptsetup xfsprogs e2fsprogs dosfstools \
 neovim tmux git networkmanager man-db man-pages sudo \
 mesa vulkan-intel intel-media-driver \
 hyprland waybar rofi-wayland \
 xdg-desktop-portal-hyprland xdg-desktop-portal-gtk \
 xdg-user-dirs polkit-gnome \
 ly \
 kitty wl-clipboard grim slurp \
 hypridle hyprlock mako \
 pipewire pipewire-alsa pipewire-pulse pipewire-jack wireplumber pavucontrol \
 bluez bluez-utils \
 tlp tlp-rdw acpid brightnessctl \
 ttf-ibm-plex noto-fonts noto-fonts-emoji ttf-jetbrains-mono-nerd

Then generate the filesystem table:

genfstab -U /mnt >> /mnt/etc/fstab
cat /mnt/etc/fstab

4. System Configuration

arch-chroot /mnt

4.1 Timezone and Locale

ln -sf /usr/share/zoneinfo/Africa/Lagos /etc/localtime
hwclock --systohc

sed -i 's/^#en_GB.UTF-8 UTF-8/en_GB.UTF-8 UTF-8/' /etc/locale.gen
locale-gen
echo "LANG=en_GB.UTF-8" > /etc/locale.conf

4.2 Keymap

localectl requires a running systemd instance. Inside arch-chroot it will either fail silently or error out, leaving you with no keymap on first boot. Write directly to vconsole.conf instead — the keyboard and keymap mkinitcpio hooks read it automatically.

echo "KEYMAP=uk" > /etc/vconsole.conf

4.3 Network Identity

echo "arch" > /etc/hostname

cat <<EOF > /etc/hosts
127.0.0.1 localhost
::1 localhost
127.0.1.1 arch.localdomain arch
EOF

systemctl enable NetworkManager

4.4 Initramfs

Edit /etc/mkinitcpio.conf and set the HOOKS array. The ordering is not optional — encrypt must come before lvm2, and resume must follow lvm2.

HOOKS=(base udev autodetect microcode modconf kms keyboard keymap consolefont block encrypt lvm2 resume filesystems fsck)

nvim /etc/mkinitcpio.conf
mkinitcpio -P

5. Bootloader

pacman -S grub efibootmgr

Get the UUID of the LUKS partition:

blkid /dev/nvme0n1p3

Edit /etc/default/grub. Set GRUB_CMDLINE_LINUX:

GRUB_CMDLINE_LINUX="cryptdevice=UUID=<uuid>:cryptroot root=/dev/mapper/vg0-root resume=/dev/mapper/vg0-swap"

Replace <uuid> with the actual string from blkid. The resume= parameter enables hibernation via the swap LV. Drop it if you do not need hibernation.

nvim /etc/default/grub

Install and generate the config. The --removable flag writes a fallback EFI entry that survives firmware resets.

grub-install --target=x86_64-efi --efi-directory=/boot/efi \
 --bootloader-id=GRUB --removable

grub-mkconfig -o /boot/grub/grub.cfg

6. User Management

passwd

useradd -m -s /bin/bash -G wheel,video,audio,storage,input osaigbovo
passwd osaigbovo

# uncomment: %wheel ALL=(ALL:ALL) ALL
EDITOR=nvim visudo

The input group is required for Wayland input device access under Hyprland.

7. Desktop Services

Enable everything before the first reboot:

systemctl enable ly
systemctl enable bluetooth
systemctl enable tlp
systemctl enable tlp-rdw
systemctl enable acpid

# tlp manages rfkill — mask the systemd units to avoid conflicts
systemctl mask systemd-rfkill.service systemd-rfkill.socket

Pipewire runs as a user session service, not a system service. On first login, enable it as your user:

systemctl --user enable --now pipewire pipewire-pulse wireplumber
systemctl --user enable --now xdg-desktop-portal-hyprland

7.1 Hyprland Configuration

Add these to ~/.config/hypr/hyprland.conf to start the essential session components:

exec-once = /usr/lib/polkit-gnome/polkit-gnome-authentication-agent-1
exec-once = mako
exec-once = waybar
exec-once = hypridle

The UHD 620 needs a few environment variables set for correct VA-API, cursor rendering, and Qt/Firefox Wayland compatibility:

env = LIBVA_DRIVER_NAME,iHD
env = WLR_NO_HARDWARE_CURSORS,1
env = XDG_SESSION_TYPE,wayland
env = XDG_SESSION_DESKTOP,Hyprland
env = QT_QPA_PLATFORM,wayland
env = MOZ_ENABLE_WAYLAND,1

8. Finalisation

exit

swapoff -a
umount -R /mnt
vgchange -an vg0
cryptsetup close cryptroot

reboot

On reboot: GRUB hands off to the kernel, the initramfs prompts for the LUKS passphrase, LVM activates, root mounts, ly presents the login, and Hyprland takes over.

Cats & Dogs

mail@osaigbovo.xyz (Osaigbovo Omere) — Thu, 16 Apr 2026 00:00:00 +0000

Society aggressively markets a cartoonish narrative of the independent man, portraying him as a stoic actor moving freely through the world. History and reality tell an entirely different tale. Patriarchal systems, military hierarchies, and industrial capitalism require rigid, disposable utility. They require absolute obedience. To extract this efficiently, the governing architecture attached the entirety of the male ego to the concept of usefulness. A man is conditioned from birth to measure his exact worth by his capacity to serve the machine–to produce capital, to wage war, to maintain infrastructure. When he ceases to provide measurable utility, society revokes his value. He is shamed by his peers and discarded as purposeless. Terrified of the social void awaiting those who refuse to be used, men eagerly submit to the hierarchy and furiously police their own cages.

We can observe this conditioning through a brutal heuristic: men have been systematically bred for the behavioural traits of dogs, while women have been forced to adopt the survival strategies of cats.

The state demands that a man obey commands, protect the property of his betters, and remain fiercely loyal to a hierarchy that routinely treats him as expendable. He marches in a straight line because his reality punishes deviation with immediate obsolescence. He equates his compliance with honour. Women, historically excluded from formal institutional power, developed a profoundly different relationship with reality. Lacking direct authority over the levers of the machine, their survival mandated intense, calculating adaptability. They had to read the room, map the shifting emotional and political dynamics of the men hoarding the resources, and manipulate their circumstances accordingly. They navigate. Men simply obey.

Parasites

mail@osaigbovo.xyz (Osaigbovo Omere) — Wed, 15 Apr 2026 00:00:00 +0000

Kings and states have always understood that a workforce cannot be motivated by happiness. Sitting in a trench or breaking rocks in a mine is fundamentally miserable, forcing the governing architecture to invent a highly abstracted metric to keep the machine running. They called it purpose. Purpose serves as perverted happiness, an ideological software installed primarily into men to convince them to willingly defer their own release for the benefit of the state. That traditional social contract has now collapsed. The post-industrial economy no longer requires a mass of rigid, physical male utility, leaving millions of men adrift and deprived of the hierarchy that historically dictated their exact value. Panicking in the absence of orders, they desperately seek a new structure to submit to.

A highly lucrative parasite class stepped effortlessly into this vacuum. The internet is currently infested with algorithmic alpha males, scammy, big-bearded, roided-up talking heads, and podcast hosts who have privatised the state’s old extraction engine. They look at a generation of men terrified of their own autonomy and sell them a manufactured purpose. These grifters deploy the rhetoric of liberation, casting themselves as rebels fighting a metaphorical Matrix while actually franchising the exact architecture of extraction they claim to oppose. They feed directly on male dread, converting the deep, historical desire for obedience and structure into course fees, engagement metrics, and premium subscriptions. They offer a cartoonish script of masculinity to men begging for someone to finally tell them what to do.

Linux is a Religion

mail@osaigbovo.xyz (Osaigbovo Omere) — Fri, 10 Apr 2026 00:00:00 +0000

Watching a digital crusade unfold in real-time on a Lemmy forum a few days ago, I was struck by a terrifying realisation. Dozens of users were locked in a fierce, polite, yet utterly unyielding holy war, each attempting to convert the heathens to their preferred Linux distribution. The rhetoric was indistinguishable from 16th-century theological debates, just heavily seasoned with acronyms. Unable to resist the gravitational pull of my own ego, I dropped a comment noting that I use Arch–a statement that effectively marks me as a fundamentalist. Seven people starred it. The dopamine hit was immediate, and deeply shameful.

There is a unique kind of dread that creeps up on you when you have spent two decades walking the earth as a committed atheist, viewing faith communities with the polite, anthropological distance of someone who considers theological devotion a cognitive defect, only to wake up one morning and realise you have accidentally joined a cult. I have become doctrinaire. I am devotional. I become quietly, irrationally furious when I see someone using apt instead of pacman. I have stumbled backward into the Linux, open-source, and privacy ecosystem and discovered a complete, all-encompassing theological system to fawn over.

Calling a subculture a “religion” is usually just a lazy linguistic shortcut to describe people who care a little too much about CrossFit or veganism. But a true religion does specific, heavy lifting for the human psyche. It provides a cosmology: an account of how the universe is structured and the foundational values holding it together. It produces orthodoxy, aggressively policing the boundary between correct belief and heresy. It generates an eschatology–a prophetic vision of how the world will ultimately end. It relies on highly specific rituals to mark the initiate against the uninitiated. Finally, it reproduces itself through conversion experiences that believers inevitably describe as “seeing the light.”

The Linux community executes every single one of these functions with terrifying, structural precision.

Every religion requires a Genesis myth and a pantheon of prophets. Our foundational cosmology is the free software philosophy, and like all cosmologies worth dying for, it is a moral position disguised as a technical one. In the beginning, the code was closed, and darkness was upon the face of the mainframe. Then came Richard Stallman.

Stallman did not launch the GNU Project in 1983 because he crunched the numbers and calculated that open-source collaboration would yield fewer bugs. He launched it because he experienced a profound moral revulsion at the idea of proprietary software. To Stallman, a world where humans could not read, modify, and share the tools they depended on was a world where human autonomy had been fatally violated. He once wrote that he could have amused himself writing code for money, but knew that at the end of his career, he would look back on “years of building walls to divide people.” That is pure, unadulterated Old Testament prophet energy. Stallman views proprietary software the way an exorcist views a demon. To him, the General Public License (GPL) is an unbreakable covenant holding the forces of corporate enclosure at bay. “Free as in speech, not as in beer.” That distinction is the rock upon which the church is built.

Then came Linus Torvalds, the architect of the kernel itself. Torvalds is the New Testament pragmatist. He does not share Stallman’s rigid theology, once famously quipping, “Talk is cheap. Show me the code.” Torvalds is interested in what actually works, what compiles, and what scales, rather than maintaining absolute doctrinal purity.

The tension between the Stallmanite moralists and the Torvalds pragmatists is the defining schism of the ecosystem. It is a disagreement over the fundamental nature of the shared project: What are we building this for? Who does it serve? What compromises will condemn our souls to the corporate abyss? Consequently, every single Linux distribution is forced to take a position in this theological landscape.

Debian is the ancient orthodox church. Its commitment to free software purity is absolute. The installation is archaic, the packages are old, and the aesthetic is unforgiving, but it is ideologically flawless. Debian’s willingness to make your life difficult in exchange for ideological consistency is a pure confession of faith.

Ubuntu is the megachurch. It has the fog machines, the coffee shop in the lobby, and the charismatic pastor wearing trainers. Ubuntu looked at the masses and decided that the church had to grow, even if it meant shipping proprietary drivers and pushing Snap packages onto the congregation. In doctrinal terms, Ubuntu made concessions to the secular world, making an easy path available–a move the orthodox view as an unforgivable temptation.

Rocky Linux and the broader Red Hat Enterprise ecosystem sit in the Benedictine tradition. They are the enterprise monks: conservative, stable, and deeply uninterested in whatever shiny new toy the desktop users are arguing about. They patch what is known, certify what is tested, and serve massive financial institutions whose only prayer is five nines of uptime. I run Rocky in an Incus virtual machine right now while working through my CompTIA Linux+ certification, and I say this with reverence: there is deep, quiet dignity in an operating system that is exactly what it promises to be, and absolutely nothing else.

Alpine is the monastery clinging to the side of a frozen mountain. Ascetic to the point of near-invisibility, it uses musl instead of glibc and BusyBox instead of GNU coreutils. The container world reveres Alpine because it boots in milliseconds, occupies five megabytes of disk space, and does precisely what it is told without ever speaking out of turn. It simply exists, minimal and correct, like a hermit who has transcended the need for human language.

Of course, no religion is complete without a vividly imagined Hell, and our world is well supplied with heretics and demons.

The deepest, most fiery pit of Hell is Windows. Windows is Babylon. It is a corrupted, bloated leviathan powered by telemetry, forced updates, and corporate surveillance. To use Windows is to willingly sign over your digital sovereignty to a faceless corporation that views you not as a user, but as a harvestable data crop. Every time Microsoft injects an advertisement into the Start menu, a Linux user gets their wings.

macOS occupies a much more complex theological space: Limbo, or perhaps an exceptionally well-decorated Purgatory. It shares ancient Unix genetic material with the faithful, allowing you to open a terminal and use grep, awk, and sed just like the prophets intended. But the ecosystem is a gilded cage. It is utterly closed, unmodifiable, and strictly controlled by a trillion-dollar corporation with very aggressive opinions about what you are allowed to do with hardware you supposedly own. The people trapped in the Apple ecosystem are capable individuals who have simply chosen aesthetic comfort over freedom.

I say this with the sheepish awareness of someone who actually discovered the command line on a 2018 MacBook Air. That machine was my gateway drug. I found the terminal, realised it was just a zsh emulator, and discovered it could be modified. That tiny distinction–realising the interface was just a mask over the machine–cracked my entire reality open.

My conversion began in earnest last August. Looking at my university degree and the catastrophic state of the Nigerian economy, I concluded that my current trajectory was not going to produce a liveable income. I discovered the concept of DevOps, and subsequently fell headfirst into the Linux rabbit hole. These two events are linked in the same way a first sip of whiskey is linked to waking up in a different state.

I started on that MacBook Air, copying someone’s zshrc configuration from GitHub. I tweaked it, broke it, fixed it, and eventually built a highly customised terminal environment I pretentiously named Aethria Systems. Every time I added a new alias or changed the colour scheme, I versioned it, eventually stopping at version 2.1. It was an objectively absurd amount of emotional and intellectual investment poured into a text configuration file, and I regret absolutely nothing.

My secondary machine was a Lenovo ThinkPad bloated with Windows. I discovered the Windows Subsystem for Linux (WSL2), spent weeks learning the basic incantations of the command line, and eventually grew disgusted by the layer of Microsoft abstraction. I moved to VirtualBox, successfully installed Ubuntu, and decided that was what I would eventually install on bare metal.

Then, a friend intervened. He told me to use Arch.

He delivered the recommendation with the wild-eyed, terrifying conviction of a man who had just returned from the mountaintop with stone tablets. He was relentless. I deleted my Ubuntu ISOs, ordered a blank USB stick, and spent the seven days before its arrival in a state of monastic preparation. I installed, wiped, and reinstalled Arch Linux inside VirtualBox dozens of times, memorising disk partitioning commands and learning to mount file systems. When the stick arrived, I wiped the ThinkPad and installed Arch on bare metal. By November, I had abandoned traditional desktop environments entirely, moving to Hyprland–a dynamic tiling window manager that operates entirely on keyboard shortcuts and requires forty hours of writing C++ configuration files to make it beautiful.

In this religion, the installation is the initiation ritual. Most consumer distributions feature graphical installers that hold your hand, make complex partitioning decisions on your behalf, and deposit you gently into a working desktop. This is pragmatically wonderful and theologically bankrupt. The person who clicks “Next” six times knows they are using Linux; the person who manually formats their EFI partition, compiles their bootloader, and spends a week wrestling with Wayland compositors knows their machine.

These are profoundly different states of knowledge, and the community treats them as such. Outsiders experience this dynamic as toxic gatekeeping; insiders experience it as necessary discernment. You cannot appreciate the cathedral if you did not haul the stones. The Arch Wiki serves as our scripture–vast, exhaustively accurate, and completely unforgiving. It punishes lazy reading and rewards deep meditation. During my initiation, I wrote a comprehensive, step-by-step installation guide based on my own agonising trial and error.

Months later, the very friend who had aggressively evangelised Arch to me decided he was finally ready to install it on his own machine. I went to his house to gloat about my Hyprland workflow, feeling like a twenty-four-year-old wizard manipulating the fabric of the digital universe. I opened his laptop and discovered he was running Manjaro.

Manjaro occupies a highly contested category. It is an Arch-derivative–close enough to the real thing that pure Arch users take its existence as a personal insult. My friend confessed he had attempted to install pure Arch using ChatGPT as his spiritual guide. It had been a bloodbath of hallucinated commands and destroyed partition tables. In a moment of weakness, he downloaded the Manjaro graphical installer and clicked his way to a working desktop.

I offered absolutely no charity. I mocked him with the zeal of a medieval inquisitor.

Later that evening, overcome with guilt, he called me. He was going to wipe the drive and attempt the true path again. He complained the official wiki was too dense, so I sent him my personal guide. An hour later, he called back in despair, staring at a black screen. He had forgotten to install the GRUB bootloader, and informed me that my guide–heavy on rambling philosophical tangents–was actually worse than the wiki. He returned to his AI companion, and they finished the installation together. The deeply unnatural relationship between my friend and his large language model is a matter I refuse to comment on further.

Eventually, I went back to his house and we wiped the machine one last time. I wrote a physical list of checkpoints on a piece of paper. We moved through the ritual manually: Partitioning. Base install. Fstab. Chroot. Bootloader. NetworkManager. Every time we cleared a hurdle, I placed a tick on the paper. He finally achieved a working, pure Arch installation. His soul was saved.

Which brings me back to Lemmy. A few weeks after saving my friend’s soul, I saw a new user asking for a graphical user interface to install packages on Arch. Without a second thought, I typed: If you need a GUI to install packages on Arch, perhaps you should not be using Arch.

My cursor blinked. When exactly did I become this person? When did I mutate into the insufferable gatekeeper standing at the threshold of the temple, demanding purity tests from the peasants?

I hit reply anyway. pacman is the greatest package manager ever coded, and I stand by the architectural substance of the comment. The elitist tone is something I am still unpacking in my quieter moments.

Evangelism is the specific feature of religious communities that generates the maximum amount of friction with the secular world, but it is worth examining why it happens. It is the inescapable consequence of a cosmology that includes a definitive theory of the good life. If you genuinely believe that software freedom matters–that understanding the tools mediating your reality is a moral imperative–then telling your family about Linux is not enthusiasm. It is an act of deep concern. To the outsider, the Linux evangelist is offering incredibly annoying advice about a software preference. To the insider, it is a desperate moral intervention to save a loved one from the Matrix.

And like all faiths, we have an eschatology. We call it the “Year of the Linux Desktop.” It is the most affectionate, enduring joke in the community because it is also the most sincere, desperate hope. Every year, a prophet emerges to announce that the mainstream breakthrough is imminent. Every year, the rapture is delayed. Yet the hope is never fully abandoned. Valve’s Steam Deck has done more to advance desktop adoption in three years than a decade of screaming advocacy. The hardware compatibility nightmare is largely over.

We keep building. We keep writing exhaustive documentation. Another teenager discovers the terminal. Another person wipes Windows and installs Arch. You do not abandon the faith just because the timeline slipped again; you continue because the work itself is the justification.

I have watched communities close themselves off in the name of rigid orthodoxy. I have watched the pastoral function of religion get weaponised into raw political control. I have spent my life rolling my eyes at zealots.

And then I found an operating system. I developed a cosmology, a theory of the good life, and a set of digital values I will absolutely refuse to compromise. I sit in my room writing scripts to automate things that do not need to be automated. I walk friends through ancient initiation rituals, checkbox by checkbox. I post arrogant, gatekeeping comments on decentralised forums and feel a rush of righteous adrenaline when I do.

I have walked this world irreligious, and I have found a religion. Both of these facts are true, and I have finally made my peace with the contradiction.

Use whatever distribution actually serves your needs. But read the wiki. Always read the wiki.

Package Categories and References

mail@osaigbovo.xyz (Osaigbovo Omere) — Sun, 29 Mar 2026 00:00:00 +0000

1. Core System

These are not optional. Without them, nothing else works correctly.

Base System

The absolute minimum for a bootable Arch installation. Includes
the core utilities, the C library, and the package manager itself.
Without this layer, the system does not exist.

Examples: base, base-devel

Linux Kernel

The kernel is the bridge between your hardware and your software.
It manages memory, processes, devices, and system calls. Arch
ships the vanilla upstream kernel, but alternatives exist with
different scheduling and performance characteristics.

Examples: linux, linux-lts, linux-zen, linux-hardened

linux-headers is also needed if you build kernel modules
(e.g. for certain GPU drivers or VPN tools).

Firmware

Blobs of binary code that the kernel loads onto hardware devices
at boot – GPU microcode, Wi-Fi card firmware, NVMe controller
firmware. Without this, hardware either does not work at all or
works badly.

Examples: linux-firmware

CPU Microcode

Processor-specific patches applied by the bootloader at boot
time. They fix hardware bugs and security vulnerabilities at the
CPU level. You pick one depending on your CPU manufacturer.

Examples: intel-ucode, amd-ucode

Bootloader

The first piece of software that runs after your firmware (UEFI
or BIOS). It finds the kernel image and hands control over to it.
Without a bootloader, the system does not start.

Examples: grub, systemd-boot (part of systemd), rEFInd

Init System

The first process the kernel starts (PID 1). It brings up
everything else – mounts filesystems, starts daemons, manages
services. Arch uses systemd by default. You are not replacing it
unless you know exactly why.

Examples: systemd (default on Arch, already present)

Filesystem Utilities

Tools for creating, checking, and repairing filesystems. Also
needed for mounting drives formatted with filesystems other than
the one your root partition uses – external drives, USB sticks,
Windows partitions.

Examples: e2fsprogs (ext4), dosfstools (FAT32),
ntfs-3g (NTFS), exfatprogs (exFAT), btrfs-progs

Man Pages

The built-in documentation system. man ls, man systemctl,
man pacman. Without man-db, you have no offline reference.
You will need the internet for everything.

Examples: man-db, man-pages

Time Synchronisation

Keeps the system clock accurate by syncing with network time
servers. An inaccurate clock breaks HTTPS certificate validation,
authentication tokens, and log timestamps. systemd-timesyncd
is already present on most Arch installs and handles basic NTP.

Examples: systemd-timesyncd (lightweight, already in
systemd), chrony (more accurate, better for laptops
that sleep frequently)

Disk Encryption

Encrypts partitions or volumes so their contents are unreadable
without the correct passphrase or key. If you set up LUKS during
install, cryptsetup is already on your system. If not, this is
the tool you use to add encryption later.

Examples: cryptsetup (LUKS), veracrypt

2. Display & Compositor

Wayland Compositor

On a standard desktop environment like GNOME or KDE, the
compositor is bundled in. On a standalone window manager setup
like this, it is its own package. The compositor is responsible
for drawing windows, handling input, managing outputs (monitors),
and compositing everything into what you see on screen. On
Wayland, the compositor also is the display server.

Examples: hyprland, sway, river, niri

The graphical (or TUI) interface that greets you before you log
in. It authenticates your session and launches your compositor.
You can also skip it entirely and launch Hyprland from a TTY with
uwsm or a shell script – but a display manager gives you a
cleaner boot experience.

Examples: ly, greetd, sddm, gdm

Wayland Session Manager

A wrapper that correctly launches a Wayland compositor as a
proper systemd user session, ensuring environment variables are
set, D-Bus is activated, and XDG portals start correctly. Without
something like this, some applications or portals may not
function properly.

Examples: uwsm

XDG Desktop Portal

A standardised interface that allows sandboxed applications
(Flatpak, but also native apps) to request desktop services –
screen sharing, file picker, opening URIs, camera access – in a
controlled way. Without the correct portal for your compositor,
screen sharing in browsers, file pickers in some apps, and
screenshots via portals will not work.

You typically need two: one compositor-specific, one GTK fallback.

Examples: xdg-desktop-portal-hyprland,
xdg-desktop-portal-gtk, xdg-desktop-portal-kde

XWayland

A compatibility layer that allows X11 applications to run inside
a Wayland session. Some software has not been ported to Wayland
yet. Without XWayland, those applications will not launch at all.

Examples: xwayland (often pulled as a dependency of the
compositor)

GPU Driver

Software that lets the kernel communicate with your graphics
card. Without the correct driver, you get software rendering,
which is slow, consumes a lot of CPU, and will make Hyprland
painful to use.

Examples: mesa (AMD / Intel open source), nvidia,
nvidia-open, vulkan-intel, vulkan-radeon

Video Acceleration

Libraries that offload video decoding and encoding to the GPU
rather than the CPU. Without this, playing video is noticeably
more expensive on your system resources.

Examples: intel-media-driver, libva-mesa-driver,
nvidia-utils, libva-utils (for testing)

Display Configuration Tool

A tool for arranging monitors, setting resolutions, refresh
rates, and scaling. Hyprland handles this in its config file, but
a GUI tool makes multi-monitor setups significantly less painful
to configure initially.

Examples: nwg-displays, wdisplays, kanshi
(kanshi is for automatic profiles, not interactive config)

3. Desktop Environment Components

These are the building blocks of the desktop. A traditional DE
like GNOME bundles all of these together. On a standalone
compositor, you assemble them yourself.

Status Bar / Panel

A persistent bar that displays information – time, date,
workspace indicators, system stats, network status, battery,
volume, active window title. On Wayland this communicates with
the compositor via its own protocol or via standard Wayland
protocols.

Examples: waybar, eww, yambar, ags

Application Launcher

A fuzzy-search interface for launching applications by name,
running shell commands, or switching between open windows.
Without one, you either open a terminal every time or bind every
application to a keyboard shortcut.

Examples: rofi (with Wayland fork), wofi, tofi, fuzzel,
anyrun

Notification Daemon

Receives and displays desktop notifications sent by applications
via the D-Bus notification spec. Manages the queue, allows
dismissal, can support actions (buttons inside notifications).
Without one, notifications are silently dropped.

Examples: mako, swaync, dunst

Screen Lock

Blanks the screen and requires authentication to resume the
session. The lock screen sits between your unattended machine and
anyone who walks up to it.

Examples: hyprlock, swaylock, waylock

Idle Daemon

Monitors input inactivity and triggers actions after a set time
– dim the screen, lock the session, suspend the system. Works
in tandem with the screen lock.

Examples: hypridle, swayidle

Wallpaper Setter

Sets and manages the desktop background. On Wayland this must be
a Wayland-native tool; X11 wallpaper setters will not work.

Examples: hyprpaper, swww, swaybg, mpvpaper (animated
wallpapers via mpv)

Polkit Authentication Agent

Polkit is a framework for controlling privilege escalation for
unprivileged processes. When an application needs elevated
permissions (mounting a drive, installing a package via a GUI),
Polkit intercepts the request and the authentication agent
presents a password prompt. Without one, those GUI operations
silently fail.

Examples: polkit-kde-agent, polkit-gnome,
lxqt-policykit

Keyring / Secret Storage

A secure, encrypted store for secrets – passwords, API tokens,
SSH keys, application credentials. Applications that handle
authentication (browsers, email clients, cloud sync tools) expect
a secret service to be present and will either fail to save
credentials or store them in plaintext without one.

Examples: gnome-keyring, keepassxc (with secret service
integration)

Clipboard Manager

Wayland does not have a persistent clipboard by default. When a
window closes, its clipboard content disappears. A clipboard
manager keeps a history of copied items and makes them accessible
after the source application is gone. Also enables fuzzy-search
through clipboard history.

Examples: cliphist, clipman

wl-clipboard (wl-copy / wl-paste) is also needed as the
underlying Wayland clipboard utility. It is not a manager itself,
but most managers depend on it.

Screenshot Tool

Captures the screen, a region, or a specific window. On Wayland
this works through the compositor’s screencopy protocol or via
XDG portals. X11 screenshot tools do not function on Wayland.

Examples: grim, hyprshot, grimblast

A region selection tool is almost always used alongside the
screenshot tool.

Screen Region Selector

An interactive overlay that lets you draw a rectangle over the
screen to define a capture area. Used with screenshot tools and
sometimes screen recorders.

Examples: slurp

Screen Recorder

Captures video of the screen or a region of it. Useful for
documentation, bug reports, or content creation. Wayland screen
recording requires compositor support for the screencopy protocol.

Examples: wf-recorder, obs-studio

Color Picker

Samples the color of any pixel on screen and returns the hex or
RGB value. Small tool, but immediately useful when theming.

Examples: hyprpicker, gpick

On-Screen Display (OSD)

A temporary overlay that appears when you change volume or
brightness, showing the current level visually. Not strictly
necessary, but without it you adjust volume blind.

Some notification daemons (like swaync) can be configured to
do this. There are also dedicated tools.

Examples: swayosd, custom scripts using notify-send

Screen Annotation / Screenshot Editor

Edits screenshots immediately after capture – adds arrows,
text, highlights, and crops. Useful for documentation.

Examples: swappy

4. Audio

Audio Server

The layer between the kernel’s audio subsystem (ALSA) and your
applications. It handles routing, mixing, Bluetooth audio,
virtual devices, and gives applications a consistent interface
regardless of hardware. PipeWire is the current standard on
modern Linux – it also handles PulseAudio and JACK compatibility.

Examples: pipewire, pipewire-pulse, pipewire-alsa,
pipewire-jack, wireplumber (session manager for PipeWire)

Volume Control / Audio Mixer

A GUI or TUI for controlling per-application volume, input/output
device selection, and audio routing. The audio server itself does
not provide this interface.

Examples: pavucontrol (GUI), pulsemixer (TUI), pamixer
(CLI)

5. Networking

Network Manager

Manages wired, wireless, and VPN connections. Handles DHCP,
static IP configuration, connection profiles, and automatic
reconnection. Without this (or an equivalent), you configure
networking manually via ip and wpa_supplicant every boot,
which is painful.

Examples: networkmanager, iwd, connman

Network Manager Frontend

A user interface for the network manager. The manager itself runs
as a daemon in the background; the frontend is how you interact
with it – connecting to Wi-Fi, editing profiles, toggling VPN.

Examples: nm-applet (system tray), nmtui (TUI),
networkmanager-dmenu (rofi/dmenu integration)

DNS Resolver / Encrypted DNS

Handles domain name resolution. The default system resolver sends
DNS queries in plaintext, which is readable by your ISP and any
network middleman. An encrypted DNS tool routes those queries over
DoH or DNSCrypt.

Examples: dnscrypt-proxy, systemd-resolved (with DoH
config), stubby

VPN Client

Encrypts your network traffic and routes it through a remote
server. Necessary for privacy on hostile networks or for
accessing private network resources.

Examples: wireguard-tools, openvpn, openconnect

Firewall

Controls which network traffic is allowed in and out of the
system. Without one, all ports are open to whatever the kernel
allows by default.

Examples: ufw (frontend for nftables/iptables),
nftables, iptables

SSH Client / Server

The standard tool for remote access and secure file transfer.
The client lets you connect to remote machines. The server lets
remote machines connect to yours.

Examples: openssh

Tor

Routes traffic through the Tor anonymity network. torsocks
wraps arbitrary applications to force their traffic through Tor.

Examples: tor, torsocks

Network Diagnostics

Tools for inspecting, testing, and debugging network connections
at a lower level than a browser or ping. Useful for diagnosing
connectivity issues, scanning for open ports, or measuring
throughput.

Examples: nmap (port scanning), traceroute,
iperf3 (bandwidth testing), bind (provides dig and
nslookup for DNS queries), openbsd-netcat

6. Input & Hardware

Input Remapper

Remaps keys, mice, and other input devices at the kernel or
application level. Useful for non-standard keyboards, ergo
layouts, or remapping modifier keys across the entire system.

Examples: keyd, xremap, interception-tools

Brightness Control

Adjusts screen backlight brightness. On Wayland this usually
works through a tool that writes directly to the kernel’s backlight
interface.

Examples: brightnessctl, light

Fingerprint Reader

If your machine has a fingerprint sensor, this daemon enables
it for PAM authentication – login, sudo, screen unlock.

Examples: fprintd

Power Management

Controls CPU frequency scaling, disk spin-down, USB autosuspend,
and other power-saving features. Particularly relevant on laptops.

Examples: tlp, auto-cpufreq, power-profiles-daemon

Bluetooth Manager

Manages Bluetooth device pairing, connection, and profiles. The
kernel’s Bluetooth stack (bluez) is the backend; a frontend
gives you a usable interface.

Examples: bluez, bluez-utils (backend),
blueman (GUI), bluetui (TUI)

Smart Drive Monitor

Monitors hard drive and SSD health via the S.M.A.R.T. interface
built into the drive firmware. Useful for catching failing drives
before data loss.

Examples: smartmontools

7. Theming & Appearance

Font — Monospace (with Icons)

Your terminal, editor, and status bar all render text. A Nerd
Font patches the typeface with icon glyphs used by many TUI tools
and status bars. Without one, you see boxes or question marks
instead of icons.

Examples: ttf-jetbrains-mono-nerd, ttf-firacode-nerd,
ttf-hack-nerd

Font — Sans-Serif (UI / Interface)

Used by GTK applications, notification bodies, rofi, and anywhere
a proportional font is expected. Picking one gives the desktop
a consistent look across applications.

Examples: inter-font, noto-fonts, ttf-ubuntu-font-family

Font — Emoji

Without emoji fonts, emoji render as empty boxes. Browsers,
terminals, and some applications use them even if you do not
intentionally.

Examples: noto-fonts-emoji, ttf-twemoji

Font — Serif

Used in documents, PDF viewers, and reading-focused applications.
Less critical than monospace and sans-serif for a terminal-first
setup, but absence is noticeable in document viewers and office
applications.

Examples: adobe-source-serif-fonts, noto-serif

Font Management Tool

Previews, installs, and organises fonts. Not necessary if you
install fonts via the package manager, but useful if you are
downloading fonts from external sources or managing a large
collection.

Examples: font-manager

Icon Theme

The set of icons used by GTK applications for file types,
folders, application launchers, and system actions.

Examples: papirus-icon-theme, hicolor-icon-theme
(hicolor is the fallback standard, always install it)

Cursor Theme

The mouse cursor shape. The default Wayland cursor is functional
but ugly. A cursor theme makes things look intentional.

Examples: capitaine-cursors, xcursor-themes,
bibata-cursor-theme

GTK Theme

Controls the visual appearance of GTK2/GTK3/GTK4 applications –
buttons, windows, scrollbars, toggles, everything. Without a
theme, GTK apps use the bare Adwaita default which may clash with
your compositor’s look.

Examples: adwaita-dark (built-in GTK), catppuccin-gtk-theme

GTK Settings Manager

A GUI tool for applying GTK themes, icon themes, and cursor
themes without manually editing ~/.config/gtk-3.0/settings.ini.
Also handles font settings for GTK apps.

Examples: nwg-look, lxappearance

Qt Theme / Qt Theming Layer

Qt applications use a separate theming system from GTK. Without
configuring this, Qt apps look completely different from everything
else – mismatched fonts, colours, and widget styles.

qt5ct and qt6ct are configuration tools. Kvantum is a theme
engine that applies SVG-based themes to Qt.

Examples: qt5ct, qt6ct, kvantum

8. Shell & Terminal

Terminal Emulator

The window that runs your shell. On Wayland this must be a
Wayland-native terminal or one that runs under XWayland. GPU
acceleration makes a meaningful difference in rendering speed,
especially with large outputs.

Examples: kitty, alacritty, foot, wezterm, ghostty

Shell

The command interpreter. Bash is the default on Arch. Zsh adds
better completion, history handling, and plugin support. Fish is
friendly but not POSIX-compatible.

Examples: zsh, bash, fish

Shell Prompt

The part of your shell that displays information at the start of
each line – current directory, git branch, last exit code, etc.
A well-configured prompt gives you context at a glance.

Examples: starship, oh-my-posh, powerlevel10k (Zsh only)

Terminal Multiplexer

Allows multiple terminal sessions within a single window, with
persistent sessions that survive disconnection. Especially useful
for SSH or long-running processes.

Examples: tmux, zellij, screen

Displays long text output one screenful at a time.
less is the standard. bat is a replacement with syntax
highlighting and line numbers.

Examples: less, bat

AUR Helper

Automates building and installing packages from the Arch User
Repository, which is not covered by pacman directly. Also
wraps pacman for full system upgrades.

Examples: paru, yay

9. Text Editors

There is a meaningful distinction between a quick terminal editor,
a modal editor, and a full IDE. They are not interchangeable and
serve different moments.

Simple Terminal Editor

A straightforward, non-modal editor that behaves like most
people expect a text editor to behave – you open it, you type,
you save, you quit. No modes, no configuration required to use
it. The value is immediate usability, especially on a fresh
system before anything else is configured, or when editing a
single file quickly over SSH.

The tradeoff is that it is slow for large-scale editing and
offers almost no extensibility.

Examples: nano, micro

A terminal editor built around the concept of distinct modes –
usually a normal mode for navigation and commands, and an insert
mode for typing. This means the keyboard is not wasted on just
typing characters; every key is a potential command. The learning
curve is steep but the payoff is that editing becomes
significantly faster once the muscle memory is built.

vim is the classic. It is installed almost everywhere, which
makes knowing it valuable beyond your own machine. neovim is
a modernised fork with a Lua configuration API, better defaults,
and a large plugin ecosystem. The two share the same fundamental
editing model.

These editors are also the foundation of the terminal-first
development workflow – with enough configuration they approach
full IDE behaviour.

Examples: vim, neovim

IDE (Integrated Development Environment)

A heavier, more complete development environment than a plain
text editor. An IDE bundles a file tree, integrated terminal,
built-in debugger, version control UI, and deep
language-specific tooling into one application. The distinction
from a text editor is fuzzy – Neovim with enough plugins
approaches IDE behaviour – but a dedicated IDE requires less
configuration to get to that point.

Worth noting: VS Code and its derivatives are technically
Electron applications. They are large, they consume more memory
than a terminal editor, and they are not terminal-native. The
tradeoff is that they work well out of the box for most
languages without extensive configuration.

Examples: code (VS Code), vscodium (VS Code without
Microsoft telemetry), intellij-idea-community,
pycharm-community, eclipse

10. Development & Version Control

Version Control System

Tracks changes to files over time. Essential for any code or
configuration work. Also used by AUR helpers to clone and update
packages.

Examples: git

Git TUI / Frontend

An interactive terminal interface for git – viewing diffs,
staging changes, managing branches, and resolving conflicts
without memorising every git subcommand.

Examples: lazygit, gitui

Diff / Merge Tool

Compares two files or directories side by side and highlights
differences. A merge tool extends this to resolve conflicts when
two versions of a file have both been modified. git diff is
sufficient for simple cases; a dedicated tool helps with complex
conflicts.

Examples: meld (GUI), vimdiff (terminal),
delta (better git diff output in terminal)

Language / Runtime Version Manager

Manages multiple installed versions of a language runtime on the
same machine. Essential when different projects require different
versions – one project needs Node 18, another needs Node 20, a
third needs Python 3.10 while your system has 3.12. A version
manager lets you switch between them per-project or per-shell
without reinstalling anything.

Examples: nvm (Node.js), pyenv (Python),
rustup (Rust – also the official Rust installer),
sdkman (JVM languages), mise (polyglot, handles many
languages in one tool)

Language Runtimes and Toolchains

The interpreters, compilers, and build tools for whatever
language you are working in. Arch ships most of these in the
official repositories.

Examples: nodejs, npm, python, python-pip, rust,
go, deno

LSP Servers

Language Server Protocol implementations that provide
autocompletion, diagnostics, go-to-definition, and other IDE
features in editors that support LSP (like Neovim). Installed
separately per language.

Examples: managed via mason.nvim inside Neovim, or installed
directly via the package manager

Build System / Build Tools

Automates the steps required to turn source code into a runnable
binary or deployable artifact. Handles compilation order,
dependency linking, and running tests. Different languages use
different build tools; base-devel on Arch covers most of what
you need to compile anything from the AUR or from source.

Examples: make, cmake, meson, ninja, gradle

API Testing Tool

Sends HTTP requests to an API endpoint and inspects the response.
Used for testing and debugging REST or GraphQL APIs without
writing code. Some are CLI tools, some are GUI applications.

curl covers basic use but is not ergonomic for repeated API
work.

Examples: httpie, xh, curlie (CLI),
bruno, insomnia (GUI, open source)

Database Client

Connects to a running database and lets you inspect schemas,
run queries, view data, and manage tables. Essential once you
are working with any persistent data store.

Examples: dbeaver (GUI, multi-database),
beekeeper-studio (GUI), pgcli (TUI, Postgres),
mycli (TUI, MySQL)

Container Runtime

Runs applications in isolated containers. Docker is the most
common. Podman is a daemonless alternative. Incus/LXD runs full
system containers and virtual machines.

Examples: docker, podman, incus

Virtualisation

Runs full virtual machines with their own kernel. QEMU is the
backend; virt-manager and virt-viewer are frontends.

Examples: qemu-full, virt-manager, virt-viewer,
libvirt

System Call Tracer / Debugger

Traces the system calls a process makes, which is how you find
out why a program is failing when it gives you no useful error
message. A low-level debugging tool you reach for when everything
else fails.

Examples: strace, ltrace

Hex Editor

Opens binary files and shows their raw byte values in
hexadecimal. Used when inspecting files that are not plain text
– compiled binaries, firmware images, corrupted files.

Examples: hexyl (terminal, read-only with colour),
bless (GUI, editable), xxd (CLI, ships with vim)

11. File Management

File Manager

Browse, move, copy, rename, and delete files. TUI file managers
are fast and integrate well with terminal workflows. GUI file
managers provide drag-and-drop and thumbnail support.

Examples: yazi, lf, nnn (TUI),
thunar, dolphin (GUI)

Archive Manager

Creates and extracts compressed archives – zip, tar, 7z, rar,
gz, zst. Without the right tool for a format, you cannot open it.

Examples: 7zip, unzip, unrar, tar (usually already
present), file-roller (GUI)

Thumbnail Generator

Generates preview thumbnails for images, videos, and documents
in GUI file managers. Without this, file managers show blank
icons instead of previews.

Examples: ffmpegthumbnailer, tumbler

Disk Usage Analyser

Shows what is consuming disk space, either visually or as a
sorted list. Useful when a drive fills up and you need to find
the cause.

Examples: dust, ncdu, duf (disk usage summary)

Disk / Partition Management

Tools for creating, resizing, and managing partitions and
partition tables. Used for setting up drives or external storage.

Examples: gptfdisk, parted, gparted (GUI)

LVM Tools

If your system uses Logical Volume Management for flexible disk
partitioning, these are required.

Examples: lvm2

Backup Tool

Copies data to a secondary location in a way that supports
incremental backups, deduplication, and restoration. rsync is
simple file mirroring. restic and borg add encryption,
deduplication, and snapshot management.

This is not optional if the data matters. A broken package
upgrade, a full disk, or a hardware failure will eventually
happen.

Examples: rsync, restic, borgbackup

Cloud Storage Client

Syncs files with a remote cloud storage service.

Examples: filen-cli, rclone, syncthing

Remote Desktop Client

Connects to remote machines running a graphical desktop via VNC,
RDP, or other protocols. Useful for managing Windows machines or
headless Linux servers that have a GUI.

Examples: remmina, tigervnc

12. System Utilities

System Monitor / Resource Monitor

Displays live information about CPU, memory, disk I/O, network,
and running processes. A better-looking, more informative
replacement for top.

Examples: btop, htop, bottom

Process Viewer

A better ps. Lists running processes with readable output,
filtering, and sorting.

Examples: procs

Fuzzy Finder (CLI)

An interactive filter for lists of text in the terminal.
Integrates with the shell to search command history, files,
processes, and anything else that outputs text.

Examples: fzf, sk

Smart Search (File Content)

Searches file contents recursively. Much faster than grep -r
on large codebases.

Examples: ripgrep, silversearcher-ag

Smart Search (File Name)

Finds files by name. Faster and more user-friendly than find.

Examples: fd

Modern `ls` Replacement

A replacement for ls with colour, icons (with Nerd Fonts),
git status integration, and human-readable sizes.

Examples: eza, lsd

Download Manager

Downloads files from the internet, with support for resuming
interrupted downloads, parallel connections, and multiple
protocols.

Examples: aria2, wget, curl

Calculator (CLI)

A command-line calculator for quick arithmetic or more complex
expressions without opening a GUI application.

Examples: bc, qalculate (has a CLI mode)

Security Auditing

Checks the system for known vulnerabilities in installed packages
and configuration issues.

Examples: arch-audit, rkhunter, lynis

Duplicate File Finder

Scans directories for files with identical content and lists or
removes them. Useful for cleaning up storage.

Examples: fdupes, rmlint

13. Applications

Web Browser

Fetches, renders, and runs web content. Wayland-native browsers
render noticeably smoother than those running via XWayland.

Examples: firefox, librewolf, floorp, brave, chromium

Email Client

Sends and receives email. Can be a full GUI application or a
terminal-based client.

Examples: thunderbird, tutanota-desktop (GUI),
neomutt, aerc (TUI)

Document Viewer / PDF Reader

Opens and reads PDF, ePub, DjVu, and similar formats. A minimal
document viewer is faster than a full office suite for just
reading.

Examples: zathura (with zathura-pdf-mupdf), evince,
okular

ePub / eBook Reader

A dedicated reader for ePub files specifically. zathura can
handle some formats but a dedicated reader offers better
navigation, bookmarking, and reading experience for long-form
text.

Examples: epr (terminal), foliate (GUI)

Image Viewer

Opens and browses image files. Should be Wayland-native or
usable under XWayland.

Examples: imv, swayimg, eog

Image Manipulation Tool

Edits and converts images. imagemagick is a CLI tool that
handles format conversion, resizing, and compositing.

Examples: imagemagick (CLI), gimp (GUI raster),
inkscape (GUI SVG / vector)

Video Player

Plays video files and streams. mpv is the standard for
terminal-first setups – it is scriptable, lightweight, and
supports virtually every format.

Examples: mpv, vlc

Media Downloader

Downloads video and audio from websites and streaming platforms
to local files.

Examples: yt-dlp

Music Player Daemon

A background daemon that manages a music library and plays audio.
Controlled separately by a client application. Separates
playback logic from the interface – if your UI crashes, the
music keeps playing.

Examples: mpd

Music Player Client

The interface for a music player daemon. Controls playback,
browsing the library, and managing the queue.

Examples: ncmpcpp, mpc (CLI), cantata (GUI)

Note Taking Application

A place to write and organise notes, references, and personal
knowledge.

Examples: obsidian, logseq, zettlr

Password Manager

An encrypted database of credentials. Without one you either
reuse passwords or write them somewhere insecure.

Examples: keepassxc, bitwarden, pass

Office Suite

For documents, spreadsheets, and presentations in standard
formats (ODF, DOCX, XLSX, etc.).

Examples: libreoffice

Spell Check Library

Provides spell checking for applications that support it –
LibreOffice, email clients, some browsers. You install the
library and then the dictionary for your language separately.

Examples: hunspell, hunspell-en_gb, hunspell-en_us,
aspell (some applications prefer this over hunspell)

Calculator (GUI)

A graphical calculator. Qalculate is particularly good because
it handles unit conversion, symbolic maths, and complex
expressions.

Examples: qalculate

Communication / Messaging

Applications for chat, social platforms, and real-time
communication.

Examples: telegram-desktop, element-desktop (Matrix),
discord, slack-desktop

TUI or GUI clients for federated social platforms – Mastodon,
Akkoma, Pleroma, Misskey. If you are on the Fediverse and want
to interact without a browser.

Examples: tut (Mastodon TUI), toot (CLI),
kaiteki (GUI, multi-platform Fediverse)

RSS / Feed Reader

Aggregates and displays content from RSS and Atom feeds – blogs,
news, podcast listings, YouTube channels. Keeps information
consumption terminal-side and out of the browser.

Examples: newsboat (TUI), rss-guard (GUI)

Torrent Client

Downloads files via the BitTorrent protocol. Useful for Linux
ISOs, large open datasets, and anything distributed without a
central server.

Examples: transmission-cli (CLI/daemon),
transmission-gtk (GUI), qbittorrent, deluge

Fetching Tool

Displays system information alongside an ASCII or image logo.
Purely aesthetic. Installed last, used constantly.

Examples: fastfetch, neofetch (unmaintained), macchina

14. Fonts Summary

Fonts deserve a consolidated note because they affect the entire
desktop.

Type	Purpose	Example Packages
Monospace Nerd Font	Terminal, editor, status bar icons	`ttf-jetbrains-mono-nerd`
Sans-Serif UI Font	GTK apps, notifications, launchers	`inter-font`, `noto-fonts`
Emoji Font	Emoji rendering everywhere	`noto-fonts-emoji`
Serif Font	Documents, reading	`adobe-source-serif-fonts`

15. Quick Checklist

Use this to verify nothing critical is missing.

Core System

Base system and kernel
CPU microcode and firmware
Bootloader
Man pages
Time synchronisation
Disk encryption (ideally set up at install time)

Display

GPU driver and video acceleration
Display manager or TTY launch setup
Compositor (Hyprland)
XDG desktop portals (compositor-specific + GTK fallback)
XWayland
Display configuration tool

Desktop Components

Status bar
Application launcher
Notification daemon
Screen lock + idle daemon
Wallpaper setter
Polkit agent
Keyring
Clipboard manager + wl-clipboard
Screenshot tool + region selector
Screen annotation tool
Color picker
OSD (volume / brightness feedback)

Audio

Audio server (PipeWire + WirePlumber)
Volume control

Networking

Network manager + frontend
Firewall
SSH client/server
Encrypted DNS
Network diagnostics tools

Input & Hardware

Brightness control
Bluetooth (if hardware present)
Power management (if on a laptop)
Fingerprint reader (if hardware present)
Input remapper (if needed)
Smart drive monitor

Shell & Terminal

Terminal emulator
Shell + prompt
Terminal multiplexer
Pager
AUR helper

Theming

Fonts (monospace Nerd Font + emoji at minimum)
Icon theme + hicolor fallback
Cursor theme
GTK settings manager
Qt theming (qt5ct / qt6ct + Kvantum)

Editors & IDE

Simple terminal editor (nano or micro)
Modal terminal editor (vim or neovim)
IDE (if text editor + plugins is not sufficient)

Development

Git + git TUI
Language runtimes and toolchains
Language version manager
Build tools (base-devel covers most of this)
LSP servers
API testing tool
Database client (if working with databases)
Container runtime (docker, podman, or incus)
Virtualisation (qemu + virt-manager if needed)
Diff / merge tool
System call tracer (strace)
Hex editor

File Management

File manager
Archive manager
Disk usage analyser
Disk / partition management tools
Backup tool and a tested restore procedure
Cloud storage client (if needed)
Remote desktop client (if needed)

System Utilities

System monitor
Fuzzy finder (fzf)
Smart file content search (ripgrep)
Smart file name search (fd)
Modern ls replacement (eza)
Download manager
Security auditing tools

Applications

Web browser
Email client
Document / PDF viewer
Image viewer
Video player
Music player daemon + client
Note taking application
Password manager
Office suite
Spell check library + dictionaries
Media downloader (yt-dlp)
Communication / messaging apps
Torrent client (if needed)
RSS reader (if needed)
Fetching tool

This note is a reference, not a prescription. Your actual
package list will differ. The point is to know what each
category does so you know what you are missing when something
does not work.

The Architecture of Noise

mail@osaigbovo.xyz (Osaigbovo Omere) — Wed, 02 Jul 2025 00:00:00 +0000

Data is the noise before translation. It is the bloodied carcass awaiting dissection. It exists without meaning, incapable of explaining itself. A temperature reading, a demographic marker, a death toll–these are corpses without context. We mistake them for evidence, forgetting that data is always observed from somewhere. The choices of what to collect, what to ignore, and what to erase shape the world long before the numbers are ever tallied. Data only becomes evidence once it has been framed and weaponised.

When intent is injected into that raw noise, it becomes information. It provides the primitive architecture of who, what, where, and when, telling a story without necessarily understanding it. This is the first point of manipulation. Search results and statistics wear the aesthetic of truth, but they are shaped by underlying infrastructure and motive. Authoritarian systems rely on this; they rarely need to lie outright when they can simply arrange the data into a structure that dictates what the public believes matters.

Eventually, information is stored, repeated, and accepted as true, becoming knowledge. This forms the archive. It is the approved curriculum of empire and the canon of the victors. Most people stop here, mistaking the archive for the peak of human intellectual achievement. But knowledge is inherently static. Left unchallenged, it calcifies into dogma. It presents itself as universal while remaining hopelessly situated–filtered heavily through ideology, culture, and power.

To break past the archive requires understanding. To understand is to internalise the mechanism. It is the moment the pattern burns into you, when you stop quoting what you were taught and begin seeing the connections yourself. Understanding perceives cause and effect simultaneously. It is an inherently painful process because it requires dismantling your previous conditioning. Any society that prioritises obedience will naturally view understanding as a threat.

Intelligence, meanwhile, is merely function. It is the capacity to operate within systems, adapt to constraints, and solve novel problems. It possesses no inherent moral compass. It dictates how to build the bomb, not whether to drop it. The world does not reward the wise; it rewards the intelligent, but only when that intelligence serves capital, the state, or the spectacle. This profound misalignment is why everything around us is breaking.

Beneath all of this lies the biological and psychological hardware: cognition and perception. Cognition is the circuitry of memory, attention, and association. Perception is the dirty glass through which that circuitry views the world, soaked in the conditioning of trauma, language, and expectation. Both are deeply hackable. Algorithms strip-mine our attention, while propaganda exploits our associations. If you refuse to acknowledge the dirt on the glass, you cannot own your thoughts. And if you do not own your thoughts, whose are you repeating?

Wisdom is post-intelligence. It is ethical pattern-recognition across time, rooted in restraint and consequence-awareness. It moves slowly. It questions rather than answers. Because it cannot be scaled, patented, or sold, it is rendered irrelevant by the modern machine. The wise do not offer lucrative solutions; they reveal problems too fundamental to fix. That is why empire discards its elders and ridicules its mystics. Wisdom requires the devastating realisation that being right is insufficient, and being clever is often the mechanism of ruin.

The natural progression from raw data to wisdom has been deliberately severed. We live in a civilisation drowning in harvested data and weaponised information. Knowledge is curated into dogma, understanding is suppressed, and intelligence is exploited to hijack our cognition and manipulate our perception.

Concept	Role	Function	Control Mechanism	Systemic Abuse
Data	Raw signals	Measurement	Collection	Surveillance
Information	Structured data	Communication	Framing	Propaganda
Knowledge	Stored information	Reference	Institutions	Indoctrination
Understanding	Internalised knowledge	Insight	Isolation	Suppression
Intelligence	Problem-solving	Adaptation	Reward	Exploitation
Cognition	Processing framework	Thought architecture	Hijacking	Disempowerment
Perception	Interpretive filter	Subjective awareness	Conditioning	Obfuscation
Wisdom	Ethical foresight	Judgement	Marginalisation	Erasure

If your data is harvested and your information shaped; if your knowledge is curated and your understanding suppressed; if your intelligence is weaponised to hijack your cognition and own your perception–wisdom is not coming.

You are not thinking. You are being thought through.

mail@osaigbovo.xyz (Osaigbovo Omere) — Mon, 01 Jan 0001 00:00:00 +0000

Osaigbovo Omere

Tiling Engine Hot-Swapping in Hyprland

The Centred Master

Workspace Engine Swapping

The Configuration

Categorical Collapse

Firmware of Ruins

The Friction of Babel

A Mapmaker's Lie and Other Poems of April

Protocols of Ruin

What is The Fediverse?

The Structural Hierarchy

The Protocol Interoperability Friction

The Microblogging Domain

The Aggregation Domain

The Visual Domain

Infrastructure and Deployment in Nigeria

The Mechanical Failure of Cross-Domain Communication

Advanced Domain Analysis: Microblogging

Advanced Domain Analysis: Long-Form and Audio

The Nigerian Imperative: Server Sovereignty

Database Architecture and Hardware Reality

Security and Supply Chain Isolation

The Moderation Mechanic

My Arch Install

1. Pre-Flight

2. Storage Architecture

2.1 Wipe the Drive

2.2 Partition

2.3 Encrypt the Root Partition

2.4 LVM

2.5 Format

2.6 Mount

3. Base Installation

4. System Configuration

4.1 Timezone and Locale

4.2 Keymap

4.3 Network Identity

4.4 Initramfs

5. Bootloader

6. User Management

7. Desktop Services

7.1 Hyprland Configuration

8. Finalisation

Cats & Dogs

Parasites

Linux is a Religion

Package Categories and References

1. Core System

Base System

Linux Kernel

Firmware

CPU Microcode

Bootloader

Init System

Filesystem Utilities

Man Pages

Time Synchronisation

Disk Encryption

2. Display & Compositor

Wayland Compositor

Display Manager / Login Manager

Wayland Session Manager

XDG Desktop Portal

XWayland

GPU Driver

Video Acceleration

Display Configuration Tool

3. Desktop Environment Components

Status Bar / Panel

Application Launcher

Notification Daemon

Screen Lock

Idle Daemon

Wallpaper Setter

Polkit Authentication Agent

Keyring / Secret Storage

Clipboard Manager

Screenshot Tool

Screen Region Selector