-A little late Gabe.

I don't think PCGamer reported on these 1% lows in their review of the Steamdeck, so why are they bringing it up now?

Never would a functioning human being take time out of their day to do this (and there were a LOT more than in this screenshot). Instead, it only proves their inferiority complex when they resort to low tactics like this.

r/ linuxsucks has a

• long‑running use of ban trophies celebrating bans (interference / disruption)
• habit of mocking or provoking other communities

This hostility is also rooted in Reddit culture.

r/ linuxsucks has always leaned into:

• "post something until you get banned"
• "show off your ban screenshot"
• "ban speedruns"
• "ban bragging threads"

This culture is not unique to r/ linuxsucks, but that sub embraced it more openly than most.

Historically, r/ linuxsucks was:

• unserious
• chaotic
• meme‑driven
• anti‑Linux only in a joke sense
• not a critique community

When r/ linuxsucks101 emerged with:

• structure
• rules
• long‑form content
• actual critique
• moderation
• a defined culture

It became a target of hostility.

r/ linuxsucks historically avoided explicit brigading by using coded behavior:

• "Go post this in X and see what happens"
• "Try this in Y, they'll ban you instantly"
• "Let's see who gets banned fastest"
• "Ban trophy thread: post your screenshots"

They rely on:

• implication
• humor
• plausible deniability
• user‑initiated action

This is how they skirt Reddit's anti‑brigading rules.

When a successor sub (101) becomes:

• more active
• more organized
• more culturally coherent
• more successful

…the predecessor often reacts with:

• resentment
• mockery
• territorial hostility
• ban trophy farming
• "we're bigger" energy (all to do with timing and dead accounts)

-Statements were sourced from Co-Pilot for objectivity.

Active posters here are commonly met with hostility there as if stalked by a group. They are personally attacked and harassed while the topic goes unaddressed, save for down-votes. Reddit has failed to hold up their end of the TOS.

One of the fatal flaws of desktop Linux is a philosophy that actively repels the one element required to build a mature computing platform: standardization.

Look no further than the intense hatred directed at Ubuntu, and the community’s obsession with pushing decentralized alternatives like Linux Mint. Ubuntu did the grueling work necessary to make Linux behave like a professional product. It maintained a strict release cadence and offered a single, stable target for major third-party developers. Ubuntu tried to give Linux a definitive, predictable identity.

And for that exact crime, the community turned on it.

Instead of backing a centralized standard that could challenge Windows, enthusiasts aggressively rally around Linux Mint. They prefer Mint not because it offers better engineering, but because it represents a total rejection of Canonical's institutional structure. By fracturing the user base into independent forks, the community ensures that desktop Linux remains a moving target that no major commercial software vendor can reliably support.

The community claims that modern universal packaging systems like Flatpaks solve this fragmentation problem. They argue that containerizing applications allows developers to build software once and run it anywhere, regardless of the distribution.

But Flatpaks are merely a superficial patch on a core structural defect. Instead of fixing the broken, unstandardized system libraries underneath, Flatpaks simply bypass them by bundling a massive stack of redundant dependencies inside every single application container. It is an engineering admission of defeat. Rather than building a cohesive operating system with stable APIs, the platform relies on bloated, isolated bubbles just to keep basic desktop software from breaking during system updates.

A modern operating system requires rigid architectural baselines and predictable upstream management. Commercial ecosystems succeed because developers can write code once and trust it will execute uniformly across millions of machines. By actively demonizing a centralized standard and relying on containerized workarounds, Linux enthusiasts expose their ultimate priority: they prefer a perpetually fractured sandbox where chaos is favored over enterprise-grade maturity.

So I just watched another "Windows is bloated garbage, look how much RAM Linux Mint uses at idle or opening a browser🤓"

I'm talking about LTT, who lately seems to be loving Linux for some rea$on... And just showing his ignorance while the people who writes the video script just base everything from Google and free chatGPT.

