Untitled Linux Show 275 Transcript

Please be advised that this transcript is AI-generated and may not be word-for-word. Time codes refer to the approximate times in the ad-free version of the show.

Jonathan Bennett [00:00:00]:
This week was a big week for Linux news. First off, well, Microsoft Defender is coming to Linux. Valve's Steam client is going 64-bit, sort of. Fortnite is coming to Linux as Epic is doing its anti-cheat on Linux without a kernel module, mind you. KDE turns 30 and a whole lot more. You don't want to miss it. So stay tuned.

Rob Campbell [00:00:26]:
Podcasts you love.

TWiT.tv [00:00:27]:
From people you trust. This is TWIL.

Jonathan Bennett [00:00:33]:
This is the Untitled Linux Show, episode 275, recorded Saturday, October the 17th. A right makes two wrongs. Hey folks, it is Saturday and you know what that means. It's time for the Untitled Linux Show. I'm your host, Jonathan Bennett, and we're going to talk about hardware, software, Linux on the desktop, probably some Linux on the server and everywhere else, maybe even on your toaster. Is that still a thing? I don't know. We're going to find out. Anyway, it's going to be a fun show today.

Jonathan Bennett [00:01:02]:
It's not just me. I got Rob. I got Jeff. That other guy is off playing hooky, busy with some business thing going on. I don't know. They sold a bunch of stuff and he's got to put it in boxes. Anyway, we're going to have fun. We're going to have a good time.

Rob Campbell [00:01:16]:
It's like a toaster. And I thought of the Amiga, the 4000

Jeff Massie [00:01:22]:
video toaster.

Jonathan Bennett [00:01:23]:
The video toaster. Different kind of toaster.

Jeff Massie [00:01:25]:
Different kind of toaster.

Jonathan Bennett [00:01:26]:
Yeah. All right. Well, Rob, Rob has a story not about Linux everywhere, but about AI office suites everywhere. Yes. What's going on? What's the new meta in office suites, I guess?

Rob Campbell [00:01:42]:
So it feels like every time I open up a Linux news story lately, somebody has built another office suite. So we've had open source office software for decades. Decades. OpenOffice, which pretty much got replaced by LibreOffice, and all those others have given us powerful alternatives to Microsoft Office. But for many people coming from Microsoft Word, Excel, PowerPoint, there's always been an adjustment. You know, it has features, but just doesn't quite feel the same. You know, it looks different. I don't like how it looks.

Rob Campbell [00:02:19]:
I just want it to look more like what I'm used to. So, you know, having the features familiar— familiarity are 2 different things. And when you spend your workday in the office, the familiarity matters. Now, we have several projects approaching that problem at once with AI playing different roles. So I recently did a show tip about the Starling desktop. The Linux desktop environment developed largely using Claude code. Well, apparently they're building a desktop wasn't enough. Now there's Starling Office.

Rob Campbell [00:03:02]:
The name sounds very similar to the old StarOffice, but no relation, completely separate. It also includes a word processor— not also, but it includes a word processor, spreadsheet application, and presentation editor with a Microsoft, or support for Microsoft's DOCX, XLSX, and PPTX formats. And you don't have to switch to the Starling desktop to use it. There are builds for Linux, Windows, and macOS, but you should switch to Linux desktop at least. Don't worry about those other 2. The initial release is version 0.1. So this is still very early software. And then there's the ArtCraft team, which we talked about, I believe, just last week for its alternatives to Adobe applications.

Rob Campbell [00:03:51]:
And then like right after the show, I noticed that they've expanded into office software with WordCraft, which for those watching, that's what's right behind me here. WordCraft, GridCraft, DeckCraft, their takes on Word, Excel, and PowerPoint, obviously. These are open-source applications written in Rust, and the familiar interface is part of the pitch. WordCraft specifically promotes its ribbon-style gallery, keyboard behavior, and ability to read/write Word documents. The Office applications are still listed as development, but installers are available. And that familiarity could be a big deal. Someone looking to leave Microsoft Office may want to keep the workflow they already know. And, and, and then now, now then we have OnlyOffice, which to me was all— has already been one of the closest alternatives to the Microsoft Office experience.

Rob Campbell [00:04:57]:
Well, with version 10 out now, it's taking another approach. OnlyOffice is bringing AI into its existing editors and combining its previous AI tools into a new module. You can ask it to summarize documents, clean spreadsheet data, identify formula errors, generate slides, or prepare presentation notes. It supports cloud AI providers as well as local models through tools like Ollama. And the desktop AI module is optional. You install it separately and it's currently in beta. You know, think of this similar to how Copilot is for Microsoft Office suite, but with more options. You can use local, you can use cloud of your choice, you know, whatever.

Rob Campbell [00:05:45]:
So there are really 2 developments happening together. AI is helping developers build new Office applications and established Office applications are adding AI to help users to do their work. So of course, a familiar ribbon doesn't guarantee that everything's going to function and format correctly right out of the gate. Those are things these projects are still going to have to improve. But suddenly we have more teams taking a run at the problem. For Linux users, that can mean more choice that fits the way people already work and a much easier transition from Windows to Linux. But that isn't the only news we have on the topic of making it easier to transition to Linux this week. All the walls are tumbling down.

Jonathan Bennett [00:06:42]:
Is that a segue to my story? Since Ken is not here, do you feel the need to segue?

Rob Campbell [00:06:46]:
Well, it's gonna be, and I'm gonna talk, I think I'm gonna talk more. Am I gonna talk more? I don't remember. Oh yeah, I'm gonna talk.

Jonathan Bennett [00:06:52]:
It's up to you. You can talk more if you want to.

Rob Campbell [00:06:54]:
No, no, I'm gonna talk more later in the show about other things it easier to switch to Linux. And I know you have a story too, but we'll respond to this one first.

Jonathan Bennett [00:07:03]:
Yeah, yeah, yeah. No, so the Starling desktop and the rest of these, I mean, they're interesting. And it's, don't get me wrong, it's cool that the technology has come to the point to where we can tell, you know, our favorite LLM to build the thing and it builds something that works. But like for practical use, It's kind of nice to have more than one person behind one of these. And, you know, if you're a business and you want to use it, maybe a place where you can get some support. And that's part of the conversation that I think people sort of forget about.

Rob Campbell [00:07:36]:
I'll tell you what, being in the business enterprise world myself, you don't get support from Microsoft either. And when you do get a little bit, it's not good.

Jonathan Bennett [00:07:47]:
That's true. That's true.

Jeff Massie [00:07:50]:
It depends on your, uh, agreement.

Jonathan Bennett [00:07:55]:
It depends on how big you are and what your support contract looks like.

Rob Campbell [00:07:58]:
Yeah. I mean, when you're, you know, in the billions of dollars and, you know, like these guys.

Jonathan Bennett [00:08:04]:
Rob and I come at this from the very small business side of the market. Jeff does not. Jeff does not work at a small business.

Rob Campbell [00:08:11]:
Yeah. You know, there's a good dozen companies who probably get some good support out there.

Jonathan Bennett [00:08:16]:
There's literal dozens of them.

Jeff Massie [00:08:18]:
Well,

Jonathan Bennett [00:08:20]:
now

Jeff Massie [00:08:20]:
aren't these, from what I've heard, a lot of these are still in kind of the alpha stage? I mean, they don't fully, not, you know, there be dragons, you know?

Jonathan Bennett [00:08:32]:
No, sure.

Rob Campbell [00:08:34]:
I mean, they're only like a week or two old. What do you expect? Come on.

Jeff Massie [00:08:37]:
Yeah. But, well, but I mean, that's why I'm like, uh, you know, we'll, we'll see if they stick with it and really it goes anywhere. But the thing I thought was interesting, there was a story and I didn't think there was enough to really do on it, but it talked about AI writing drivers for hardware that has been abandoned. And so instead of coming from the software side, it was coming from the hardware side. And, you know, that old widget you have, you can, oh, let's make a driver for it and plug it in and make it useful again.

Rob Campbell [00:09:05]:
For sure. I saw that story too. And it's not even, old stuff that could be beneficial. It's, it's even probably new stuff that can help reverse engineer. Well, like, like the, uh, I already forgot who's, uh, the other ones doing, uh, uh, the Apple Silicon besides Asahi. There's another one that just recently— but I mean, I think they're pretty much doing that probably using—

Jonathan Bennett [00:09:29]:
Yeah, they're using a lot of AI for it. Yeah, I've, I've, uh, in fact, some of the guys that I work with, we, we do this a lot for various widgets. We get like a A label printer. Now there's a Windows driver for it. Throw the driver at Claude, let's see what it can figure out. You know, an hour later, hey, I wrote this in Python. And then a couple hours later, I rewrote it in WebSerial. We can print from our, you know, our CRM now.

Jonathan Bennett [00:09:51]:
We live in magical times.

Rob Campbell [00:09:52]:
Right. I mean, this day and age, even Linus Torvalds is all in. We'll talk about that later.

Jonathan Bennett [00:10:00]:
Yeah. Well, there's another real magical thing that has happened. This week, and that is Microsoft has come out with an announcement and they are really living up to their we love Linux ethos. And their announcement is Windows Defender is now going to be available on the Linux desktop. And this was only one of the groundbreaking bits of news this week. There were several of these. And in fact, we had a conversation. I had a conversation with the guys.

Jonathan Bennett [00:10:33]:
during the week. And I think about 3 different times we said, oh, I know what the headline is going to be. And it kept changing. Well, this was one of those things that was going to be the headline. Now, it's not quite as straightforward as it seems because this is not just your regular run-of-the-mill Windows Defender that now is running on Linux. No, this is Microsoft Defender for Endpoint. And so it's kind of like they're one of their tiers up and you've got to have, you know, you've got to actually have a license agreement with them where you're paying some money for Defender to be able to run it on Linux. But they do indeed, they have their endpoint detection response, their EDR solution will run there.

Jonathan Bennett [00:11:18]:
I believe it, if I remember correctly, it installs an eBPF module. Yes, yes, it is. They describe it as a lightweight eBPF-based sensor architecture without kernel modules. So the Extended Berkeley Packet Filter is sort of like a user space kernel module, but they're making the distinction here. It's not an actual kernel module. And it provides protection with minimal overhead and zero workload disruption on resource-constrained systems, which is interesting. That is the direction that they're sort of pushing this. But I mean, it makes sense.

Jonathan Bennett [00:11:57]:
And in fact, so one of the things that we've had to do on Linux servers for a long time is check for Windows malware because it's not the Linux machine that's getting pwned, but you could certainly serve malware to Windows machines if somebody puts the wrong thing on the file server. And of course, Linux machines do get popped from time to time. And so they've got some interesting things here. One of the other ones that they have apparently built into it is vulnerability management. And that sounds to me like they're going out and doing checks for like, this is the version of software you have installed, sort of building a software bill of materials on the fly and then checking that against known vulnerabilities, which is great. It's a really good approach. And then of course, they've got some management stuff built into it. But I mean, it's just the big headline, Windows Defender on Linux.

