When your Arch-Linux oath collides with macOS provisioning reality

Level 1: No Going Back

Imagine a kid who always said, "I will never wear a suit and tie when I grow up. I'm going to stick to my comfy t-shirts no matter what!" That was a big promise they made to themselves. But then the kid grows up and lands a job where the dress code is suits and ties every day. Now, each morning, as they put on that suit and tie, they remember their younger promise and feel a little bad (and maybe a bit amused at how things changed). It's like younger-them in their memory is yelling, "Hey, you sold out! You said you'd never do that!" But adult-them knows this is what they need to do for their job.

This meme is the computer version of that story. The person promised their younger self they'd only use their favorite kind of computer setup (the super-custom Linux PC, which was their "comfy t-shirt"). But now they have to use a different computer (an Apple MacBook, which is like the "suit and tie" in this case) every day for work. They feel like they've chosen a path where they can't go back to how it was, at least while they're doing this job. It's funny and a bit sad at the same time: funny because life took them in a direction they never expected (oh, the irony!), and a bit sad because we all kind of feel for that younger self who had strong ideals. In simple terms, it's humor about breaking a personal promise because real life had other plans, and most of us can understand how that happens.

Level 2: Arch vs macOS for Devs

Let's break down the situation and why it happens, in simpler terms. Arch Linux is a popular flavor of the Linux operating system. Linux, in general, is an open-source OS that developers often love for its flexibility and control. Arch in particular is known for being bleeding-edge (always updated to the newest software) and highly customizable. When someone says they use Arch, it often implies they're comfortable getting hands-on with their system: you usually install Arch manually, configure many things yourself, and learn a lot in the process. There's no big company behind Arch — it's supported by a community and detailed documentation (the Arch Wiki). The Arch Linux User Repository (AUR) is one of Arch's crown jewels: it's a huge collection of community-contributed packages. If you need some software that's not in Arch’s official repos, chances are someone wrote an install script for it in the AUR. With Arch, you can pretty much install anything and tweak everything. This represents a kind of freedom and DIY ethos in your dev environment setup.

Now, i3WM stands for i3 Window Manager. A window manager is the part of the system that controls graphical windows on your screen. i3WM is a tiling window manager, which is quite different from the window system on macOS or Windows. Instead of overlapping, draggable windows, a tiling WM arranges every new window into a grid or tiles. For example, if you open a new terminal and code editor in i3, the screen might split into two halves, each app taking a tile. Open a third, and maybe your screen splits into thirds, and so on. You navigate and arrange these tiles with keyboard shortcuts instead of a mouse. It looks less shiny but it’s very efficient once you get used to it. People who use i3WM (and similar tiling managers) love that they can do everything with the keyboard and keep their hands on the home row. It's minimal, uses very little memory, and is highly configurable (you can script how it behaves, change its shortcuts, style, etc.). Using i3WM is kind of a badge of the power user; it means you prefer speed and simplicity over flashy visuals and are willing to climb a learning curve to get a tailored workflow.

The meme mentions using Arch and i3WM on a Ryzen 5 APU. A Ryzen 5 is a model of CPU made by AMD (a company that makes processors). "APU" means that the CPU chip also includes a built-in graphics processor. In simpler terms, this person’s younger setup was a custom-built PC with a mid-range AMD processor that could handle graphics without needing a separate graphics card. This detail emphasizes they were a PC builder/enthusiast type, likely building their own machine for development or gaming and running Linux on it. It’s very much a do-it-yourself vibe: pick your own parts, assemble your computer, install a Linux OS of your choice (Arch, in this case), and customize everything from the ground up.

On the flip side, macOS is the operating system that runs on Apple’s Mac computers (like the MacBook laptop). It's a Unix-based OS (meaning it shares some roots with Linux in terms of command-line and file system structure), but it's not open-source — it's developed and controlled by Apple. Apple designs both the hardware and software of Macs to work together. For developers, macOS is popular in many companies because it provides a Unix-like environment (with a Terminal app, scripting, etc.) while also being able to run mainstream software (Adobe products, Office, etc.) and support devices (like plugging in iPhones for testing apps). Essentially, it can feel like a polished middle ground between Windows and Linux. But importantly, if you want to develop apps for iOS (iPhone/iPad) or for macOS itself, Apple makes you use their tools on their OS.