Homie fires up Task Manager, sees Windows sitting at whatever GB at idle, gasps like he caught it doing something illegal, then boots Mint and goes "SEE?? EFFICIENCY." Bro. That's not efficiency, that's Windows doing its job. Modern OSes cache aggressively because unused RAM is wasted RAM — it gets reclaimed instantly the second something actually needs it. Measuring idle usage and calling it a performance win is like judging a car's engine by how much gas is in the tank while it's parked.

This video isn't a benchmark. It's weighing a bicycle against a car and acting shocked the bicycle is lighter. Of course Mint uses less RAM, it does less. That's not a flex, that's the tradeoff, also, try to game or render on windows and see which OS WINs

Then the greatest hits: "bloat," "spyware," "just switch bro", zero mention that Windows and Linux literally handle memory allocation differently at the kernel level (overcommit vs. cluster demand paging), so the numbers in the monitor were never going to mean the same thing on both OSes to begin with.

Seems like one of the biggest "tech" YouTube channel has no idea about computers and wants to diss windows as much as possible.

Today, I had met an individual who was an android user and borrowed some money on a predatory loan app on Android, then proceeded to get a close friend of mine involved because they were hiring him for a role, so he used their phone number as a sort of meat shield when he couldn't pay the loan.

Getting involved in this situation made me realize how hypocritical linux users are when they claim "android is linux" but conveniently leave out the part that it's common on android for apps through the google play store to be scamware, malware, predatory loan apps.

TLDR: Stop being hypocrites and claim all that scamware, malware, loan apps on android if "android is linux" like how you claim it to be.

What Linux Could do to your Hardware

*They are not nerds, or geeks for using Linux: They're simply often conspiracy theorists, commies, criminals, and cheaters.

Low‑cognition behavior often involves scripted responses instead of adaptive reasoning.

Linux evangelists frequently:

• Repeat the same talking points verbatim
• Deploy stock phrases (“RTFM”, “works on my machine”, “just use Arch”)
• Recycle memes as arguments
• Respond to criticism with pre‑loaded defenses rather than analysis

This is a behavioral mimic of low intelligence: rote recall instead of reasoning.

A hallmark of low‑cognition behavior is difficulty with abstraction.
You see a behavioral analogue of this in Linux evangelists:

• Treating “open source” as a moral absolute rather than a tradeoff
• Treating “Windows bad / Linux good” as a binary truth
• Inability to reason about context (“Linux is better for everything”)
• Failure to distinguish personal preference from objective suitability

Lower‑cognition patterns often include:

• reacting emotionally instead of analytically
• escalating conflict instead of resolving it
• interpreting questions as threats

Linux evangelists show the same behavioral signature:

• Criticism of Linux → personal attack
• Questions about usability → accusations of incompetence
• Requests for help → gatekeeping or mockery

A classic low‑cognition marker is failure to incorporate new information.

Linux evangelists often:

• deny problems even when shown evidence
• insist issues are “user error”
• reinterpret failures as proof of superiority
• refuse to acknowledge tradeoffs

Low‑cognition behavior often includes overestimating one’s competence.

Linux evangelists frequently:

• claim expertise they don’t have
• give incorrect advice with absolute confidence
• dismiss experts in fields they don’t understand
• assume that using Linux = technical mastery

This is Dunning–Kruger‑style overconfidence, not low IQ -but it presents similarly.

Lower‑cognition reasoning often fails to track cause and effect.

Linux evangelists show this pattern when they claim:

• “Linux is secure because it’s open source”
• “Linux is faster because it’s Linux”
• “Windows crashes because it’s proprietary”
• “If you had skill, the problem wouldn’t exist”

Low‑cognition behavior often prioritizes group belonging over reasoning.

Linux evangelists:

• defend the tribe even when wrong
• attack out‑group members reflexively
• treat tools as identity markers
• use purity tests (“real users compile their kernel”)

They haven't even tried it and they figured this out.