Jonathan Bennett [00:12:45]:
It really sort of made my day when I heard that. I thought it was really cool.

Rob Campbell [00:12:48]:
Well, and like I said, this helps People move to Linux kits. It's not your regular home users gonna be like, oh yes, now I can move to Linux. It's going to be the businesses and the enterprises, you know, the ones that's like, hey, can I, you know, when you have an end user comes up, joins a company, hey, I really love Linux. Can I use Linux as my desktop? Like, no, you can only have Windows or macOS. Like, but why? It's so secure. Because of compliance. And what our management and software supports. And

Jonathan Bennett [00:13:24]:
your security compliance officer has to have a bit of flexibility and a bit of creativity to be able to sign off on that.

Rob Campbell [00:13:31]:
Yeah. And this makes it one step easier. It's like, yep, we support that too.

Jonathan Bennett [00:13:36]:
Go on in. I'm sure. Yeah. If you're doing like a cybersecurity, oh, what's the take, the, acronym, uh, CMMC-A, Cybersecurity Maturity Module or Maturity Level. I forget what that stands for. Um, but anyway, yeah, it's a good— it's the government. It's one of the government things, but it's like, you know, make sure your cybersecurity is mature. Cybersecurity Maturity Model Certification.

Rob Campbell [00:14:02]:
Yeah.

Jonathan Bennett [00:14:03]:
I think that's it. Uh, and, but the really great thing about that is like, if you have some of these different programs that you pay for, they will just have a guide of If you have this installed in the recommended way, here are all the checkboxes that you can just automatically check because we cover that for you. And I'm sure that this does exactly the same thing for both that cybersecurity checklist and some others.

Rob Campbell [00:14:24]:
Yeah. And that goes for cybersecurity insurance checklists and

Jonathan Bennett [00:14:29]:
all of that ugly, boring stuff that we sometimes have to deal

Rob Campbell [00:14:32]:
with in our day jobs. Regulated companies and...

Jeff Massie [00:14:37]:
See, one step closer to get the Linux kernel into Windows.

Rob Campbell [00:14:42]:
Yeah. You know, I saw a post this week, someone saying that, uh, what was it? They're asking, I don't know if they're asking or saying. I mean, okay, it's been said many times, but the question was like, do you think Windows is going to move to Linux within the next 15 years?

Jonathan Bennett [00:14:59]:
Yes. 15 years is a long time in technology years. It's possible. I could— I, I'm a little skeptical generally about the, ah, it's coming, but 15 years is a long time. I could— I would not be surprised to see it happen in 15 years.

Rob Campbell [00:15:14]:
I mean, Mac years ago went to a Unix backend. I think Windows should follow.

Jeff Massie [00:15:22]:
Yeah, they got NeXT, I believe, is what they purchased.

Jonathan Bennett [00:15:26]:
I mean, the sort of surprising thing is If I remember correctly, for everything except forking, Windows is POSIX compliant.

Jeff Massie [00:15:39]:
Yeah.

Jonathan Bennett [00:15:39]:
Everything but the actual fork call is POSIX compliant, which is why you can use something like mingw or MSYS2 and compile all of our Linux tools on Windows because, I mean, it is literally at this point another POSIX.

Jeff Massie [00:15:54]:
And now that it's not a big revenue stream for them versus the other stuff, hey, why don't we just jump on the open source and let that community take care of the updates and we can take those developers and move them to cloud and other stuff?

Jonathan Bennett [00:16:09]:
That is the most interesting argument for them doing that.

Jeff Massie [00:16:14]:
I did think your slip-up was good though too when you were saying run-of-the-mill and at first you said run-of-the-will and I thought of,

Rob Campbell [00:16:20]:
oh.

Jeff Massie [00:16:21]:
The Microsoft 3 E's, embrace, extend, extinguish.

Jonathan Bennett [00:16:27]:
Yeah, I do. The one thing that makes me think that Microsoft would not be interested in actually moving to like Linux as their backend is having all of the businesses kind of locked into Windows has been, doesn't make a whole lot of money on its own, but it funnels all those businesses into using other Microsoft projects. And that's probably the use case that really keeps them making the Windows OS. Because like you said, they don't make a whole lot of money on it otherwise.

Rob Campbell [00:16:59]:
So many of those other projects are already available on Linux. Sure,

Jonathan Bennett [00:17:04]:
it's getting to be there. But I mean, how many businesses actually use those? Businesses are still Windows domains, Windows servers, Windows desktops.

Jeff Massie [00:17:15]:
Well, but the thing is, if you think about it and they say, okay, you know what, we're going to just put a shiny wrapper on top of Linux, but they still have the whole OneDrive and the Azure and all that other stuff. They still tie into the network. So kind of like Apple, right? Mm-hmm. I mean, they just put a shiny wrapper over Unix, but they have the rest of the system that isn't open source or isn't, you know, and it's still proprietary and you have the locked in. You already have the contracts. You already have all the support levels. So it's kind of like Red Hat Enterprise where you're just like, oh, we're going to take care of you.

Rob Campbell [00:17:56]:
And you can put Linux on a domain.

Jonathan Bennett [00:17:59]:
That's true.

Rob Campbell [00:18:00]:
Ubuntu has it built right into the installer.

Jonathan Bennett [00:18:02]:
Yeah. That used to be a real challenge. I've done it a time or two. It used to be a real challenge to make that work. From what I understand, it's a lot easier now. I've not gone through that process. I have more self-respect for myself than to spend too much time on that again. But

Rob Campbell [00:18:16]:
I feel like one way or another, you know, with businesses caving or just, you know, putting their stuff on Linux like this, or with other third parties saying, okay, well, if you're not going to put your stuff on Linux, we're going to use AI and do it. And somehow the walls are going to come tumbling down and

Jonathan Bennett [00:18:40]:
Yeah, here's another potential driver to think about as the various European governments are pushing people away from being locked into Microsoft projects and products. Might it eventually become a business case for Microsoft to support with their cloud products all of these Linux desktops that are suddenly getting installed by customers in Europe?

Rob Campbell [00:19:02]:
Huh. You know, that could be one reason why they did this right here.

Jonathan Bennett [00:19:06]:
That's an interesting thought, now, isn't it? All right. Let's actually take a real quick break and then we're going to come back and get away from the enterprise side of the house and have some more fun. Don't go anywhere. We'll be right back. All right, Jeff, you're going to lead us off and we're going to talk about some gaming stuff. We got a few gaming stories here. What's the first one? Where are we going first?

Jeff Massie [00:19:31]:
Well, you know me, I love to game on Linux and love to have fun. And realistically, for as long as most of us have been gaming on Linux, the Steam client itself has been a 32-bit program. And you probably got a lot of your first exposure to gaming on Linux through Steam, unless you were running TuxKart or a few things like that. But Steam was the first one that was— Or one of the major ones anyway, that was kind of available across a whole bunch of platforms without any special finagling to get things to run. Now, I say it's 32-bit program, but your games might be 64-bit. You know, most likely your distribution you're on is probably 64-bit. I mean, barring somebody running something Very fringe or very, very old. And but the storefront, you know, the library you see when you're picking your games you want to play, your friends list, you know, the actual window you click on has been running in 32-bit mode, you know, just the same as it's been since 2013.

Jeff Massie [00:20:44]:
Well, as of this week's Steam beta, that's changing. On October 15th, Valve pushed a Steam client beta with 2 big changes for Linux. The first, the client is now built as a 64-bit application. Second, and this is the bigger deal, the client now runs inside a Steam runtime container. Now, Valve's release notes, and they say that this will help the Steam client provide a more consistent experience across multiple distributions. Well, Okay, how does that— what does that actually come down to? What does that actually mean? Your games already run in containers. You know, Valve's tool for this is called Pressure Vessel, and every game goes— or game gets launched into a known fixed set of libraries called the Steam Runtime. So a game built years ago doesn't break just because your distribution updated something underneath it.

Jeff Massie [00:21:37]:
The one thing Pressure Vessel deliberately borrows from Your real system is the graphics driver since, well, that has to match your actual hardware and the kernel. You know, you, you can't, uh, make a bunch of assumptions of what driver you could use if it doesn't support your actual hardware. So, you know, that makes sense, but everything else is in the container. The Steam client never got that treatment. It never— it was always running native. Well, and It used an older trick where the Steam runtime libraries were layered on top of whatever your distribution had installed. And that worked reliably well when your system was newer than the, you know, the system items, libraries and whatnot were newer than the runtime. Now, if you've ever had Steam refuse to open after a distribution upgrade or ended up hunting for some missing library on a less common distro, this is the kind of mess that the container is meant to clean up.

Jeff Massie [00:22:36]:
Now, the new container is called SteamRT3C. It's a variant of the Steam Runtime 3, codenamed Sniper, built specifically to run the Steam client. Sniper is the same family of runtimes that, you know, a lot of native Linux games and Proton already run inside of. So Steam is now living in the same kind of container it's been building for its containers for years. So this isn't like a huge departure from what it's been doing. They just kind of put the initial interface into the same containers as the games. Now, this didn't come from nowhere, but it's been a little quieter. So back in March, actually, Valve put out an early version of the containerized 64-bit client as a separate Steam RT3 beta.

Jeff Massie [00:23:24]:
Now, this is in the regular Steam beta, which means a lot more people are about to are about to test it. So when you're there in Steam, there's command line or options in there that you can set whether you want to be on the beta or not. Before, it was separate. You had to actively seek the beta. So that's where the difference comes from. And that's why there's going to be more people that will be actually using it. Now, if you think, oh, I'm going to be in the beta, I'm going to just trash those 32-bit libraries. Don't do that.

Jeff Massie [00:23:57]:
You still need them. Now, Valve says about its beta requirements, and I'm quoting, 64-bit only, x86-64 systems are not supported. You still need multilib with both 32-bit and 64-bit versions of the required libraries and your graphics drivers. Now, you might be thinking, well, wait a minute, you just said they're converting to 64-bit. The reason is the games. A large number of the Steam catalog is still 32-bit games, and there's plenty of games running through Proton that need 32-bit pieces as well. So the container even ships with 32-bit libraries for compatibility with older software. So while the client went 64-bit, your game library did not.

Jeff Massie [00:24:51]:
Basically, and again, kind of an example of this is like back in 2019, and some of you might remember this, Canonical announced that Ubuntu would stop shipping 32-bit packages. Valve responded that it would drop official support for Ubuntu. And within a week, Canonical backed down. I mean, if you don't have Steam support, you're taking a big hit for your general audience and you're kind of just relegating yourself to servers. On the Linux desktop, 32-bit compatibility is needed, was needed for Steam. And, you know, this, this beta doesn't change that, even though the, the initial interface is 64-bit. So I hope that's really clear. Uh, the rest of the requirements for this beta are glibc 2.31 or newer and Linux kernel 5.6 or newer and X11 server Or XWayland.