The key tool here is Xcode, which is Apple's official development application for making iOS and Mac apps. Xcode only runs on macOS. If you want to create an iPhone app and distribute it, you have to compile it with Xcode (or at least use Apple's build tools and get it signed with an Apple certificate). Even cross-platform app frameworks (like making a game in Unity or an app with React Native) eventually require a Mac to compile the final iOS app or upload it to Apple's App Store. This is what we mean by Apple’s "platform lock-in": to work within Apple’s platform, you need to use Apple’s environment. There’s no supported way to do it on pure Linux or Windows. Some developers might try workarounds like "Hackintosh" (running macOS unofficially on PC hardware) or using cloud Mac services for building the app, but those are complex or violate Apple’s terms. The straightforward, officially supported path is: use a Mac.

So in the meme, the person is basically saying: "I prefer Linux and I promised I'd stick with it, but I have to use a MacBook now because I'm developing macOS/iOS apps (for personal projects or my company)." They add "I'm not an Apple fanboy" to stress they're not doing this out of love for Apple; it's out of necessity. Many developers from a Linux background feel a bit conflicted using Macs. On one hand, a MacBook is well-built hardware and macOS has a polished feel. On the other hand, it’s not the open system they're used to; you can’t tinker with it as freely as an Arch Linux box. Plus, there's a bit of culture clash: hardcore Linux users often poke fun at Apple for being closed-source or for users being "Apple fanboys" (people who just buy everything Apple). Admitting that you use a MacBook can feel like a small identity crisis if you always identified as a Linux/PC person.

The line about betraying my younger self is showing that exact internal conflict. The younger self had an almost ideological stance: "I will never leave Arch and my custom setup." This is common in tech – when we learn something we love, we sometimes get almost religious about it, thinking it's the best and we'll stick with it forever. But fast-forward: a job, project, or some practical concern comes up that forces a change. Here, presumably, the person’s job as a developer who builds iPhone/iPad apps requires a Mac. It might feel weird at first: imagine going from a clacky mechanical keyboard and terminal screens on Arch, to the sleek MacBook with macOS animations and the Xcode interface. It's a big change in daily routine and tools.

To a newer developer, the takeaway is that different tasks sometimes demand different platforms. If you want to do Android development, you can do that on Linux, Windows, or Mac. But for iOS development, you really need macOS. So even if you love Linux, you might find yourself owning a Mac someday just to deploy an iPhone app. This can feel like a betrayal if you were very devoted to the Linux way of doing things. The humor is in the relatable frustration: many developers have a story of "I said I'd never use X, but then I ended up needing X for work." It's like the universe laughing at our tech promises.

Here's a quick comparison between the two setups mentioned, to illustrate the change:

Aspect	Arch Linux + i3WM (Younger Self)	macOS on MacBook (Current Self)
Hardware	Custom-built PC (e.g. AMD Ryzen 5 APU)	Apple MacBook laptop (Apple hardware)
Philosophy	DIY, open-source, user controls everything	Controlled, closed-source, Apple sets defaults
Interface	i3WM tiling windows (keyboard-centric)	macOS Aqua GUI (mouse/trackpad-friendly)
Software Install	pacman + AUR (community packages for anything)	App Store + Homebrew (Apple-approved or community brew recipes)
Dev Tools	Whatever you like (e.g. Vim/Emacs, GCC, etc.)	Primarily Xcode for iOS/macOS apps (Apple-required) plus standard tools
Updates	Rolling updates (frequent, user-initiated)	Periodic macOS releases (infrequent, automatic prompts)
Identity	"I use Arch, BTW!" (techie cred, pride)	"Not an Apple fanboy, but..." (pragmatic, just for work)

As you can see, the two worlds are quite different! The meme humorously captures the shock of moving from the left column to the right column.

In summary, the developer in the meme feels like they made a promise to themselves about their tech identity ("I'll always use my favorite setup and never switch to that other side"), and life made them break that promise. This is funny to other developers because most of us have been so sure about a tool or platform ("I'll never use Java", "I refuse to use cloud IDEs", etc.), and then reality comes along and we end up doing exactly that. It's a poke at the relatable developer experience of learning that in tech, "never" is a risky word. Sometimes, you have to be flexible and use what gets the job done, even if it means embracing the thing you once swore off.

Level 3: AUR vs App Store