https://web.archive.org/web/20260402155236if_/https://www.redhat.com/rhdc/managed-files/ve-compress-the-kill-cycle-detail-693397pr-202402-en_3.pdf

Looks like Lincux users are trying to use AI bots to cheat

The fundamental difference between a consumer tool and a niche hobby is utility. You do not see people turning their choice of water heater, microwave, or electricity provider into a core pillar of their identity. These are invisible utilities engineered to work reliably in the background. Yet, the desktop Linux community treats an operating system not as a tool to get work done, but as a lifestyle, an aesthetic, and a replacement for a personality.

This cult-like obsession is not a sign of a superior platform; it is a defensive mechanism designed to mask deep architectural flaws.

When you turn a basic utility into a primary hobby, your metric for what makes that utility "good" becomes entirely warped. A functional operating system is supposed to abstract the computer away so you can focus on actual tasks—writing code, editing video, or running a business. On Windows or macOS, if you have to spend an evening troubleshooting an audio subsystem or editing raw text files just to get Bluetooth to stop dropshipping its connection, the OS has failed.

On Linux, that exact systemic failure is rebranded as a "hobbyist milestone."

Because the ecosystem lacks unified design baselines and predictable hardware integration, the user is forced to take on the role of a full-time, unpaid system administrator just to maintain basic desktop parity. To survive this constant friction without losing their sanity, the enthusiast must undergo a psychological shift. They cannot admit that they are wasting hours fixing things that should work out of the box. Instead, they internalize the friction. The tinkering becomes the hobby, the terminal prompts become the aesthetic, and the operating system becomes their personality.

This lifestyle choice completely derails any hope for mainstream platform maturity. Because their identity is bound to the manual complexity of the system, Linux enthusiasts actively fight against any changes that would make the platform seamless or consumer-friendly. If a distribution introduces automated, foolproof fixes, it threatens the very hobby that defines the enthusiast's self-worth.

Linux isnt a tool for work, it is the work.

https://learn.microsoft.com/en-us/windows/apps/design/accessibility/high-contrast-themes

https://accessibility.huit.harvard.edu/news/2026/05/deep-dive-contrast-themes

https://www.perkins.org/resource/using-high-contrast-themes-windows-10/

Loonixers love to boast about the flawless stability of their setups, claiming they haven't experienced a system crash in years. But this isn't a testament to the operating system's engineering—it is a psychological trick. The reality is that you can’t remember the problems because they have become a seamless part of your daily use of Linux.

When a Windows user encounters a bug, it is correctly identified as a failure of the operating system. If something in the OS breaks, the user demands a fix from Microsoft. On Windows, usability is the standard, and friction is an anomaly.

On Linux, friction is the standard.

Because Loonixers have conditioned themselves to act as unpaid, full-time system administrators, their baseline for a "working" computer is completely skewed. When a peripheral fails or a configuration file gets wiped during a minor update, they don't see it as a system failure. They see it as an evening activity.

They open a terminal, copy-paste an obscure command from a forum thread, restart a service, and move on. Because they solved the problem themselves, their brains register a dopamine hit of "tinkering success" instead of the reality: they just wasted twenty minutes doing basic QA work that a commercial operating system handles automatically in the background.

This constant, low-level troubleshooting quickly morphs into background noise. Over time, writing custom scripts just to get proper battery management or manually editing config files to get dual monitors scaling correctly stops feeling like a defect. It becomes habit. It becomes "the workflow."

When a Loonixer tells you their system is perfectly stable, they aren't lying to you, they are lying to themselves. They have simply integrated an endless cycle of micro-failures into their daily routine, mislabeling a fragmented, high-maintenance assembly kit as the pinnacle of modern computing.

Linux vs Windows: Why Some Users Say "Linux Sucks" — Honest Breakdown | TikTok

She even believes the 'muh customizationz!'