Jeff Massie [00:25:46]:
So either one of those will work. So if you're just on KDE 6.8 and you're thinking, I don't have X11, XWayland will keep you, keep you just fine. Uh, you need PipeWire with its PulseAudio layer or PulseAudio itself and a Vulkan-capable GPU. Now, Valve said it's designed mainly for the Arch Debian, and Fedora families on KDE Plasma and GNOME. So if you're running a distribution that has Jack and ALSA demix only, you're going to be unsupported. There's a lot of changes in this beta release besides what we just talked about. Take a look at the links in the show notes for more details and more links to follow in those articles. Happy gaming.

Jonathan Bennett [00:26:35]:
Yeah, it's, uh, It's cool to see this move in this direction. I am humored though that they're like, it's 64-bit. You still need the 32-bit libraries. I bet some of those, because like you can run Proton inside of Sniper or Soldier or whichever runtime that you're using, you can set Proton up that way. So you could probably get away with very few 32-bit libraries.

Jeff Massie [00:27:01]:
Yeah, like Multilib and... A few like that are still required. So it's a subset of a full complement of 32-bit libraries. Just a few critical are needed.

Rob Campbell [00:27:14]:
So then, I mean, I have some ideas, but why? 32-bit's been working just fine for all these years. Why now?

Jonathan Bennett [00:27:23]:
I mean, the kernel is trying to drop 32-bit. Different distros are trying to drop 32-bit packaging. And I mean, you've even got like Intel and AMD talking about going to 64-bit. bit only chips.

Rob Campbell [00:27:33]:
Yeah, but you still have all those games that are reliant on it anyway. So on bits of it.

Jonathan Bennett [00:27:40]:
I mean, it's not, it's not that hard to imagine a future where you've got something like FEX that lets you run 32-bit games on a 64-bit system.

Rob Campbell [00:27:49]:
So you're saying it's to prepare for the future?

Jeff Massie [00:27:52]:
Yeah,

Jonathan Bennett [00:27:53]:
I think so.

Jeff Massie [00:27:55]:
And the library compatibility that I mentioned in the article where So sometimes you get a little mismatch, you get a hiccup because the proper library isn't there. So they just, all right, let's containerize it. And then we don't have so much to worry about because realistically, I think one of the greatest gaming benefits to Linux is DirectX because the kernel, Linus Torvalds says, do not break userland. Userland. But A lot of other libraries do. And that's why it's always, every time you hear about people having to package for various distributions, it can be a nightmare. But with DirectX, you have a set standard that you know is very solid that you can work against. And I think that's why I think a lot of games now, they just go ahead and don't make them native.

Jeff Massie [00:28:49]:
One, because there's not a lot of benefit to make them native because Proton's become so good. Yeah. And the second is you don't have to worry about all the overhead of like, oh, this works on Ubuntu, but not on Fedora. Oh wait, what about Arch?

Jonathan Bennett [00:29:02]:
Oh, I've still gotten used to this. It works on Linux. Yes, here's the binary. Oh, that's not going to work.

Rob Campbell [00:29:07]:
Can you imagine now when Windows goes all in on Linux and they're running on Linux and eventually the only thing you're going to need Proton for is legacy games? Because they might as well, I mean, if you don't have Windows anymore, you might as well make it native for Linux.

Jeff Massie [00:29:29]:
If, you know, if Microsoft, say, went all Linux, one of the greatest things they could probably do is just say, here's the standard we're going to put forth for ourselves, and then have other distributions aligned to it. So there's not quite the packaging nightmares, the, You know, and there's been—

Jonathan Bennett [00:29:48]:
That seems to be right at the tail end of that extend section of the 3 E's.

Jeff Massie [00:29:55]:
There is. And this is something that's been going on for a while because we've talked every once in a while about distributions going, okay, they're making this change where they move their directory structure to better align. And, you know, the Debian and Red Hat camps and even Arch somewhat are trying to kind of standardize the directory hierarchy and Things like that to just take the pain out of packaging.

Jonathan Bennett [00:30:20]:
Yeah. Yeah, there's been, there's a pretty official, I forget the name of it, but there's an official standard that talks about where everything's supposed to go as far as the file directories. And it still doesn't match up perfectly between the different distros, but in theory it does.

Jeff Massie [00:30:37]:
Well, and I think we covered a couple months ago, and I don't remember if it was Debian or Red Hat, somebody was shifting what they were doing and saying, okay, we're moving this stuff out of directory A and putting it in directory B just to align and try to merge into a more standardized interface.

Jonathan Bennett [00:30:59]:
Yeah, it was like moving stuff out of /usr/lib into /lib64 or something like that.

Jeff Massie [00:31:02]:
Yeah.

Jonathan Bennett [00:31:03]:
All right.

Rob Campbell [00:31:05]:
Now, Windows version of Linux is going to have Program Files and Program 32.

Jonathan Bennett [00:31:13]:
I mean, it would have to, right? Like, that's Microsoft's big thing is you can run, you can just about run software. You can legitimately run like Windows 95 and Windows 98 software on modern Windows still. You can't go, you can't jump 2 versions as far as the bit width. So like you can't run 16-bit software on 64-bit Windows, which that was actually one of the things that was keeping people on 32-bit Windows for the longest time.

Rob Campbell [00:31:39]:
Well, everything in /lib is going to go into /windows/system64 because it's going to be 64-bit.

Jeff Massie [00:31:48]:
Well, and, you know, kind of a note too is that the talk of getting rid of 32-bit in the hardware for Intel and AMD, they've talked about they can get rid of a lot of old cruft and some workarounds and things like that if they got rid of 32-bit. Just like when they got rid of 16-bit, it cleaned up a lot of stuff because things weren't as aligned back then as they are now. And 64-bit is a lot more aligned than the 32-bit.

Rob Campbell [00:32:18]:
It'll be a while, but the good thing is Steam is on its way to getting ready for 2050.

Jonathan Bennett [00:32:25]:
Yep. Now, what about getting ready for anti-cheat? Isn't that the other big problem in Linux gaming?

Rob Campbell [00:32:32]:
Yeah, that's one of the things holding back the last few games that don't work on Linux. So if you follow me on the socials, you may already have some of the details on this story, but we are at the point where Linux gaming has reached a point where the question often isn't, can Linux run my games? It's, can I run that one game keeping me on Windows? So compatibility has improved enormously through Wine and Proton. An analysis of ProtonDB reports last year put nearly 90% of all Windows games in its dataset somewhere in the playable category. Now, that doesn't mean every game works perfectly, but it shows how far we've come. Some of the most frustrating holdouts are the multiplayer games being blocked by anti-cheat. And one of those companies that have been the most frustrating to Linux gamers is Epic. Somehow they've, they've been a big holdout to reviews, but now Epic Games is taking a significant step towards changing that. Epic has announced EAC Linux v2, a rebuilt Linux implementation of the Easy Anti-Cheat.

Rob Campbell [00:33:59]:
The company plans to test it with Fortnite before expanding availability to other developers. Though ironically, we've actually been able to run, play Fortnite on Linux through Xbox cloud streaming for years. I even talked about it on a show years ago, I know. But cloud streaming does have its limitations. So anyway, existing EAC support for Linux and Proton. has been optional for developers, and Epic says its protection hasn't matched what it could provide on Windows. And DHH appears to deserve some credit for keeping this on Epic's radar. That said, David Heinemeier Hansson, the creator of Ruby on Rails and the person behind Umachi, has been pushing Tim Sweeney to bring Fortnite to Linux.

Rob Campbell [00:34:50]:
Following the announcement, he joked about what years of nagging could accomplish. He also said the Numachi team was already working with Epic to meet the security requirements for day-one support. Now, I'm not saying DHH single-handedly changed Epic's direction, but it does show persistent advocacy, uh, and that every little bit may help. So what does this require? Epic's current requirements include TPM 2.0 enabled in firmware, UEFI Secure Boot, measured boot, and a kernel module signed with recognized keys. It also calls for kernel lockdown integrity mode, disabled kexec, and an active BPF security module. On non-handheld systems, I/O MMU must be enabled with pass-through disabled. That may be a lot for some people, um, but for those who have said it can't be done, I always said it could be with the right restrictions in place. And yeah, I know it's a lot for some people.

Rob Campbell [00:36:07]:
I've had an argument with somebody online recently who was, uh, Rather paranoid about TPM 2 and Secure Boot and how it's spying on us or something. But anyway, the implementation is also worth understanding. Epic won't install a traditional anti-cheat kernel module. No kernel module like on Windows. Instead, it will use existing Linux security features, eBPF, PF programs and a systemd service. It starts with a protected game and stops when it exists. So I don't remember if I mentioned it, but it also requires systemd. So for those of you who were thinking of moving away from systemd because of age verification or something else, well, here's one reason, another reason to stay.

Rob Campbell [00:36:56]:
Anyway, there's one significant disappointment. Steam Deck doesn't currently meet the requirements. Epic says it is— talking with Valve about future support. So I'm sure it'll be coming as well. Meanwhile, Epic's new launcher is already available in preview for Linux. Fortnite itself is still coming with its release dependent on getting the anti-cheat work ready across enough distributions. This won't automatically unlock every multiplayer game. Developers still have to support it, which may be another big blocker, but hopefully those walls will tumble down too.

Rob Campbell [00:37:31]:
And other anti-cheat systems remain separate challenges. We just need to keep being persistent. This could give more of those remaining holdouts a path onto Linux. And for someone whose entire gaming group plays one unsupported title, bringing that single game over couldn't matter more than adding another 1,000 games that they don't play. So it feels like a lot of the remaining barriers to leaving Windows are going away.

Jonathan Bennett [00:38:06]:
Yeah, this was the other big story that we saw this week. Fortnite's coming to Linux.

Rob Campbell [00:38:12]:
I mean, and it's not so much that any of us care at all about Fortnite, but it's what it means, the EHC behind it.

Jonathan Bennett [00:38:18]:
No, I've never been terribly impressed with Fortnite. PUBG looks like a lot of fun. And then of course, it's got the same problems. It's anti-cheat doesn't run on Linux at all. So it's like, yeah, just go play other games.

Rob Campbell [00:38:29]:
Years ago though, I, I played Fortnite a few times on, on Xbox. The second time I played it, I won the battle royale.

Jonathan Bennett [00:38:37]:
Winner, winner, chicken dinner.

Rob Campbell [00:38:38]:
And you wanna know how? I just stayed and hid on the side of the map the whole time. And at the very end, it's me and 2 other people. Those 2 people were fighting it out and they killed each other and I won. I never killed anybody.

Jonathan Bennett [00:38:51]:
The pacifist win.

Rob Campbell [00:38:53]:
Yep.

Jeff Massie [00:38:53]:
A win by default is still a win.

Jonathan Bennett [00:38:57]:
Yep.

Rob Campbell [00:38:58]:
I took a picture of that. I have it somewhere.

Jonathan Bennett [00:39:01]:
There's a few interesting things here. So like you gotta have TPM 2. That's, yeah, that's not terribly unexpected. You gotta have secure boot. Measured boot is interesting, but the kernel lockdown mode, that's something I don't think a lot of people run. It'll be interesting to see like that support get suddenly more interesting for people and more people will go try and test it out, right? Because that's a— that's— you generally think of that as being like an enterprise feature where you need— well, I mean, like we talked about earlier, you got to meet some weird CMMC certification. And so you got to turn on kernel lockdown mode to hit it or whatever. And then the other thing that I don't fully understand is The IOMMU, like, that's just, I thought, built into hardware.

