Untitled Linux Show 272 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, we're running virtual machines through reboots, talking about Ubuntu and some interesting security flaws. We're skipping ahead on the Apple M4. We fight a little bit about the Raspberry Pi and KDE, and then finish it off with some not typical benchmarking. It's a lot of fun. You don't wanna miss it.
Rob Campbell [00:00:23]:
Podcasts you love.
Jeff Massie [00:00:24]:
From people you trust.
Rob Campbell [00:00:27]:
This is TWiT.
Jonathan Bennett [00:00:31]:
This is the Untitled Linux Show, episode 272, recorded Saturday, September the 26th, typing with mittens. Hey folks, it is Saturday and it is time for the Untitled Linux Show. That's where a bunch of us nerds get together and we talk about the Linux kernel and hardware and software and all the cool stuff going on in the world of Linux desktops and technology. It is not just me. We've got the crew, the roundup, the panel of nerds. Experts? Anyway, we've got Kenan, we've got Rob, and we've got Jeff. And we've got some stuff to talk about. Some exciting stuff, some neat stuff.
Jonathan Bennett [00:01:07]:
A little bit of unfortunate stuff, but we'll get to that. We're going to let Rob go first, actually.
Ken McDonald [00:01:13]:
Good.
Jonathan Bennett [00:01:13]:
Then we're going to let Jeff go first because he's the one that was going to say something.
Jeff Massie [00:01:17]:
Well, I was just going to say, you know, panel experts, we're each legends in our own mind.
Jonathan Bennett [00:01:23]:
I could say the panel of talking heads. That we obviously are.
Rob Campbell [00:01:26]:
And some of us are legends in other people's minds. You could figure out who those people are.
Ken McDonald [00:01:31]:
It's hard to be humble.
Jonathan Bennett [00:01:33]:
It's hard to be humble when you're this great. No, there's a show title in there.
Ken McDonald [00:01:37]:
You're perfect in every way.
Jonathan Bennett [00:01:38]:
There's a show title in there. Let's workshop that. Anyway, Rob, we let you go first with the stories. Take it away.
Rob Campbell [00:01:46]:
All right. So imagine rebooting your virtualization host to load a new Linux kernel. And the virtual machines keep running through the whole thing. If you manage servers, you could probably already picture the maintenance window you'd like to get back. That's the idea behind Orphaned VMs, an experimental Linux patch series from Google engineer Pasha Titashin. The work aims to keep virtual machines executing while the host kernel goes offline for coordinated updates. The prototype has been tested on Intel, AMD, and ARM server hardware. The interesting part is how it works.
Rob Campbell [00:02:30]:
The system preserves the virtual machine's memory and essential state and keeps selected physical CPU cores running through the workloads. A small component called the caretaker handles certain operations that would normally require the host. To still be running. Meanwhile, other cores bring up the replacement kernel, which can then take back management once it's booted, or once the kernel's running again, the new kernel, or updated, or whatever it is. This uses a controlled kernel handover through kexec with the hardware remaining powered on. From an administration standpoint, the potential is huge. Think about everything surrounding a maintenance window, notifying users, coordinating schedules, moving workloads, and checking that services came back up correctly, at least in more of an enterprise environment. And maybe in your home lab if you're running things and your family doesn't want your network to go down.
Rob Campbell [00:03:32]:
But even when the update itself takes minutes, managing the disruption can become an entire project. My hope is that technology like this could make security updates easier to deploy promptly. When applying a kernel fix creates less disruption, there's less pressure to postpone it until the next convenient outage window. And if this eventually reaches everyday virtualization platforms, I'd love to see what it could do for smaller businesses or home labs running a single host. There are some significant catches. For example, keeping a VM CPU executing doesn't automatically mean its storage and networking remain functional. Operations that still depend on the missing host can stall, and host-dependent emulated devices are a known limitation of the current initial design. The developer also explicitly describes these patches as an early proof of concept, nowhere near production ready.
Rob Campbell [00:04:38]:
But this is exactly the kind of Linux development that gets my attention. Faster patching, fewer service interruptions, and potentially fewer evenings spent babysitting maintenance. So I'm happy to let the kernel developers do some incredibly complicated stuff if it's going to make my life easier and simpler.
Jonathan Bennett [00:05:03]:
Yeah, this is really fascinating, actually. There's like 2 layers to this, and you touched on this, but I want to dig into this more. There's 2 layers to this. One is, I guess, 3. Many things came to mind when you were talking about this. One is, yeah. One is when you do this, you're not going to be doing a full system boot the way that you normally do, because part of that is initializing your CPU and all those things. You're just switching out the kernel.
Jonathan Bennett [00:05:39]:
And then there's also like, this is just incredibly, it's impressive, but it's also like really hard to get this right because it's, you know, it's processor black magic really to get it to do this thing that you're asking it to do. You know, conceptually, if you sort of understand the way virtual machines work with the hardware extensions conceptually, it's like, yes, that should be possible, but there's a reason nobody has tried to do this before now. And then the other thing that you don't immediately think of that you called out is like, Does your network go down? Does your hard drive go down? Like how much of the stuff on the underlying machine that your VMs depend upon are going to go down when your kernel stops turning? And it's an incredibly challenging problem. But you can obviously understand anybody that's run VMs and had to do updates of the underlying system. You immediately understand why this would be huge for your data center or your home lab, whichever it is that you're running.
Rob Campbell [00:06:36]:
I know my home lab, Last time I rebooted, it was up for close to 600 days. So the host was, the clients had all been updated.
Jonathan Bennett [00:06:44]:
Right, right. So that's the other thing. If you're a fan of having huge uptimes, like I too am, you can have a virtual machine with a true, really, really high uptime. And yet the underlying system is up to date.
Ken McDonald [00:07:01]:
Yep. That's a lot of fun.
Jonathan Bennett [00:07:02]:
I look forward to this being testable.
Rob Campbell [00:07:03]:
I imagine passthrough maybe could solve some of those problems if they can't solve it other ways, but.
Ken McDonald [00:07:09]:
Yeah. Now, what kind of hardware is it going to require to run this on?
Jonathan Bennett [00:07:16]:
The article says that they've tested it on Intel, AMD, and ARM hardware. So I'm guessing it's basically anything that supports the virtualization hardware extensions. And so that's essentially a set of hardware extensions that lets you run your virtualized machine essentially on the bare metal. And then you just, you, it's extensions. So it's an API call that lets you talk to the CPU to control it as the hypervisor, which is how this whole thing works.
Rob Campbell [00:07:44]:
Yeah. And you pretty much need that for any, at least any type 1 hypervisor, maybe type 2. Type 2 probably doesn't.
Jonathan Bennett [00:07:51]:
I'm not sure. Yep. All right. Ken, what about Ubuntu? What's going on here? You've got a whole, you got a whole list of Ubuntu-related stuff. What's the deal with Ubuntu?
Rob Campbell [00:08:06]:
See you in a half hour.
Ken McDonald [00:08:07]:
Actually, the first 3 are all related. It's the 4th one that you may find interesting when I get to it. But this week, Bobby Barisal, Saurabh Rudra, and Joyce Sneddon all wrote about Canonical announcing it adopted a unified 2-week stable release update. They then go on to abbreviate that to SRU, but this is going to be the cycle for kernel updates, which will speed up patching, testing, and releasing fixes to users. According to Bobby, Canonical is replacing the current mix of 4-week regular kernel stable release update cycles and 2-week security cycles with a unified 2-week release process. Since those cycles overlap, Ubuntu will effectively receive a new kernel release every week. According to Joy, the reason for the change is the obvious one. Canonical describes the explosion in bugs and CVEs, driven largely by researchers using AI models and agents to uncover issues, as necessitating a new approach.
Ken McDonald [00:09:26]:
Which makes sense. Flaws are being found faster than ever, so patches have to follow suit. If not, users and companies who rely on Ubuntu are potentially left vulnerable to attack or exploit. According to Surov, each cycle starts with a week of patch integration and prep work. The kernel team selects which fixes land on each kernel. builds the packages, and runs basic smoke tests to catch anything obviously wrong before the build moves on. Canonical states while a patch is being prepared, they aim to provide safe workarounds where applicable, so users aren't left exposed in the meantime. Where no safe workaround exists, Canonical will say so clearly and point users toward general hardening steps instead.
Ken McDonald [00:10:18]:
The goal is to get environments into a defensible, safer state within 24 to 48 hours of public disclosure, well before patch ships. This doesn't replace the patch. It buys— excuse me— it buys the time needed to fix the vulnerability properly without sacrificing security. Now, more details about the new cycle is available in the articles by Bobby Joey and Saurabh. Now, the last link I have is to a post by Miso Ores. Excuse me there. About KDE Plasma. The desktop would start, flash for a second, then disappear.
Ken McDonald [00:11:07]:
Plasma Shell kept crashing in a loop. The article discusses what was happening in his system and how he diagnosed it. MISO also provided temporary and permanent solutions. Even if you don't use KDE, this article does demonstrate how to create a systemd drop-in that will survive updates, which I found interesting as I was implementing it on my system.
Jonathan Bennett [00:11:35]:
Yeah, I saw the 2-week cadence. I was actually a little confused because they're like, we are switching to a 2-week cadence. And it's going to have a 1-week cadence.
Ken McDonald [00:11:47]:
No, you've got 2 different kernels. One week, one, you start it on one kernel. Week 2, you start on the second kernel while they do the, uh, prepare it for shipping the one to the first one to ship. Then they switch to preparing the second one while, while they start on a new kernel. So yeah, it's 2 overlapping weeks.
Jonathan Bennett [00:12:14]:
Yeah, that makes sense. That makes sense. I mean, if you're running it and you want to update all the time, that sounds great. That's a lot of updates though.
Ken McDonald [00:12:24]:
Well, there's a lot of security patches coming too.
Jonathan Bennett [00:12:26]:
That's true.
Jeff Massie [00:12:27]:
They're almost hitting rolling release.
Rob Campbell [00:12:30]:
I mean, that's for features.
Ken McDonald [00:12:34]:
So security. This is for security basically.
Rob Campbell [00:12:36]:
Right. I mean, rolling release. releases is really more of a feature thing. Security updates, you should be able to get them whenever they're—
Ken McDonald [00:12:44]:
So for all intents and purposes, it's like, let's take 6.18 kernel, for example. You're going to have, it's going to be 6.18.1.2.3.4.5.
Rob Campbell [00:12:58]:
Yeah. Lots of dots.
Ken McDonald [00:13:00]:
.52.
Rob Campbell [00:13:02]:
Even Microsoft has had to do out-of-band patches lately. So.
Jonathan Bennett [00:13:09]:
I mean, it's true.
Ken McDonald [00:13:11]:
It's true.
Jonathan Bennett [00:13:11]:
Every time the AI models get better, it has changed the game when it comes to security research. You can find, they find so many things that people have just either overlooked or ignored for so long. And then suddenly you kind of have to fix it. And yeah, it's changing everything.
Rob Campbell [00:13:26]:
I'm always doing an apt update weekly anyway. Unfortunately, I guess this A kernel update requires a reboot.
Ken McDonald [00:13:32]:
So.
Jonathan Bennett [00:13:33]:
Yeah, unless you're doing something really fancy like live patching, which.
Rob Campbell [00:13:37]:
Yeah, Ubuntu has that. I think that's a pro feature.
Jonathan Bennett [00:13:39]:
I think it's a pro feature, yeah.
Jeff Massie [00:13:41]:
They have it, yep, pro.
Rob Campbell [00:13:42]:
Yeah.
Ken McDonald [00:13:43]:
Ubuntu Pro.
Jeff Massie [00:13:44]:
Yeah.
Jonathan Bennett [00:13:45]:
All right, well.
Ken McDonald [00:13:47]:
I have enabled on my system.
Jonathan Bennett [00:13:49]:
Yeah, because it's free for like the first 5 systems, right?
Ken McDonald [00:13:52]:
Yeah, and I've only got at the moment 3 systems. Yeah.
Jonathan Bennett [00:13:58]:
All right. Well, let's take a quick break. Got to pay the bills. And then we're going to go and talk about some more security vulnerabilities Jeff's going to tell us about right after this.
Jeff Massie [00:14:09]:
If you've ever used a tool that rebuilds your project the moment you hit save or a file manager that refreshes itself when something new appears, you've used inotify. It's been part of the Linux kernel since 2005. And it's one of those quietly useful features that nobody thinks about. inotify is a program that says, watch this directory and tell me when something happens. And the kernel sends it events, like a file was opened, read, changed, closed. You know, it keeps the kernel and other programs from having to poll a location, a file location, to see if anything has been updated. A team of 7 researchers at Graz University of Technology in Austria spent a long time asking a simple question. What can a program with no special privileges learn from those events? Their paper being presented this November at the ACM CCS, you know, one of the top security conferences, has an uncomfortable answer.
Jeff Massie [00:15:08]:
They tested Linux, Windows, macOS, and Android. And unfortunately, by their own assessment, Linux leads the most. leakage, we'll say. The root of the problem is one rule. If you can read the directory, you can put an inotify watch on it, and then you'll get events for files inside it, even if the files you aren't allowed to open. The researchers call this the unreadable file bypass. And on Linux, the most interesting unreadable file lives in /dev.
Ken McDonald [00:15:42]:
Oh, really?
Jeff Massie [00:15:44]:
Now, every input device on your system shows up as a file under /dev/input. Your normal user account can't read those files, which is exactly why keyloggers usually need to have root access, but anyone can watch them. So every time you press a key, the kernel touches that device file and inotify files off an event to whoever's listening. Now, I just want to make sure this is clear. It knows that you touched that file because you pressed a key. It does not know which key you pressed. So it only says a key was pressed, not which one. Now, here's where it starts getting funky.
Jeff Massie [00:16:29]:
The researchers had 6 people type a passage they'd never seen before. And when in their attack, they detected their keystrokes with an F1 score between 93.1% and 100%. Now, F1 is just a standard measurement of accuracy, and the events arrived about 9 milliseconds after each key press on average. So why does timing matter? Security research going back more than 2 decades has shown that the rhythm of your typing, the gaps between the keys, can help an attacker narrow down what you typed. So based on how you type it, they kind of can pretty accurately guess what you typed. Now, even if you're logged in over SSH, it works. The researchers had a user on the same server watch the device while someone else typed 402 keystrokes over SSH. The attack caught everyone with no false alarms.
Jeff Massie [00:17:31]:
So, i.e., 100% accuracy. There is a limit, though. Keystrokes that don't echo on the screen, like typing your password at a sudo prompt, don't trigger an event, so they stay hidden. So basically, here's a real-world example of not having the shadow characters show up for your sudo password. You know, I know we talked about it a while back and said, well, does that really matter? In this case, it actually does and adds more security by not having those shadow characters. Now, by watching which files a browser touches, the researchers could tell which of the top 100 websites somebody was visiting with almost 88% accuracy, even when that person was also browsing sites the attack had never seen. So top 100, they kind of have them fingerprinted a little bit, I think is what's going on here. And then They kind of knew where you were going.
Jeff Massie [00:18:29]:
Not the ones that were, you know, some weird site that they didn't have record of, but in the top 100, they knew. Now, do we panic? Well, not really. I mean, it's something to know about, but don't freak out. The researchers actually reported the findings in 2025, and Linux kernels patched in early 2026 stop inotify. from reporting the read and write events is on device files. That, if you really care, that device, that fix is tracked as CVE-2025-68788, and it kills the keyboard and SSH attacks. But, you know, the paper that I have a link in the show notes to says this only covers device files. All other files in your system are still susceptible.
Jeff Massie [00:19:20]:
Now, what they're proposing is that for the fix for this is the kernel should only let you watch files that you can actually, that you actually own or can actually read. Now, another kind of caveat here, every one of these attacks requires code already running on your machine. So either in another user account or a program you installed, or, you know, nobody's just doing this. Over the internet. They have to have already been in your system and put in this software or be watching all this. So it's recording this.
Ken McDonald [00:20:00]:
What should you do?
Jeff Massie [00:20:01]:
Right now, make sure your kernel version that you have compiled is from 2026 or newer. And I'm not going to list out all the kernels, but they backported it to a ton of kernels. So As long as you have something versioned from 2026 or newer, you know, from the start of the year, you're good. You know, and like anything, you know, make sure you're on a normal distro, you're careful about what you install, you know, i.e., don't take packages from shady places, you know. Don't take candy from strangers. All the safety stuff.
Jonathan Bennett [00:20:44]:
Yeah, I was just thinking AUR, npm. Yeah, there's a lot of shady places out there anymore.
Jeff Massie [00:20:50]:
I was gonna mention AUR and all that. Let's just say, you know, shady places, and that covers all the 3-letter acronyms out there. Basically though, take a look at the articles linked in the show notes for a lot more details. And there's a couple in there, so I haven't access to the various, uh, um, like file notification attack from the actual website itself and an article basically covering the, uh, research as well. So take a look. There's a lot more details in there. And like I said, just remember too, don't feel bad. It's Linux.
Jeff Massie [00:21:26]:
Linux has got this because all the other operating systems do too. We're not in this alone. This, this affects the entire pretty much the entire computer industry.
Jonathan Bennett [00:21:36]:
Yeah, it's so it's interesting. One of the things that I immediately questioned was like, what, like how much data do you get and how fine-grained? Because I know in that same /dev, you also have like your disk changes. When you move your mouse around, that also causes events. And it's like, are all those just the same event or no, no, no. It will tell you not only did a file— was a file changed, but this is a particular file that was changed. So yes, an attacker can pretty easily hone in on just the keyboard, making it a lot more effective.
Rob Campbell [00:22:07]:
I feel like the prediction model must somewhat rely on dictionary words and words that it knows. If you were typing random characters, I feel like it would be harder to predict just based off a typing pattern.
Jonathan Bennett [00:22:22]:
Yeah, I'm sure.
Rob Campbell [00:22:24]:
And then the other thing I wonder, if all these people that they they monitored or tested with, if they all type, you know, the formal, you know, home row with all your fingers, you know, I wonder if they all type that way because that seems like it'd be much more uniform. Whereas somebody, you know, some people are single finger. I know some people that might take 2 couple fingers from each hand or 3. You know, there's some, seems like a wide variety of hunting and pecking out there that It could throw some, I don't know. So maybe there is a reason to be a hunt and packer.
Jeff Massie [00:23:04]:
Hacking for security.
Rob Campbell [00:23:06]:
Hacking for security.
Ken McDonald [00:23:08]:
So Jonathan, just out of curiosity, what would you find by monitoring the /dev/dmaheap directory?
Jonathan Bennett [00:23:20]:
DMA is direct memory access. I'm not sure what exactly is in DMA heap. I have a feeling you're going somewhere though.
Ken McDonald [00:23:29]:
Always is.
Rob Campbell [00:23:30]:
What, what's the next story?
Ken McDonald [00:23:33]:
Nope, it has nothing to do with that. I'm just looking at all the directories that you have under /dev.
Jonathan Bennett [00:23:38]:
Oh, you listed out /dev. Yeah, it's all the devices. I'm not sure what exactly is in DMA heap, but it's going to have something to do with managing the parts of RAM that are under direct memory access.
Jeff Massie [00:23:48]:
I don't think you're going to get anything because it's going to just know that it was changed, not what changed. The reason the keyboard worked was because of the timing, the rhythm. When, if you listen to somebody type on a standard keyboard, most people using the home row and not typing with mittens or anything are going to have kind of a natural cadence. And if you have enough of that data, you can just go through and parse the— the timing to go, ah, that's what these keys are. Because if you're typing multiple letters with one hand versus going back and forth, you're going to have a different speed as you move your fingers around.
Ken McDonald [00:24:28]:
But I bet I know one that you might want to use iNotify with.
Jonathan Bennett [00:24:35]:
What's that?
Ken McDonald [00:24:37]:
dev/usb.
Jonathan Bennett [00:24:40]:
And I'm sure that that is exactly what the various desktop environments do to be able to give you a pop-up that you plugged in a new USB device. I'm sure that's exactly how they do it.
Jeff Massie [00:24:51]:
Oh, all right.
Jonathan Bennett [00:24:51]:
Let's actually talk about some Apple hardware, right? Rob, we've got some news on Asahi and the M4. Is that what this is? Not exactly?
Rob Campbell [00:25:04]:
Yes and no.
Jonathan Bennett [00:25:06]:
Surprise us. Tell us what's going on.
Rob Campbell [00:25:07]:
All right.
Ken McDonald [00:25:08]:
Maybe.
Rob Campbell [00:25:09]:
So I'm pretty sure we've talked about Asahi Linux's anti-AI stance before. And I remember thinking, or I feel like I would have said something or thought something. It seems to click in my mind. I don't remember exactly that, you know, shutting out these tools could become a big mistake. And eventually someone else is going to come along and use those tools responsibly and jump ahead of Asahi Linux? Well, meet Gravity Linux. So Asahi broadly prohibits generative AI and material contributions, citing ethical concerns and the risk of contaminating its clean room reverse engineering with proprietary information. Those concerns deserve attention. And I obviously, you know, disagree with making a blanket To try to solve that.
Rob Campbell [00:26:04]:
Gravity has released an early alpha for the M4 Mac Mini. So, Asai is not the only one in the game anymore. So running a Fedora-based KDE Plasma desktop on Wayland with working GPU acceleration and support for OpenGL 3.3 and OpenGL ES 3.0. Meanwhile, Asahi's recently announced M3 support still lacks full display controller and GPU support. On delivering an accelerated desktop for newer Apple hardware, Gravity has reached a significant milestone ahead of Asahi. And the connection to the AI policy is explicit. Gravity says it forked from Asahi over policy differences, particularly LLM use. Asahi's foundational work deserves credit here, though.
Rob Campbell [00:26:58]:
It helped make this possible and, you know, kick this whole thing off. Now, Gravity's release is an early developer alpha. Things like suspend, USB-C display output, and Thunderbolt aren't working yet. And shutdown and reboot can be unreliable. There's plenty left to prove. Before this becomes a dependable daily driver. But what I think we should all be able to get behind is Gravity's AI policy. Contributors remain responsible for delivering correct, maintainable code and demonstrating that it was developed through an acceptable clean room process.
Rob Campbell [00:27:42]:
Using AI excuses none of that. They must disclose AI's involvement, explain what information the model received and what human review occurred, and preserve records that maintainers can inspect. Gravity also prohibits feeding proprietary Apple implementation details into a model, asking it to disguise their origin. Starting a fresh chat doesn't erase that contamination. Their contributor guide reinforces the separation. People studying Apple's proprietary implementations produce carefully limited hardware documentation. Cleanroom developers build from permitted documentation and observations only. To me, this sounds like a responsible approach.
Rob Campbell [00:28:34]:
Use the tools, demand good code, and One alpha release can't establish how much Gravity's progress came from AI. But to me, this is exactly the competitive pressure I was kind of expecting to happen. Rejecting useful tools can carry a cost. So Gravity is showing another approach. I wonder if Asahi is paying attention.
Jonathan Bennett [00:29:07]:
So I have a little bit different perspective on this. This is something I was thinking about, and it's what you mentioned that they talked about, the clean room implementation. So here's my story. Meshtastic project, GPLv3. People want to use it in their closed source applications. And so they go to Claude or their favorite LLM and they say, give me a clean room implementation of the Meshtastic Protobufs. And then they come to us and they say, I have a clean room implementation of the Meshtastic Protobufs. And we say, oh, let's sign an NDA and we can take a look at that.
Jonathan Bennett [00:29:41]:
And without fail, we look, after we sign an NDA, we look in their files and the LLM will say, here's the clean room implementation of Meshtastic Protobufs. This value was taken from this file on this line. This value comes from meshtastic/source/this line. Obviously, the LLM is lying to them is essentially what's happening. Oh yes, I made a clean room implementation.
Rob Campbell [00:30:07]:
And no, it didn't.
Jonathan Bennett [00:30:08]:
It pulled up the files and just copied everything over. And that becomes pretty obvious when you know what you're looking for and you actually go and you look at it. So all that to say, that is a very real concern that using an LLM will break their true clean room implementation. And that That to me is actually a really compelling reason to have blocked LLM usage because that's something they care about very deeply in the Asahi project.
Rob Campbell [00:30:35]:
Right. And that's why their policy, you know, that you have to preserve that stuff and be willing to show them, you know, so they can look at your chat and stuff.
Jonathan Bennett [00:30:46]:
Show your work.
Rob Campbell [00:30:48]:
Just like school. Yep.
Ken McDonald [00:30:51]:
Thinking back to when the early IBM clones came out, I think what you had is you had, what, almost like 3 groups of people? One group that would go through, write a— not a script, but a list of things that you needed to have done.
Jonathan Bennett [00:31:13]:
Specifications.
Ken McDonald [00:31:14]:
And then you'd hand that to another party and they would implement that list of things in whatever way they thought seemed best. And then you had a third that would vet it.
Rob Campbell [00:31:28]:
Sounds right. Most of us can't think back that far, but yeah, they would—
Jeff Massie [00:31:32]:
well, they would have one that would use like, say, the BIOS and figure out everything the BIOS did, and then they would list that. And then the second group would just write out the specifications from that original group And then you're right, you'd have another group that would actually code it, not knowing the first step. And then yeah, it would get tested, but that way they would, but the thing was they had people doing it and coming up with it. AI being a pattern matching engine is gonna go, oh, I've seen this before. Here you go, here's the answer.
Ken McDonald [00:32:09]:
Yeah.
Jeff Massie [00:32:10]:
It's not gonna—
Ken McDonald [00:32:11]:
it's not clean.
Jeff Massie [00:32:13]:
No, because it's not thinking and coming up with new methods. It's simply regurgitating what it's already seen before.
Rob Campbell [00:32:23]:
Yeah, and to wrap that up, you know, like you said, Jonathan, there's definitely valid reason to block it, but I appreciate the, You know, the concentrated effort, you know, the attention to detail that Gravity folks are trying to make to allow the tools to be used while still being responsible.
Ken McDonald [00:32:50]:
Use LLM A, give me a list of tasks that the software accomplishes. LLM B, goes, okay, take these tasks, write a function to accomplish these.
Jonathan Bennett [00:33:09]:
Yeah, I've seen some attempts to be very careful and to do it that way. It's part of the deal is that we've not, like, as a sort of a universal legal system, or even in the United States, the US legal system, we don't really have any rulings on what an LLM does as far as copyright. That's still an unanswered question. Now, I've talked to a couple of lawyers about this, and they've all agreed with the idea that the genie is out of the bottle, and there's not enough will within the court system to put it back into the bottle.
Ken McDonald [00:33:46]:
It's public domain.
Jonathan Bennett [00:33:48]:
Well, it's not necessarily public domain, but just like the idea of— so one of the big questions with the LLM is, when you train it on copyrighted data, is the training transformative enough that it sort of breaks the copyright? It breaks you out from, you know, then you train it on copyrighted data. Is the result of that copyright? Does it inherit that copyright? So in the case of like the GPL, does it inherit the GPL license? And the working idea right now is that no, it does not inherit it because the LLM is transformative enough. It works in the same way that the human mind does. Obviously, when we read something copyrighted, our memory of that and our understanding of it is not copyrighted. We do not, we do, our brains do not become copyrighted, thankfully. The Free Software Foundation has a short story about essentially like a horror story with that as the concept, the right to read, I think they call it. But anyway, and so the theory is that when an LLM gets trained, you have the exact same transformation. But I don't think that's been tested in court.
Jonathan Bennett [00:34:56]:
And then there is also the question of the output of the LLM copyright, at least in the United States. Copyright only applies to things that are created by humans. So there was a really famous case where a photographer gave a camera to a monkey, a primate of some sort. The monkey took a picture, and then the photographer went to copyright the picture, and because reasons, It went to the court and the court said that picture was not created by a human. It is public domain by default. And so there's several different things sort of playing together here that are really interesting questions about the legal status of LLM output and copyright questions.
Ken McDonald [00:35:39]:
So if I take a photograph and I just draw a mustache showing it, is that transformative enough?
Jonathan Bennett [00:35:46]:
Probably not. But if you take a photograph and feed it into an LLM and ask the LLM to draw a mustache on it, then is it? I don't know.
Jeff Massie [00:35:58]:
Ask a lawyer.
Jonathan Bennett [00:35:58]:
I'm not a lawyer.
Rob Campbell [00:36:02]:
Anyway.
Ken McDonald [00:36:02]:
Take this photograph, use it, the photograph itself duplicated millions of times within the thing to create the same image.
Jeff Massie [00:36:14]:
Well, but see, then you get into the nuances of, was it lossless duplication or lossy duplication?
Rob Campbell [00:36:21]:
Well, you know, you've got to be lossy to be transformative. If you give AI an image and don't really put good guardrails around it and tell it to do something to that image, if that's like a picture of you, for example, all of a sudden, suddenly The picture doesn't really look like you, so it doesn't take thousands. Indeed.
Ken McDonald [00:36:43]:
How does that apply to videos? You remember that?
Jonathan Bennett [00:36:47]:
You remember that clip, the, the really cursed video of Will Smith trying to eat spaghetti? That's what— that's how it applies. All right, let's, let's move on to something else. And, uh, this one is, this one is interesting. You guys may have seen it. Uh, so Jeff Geerling put out a video about Raspberry Pi and swapping out RAM chips on it. And so this is a hack that ironically we covered on Hackaday years ago. You can take, so you can buy a 1 gig Raspberry Pi. And if you have nerves of steel and a lot of self-confidence, you can desolder the CPU and the RAM chip because they're stacked on top of each other on the way the Pi is built.
Jonathan Bennett [00:37:28]:
So the RAM chip sits directly on the PCB and then the CPU stacks on top of that. And you can actually take it apart and then put them back together with— that may not be true on all of them, but I think on some of them, that's the way it works. Anyway, 2 separate chips. That's the point here. They're 2 separate chips, CPU and RAM. You can desolder the RAM chip and replace it with a higher density RAM chip. So you can do like a self-upgrade of, you know, 1 gig up to 4 or 8 gigs. And for some people, that's really a win.
Jonathan Bennett [00:38:05]:
You may be able to get a higher capacity Raspberry Pi for a lot cheaper. Well, you can't do that anymore. And that's what Jeff Geerling was talking about, that Raspberry Pi has in their latest firmwares included a test for this and the Pi will fail to boot. It will detect that this is a 1 gig Pi and you have an 8 gig RAM chip on it and it fails to boot. And Jeff took the text of, and I don't blame him for this, I'm disappointed in Raspberry Pi. Obviously, they're doing this to force people to buy the higher RAM version, you know, to buy an 8 gig if they want an 8 gig. They're shutting out people doing their own fixes. And I watched that and I, you know, I'm like, yeah, I get it.
Jonathan Bennett [00:38:47]:
I bet there's a little bit more to it than that. I don't know yet what it is, but there's probably something else going on here. So that I would say, I would say do it like this. Go watch Jeff's video. Don't pause us. Hang on, don't pause us. Finish watching this episode of The Untitled Linux Show and then go watch Jeff's video. It's only like 7 or 8 minutes long.
Jonathan Bennett [00:39:07]:
And then go read the Hackaday article because it is yet another take on this and a bit more information that apparently some— I see a comment coming live from the chat. Rocko's Life that this is a weird, perverse attempt with a fig leaf of excuse about integrity. Um, actually what it is, is that it's an attempt to stop scalpers. Or at least this is what, um, this is what Aria over at Hackaday, uh, suspects. And I think it's probably a, a pretty valid, uh, a pretty valid call here. So if you go to places like Alibaba or, uh, let's see, what, what would be some of the other ones? Some of, some of these like gray area sales places and you buy an 8 gig Raspberry Pi. Well, historically, whoever it was that was the seller was actually buying the 1 gig and doing the swap for you in there, you know, out of the goodness of their heart, they were doing a RAM swap for you. And that's problematic for a couple of ways.
Jonathan Bennett [00:40:24]:
AliExpress. That was the other, that was the other sales place I was trying to think of. And apparently this happens on Amazon too, which does not surprise me. Amazon's not terribly trustworthy, um, when it comes to some of these things. Anyway, uh, they would buy a 1 gig Pi and they would do the swap and then they would get— they would sell it as an 8 gig Pi. But the, the, the 2 problems with that, one, they are pocketing the difference instead of Raspberry Pi guys. But 2, like, you don't know anything about the quality or the provenance of that RAM chip at that point. So like, it could be a knockoff chip.
Jonathan Bennett [00:41:02]:
It could be a factory second. Whereas if you buy it directly from Raspberry Pi, you kind of have an idea that it's a solid chip. So yeah, I think really the big reason for this was scalpers. And, you know, it kind of gets into that gray market and the idea of, you know, not entirely legitimate hardware. I do also agree with the callout that it would have been really nice if the Raspberry Pi Foundation had like done this publicly and, you know, put out a statement or at least put it in the release notes for the firmware version that, hey, we're making this change and this is why. But if you want to do this, if you want to hack your Raspberry Pi and put 8 or 16 gigs of RAM on it, you can still do it. You just have to roll back your bootloader, the code there. There's no lock on it.
Jonathan Bennett [00:41:53]:
You can roll back to previous versions. And so it's actually pretty easy to make this happen still. But what's really, really hard now is for a scalper to do this without telling anybody, being able to totally hide it. So I, yeah, I agree with Aria's take on Hackaday. I can't bring myself to be terribly mad over this. Just, it could have been handled just a tiny bit better on the Raspberry Pi side with the communication around it. So hopefully, hopefully we can put the pitchforks down.
Jeff Massie [00:42:21]:
And I could even see technical reasons if they hadn't set up for different memory sizes. I mean, there's—
Jonathan Bennett [00:42:29]:
That was actually, Jeff, that was the thing that I was immediately thinking of when I watched Jeff's video. I'm like, I know how much problem I've had trying to swap RAM on a laptop. Like one of my, I think it's the Framework 13 that sits outside my My wife's laptop, actually. I tried to do a RAM upgrade on it and it would not boot with the new RAM. It was even RAM that was on the list as being approved and it would not boot with the new RAM. And I finally ended up swapping back to the old RAM. And so my immediate thought was, I wonder if they were just having technical problems because of this. And so they wanted to avoid all of that heartache.
Jeff Massie [00:43:05]:
Yeah. And a couple of things too is like, all right, you swap that RAM. It's never as good a connection as the very first fresh chip going on. When you redo those solder balls, it just— there's, there's a little oxidation. It's little— it's just not quite as good. The other thing is, so people know, there are tiers of memory. So if you've got RAM that you're going to stick in this can-never-go-down server, You're paying premium prices, but that is the super tested, highest quality, guaranteed good memory. If you're gonna have RAM all the way down to like, oh, this is just a junk little toy.
Jeff Massie [00:43:50]:
It needs to last like maybe 12 hours and then we don't care. Yeah, there's some of that that gets binned way down and they sell it really cheap because Yeah, we know it's got problems. It's not guaranteed. You don't run this in anything important. And there's multiple tiers. So depending on your price point and the application you're going to use, those chips get binned differently. And yeah, the very bottom ones are pretty cheap because they're kind of crappy.
Jonathan Bennett [00:44:23]:
Yep, absolutely. Uh, it kind of reminds me of the other thing that happens with Chinese factories sometimes. Not, not Not every company in China, not every factory, but in some of them, what will happen is, you know, they have the day shift that goes in and makes the official product under the brand name. Then those guys pack it up and go home. And somebody forgets to lock the factory. And then the night shift come in and they make the knockoff version of it, different brand name, sell it for half the price on the same factory hardware. And that just happens at night. And then they clean up and they gather their stuff and they leave.
Jonathan Bennett [00:44:55]:
And then the day shift comes back in. Apparently that happens quite a bit, and that's why you see so much almost identical knockoff stuff on, unfortunately, on places like Amazon. Um, well, anyway, I don't want to get— I don't want to get into that any further.
Jeff Massie [00:45:09]:
Oh, I was going to say, also, also, they'll take, uh, chips that maybe failed qualification. They're, they're only partially functioning, and they go into the recycle barrel. Well, they You can run them through the laser scribe and go, oh, see, look, we'll put these marks on them. And then you can actually program them to say, oh yeah, we only have 4 gigs of this chip working. We're going to say it's marked as an 8 gig and program it to be an 8 gig, which it's kind of like the SSD stuff where, yeah, you won't see a problem until you try to use that piece of memory that either doesn't work or isn't there.
Jonathan Bennett [00:45:48]:
You also have, um, like AMD used to do this a lot, and I'm sure, I'm sure every CPU manufacturer does this to some extent. And this is not a sketchy thing to do, but it's just similar. Um, if you have, you have an 8-core CPU but some of the cores don't validate, you turn them off and suddenly you've got a 6-core CPU or a 4-core CPU. And, uh, you know, they sell it, they sell it for cheaper because the, the alternative— if you do it that way, it's a, it's a valid CPU, but the alternative was just throw it in the trash. So there's a lot of that kind kind of binning and recycling that goes on.
Jeff Massie [00:46:16]:
And memory is the same way. Your 8-gig part, they might blow fuses in there. And there's special fuses inside every memory chip that they blow and go, okay, we know the 4-gig is good. So we're just going to call it, sell it as a 4-gig chip at a reduced tier.
Jonathan Bennett [00:46:33]:
Interesting. I did not know that that was possible with memory. That's very cool.
Ken McDonald [00:46:37]:
Yeah.
Jeff Massie [00:46:37]:
There's all sorts of redundancy built in and So that, because why, why scrap an entire chip when you can go kind of like, like this CPUs, right? All right. We're just going to blow fuses on a couple of cores that are broken.
Jonathan Bennett [00:46:51]:
All right.
Jeff Massie [00:46:52]:
We sell it as a reduced core chip. We still get some value out of the chip.
Ken McDonald [00:46:58]:
Yeah. You know, it's funny that it's coming out now when we're experiencing this increase in the price of RAM instead of What was it, about 2 years ago when they actually started doing this?
Jonathan Bennett [00:47:08]:
And I think, I think it's probably, that's probably why it's coming out now is that, that people were, you know, they, they have suddenly the need to try to do this and the Raspberry Pi price has gone up so much.
Jeff Massie [00:47:19]:
And so people were trying to try to do it, but this stuff has been going on for decades.
Ken McDonald [00:47:25]:
And I got a feeling it's less hobbyists and more resellers that are Trying to make a bit more profit.
Jonathan Bennett [00:47:33]:
Well, that's actually, that's something the Hackaday article, there are links to GitHub issues where people bought new, new air quotes, new Raspberry Pis. And they were failing to boot with exactly these errors. And that's exactly what it was. It was shady resellers that were doing the work and selling them as new, higher memory Pis.
Ken McDonald [00:47:58]:
And for more money. Oh, of course, of course. And not sharing it with the Raspberry Pi Foundation.
Jeff Massie [00:48:04]:
Well, and keep in mind, this is surface mount chips. So this is not just, oh, I got a wire and I use my soldering iron and I put it in. You need to know how to ball a surface mount chip and get the solder flowing.
Jonathan Bennett [00:48:20]:
It's definitely beyond my soldering levels. I'll tell you that.
Ken McDonald [00:48:24]:
I don't think you want me trying it now.
Jonathan Bennett [00:48:28]:
I can solder, but I have also tried soldering and blown up capacitors before. That's always real fun. Like, I'm going to desolder this thing to see what's in it. Let me use my heat gun to get into it. Surely that capacitor there will be fine. Boom. Yeah. All right.
Jonathan Bennett [00:48:46]:
Anyway, let's actually take a quick break so I can recover from blowing up that capacitor. And we're gonna talk some more about the Raspberry Pi. Actually, we're gonna let Ken dive into a slightly different topic on it. Don't go anywhere. We'll be right back.
Ken McDonald [00:49:03]:
Well, we've got an update, updated look for the Raspberry Pi desktop. Last week, Bobby Borisov, Simon Long, and Marcus Nestor wrote about the Raspberry Pi Foundation publishing a new version of its Debian-based Raspberry Pi OS. Based on Debian 13 Trixie and powered by the long-term supported Linux 6.18 LTS kernel series, the new Raspberry Pi OS release introduces dock support to the Wayland panel, along with new icon menu and icon task list plugins And a widgets panel in Control Center to let you enable the configuration of the dock and taskbar. According to Simon, these new features are entirely, entirely optional unless you choose to enable them. Your desktop will continue to look and feel exactly the way it always has. These are purely intended to give users who want a more up-to-date desktop experience the option to have one if they want it. Bobby, Simon, and Marcus agree that the biggest change is the introduction of an icon dock, which can replace the existing taskbar or be used alongside it. 2 new widgets have been added to the dock.
Ken McDonald [00:50:27]:
One is a graphical application launcher, and the other is an icon-based combined quick launcher and task list. Notifications have been moved to their own Control Center panel, replacing the previous WF Panel Pi dialog. Plus, a new Shortcuts panel lets users view and configure system keyboard shortcuts. According to Markus, the new Raspberry Pi OS also introduces a brand new screenshot tool, a new monolithic build of the file manager that integrates PCManFM and LibFM into one application, and switchable auto-mounting of external drives to the ejector plugin, since PCManFM no longer auto-mounts them by default. If you want all the details on the new Raspberry Pi OS, I recommend reading Bobby Simon And Marcus's articles.
Jonathan Bennett [00:51:33]:
A lot of new stuff in there. Is there anything in particular that you're looking forward to? Now, actually, before I ask you that, Ken, do you actually run any Raspberry Pis as like desktop computers?
Ken McDonald [00:51:43]:
As desktop computers? Not at the moment. I've got the Raspberry Pi 5 that I've got set up as a... Kodi, um, basically interface and hanging off of, uh, one of the TVs in the house. And I've got to go see if it'll, uh, access the Jellyfin, uh, that I'm running in a VM at the moment. I haven't done that in a while.
Jonathan Bennett [00:52:17]:
Yeah.
Ken McDonald [00:52:17]:
And then the Raspberry Pi 4 is just, uh, I'm using it as an OctoPi still. I think it's time to update it again.
Rob Campbell [00:52:28]:
Every week. Yep.
Jonathan Bennett [00:52:31]:
You know, I remember when the Raspberry Pi Control Center was like really, really minimal and hardly anything there. And they keep adding things to it. And it's actually pretty cool that there's now so much in there. You have so much control you have over it. And yeah, I kind of like it. I kind of like what they've done. I'm not usually a big XFCE fan. It's usually a little too minimal for me, but it really works fairly well on the Pi.
Jonathan Bennett [00:53:00]:
Right? Isn't it XFCE-based? No, LXDE.
Ken McDonald [00:53:03]:
I was going to say, I thought it was LXDE.
Jonathan Bennett [00:53:07]:
I remembered wrong. Imagine that.
Rob Campbell [00:53:09]:
I am jet-lagged.
Jonathan Bennett [00:53:12]:
That's my excuse and I'm sticking to it. Yeah, I'll have to pull this release down though, particularly on my Raspberry Pi laptop. That one's going to be the one that'll probably, it'll be the coolest to test out on.
Ken McDonald [00:53:26]:
Think we can run KDE on Raspberry Pi yet?
Jonathan Bennett [00:53:29]:
Well, that's really what I'm interested in. And, you know, we talk about KDE being so lightweight. Jeff has a story here about KDE. I'm going to turn it over to him and then I'm going to check my network connection because I feel like I might be the one breaking up here, but we're going to let Jeff take over and talk about KDE for a bit.
Jeff Massie [00:53:52]:
Yeah, this is a little bit of a ripple in the force, so to speak. So on September 23rd, Nate Graham published a post titled KDE and AI and You and Me. And it opens like this. So I accidentally triggered an online shipstorm. Not the word he used, but I'm editing that for the kids. In the process of trying to craft a set of more restrictive LLM usage guidelines for KDE. Now, the keyword here is restrictive. The problem Graham was trying to solve is the same that almost every other open source project has.
Jeff Massie [00:54:30]:
People are feeding AI chatbots bug reports, pasting whatever comes out into a merge request, and leaving a volunteer maintainer to figure out whether any of it even works. You know, this is the same thing we've talked about for a while now, and various projects have handled it differently. But as Graham put it bluntly, LLMs lower the barrier to enter for people who have no idea what they're doing to basically DDoS FOSS, you know, free open source software maintainers with a tidal wave of crap. Now, The reason I'm doing this story is that this took on a life of its own. And, you know, I thought I should put what really happened out there. So it kind of does it a little justice. So on September 19th, Nate Graham opened a draft policy for discussion on the KDE Invent, the project's GitLab server. And its golden rule was don't be lazy.
Jeff Massie [00:55:33]:
Don't use a tool to replace your own judgment, your own communication or your learning. Don't submit code you don't understand and couldn't have written yourself. The idea was that AI-assisted code should be indistinguishable from what your normal work looks like, and maintainers would have a clear cover to close AI slop without anybody arguing about it. So if you got crap code, see ya, we're not dealing with it. You know, and like I said, this is a stance like a lot of projects are taking now. You can use AI, you know, in general, a lot of them say you can use AI, but you better know what it does. You better understand the code. You can't just throw whatever out there and have no idea what's going on.
Jeff Massie [00:56:15]:
Now, Graham also argued against requiring contributors to label AI-assisted code. His reasoning was that the disclosure tags are basically, and in quote, just free advertising for the LLM provident. And at the same time, something else was building. So now KDE's annual Academy conference had accepted a talk called A Lovable Sovereign AI Native KDE. And it closed with the line, the question is not whether AI, it is how. You should choose how much AI and which. Now, Nate says it came from 2 people who are important to KDE in decades past but hadn't contributed recently. It got what he calls a fairly chilly reception.
Jeff Massie [00:57:03]:
But online, a lot of people read AI-native KDE as KDE's official direction, which it very much was not. It was a discussion, a thought. It was not a solid direction or a path forward. Well, you put those 2 things together and you can guess what happened. Hilarity ensued. Nearly 50 people weighed in on the draft over just a few days. Some thought it was a reasonable line in the sand. Others thought any policy that allows AI gives it KDE's blessing.
Jeff Massie [00:57:42]:
KDE developer Soon Virola called the proposal a giant insult to KDE's eco, the earth copyright and code reviewers, you know, pointing to the energy use of AI data centers. Another contributor, Hadi Choker, argued the opposite. The genie's out of the bottle and a ban would only punish the people with, you know, honest enough to follow it. And then it really went off the rails. So that's kind of where it started. Now we derailed the whole train. 2 people with no clear connection to KDE started fighting about the morality of AI in general. You know, one dug up the other's old social media posts.
Jeff Massie [00:58:29]:
You know how these online discussions quickly turn into dumpster fires. Comments were then locked to KDE developers and both people were banned and the thread eventually was taken down. Meanwhile, an outside campaign called KDE for the People started demanding a complete ban on generative AI. And the Register reports it collected about 250 signatures before it closed. Now, Nate's post is kind of equal parts apology and just exasperation. He says a bunch of people, mostly outside of KDE, who disapprove of LLM usage derailed KDE's attempt to add restrictions to LLM usage. You know, he does mention the downside of AI. He lists the stolen training data, murky licensing, electrical strain, and hardware shortages.
Jeff Massie [00:59:26]:
And his analogy, it's like the 100 billion toaster-sized nuclear reactors dropped from the sky one day. You know, 2026, the year the nuclear toasters took over. So where does KDE stand now? Yeah, right now, nowhere. As of this week, it's adopted neither Graham's draft nor a ban, and a revised draft is still expected. I think they're just kind of waiting for the smoke and the flames to die down a little bit. Future discussions will likely be limited to actual KDE contributors. And, you know, for what it's worth, the 3 official goals KDE picked after the Academy are enterprise deployments, better documentation, and next-generation styling. Nothing involving AI.
Jeff Massie [01:00:14]:
And like I said earlier, that AI topic was just a topic, a discussion, a thought exercise. That's all it was. Not a direction, not an initiative, no promise of anything. Graham's own summary is, I don't know what to do, and that's scary. If the people building your desktop feel that way, you're in good company. So take a look at the articles linked in the show notes for more details and more information on the ship storm that happened.
Rob Campbell [01:00:48]:
I've seen a petition online. Somebody was, uh—
Jonathan Bennett [01:00:52]:
Of course, of course there's a petition online.
Rob Campbell [01:00:53]:
Hey, sign our petition to ban AI and KDE. I said, Where do I find the other petition?
Jeff Massie [01:01:02]:
Yeah, that was that.
Ken McDonald [01:01:05]:
At the page you started it on.
Jonathan Bennett [01:01:09]:
No, let's not do that. That does not feel like that would make the situation better.
Jeff Massie [01:01:13]:
Yeah, that was the KDE for People movement that they were trying to start when it was like, we're going forward on this initiative. We want this. But nobody actually ever said that's what they were doing. Yeah, a lot of go with no direction.
Ken McDonald [01:01:32]:
Let's hope nobody reverses things and goes with EDK for AI. EDK.
Jeff Massie [01:01:40]:
It only runs on 11x.
Rob Campbell [01:01:46]:
My goodness.
Jonathan Bennett [01:01:47]:
Surrounded by clowns.
Ken McDonald [01:01:50]:
Uh, yeah, just now realizing that.
Jonathan Bennett [01:01:52]:
No, just reminded of it. Um, I, I am sort of disappointed in the internet, I guess. Um, I, I, I think one thing that really sticks out to me here is that, uh, I think Nate took the wrong, the wrong tact here by trying to apologize and trying to defend himself at all. I think, I think when you're, when you're faced with this sort of insanity Not people within KDE that have opinions, those you listen to. But when you're faced with the insanity of the brigading from people outside, the thing to do is just ignore them and do what you feel you need to do.
Ken McDonald [01:02:27]:
Or turn it into a streaming game.
Jonathan Bennett [01:02:30]:
Yeah, I guess.
Jeff Massie [01:02:31]:
No, I think they should have early on just locked it down to only developers that actually contribute. And even at the discussion, maybe reiterate, this is You know, you're talking about 2 separate things. You're confusing them. And this is, you know, explain what the differences are. Yeah.
Ken McDonald [01:02:56]:
We started off by whitelisting who can provide input into it. Yeah.
Jonathan Bennett [01:03:01]:
Yeah.
Jeff Massie [01:03:01]:
That's the blocking of KDE developers.
Jonathan Bennett [01:03:03]:
Move the thing off the public mailing list and talk about it internally and then come to a decision. Announce the decision and then batten down the hatches. People are going to be mad no matter what you say. Just running an open source project, you just kind of have to be prepared for people to be ticked off at you. That's just the way it works anymore. Because the internet's a terrible place and there are terrible people there and everybody has an opinion. And they think their opinion is very special and you should listen to it. And not everybody is right.
Ken McDonald [01:03:33]:
Yeah, I agree with all of those statements. Yeah.
Rob Campbell [01:03:37]:
Yeah. It's been that way for a long time, so it's, uh, yeah.
Jonathan Bennett [01:03:39]:
And, and then it's a little too late to be disappointed.
Jeff Massie [01:03:42]:
I, I was gonna say, I was, I was disappointed in the early '90s.
Ken McDonald [01:03:46]:
Yeah. Uh, oh, you should have been around in the '80s.
Rob Campbell [01:03:51]:
He was.
Jeff Massie [01:03:52]:
I, I was, but I was on, uh, you know, um, uh, he wasn't disappointed then. FidoNet. I wasn't on the internet. I was on like BBS servers and FidoNet and that kind of stuff. I didn't hit the actual internet until early '90s. Yep.
Ken McDonald [01:04:08]:
Now, the problem is, is opinions have been around as long as humans have. Yeah.
Rob Campbell [01:04:15]:
So let's talk about some more opinions.
Jonathan Bennett [01:04:17]:
I mean, that's all we got. It's all we got is opinions, really.
Ken McDonald [01:04:21]:
So Rob, what's your opinion on Valve?
Jonathan Bennett [01:04:24]:
That's a good question.
Rob Campbell [01:04:26]:
They are awesome. And I like the idea of having one powerful gaming PC and being able to play from another room. You know, leave the big machine at a desk, sit somewhere comfortably, and stream the game to any lower or lesser powered device I want. The challenge is making it feel like you're actually sitting at the gaming PC. Valve's latest Steam beta introduces an experimental video codec called Pyrowave, designed to reduce the delay in Steam Remote Play. I know I haven't tried Steam Remote Play in a long time, but it wasn't a good experience for me. I mean, it's been many years, but I'll have to try it again. Anyway, when you stream a game, your computer has to render each frame, compress it, send it across the network, and have the receiving device decode and display it.
Rob Campbell [01:05:23]:
Every step takes time. A beautiful picture becomes considerably less impressive when your character reacts noticeably after you press the button. Pyrowave tackles the encoding and decoding part with a design built for speed developed by Hans Christian Arsen. It uses Vulkan compute shaders and compresses each frame independently. Its implementation is also open source under the MIT license. It's very open. There is a trade-off, and it's a pretty substantial one, and that is bandwidth. Valve says PyroWave uses 5 to 10 times the bandwidth of other streaming codecs.
Rob Campbell [01:06:12]:
It recommends connecting the computer over wired gigabit Ethernet or better, which isn't going to help me with the, the Frames that I haven't ordered yet, the Valve Steam Frames. For streaming across your own house, I think, I think that's an interesting bargain though. If the network has capacity sitting around unused, which most of them do, spending more of it to make a game feel more responsive sounds worthwhile to me. Imagine leaving your gaming tower in the office and using a compatible computer connected to the living room television. Improvements like this could make that arrangement much more appealing and reduce the temptation to build another expensive gaming system. There are image quality options too. Pyrowave supports HDR. Jonathan, you like that one?
Jonathan Bennett [01:07:07]:
Mm-hmm.
Rob Campbell [01:07:08]:
When both ends support it, at least, plus optional 4:4:4 color, which can help preserve fine color detail and make desktop text cleaner. It's available in the Steam beta on Windows and macOS. Linux users also need to use the experimental Steam RT3 client, have that enabled. Pyrowave itself is an opt-in setting under Remote Play's advanced client options. And Valve cautions that whether it helps depends on your particular setup. And that's what I like to test, you know, how it actually feels when playing. If a software update can make the gaming hardware I already own more enjoyable to use in this house, you know, that's a Steam feature. Another Steam feature, because it's just one after another.
Rob Campbell [01:08:01]:
It's another one I'd be excited Yeah.
Jonathan Bennett [01:08:06]:
So one of the things that intrigues me is that it's not made for low bandwidth. It's LAN only, high bandwidth. So I'm guessing low latency and high quality is really what they're looking for. Maybe a low CPU usage on the decoding too.
Rob Campbell [01:08:20]:
You know, I didn't say anything about latency. You know, really today with fiber usage, you know, a 1 gig home network isn't a whole lot different than a 1 gig internet connection if you got it on both ends. But the latency might be a problem.
Ken McDonald [01:08:33]:
1 gig to your home or within your home?
Jonathan Bennett [01:08:36]:
That's pretty much what he just said.
Rob Campbell [01:08:38]:
Yeah, I've got both.
Jonathan Bennett [01:08:42]:
High bandwidth, low latency video codec. Yeah, so that's what they're going for is the ability to be able to encode and decode those frames very quickly. Yeah, very cool. Now, I wonder if they took patents into consideration. Are we going to get, you know, a a statement here in the next few days from MPEG-LA that, uh, we're rolling out our, our, uh, what are they, our licensing program for Pyrowave. We'll sue you if you don't buy in. That's the sort of thing that, that particular group of sharks would do. Is it open source?
Jeff Massie [01:09:16]:
I'm glad I upgraded to 2.5 gig.
Ken McDonald [01:09:19]:
Cool.
Rob Campbell [01:09:20]:
MIT licensed.
Jonathan Bennett [01:09:21]:
Yeah, 2.5 gig is great. I've got it on... Technically from the ONT to the server and then from the server to the one desktop, I've got 2.5 gig.
Rob Campbell [01:09:33]:
Well, now I'm going to have to one-up you and go upgrade myself.
Jonathan Bennett [01:09:37]:
Yeah, go to 5 gig.
Jeff Massie [01:09:38]:
Well, actually, it's pretty cheap. When I bought the switches, not too bad. 2.5 gig is nothing these days.
Rob Campbell [01:09:46]:
Yeah, I can't match you though. I got to one-up you. So I got to go to 10 gig.
Jonathan Bennett [01:09:52]:
I must beat you.
Rob Campbell [01:09:53]:
I'm gonna have fiber in my house on my LAN side.
Jonathan Bennett [01:09:57]:
Nice.
Jeff Massie [01:09:57]:
Well, you already beat me on the incoming. I got 1 gig down and like 50 megabytes up.
Rob Campbell [01:10:01]:
And that's the important thing anyways.
Jonathan Bennett [01:10:03]:
True, true.
Ken McDonald [01:10:05]:
Is it down or up?
Jonathan Bennett [01:10:08]:
Both, really. That's what you want. All right, actually, we're going to take a quick break and then we're going to come back and talk about a couple of graphical things, maybe watch some videos, do some benchmarking, but don't go anywhere. It'll be fun. We'll be right back right after this. Ken is going to tell us all about VLC and what is new there.
Ken McDonald [01:10:30]:
Yes, I am, because last week, Bobby Borisov reported on the release of the popular open-source multimedia player VLC version 3.0.10. 24-RC1 titled Veterin— Veterinary. Now following that, Markus Nester announced the official release of VLC version 3.0.24 this week. Now this update brings significant improvements, including a major upgrade to FFmpeg Support for Flatpak builds, enhanced compatibility with Qt 6, and a long list of improvements for playback and streaming. One of the most notable changes in VLC 3.0.24 is a transition from FFmpeg version 4.4 to 8.1.2, which significantly enhances decoding performance and resolves playback issues across various formats. Another important addition for Linux users is the inclusion of Flatpak build support in VLC. Additionally, codec support has expanded to include decoding for ATRAC-3 and ATRAC-9 audio formats. MP4 files will now support CEA-708 Closed captions.
Ken McDonald [01:12:06]:
According to the changelog, VLC version 3.0.24 also addresses over 130— count them, 130— security vulnerabilities in VLC and its bundled libraries, including fixes for out-of-bounds access, integer overflows, double freeze, And use-after-free bugs. For more information, you can read the articles I have linked in the show notes by Bobby and Marcus. It was an interesting 2 weeks there because I come across the, uh, release, uh, the RC1 last week and started writing up my notes for last week's episode. Then wasn't able to make it. So when I looked back, I saw this week, Marcus had released a similar article about it actually coming out completely. So Jonathan, how long do you think it'll be before Ubuntu 26.04 has it?
Jonathan Bennett [01:13:16]:
No clue. I don't even know how, I don't even know if they will grab it. I would assume so because there's security fixes in there, but Not until the next one.
Ken McDonald [01:13:29]:
Hopefully it'll be in 2610.
Jeff Massie [01:13:32]:
It almost sounded like for a moment you said they added decoding for 8-track. And I was like, what?
Jonathan Bennett [01:13:40]:
That would be cool.
Ken McDonald [01:13:43]:
Yeah.
Jonathan Bennett [01:13:46]:
It's also interesting that they killed HEVC for Chromecasts. That seems like something that they could have kept around for a long time. But maybe Google has pulled the plug on that one, and that's why they disabled it.
Ken McDonald [01:13:58]:
Why support something that Google's not supporting?
Jonathan Bennett [01:14:03]:
Isn't that like the MO of open source, is to continue supporting things even after the closed source stuff doesn't?
Jeff Massie [01:14:09]:
We run it till they go, I don't know, I don't think anybody has this hardware. Can somebody test the code?
Jonathan Bennett [01:14:14]:
And you just hear crickets and you go, okay, it's time to pull it now.
Jeff Massie [01:14:17]:
Time to pull it.
Jonathan Bennett [01:14:19]:
Yep.
Jeff Massie [01:14:19]:
Or we will mark it for pulling and then we'll have 3 more releases before we actually fully remove the code.
Ken McDonald [01:14:26]:
Well, how long has it been in VLC?
Jonathan Bennett [01:14:31]:
That I don't know. I just know that it's cool that it works. We've used that a few times.
Rob Campbell [01:14:37]:
Ken, you're the VLC aficionado who seems to know everything about it. Why don't you tell us?
Ken McDonald [01:14:43]:
Since version 23.
Rob Campbell [01:14:49]:
3.0.23. I just use it. I don't know.
Ken McDonald [01:14:50]:
I love it. It's been several years. Yeah.
Rob Campbell [01:14:56]:
Oh, goodness.
Jonathan Bennett [01:14:58]:
He did know the answer to the question.
Ken McDonald [01:15:01]:
Yeah.
Rob Campbell [01:15:03]:
I'm not going to understand the details of it unless it's something really cool.
Jonathan Bennett [01:15:07]:
Don't bring me details. I don't want your details. I just want to have fun.
Rob Campbell [01:15:10]:
It plays a video.
Jonathan Bennett [01:15:13]:
All right, Jeff, tell us about spec. Let's get into some benchmarking.
Jeff Massie [01:15:19]:
Oh yeah, you know me, test that hardware. Now, if you've ever shopped for a graphics card, especially at the professional level, or read a workstation review, you've probably seen a chart labeled SPECviewperf. It's been one of the industry standard yardstick for professional 3D graphics for decades. run by SPEC, S-P-E-C, the nonprofit best known for its CPU benchmarks. On September 22nd, SPEC released SPECviewperf 15.0.1 Linux Edition, bringing the current version to Linux. Now, first, what does it actually measure? There's a reason I said professional, because it doesn't measure gaming. SPECviewperf measures Viewport performance, like how smoothly your GPU can spin, zoom, and redraw a huge 3D model inside an application like SolidWorks or Maya. If you're an engineer rotating a jet engine assembly with thousands of parts, that's the number you care about.
Jeff Massie [01:16:24]:
The cool thing is you don't need to have the actual applications installed. Each test, which SPEC calls a viewset, reproduces the graphic workloads of real professional programs. So you can see how a card handles CATIA without paying for a CATIA license and, and so on. Now the Linux edition ships with 8 of these workloads covering CAD, content creation, engineering, energy, and medical visualization. These represent apps including CATIA, Creo, Maya, SolidWorks, Siemens NX, And new in this release, Blender. Now it officially supports Ubuntu 24.04, Red Hat Enterprise Linux 10, Rocky Linux 10, and Fedora 43. And it's free for end users. Now, if a hardware vendor who wants to use it in their marketing, excuse me, that's when you have to pay $2,500.
Jeff Massie [01:17:23]:
Now, 2 things make this release more than just a routine update. First is ARM. For the first time, ARM-based Linux workstations can be tested with exactly the same workloads and scoring as the x86 machines. Right now, that support is Ubuntu 24.04 only, but with ARM workstations starting to show up and, you know, now you can have more of an apples-to-apples comparison. So you can truly figure out what your hardware can and can't do. Now the second is usability. Anybody who used the older versions will remember it had a lot of setup friction. This one adds a graphical interface and results manager to keep track of runs in a modular snap-in design.
Jeff Massie [01:18:09]:
So you can just download and run the workloads you care about instead of the whole suite. You know, maybe you don't use medical visualization, Well, you don't need to install it. You don't need to download it. Just do the ones that you care about. Now, why should Linux users care about a benchmark? Well, remember how we talk about the year of the Linux desktop and it never comes and we say, well, Linux runs on the rest of the world besides the desktop? Well, that's why. Professional graphics is, for example, one of the places Linux quietly dominates. According to the VFX Reference Platform's 2024 survey of 67 visual effects and animation studios, cited by John Petty Research, more than half of the artists in every single studio group use Linux workstations as their primary machine. So if you've watched a big-budget movie lately, there's a good chance the effects were built on Linux.
Jeff Massie [01:19:09]:
And these studios, and this is just an example, this applies to other forms of engineering and medical research, all that. They need a fair way to compare, you know, NVIDIA, AMD, Intel, and drivers on the OS they actually use. Now, there is one catch, one blemish on this. The Linux edition is OpenGL only. So SPECperf15 came out for Windows back in May of 2025. And that version added tests using DirectX 12 and Vulkan. And now it also included the workloads based on Blender and Unreal Engine 5. So Linux got the benchmark about 16 months later without the modern graphics API.
Jeff Massie [01:19:59]:
So basically, the John Petty Research says it simply, of the open, the GL OpenGL-only suite is the limitation to watch because we know OpenGL and Vulkan, they handle speed a little differently. So as, as the industry moves towards Vulkan, hopefully then we will, uh, get an update so we get the Vulkan backend also added to the SPEC benchmark. Now still though, I mean Linux workstations are on the same scoreboard as everybody else, and ARM machines got a seat at the table now. So like I said, hopefully we don't have to wait another 16 months for Vulkan. But take a look at the articles linked in the show notes for full details and the other operating systems that have made this work on the, you know, the other distributions, I should say, that have made this work on them, even they're not.
Jonathan Bennett [01:21:01]:
Official. Yeah, it's, it's cool to see. I don't love the fact that they made it free for individuals to download too. And really, for a business, that $2,500 is not a whole lot.
Jeff Massie [01:21:10]:
Oh, especially if you're somebody like AMD or Intel, that's, that's a rounding error. It's around maybe not even that large.
Jonathan Bennett [01:21:20]:
Indeed, exactly. Yeah, it's, it's a drop in the bucket of a drop in the bucket, right? Like Yeah, it's, it's the— yeah, it's very small businesses that would really struggle at $2,500.
Jeff Massie [01:21:32]:
Um, yeah, and at that size, you're probably not making hardware, right?
Jonathan Bennett [01:21:38]:
Absolutely. Um, I, I kind of want to go grab it and try it on my various computers just to see how well it does. Uh, I wonder, I wonder if there's a path to adding it to Phoronix. That would be interesting to the Phoronix test suite.
Jeff Massie [01:21:51]:
You know, Michael Arable's probably gonna— it's probably gonna show up.
Ken McDonald [01:21:55]:
Jeff, this version isn't the first time that there's been a first Linux release for this spec, is it?
Jeff Massie [01:22:03]:
No, there's an older one, but it's kind of old.
Ken McDonald [01:22:08]:
And does it cover ARM or Blender?
Jeff Massie [01:22:13]:
It had neither of those and didn't have the graphical interface, so it was clunkier and Yeah, it was, I can't remember which version it was, but it's a few years old.
Ken McDonald [01:22:25]:
Similar to building Linux from scratch?
Jonathan Bennett [01:22:29]:
Probably not quite that difficult.
Jeff Massie [01:22:30]:
Not that bad, but it was a little more clunky. And then like I said, it was outdated. So you could run it before, but you were running, you know, oh, look, we got something.ancient as our benchmark engine. the actual software you're using, the Maya version, the whatever. Oh, it's now 4 or 5 versions later and using different backends and different— it just wasn't capturing the performance as accurate as matching the software with what's current.
Ken McDonald [01:23:07]:
Especially if you've got a lot more Linux users Our workstations out there now that you need to test.
Jeff Massie [01:23:17]:
Oh yeah, and that's why I said that Linux didn't win the desktop, but it won everywhere else. The major big iron industry pretty much runs on Linux for the most part.
Ken McDonald [01:23:30]:
And the entertainment industry.
Jeff Massie [01:23:33]:
Yeah, I mean, everywhere but the desktop.
Jonathan Bennett [01:23:38]:
Indeed. All right. We are actually going to take another quick break and then we will be back to do some command line tips. Don't go anywhere and we'll be right back. All right. So Rob is up first. Rob, what is your cool command line tip or other computery Linux-related tip for us this week?
Rob Campbell [01:23:57]:
This is a tip. And, you know, it's not like, it's not necessarily a tip of something I'm recommending. But it's kind of cool to check out. This is going to be definitely much better for those watching visually than those listening. If you're listening, you might just want to skip over most of the display part. But what I'm showing here, I saw an article on the Starlink desktop and they are bringing 3D to it. And I'm like, well, what is that? So I thought I'd check it out and install it. It's easy to install on Ubuntu because there's a dev port.
Rob Campbell [01:24:32]:
So super easy to install. Now, for those watching, Starlink Desktop, apparently a lot of it is vibe-coded or AI-assisted. I don't know. But by default, okay, now those looking, this is just a regular desktop here. This is not the 3D desktop. And I'm running on a VM. So to do the 3D desktop, I had to Use VirtIO graphic drivers to get it to even be somewhat usable for the show. But the regular desktop here, there is a— I'm in the appearance settings sections and you can have a macOS look and it's very macOS-like here.
Rob Campbell [01:25:15]:
You can do a dark mode. You could do tiling. I'm not going to do anything there. But if Mac's not your thing, You can also do windows. Let me go to dark mode because that looks more like better. So there you go. You can add the windows. Now, this is just a regular old-fashioned desktop.
Rob Campbell [01:25:35]:
It's not the new 3D thing yet. So I'm going to show you that because that's where things get weird.
Jonathan Bennett [01:25:44]:
I don't know.
Rob Campbell [01:25:45]:
I wouldn't use it, but it's interesting. So if I just toggle this 3D desktop, it flips me over to 3D. And now to move around this desktop, it's, uh, it's for those gamers out there, it's the WASD keys. So I can move around the desktop and I'm going to go just right here and I'm going to open, let's see, there's a calculator right here. I'm going to open that there, but then I'm going to— I'm going to leave that calculator over there and just not worry about that because I can.
Jonathan Bennett [01:26:28]:
Oh, great. Letting us lose our stuff in virtual reality.
Rob Campbell [01:26:32]:
Over here, I'll put the Firefox browser and back up a little bit here. Now you can also, oh, I don't remember the The command, but you can do a— oh wait, I think, uh, no, I don't remember. But there are keys you could toggle. I think you can, uh, Alt+Tab, which is not working because my desktop is pulling that, is grabbing those keys instead of transferring to the VM here. But I think you can Alt+Tab, I think it is, and it'll bring that calculator right back up to me. So it's not going to be lost. I think, is that calculator still over here? I don't know. It's not even there anymore.
Jonathan Bennett [01:27:18]:
And he lost it.
Rob Campbell [01:27:19]:
Yeah, as soon as I open Firefox, it's gone. So, you know, this isn't like, there's the web browser way back. Whoa, I got, I zoomed in or something. Way back there, look at the little web browser. Isn't it so cute?
Jonathan Bennett [01:27:31]:
Oh, hey, there's the calculator. It's stuck in the tree.
Jeff Massie [01:27:37]:
Yep.
Jonathan Bennett [01:27:38]:
Web browser down on the left, web browser, then over to the left further, the calculator.
Rob Campbell [01:27:41]:
How did it get over there? Anyway, I'm not saying I recommend this, but if you want to play around with something really easy to install on Ubuntu, probably Debian also. And you don't have to even have that as your main desktop. Like I could still log out and swap back over to a GNOME or whatever desktop environment I want. But so if you want to play around with it, it's interesting. Yeah.
Jonathan Bennett [01:28:10]:
Now here's the question. Does it work with 3D goggles? Can you go get a Steam Frame and use it?
Rob Campbell [01:28:16]:
Not that I know of. I know that was my initial thought too, that that would be really cool. And I mean, maybe? I don't know.
Jonathan Bennett [01:28:23]:
That's really what it needs to move to the next level.
Rob Campbell [01:28:25]:
Yeah, maybe.
Jonathan Bennett [01:28:26]:
It would actually be pretty interesting if you could do it with a Steam Frame and just sort of, you know, look around in 3D space at your different windows and everything.
Rob Campbell [01:28:33]:
And maybe that's their thought, you know, Steam Frame's coming out. We got to make this thing. We got to make a 3D desktop for that. I mean, they had to be thinking that. I don't know how it works yet.
Jeff Massie [01:28:43]:
But I had to laugh when you lost your calculator because I've used the HoloLens 2 for work. And you walk around and you go, oh, because it's augmented reality. And you're like, I left that window in the other room.
Rob Campbell [01:28:56]:
Well, with this, you can pull it back up. So. That's great.
Jeff Massie [01:29:03]:
Yeah, it— I'm— I haven't quite— 3D desktops are a novelty for me.
Rob Campbell [01:29:12]:
I've briefly played with a 3D desktop with my Oculus years ago. I'm like, yeah, this is cool. All right, I'm done. Let's go play a game.
Jeff Massie [01:29:23]:
Yep.
Jonathan Bennett [01:29:23]:
All right, let's see. Up next is Ken. What do you got for us, Ken?
Ken McDonald [01:29:28]:
Well, this week I want to share a command that makes the cd, the change directory command, smarter. It is Zoxide, written by Ajit Desova, and it sets up automatically when you install Amarchi. Now I found it fairly easy to install on Ubuntu Studio 26.04 by following the instructions on the project's GitHub page that I've got linked, uh, with the command in the show notes. Now, after installing Zoxide, I then added the command eval and then in quotes dollar sign open, uh, parentheses Zoxide init --cmd space cd in parentheses to the end of my bashrc so that I can do This. Let me get over to my terminal. And would you believe I have a directory named SHA?
Rob Campbell [01:30:35]:
No.
Jonathan Bennett [01:30:36]:
Yeah.
Ken McDonald [01:30:38]:
But it actually took me to public slash there and under my home directory. Or I could do— just type it right. And that takes me to my workspace. Now, if I do one that I don't have, it says command not found. So let's go back to— And then up one. I wanted L, not KS.
Jonathan Bennett [01:31:14]:
You're having problems with the typing too.
Ken McDonald [01:31:18]:
Yes. And there's my videos. Now if I go back to my root and just do cd vid, Where do you think it'll take me?
Jonathan Bennett [01:31:38]:
Uh, I don't know.
Rob Campbell [01:31:39]:
Your videos.
Ken McDonald [01:31:41]:
Videos under the public. So for those of y'all listening, I just typed cd SHA and that took me to my home public shares directory. Then from there I did cd space WR and it took me to my home projects workspace directory. And then from there I went back to the public share by just doing cd share again, SHA again. And then I had to actually go into the, uh, my public/video directories the first time, but basically typing it out completely. Then I could do cd vid to get back to it.
Rob Campbell [01:32:28]:
So is that CD-VED context depending on where you're at? Like if you were somewhere else, it wouldn't do anything?
Jonathan Bennett [01:32:35]:
No.
Rob Campbell [01:32:36]:
Oh, anywhere taking a public video.
Ken McDonald [01:32:37]:
Okay. Right. Because what it does is it builds a— Zoxide builds a database of your recently entered directories. And if you type any part of it, it'll find it. Pull it up.
Jeff Massie [01:32:54]:
So does it replace your cd command, or is it an alias, or is it— it adds—
Ken McDonald [01:33:00]:
I've got it set up so Zoxide is replacing the cd command using the init --cmd cd. Now you could put, say, j in there, and then the letter j would work with Zoxide to do the exact same thing.
Jonathan Bennett [01:33:18]:
Looks like in the website documentation they use z. to do it in some cases.
Rob Campbell [01:33:23]:
That's what I've seen, I think.
Jonathan Bennett [01:33:24]:
Z would— Z makes a lot of sense, although I do kind of like the idea of just aliasing cd to it.
Rob Campbell [01:33:29]:
So I've thought about this command line tip and I forgot about it. Yep. Cool.
Ken McDonald [01:33:35]:
When you saw it in Umarchi?
Rob Campbell [01:33:37]:
No, a long time ago I've seen it. And just a correction there, it's according to DHH, it's pronounced Umarchi.
Jonathan Bennett [01:33:46]:
Umarchi.
Rob Campbell [01:33:47]:
Umarchi? Yep, the R is silent.
Jonathan Bennett [01:33:50]:
The R is silent.
Rob Campbell [01:33:52]:
Like mommy.
Jonathan Bennett [01:33:53]:
All right, Jeff, what you got for us?
Rob Campbell [01:33:58]:
LLTag.
Jeff Massie [01:33:58]:
So if you have a music folder full of files with great names and terrible tags, today's tip is for you. LLTag does one clever thing. It reads your file names and folder names and turns them into proper tags. It works on MP3, Ogg, Vorbis, and FLAC files. It's a small Perl script written by Bryce Golan, and it's on Debian, Ubuntu, Mint, you know, and it's just sudo apt and you can install it. Arch users will find it in the AUR. I'm sure the Red Hat world probably has it in there somewhere as well. Now, The way you use it is say your files are organized in the classic way, an artist folder and then an album folder with the year in parentheses and then the files named like 01-innuendo.flac.
Jeff Massie [01:34:57]:
And you can go into your music folder and run lltag -G -R Double dash dry dash run space Queen, because that's a Queen song, and hit it, and it will— it'll start, uh, guessing what it, what it should, uh, put in for the tags, which is what the capital G is for. It's guess. Uh, R is for recursive, so you can recursively go into your directories. And, you know, it, it has a built-in list of common naming patterns, and then it will try them against the whole path. Um, I tried it, and in my, in my test, it pulled out the artist, album, year, track number, title, all in one go. Uh, you know, of course, the dry run flag means that it's going to show you what it's going to do so you don't actually commit to it before you go, oh, I don't like that. You know, it lets, it lets you, uh, test before before you commit. Of course, you know, when you're happy, drop the dry run.
Jeff Massie [01:36:06]:
And there's a --yes to skip the confirmation prompts if you're, you're very thrilled and you know it's going to do what you want. Now, if your file name doesn't match any of the patterns, the guess mode doesn't give up. It falls back to dumping the entire file name in the title. So You know, if, if you give it a fact, a file called track 7 underscore Queen underscore Headlong, and it will cheerfully set the title to exactly that. So, and that'll be in your, uh, metadata or in your, in your tags. Now, for oddball names, you can give it your own pattern with a dash Capital F, and then you can set what you want. Now, this also works in reverse. So if you want to rename files based on their tags, because maybe how you got the files, your tags are all correct, but the file names are kind of a little wonky, you can do lltag --no-tagging --rename And then you put in the pattern you want, like %n for name, dash, %t, or I mean, n for the number and %t for the title, *.flak.
Jeff Massie [01:37:32]:
So it will, it'll then go in and say, oh, I'm going to rename all your Flak files in this directory based upon what it's pulling out of the tags. So the number in the title. So if you had some wonky file names in there or stuff, it'll, it'll, it'll fix that. Um, and if you just want to check what's going on, lltag -S, that shows you the current tags on any file. Now, one little caveat here, the man page will tell you about a -C, which looks up album info on an online CD database. That feature's broken. The default server, traktype.org, went dark back in 2018, and there's been an open bug about it on GitHub ever since. You know, and I will say the last real release was version 0.14.6 back in 2017, but it's still packaged in the current Debian and Ubuntu.
Jeff Massie [01:38:36]:
And I mean, it's even in Trixie. So. You know, kind of almost like Steve Gibson always says, you know, sometimes the best tools are the ones that were finished years ago. Just don't ask this one to phone home. Yeah.
Ken McDonald [01:38:50]:
The man page shows there's an option to set the CDDB server you use.
Jeff Massie [01:38:58]:
Yeah, I looked into that a little bit and some people were having problems with it, setting it. So it could be that it, you know, if you find the right database that's compatible with it or somebody needs to update the code.
Jonathan Bennett [01:39:16]:
Yeah.
Jeff Massie [01:39:16]:
But most of the times you're just pulling off the tags or the names already.
Jonathan Bennett [01:39:22]:
Makes sense. It's unfortunate when stuff like that that was super cool goes dark. You can't use it anymore. But yeah, it's the reality. It's the way it works. All right. And so last one, I've actually got a quick one. We're going to see if I can get this to share.
Jonathan Bennett [01:39:40]:
Yeah, here we go. We're going to look at pstree. And this is a nifty command line that I didn't know about until just recently. And it lets you look at the tree of processes that you're running here. Let me make that a little bit bigger. Or maybe a lot bigger. There we go. I ran pstree and as you'll see, my process 0 here is systemd.
Jonathan Bennett [01:40:06]:
Then this is the list of processes that it started, modem manager, network manager, auditd, bluetoothd, Grafana, a whole bunch of things. But you'll see that it's actually showing it to you in a tree. That's where the name comes from, pstree. You get to see, well, we have Grafana, And then Grafana started this MQTT and it also started Valky. Plasma Login started some other Plasma things. And then we have, let's see, some Steam Web Helpers going on down here. A whole bunch of Chrome. Of course, we have a whole bunch of Chrome.
Jonathan Bennett [01:40:44]:
That's the way it works these days. But there are some interesting, in the help options, there are some interesting, this is funny, --help.
Jeff Massie [01:40:52]:
ps tree.
Jonathan Bennett [01:40:53]:
Unrecognized option --help. Let me show you the help so that you know what to do instead of asking --help. I love it. But you can give it just a single PID and it will tell you the— it'll show you the tree of that PID. You can give it some things like -p will show the PIDs, -esh will show the parents. You can, let's see. I want to do a ps -a and then look at one of these in particular. Let's see.
Jonathan Bennett [01:41:30]:
I got a bash here that's 1414531. I will go into pstree and let's look at that one in particular. Hey, look, it's bash. All right, well, let's do -ps and say, okay, I want to see the whole tree, but of just this. And so you now see we've got a systemd binary is 1, a systemd binary is 2878. I don't know for sure why it spins the second one up, but it does. Then we've got console. All this is happening inside of console.
Jonathan Bennett [01:42:05]:
And then inside console is our bash. And then finally, the pstree binary is the one that's running. when we run PsTree, so it sees itself. But this seems like actually a really cool way to get a quick look at what your system is doing. You can just quickly pull up the whole tree and look at it. There's some other nifty things that it can do, but it's a cool way to get a quick overview of what's running. PsTree, I enjoyed it. That's pretty cool.
Jeff Massie [01:42:36]:
That is cool. I didn't know about that one.
Rob Campbell [01:42:39]:
Yeah.
Ken McDonald [01:42:40]:
And I wonder if the version on Ubuntu Studio 26.04 is in C or Rust.
Jonathan Bennett [01:42:50]:
Is pstree, you know, I didn't even look, is pstree one of the uutils?
Ken McDonald [01:42:56]:
It's already installed on my system.
Rob Campbell [01:43:02]:
Hmm.
Jonathan Bennett [01:43:02]:
That's an interesting question.
Rob Campbell [01:43:05]:
You know, I happen to notice your PID numbers seem really high. You need to reboot or something?
Jonathan Bennett [01:43:13]:
Yeah, this is the laptop that has not rebooted for a while.
Rob Campbell [01:43:17]:
I don't think I've ever seen PIDs that high on any of my systems.
Jeff Massie [01:43:20]:
Well, my version is installed in Cachy.
Jonathan Bennett [01:43:24]:
It's part of PSMISC. So not a, uh, uh, not, not a uutil, not one of the core utils.
Ken McDonald [01:43:34]:
Yeah, it's copyrighted by Werner Allesmüller and Craig Small, and it's just distributed under the GNU General Public License.
Jonathan Bennett [01:43:47]:
Not surprising. All right, that is the show. I'm gonna let each of the guys plug what they've got. Rob is going to tell us about his book. Hit it, Rob.
Rob Campbell [01:43:57]:
All right. So for those interested in, uh, my little green screen's messed up right there.
Jonathan Bennett [01:44:06]:
Anyway, the real world is leaking in.
Ken McDonald [01:44:09]:
Oh no.
Rob Campbell [01:44:10]:
Anyway, uh, so for those interested in knowing more about me, connect with me. Uh, one, I've been posting a lot more on social media. I've been trying to do it about every other day posting something lately. So the way you can get more of me is by connecting with me on social media, and the key places are down here on my webpage. First, go to my webpage. It's the easiest way, robertpcampbell.com. On there, there's links to my LinkedIn. Post there fairly often lately.
Rob Campbell [01:44:40]:
Twitter, I don't ever touch that, but, uh, I don't know, I tried to log in recently. It was, it was, it's just I don't know. Anyway, Bluesky, posting there. Mastodon, I've been posting there. And a place to donate a cup of coffee, which is really $5 increments. And if you want to know about my history, you can read my book. And if you, uh, scroll in the right way, you can scroll down on the page, or you can just go to Amazon. It's called Trailer Park to Technology Leader.
Rob Campbell [01:45:12]:
It's So you could search on Amazon, you go to my webpage, scroll down and click buy on Amazon. And if you act now before October 1st, the ebook, the Kindle ebook is on sale on Amazon for a limited time only for $1.99 in the US. I don't know what that translates to in other areas, but in the US it's $1.99. For a very limited time. Act now before the prices go up. Or there's a softcover and a hardcover available if you prefer to have a more permanent keepsake to show on your shelf.
Jonathan Bennett [01:45:54]:
I got the hardcover because one, I like hardback books. And two, when he gets— when Rob finally, they try to cancel him and he needs to remove something from his book, I'll have the evidence. You know, Got the last story.
Rob Campbell [01:46:05]:
And I'm gonna be honest, I have not seen the hardcover yet myself. I did not order it. I ordered the softcover only.
Jonathan Bennett [01:46:12]:
It's, uh, it's somewhere around here.
Ken McDonald [01:46:14]:
When I purchased it last night, it was priced $2.99 for the Kindle version.
Rob Campbell [01:46:19]:
$2.99?
Ken McDonald [01:46:21]:
$2.99.
Jonathan Bennett [01:46:23]:
Here it is. Here's the hardcover.
Rob Campbell [01:46:24]:
Okay, according to Ken, it's $2.99.
Ken McDonald [01:46:27]:
Look at that.
Jonathan Bennett [01:46:28]:
See, look, it's hard. Hardcover. Yeah, it's pretty nice.
Rob Campbell [01:46:33]:
Okay, well, Ken says it's $2.99. I thought it was $1.99. Um, yeah, I don't know, maybe that's Amazon surge pricing.
Jonathan Bennett [01:46:44]:
That's a great show title itself, Amazon Surge Pricing. All right, Jeff, what you got for us?
Jeff Massie [01:46:51]:
Uh, nothing too much. Um, I just have a little bit of poetry. Buzzing screens surround. Fingers dance like secret scrolls. Meeting? What meeting? Have a good week, everybody.
Jonathan Bennett [01:47:08]:
Oh, I've been there.
Rob Campbell [01:47:10]:
It's $2.99. I was wrong. Maybe that's what I get.
Jonathan Bennett [01:47:14]:
Maybe it's $1.99.
Jeff Massie [01:47:15]:
And that's why you never let Rob fix your remote control car. But he can do snowmobiles.
Jonathan Bennett [01:47:21]:
All right, Ken, what you got?
Ken McDonald [01:47:25]:
Well, I've put a link in the show notes to where you— to an article by Saurabh where he talks about 18 programming books that you can get as one bundle and also support the EFF. Cool.
Jonathan Bennett [01:47:46]:
I like it. There is actually one thing that I'm going to plug that is outside of the normal Hackaday and Lost Weekly. We talked briefly about Jeff Geerling and how he brought to light the Raspberry Pi thing. Geerling had another announcement this week, the Home Lab Fest in September of next year, 2017, in St. Louis. And it actually, it seems like it's going to be pretty cool. I don't know of anybody else doing quite this, a festival quite like this. And he's going to bring a whole bunch of geeks and nerds together.
Jonathan Bennett [01:48:16]:
It's going to be a lot of fun. And really thinking about trying to go to this one and maybe even have an official presence there. But yeah, that was something cool that we saw this week. And then of course, there is also Hackaday and FLOSS Weekly, and we sure appreciate people coming and checking those out as well. Other than that, I just want to say thank you. Appreciate the guys being here and everybody out there watching or listening, whether it's live or on the download. We sure appreciate it. Hope you all have a great week, and we will see you next week on the Untitled Linux Show.
