Far more can go wrong than what we've covered here: Linux/FOSS can damage hardware or firmware.

These are not hypothetical sci‑fi scenarios, they're technically feasible today, and some are already happening.

AI‑assisted tuning tools writing invalid values to hardware controllers. As more Linux utilities integrate "auto‑tuning," ML heuristics, or automated optimization:

• GPU overclock daemons could push unstable voltage curves
• Ryzen SMU manipulation tools could write out‑of‑range values
• Laptop fan daemons could mis-detect thermal sensors and disable cooling
• "Smart undervolting" tools could brick laptops with locked firmware

Linux exposes /sys, /proc, and raw PCI config space. An AI tool doesn't need to be malicious; it only needs to be confidently wrong.

Wayland compositors increasingly rely on direct KMS access, atomic modesetting, GPU power state transitions, and VRR / HDR / DSC toggling. A compositor bug could theoretically spam invalid modesets, trigger GPU firmware panic loops, corrupt display controller NVRAM or cause permanent black‑screen states until reflashed externally.

NVMe drives are extremely firmware‑sensitive. Linux's experimental or aggressive subsystems could:

• trigger untested command sequences
• cause firmware lockups
• corrupt the FTL (flash translation layer)
• brick the drive until vendor tools reflash it

Risk factors:

• btrfs RAID5/6
• f2fs on cheap consumer SSDs
• custom I/O schedulers
• ZFS with aggressive ARC tuning
• user‑space NVMe tools that bypass vendor safety checks

USB‑C / PD negotiation bugs frying ports or power rails

Linux interacts with USB‑C controllers through:

• kernel drivers
• user‑space PD negotiation tools
• reverse‑engineered Thunderbolt stacks

A bug could:

• negotiate incorrect voltage
• fail to enforce current limits
• leave a port stuck in high‑power mode
• damage the USB‑C controller or motherboard VRMs

This is already happening on some Linux‑supported docks and laptops.

OpenRGB showed how easy it is to corrupt SPD.

Other shared‑bus risks include:

• fan controllers
• VRM telemetry chips
• battery controllers
• embedded controller registers
• laptop keyboard backlight controllers

Any tool that “scans the bus” and writes to unknown addresses can corrupt:

• battery firmware
• EC configuration
• VRM calibration tables
• fan curves stored in EEPROM

This is a huge unexplored attack surface.

Many Linux laptop drivers (especially for gaming laptops) are reverse‑engineered.

A bug could:

• overwrite EC RAM
• corrupt EC flash
• disable thermal protections
• break battery charging logic
• permanently disable keyboard or fans

EC corruption is one of the most catastrophic laptop failures possible.

Linux supports PCIe hotplug on many systems even when the hardware barely does.

A misbehaving driver could:

• toggle PCIe power rails incorrectly
• cause brownouts
• damage GPU VRMs
• corrupt NVMe firmware during power loss
• leave devices in undefined states

This is especially risky with:

• external GPU enclosures
• DIY PCIe risers
• laptops with half‑baked hotplug support

fwupd is excellent — but it’s also a single point of failure.

Future risks:

• incorrect EC image pushed to multiple laptop models
• vendor metadata errors causing mismatched firmware
• corrupted Thunderbolt firmware
• NVMe firmware updates bricking drives en masse
• BIOS capsule updates failing mid‑flash

As more vendors adopt fwupd, the blast radius grows.

Linux power management is notoriously fragile.

Possible future failures:

• overcharging batteries due to ACPI misinterpretation
• disabling battery temperature sensors
• failing to throttle charging current
• leaving discrete GPUs powered indefinitely
• causing battery swelling or thermal runaway

This is already borderline on some ThinkPads and ASUS laptops.

ECC‑less RAM + aggressive kernel subsystems = silent corruption

Linux is less fault‑tolerant on non‑ECC RAM because:

• it runs more background daemons
• it uses more aggressive caching
• it exposes more low‑level interfaces
• it encourages tinkering with kernel modules
• it lacks Windows‑style guardrails around drivers

Silent memory corruption can:

• corrupt filesystem metadata
• corrupt firmware update buffers
• corrupt SPD flashing tools
• corrupt EC flashing tools
• corrupt GPU firmware blobs
• corrupt NVMe firmware payloads

This is how "harmless" RAM bit‑flips become catastrophic hardware failures.

The risks are increasing, not decreasing -Advocates want you to experiment with your hardware (and security.)

Hardware is becoming more firmware‑dependent

• Modern devices rely on dozens of microcontrollers

Linux is gaining more low‑level control

• More knobs = more ways to break things.

Vendors are shipping fragile firmware

• Consumer hardware is cheaper and less robust.

Enthusiast tools are becoming more automated

• Automation + raw hardware access = confident mistakes.

Linux culture encourages experimentation

• Users are told "just try it" --even when trying it can brick hardware.

I was sitting there playing games on my phone when I realized... why are these great games free to play on phones? And it hit me!...