Jonathan Bennett [00:39:51]:
That was just part of your, like, Intel or AMD processor. And I thought that Linux doesn't work on devices that don't have IOMMUs. So I'm not sure exactly what that is about either. But apparently it's something. There's something to that.

Rob Campbell [00:40:11]:
And that purpose is to prevent devices from accessing memory they shouldn't. Mm-hmm. Yeah, I don't

Jonathan Bennett [00:40:21]:
know. Yeah, I've seen it. Go ahead, Jeff.

Jeff Massie [00:40:25]:
Well, I was gonna say, isn't that something that you have to toggle to get virtual machines to work in your BIOS? If you don't turn it on, you can run a little bit faster, but then it breaks a lot of virtual machine stuff. Or am I confusing that with something else?

Jonathan Bennett [00:40:44]:
It does. Look what Google does suggest.

Rob Campbell [00:40:46]:
It's particularly important for PCI pass-through using technologies such as KVM. So I think it's, I think the virtual machine tie-in is for PCI pass-through.

Jonathan Bennett [00:41:01]:
Yeah, I don't, I don't remember seeing this in BIOS. I'm not gone and messed around in my BIOSes for a while. Yeah, but yeah, this is just not, was not on my radar. I'll have to do some more reading about what exactly this thing does and how it's different than your normal memory management unit that every computer has and doesn't boot without. Oh,

Rob Campbell [00:41:22]:
but yeah, Intel's version of it is called the VT-D virtualization technology for direct.

Jeff Massie [00:41:29]:
Okay, yeah. That's one of those you have to turn on to get virtual machines to work.

Rob Campbell [00:41:33]:
Yeah,

Jonathan Bennett [00:41:34]:
that makes sense.

Jeff Massie [00:41:36]:
I think it comes on default now. It used to, it used to be that it didn't. And, you know, it was what it used— I don't know if it makes a difference now, but it used to be you could, you could turn it on and, you know, you got another frame per second in your game or whatever.

Rob Campbell [00:41:49]:
Yeah, and they just say it has to be on for handheld, so that shouldn't be a problem probably for most, most cases, I guess.

Jeff Massie [00:41:58]:
I go in and just turn mine on or make sure it's turned on. when I build a new machine. In my last one, it was on. I mean, that was a few years ago, but still it was already enabled. Okay, I'm good.

Jonathan Bennett [00:42:16]:
Yeah. So apparently you've got traditional MMU, which is what I was thinking of. Then IOMMU lets you do things like direct memory access. from external devices. And it handles the mapping of memory to make all of that work, which one of those potential external, quote unquote, external devices is a virtual machine. So that does make sense.

Rob Campbell [00:42:42]:
Or it could be some kind of software used for cheating.

Jonathan Bennett [00:42:46]:
Apparently.

Rob Campbell [00:42:47]:
Which makes sense.

Jonathan Bennett [00:42:48]:
Apparently.

Jeff Massie [00:42:49]:
Keep that device protected.

Jonathan Bennett [00:42:51]:
Yeah. All right. Well, we've got quite the milestone actually this week. to move out of the gaming realm but stay in desktops. 2 things in the KDE world. And the first is that KDE 6.8 is out. But with that, we are celebrating 30 years of KDE. This is the 30th anniversary edition, Plasma 6.8.

Jonathan Bennett [00:43:17]:
And yeah, it's out. It's ready to go. It looks pretty cool so far. Nothing is broken too terribly. And there is that with all of its changes that it brought. We've been talking about those for weeks now between the better window management and the better graphics, the getting rid of the paper cuts, all kinds of stuff that is there. And then, of course, there's always the weekly look towards the future. They're already working on Plasma 6.9.

Jonathan Bennett [00:43:51]:
And one of the real fun things that sticks out there so far is the new weather widget, which actually looks pretty cool, especially for those of us that care and have to care about the weather. And some other stuff like the on-screen keyboard nightlight feature is getting some upgrades. You can make your system icon really, really small in 6.9 down in the tray, all kinds of fun stuff like that. But yeah, just happy 30th. KDE has been around for 30 years, been part of our desktop experiences for that long. And it's kind of sobering, makes me feel really old because I remember some early KDE versions.

Jeff Massie [00:44:32]:
I remember, I think it was running Caldera Linux on KDE 1.4 or 1.2 and then compiling 2.0. And doing the conversion.

Jonathan Bennett [00:44:45]:
Yep. Yep. I remember the 3 to 4 conversion pretty vividly.

Jeff Massie [00:44:51]:
Oh, that was—

Rob Campbell [00:44:52]:
Yeah.

Jeff Massie [00:44:53]:
Well, that was an advertising mistake. Yes. Because they had 4.0 and everybody goes, oh, I'm going to get on 4.0. And they should have said, no, no, no, this is a beta.

Jonathan Bennett [00:45:03]:
Yeah. It

Jeff Massie [00:45:03]:
wasn't for people to jump over till about 4.4.

Jonathan Bennett [00:45:06]:
It was kind of a semantic versioning fail. That's what it was.

Rob Campbell [00:45:10]:
Back when I started, it was like 1.1, I think. 1999.

Jonathan Bennett [00:45:16]:
Yeah. Trying to remember.

Rob Campbell [00:45:19]:
I partied like it was 1999.

Jonathan Bennett [00:45:21]:
There you go. I'm trying to remember what version of, like, what year it was when I first started playing around with Linux. It was after '99. It would have been 2002? Probably somewhere, something like that.

Rob Campbell [00:45:37]:
Probably 2.0.

Jonathan Bennett [00:45:39]:
Yeah, probably.

Rob Campbell [00:45:40]:
2 point something.

Jonathan Bennett [00:45:41]:
Yeah.

Rob Campbell [00:45:42]:
Yeah, I didn't remember what version it was. I had to look it up what version it was in 1999, as I do every time I think about that. It's not the first time I've looked it up.

Jonathan Bennett [00:45:53]:
Yeah.

Jeff Massie [00:45:53]:
Now I'm going to have to look and see what years Caldera Linux was going because I was somewhere around in there. Because I started at my current job in '97. So it would have been '98, '99, 2000, somewhere in there when I played with Linux.

Rob Campbell [00:46:15]:
You've been there a long time. Time for another career.

Jeff Massie [00:46:20]:
Yeah, but I like what I'm doing.

Jonathan Bennett [00:46:23]:
He's about to get the watch. Don't they give you a watch next year?

Jeff Massie [00:46:30]:
They just give you cash so you can spend it on whatever you want.

Jonathan Bennett [00:46:33]:
Oh, okay.

Rob Campbell [00:46:34]:
You get early retirement for starting being there so long?

Jeff Massie [00:46:39]:
Only depending on how much stock you kept.

Jonathan Bennett [00:46:42]:
Yeah. All right. Let's move on. And actually, we're going to take a quick break and then we're going to come back and talk about some browser stuff. Firefox and some interesting things going on there. So don't go anywhere. We'll be right back. So what is up with Firefox? What version are we up to now?

Jeff Massie [00:47:02]:
Well, the current version now is 158, which landed on October 13th. And the headline feature is that JPEG XL image support is now on by default. You know, there's no settings. You don't have to go into the labs checkbox. There's no about config searching and toggling things. If a website serves a JPEG XL image, Firefox shows it. Now, so what is JPEG XL? It's an official ISO standard from the same JPEG committee that gave us the regular JPEG format back in the early '90s. It grew out of 2 earlier projects.

Jeff Massie [00:47:38]:
There was a Google PIC and Cloudinary's FuIF, F-U-I-F. The idea is that one format can do everything the others can do separately. You know, one standard to rule them all. Mozilla's developer notes describe it as royalty-free with lossy and lossless compression, transparency, animation, and HDR. It also supports wide color gamut, high bit depth, and progressive decoding, where a blurry version— that which is where a blurry version of the image shows up first and then sharpens as the rest downloads. You Those that were on modems way back in the day might remember such a feature where things would start pixelated and kind of appear in. One feature that no other format really has, and quoting Mozilla, it can also losslessly transcode existing JPEG images. So you can take a JPEG you already have and convert it to JPEG XL.

Jeff Massie [00:48:43]:
And it'll get noticeably smaller, typically around 20%, but it's also reversible. So you can turn it back into the exact original JPEG bit for bit. A lot of, a lot of JPEG compression is, uh, lossy, meaning it trims some of the, uh, some of the bit depth so that it can make the image smaller But you lose some quality of the image. And if you really crank it up hard, you get very blocky kind of, um, bad 8-bit graphic looking, uh, images. Now Chrome actually has experimental JPEG XL support, and at the, at the end of 2022, now then Google pulled it out And the reasoning was there wasn't enough interest and not enough advantage over existing formats to be worth maintaining. Since Chrome is most of the browser market, you know, it kind of looked like that format was done. And the people who wanted the format were not very happy, but it didn't really stay dead. In 2023, Apple shipped JPEG XL in Safari 17.

Jeff Massie [00:50:01]:
And in November 2025, the Chromium team reversed course and said, Yeah, they'd welcome a fast memory decode, citing Safari and possible Firefox support and developer interest as well. Then Chrome 155 turned JPEG XL on by default. And that was just a week before this Firefox release where it's on by default. What once was kind of a zombie image format now has all 3 major browser engines. Yes, there's other browsers, but that's the majority chunk. The memory-safe part is how Firefox got here. So Mozilla wouldn't ship JPEG XL until a decoder written in Rust existed. You know, the thought was, you know, image decoders are a classic place for security issues because they process untrusted files from random websites all day long.

Jeff Massie [00:51:05]:
So Mozilla wrote it, or Firefox wrote it in Rust, and it's called JXL-RS. Now, Mozilla engineer Timothy Niko posted the intent to ship, and it's been behind a Firefox Labs checkbox since Firefox 152 with the plan default to go live in 157. Well, it— but it slipped one release because the remaining work took longer than expected. So now if you thought it was coming in 157, well, it didn't. Now that's why we have it in 158. Kind of a oops. Uh, developer Sergey Davidov measured lossless JPEG XL decoding at 15 to 20 times slower than lossless WebP. And depending on hardware, and in exchange for roughly 10% smaller files.

Jeff Massie [00:51:58]:
So looks better, but you got a slowdown. Now, he argued Firefox shouldn't ship the lossless mode at all, but Jake Archibald backed shipping it for compatibility since Safari already supports it. And he also said, quote, anyone who even cares a tiny bit about performance won't ship lossless imagery. You know, i.e., you're not going to have the big version of the file that looks perfect if you're worried about speed. Now, he's more worried that developers will assume lossy JPEG XL beats AVIF on the web, which he doesn't think is true. So JPEG XL is in, but it's not automatically the best choice for every image. Firefox now tells its websites— this is when it communicates when you first go to a website— that it now supports JPEG XL. The Image Accept header lists AVIF, JPEG XL, WebP, and PNG, and that's what it communicates to every server so the server knows what formats it can send to Firefox.

