Following yesterday’s Linux 6.18 kernel release, GNU Linux-libre 6.18-gnu is out today as the latest release of this free software purist kernel that will drop/block drivers from loading microcode/firmware considered non-free-software and other restrictions in the name of not pushing binary blobs even when needed for hardware support/functionality on otherwise open-source drivers.
With Linux 6.18 there are more upstream kernel drivers dependent upon binary-only firmware/microcode. Among the drivers called out this cycle are the open-source NVIDIA Nova-Core Rust driver as well as the modern Intel Xe driver. Nova-Core is exclusively designed around the NVIDIA GPU System Processor (GSP) usage and thus without its firmware the driver is inoperable. Similarly, with the newer Intel Xe driver depending upon the GuC micro-controller without its firmware the support is also rendered useless.
If I’m not mistaken doesn’t the firmware in question get uploaded to the device in question and run on said device not the host CPU? Those devices are already closed and often already running proprietary firmware. I don’t really understand the war against uploading blobs to them? I love FOSS and more power to anyone who wants to do this but it seems excessive.
The FSF’s position is roughly that software (instructions that run on programmable computers) ought to be free as a matter of ethics, but that hardware is different, basically because of the difficulty and resources necessary to “copy” hardware. See Free Hardware and Free Hardware Designs for Stallman’s thoughts. Basically, he (and the FSF) don’t consider “free hardware” to be a coherent concept- just “free hardware designs”. So using FSF terminology, it doesn’t make sense to speak of free or open-source hardware.
The FSF basically draws the line at easy programmability. If a device was designed to be reprogrammed, what it’s running is software, which should be free, otherwise you’re ceding control over that computer to the copyright holders of the software it runs- and that doesn’t just include your host CPU, it includes every computer you own, including other ones on your motherboard. If a device was not meant to be easily reprogrammed, then the “software” it runs is really just a permanent part of the design, and the FSF doesn’t really care about this type of firmware being “free”. Devices with firmware in Linux are clearly able to be easily reprogrammed- you just change the firmware code- so firmware that runs on these devices meets the FSF’s definition of software.
Apologies, when I said free hardware I meant design as well as somewhat blending the term with free firmware. But either way the difference they draw isn’t really all that different when you think about it. It’s sort of irrelevant whether or not the firmware can be easily updated, what really matters is where the firmware is being executed. If it’s running on the device then it can be isolated by the host system, if it’s running on the host then it’s not really firmware but rather part of the driver. The semantics don’t change just because the firmware is “easily updatable.” Having it be uploaded by the driver provides security benefits in that it can be patched by the manufacturer after the fact and having firmware in ROM which can’t be patched doesn’t guarantee it’s more secure or even less complex in design. I guess I just see it as a somewhat arbitrary line and I personally don’t agree with it
They’re not saying devices shouldn’t be programmable- they’re saying if they are, users need to have the right to control the software that runs on said device.
For the FSF it’s not about what’s more “secure” or less complex, but rather whether there’s freedom to be had. In the one case, having rights to view and modify the source gives the user additional freedoms they otherwise don’t have, e.g. to apply security patches as you point out. In the other case, it doesn’t, because even if they could view and modify the source, they can’t make changes to their device with that ability even in principle. Note that, in general, the law does not prohibit users from modifying hardware that they own, so that’s not an issue of freedom. But software is.
Having a circuit diagram for a chip you own is cool, but it doesn’t allow you to change an IC- you don’t have the practical ability to do that. Likewise if the “firmware” is permanent- viewing the “source” is maybe technically interesting but grants you zero additional abilities. If it’s defective, it’s the same as buying a defective IC. Tough luck.
You can choose not to care about the additional freedom you get if you’re allowed to view and modify firmware for programmable devices you own, and that’s fine. It’s typically not meaningfully important for me either. But it’s absolutely not an arbitrary line.
Why do you say it matters where the firmware is being executed? Is it less important to control less powerful computers you own? Why should the code suddenly be unimportant if it’s not executing on your main processor?
This is basically the same argument that caused the libreboot vs gnuboot thing and I just personally don’t get it. It seems to me like the FSF is letting perfect be the enemy of the good. Having a FOSS driver isn’t something to be celebrated it’s something to be punished if the firmware isn’t also FOSS. Yes, ofc, FOSS firmware is better than closed firmware, but when almost no modern hardware has that as an option, it’s not even something you can really vote on with your wallet unless you just run ancient hardware all the time.
It matters because for me, a good chunk of the FOSS benefit is the auditability of code. Being able to make changes is nice and that’s the freedom bit, but being able to audit it is also a huge benefit. If the code is not running on the main CPU then the driver on the main CPU can contain possible exploits of firmware using the IOMMU etc so it becomes more tolerable than a closed source driver. Basically a firmware vulnerability effectively becomes a hardware vulnerability as opposed to a driver running with full kernel privileges and no oversight or containment.
They’re not saying devices shouldn’t be programmable
That may not be their goal but that is what they are saying. The position of the FSF is that a device whose closed source firmware cannot be upgraded is superior to one that can be upgraded but for which only closed firmware exists. So, if you are buying proprietary hardware (and you are in 2025), you should prefer the closed hardware which is not programmable.
It is a stance that only makes sense if you care more about the simplicity of your message than the implications of your position.
They are directly creating demand for less open systems that provide less freedom. It is dumb.
The solution is simply to have a sane definition of “free software” that does not include firmware.
There should be a Free Hardware Foundation that calls for hardware to be free. They can demand that everything be completely open which most of us would support and may even be possible now that we have RISC-V. Their list of “approved” hardware could be essentially blank. That said they could participate in creating some. Of course, it would likely be worse at first. You know, like Free Software was bootstrapped.
The FHF could object to all non-free hardware while still acknowledging that programmability is a positive step that at least has the potential to be more open. The FHF could sponsor or endorse free firmware efforts.
That clarity would allow the rest of us, even the FSF fundamentalists, to make sane choices.
This is exactly my sentiment on the matter too. Firmware is not software in practice although it is in theory. Proprietary firmware that can be upgraded is better than firmware burned into a ROM although the FSF disagrees. I personally run nearly 100% FOSS…S as in software, I have no open firmware, I wish I did…but it just isn’t realistic at this point in time.
100%.
There is a reason even the purists fall back on “hardware is out of scope”.
But calling firmware software drives worse outcomes. Will they do the same thing with RISC-V?
Is a RISC-V board better than an ARM board even if both have proprietary schematics and/or divers. In my view, clearly yes.
Every step towards open is positive.
The hypocrisy irks me somewhat as well. The FSF rather famously did not start by writing a kernel. It is why we have the GNU/Linux nonsense. The GNU utilities were first written to run on proprietary UNIX. And this made sense pragmatically as you have to start somewhere. But that was actually real “software” and yet RMS was ok with that. And today he tells people they cannot update the microcode in their Intel CPU.
According to his own definitions, the FSF should not have run a line of code on proprietary operating systems until the FSF had written its own kernel and drivers. But they enthusiastically did. Ok, so they did not write a kernel. How about the C library? Surely, they did not link to propriety C libraries. Or how about the compiler? Did they start with that? No, the first thing they wrote was a text editor (Emacs) and it was built with proprietary compilers, using proprietary C libraries, on proprietary operating systems. The C library came years later. Before that, all GNU software was linked with binary blobs (C library).
Fast-forward to today and you are supposed to condemn Debian for allowing binary blobs.
Not only dumb but massive hypocrisy.
From the article:
Freedom to copy and change software is an ethical imperative because those activities are feasible for those who use software: the equipment that enables you to use the software (a computer) is also sufficient to copy and change it. Today’s mobile computers are too weak to be good for this, but anyone can find a computer that’s powerful enough.
You can’t build and run a circuit design or a chip design in your computer. Constructing a big circuit is a lot of painstaking work, and that’s once you have the circuit board. Fabricating a chip is not feasible for individuals today; only mass production can make them cheap enough.
Basically, you’re legally prohibited from copying software, but you’re technically prohibited from copying ICs. Hardware isn’t “out of scope”, it’s just not the same kind of thing as software- information can be copied for basically zero marginal cost, but hardware can’t.
The FSF exists to fight legal encumbrances on the copying and modification of software because the technical details of hardware and software are totally different. Although, even in that same article, the FSF advocates for and recommends free hardware designs, which are more analogous to software. You can care about more than one thing. The FSF just particularly cares about software, including firmware, being free of unnecessary legal encumbrances related to copyright.
A hardware circuit can’t be changed; that’s its nature. If it’s acceptable for a device to be implemented with internal circuitry that no one can alter, then an internal program that no one can alter is no worse.
Treat ROM firmware as circuit.
The equivalence falls apart, however, when the software implementation is not totally internal and some company can modify that code. For example, when firmware needs to be copied into the device to make the device function, or included in the system distribution that you install, that is no internal software implementation; rather, it is a piece of installed nonfree software. It is unjust because some manufacturer can change it but you can’t.
Here, for your reference, ROM is fair for anyone, non-ROM that is non-free not fair.
But not think this imply “ROM better”, but rather “make free software or no software at all”. He want absolute freedom, you want usability. Which absolutely not what libre about.
The position of the FSF is that a device whose closed source firmware cannot be upgraded is superior to one that can be upgraded but for which only closed firmware exists.
Where they say that? They say if ROM firmware, no freedom possible. So outside scope of FSF.
“Where they say that?”
You have a hardware device that is fully proprietary and closed. The firmware cannot be programmed or upgraded.
The FSF is fine with this hardware. Stop me if you disagree.
Version two of the hardware above is released. The firmware can now be upgraded. The initial firmware available is closed source. It is actually the exact same firmware used in version one but it now ships as a binary blob. Since the hardware is programable, open source firmware could be written but none yet exists.
The FSF says that this hardware must be avoided. The binary blob cannot be handled or distributed. Version one of the hardware is still fine and is preferred. Again, stop me if I am wrong. Note, the firmware is the exact same.
Ok, now answer “where they say that?” for yourself.
If hardware is out of the scope of the FSF (totally reasonable) then firmware should also be outside of the scope of the FSF.
Because their stance today is that hardware that is more open is worse. Hardware can be as proprietary and closed as you like as long as you do not make it programmable. If you do, the FSF may have a problem. Insanity.
Free software is better than non-free software. The FSF and I agree.
Open firmware is better than closed firmware. This is my view but the FSF only has an opinion when the firmware is upgradable (as you state above). Silly.
Programmable hardware is always better than non-programmable hardware. That is my view, but the FSF disagrees when no open firmware exists. Dumb.
Obviously, version two is better than version one in the technical sense, because it has more capabilities. But it is also obvious that version one does not deny its users any abilities that it affords instead to the vendor- neither the user nor the vendor can modify the firmware inside the device, so the vendor doesn’t exercise more control over the sold device than the user does. Obviously, the vendor designed the device, but that’s as far as their influence over it extends.
Version two, on the other hand, it programmable. This make it technically superior, but since the firmware is proprietary, the user is denied the right to view source code and modify the firmware, a right which the vendor continues to hold after the device is sold to the customer. In other words, the vendor has a right over the device under copyright law that the customer does not.
That’s not an ideal situation, and it’s the one the FSF is trying to prevent. You have every right to buy hardware with firmware encumbered by such restrictions, I have myself. But it’s not dumb to care about one day freeing yourself of such restrictions, and that won’t happen if no one is pushing back on the practice.
Surely you don’t think all free software was technically superior to all proprietary software at the start of the movement, and surely you don’t think it even is now. But if you still think it’s a good thing that we have the free software ecosystem, then perhaps you sometimes care about things other than pure technical superiority. If so, you ought to be able to understand the FSF’s position here.
I ask for reference to source material, you repeat your own word.
Fine, i will do it myself.
@Scoopta @cm0002 The point is that if everything was open Linux support would be so much better as we would understand the working of the hardware so much better, and we should do everything we can to discourage manufacturers from adopting this stance. FOSS has the great benefit that anyone in the world can improve it, and then share their improvements with everyone else. That makes a better world. Just better.
To be clear, I’m not saying I don’t want open hardware, what I’m saying is I don’t get the point of allowing closed hardware that doesn’t require a firmware blob as opposed to closed hardware that does. That’s a very arbitrary and silly line that does nothing useful. They’re going on this crusade of “no blobs.” But why? There’s lots of hardware that already has closed blobs on the HW, but because it’s not uploaded by the driver those blobs are ok? You either have to say all closed firmware is bad and we’re going to take a stance against any devices which have any amount of closed firmware, even when shipped on ROM in the HW. Or, closed firmware is tolerable so long as the driver is fully FOSS. I love the idea of not having closed firmware but I just don’t get the intellectual inconsistency here.
Keep up the good fight Scoopia.
It is clear from the responses you get that people just do not understand what you are saying. But keep trying.
Imagine the FSF argument at the level of the whole computer. If the computer lets you run software, it has to be free software. But if the computer has all its software in hardware that cannot be programmed or updated, then it is not only totally fine but superior to a Windows computer because Windows is closed software even though the Windows computer let’s you run free software and the non-programmable one does not.
Running on Windows is evil because it is software. But running on closed non-updatable firmware baked into your closed, proprietary hardware is good. That is what the FSF has to say. Programmability bad.
There are two ways to fix the FSF position:
1 - they demand that everything be free including all hardware and all hardware running on it. But that means the purists have to stop using all the closed hardware they enjoy today.
2 - the FSF continues with the position that they are ok with closed hardware and defines “free software” to exclude firmware.
There are three words for a a reason, they are three different things: hardware, firmware, and software.
Defining firmware as software makes no more sense than defining it as hardware. In fact, the latter makes more sense to me and would fix the FSF silliness. But what makes the most sense is to acknowledge that they are all different.
Now that I type this, we need a Free Software Foundation, a Free Hardware Foundation, and Free Firmware Foundation.
The FSF mission makes sense if you exclude firmware. The FFF could preach that free firmware is superior to closed firmware. No argument there. The FHF can push for free hardware. That would be great and we could all push for it. But the FHF could also acknowledge that programmable hardware is superior to non-programmable hardware even when only closed firmware exists. The hardware itself is more open and more free. Basically both the FSF and the FHF could be more relaxed about the other. The FHF could be ok with closed software on open hardware just like the FSF is ok with running free software on closed hardware (their stance today).
Honestly, the above is maybe the only sane solution.
That would allow all of us to:
- choose programmable hardware over non-programmable hardware (FHF)
- choose free firmware over non-free firmware when free firmware exists (FFF)
- choose free software to run on the above (FSF)
I bet every one of us would agree to the above. Or at least we could choose which of the three missions to endorse. At least they would all be sane and consistent.
Instead, we get the FSF telling us to ignore the closed hardware behind the curtain while choosing hardware that is more restrictive and less free in the name of avoiding binary blobs. We are being forced to fight a religious war and nobody ever wins those.
Yeah, that would be a much more consistent setup and I agree with everything you said here. I just don’t understand how being less programmable is good, it isn’t, I don’t see any world in which it is unless there is truly NO firmware involved and it’s pure HW.
The line is basically programmability. If a device runs “firmware” that can’t be changed, that’s really just a part of the design of the hardware you bought, so the fact that you can’t see or modify the source code is irrelevant- even if you could, it wouldn’t give you any more control over the hardware. If it runs firmware that can be changed, it’s a programmable computer, and by running proprietary firmware, you’re giving up control you would otherwise have over your computer.
Exactly. It is about programmability. And that is dumb.
Imagine you have a piece of hardware that is not programmable. The FSF says that hardware is fine. Buy the shit out it and “be free” apparently.
Version 2 of that hardware is released with the new feature that the firmware is upgradable. Of course, only closed firmware updates are available initially. According to the FSF, this programmable hardware must now be avoided. Keep buying the original “more free” version that cannot be programmed.
And if you do have hardware version 2, the FSF says you should at least never update your firmware. Nevermind new features. Security fixes are to be avoided. Because the baked in firmware is more free than the firmware update. It is not that you are not using closed firmware. Of course you are. But you did not change it. So that is better?
It is total nonsense.
If there was a Free Hardware Foundation, a device whose hardware was programmable and whose firmware could be upgraded would clearly be seen as superior to one that was completely closed. It is definitely more open, “more free” hardware even if only closed firmware is available. The hardware is obviously more free. Self-evidently.
But the FSF position is that this “more free” hardware is less free than fully closed options when only closed firmware exists. There is no way for that to make sense unless you move “firmware” into the software bucket and completely ignore the concept of hardware all together. Sorry, but that is dumb.
It is also a good way to roadblock progress towards open hardware. Please stop.
An organization which exists exclusively to advocate for a type of program caring about programmability is not dumb. That seems… kinda obvious? They don’t exist to rate the technical superiority or inferiority of hardware devices, they exist to advocate for the simple position that: if a device can be programmed, the user of that device ought to control the program on the device, not some company which happens to hold the copyright over the on-device program.
And if you do have hardware version 2, the FSF says you should at least never update your firmware.
Um… absolutely not? They say that running proprietary firmware represents an injustice (perpetrated by the copyright holders of the firmware, btw, not the user). Updating the firmware to free software would obviously be great in the eyes of the FSF; upgrading to proprietary firmware would be simply continuing the existing, unjust status quo. You appear to have completely made up this particular position.
I think you missed the point. Imagine 2 devices, device A has a chip with flash memory that contains a binary blob with firmware. Device B doesn’t have built-in flash storage so it requires the driver to load the same binary blob during boot. Both devices are reprogrammable and both contain the same closed source firmware. However device A would be allowed but device B would not. From my point of view they are the same device. The fact that you don’t know how to reprogram device A doesn’t make it more or less proprietary.
The very silly argument the FSF is trying to make is that device A is not programmable because the firmware is baked into the HW effectively making it part of the HW rather than a separate entity. Therefore it’s a HW limitation and not proprietary software. Device B on the other hand has proprietary software uploaded to it which is not to be allowed under any circumstances and therefore must be neutered. I call it silly because as you so rightfully point out, the firmware blob could be literally the same exact blob, just stored differently