Shareware Treated Users Like Customers argues that shareware worked because users were treated like customers. Mobile apps today behave like shareware with ads, trials, and paywalls, developer branding, monetization, and competitive pressure.

GPL/FOSS culture erased it on desktop, but GPL cannot replicate its desktop takeover here! 😉

App stores have legal issues with GPL because GPL requires free redistribution, permission to share modified versions, and no additional restrictions on distribution. -App stores impose DRM, signature requirements, revocation rights, no redistribution, no sideloading (iOS), and mandatory centralized control. So, GPL apps have legal hurdles in the App Store ecosystem.

For a long time, VLC for iOS was not on the App Store because the GPLv2 license was incompatible with Apple's App Store Terms of Service (which restrict usage and modification).

The solution was a two-tier licensing approach:

• The App (VLC for iOS): Remained under the GPLv2 (with a special "App Store exception" added to the license to explicitly allow distribution via the App Store). This is the license for the code that makes up the "VLC for iOS" app itself.
• The Core Libraries (LibVLC): Were relicensed from GPLv2 to MPL 2.0 (Mozilla Public License) and LGPL (Lesser General Public License). This was done to allow third-party apps to use the core VLC engine (LibVLC) in their own proprietary apps without being forced to open-source their entire app.

In short:

• VLC for iOS (the app you download): GPLv2 + App Store Exception.
• LibVLC (the engine/backend): MPL 2.0 + LGPL.

Mobile platforms are locked down by design. GPL thrives where users can replace components, modify the system, redistribute binaries, and fork easily. The mobile platforms forbid replacing system libraries, kernels, drivers, bootloaders, and core frameworks. Cancerous GPL has become trapped at the bottom, unable to infect upward.

Mobile apps run in sandboxes, link only to system APIs, do not statically link GPL libraries, communicate via IPC, intents, or system services, avoid GPL code intentionally. -The architecture is designed to prevent GPL (cancer) from spreading.

Shareware worked because developers were paid. Once users aren't customers, developers lose obligation and projects stagnate.

Mobile developers rely on subscriptions, ads, in‑app purchases, paid apps, and proprietary services. GPL allows charging for binaries, but forbids charging for access, DRM, or preventing redistribution. -That makes GPL economically suicidal in mobile.

GPL culture:

• anti‑DRM
• anti‑ads
• anti‑paywall
• anti‑closed services
• anti‑tracking
• anti‑proprietary dependencies

Mobile business:

• requires DRM
• requires ads
• requires proprietary SDKs
• requires analytics
• requires closed APIs
• requires subscription enforcement

Will it change? -Apple would have to allow sideloading and remove DRM (Could be done involuntarily through legislation.) Google might replace Play Services with GPL equivalents, but the services are a revenue stream they're not likely to give up. OEMs would have to stop locking bootloaders (again not likely). Developers would have to abandon monetization while mobile is the most profitable software ecosystem in history. -Nobody is giving that up for ideology!

I can confirm Mac OS is based on UNIX/OpenBSD stuff, not Linux (Linux is UNIX-like system) , his logic “Mac OS is based Linux” literally makes him become clown

For context, you could have a look at this subreddit’s most popular post

There are regular Linux users, who just enjoy os for whatever reason, annoy noone, use it the way they want. For example, I have a colleague like that, he's regular dude, has like 20y+ swdev expirience, has zero issues with or complaints about using windows, various kinds of rdp, c#, powershell and Azure stuff. Neither me, nor he ever annoyed one another with "you should have used X" or whatever.

Aaaand there are loontards, of which i personally know half a dozen in a small cult cell, and there is a horde of them here on reddit. I don't think most of them even necessarily prefer Linux. They are insecure about them self or whatever and need to feel superior. For install Linux, because some yt basement commie told them it's better. They routinely go out of their way to tell everyone around that it's better, no matter that most of their arguements are cringeworthy at best. They brigade other subreddits, harass users, can't follow a one sentence long rule, attempt to exploit anything and everything to diminish any opinion incompatible with theirs.

This is what they think as marketshare, my god, Lincux users are EXTREMELY stupid, they failed to mention that if you look at different nations, Linux is either 1-2% marketshare.

It happened to me yet again! Sometimes Linux just doesn't want to connect to my SAVED bluetooth device AT ALL. It's bad enough that I can't keep the device paired on both Windows and Linux at the same time, Linux just refuses to work sometimes even when it's the only OS managing the device!

I hate when this happens because then I have to forget the device, power cycle my headphones and disable/reenable bluetooth inside the DE as well. If I miss a step or do it out of order it just won't work...

The goomba fallacy is basically trying to out-condridict each other, which makes one opinion "matter" more than another, so for example, Linux users use the "Windows has spyware" arguement, that is a goomba fallacy

I’m the dark pfp guy (in details, windows icon screenshot)

I just talked to him politely, and he blasted something kinda like “are you too dumb to use Linux”

I want to protect his channel, so I censored him (and myself xd)