Jeff Massie [00:53:08]:
There's other fixes in 158, but You know, I also wanted to touch on, instead of that, I want to touch on the same day that this release came out, Mozilla launched Firefox Enterprise. It's Firefox plus a management console that companies and governments can run on their own servers. So IT teams can control which extensions are allowed, control telemetry, allow, restrict, or turn off AI features, block actions involving sensitive data on certain sites. It can turn on a lockdown mode for risky browsing. Now, before you get too excited globally, Mozilla is selling it first in France, Germany, Austria, and Switzerland, and basically pitched straight at Europe's digital sovereignty push. You know, we've been talking about that over the last few weeks. So there's no public pricing. You basically have to contact sales before they'll give you a number.

Jeff Massie [00:54:05]:
And which of course is going to depend on the size and the maturity of the infrastructure you're trying to run it on. Something to note. Now, Mozilla said, you know, the Mozilla browser is open source, but it hasn't confirmed the console is. And so, you know, self-hosted doesn't automatically mean open source. So we don't know right now if the console for the enterprise is open source or that's going to be closed source even. But the browser is, even for enterprises, open source. The bigger picture is this could be a new revenue stream for a company that still relies mostly on Google for money. Side note, a Thunderbird Enterprise is on the way as well.

Jeff Massie [00:54:58]:
So, Take a look at the articles linked in the show notes for full details and happy browsing.

Jonathan Bennett [00:55:06]:
That's a lot. There's a lot going on in Mozilla land.

Jeff Massie [00:55:10]:
Yeah. The enterprise, I think, is pretty cool.

Jonathan Bennett [00:55:15]:
It is. It's a big deal.

Jeff Massie [00:55:17]:
Well, because realistically right now, Google keeps Firefox alive because they don't want to be a monopoly. And as long as they keep feeding Firefox, there's an option out there. I mean, kind of like when Microsoft gave Apple money.

Rob Campbell [00:55:33]:
You know, the enterprise is one of the places where Firefox has really been lacking. You know, whereas like Chrome and Edge, you can manage those within Active Directory. And I'm pretty sure Firefox you can't. But did you mention the enterprise? I think there's like a new management thing coming out. Is that something you mentioned there?

Jonathan Bennett [00:55:53]:
That was one of the last things you talked about.

Rob Campbell [00:55:54]:
Yeah. Okay. Yeah. I thought so.

Jonathan Bennett [00:55:56]:
That's what, that's why you were listening to me daydreaming and falling asleep.

Rob Campbell [00:56:00]:
Yeah, I was looking for something, that's something else near the end there, but, uh,

Jeff Massie [00:56:04]:
trying to drink his water.

Rob Campbell [00:56:05]:
It's pretty cool because like, actually, I was talking to somebody recently about like how the reason why they don't prefer not to allow Firefox is because they can't manage it in their domain. And like that same day, I think within hours, I saw the news story. That Firefox was having. I was like, ah, look at that.

Jonathan Bennett [00:56:28]:
There you go. Yep.

Jeff Massie [00:56:31]:
Um, if they can get in, if they can get in good because they're, you know, open source, they're like, hey, we're, we're not corporate America, which Google's got that kind of stain, you know, black eye on them from corporate America that Europe's trying to get away from.

Rob Campbell [00:56:46]:
The biggest stain that Google has with me is you don't really want to invest too deep in anything they're doing because you don't know if it's going to be around tomorrow.

Jonathan Bennett [00:56:55]:
True. I mean, Mozilla is based in San Francisco. They are US tech bro, American tech bros just as much as any other company.

Jeff Massie [00:57:08]:
Well, but they're a lot more— they're open source. I mean, you can say Chromium is, but Chrome isn't. I mean, there's a lot of other stuff that gets

Jonathan Bennett [00:57:18]:
That's true.

Jeff Massie [00:57:18]:
Thrown in there. And they— I think they are more— they, they are not as aligned to large corporate America as Google is.

Rob Campbell [00:57:29]:
Well, and like Keith points out, uh, uBlock Origin still works on Firefox where it doesn't work in the modern versions of Chrome.

Jonathan Bennett [00:57:40]:
Although uBlock Origin Lite is honestly fine. It just works.

Rob Campbell [00:57:45]:
I don't know. Honestly, I don't use either because I have Pi-hole on my network. And so I don't need to really install any.

Jonathan Bennett [00:57:52]:
Yeah.

Jeff Massie [00:57:53]:
I use Firefox and once in a while Chromium, but 99% of my browsing is Firefox with the full, full-fat uBlock Origin. Give me the fat. I'll take it all.

Jonathan Bennett [00:58:07]:
Give me the fat. All right. So Rob, we haven't really talked. Well, no, we have. We have talked about AI. Please don't make a fucking game out of it. Alcohol poisoning is a real thing. But we've got one more, at least one more.

Jonathan Bennett [00:58:24]:
No, we got several more. All right. We have more AI stuff to talk about. Rob, why don't you take the next one? The next thing in a string of AI stories. This is the Untitled AI Show.

Rob Campbell [00:58:34]:
I've already hinted at this one. But if you are still wondering whether AI coding tools have a place in serious software development, well, Linus Torvalds has apparently decided to demonstrate it. Over the past week, we've seen him use AI to work on kernel performance, make difficult code easier to understand, and help uncover bugs dating back more than a decade. So it's not like X.org old bugs, but a decade's pretty long for the kernel. Anyway, calling him all in might be putting a headline on it, but he's clearly moving beyond simply saying these tools can be useful. He's putting them to work himself. First, Linus published an experimental kernel branch to developed with Claude Code.

Rob Campbell [00:59:33]:
It tackles a bottleneck that occurs when multiple threads repeatedly read small amounts of data from the same cache file. Essentially, those threads spend time fighting over a shared bookkeeping counter. The proposed changes let the kernel serve certain reads without updating that counter. Linus credits Claude Code with helping produce the code. test programs, review, and initial write-up, all under his direction. His measurements showed a substantial improvement in that specific workload, but he also documented unresolved problems and testing gaps. Then came a separate example involving the kernel's associative array library. Developer Nils Olrugi had reported a bug and supplied a fix.

Rob Campbell [01:00:31]:
Linus said the code was too obscure for him to follow comfortably. So he used modern language model tools to help make sense of it. His description was, quote, I did what I preach. The resulting work split larger difficult functions into more readable pieces. Testing through a user space harness confirmed the original bug and uncovered 3 additional bugs, all dating back to the library's introduction in 2013. So just think about that. The creator of Linux encountered code that was difficult to follow, reached for an AI assistant, and used it as part of a process that exposed problems hiding for 13 years. So that's a pretty practical demonstration of where these tools can help even experienced developers.

Rob Campbell [01:01:26]:
Meanwhile, kernel developers are considering changing how AI assistance gets disclosed. A proposed patch would remove the legal requirement to include an, quote, AI-assisted by tag when AI contributes a patch. According to Phoronix, there was consensus for dropping the requirement. At the recent Linux Maintainer Summit, although the mailing list discussion still includes objections from developers who want that disclosure preserved. At the time of this report, this was only a proposed change. Taken together, these stories suggest AI is becoming an ordinary part of the development toolkit for at least some of the people maintaining Linux. And Linus is showing several uses beyond generating code. Understanding existing code, developing tests, investigating bugs, and exploring performance improvements.

Rob Campbell [01:02:25]:
There's still a developer directing the work, checking the results, and identifying what remains unresolved. But when Linus Torvalds is openly using Claude code on kernel internals, the conversation has moved well beyond whether AI belongs anywhere near a serious program. Now, We get to watch what a skilled developer can accomplish with it. You know, even myself this week, you know, I've been saying I'm going to move away from Ubuntu, my servers, and I have. I finally moved my Ubuntu web servers to Debian this week. And I used AI to give me ideas how to optimize the server's performance better. And then I used ChatGPT's new, they have a dot, which is an always-on agent, similar to Muse. I used that to stress test the server while I monitored the resources on it and everything.

Rob Campbell [01:03:17]:
And that worked pretty well. I told it what to do and it just hit it. Anyway, I also went back to an old open source program that I started years ago and then pretty much abandoned it. It actually had some people following and starring it. So I'm like, you know, this is something maybe I should try to move forward. It hasn't been touched in 5 years, but I decided to get some ideas and use some assistance, and I've started working on that one again. So if anyone in here is, uh, watching that project of mine, it's, it's alive again. All my projects are alive again.

Rob Campbell [01:03:53]:
Nothing's abandoned anymore, at least not in, uh, GitHub. I still have some really old stuff over at SourceForge. that I have no intention on bringing back because in 2026, they're just not worth anybody using. But—

Jonathan Bennett [01:04:12]:
I went ahead and tagged on Linus's response to this where he put his oar in the water. It's actually pretty good. He responded to someone talking about, oh, we want to set expectations. He says, no, you're about something entirely different. It has nothing to do with expectations and has everything to do with your hangups. I don't understand this whole idiotic concept of don't use AI for X. Here's a new rule just for you. Don't use compilers for any of your kernel submissions.

Jonathan Bennett [01:04:44]:
Because if you can't show that you really understand what the machine is actually doing by writing your code in assembler, then I don't want to see your code contributions. You clearly aren't competent if you can't write it that way. And by the way, you better not use an editor to write that commit message either. It's great. It's great. So yes, Torvalds is in rare form.

Rob Campbell [01:05:10]:
I wonder if we've lost any listeners from our like of AI.

Jonathan Bennett [01:05:17]:
I don't know. I

Jeff Massie [01:05:20]:
would like to point out all 3 of my stories today, none of them have anything to do with AI.

Jonathan Bennett [01:05:25]:
I tried real hard to be skeptical and then I actually started using it for writing code and it's like, It makes it so much faster. It makes it so much faster and it also lets you do things that you couldn't have done.

Rob Campbell [01:05:38]:
Yeah, like stress tests. I would have had to write some program to stress test as well as that did it for me.

Jonathan Bennett [01:05:45]:
Yes.

Jeff Massie [01:05:46]:
I've got Claude Code at home and it even handles some basic stuff that I was starting up my folding at home again because it's Getting cooler here and I like to donate some CPU cycles. And it wasn't working. And I'm like, wait a minute, is the daemon running or not? And I was like, oh, let me restart. Oh, what's that command? You know, I knew it was service start. And is it, you know, folding@home or folding.home or folding home? You know, so I just, hey, is this service running? And it was like, oh, yes, it is. But you're seeing this problem. So here's what the fix would be. And Okay, do it.

Jeff Massie [01:06:25]:
Okay, blip, and all better. And I got to thinking, I can see a danger. And I know it's been talked about on other shows on the network where you kind of forget how to do some stuff because you just tell AI, hey, do this for me. Okay. And it's like, wait, what's that command to list all this stuff? Or what is, you know?

Rob Campbell [01:06:45]:
One of my most recent little projects I did, I don't have this. I should, I might put it on GitHub, but I just did it for me. Is I wanted, you know, Uptime Kuma is great for watching the uptime of a website, but it's like, well, why can't I monitor other things like CPU, memory, storage?

