NVIDIA Drivers Broke My System. Again.

Not catastrophically. Not “reinstall everything” broken. Just… broken enough that nothing works right.

Screen tearing everywhere. Random crashes. My GPU is fighting with Wayland and losing.

And I’m sitting here at 11 PM, digging through Arch Wiki pages about NVIDIA-specific Wayland fixes, trying different kernel parameters, editing config files I barely understand.

Classic NVIDIA on Linux problems. Everyone warned me. I thought I could handle it.

The Pattern I Didn’t Want to See

Here’s how my days have been going lately:

Morning: Boot up, something looks off. Spend 20 minutes tweaking a config.

Afternoon: See a cool setup on Reddit. Spend an hour trying to recreate it.

Evening: Update breaks something. Spend two hours fixing it.

Night: “Just one more color scheme adjustment…”

I’ve spent more time maintaining and configuring my system than actually using it to build anything.

The setup is perfect. Beautiful, even. Everything exactly how I want it. But perfect is fragile. And fragile means constant maintenance.

I came here to learn to code. To build things. To ship projects.

Instead, I’ve become a full-time system administrator for my own desktop.

The Wake-Up Call

Last week, I started a side project. A simple web app. Nothing fancy. Should’ve taken a weekend.

It’s Thursday. I’ve written maybe 200 lines of actual code.

Not because the project is hard. Because every time I sit down to work on it, something else catches my attention.

“This terminal font looks weird at this size."
"I should reorganize my workspace layouts."
"Maybe I should try a different file manager."
"That status bar clock format bothers me.”

Two hours disappear. The project sits untouched.

I caught myself reading Hyprland documentation at midnight. Not because something was broken. Not because I needed to solve a problem. Just… because I could.

That’s when it hit me: I’m not learning anymore. I’m procrastinating with extra steps.

The system is perfect. So perfect that I’m afraid to actually use it for fear of breaking the perfection.

The Update That Broke Me

Yesterday’s system update was the final straw.

sudo pacman -Syu like I do every few days. Packages updated. NVIDIA drivers among them. Everything looked fine. Rebooted.

Black screen. Then flickering. Then Hyprland finally starts but with screen tearing so bad I can barely read text. GPU usage spiking randomly. Windows stuttering.

The NVIDIA driver updated and decided to break everything.

Three hours. Three hours hunting down solutions. Adding kernel parameters. Tweaking Hyprland configs for NVIDIA-specific settings. Installing older driver versions. Rolling back. Testing. Breaking it worse. Fixing it again.

Finally got it stable by adding a bunch of environment variables and kernel parameters I found scattered across forum posts and GitHub issues. nvidia_drm.modeset=1, __GLX_VENDOR_LIBRARY_NAME=nvidia, a dozen config tweaks I don’t fully understand but copy-pasted because they worked for someone else with my GPU.

It works now. Until the next driver update. Then I’ll probably have to do this dance again.

This is what rolling release means when you have NVIDIA hardware. Constant updates. Constant potential for driver conflicts. Constant maintenance.

And I was tired of paying that price.

The Question I Didn’t Want to Ask

Sitting there at 2 AM, finally getting my config working again, I asked myself something uncomfortable:

“Do I actually enjoy this? Or am I just too stubborn to admit this isn’t working?”

The honest answer: I enjoyed it. Past tense.

I enjoyed learning how everything worked. I enjoyed building the perfect setup. I enjoyed understanding the system at a deep level.

But I didn’t enjoy maintaining it. I didn’t enjoy fixing the same types of issues every update. I didn’t enjoy spending more time on my OS than on my actual work.

The novelty had worn off. What remained was just… work.

Discovering Omarchy

The next day, exhausted and frustrated, I was scrolling through yet another Arch Linux forum thread. Someone mentioned Omarchy.

“Arch-based distro with sane defaults. Pre-configured Hyprland. Maintained by community. Still all the Arch benefits, but someone else handles the config maintenance.”

I almost dismissed it. Isn’t this exactly what I was trying to avoid? Using someone else’s setup instead of understanding my own?

But then I thought about the last month. About the projects I didn’t start because I was tweaking configs. About the code I didn’t write because I was fixing animations.

I clicked the link.

Omarchy’s philosophy hit different: “An opinionated Arch setup that just works. For people who want to use Arch, not maintain Arch.”

They had screenshots. Clean Hyprland setup. Thoughtful defaults. Curated package selection. Everything I’d spent two months building… already done. And maintained by people who actually know what they’re doing.

The ego part of me resisted. “I built my own setup! I understand every piece! I can’t just throw that away!”

The practical part of me said: “You have seven unfinished projects and a config file that breaks every update. Maybe it’s time to let someone else handle this part.”

The Hard Truth About Customization

Here’s what I learned over 58 days of perfect customization:

Customization is a trap. Not because it’s bad - it’s great when you’re learning. But there’s no end point. There’s always one more thing to tweak. One more optimization to make. One more perfect config to chase.

Maintenance compounds. Every custom config is something you have to maintain. Every package you manually installed is something you have to update. Every tweak is something that can break.

Perfect is the enemy of done. My system was perfect. So perfect I was afraid to use it. So perfect I spent all my time maintaining perfection instead of actually building things.

Someone else’s 80% is better than my 100%. If Omarchy gives me 80% of my perfect setup without any of the maintenance burden, that’s a better deal. I can spend the 20% difference on actually shipping code.

The Decision

I’m switching to Omarchy.

Not because I failed. Not because I couldn’t handle Arch. I proved I could build and maintain a custom Arch setup. I have the dotfiles to prove it.

I’m switching because I’m choosing productivity over perfection.

I want to build things. Ship projects. Learn to code properly. Actually use this system for what I intended it for.

Not spend my evenings debugging why my status bar icons shifted 2 pixels after an update.

My ego hates this decision. I built something from scratch. I understand it. Letting go feels like giving up.

But my practical side knows: this is the right move.

Omarchy is still Arch. Still terminal-focused. Still minimal and fast. Still everything I wanted when I left Windows.

But someone else maintains the configs. Someone else handles the updates. Someone else makes sure things don’t break.

And I get to actually use my computer instead of perpetually configuring it.

Where I Am Now

I’ve backed up my dotfiles. Documented what worked and what didn’t. Taken screenshots of my setup for posterity.

Tomorrow, I’m installing Omarchy. Fresh start. Clean slate. Pre-configured but still customizable.

Will I lose some of my perfect setup? Probably.
Will I miss certain configs? Maybe.
Will I be more productive? I’m betting on it.

Two months ago, I left Windows because I wanted control. I wanted to understand my system. I wanted to learn.

I did all of that. Mission accomplished.

Now it’s time to use what I learned to actually build something instead of endlessly maintaining the builder’s tools.

Sometimes the smartest choice is knowing when to stop optimizing and start shipping.

The arch.log series: My journey from Windows to Arch, from consumer to builder to… pragmatic builder? Learning when to DIY and when to let go. Still shipping. Still honest about what works and what doesn’t.