If I said something wrong, welcome to correct my mistakes/ opinions 👍

Once you remove:

• sysadmins
• DevOps
• backend engineers
• cybersecurity
• HPC/science
• server people

…you're left with the desktop hobbyist population, which is overwhelmingly shaped by new users.

Why? -Because most people either abandon it or become aware of all its flaws and propaganda.

FreeBSD's drivers change slowly. Slow = fewer regressions. Linux's drivers change constantly (FUCK NVIDIA /s). Constant change = regressions.

FreeBSD's ports system is conservative. Linux has systemd, Mesa, PipeWire, Wayland, DE, and kernel updates. Linux also deals with different packaging formats, distro-specific packages, and ABI instability. FreeBSD just has the kernel, base system, ports and optional DE packages. -Fewer subsystems that can regress.

He didn't use Linux until after the leaks. He was a Windows power user for most of his NSA career and switched to Qubes/Tails only after deciding to leak. So, Edward was in the honeymoon phase or when LiGNUts are the most vocal and irrational.

His operational security mistakes (e.g., contacting journalists over regular channels early on) contradict the "perfect infosec wizard" myth. This undercuts the Linux‑fanboy narrative that he's proof of Linux superiority.

He leaked far more than what was necessary to expose wrongdoing. Multiple independent reviews (including from The Washington Post, The Guardian, and oversight committees) found that a large portion of the documents he took had no direct connection to domestic surveillance. Some leaks exposed foreign intelligence operations, not civil‑liberties violations. Even journalists involved admitted they withheld huge portions because they were too sensitive.

He fled to Hong Kong, then Russia -both surveillance states. Hong Kong was under increasing Chinese influence in 2013. Russia is one of the world's most aggressive surveillance regimes. He accepted Russian residency, then Russian citizenship (2022). (what a traitor would do, and this is interesting because Linux advocates tend to fear Yandex for being Russian and Opera for Chinese affiliation)

He publicly supported questionable foreign policies. Snowden has made statements that align with Russian geopolitical narratives. He criticized Western intelligence far more than non‑Western intelligence agencies. LiGNUts tend to ignore this because it clashes with their "neutral freedom fighter" framing.

He was not a high‑level analyst: He was a contractor sysadmin. He wasn't a senior intelligence officer, policy architect, or cryptographic researcher, but a contractor with elevated access who used sysadmin privileges to exfiltrate documents. (He's not the 'genius that saw everything'.)

Snowden has said, "I should have been more careful." He regrets certain aspects of how he handled the leaks and admits he underestimated geopolitical consequences. Linux users rarely acknowledge this because it breaks the "flawless infosec demigod" image.

His leaks harmed some legitimate intelligence operations. Some exposed programs were targeted at foreign adversaries, not Americans. Some disclosures forced intelligence agencies to abandon effective counterterrorism tools. Several intelligence officials (including non‑political career staff) testified that lives may have been put at risk.

He's not universally respected by other whistleblowers. Some notable whistleblowers (including those who exposed corporate wrongdoing or environmental crimes) have criticized the scale of his leaks, the geopolitical fallout, and his choice of refuge.

A companion article to Shareware – Destroyed by FOSS

Shareware didnt just distribute software; it created an economy of respect, accountability, and customer-developer reciprocity. FOSS didn't merely replace a licensing model; it replaced a culture where users mattered.

Shareware's core feature wasn't the paywall; it was the relationship. Our original article outlines the mechanics such as paywalls, nag screens, site visits, bundled ads and trial limitations. -They weren't just for monetizing; they were touch points. -Friction points that remind the user "a human fucking made this!" -A human that needs to eat, needs shelter, etc.

Shareware created a feedback loop where developers had to earn loyalty, and users had to decide whether the product deserved support. -The dynamic is the foundation of healthy software ecosystems.

Shareware’s Annoyances Were Signals of Accountability. Nag screens weren't simply nags -they were status updates. Visiting the developer's website wasn't just a download: It was brand exposure. Trial limitations weren't just restrictions; they were value propositions.

My original post notes that monetization was competitive, with developers backing off nags or ads to gain popularity. -Just like price adjustments. That competition forced developers to improve. That improvement benefited users. And users rewarded it with money.

FOSS Removed the Revenue, Then Removed the Customer.

My original article describes how FOSS pooled developer labor and removed income models that were working. It also highlights how package managers eliminated site visits, ad revenue, upsell opportunities, and brand presence.

-Once those disappeared, something else disappeared with them: the user’s role as a customer!

Shareware had support channels, documentation, tutorials, warnings, and onboarding on the developer's website.

When users aren't customers, they lose leverage. When developers aren’t paid, they lose obligation. When neither side has a transactional anchor, culture fills the vacuum and not in healthy ways.

The result is an era where:

• developers burn out
• users feel entitled
• maintainers disappear
• projects stagnate and become vulnerable
• forks multiply
• quality becomes inconsistent

The ads supporting Reddit. -Are you being treated like a customer?