Jonathan Bennett [01:07:01]:
Mm-hmm.

Rob Campbell [01:07:02]:
I had him write me a little agent to throw it on my server, and then I could have just left Uptime Kuma the way it was, but I had put a patch in there to actually label the stuff CPU, um, memory or RAM and, and storage. So now on my Uptime Kuma, I monitor with history tracking the resources on my server.

Jonathan Bennett [01:07:23]:
Nice. Yeah, let's let you figure out, is that downtime because I ran out of memory?

Rob Campbell [01:07:30]:
Yeah, I was having some problems like that with my old server, which is why I originally did it. My new server is way more optimized and uses significantly less everything. Thanks to AI.

Jeff Massie [01:07:44]:
So, and while I do use AI, I will go on the record saying I don't believe AI is going to be the end of the world. Do you know where I see the real danger? And I've never heard anybody say this. The real danger of AI is twofold. One is going to be when people say, oh, I need— hey AI, I need more toilet paper. And it's going to go in and say, oh, okay, I'm supposed to look for this cheapest thing and I'm supposed to— and then it's going to go, okay, I just purchased 6 railroad cars of toilet paper because it's at a cheaper value for you. And you're like, wait, you drained my bank account buying toilet paper. You know, it's, it's going to be stuff like that that's going to happen. Or my true worry is bureaucracy where, oh, we're denying this health insurance claim or whatever.

Jeff Massie [01:08:37]:
My worry— Go— what?

Rob Campbell [01:08:40]:
Go finish.

Jeff Massie [01:08:42]:
Oh, because it can look and say, oh, based on what we know about you, we don't think you're going to fight this, or you can't afford to fight this, or it's going to take so long that you're going to—

Rob Campbell [01:08:51]:
They already have algorithms, I think, doing that.

Jeff Massie [01:08:54]:
Yeah, but it's going to get more malicious because then they can go, oh, you know what? I think this person's going to die before they can actually fight this thing, or, you know, we can bog it down enough. We'll still come out ahead. That's where I see the danger of AI is stuff like that, not for From the robots walking around taking us over.

Rob Campbell [01:09:12]:
Is people getting too reliant on it to where they stop learning how to do anything? Like, for those of us who already know how to do stuff, we're using it to assist, it's, it's great. But for those just coming up, if they don't take the time to learn the things and they just like, why'd I have to learn this? Like, I got this. You know, it's kind of like the old saying, it's like, why do I have to learn math, you're not always going to have a calculator with you. Well, I do have a calculator with me now. I don't have to learn math really. I mean, yeah, but anyway, just that basically that people are going to come and just rely on that and basically become the, uh, movie Idiocracy.

Jonathan Bennett [01:09:53]:
Oh, ouch.

Rob Campbell [01:09:55]:
Maybe not that extreme, but maybe.

Jeff Massie [01:09:58]:
Well, that's why, why some of the stuff they talk about Leaving in manual steps just so that you retain some of that knowledge. And because I could, I could have figured out the, the service, you know, is my service running? I know that I kind of know the command. What switch is it? I'd have to look it up because I don't use it that often. But you keep doing more and more, then wait a minute.

Rob Campbell [01:10:21]:
I use it for dumb little things like commands that I use occasionally, and I've used them plenty of times before. I could look at my history and finding various things. I was like, you know what? Tell me this command again. He's like, oh yeah, okay, I remember it. I throw that in there. It's like, it's just quicker. Like I know how to do it. I can figure it out, but I can figure it out faster this way.

Rob Campbell [01:10:41]:
That's

Jeff Massie [01:10:42]:
true. So, so Rob doesn't have to look up tar anymore to see the switches.

Jonathan Bennett [01:10:48]:
Uh, yes.

Rob Campbell [01:10:49]:
ZXVF. I just have that memorized.

Jonathan Bennett [01:10:54]:
All right, we're going to take a quick break and we have at least one security story when we get back and some other stuff to look forward to. So don't go anywhere. So there is a really interesting, the first half of a really interesting security story got released this week and it's PwnEscape. And this is the guys from Pwn.ai who won a $1 million Million Dollar Sandbox Challenge put out by Vercel. And this challenge invited researchers to break the isolation boundary of the Vercel Sandbox tool. And this used virtual machines inside the Linux kernel was part of its solution. And they, the guys at Pwn.ai, took a look at this and put their own AI tooling to the test. to figure out, could they find a crack in this VM-based sandbox and exploit it? And it didn't take long for them to find something.

Jonathan Bennett [01:12:02]:
I believe that they found a problem within the first 24 hours, if I remember correctly. I'm looking for the exact details of the timing of this. But they very quickly found a problem. And it's really interesting what the problem is. So it's in the networking stack. And so inside the Linux kernel, you have the way that a networking packet gets put together. Of course, it's a memory object, essentially. And because Linux has all of its bells and whistles, you can do a lot of different things with that memory object because different packets go out across different kinds of mediums.

Jonathan Bennett [01:12:46]:
So it might be an Ethernet packet, it might be a Wi-Fi packet. There's still stuff in the kernel for doing token ring packets and AX.25 packets and just everything that you can think of. All right. One of the things that happens in those packets is a checksum gets written. And that is essentially a, you know, it's a check. It's where you do some math on the contents of the packet and then you write out a second number. And then somebody on the other side can look at those 2 things and go, oh, no bits changed in flight. The checksum matches.

Jonathan Bennett [01:13:18]:
We know it's good. All is well. The Linux kernel has support for something called a delayed checksum write. They call it— what's the term they use here? Delayed write. Um, checksum. I had it. I had it earlier. Uh, anyway, they write it into the metadata.

Jonathan Bennett [01:13:49]:
So the, the extra contents that goes along with the packet, they say, well, we'll figure the checksum out later. And then there's another thing that can happen with these packets. And that is if you try to send one that's too big, it gets fragmented. And that's something else that the kernel has to handle is to fragment packets. And so they put these things together and they said, wait a second, there's something really interesting that happens here. When we— so we're inside a virtual machine, we tell the hypervisor we want to send a network packet. Here it is. It's big.

Jonathan Bennett [01:14:24]:
And oh, we'll take care of the checksum thing later. Deferred. We defer the writing of the checksum. The packet gets partially processed, the packet gets broken for fragmentation, broken into 2 pieces or more potentially. Then the machine inside the virtual machine says, here's the checksum. In certain cases, it was possible that that checksum, so the pointer where the memory was at, was no longer pointing at the right place. And so they could actually abuse that to reach into memory on the outside host that they were not supposed to get to. And that is the essential flaw that they found on this.

Jonathan Bennett [01:15:13]:
And it started out as a read primitive. And then I believe the next part, this is like the part 1 of the series of discovering this. It looks like the next part is going to be how they changed that into a write primitive. primitive to be able to write up to 32 bytes and then take over the outside server. But it was a very AI-centric workflow that they found. And it happened very, very quickly. They have here at the very end, yeah, 3 days to the primitive. There it is.

Jonathan Bennett [01:15:48]:
They found the... Yeah, they made the initial report of the problem 3 days after the sandbox challenge was published. And then apparently it took several weeks to actually get it fixed in the kernel, which is sort of an interesting pattern that we're seeing as well, that AI can find problems very quickly, but sometimes coming up with a solution to these problems that are found can be challenging. But anyway, yeah, really, really fascinating story. We've got it linked to, and it looks like there is a part 2 coming to this. where they dive into some more details about how they turn this read primitive into a write primitive. But it's all about this idea of a deferred checksum. So you give us a live pointer, we'll write into the pointer when the time is right, and they write into the pointer when the time was not right, and it ends up writing over the wrong things.

Rob Campbell [01:16:40]:
The time's not right, Bob.

Jonathan Bennett [01:16:42]:
Wrongs were written. Indeed. Really, really interesting security story though. I find those sorts of things fascinating.

Jeff Massie [01:16:51]:
A right makes two wrongs.

Jonathan Bennett [01:16:53]:
Oh yeah. Yeah, it does in this case.

Rob Campbell [01:16:58]:
A right makes two wrongs.

Jeff Massie [01:17:02]:
And for those that might not know, there's a phrase that says, two wrongs don't make a right.

Jonathan Bennett [01:17:11]:
Yes, it's a double play on words, a double entendre of sorts there. Yeah, so that is already fixed in the upstream kernel. I don't remember which version it got fixed in, but, you know, found, fixed, and then they released it after the fix was released.

Jeff Massie [01:17:30]:
Several. The latest supported kernels have it.

Jonathan Bennett [01:17:33]:
Yep, absolutely. All right, Jeff, you wanna talk about Framework?

Jeff Massie [01:17:40]:
Yeah, and, you know, They keep coming up with stuff. They keep doing stuff. Yeah, they just keep doing stuff that's pretty cool. So on October 14th, uh, CashUS developer Peter Jung announced that Framework, you know, company that makes the repairable laptops, is more than tripling its sponsorship of the distribution. Now, let's keep this realistic here. It's nothing major. It's not major corporations, but it It's going from $250 a month to $10,200 a year, which works out to about $850 a month. So this is not, you know, mega corporation type money, but, you know, it helps quite a bit.

Jeff Massie [01:18:26]:
Now, for those that have forgotten, CacheOS is an Arch-based distribution focused on performance, and it ships optimized kernels and packages built on newer CPUs and It's becoming really popular with Linux gamers. In the latest Steam hardware survey for September, CacheOS was just over 18% of the Linux users on Steam. So that makes it the number one Linux distribution on Steam, even ahead of SteamOS, which operates on the Steam Deck. So, I mean, CacheOS has grown every month in the Steam hardware survey since May. And It's doing pretty well. But anyway, the donations started last December. So Framework sent the CashOS team a Framework Laptop 16 to tune their kernel and packages on modern hardware, plus the $250 a month. At the time, CashOS said that was about 10% of all its monthly donations.

Jeff Massie [01:19:26]:
So that tells you that CashOS is not a big money-making juggernaut. It doesn't have really deep pockets. Now, according to Jung, the new money goes to 3 things, keeping build servers, mirrors, and infrastructure running reliably. So spending more time on kernel optimization, packaging, and hardware support, and getting closer to the project's long-term goal of letting the developers work on CacheOS full-time. Now, Jung wrote, Having Framework triple its support says a lot about how much they care about Linux on their hardware. Framework replied on X that CacheOS is one of the fastest-growing distributions being used by Framework laptop owners. I should note that this isn't a one-off for Framework. The company runs an open-source sponsorship program that's committed over $260,000 as of March.

Jeff Massie [01:20:22]:
It also supports KDE, Xfce, Arch, Debian, Bazzite, NixOS, FreeBSD, NetBSD, and others. So they spread the love around. This is not just only supporting CacheOS. CEO Nav Patel stated, rule is simple. We focus on supporting projects that, and this is the Framework CEO, we focus on supporting projects that create open source software that makes our products work. So basically a nice symbiotic relationship. When cacheOS was added last year, Patel said he had picked it because it consistently comes up on top in performance benchmarks. To make it simple, you know, like I said, Framework sells the hardware to Linux users, so it pays the people who make Linux run well on their hardware.