The top text reads like a confession from a seasoned developer who once swore an oath on Arch Linux with a tiling window manager (i3WM). In our industry, that's practically a blood pact of tooling purity: Arch users pride themselves on a rolling-release Linux distro where you compile and configure everything just the way you like it, windows snapping into tiled positions via keyboard in a glorious mosaic of productivity. This meme highlights a hard truth: sometimes even the most fervent open-source devotees end up embracing the Apple ecosystem — or at least tolerating it — for the sake of work. It's a bitter pill wrapped in a MacBook's aluminum shell.

Why is this funny? Because it's painfully relatable. The developer proclaims, "I'm not an Apple fanboy but I still own a MacBook as I develop apps for mac and iOS." There's palpable reluctance in that statement. It reads like they're apologizing to their younger self (and to the Linux gods) while booting up macOS every morning. The Arch Linux User Repository (AUR) is like a temple of customization and user freedom, whereas Apple’s world of Xcode and the App Store is a curated walled garden – a polished, restrictive orchard where you must use Apple’s tools to pick the iOS build fruits. The humor lies in this identity crisis: picture a die-hard Arch evangelist, known for saying "I use Arch, BTW" at every opportunity, now quietly running brew install on a Mac. It's a classic platform_lock_in_realities moment: the developer road that leads to iOS runs through Apple's orchard, and you have to carry a Mac to travel it.

This "betrayal" of the younger self is something many senior engineers smirk at because we've been there. Perhaps you once rolled your eyes at colleagues carrying shiny overpriced MacBooks, only to find out later that if you want to code for iPhones or publish an app on the App Store, there is no real alternative. Apple’s development ecosystem demands you use an Apple machine with macOS for tools like Xcode (the official IDE for iOS/macOS apps). This is a textbook case of tooling_purity_vs_delivery_deadlines: your clean open-source principles might have forbidden touching proprietary platforms, but when a client or employer says "We need an iOS version by Q4," you either break that oath or break your career. The meme’s bottom image — a man in tears with the caption "He left and chose a path from which he cannot return anymore" — dramatizes that once you commit to Apple's platform, there’s no easy way back. You invest in the hardware, the OS, the entire Apple ecosystem; your workflow adapts to it. It’s like stepping through a one-way door: try running i3WM on the latest MacBook Pro with an M3 chip — good luck, you’re pretty much stuck with Aqua’s overlapping windows and Apple’s way of doing things now.

From a DeveloperExperience perspective, the clash is real. On one hand, Arch + i3WM is the ultimate personalized dev environment, often boasting superior developer ergonomics for that user: every shortcut honed, system bloat trimmed, nothing pre-installed that you didn’t explicitly need. On the other hand, macOS is opinionated: it has its own way of doing things, many of which you can’t change (at least not without voiding warranties or hacking around). The Arch user who manually tilled every inch of their OS now finds themselves in a garden where Apple is the gardener. Need a library? Instead of pacman -S <package> or an AUR helper script, you end up using Homebrew (brew install <package>) or the official App Store, abiding by Apple's rules and update schedules. Control shifts from the user to the vendor. For a veteran who spent years avoiding vendor lock-in, that’s ironically hilarious and exasperating at the same time.

Yet almost every senior developer has a story of a compromise like this. Maybe it’s the back-end guru who vowed to never touch JavaScript, now writing Node.js APIs because it's in demand. Or the engineer who promised to never use Windows again, until a .NET project paid their bills. Here, the meme hits on an Apple vs Arch identity crisis in a way only developer humor can: by exaggerating it to an almost tragic level. The crying reaction image is hyperbole — of course switching to a MacBook isn't literally the end of the world — but emotionally, it feels like betraying a friend or a cause. It's the Spider-Man pointing meme of operating systems: older-you is pointing at younger-you saying, "See, you became what you mocked," while younger-you points back "How could you?"

In reality, developers often pragmatically use the best tool for the job, even if it means eating some humble pie. The underlying lesson (wrapped in a joke) is that sometimes the walled garden wins despite our ideals. Apple's closed ecosystem is a prime example: if you want to reach iPhone users, you play by Apple's rules. You might try to dual-boot or run Arch in a VM on your Mac for comfort, but eventually you find yourself spending more time in macOS debugging xcodebuild errors than tweaking your Arch rice (custom config). Once you've invested in that workflow, your poor Arch partition might gather dust. "He left and chose a path from which he cannot return" — strong words, but any dev who’s gone down the iOS road knows it’s a long-term relationship with Apple. Breaking away would mean giving up a whole user base or a career path. That sense of being stuck by necessity is the punchline. Every engineer who’s made a similar concession chuckles (and perhaps sheds a single tear) in solidarity.