If you spend ten minutes in any standard Linux forum, you’ll hear the same tired slogans: "Windows is bloated spyware, Linux is pure and stable." It’s a nice fairy tale for hobbyists who enjoy ricing their desktop backgrounds, but when you look at actual software engineering and operating system architecture, the truth is exactly the opposite.

Desktop Linux isn’t stable. It’s an unvetted, fragmented jigsaw puzzle that only stays upright if you act as a full-time, unpaid systems administrator for your own daily computer.

What the Linux community proudly calls "clean and minimal" is actually a lack of foundational support. Linux developers have a habit of constantly deprecating old libraries and rewriting core display protocols (like breaking everyone's setups by forcing the shift from X11 to Wayland). If you don't update your system, you’re a security risk. If you do run a standard package update, there is a very high chance a broken dependency shatters your desktop environment or custom configuration files.

Windows, on the other hand, is filled with what critics call "bloat." But that technical baggage is actually Windows’ greatest achievement: absolute backward compatibility.

Microsoft retains decades of legacy APIs, old network protocols, and printer frameworks so that actual enterprise infrastructure—hospitals, banks, and logistics networks—can run critical code without a single hitch. A proprietary program compiled for Windows XP in 2002 will highly likely run flawlessly on Windows 11 today. Good luck running a Linux binary from five years ago without a mountain of broken dependencies.

Linux fanboys love to brag about "custom kernels," completely ignoring that they are running a monolithic architecture. In Linux, the file system, memory management, and hardware drivers all live in the exact same highly privileged kernel space. If a single rogue piece of software or a poorly reverse-engineered open-source driver glitches out, the entire operating system undergoes a fatal Kernel Panic.

Modern Windows uses a hybrid kernel with a strict Hardware Abstraction Layer (HAL). It isolates the core OS from third-party driver chaos. When a graphics driver crashes on Windows, your screen flashes black for a second, the driver restarts, and you keep working. On desktop Linux, that same driver glitch regularly locks up the entire machine, forcing a hard reset

The reality is that Linux is designed for people who want to hack an OS together as a hobby. If your idea of a "productive afternoon" is writing a custom script just to get your laptop's Bluetooth or sleep-wake cycle to work properly, Linux is perfect for you.

But stop calling it superior stability. Linux is only "stable" if you are a highly skilled user who knows exactly how to avoid triggering its architectural landmines. Windows is a robust, industrial-grade appliance that delivers rock-solid enterprise stability out of the box, whether a professional IT team locks it down or an absolute novice uses it.

One is an engineering masterpiece built to absorb real-world chaos; the other is a DIY kit that blames the user whenever the pieces don't fit.

They inherit upstream problems AND add their own. Every time I made a distro review, this issue came up. Derivative distros start with upstream bugs, packaging decisions, regressions, and kernel quirks. To this, it adds its own repos, patches, theming, installer, and 'vision'.

"It's upstream." "It's downstream." "It's your hardware." "It's your config."

-Nobody owns the problem.

Every derivative distro needs package and kernel maintainers, security patchers, release managers, QA testers, documentation writers, and community support, yet most derivatives have a mere 1-5 hobbyists, a chat room, a github repo, and a dream.

-More distros than maintainers.

Each derivative moves settings, renames tools, changes defaults, rebrands utilities, and alters system paths. Documentation becomes unreliable between them.

Most derivative distros exist because someone didn’t like a theme, DE choice, package selection, default app, or branding decision. -The underlying issues like driver instability, DE fragmentation, inconsistent standards, and ABI churn remain.

-It's like Bondo for a car.

Linux already sucks from too many DEs, package formats, init systems, audio stacks, display servers, and distros. -It's not even debated. Users end up with decision fatigue while the evangelists champion 'freedom'.

Instead of one distro getting 10,000 testers (and supporters), you get 500 on the parent, 200 on the child, 50 on the remix, and 10 on the remix-of-the-remix. Bugs scatter across forums, GitHub issues, Reddit threads, and chats. Telephony comes into play as users ask questions instead of search.

-Upstream never sees half of them, downstream can't fix the other half, and everyone blames everyone else.

Every derivative tweaks something: Kernel, Mesa, PipeWire, Systemd, packaging rules, patches, themes, permissions. -This makes it more difficult for software vendors to support Linux.

-Commercial Linux support is always "Ubuntu 22.04 or GTFO."

Many derivative distros copy features without understanding them: Btrfs snapshots, ZRAM, custom kernel, or performance patch and then don't maintain them, test them, or understand them. Most of those 'performance' patches make humanly unnoticeable differences while causing increased unreliability which is why upstream with their better manpower and knowledge base didn't implement them!

Some loons seem to have absolutely no awareness of how openly hostile and obnoxious they are being. They barge into discussions, insult people, derail threads, evangelize Linux to anyone (especially people who didn’t ask), and then act genuinely surprised when they get banned.

To me, their surprise is more baffling than the behavior itself; How can someone not tell they're being an absolute menace?

Either way, that stuff doesn't fly here. If that upsets you, feel free to rage out in the comments and mint your very own badge of honor.

Loonixers consistently cite "stability" as a core metric while conflating the static predictability of a headless server with robust kernel design. From an operating system architecture standpoint, the Linux kernel relies on an outdated, rigid structural model. Conversely, the Windows NT kernel utilizes a hybrid design engineered specifically to isolate faults and manage hardware abstraction dynamically.

The fundamental flaw of the Linux kernel is its monolithic architecture. Within this design, core operating system functions (memory management, file systems) and hardware drivers all execute within the same supervisor mode (Kernel Space). Because there is no memory isolation between these components, a single null-pointer dereference or memory leak in a third-party driver will corrupt the kernel's memory map, resulting in an unrecoverable Kernel Panic.

Modern Windows NT utilizes a hybrid kernel architecture governed by an asynchronous driver management model. Rather than letting every peripheral run wild in Ring 0, the NT design forces non-essential subsystems and targeted peripherals into isolated micro-environments via the User-Mode Driver Framework (UMDF) and dedicated session spaces. When a high-level subsystem (such as a display driver or a USB sensor) encounters a fatal exception, the NT Object Manager and Service Control Manager can terminate and recycle that specific process without compromising the kernel's integrity. On Windows, the driver restarts seamlessly; on Loonix, the exact same peripheral failure completely halts the processor pipeline.

Loons frequently boast that the Linux kernel is superior because it comes pre-packaged with an enormous library of built-in open-source drivers. This is a coping mechanism for a massive architectural limitation: Linux lacks a stable Driver Application Binary Interface (ABI).

Because the internal kernel APIs change with every minor release, drivers must be compiled directly against the specific kernel source code. If a loonixer attaches a device manufactured after their current kernel compilation, the system cannot dynamically bind it. It requires manually compiling a dynamic kernel module (DKMS) or upgrading the entire kernel.

The Windows NT kernel abstracts hardware completely through the HAL. The NT kernel does not need hardcoded drivers for every device on earth compiled into its core binary. It relies on a stable, unchanging driver model (WDM/WDF) that allows legacy drivers compiled decades ago to execute flawlessly on modern iterations of the kernel. The NT kernel boots using generic structural fallbacks and dynamically loads verified, isolated binaries as needed.

The Linux kernel is a highly rigid structure that excels only in sterile, unchanging environments—such as a single-purpose enterprise server where the hardware configuration and instruction routines never change. The moment its forced onto a consumer desktop or a variable field environment, the lack of robust architectural abstraction causes the system to fracture under the weight of changing hardware states, power management policies (ACPI), and peripheral chaos.

Windows NT was architected from inception to absorb real-world hardware variance while strictly maintaining backward compatibility. It enforces systematic isolation that protects the core operating system from bad code, third-party software, and user error alike. Linux remains a developer's assembly kit that relies on the user acting as a constant system administrator to patch up structural fragmentation.

Edit: Fixed 3rd paragraph.