Jeff Massie [01:21:15]:
So works out pretty good. You know, like I said, it's not a huge check, but for a small, you know, distribution team, a predictable monthly payment that keeps build service running is a nice bit of security and stress relief. If people or other companies want to donate, the CashOS donation page is open. I did check. So if you're at all interested, take a look at the articles linked in the show notes for more details and happy donating.

Jonathan Bennett [01:21:43]:
Yeah, good for them. It's neat to see a company that's giving back and helping out their community and really trying to make Linux support really good. Poor Rob. Poor Rob.

Rob Campbell [01:21:56]:
I'm all blurry.

Jonathan Bennett [01:21:57]:
He's just struggling right now.

Jeff Massie [01:21:59]:
I thought that was enhance my look image.

Jonathan Bennett [01:22:03]:
Yeah.

Jeff Massie [01:22:04]:
Haven't looked better, Rob.

Jonathan Bennett [01:22:05]:
Yeah.

Jeff Massie [01:22:07]:
But no, it does come full circle though, right? I mean, they, the better Linux runs on their hardware, the more hardware they can sell. So it makes sense.

Jonathan Bennett [01:22:17]:
At one point, one of their new models came out. I think it was the Framework 13 Pro. And they put out an announcement and said, we're selling more Linux on this than anything else for the Framework 13 Pro. So—

Jeff Massie [01:22:30]:
I want to say it was like, now I'm rusty on this. I want to say like 70% or something like that or 80%. of the hardware they sold, people are putting Linux on it.

Rob Campbell [01:22:40]:
I mean, the whole model of what a framework is really aligns far better with Linux users than non-Linux users.

Jonathan Bennett [01:22:49]:
It's true. Yep, it's true. It does sort of scratch your itch. Uh, really does.

Jeff Massie [01:22:55]:
Well, didn't they just start installing Linux on it because of customer demand? I thought I saw a story about that.

Jonathan Bennett [01:23:04]:
Maybe it was. They may. It's very possible that they do. Let's see. That's warranty. That's laptop sleeve. Operating system. There it is.

Jonathan Bennett [01:23:19]:
So on the new Framework 12, you can get Windows 11 Pro, Windows 11 Home, or Fedora 44 KDE Plasma.

Jeff Massie [01:23:28]:
Oh, okay. I guess it's older. It started in April.

Jonathan Bennett [01:23:33]:
And interestingly, Fedora 44 Plasma is the top choice here. It's like you can have Fedora, or I guess we can put Windows on it for you.

Rob Campbell [01:23:41]:
You can get with a Fedora on it, yet they're giving Cachy money. Are they going to pre-install Cachy? Is that going to be an option?

Jonathan Bennett [01:23:50]:
I don't know. I don't know. I guess they figure that most people that want that can go and do it themselves. If you can't get that installed by yourself, maybe it's not for you.

Rob Campbell [01:24:03]:
I mean, that kind of goes— well, whatever.

Jonathan Bennett [01:24:10]:
Indeed, indeed. Yeah, fun stuff though.

Jeff Massie [01:24:14]:
Yeah, Keys512 said, I think they said Framework 12 is 80% Linux. So maybe that's what I was thinking. I just remember that one of the models had a high, uh, Linux percentage.

Jonathan Bennett [01:24:26]:
Yeah, I'm pretty sure it was the 13 Pros where I saw that they made the statement that it was primarily Linux. I don't remember any numbers attached to that though. Um, speaking of Framework, there was actually a, uh, uh, the Framework 13 or Framework 12, uh, with Intel Core 3. There was a story about that. That is a new offering as well, and apparently that works really well on Linux too. There's a Phoronix article about it. So it's a really interesting time to buy a laptop. Some really compelling options out there.

Rob Campbell [01:24:58]:
Yeah, if it wasn't for the RAM prices.

Jonathan Bennett [01:25:02]:
Yep.

Jeff Massie [01:25:03]:
Or desktop. They do sell desktop as well.

Jonathan Bennett [01:25:06]:
It's true. That is true. So thinking about this, about this question of laptop choices, there is a new player. And I actually want to pick my co-host's brain about this, what they think about it. The RTX Studio. Spark. You guys seen coverage of this? It's NVIDIA's new chip you can get in a laptop, an ARM-based laptop.

Rob Campbell [01:25:31]:
I've heard about it. That's about it.

Jonathan Bennett [01:25:33]:
Ah, Jeff, are you more familiar with this?

Jeff Massie [01:25:38]:
A little bit. Yeah.

Jonathan Bennett [01:25:40]:
Or is this one of those topics where you're limited what you can talk about?

Jeff Massie [01:25:45]:
I can say a little. Yeah.

Jonathan Bennett [01:25:48]:
Okay, I gotcha. So the question that I have, apparently this thing is really pretty interesting hardware, but it is a partnership between NVIDIA and Microsoft for running Windows on ARM. And the question really is, how much of a challenge is it going to be to install Linux on one of these laptops, one of these RTX Sparks?

Rob Campbell [01:26:11]:
If you think about the Qualc— the, uh, what is it, the X Elite Qualcomm ones that were working with Microsoft to put Windows on ARM. At the beginning, it was— it's been quite— I mean, not even at the beginning, it's been quite the job to get Linux to fully run on there. And now they're even, you know, providing some support. So I feel like this is— I feel like it's not going to be good unless just coincidentally it is.

Jonathan Bennett [01:26:43]:
So here's the interesting thing about this. The RTX Spark is based upon the DGX Spark, which is sort of a desktop-y neural processor thing from NVIDIA. And their official SDK is, I believe, a Debian image. So like, The software is already written. It really just comes down to, uh, is the bootloader locked on these things or are you going to be able to install Linux on it? Um, excuse me, Ubuntu, not Debian. But yeah, DGX OS is Ubuntu. Hmm. But apparently they're kind of expensive laptops.

Jonathan Bennett [01:27:27]:
Yeah.

Jeff Massie [01:27:30]:
They're, they're— well, because it's AI, right? I mean, it's—

Jonathan Bennett [01:27:34]:
yeah,

Jeff Massie [01:27:35]:
so it's, it's got to come with a bunch of memory and it's gotta—

Rob Campbell [01:27:39]:
I like it. I like— ask, isn't this Leo's obsession? Is that what he— I remember hearing something where he bought 2 expensive— spent like $10,000. Maybe it was these.

Jonathan Bennett [01:27:51]:
Could be.

Jeff Massie [01:27:51]:
It was the older version of the Sparks.

Rob Campbell [01:27:53]:
It was the older one. Okay.

Jeff Massie [01:27:55]:
Yeah. Because, because he mentioned you, you can't get the— they've cut down the memory you can get in them.

Jonathan Bennett [01:28:02]:
Makes sense. Yeah, these go up to 128 gigs, I think, and it's like 20 cores. So I mean, they're pretty impressive bits of hardware.

Rob Campbell [01:28:12]:
Geez, and that's cut down?

Jonathan Bennett [01:28:15]:
Yeah, probably

Jeff Massie [01:28:16]:
because you could get 256, I believe.

Jonathan Bennett [01:28:19]:
Yeah, I bet.

Jeff Massie [01:28:20]:
So anyway, this is pretty cool because modern— a lot of modern CPUs can only handle 192 gigs. Now, I'm not talking workstation or enterprise, any of that,

Jonathan Bennett [01:28:31]:
just— Right,

Jeff Massie [01:28:32]:
right. The normal consumer ones.

Jonathan Bennett [01:28:34]:
Yeah, the ones that actually show up on our desks.

Rob Campbell [01:28:37]:
Yeah, it's the memory that's all expensive. You're spending all that on the memory.

Jonathan Bennett [01:28:40]:
Yeah,

Jeff Massie [01:28:41]:
yeah.

Rob Campbell [01:28:41]:
I hate that.

Jonathan Bennett [01:28:42]:
I hate that right now. Yeah. And then just think, you got some servers in the data centers that have a whole whopping terabyte of memory in them

Jeff Massie [01:28:48]:
or more.

Jonathan Bennett [01:28:50]:
Yeah, probably more these days. I don't know. I don't know what they actually max out at right now.

Jeff Massie [01:28:55]:
I know you can do at least 2 terabytes without getting— now that's not counting like custom type motherboards that—

Jonathan Bennett [01:29:05]:
Right. Yeah. But you know, we, we, we have so much memory we hang it off of our PCI Express slots. Yeah.

Jeff Massie [01:29:15]:
Well, and that, that, that goes back to now you better understand why If somebody's unsure, why, why do they have all these different tiers of memory and shared pools of memory? This is why.

Jonathan Bennett [01:29:28]:
Yep.

Jeff Massie [01:29:29]:
But I mean, as expensive as it is, I mean, there's a lot of mega fabs coming online trying to put out more wafers.

Rob Campbell [01:29:36]:
Are your— is your prediction it's going to come down eventually?

Jonathan Bennett [01:29:40]:
I mean, it's eventually going to come down, right?

Jeff Massie [01:29:41]:
It's eventually— well, it

Jonathan Bennett [01:29:43]:
pretty— we're safe to say that, right, Jeff?

Rob Campbell [01:29:46]:
Eventually. In my lifetime?

Jeff Massie [01:29:48]:
In the next 15 years. Within the next 15 years, we're gonna— well, no, because I, I kind of said I thought it kind of leveled out, and yeah, it's gone up from there, but demand just keeps—

Rob Campbell [01:30:02]:
Now they gotta listen to your predictions, obviously.

Jonathan Bennett [01:30:05]:
And here we thought he knew what he was talking about.

Jeff Massie [01:30:07]:
Well, I know of one mega fab coming online next summer.

Rob Campbell [01:30:11]:
His boss has told him, hey, tell him it's coming down. Almost leveling out.

Jeff Massie [01:30:17]:
And then a year or two later, there's another mega fab coming online. There's—

Rob Campbell [01:30:22]:
I don't know what benefit that would do.

Jonathan Bennett [01:30:24]:
That's what cranks out the memory.

Jeff Massie [01:30:27]:
Yeah.

Rob Campbell [01:30:27]:
No, no, no, no. I mean, I mean, telling us that it's coming down and like, okay, well, we'll hold off then. Obviously.

Jeff Massie [01:30:34]:
Well, honestly, I, I was on a forum a while back and people like, how do I navigate this? And I honestly said, well, I would personally wait. I mean, unless you're in dire need of hardware, then you're, you're kind of up the creek without a canoe. But, you know, if you can, just delay.

Jonathan Bennett [01:30:54]:
Mm-hmm.

Jeff Massie [01:30:55]:
Because all, all 3, depending— 4 if you count, was it CXLM or whatever they are— I mean, every— everybody's trying to get more wafers out the door. There's fabs coming online. There's— but it, it takes time. So even when they say, I am going to, you know, like Elon, I'm going to make this super mega fab and it's going to do it. Yeah, good luck.

Rob Campbell [01:31:22]:
Hurry up.

Jeff Massie [01:31:23]:
Yeah, this, this takes years to build. This takes people to train it, to get the tooling, to get the—

Rob Campbell [01:31:30]:
If he can make a car fly and do a barrel Barrel roll through the air and land. We should have a fab by next week.

Jonathan Bennett [01:31:38]:
What is it, what is it they say about Elon's companies? He takes things that were previously impossible and just makes them very, very late.

Jeff Massie [01:31:45]:
Yeah, well, I— good. That's to me, I'm like, good luck with those ASML mirrors and lenses. Sure, getting, getting that, uh, I, I have no idea what the lead time on those is, but There's semiconductor equipment I know for a fact it's out, you know, at least a year to 2 years. So if you put an order in today, it'll show up in a couple of years.

Jonathan Bennett [01:32:12]:
Checks out. All right. We're going to take a quick break and then we're going to come back and talk about some command line tips. We got some fun stuff here. So don't go anywhere. We'll be right back.

Rob Campbell [01:32:26]:
All right. So with all the office suites coming out lately to replace the Microsoft Office suite, obviously, there is always one piece missing that these suites never have. And that is a good email client or an email client at all to replace Outlook in their office suite. So my tip this week is called Convey, a Linux email client forked from Geary. It keeps Geary's simple conversation-based layout, adds a modern GTK4 interface, and supports Outlook and Microsoft 365. Well, you know what I read? It does that. But when I set it up, only thing I saw was a regular IMAP setup. So I don't know, maybe I need to dig further.

Rob Campbell [01:33:17]:
Further. What I read is it supports Outlook and 365, but maybe there's some adjustment I had to make. So anyway, I set this up with just the IMAP and I threw a bunch of— so I used, uh, I used that, uh, AI dot in ChatGPT and said, send me, uh, a bunch of test messages to this email. So anyway, filled up this, uh, empty email box I use for testing here. And so for those looking, Convey, it's a very simplistic, um, email client. I can't click there because that is my video and not the actual desktop. Um, so anyway, it's very simple. It's got a lot of buttons right up here.

Rob Campbell [01:34:03]:
I can create a new email right here, and you know, I want to send this to whoever and a subject to whatever. And yeah, I could send it. Obviously this isn't going to go anywhere because I didn't type an email address in there. But anyway, Convey— I saw an article about this and I'm always looking for a good email client. Um, and I mean, it's simple, clean. Um, so it kind of checks those boxes, but I don't know, maybe I'd like a little bit more. And I know Geary has had a lot of fans in the past, but I don't think they've updated for a while.

Rob Campbell [01:34:46]:
So if you were a fan of Geary, here's a replacement for you.

Jonathan Bennett [01:34:51]:
Very cool. All right, Jeff, what do you have for us?

Jeff Massie [01:34:56]:
I got psutils, kind of an oldie but a goodie. So it's an old package of PostScript tools. Tools, but the modern version also works on PDFs. So it, it was rewritten in Python by Reuben Thomas a couple years ago, and you probably already have it on your machine. And it's a suite of tools, so each command in the package does one job to the pages of a document, kind of, uh, very Unix-like, right? You just, you do one thing, you do it well. Like, psnup puts several pages on one sheet of paper. So, like, if you're printing a bunch of slides or something like that and you wanna condense it down, you can put, say, for example, 2 or 4 on a single sheet of paper to give it kind of that 2-column look or the windowed look where you'd have, like, 4 panes. psselect pulls out the pages you want.

Jeff Massie [01:35:56]:
So you can grab, you know, odd or even pages, or you can reverse the document when you pull the pages, or you can just say, I want page 1 and 7 and 12. So, and you can even reverse it. So you can, uh, it's kind of handy sometimes too. You can do like double, double-sided printing on a printer when you, uh, when you play with that to get it ordered so it'll print correctly. If you have documents you want to join, PS Join puts documents together. Pre-Size changes the paper size. So if you wanted to go from an A4 size paper to US Letter, it'll do that. You have PS Book, which is Kind of a cool trick here.

Jeff Massie [01:36:49]:
It reorders the pages in— into a— into booklet order. Now you pipe that into psnup and you can get a booklet you can print double-sided, fold it in half, and staple it. You know, you can pretend— you can pretend you're on, uh, pretend you're Rob on the old, uh, binder machine. On an 8-page document. Uh, PSBook, put, you know, you'd put the pages in order and like I said, then you, then you just, you can, you can reverse them back and forth and then so it, when it's folded, it'll read 1 through 8. Um, basically if you don't have it, it's just PsUtils on At least on, I know it's on Arch, Debian, Ubuntu, and Fedora.

Jonathan Bennett [01:37:43]:
All right, very cool. Making books. All right, I've got one that I was kind of surprised we hadn't talked about before. And I'll go ahead and do the screen share thing. We can take a look at it. And I'm going to talk very, very briefly about TShark, which is not installed, but I can tell Fedora here to, yes, do the thing and install it. And it will, of course, do so. Way to be prepared.

Jonathan Bennett [01:38:12]:
Because Fedora is cool like that.

Jeff Massie [01:38:14]:
As Jonathan's image suddenly pixelates and—

Jonathan Bennett [01:38:20]:
Indeed. So interestingly, it may tell you things like this, like you are not a member of the Wireshark group. And so you can't do the thing that you're trying to do. Well, we will just temporarily do a sudo. There. Now I'll stop that because we don't actually need all of these, but this is doing essentially what Wireshark would do. It's a live capture of packets. Now the interesting thing is it doesn't do anything with those, but I can tell it to— we want to save it.

Jonathan Bennett [01:38:57]:
I believe it's -d. -w. Let's check real quick. Where did it go? Yes, -w is where you specify the outfile. I can say I want to go— oh, interesting. Maybe like this? Nope. Well, I should have tested this before I went to try it out. It's something about the fact that sudo is not playing nicely with my user profile here.

Jonathan Bennett [01:39:37]:
May even be an SELinux problem. But we got to demonstrate. I can tell you that -w is the way to do it. And the really interesting thing here is this command right here, usermod -a -G Wireshark, your username. And so that is at least the way that's set up on Fedora is that there is a Wireshark group, which is what you would add your user to to be able to do packet captures like this. But yeah, if you need to capture some packets from the command line, you don't want to have to pull up the full fat Wireshark. It's the way to do it. And it is, you know, it is of course going to be really nice if you're on a remote machine, you can capture it, throw it in a file.

Jonathan Bennett [01:40:20]:
email it or wormhole it across. There's various ways to get files from one place to another. Yeah, TSharp, it's pretty cool. That's the way to do it.

Rob Campbell [01:40:29]:
Nice.

Jonathan Bennett [01:40:30]:
Yeah.

Jeff Massie [01:40:31]:
Yeah, I'm surprised we hadn't covered it already.

Jonathan Bennett [01:40:33]:
Yeah, so was I. But I had searched and it was not there. All right, that is it. That's the show. We had a bunch of news we covered, some cool command line tips. I'm going to let each of the guys plug whatever they want to. Rob, what, what do you have for us?

Rob Campbell [01:40:49]:
Just the usual stuff. You want more of me, I have been posting almost daily, uh, 5, 6 days a week, uh, and, uh, and getting a lot of, um, some more activity on, on there. So if you want to connect with me on my social medias, the best way to do that, easiest way, is to go to my website first. Robertpcampbell.com, and on there there's links to my LinkedIn. I've been posting regularly. Twitter I have not, but if you want to connect with me there just because you like Twitter, you can do that. Uh, Bluesky, I've been posting there. Mastodon, I've been posting there.

Rob Campbell [01:41:28]:
And if you really, really want to thank me for everything I'm doing, you can donate a coffee here. Or another way that helps me out Is by getting a copy of my book, Trailer Park to Technology Leader. And most of you already know by now, it's a memoir about me, a story of my trajectory from, uh, a poor kid being born on the day of a blizzard to my trajectory to being a technology leader. And how you could find that is search on Amazon for Trailer Park to Technology Leader. Or scroll down on my website and there it is right there. You can buy it on Amazon, that'll take you right to it also. So, um, my sales have slowed down, so I could use some more people, uh, you know, uh, checking it out and, uh, writing some reviews and stuff like that.

Jonathan Bennett [01:42:26]:
Yeah, so I, I gotta ask, is this your first book, Rob?

Rob Campbell [01:42:30]:
Yes.

Jonathan Bennett [01:42:30]:
Amazon thinks that there is a second book under your name.

Jeff Massie [01:42:35]:
Oh, what is it?

Jonathan Bennett [01:42:36]:
Kickoff to Keepsake. It's a football season memory book. Apparently that is the other Robert Patrick Campbell.

Rob Campbell [01:42:45]:
Uh, well, I tried a few things.

Jonathan Bennett [01:42:48]:
Apparently one of them escaped the zoo because it's out there.

Rob Campbell [01:42:51]:
Yeah, no, that's mine actually.

Jonathan Bennett [01:42:55]:
Dark secrets unveiled.

Rob Campbell [01:42:57]:
There's another— I, I was playing around with, uh, publishing on Amazon and stuff like that, and I whipped together a, like, a, uh, what's it called, uh, memory book kind of thing for, like, kids in football. I also have one for Little League. Uh, so it's just a place to kind of log the season. Team members' scores, things like that.

Jonathan Bennett [01:43:27]:
Yeah.

Rob Campbell [01:43:28]:
But it's not like there's no stories in there or anything. It's just a log, cheap logbook kind of thing. But I guess you can get them if you have kids in football or baseball. I don't know. I'm not going to push it. But this is the one that you really should get because it's a good read.

Jonathan Bennett [01:43:46]:
I think. There you go.

Rob Campbell [01:43:48]:
And so does Jeff.

Jonathan Bennett [01:43:50]:
All right, Jeff, what you got for us?

Jeff Massie [01:43:54]:
Uh, well, it's tough to follow that. I'm not much on social media. If you find Rob on LinkedIn and want to connect with me, connect with him. Or if you try to connect with me, you got to mention TWiT because I get so much garbage on there that I ignore them unless you specifically say, hey, I'm from TWiT. I listen to the Untitled Linux Show, you know, something like that. Otherwise, it gets round filed. But I do have a little poetry. And I do have to thank somebody, Steve, for— I think Steve is the one I got this one from.

Jeff Massie [01:44:36]:
So love the contributions that people send my way. Murphy is my shepherd. He leads me into crap so that I might be stronger for the future. Have a great week, everybody.

Jonathan Bennett [01:44:50]:
Wow. All right. Thank you guys for being here. It has been a lot of fun. If you want to find more of me, there is, of course, over at Hackaday, a lot of fun stuff going on there. That is where FLOSS Weekly lives. And we do have a guest scheduled for this week. Last week's guest had to bail on us for a health issue, but we've We've got it scheduled for this week and looking forward to that.

Jonathan Bennett [01:45:09]:
It'll be a lot of fun. Other than that, we just want to say thank you. Appreciate everybody that catches us here, that watches, that listens, whether you get us live or on the download. And we'll be back here next week on the Untitled Linux Show. Thank you.