Untitled Linux Show 260 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 double tap on the AUR disaster from last week. It gets a little bit better. We're talking about OpenSUSE and the new installer there. We talk about the hidden input lag that you didn't know you were suffering from and how it got fixed. There's KDE 6.7. There's the new kernel release. There's a deep dive into why you don't want to use String Copy in C and a whole lot more you don't want to miss it.

Jonathan Bennett [00:00:32]:
This is the Untitled Linux Show, episode 260. Recorded Saturday, June 20: Meme It Into Existence. Hey folks, it is Saturday and it is time to talk about Linux. It is the Untitled Linux show and we're here to cover the software, the hardware, the open source stories, the security stuff. Oh my goodness, there's been a lot of that the last few weeks and it's going to continue. Unfortunately. We got some good news too.

Jonathan Bennett [00:01:01]:
Some fun stuff going on and it's going to be. It's going to be a good day. It's going to be a good show. We've got the guys here, all four of us, Rob and Ken and Jeff, join me and we have some stories to cover. In fact, we each brought three stories, so buckle up. This one might go a little bit

Rob Campbell [00:01:20]:
long, but we're going to be here all night.

Jonathan Bennett [00:01:23]:
I'll make mine. I'll make mine pretty quick and so we can do it that well. Two of mine at least will be pretty quick. One might not be. We'll see.

Ken McDonald [00:01:31]:
Articles should be quick.

Jonathan Bennett [00:01:33]:
There you go. Rob is up first. And Rob, we've got a follow up on the Arch user repository fiasco. I think we can call it a fiasco at this point. It was a mess.

Rob Campbell [00:01:46]:
Yeah.

Jonathan Bennett [00:01:47]:
What's. What's new? Have they fixed it? Is it safe?

Rob Campbell [00:01:50]:
So well, Jeff covered the AUR compromise last week so so I'm not going to go rehash much of that story, but there has been some follow up to discuss first, after the initial cleanup, more waves of malicious AUR packages kept showing up to the point where Arch eventually disabled new AUR account registrations while they worked through the mess. That brings us to something to celebrate. Yay. The Aurr safety net is here. That is in Yay version 13. The big news, the big new feature is that Yay can now show when a package was last modified. Sounds small, but it is actually a really useful signal. A package being changed recently obviously does not automatically Mean it is bad.

Rob Campbell [00:02:47]:
It could have just received a normal update, but you know, and an old package is not automatically safe either just because it hasn't changed in a while. But if you are about to update an AUR package and you see the package build change a few changed a few hours ago, maybe, maybe that's your cue to slow down and take a look as it, you know, as before pressing Enter, you know, check if there's a reason for the update, check the software website or just hold off, you know, delay the update. Kind of, kind of like a lot of enterprise environments do. Well though where they'll put a little hole before they update. Except for security updates of course. Anyway, yay version 3. Yay version 13. Also add support for LUA hooks, which means users can start scripting their own checks into the install and upgrade process.

Rob Campbell [00:03:47]:
You could warn on recently changed packages, block certain sources, or inspect files before anything actually installs. This does not magically make the AUR safe, but it does and it does. It does not replace reviewing packages, but it does give users better tools to notice when something deserves a second look. And the more tools we have, the better. And these problems, you know, I never got a chance to see what was said last week, but these problems aren't unique to Arch. They can happen to basically any software repository on any OS and they have any place where people can publish software is eventually going to be a target. But even with that risk, I still think this model is far better than the old days of just searching the Internet, downloading some random installer or tarball from whatever website or FTP server you happen to find, and hoping for the best. At least with repositories there is structure, there is history, metadata maintainers, there's a community reviewing things.

Rob Campbell [00:04:53]:
And when something goes wrong, tools can improve around it. And that is one, one thing that makes open source so great things are going to happen and the real key to success is how fast they're caught, how, how fast they're fixed, how we handle that and improve things for the future. I'd like to personally, I like to see some AI hooks in there to help me review my package updates and installs faster and more. And maybe, maybe with the lua, that's possible, but you know, it's definitely a step in the right direction to, you know, the, the use. Being a user repository is always going to be a challenge, but having some tools to help, you know, maybe slow down those, be able to pick and choose what you're doing is going to be a good Helpful tool for those using the aur.

Jonathan Bennett [00:05:48]:
Yeah. So Robert, you just said something that I said almost word for word the same on another Discord server earlier this week. And I said it this way. I said, it seems to me that there's an analog to Murphy's Law and that is that any platform that could be used theoretically to serve spam or malware eventually will. I was going to call it Jonathan's Law, but then you went and you went and said it. You discover you discovered it independently. I think we have to share credit. I think it's the way that works.

Jonathan Bennett [00:06:23]:
There is actually a real particular weakness with what AUR was doing. And so like we've talked, I know I've told people this in the past that like AUR theoretically is not as safe. So be careful installing packages from there because you know, it's not maintainers. Anybody can upload a package. That's true, but that's not actually what caused this. The problem with AUR is that when anyone uploads a package and then that package doesn't get updated long enough that it's considered orphaned, anyone else can come along and then update the package. Anyone else can take it over. Anyone can take over an orphan package.

Jonathan Bennett [00:07:00]:
And if you have it installed and you go to install updates, you will just grab the new version. And so it's worse than just being a repository where anyone can upload stuff. It's a repository where anyone can take over certain packages and if you had them installed, you're just sort of automatically popped. You're automatically owned.

Jeff Massey [00:07:19]:
Yeah, they said that you could create a brand new account and within about three to five seconds you could own a piece of abandoned software.

Jonathan Bennett [00:07:26]:
Yeah, that is really the problem. And so I'm hoping that what they do to fix this is they simply disable the ability to take over abandoned packages. Like just make it go away altogether if you want. You know, if someone is. Is someone has a nano in AUR and it goes, you know, they stop updating it and you want to make it, you get to call it something else, you get to call it Nano 2 or whatever, but it's not the same package. And that's the only way I can imagine to keep. To make this work safely.

Rob Campbell [00:08:03]:
Yeah, I've heard other things, but they don't necessarily cover it, such as the age of the account. But people can play the long game like they do with ZX XY or whatever that piece of software was.

Jeff Massey [00:08:19]:
So I don't know, there was a lot of options being thrown around and it's just how do you manage it without becoming a big burden or totally killing the ability to have people upload stuff?

Jonathan Bennett [00:08:33]:
Yeah, I think that is the correct answer. You kill the ability to take over abandoned packages.

Rob Campbell [00:08:38]:
But hey, it's still better than the old days when it was the wild West. And it's like, I want this piece of software. I go online, I find this questionable site that has it, I download it, I know I had various machines or just riddled with problems.

Jonathan Bennett [00:08:56]:
Riddles with problems, yes. So.

Jeff Massey [00:08:59]:
Well, I mean, realistically, I think a YouTuber put it best when they were, they were talking about it and said, you know, realistically too, the AUR should be just for the really corner case pieces of software that you need. Like, like for me, the only one right now I've got running from the AUR is I've got an old printer driver and I felt good about it because it was last done up quite a while ago. You know, it wasn't anything that's changed or, you know, but. And that was also why they're putting that in. Yay. Is just from if it was, if the packages was updated within the last week at the time of the story, those were the ones to worry about, the ones that had been up, you know, oh, this thing hasn't been touched for a year.

Ken McDonald [00:09:44]:
The older the better.

Jeff Massey [00:09:45]:
Yeah.

Jonathan Bennett [00:09:47]:
Yep. All right, let's, let's move on and let's get Ken to talk about what's new in OpenSUSE. He is holding down that distro for us. He's got the coverage of it, or at least has historically. What's new in the Agama installer, Ken?

Rob Campbell [00:10:03]:
He's keeping it alive.

Ken McDonald [00:10:06]:
Well, I can thank both Bobby Barsov and Mark Snester for writing about Suse's YAS team releasing Agama version 22. That's what's new now. This release introduces a new appearance tool that finally lets you configure the look of the web based installer by changing the contrast and the combination of colors. In fact, the new dark scheme of the Agama Installer wears Suse's brand colors by default. Agama 22 also introduces a redesigned header and toolbar. This release also adds some extra controls to the web interface for defining some advanced settings for file systems and updates the installer sections for setting up disks, partitions and logical volumes to be more consistent with the rest of Agama's web interface. Now networking includes Vlan setup directly in the graphical web interface.

Jonathan Bennett [00:11:11]:
Cool.

Ken McDonald [00:11:12]:
Agama's web user interface can configure WI fi, Ethernet, bridge bond and VLAN connection for users preferring the command line. Enhancements include the text based monitor and now allows answering the installer questions interactively. Agamma version 22 now includes a new access section in its JSON configuration that allows you to set up all the related aspects on the installed system by following the documented syntax to indicate whether you want to access the new system via SSH or cockpit. And Agamo will take care of enabling the service, opening the port in the firewall and any extra adjustment that may be needed. Now, as always, I have only touched on some highlights from Bobby and Marcus's articles. You can follow the links in our show notes if you do want more details.

Jonathan Bennett [00:12:17]:
Yeah, I like the fact that they make it so easy to configure some of those fancier network things like VLANs and bridges. Those are somewhat fiddly on a lot of Linux systems and the things that you can do with them though is very, very cool is the word you're

Ken McDonald [00:12:32]:
looking for most systems

Jonathan Bennett [00:12:36]:
probably. Yeah. I mean most people don't need to mess with that. But for those, those few of us that want to nerd out and have, you know, virtual machines connected in various different ways and do crazy things like run a virtualized router. No, you don't have to do it for a pie hole. For things like. So if you want to run a virtualized pie hole on a server or on a desktop, then you would want to mess with that stuff.

Rob Campbell [00:12:59]:
Yeah. Or if all you want to do is test a VLAN configuration on a switch. Nice to check the tagging.

Jonathan Bennett [00:13:05]:
True.

Jeff Massey [00:13:07]:
Maybe getting fancy with the network for your IoT devices to keep them segregated.

Jonathan Bennett [00:13:12]:
That is one of the. That is one of the things that you can do with it. Yes, absolutely. Particularly if you want your desktop to be able to get to that segregated network, that's really when you got to go in under the hood and fiddle

Rob Campbell [00:13:23]:
around without desegregating it with the firewall rule and kind of ruining the whole point.

Jonathan Bennett [00:13:29]:
Yes. Or, or you know, there's always the put yet another network card into your desktop and just plug it into the the other network. All kinds of fun stuff you can do. But yeah, like I like playing with VLANs. It's fun. All right. What I don't like playing with is extra input lag. So this is a story from XDA developers.

Jonathan Bennett [00:13:54]:
Actually these guys have sort of turned into a new it used to be just covering Android devices and XDA has sort of turned into a more generic nerdy Linux news site and I like it. I'm down for it. This is a story about Jacob Okonsky who was fiddling around with KDE and apparently also had a Windows install and, and realized that his mouse didn't feel quite right inside of kde. And people have sort of noticed this over the years, that there are some things that in Linux they're not dialed in quite the same way that they are in Windows. But what Jacob here did is he actually tested it and it describes the rig that he set up, which I believe was a little Arduino device that was emulating USB if I remember correctly, and actually tested it and discovered that KDE plasma on Linux processes inputs 4 milliseconds slower than Windows. And you may think, oh well, 4 milliseconds, that's hardly anything like, surely you can't feel that. Well, that's 1 250th of a second, which on really high refresh rate monitors that could be an entire frame. But there's also various bits of technology now coming to Linux machines as well as Windows that tries to, and we talked about it last week or the week before that tries to mess with that timing so that it takes your input and maps it to like the last possible moment to start the frame draw so that your, you know, you minimize that latency.

Jonathan Bennett [00:15:41]:
And he found yet another source of said latency. And there's actually about three different sources of latency. One is that in KDE and particularly in Kwin, there is a timer that automatically rounds up to the nearest millisecond. And so, you know, it was on average costing about a half millisecond in all of that rounding. And then there's also a, he calls it a safety margin. Essentially this is Kwin saying, all right, we're going to wait this long before we send out the buffer. And he said that was far too protective and that was adding just a flat 1.5 milliseconds. And then there is yet another sort of buffer built in there and that is it expected that the GPU would take 2 milliseconds to draw a frame.

Jonathan Bennett [00:16:35]:
And he said you can, with the right setup and the right hardware, you can turn that down. And so he dropped that to below 1 millisecond and cut the lag better than in half. And for most of us we won't notice this, but if you're actually talking about like competitive gaming for sure, but also just sort of twitch gaming, I think this probably is something that you'd be able to notice. I would say even beyond that, it's cool to just see this level of detail being attended to in Linux for gaming in particular. But everything on the Linux desktop, I just, I like it, I like seeing it. I like, there's, I like the fact particularly that everything is open source and so you can just make the measurement and then dive into the source code and figure out what's causing it. And that's exactly what he did. And getting it, getting it improved, getting it, getting it fixed and hopefully get that pushed out in an upcoming version of KDE and K1.

Jonathan Bennett [00:17:33]:
It's a pretty cool story. I like it.

Rob Campbell [00:17:35]:
Well, that explains my KD ratio.

Jonathan Bennett [00:17:39]:
Your KDE ratio?

Rob Campbell [00:17:42]:
KD ratio.

Jonathan Bennett [00:17:44]:
Oh, your kills to death ratio.

Jeff Massey [00:17:47]:
But I'm pump. Yeah, you know, I, I'm with you Jonathan. It's. This is the kind of thing that really makes Linux so cool because you can have people with these specialized,

Ken McDonald [00:18:00]:
you

Jeff Massey [00:18:00]:
know, that kind of, I don't know, things they love and really can go after it and dig in and. Because now doesn't it even say that there's still more to go after? I mean this isn't everything but I don't see anybody at Microsoft just digging in this, this far and this hard into something to just go, we're going to optimize this even better now for me. Yeah, I'll never notice it. I don't play fast twitch games so I, or if any, I kind of do, I'm not that good at. So I'm not gonna. My, my own ineptitude far outweighs any, you know, a four millisecond lag but.

Rob Campbell [00:18:42]:
Well, at least you're giving me excuse now.

Ken McDonald [00:18:47]:
That's probably why I prefer role playing or RPGs or strategy games over.

Jonathan Bennett [00:18:54]:
You know, you say that you won't ever notice it, Jeff, but I've, I've noticed the, the mouse getting really st. Like a compile and so depending upon what all they do to fix this, that could make an improvement and in that case you would notice it.

Jeff Massey [00:19:08]:
Yeah, that's true. I, I have noticed it stutter. I just guess I just never really thought much about it. It's just like.

Rob Campbell [00:19:13]:
Oh, I'm.

Jonathan Bennett [00:19:14]:
That's just what computers do. When you compile something, the mouse stutters,

Jeff Massey [00:19:19]:
this is bogged down and okay,

Rob Campbell [00:19:23]:
this

Ken McDonald [00:19:23]:
matches or disappears all, all together.

Jonathan Bennett [00:19:27]:
Yeah. Oh yeah, no, I've had that a few times too. The mouse just stops like well okay, I guess I'm going to go get a cup of coffee and see if that wakes itself back up eventually all

Ken McDonald [00:19:37]:
right, Grind the beans, then wait for it to brew and then come back and it's still stuck.

Jonathan Bennett [00:19:43]:
Yeah, sometimes. Now that's what happens. All right, we're going to take a quick break and then we're going to continue to talk about kde. We're going to turn Jeff loose on it with the newest in 6. 7, and that is right after this, 6.7.

Jeff Massey [00:19:57]:
So we've been talking about Plasma 6.7 for a while and it's finally out now. We mentioned it last week. We've got a new kernel now. We got plasma 6.7. You know, this is a lot of new code hitting this summer, so wonderful thing. Now this is a point release, but it's a really pretty big change. Normally when talking about, you know, about it, we say, you know, there's tons of little things which we didn't go over because, you know, there's a lot of little stuff that is kind of done in the background. Well, just for the heck of it, I took the change log and I counted the number of times the word commit showed up.

Jeff Massey [00:20:33]:
So unofficially, there was 2678 times the word commit was in the 6.7 change log. You counted them? Well, I had my word processor count, you know, just did a find and it said this many came up.

Jonathan Bennett [00:20:50]:
But he didn't even have to use AI.

Jeff Massey [00:20:53]:
Yeah, and I don't have that many fingers and toes, so I had the machine do it for me. I mean, well, I scrolled through the change log and I was like, well, I wonder how many are in here. And it, it goes on for a long time. Now this is all a kde. So that's, that's including the, the Pro, each program's updates, the plasma updates everything. But it was pretty huge anyway. You know, you can see why a lot of people have been happy with the progress KDE is making. You know, not only are there a lot of new features, there's a ton of general usage improvements and a ton of bug fixes.

Jeff Massey [00:21:32]:
You know, this is getting a lot of love from a lot of people and they're really polishing the interface. So it's just very smooth. One of the most notable additions in Plasma 6.7 is the introduction of per screen virtual desktops. Now this capability has been requested by users for nearly 20 years. I mean, if you really go back to when it first showed up, and it fundamentally improves multi monitor workflows. Instead of all displays switching virtual desktops simultaneously, each monitor can now maintain its own independent set. Now, this change has been widely recognized across coverage as one of the defining features of the release and one that immediately benefits users who rely on complex or multi display setups. I think about every article I have linked in the show Notes talks about it and there's several I didn't link.

Jeff Massey [00:22:27]:
We could have had 20 links in here talking about this. It's pretty big across all the sites. Now there's a ton of other improvements to make the Wayland experience better. Intel GPU users benefit from hardware overlay planes being enabled by default, reducing power consumption and reducing power consumption and improving responsiveness. The Compositor sees major CPU usage reductions. It's up to 70% in certain scenarios, particularly for applications rendered on high resolution displays. So rob your 720p probably isn't going to see near that amount, but fractional scaling receives visual improvements resulting in sharper icons and thumbnails in modern applications. Additionally, recent fixes ensure that more reliable startup behavior on older or legacy graphics hardware, making things look better was also on the list of changes such as the return of the classic Oxygen theme.

Jeff Massey [00:23:31]:
Originally introduced in KDE 4, Oxygen's distinctive aesthetic has been refreshed and reintroduced alongside updated versions of the Air theme and several classic wallpapers. Now with KDE approaching its 13th anniversary, this inclusion serves as a respectful nod to the project's history and longtime community members. Now, in the same vein, this release was dedicated to one of those community members, Eric Laf Laffan who passed away in May and had been a very long time supporter like for over a decade. So they said this is dedicated to him who is such a big contributor to kde. Going back to how things look, another visual change which you know we've talked about this in the past episode, so I won't go into details, but a new theming engine called Union. Now it is not enabled by default and it's currently limited to QT Quick applications. Now just to cover it a little bit is Union represents a long term effort to unify the visual styling of plasma QT Quick and WT widgets under a single CSS based system. Basically it's going to eventually simplify theme development, ensure greater consistency across the entire desktop environment is basically you have just one interface, you have to write all these different styles of modules to so it's just kind of a universal translator almost for the themes, this release includes a wide range of smaller but meaningful usability enhancements.

Jeff Massey [00:25:11]:
Users will find new microphone test button in the system tray clean their clearer visibility of background flatpak applications, improved support for HDR displays Alongside ICC color profiles, notifications now appear in the nearest screen edge file selection on the desktop once again supports type ahead search and the overview effect offers more intuitive virtual desktop switching. The Discover Software center features cleaner installation controls. The clock widget now displays time zone offsets and privacy controls allow windows to be hidden from both screencasts and screenshots. Even the printer indicator now shows a number of queued jobs contributing to a more informative and responsive interface. So that, you know the. And I'm not going to go into it, but the KDE team also delivered a huge number of bug fixes. I mean there's a lot of bug fixes, both major and the small paper cut ones. And some of the links show what they're even putting into plasma 6.7.1, which we should be seeing out very soon if not released by the time you hear this, the 6.7 point whatever.

Jeff Massey [00:26:34]:
Those are usually more on like a weekly type cadence. They come fairly frequently so there won't be a long wait for that and some of the article and we'll cover it maybe on a show next week or after. They're already got stuff going into Plasma 6.8, so development is full steam ahead on this thing. Take a look at all the articles linked in the show notes for full details. I also included a link to the change log for those looking for a very specific item. Like I said, a lot of lines and it. It's quite a bit to scroll through and you know, as always the articles go into much more detail than I can here and I think they're worth a read. So happy reading.

Jonathan Bennett [00:27:17]:
Yeah, very cool. It's always good to see the progress marching on on things like KDE and the various desktops. I'm going to try 6.7 and the throwback theme. That'd be fun. I haven't run that in a long time.

Jeff Massey [00:27:34]:
Oxygen.

Jonathan Bennett [00:27:35]:
Yeah, that's the one.

Ken McDonald [00:27:37]:
Yeah. My system Ubuntu 2604 has KDE Plasma version 6.6.4. Should I try the back ports for it? Jeff?

Jeff Massey [00:27:52]:
Yeah, I'm. I'm on 6. 7 right now and it smooth now I am running this the 7.1 kernel as well so. But it's working perfect and maybe that'll

Ken McDonald [00:28:07]:
fix the fact that some of the on my panel, some of the apps that are up there don't show an icon for them.

Rob Campbell [00:28:18]:
Maybe it's the Oxygen Oxygen theme. Speaking of throwbacks.

Jeff Massey [00:28:25]:
Well, I would say if you go to 6.7 before you do, I would delete your configuration.

Ken McDonald [00:28:34]:
Delete My what?

Jeff Massey [00:28:36]:
Your configuration files or at least move them. Yeah, I'm ignoring you, Rob. Who Sometimes you'll have legacy configs that get stuck and cause issues. They maybe aren't officially supported but they haven't removed them from the code. So it can cause things to get a little funny. Go in into your home directory, move those to a backup your kde and I think there's in your config config, there's a couple directories in there. Look online there's about three different directories. Rename them back up, then go to 6.7.

Jeff Massey [00:29:18]:
So you get a fresh configuration from the, from the 6.7 software and it will sometimes get rid of some of the weird ghosts in the machine kind of things.

Ken McDonald [00:29:30]:
Yeah, some of them have found if I go in and to the menu editor and take and select another icon to use and then save it for that, it'll create the desktop file and then it'll use that icon on the taskbar. But it's like the default desktop files

Jonathan Bennett [00:30:00]:
doesn't have an icon.

Ken McDonald [00:30:01]:
Yeah, weird.

Jonathan Bennett [00:30:05]:
All right, let's, let's indeed talk about throwback and Rob was trying to, trying to transition, transition us on to Commodore. Have you been, have you been paying attention to the Commodore story since perifractic? It's a YouTuber. What he goes by bought the Commodore brand or are you. Did you just see this in the news this week?

Rob Campbell [00:30:25]:
I have not. I mean I understand they've been, it's been like a year now and. But I just saw this one in the news this week so.

Jonathan Bennett [00:30:34]:
All right, we, we may come, we may come back after the, after Rob's gives the story and give a little bit of background, but what's the, what's the new, what's the new Commodore thing? So what's the new Commodore gadget?

Rob Campbell [00:30:46]:
Commodore is back and this time apparently it's running Linux. Now when most of us think of Commodore, we are thinking about the old Commodore 64 base keyboards, basic prompts, old school home computing and that very specific kind of nostalgia where you can almost hear the floppy drive making noise. But the revived Commodore brand has been making a comeback under new ownership, as Jonathan mentioned, with the new Commodore 64 Ultimate Editions, C64XPC and now of all things, a flip phone. It is called the Commodore Callback 8020. And the interesting part of, of, of, of this is that it skips Android as the main operating system altogether and instead runs Sailfish OS which is a Linux based mobile operating system from Jala. So yes, in the most technically accurate way possible possible. Commodore has returned to the phone market with a Linux phone kind of the commodity the callback 820. It's not trying to be another smartphone slab glass slab doom scrolling machine.

Rob Campbell [00:32:14]:
It's a retro inspired flip phone with a T9 keyboard, a small internal screen, an outside display, a removable battery, that's a plus. Removable batteries. I miss those days for sure. Dual SIM 4G micro SD expansion and a 48 megapixel Sony camera. It also has some very intentional restrictions which I don't like restrictions, not in my Linux anyway. According to the report, browsers and social media apps are blocked at the system level with no toggle, turn that turn to disable that or enable that or however you want to think of that. And WhatsApp comes pre installed. I know a lot of you, especially in other countries use that, but WhatsApp and apps like Signal, Telegram, WeChat are supported.

Rob Campbell [00:33:15]:
That's good too. Sailfish OS also brings Android app compatibility. So it's not some completely isolated feature phone ecosystem. And here's where it gets a little world weird. You know, on one hand it's cool to see Commodore back and running Linux. A Linux based phone with a physical keyboard, a removable battery, you know, all those great things. On the other hand, this is a Commodore branded phone that starts around $500. A flip phone that starts around $500 run sailfish OS support.

Rob Campbell [00:33:53]:
It supports apps, blocks, blocks the browser and it can apparently control the LEDs on a Commodore 64 ultimate if they are on the same Wi Fi. You know, that's a very specific product for a very specific kind of person. I'm not totally sure who that person is. You know, the Linux phone crowd usually, or the Linux crowd usually wants openness, hackability, repairability and control. Not so much restrictions. The nostalgia crowd, you know, usually wants them to feels connected to maybe the original Commodore. I guess they got the nostalgia for the flip phones. This seems, seems it sits somewhere in the middle.

Rob Campbell [00:34:38]:
You know, it borrows a name, it borrows the same retro styling uses Linux. But you know, I, I don't know which group it fully satisfies. You know, I like that something other than Android and iOS is even being attempted. And so I'm always going to cheer for anything that's Linux powered, but I think they're kind of missing the target a little bit in the Linux phone market, you know, the first mistake is locking anything down completely. If it's Linux you don't lock things down. But you know, I get where the flip phone market is, is often it's older people so maybe you want to lock it down, you know. So. So are they targeting the flip phone market? You know, is that the people they really want the, you know, traditionally usually older people who just want something old basic like Ken, considering, you know, consider you could often get a flip phone for around a hundred dollars, give or take a $500 flip phone is more expensive than some of the really low end Android phones.

Rob Campbell [00:35:49]:
So I don't know. Ken, you looking to get a new phone?

Ken McDonald [00:35:55]:
Not yet. Mine's still got a good screen.

Rob Campbell [00:35:58]:
Yeah. Which flip phone is that? Is that like

Ken McDonald [00:36:03]:
by Motorola?

Rob Campbell [00:36:05]:
The Razor, I used to have that one.

Jeff Massey [00:36:07]:
I love the razor.

Ken McDonald [00:36:08]:
Moto G Power 20 Moto G Power 5 G 2024.

Rob Campbell [00:36:15]:
The Razer was my, my last non smartphone. It's nice.

Jeff Massey [00:36:20]:
Yep, yep.

Ken McDonald [00:36:23]:
It is an Android phone or fortunately depending on your point of view.

Jonathan Bennett [00:36:28]:
Yeah, I think, I think there is something like for kids when you don't want them on social media but you want to be able to give them a phone. That, that is interesting. When I first read about this, I did, I have, I had the same thought like does that really match the Commodore brand? Is that something that they wanted to do with Commodore, the brand, the story here, of course Commodore died as a company years ago and it got sold like the brand name got sold several times and this conglomerate ended up with it and they started talking with again, he goes the YouTube channel is perifractic. And they started talking to him and he's like, well, you know, he had ideas and he's like, I think this is the sort of thing people would like to see with the brand. And they basically told him like, do you want to buy the Commodore brand? You really seem to know what you want to do with it. And he got the funding for it and did so and is trying to resurrect it. And they've done things like the Commodore C64 ultimate, which is kind of the rebuild of the old Commodore 64 with some modern components in it, which I think that's gone fairly well for him. The, the phone is, is a departure and like I, I very much admire the boldness to do something different and not just stay in the retro, in the retro lane.

Rob Campbell [00:37:51]:
I mean a flip phone is kind of retro still, even though they still exist. It has a retro ness to it.

Jonathan Bennett [00:37:57]:
Yeah, it does. I suppose it does have a, a tinge of retro. It smells like retro, we'll say. But yeah, I don't know, I don't know if this is going to be a big win or not. The business side of me says I hope they didn't sink a whole lot of capital into this because it's the sort of thing that may take off and be real popular or may not at all. You could get a Chinese company to knock one of these out for you without having to put a whole lot into it. Or you could spend a lot of money to get this off the ground. Hopefully they did not do the latter.

Rob Campbell [00:38:32]:
Yeah, I mean, you kind of brought up some good points if you want to have a phone with kids, but Yeah, I mean, you could just get a flip phone. They exist, but then all they could do is talk, I guess, you know, with a flip phone that has some. A little more technology under the hood, you could maybe do a little more with it that you would like to do with it with a kid's phone, maybe.

Jonathan Bennett [00:38:55]:
Yeah, like run WhatsApp and Signal and, you know, some other apps like that that might be worthwhile to have. It's interesting.

Jeff Massey [00:39:04]:
Well, I was gonna say, you know, with you talk about modern technology, it would be hard to build a phone now with available components that don't have a ton of modern technology in them. I mean, it. It's probably already there. You know, a lot of what you want to do or like, oh, we want to. It's in the hardware already. It's just baked in.

Ken McDonald [00:39:23]:
It's already in the system on the chip.

Jeff Massey [00:39:25]:
Yeah.

Rob Campbell [00:39:26]:
Are you talking about modern. The other modern flip phones today, you think it's in there just not being used, Is that what you're saying? Or.

Jeff Massey [00:39:32]:
Yeah, I mean, because a lot of times the flip phone market is going to be small enough. Now, this is just my speculation. You're not going to have the parts longevity that people are going to keep these old parts going for forever. So you're just going to use them the lowest cost, lowest power, modern part? Because I've noticed since, you know, human malware that parts don't stick around like they used to. You know, you'd have these parts that just. Oh, yeah, you've been able to get these for forever. They don't tend to do that anymore. It's.

Jeff Massey [00:40:08]:
It's much shorter life cycles on some of these things.

Jonathan Bennett [00:40:11]:
It depends on what the part is. Because, I mean, Texas Instruments has some things that have been around for like 25 years and you still get. And they still get used in modern designs, but anything that's on the Moore's Law curve is going to Disappear really, really quickly. And so your MCUs will tend to go away reasonably quickly. But anything faster than that, like actual ARM core CPUs. Yeah, the shelf life on those is so short because six months from now they're going to be completely obsolete.

Jeff Massey [00:40:42]:
I'm finding even some dumber components don't have the shelf life that they used to. What I found now, now if they're.

Jonathan Bennett [00:40:51]:
What I, what I've seen is less about shelf life, more about availability. And so like I'm, I'm seeing places where if you want to make an actual order, I don't mean like a hobby size order, I mean like an actual production run size order for something you're 18 months out, 24 months out, that, that is challenging for shelf lives too, just because things are.

Ken McDonald [00:41:13]:
Yeah.

Jonathan Bennett [00:41:14]:
So hard to get a hold of.

Jeff Massey [00:41:15]:
I've just noticed a lot of last calls. Last call for this part, but it's not. I mean, yeah, you're going to have like some of the Texas Instruments stuff that's around, but they also probably still have really good demand because you have, you'll have certain things like audio processing chips that they're not changing a ton. You know, they're not going through huge life cycles.

Ken McDonald [00:41:39]:
How about the speakers in these phones?

Jeff Massey [00:41:43]:
They're pretty static. I mean, speaker technology for everyday use doesn't move that much.

Jonathan Bennett [00:41:51]:
I'm thinking Ken is trying to talk about pipe wire there. We kind of, we kind of missed, we kind of missed it on, on that, that segue, but that's a weird one.

Ken McDonald [00:42:01]:
Yeah, he started talking audio and I figured that sounds like an interesting topic to me.

Jonathan Bennett [00:42:06]:
What is a really interesting topic is that pipewire gets used in Android and I would not be surprised if pipewire is used in that Jala Sailfish OS because it's, it's kind of everywhere now.

Rob Campbell [00:42:17]:
Yeah, you missed, you missed the better segue.

Jonathan Bennett [00:42:24]:
Anyway, take it away, Ken, and tell us about what's new in Pipewire.

Ken McDonald [00:42:29]:
Well, I want to first of all thank Qies512 since he pointed out earlier this week that there was a new version pipewire release that thankfully Bobby Borisoff and Morris Nestor wrote about. That's Pipewire version 1.6.7. Now it fixes audio regressions affecting silent ports, ALSA synchronization, scheduler behavior, and several smaller stability issues. According to Bobby, the main fix addresses a race condition where some ports could remain silent. And after a sample rate change, this issue can affect audio routing after switching sample rates, leaving parts of the audio graph inactive until the affected streamer device restarts. According to Marcus, Pipewire 1.6.7 also fixes a bug where Pipewire would temporarily freeze or lag because it was using a slow indirect communication path to request real time scheduling privileges. Now this update also fixes a potential crash when removing a card due to incorrect ALSA API usage. Now pipewire emits a route parameter update when card properties change, ensuring jack port updates are reflected correctly.

Ken McDonald [00:43:56]:
Now more details about this update can be found in Bobby and Marcus's articles which I have linked in our show notes.

Jonathan Bennett [00:44:05]:
A lot of just bug fixes and it's not terribly surprising as 1.6 is their stable release stream. I was briefly poking around at the Pipewire GitLab to see if there's anything really interesting that I can see that is coming and looks like progress has sort of slowed in pipewire and I think that's because they've they basically supported all the things that they want to support or at least getting close to it in pipewire itself. Now, some of the periphery around pipewire we still have features that we want to see like pipewire outputs from obs. I still very much want to see that one of these days. Yes, I will mention that every time we talk about pipewire I will meme it into existence. Thank you very much.

Ken McDonald [00:44:57]:
Yes, I am also looking forward to be able to just go into QPW graph, grab the video output

Jonathan Bennett [00:45:05]:
here, connect.

Ken McDonald [00:45:06]:
Yeah.

Jonathan Bennett [00:45:07]:
Have this Firefox, have this Chrome do the thing with it. Yes, absolutely.

Ken McDonald [00:45:11]:
To both of them at the same time.

Jonathan Bennett [00:45:12]:
Yeah, 100 or the different tabs within Chrome or Firefox.

Jeff Massey [00:45:17]:
I just want Firefox to work with the loopback camera.

Jonathan Bennett [00:45:22]:
Yeah, that's why you have two cameras, one to record and the other one to share. All right, let's talk about a little kernel stuff. We got some kernel stuff coming up. I'm going to talk about something that Linux 7.2 dropped, done away with, no longer can use. It's gone. We're going to do that right after this in the kernel you can no longer stern copy that is strincpy and I thought it would be interesting to take just a moment and dive into some programming stuff and explain why this particular function that was intended to be more secure has caused almost as many problems as the one it replaced. So we're going to talk about strings in C land and the first thing to note is that a string in C is just an array. It's just a carved up bit of memory and in cparlance the way that you end a string is with a null.

Jonathan Bennett [00:46:40]:
So not a zero, not a space, but a literal ASCII value zero, a null, that is the end of strings, that is the symbol that indicates the end of the string in C. And that fact has been used. It was actually really, really convenient if you wanted to copy a string from one place to another. There was a function string cpy copy string copy. And you would get the pointer, the destination pointer first. If I remember correctly, it's usually destination first and then the source. And so you would say, grab it from there and put it here. And what strcopy would do, what string copy would do, is just start at the first byte, move it over, go to the next one, check if it's a null.

Jonathan Bennett [00:47:29]:
If it's not a null, move it over, go to the next one, check if it's a null. If it's not a null, move it over. And the problem there is that your input string, that buffer that you're copying from, has a length and your output string, the buffer that you're copying it to, has a length. And this is, this is where you know, as you're managing your memory, you say, okay, I want this buffer to be this many bytes. So that's the length. You've got just a STR copy string copy. It doesn't know anything about that buffer size. It just copies until it gets to a null.

Jonathan Bennett [00:48:09]:
And so many, many programming errors over the years have simply been, for whatever reason, there wasn't a null at the source. And so we just keep copying. We go right past the end of the input buffer and keep copying data. And the same thing on the output. We go right past the end of the buffer and keep copying data. So someone came along and said, you know what would be really great is if we could make STRCPY aware of these buffer sizes. And so they made str in copy string copy with a number added. And so with this, you say, okay, here's the destination buffer, here's the source buffer.

Jonathan Bennett [00:48:53]:
You're going to come from, copy a maximum of this many characters, which is great. So then if you get. So say you've got, you've got a buffer that has, you know, hello in it, and you want to copy that over. Well, H E L L O is 5. And then you would add one more for the null and you would say, okay, copy six characters over. It would copy it over. What if you're off by one and you've got a, say, a space at the end, you copy those same characters. H E L l o space and the quirky thing that strincopy does is it doesn't set a null at the destination.

Jonathan Bennett [00:49:41]:
And so now, instead of the danger being that you blow past the end of the string when copying it, the danger is now that after you've copied it, you have a malformed string because it might not have a null at the end. And so this is the problem with strincopy. And so yet another function, actually there's several of these. The bsds have a function for this and Linux has a function for this. So in Linux it is STRS for secure, I think. So a string secure copy, it takes the same three things. It takes the destination, the source and the number to copy. But with strs copy it just after it's done copying, it backs up one and sets a null.

Jonathan Bennett [00:50:32]:
And that way you know that your destination string is null terminated the way that it's supposed to be. So all of that explanation to say that in 7.2 Linux 7.2, they finally killed, completely removed their implementation of STRN copy, the stern copy you could call it. So that no longer exists, which means that they've gone through each of these and they've converted it to the more secure copy method. They finally gotten rid of it. Now I'm sure someone out there is saying, well, if they would just use Rust, they wouldn't have to do this. And yeah, this is a problem that Rust doesn't have. And it's worth pointing out that they are indeed adding support for Rust, but that's going to take a very, very long time for R real fruit to bear in a, in a sizable way across the kernel. So this is something that we can do, the guys at the kernel can do right now, make a big difference, makes things more secure and finally get rid of some old code.

Jonathan Bennett [00:51:36]:
So you'll love to see it. That's one thing that's happening with the 7.2 kernel.

Rob Campbell [00:51:41]:
When you say it like that, it sounds like an easy fix that they just should have did years ago.

Jonathan Bennett [00:51:47]:
Well, but I mean, you know, there's probably 10,000, if not more, maybe more than, maybe quite a bit more than that.

Ken McDonald [00:51:54]:
So we're replacing Stern with stress.

Jonathan Bennett [00:51:57]:
Yes, but, but you have to think, you know, what are the, what's the potential edge cases there? How do I know for sure that when the person that wrote this first wrote it, they didn't know that it wasn't going to be null terminated? Maybe that's what they wanted it to do. Maybe we're actually concatenating strings in memory. And so we really, really don't want to null terminate. And you know, there's a lot of potential pitfalls with this. You got to be very, very careful with it. You can't just do a, you know, a select all and replace. You're going to cause bugs doing that too.

Ken McDonald [00:52:29]:
You mean you couldn't just rip it out like you could a graphics card?

Jonathan Bennett [00:52:33]:
Nope, you cannot.

Rob Campbell [00:52:35]:
What kind of segue is that to

Ken McDonald [00:52:38]:
the Hercules monochrome ISA graphics card that they're dropping from out of 7.2?

Jonathan Bennett [00:52:44]:
Oh wow.

Ken McDonald [00:52:45]:
Yeah.

Jonathan Bennett [00:52:46]:
At that point I long time don't

Jeff Massey [00:52:49]:
handle it carefully, just rip that thing out.

Ken McDonald [00:52:52]:
40 years old. What are you going to hurt?

Rob Campbell [00:52:54]:
Well, yeah, the system's old. You really don't need to rip it out. It can all just be recycled together.

Jonathan Bennett [00:53:00]:
Indeed. All right, Jeff, you've got some other 7.2 news. What are you tracking in the kernel for this week?

Jeff Massey [00:53:09]:
So it isn't a secret that I'm a bit of an audio fan and I talk about it from time to time here on the show. And sometimes I I sometimes even go into longer verbose tangents about my own audio proclivities. But you know, and though I will warn anyone, you know, getting into the audio world, asking what's the best audio anything is like asking what's the best Linux distribution? You know, it's a whole big topic. But now you know why this story caught my ear. I interest the introduction of AMD's next generation ACP7.x Audio Co processor has been entered into the Linux 7.2 kernel. Now this update represents a significant architectural shift in how AMD handles on chip audio processing. AMD has contributed initial driver support for three new ACP variants, ACP 7D, E, and F. So they're all seven dot letters.

Jeff Massey [00:54:13]:
ACP is a dedicated audio DSP subsystem integrated into many AMD APUs, and it offloads audio processing tasks from the CPU, improving efficiency, latency and power usage too. The ACP typically includes now this is the new one. So this is the seven dot letters, an extensib based DSP core, multiple audio interfaces like pcm, Bluetooth audio headset, audio, dm, ic, so on. It's got DMA engines, mailbox based IPC mechanism for communication with the host cpu, and support for sound wire and PDM on newer generation chips. Now these architectural elements are documented in the Sound Open firmware, SOF projects, AMD platform materials now according to The Patch series, ACP7.x introduces substantial design changes compared to earlier generations, including a completely updated register layout. Because of this, the Linux developers place the new implementation in its own directory and ensuring that the new code path remains clean, maintainable and separate from legacy ACP logic. So what that means is when you have a newer older chip, you're running completely different code. They don't have one code base to handle the if on this or if on that, it's just completely separate.

Jeff Massey [00:55:50]:
As a point of reference, The ACP Series 6 is based on a HiFi 5 extensive DSP core. Since the new one isn't called out, there's a high likelihood that the DSP core has changed and that would explain the differences in registers and the different layout that they have to account for. The initial driver focuses on the essentials PCI bring up register definitions, probe and removal routines, integration with system sleep and runtime power management, additional audio I O support such as the SoundWire and ACP PDM controller and that'll arrive in follow up patches. The current contribution is roughly 3,000 lines of code, making only the beginnings of the broader ACP 7x enablement. The article linked in the show notes also has a link to the kernel mailing list with a sound poll email where you can get many other improvements which are listed for those who love to look up all the audio information they can get. So that's not just strictly with the AMD acp. This is all the sound stuff in general. A lot of it boils down to just a lot more hardware supported.

Jeff Massey [00:57:00]:
So you can look it up if your specific piece, you know, isn't fully supported now maybe is going to be in 7.2 and fixing some issues with quirks and existing hardware and other little bug fixes. But take a look at the article linked in the show notes for an earful of audio goodness. Happy listening.

Jonathan Bennett [00:57:19]:
Yeah, something that intrigues me is that audio processing in the same way that we do video processing in a GPU has kind of gone away on systems and I think probably because CPUs have done it so well for so long, but there for a while there were audio processing engines that were in GPUs and people doing some really fancy stuff with it. I remember Doom 3 I think was very famous for having support for one of those, I forget the name of it but an audio processing like CO processor and it's difficult to get it working but if you do it actually still sounds pretty novel some of the things that they do.

Jeff Massey [00:58:04]:
Yeah, the thing if you're kind of an audio nerd. Yeah, CPUs can do a lot but a Lot of times a dedicated DSP can sound so much better because there's less rounding and they're, you know, carrying. Carrying the bits a little further into the. Into the audio signal.

Jonathan Bennett [00:58:22]:
EAX4 environmental audio extensions. That's what I was thinking of.

Jeff Massey [00:58:28]:
Yes, as a blast from the past.

Jonathan Bennett [00:58:30]:
Yeah, indeed.

Rob Campbell [00:58:32]:
When you say blast from the past and sound, all I think about a sound blaster

Ken McDonald [00:58:38]:
and sound bluster AE5 plus.

Jeff Massey [00:58:43]:
Well, they had a bad reputation for a while because they said, oh, we got 24 bit audio. But certain parts of the pipeline they went down to like 12 bits and they weren't fully honest with their hardware for a while and they got a pretty bad black eye.

Jonathan Bennett [00:58:57]:
Yeah, 12 bits is low enough that you might actually be able to hear that.

Jeff Massey [00:59:01]:
Yeah, yeah, normal CD is 16. That's kind of the standard.

Jonathan Bennett [00:59:08]:
Yeah, that's the. Yeah, at this point that's sort of the bottom edge of acceptability.

Jeff Massey [00:59:13]:
Yeah, I mentioned it before, but a

Ken McDonald [00:59:16]:
lot of 24 now.

Jeff Massey [00:59:18]:
A lot.

Jonathan Bennett [00:59:19]:
Aria.

Jeff Massey [00:59:20]:
A lot. A lot of 24 and. But realistically, 44.1 and 16 bit is all you need. It's the higher resolutions. And this is also where vinyl comes in. And I've mentioned this many times on the show before. That's where they master it much better because they know people care about audio quality. So they're like, oh, we got to be careful versus just kind of slamming it out.

Jeff Massey [00:59:43]:
It's like being in a cafe, cafe. And they're like, oh, here's. Here's a normal trucker burger. And then, oh, we got the food critic. Okay, we're going to make this a little better and a little nicer and, you know.

Jonathan Bennett [00:59:53]:
Indeed. All right, let's talk to Ubuntu.

Jeff Massey [01:00:03]:
Rob?

Jonathan Bennett [01:00:03]:
Yes, we're adding AI to Ubuntu, but maybe it makes sense.

Rob Campbell [01:00:08]:
We said it was coming. We've had stories about the sales coming and yes, Ubuntu is adding a. They've announced now a specific new AI feature. And this one is one of those times where I think the Linux community should probably.

Ken McDonald [01:00:24]:
Pause, Listen.

Rob Campbell [01:00:26]:
Yeah, just pause. Pause before immediately grabbing the pitchforks. Because I mean, this isn't about listening, this is about talking kind of anyway before. Because this time it helps improve accessibility for Linux, something we've always been a little lagging in. So I heard. I've never really had to deal with it myself, but that's what I've heard. So Canonical has announced the Mina, that's my N. A project or Project Mina, a new speech to text tool being built for the Ubuntu desktop, the plan is for it to debut with Ubuntu 26.10.

Rob Campbell [01:01:13]:
And the idea is pretty simple. You know, press the keyboard, shortcut, talk naturally, and the words show up in whatever application you're already using. No big chatbot window, no voice assistant trying to run your life for you. No, you know, you can't be like, open my calendar, send an email, turn on the lights, which I think would be cool when they get there. But that's not what this is, you know, at least, at least for now. Canonical says the goal is just a reliable desktop dictation. And it's probably a good place to start, especially with all the hesitation in the Linux community when it comes to AI. Speech to text is one of those features that has felt normal on phones for years, but still feels kind of missing or awkward on the Linux desktop.

Rob Campbell [01:02:06]:
If you use Windows, macOS, Android, iOS, voice input is just expected. Now on Linux you can get there, but it's usually a little more fiddly do it yourself than, than most people want. Mina is supposed to make that a first class Ubuntu desktop feature. The version is being built around Gnome on Wayland.

Ken McDonald [01:02:31]:
Ding, ding, ding, ding.

Rob Campbell [01:02:32]:
Another reason to run Wayland anyway. You hold the hotkey, speak, let it go. There's a small visual indicator while it's listening, and then the finalized text gets inserted wherever your cursor was. The part many users will like is the speech recognition is intended to run locally on your machine. Once the model is downloaded, it does not need an Internet connection. Canonical also says the microphone is only accessed when diction is explicitly activated, the audio is processed in memory, and recordings are not uploaded to some cloud service yet. Anyway, when people hear AI in the desktop, you know, they often only imagine the giant privacy nightmare bolted onto an operating system, which, that's not what this is yet. And you know, a lot of, a lot of companies have probably earned that suspicion.

Rob Campbell [01:03:34]:
But you know, local, private, useful AI is a different conversation. This is the kind of AI feature that actually makes sense on Linux. It's not replacing the user, it's not taking anybody's jobs, it's not trying to turn the desktop into a chatbot. You know, it's just taking something that people already need. Dictation, accessibility, hands free, input, productivity, and trying to make it work better. For some people, speech to text is not just a convenience, it's the difference between being able to comfortably use a computer or not. You know, this is still early, the project is not finished yet. So maybe they'll add the cloud features later.

Rob Campbell [01:04:23]:
Probably not for this one. There are questions around model quality, you know, language support, hardware performance, desktop environment support, whether this lands cleanly in 2610. You know, I'm just hoping it works better than Siri. From some of my past experiences, you know, doing a voice to text with a Siri, it's not so much the voice text, it's the finding things like, well, let me find a web page for you. Anyway, different topic with all the hype and hate over recent, the recent announcement of Ubuntu Add AI. Hopefully this, their first step into AI is a feature everyone can approve of.

Jonathan Bennett [01:05:06]:
You know what strikes me about this, listening to it, is they've sort of embraced the Unix philosophy in it. Oh, it does one thing. You press the keyboard button, it listens to you, and then it spits that out into an application. That's all it does. And then if you want to do fancier things, like if you want to make a chatbot, if you want to be able to talk to an LLM, you can do it. You can point it at the next tool, just like you can pipe together things in the, in the command line. I really like that. I think that's a, that's a pretty, a pretty clever way to do it.

Rob Campbell [01:05:39]:
String it together.

Ken McDonald [01:05:40]:
String it together and Rob, you got your whoosh. Ubuntu will now listen to you.

Rob Campbell [01:05:48]:
Well, the desktop will. I want Canonical to listen to me.

Jeff Massey [01:05:54]:
You always want more. Yeah, we have Aunt Pruitt saying, but isn't Ubuntu already easy to use for folks? Seems like the voice input would be a pain. It is, it is easy to use. But keep in mind this is also accessibility.

Rob Campbell [01:06:08]:
Yeah, some people don't have as limber fingers to type all day long, so, you know, they need to use things that.

Ken McDonald [01:06:17]:
Or they're multitasking.

Jonathan Bennett [01:06:19]:
Well, I was thinking, we programmers, sometimes we, we sit at a keyboard in the, the worst possible angles and way of sitting and you know, that leads to things like carpal tunnel syndrome and your eventually inability to be able to type. And so you, you're not going to give up working on the computer. Of course, nobody would do that. So instead we turn to things like this speech to text and you know,

Rob Campbell [01:06:41]:
Well, I, you know, if you're using it for programming though, I really hope that dictates well, because that could be some interesting bugs.

Jonathan Bennett [01:06:51]:
Yeah, I've, I've actually seen, I don't remember if it was a TED Talk or some sort, but years ago, some Sort of talk where a guy that was a full time programmer basically said, try to figure it out. Like, how can I do this? Because what you do as a programmer is different than what you do as someone just dictating a letter.

Rob Campbell [01:07:08]:
They're really weird words and.

Jeff Massey [01:07:11]:
Yeah, I know what you're talking about, Jonathan. I, I heard that. And it sounds half English, half like random noises.

Jonathan Bennett [01:07:21]:
You basically have to come up with new words to represent some of the symbols.

Jeff Massey [01:07:26]:
Yeah, because you don't want to say open parentheses. It's too long.

Rob Campbell [01:07:30]:
Yeah, it's got to type out open parentheses.

Jonathan Bennett [01:07:33]:
Exactly.

Jeff Massey [01:07:34]:
Or that. Yeah, and so he came up with weird like squawk. And that just meant open the parentheses

Jonathan Bennett [01:07:42]:
exactly. Stuff like that.

Rob Campbell [01:07:43]:
Squawk, squeak, shebang.

Jeff Massey [01:07:46]:
It. It sounded half video game, half English.

Rob Campbell [01:07:51]:
Okay, that, that sounds interesting.

Jeff Massey [01:07:52]:
But he was demonstrating it and it's kind of almost like a, like with working with VI or an RPN calculator. He was whipping out code wicked fast because as fast as he could say it, it was throwing it on the screen and it was doing what he wanted.

Jonathan Bennett [01:08:11]:
Yeah, it was real impressive. I have to go see if I can find that. That's been probably a decade ago now that talk was given. It may have been a TED talk.

Ken McDonald [01:08:23]:
Got me wanting to mess around with a old 8 bit program I use for converting text to audio to speech. Sam,

Jonathan Bennett [01:08:36]:
that's been a while.

Jeff Massey [01:08:37]:
I use that on the Commodore 64 software.

Ken McDonald [01:08:41]:
Automated mouthpiece.

Rob Campbell [01:08:42]:
Maybe the new Commodore phone will have.

Jeff Massey [01:08:47]:
You know, with the phones powerful today, you could probably put a whole 64 emulator in one and.

Jonathan Bennett [01:08:52]:
Oh, absolutely.

Jeff Massey [01:08:53]:
Just fine.

Ken McDonald [01:08:54]:
You mean it's not coming with a 64 emulator?

Jonathan Bennett [01:08:56]:
I'm pretty sure there are 64 emulators on the Play Store already for both major cell phones. Pretty sure it's already out there.

Rob Campbell [01:09:05]:
Linux, though. Linux phones, selfish.

Ken McDonald [01:09:09]:
Well, no, that's.99% of the Android apps are compatible.

Jonathan Bennett [01:09:12]:
Oh yeah, that's its thing. It'll run almost all the Android apps. All right, let's take a quick break and then Ken's got a story that I was thinking about covering. I did not grab it, but he did. And Ubuntu is threatening to kill some unofficial flavors. Maybe that's not exactly what, what they're doing. We'll get the whole story.

Ken McDonald [01:09:34]:
They're not threatening to kill, they're just giving them. They're putting a hard line in there and I'll get into that.

Jeff Massey [01:09:43]:
Not a threat, it's a promise.

Jonathan Bennett [01:09:45]:
You guys messed up my cliffhanger after this somewhere in here. They'll break it off.

Jeff Massey [01:09:55]:
We'll be back after these messages.

Ken McDonald [01:09:57]:
Yeah, well, Jonathan, as you were talking about Ubuntu is they're not threatening to kill things, but they are mandating that the Ubuntu flavors now participate in beta releases to keep that official status. Thankfully, Michael Arabell and Joey Sneddon wrote about Oliver Rees posting an important policy regarding the beta participation. Basically, the post states, to ensure that every flavor is fully prepared for the final release. Please be advised that no flavor will be considered for an official release unless it has successfully submitted a beta release. According to the scheduled timeline, the package diffs between beta and final releases should be minimal and only contain bug fixes. This sounds familiar, doesn't it? Now, according to Michael, rare exceptions were granted if an Ubuntu flavor wasn't ready in time for the beta milestone in the past. But moving forward, this is being treated as a hard requirement with no exceptions to be granted. Now, an obvious upside is a more stable release of the various flavors come April or October for US users.

Ken McDonald [01:11:31]:
Now, if you can follow the links in the show notes, if you want to comment on Joy and Michael's articles about how you feel about this hard, hard line approach to making sure we get those betas before the final release,

Rob Campbell [01:11:47]:
I think it's a great idea.

Jonathan Bennett [01:11:49]:
Betas are important. Yeah, that's one of the ways that you get high quality software instead of

Ken McDonald [01:11:53]:
having a final release that feels like a beta.

Jonathan Bennett [01:11:56]:
Yep, absolutely.

Rob Campbell [01:11:59]:
Though I can maybe see flexibility in the interim ones, but when it comes to the LTS, that would be my stance. LTS's hard stance. Interims, Kubuntu.

Ken McDonald [01:12:11]:
As long as they meet the timelines, it shouldn't be that hard to get that beta out.

Rob Campbell [01:12:18]:
Interims are kind of a beta anyway.

Jeff Massey [01:12:21]:
Yeah, like for example, Kubuntu sometimes, at least for a while there wasn't putting out Betas for the dot 10 releases, but for all the Dotto 4s they had, they had betas in there. There was a little more official cadence with those, but they might be putting them out now for a while. Some of it was just the amount of people taking care of the distribution. It was just hard to get the beta out.

Jonathan Bennett [01:12:47]:
Yeah, I think we said this, but getting a beta and letting people test it is actually pretty important for making sure that that release ISO is in good shape. And that's what Ubuntu definitely does not want. If they're going to sort of officially put the Ubuntu name on something, something they Want that ISO to be something people can really use and not an image that's going to be terribly broken right out of the box. Nobody wants that. But it's really bad for the, it's bad for the Ubuntu brand and like that's.

Jeff Massey [01:13:16]:
And it's a big deal to be an official flavor because you get a lot of support from Canonical, you know, not necessarily like coding and stuff like that, but you get, you know. Oh, okay, you're allowed to use our servers. You're allowed to use bunch of the.

Rob Campbell [01:13:28]:
Yeah, their build systems.

Jeff Massey [01:13:30]:
Yeah, you, you, the framework there you can use.

Rob Campbell [01:13:33]:
I wonder if any will drop off. I know. I don't think we ever cover the story, but I, I think the, the mate flavor. I know. Martin. Yeah, I think he, he's. He's the one who retired from mate a little bit ago and, and I know the other people are taking over for him.

Ken McDonald [01:13:52]:
Rob, what I think we may see happen with some of the more niche flavors is that you may not see them come out for the dot 10 releases.

Rob Campbell [01:14:05]:
Unity's already kind of been struggling there with their developers, Mate. Well, it sounds like they're committed to keeping it going, but I think they had some delays and struggle there when it came to the 2604 timeline.

Ken McDonald [01:14:21]:
But I think Harold Fences hit it on the head. This may be in response to seeing more people using Linux as the Windows 10 support has stopped.

Jonathan Bennett [01:14:34]:
Yeah, it's definitely a driver to get the quality up and make sure that things are not a train wreck when you first do the install. I know, I know. We Linux geeks that have been around for a long time, we're sort of used to that. That. Oh yeah, like half my drivers won't work. And it's sort of an adventure to get things working. But not, not everybody will put up with that.

Ken McDonald [01:14:53]:
That's why we do it.

Jonathan Bennett [01:14:55]:
That's part of the fun. I know. Maybe we need a future Linux distro broken OS that has puzzles baked into it. You have to solve the puzzles before your, your individual hardware will come up and work. Could be like an online adventure.

Jeff Massey [01:15:11]:
That used to be Arch.

Jonathan Bennett [01:15:13]:
That used to be every Linux distro.

Ken McDonald [01:15:16]:
Didn't they do a game based around that?

Jonathan Bennett [01:15:19]:
Yeah, several. Several Use that sort of idea, you

Jeff Massey [01:15:23]:
know, for a long time.

Jonathan Bennett [01:15:27]:
Is that just me or him? Jeff is frozen. All right, well, he's back. Oh, you started to say for a long time.

Jeff Massey [01:15:36]:
Oh, I didn't. It's clear on my side.

Jonathan Bennett [01:15:41]:
Imagine that.

Jeff Massey [01:15:42]:
Yeah. So I was. We have a little Linux users group. We go and eat lunch at and we kind of sometimes joke now it's like updates are kind of boring because it's like, yeah, it worked before, it works now.

Ken McDonald [01:15:53]:
Just, it'll work next week.

Jonathan Bennett [01:15:56]:
Yep.

Jeff Massey [01:15:56]:
Yeah, there's, there's no weird like oh, I did this, that broke this and I had to go in and yeah, it just works.

Jonathan Bennett [01:16:02]:
Yeah. It used to be that playing Linux was like playing a missed game where, you know, you, you were exploring everything and oh, this doesn't work. Okay, well we have to, you know, take the, take the panel off and adjust the gears till it gets just right. It'll make the right noise and then you can put the panel on and the thing will do its thing. It's like one of the adventure games. Yep, it's kind of boring now. So we need it, we need a Linux adventure game. Adventure OS.

Rob Campbell [01:16:25]:
I just remember the old days of IRQs and.

Jonathan Bennett [01:16:29]:
Oh, okay, let's not go that far back.

Ken McDonald [01:16:32]:
Adventure OS that you run on steamos.

Jeff Massey [01:16:36]:
You could.

Jonathan Bennett [01:16:36]:
Yeah, no, no,

Jeff Massey [01:16:39]:
well, but, but the thing is though, you know, kind of going back to Harold's comment is with so many more tech people talking, you know, you got, you got the Linus Tech tips channel. You've, you've got, you know, level one techs even. They kind of always had Linux but I mean now they've got their own special Linux channel. They, you know, gamers, Nexus hardware on box. There's so many more of these J's 2 cents that are talking about Linux. Maybe not all the time, but they bring it up now more. They, they're kind of dabbling in it. They're playing and so it's going to be important to go.

Jeff Massey [01:17:16]:
If it's got our name on it, we want it to be quality.

Jonathan Bennett [01:17:19]:
Yeah, absolutely.

Ken McDonald [01:17:20]:
Have we got any more game related news?

Jonathan Bennett [01:17:23]:
So this one is sort of game related and that is that there is a new version versioning system, a new version control.

Rob Campbell [01:17:29]:
Oh Lord.

Jonathan Bennett [01:17:31]:
Git wasn't good enough. Epic Games, not my favorite game store, but that's beside the point. Epic Games, good on them though for making this open source. They've released the very first release of Lore, the new version control system. And you like I probably look at this and immediately win. Why, why does the world need another version control system? I mean we have Git, which does basically everything that you would want it to do. And then if that wasn't enough, if you really want to, you can go back and run subversion. There's several other options.

Jonathan Bennett [01:18:10]:
Well, they have addressed this actually, and they have some thoughts and in fact I've got the second link here is actually off to the Epic Games documentation on this. And they asked the question why a new version control system? And they talked about three different systems that are already out there, Git, Perforce and Mercurial, which, yeah, a lot of companies, a lot of places use those. And they talked about some weaknesses that each of them have and one of those is in dealing with binaries and very large files. And this is absolutely correct that this is something that Git was not made to do. Working with binaries and Git is kind of a pain. I will 100% grant them that. And then they also talk about like the ability to do lazy copies, that you don't have to download everything all at once. Being able to break those big binaries up into pieces to pack them and transfer them around properly.

Jonathan Bennett [01:19:19]:
Even things all the way to like they're not using a Shaw hash. Instead they're using Blake3 for the hashing at the core of it, which for those, for that small intersection of people that care about both VCSS and security. You probably know that Git is moving from is it SHA1 to SHA256 I think is what they're doing. But anyway, so like there is something to be said for a new VCS that just uses a better hash by default. And then the other thing that they mentioned here that I think is telling is that most of these, the open source ones, they are not permissive licenses, they're copyleft licenses, they're Git is gpl, whereas Lore is under the mit, it's under a permissive license. And so remember we're talking about the Epic Games Store here. Well, what might they be interested in doing with one of these version control systems that you couldn't do with something that's gpl? And the obvious answer is embed it into something that's closed source, whether that be a game or a launcher, like the actual Epic Games Store launcher, or even a tool, you know, one of the kind of game creation toolkits. You might want to have a VCS baked into that.

Jonathan Bennett [01:20:41]:
But you can't use Git, not if you don't want the whole thing to be open source. So that is sort of where they're at with Lore. And then I must admit I was very amused that several times here they have the comment Lore. You can get it now on GitHub. I just want to know where is the Lore right repository for Lore. That's when this in my mind will cease to be a toy and become a tool. Let it self host.

Rob Campbell [01:21:14]:
Yeah, I mean if you don't have Lore yet, it's hard to get it from Lore, I guess. I don't know.

Jonathan Bennett [01:21:19]:
This is true.

Rob Campbell [01:21:21]:
Chicken and egg.

Jonathan Bennett [01:21:22]:
Yep. Yeah, I mean it'll, it'll eventually get packaged, right? And then there'll be like installers, you know, install it on Windows or just use your, your package manager on Linux. It'll eventually get there. But yeah, it is for now kind of a chicken egg problem.

Ken McDonald [01:21:35]:
I think you'll have a Lore version control system that you can use when EPIC has a VCS you can play on.

Jonathan Bennett [01:21:49]:
Yeah, well apparently, apparently it's out. You can get it now and it is open source. It's just, it's a permissive license which, you know, there's, there's definitely a place for that. I like my gpl, but I do understand why the MIT exists and it has its, definitely has its use cases. Yeah, super interesting. All right, what is next, Jeff? Sparky Linux. What's Sparky linux? We haven't talked about this for a long time.

Jeff Massey [01:22:17]:
It's been a while. We have talked in the past about Sparky Linux. In fact, it was an episode, I believe it was 2, 216, titled the kernel Needs a Shave Bridge. Ken talked about it. Now I want to talk about it again because of Cashy OS and Arch. Okay, stick with me here. So right now there's a wave of interest in Arch and Arch based distributions, most of which is focused on Cashy. You know, it's one of the hot flavors of the month kind of thing.

Jeff Massey [01:22:46]:
You know, I'm not saying anything's wrong with it, but you know, it's getting a lot of PR right now, you know, and it's. What is it? It's known for cutting edge packages and you know, if you want cutting edge, people will tell you to go that route. But what if you like the Debian or Ubuntu based flavors better for whatever reason? Maybe you love APT and can't get enough. Maybe the color schemes feel better. Maybe you had an old X that ran Archie or Cashy and that's just enough not to use them. You don't want to be even reminded of them. Well, Sparky is someplace you can go which is based on Debian testing. Now I know Debian is known for stability and while it's true when you have a distribution based off the testing repositories, you can get much more cutting edge software.

Jeff Massey [01:23:36]:
Now why this article Caught my eye is because Sparky is supporting the 7.1 kernel today and at the time I read the article, Cashy was still on 7.0 now Kashi since upgraded, I'm on 7.1 now. But it was like wow, here's. Here's a, you know, distribution was a little more cutting edge on it and it made me think that sparky 26.06, you know, with their semi rolling release is running some pretty cutting edge stuff now. Okay, it's semi rolling. So for example, like I should mention, 7.1 isn't the default kernel but you opt into 7.1. But the point is you can now LTS kernels are also an option if you like the OS to be a little more stable or you know, you want to run cutting edge software, but you want to have a little older, more stable kernel. So you can do all that. You know, there's things like you have options where Firefox defaults to 140.11 ESR which is Extended Support Release, but 152 is in the repos if you want the latest and greatest.

Jeff Massey [01:24:47]:
So there's a lot of. There's a lot of options with this. It's not full on rolling, but a lot of times people don't always want full rolling. They just have certain, you know, I want the latest kernel and I want the latest Firefox and I'm happy, you know, a lot of the other sub libraries, a lot of times people aren't as worried about. 26.06 does ship with the latest Calamari's 3.4.1 installer and it does support the Plasmid login manager when using kde. I will say if you're a fan of the Lumina desktop manager that sadly has been removed, they don't go into reasons. I mean the official Sparky people don't. But basically the community consensus is pretty much the development has gone quiet and realistically it's gone inactive and so it just needed to go.

Jeff Massey [01:25:38]:
While a lot of what I've been talking about is cutting edge, I mean if you want to go old school hardware you can do an old school install and use the command line installer and put the distro on older hardware. And looking at distrowatch, it shows Sparky Linux has been around a few years so I think it's a safe place to jump to if you're so inclined. This isn't a sudden fork which will probably be dropped soon type of distribution. Take a Look at the article in the Show Notes for more details and a link to the official Sparky Linux page. And you can choose if you want stable or semi rolling. And then you can choose which desktop version you could. Which desktop version you would prefer. And they also have special editions like ARM Edition for the Raspberry PI systems.

Jeff Massey [01:26:20]:
You can get Rescue editions, multimedia, and they even have a Game over edition which comes with a lot of the gaming stuff. So happy semi rolling.

Jonathan Bennett [01:26:30]:
Game over, man.

Rob Campbell [01:26:33]:
You know, Sparky, I would say had access 7.1 before Kashi because Sparky is actually built on the testing of Debian, while Cashy isn't supposed to be a testing distro. So.

Jeff Massey [01:26:47]:
Right.

Rob Campbell [01:26:47]:
I would see a lagging slightly behind.

Jonathan Bennett [01:26:50]:
It's funny how that works sometimes, you

Jeff Massey [01:26:51]:
know, and you say like, oh, go ahead.

Ken McDonald [01:26:53]:
Well, actually shouldn't you say it's built on Forky since that's what's in the test, Debian testing right now. Yeah.

Jeff Massey [01:27:03]:
But you say as a release you can change names.

Rob Campbell [01:27:07]:
You can, you're still accurate, it's more encompassing. But you know, I was, I was thinking about. And it brings us back to the first story, how you said Cashy is the flavor of the week or year or whatever. I know, I've seen, I've, I've read a lot of concern after the A Aur debacle. People worried about, oh, should I not be using Cashy now because of this. And, and you pro, you probably touched on it last week. You know the Aur is not the default way to install it. Right.

Rob Campbell [01:27:39]:
Keep using Cashy if you like it.

Jeff Massey [01:27:42]:
Yeah, you have, you have to opt in to the Aur, basically. You can't just. Oh, half my packages are in the. You have to know what you're doing to do something like that.

Rob Campbell [01:27:51]:
Yeah. If you're using the Aur, you've already decided to use the Aur. Yeah.

Jeff Massey [01:27:59]:
And last time I installed something from there, I believe it says, hey, this is. Be careful, this is not from our official repositories. You know, it came up with some warning stuff which I know a lot of people. Oh yeah, whatever. Okay. Yes, I want it, you know, but

Jonathan Bennett [01:28:14]:
I would like to think that now people will think twice, but most won't. I know.

Jeff Massey [01:28:20]:
Yeah, well, but like you can't use Pac man to just get from the Aur. You have to use Yay or Paru.

Jonathan Bennett [01:28:27]:
Yeah, that's all right. Well, that is our, that is our news for the week. Quite a bit going on this week and we are now up for some command Line tips and we have some fun ones, some simple ones that we've either not covered for a very long time or that surprisingly we've never covered. So stick around for after the break and we will give you that and then close her up. We'll be right back. All right, Rob is up first. What you got?

Rob Campbell [01:28:54]:
All right. My command line tip is another TUI app. It's Go Lazo and this is for you football or soccer fans, as we call in the United States, for you fans of. Of this great sport. So what this is is Go Lazzo is. It's a TUI command line application that allows you to see the current football soccer scores so you can see finish matches and it's going to. I just, I don't have to finish matches there. I can go three days back.

Rob Campbell [01:29:37]:
They were there earlier, but three days back Brazil versus Haiti 0. Or I could see live matches there. Any live matches on. There was earlier, but I don't think there is now. Yeah, should have recorded this one. There's actually live matches going on

Ken McDonald [01:29:58]:
or

Rob Campbell [01:29:58]:
you can see the World cup and yeah. So anyway, for those fans of soccer or football as the rest of the world calls it, there's a little spot where you can keep keep an eye on the scores in the command line.

Jonathan Bennett [01:30:16]:
Nice. Short and sweet. I like it. All right. And then, Ken. Yes.

Ken McDonald [01:30:24]:
And this week I have a going back to. After digging through our command line spreadsheet, I noticed we haven't actually discussed the this command directly. It's the list command, sometimes spelled ls. We've demonstrated it when we're talking about other commands in the past or we're trying to get specific information about files or directories. But today I'm going to take and provide a, a deep dive into what it can do. I'm going to start that deep dive and then I'm going to leave y' all to explore further after I'm finished.

Rob Campbell [01:31:12]:
But let me go ahead and there should be a two minute job, Ken.

Ken McDonald [01:31:19]:
And I need to swap my video because it's showing that I'm mirrored. There we go. And now you can read what I've got on the screen there, right?

Jeff Massey [01:31:35]:
Yes.

Ken McDonald [01:31:36]:
And as I said, the command is list or sip. Some people would do it LS and everybody needs to find. Wants to get help with it. Can just type dash, dash, help or if you want, you can open a second terminal LS to get all that because there's quite a bit of information. Just with the help though, as you see, it says list, directory, contig by default, it will ignore files and directories starting with a period. Basic sent usage is the LS followed by the option or a file or a path. Now, the most common use is just doing LS and hitting enter. And that'll give you for most distributions, it'll have that set to automatically colorize the output and put it in columns sorted alphanumerically.

Ken McDonald [01:32:47]:
Now, you can control the sorting by using different commands like dash T, which will sort it based on the time it was created or the time it was last modified, Or by you, which does it by access time. And another option that you may find is how you can change that way it's displayed from columns to by using dash X so that it does it in rows. So for those of y' all listening with the X it has my the first row is the out goes Bash scripts desktop documents. Whereas in the previous ones when I first did it, it was Bash scripts desktop documents in the first column. But you got that going across. So I've actually got

Rob Campbell [01:33:57]:
four,

Ken McDonald [01:34:00]:
five, six columns, three rows of six columns, with the first row having the first six items in alphanumerical order. Now, another way that you can. Another option that you have is dash L or dash dash long for displaying detailed information about the files. And for those of y' all listening, what it's showing is that I've got a column for showing permissions, a column for showing the number of links, column for owner group size, and then the date that it was either created or modified or last access. Then a column for the name of the file and depending on what type of file it is in my case, set to colorize it so that all the symlinks in my directory are in green. And in this case it shows the link where the link points to for some of my directories. Now.

Jeff Massey [01:35:30]:
Yep.

Ken McDonald [01:35:32]:
Now, sometimes you may want all the information. So if you use this lowercase A, it'll even include the dot files or. Or dot directories, like the single dot or the dot dot directories for the current and parent directory and all the dot files that I have. Now, what's really nice is if you want to be able to quickly understand how big those file is, you can add an H to that and that will give you the size in human readable format.

Jonathan Bennett [01:36:13]:
Yeah, I like dash H. You could do that for a lot of different commands.

Ken McDonald [01:36:18]:
Now, what I find handy, depending on what I'm listing, is using the dash one followed by the capital Q. And that will do this cool column and puts everything in quotes so that if you do have a file that's got spaces included in it, it makes it easier to just go.

Jonathan Bennett [01:36:48]:
You triple click it and get it.

Ken McDonald [01:36:51]:
Yep, yep. Just.

Jonathan Bennett [01:36:54]:
I like it.

Ken McDonald [01:36:55]:
Oh, and another one that you may find useful is dash M where it puts a comma between everything. It's all one line.

Rob Campbell [01:37:08]:
So that you could feed into a CSV.

Jonathan Bennett [01:37:10]:
Yeah, that's like a CSV output. Very cool. All right, I've got a quick one. This is something I actually had to do this week. Needed to figure out how many characters were in a string. And there's a bunch of different ways to do this, but I had the string on a web browser and it's like I started to count them and you know, I got about five or six characters in. And I'm like, no, no, this is dumb, I'm not going to do this. And I then realized that, wait a second, I've got a command line tool and I could paste into the command line.

Jonathan Bennett [01:37:42]:
So I will. Let's see if we can make this work real quick. Yeah, here we go. It's word count wc and hopefully I can make this work. So you could just run wc. You hit enter and it's just sitting there waiting. It's waiting for standard in and we are going to paste. And so I've got just the contents of our shared document, our show notes here, the top part of it.

Jonathan Bennett [01:38:06]:
Now here's the catch. Here's the kicker. You can't just hit enter because enter is another character that it will count. No, you want to send the end of file character. That's a special one here. And that's Control D. Send Control D and it'll tell you, oh, hey look, you pasted in what is 28 lines, 123 words and 10, 24 characters. And so there you go.

Jonathan Bennett [01:38:34]:
You can do that to just snag some text and drop it straight into WC and figure out exactly how many characters you've got. Which sometimes you really need to do. All right, and last up, Jeff, which, which, which thingy are we talking about?

Jeff Massey [01:38:53]:
Which LLM. And it's like what it sounds like. It's a command to find the local LLM. Now this is just for stuff you run on your own hardware that actually runs and performs best on your machine. So it's ranked by real recency, aware benchmarks. It's not a parameter count. So. And it, so it's.

Jeff Massey [01:39:17]:
It's looking at real world data. Basically. It'll. Which LLM? It'll auto auto detect your GPU CPU and your RAM and then finds which hugging face models best fit your system. You can do also simulate things like what would a new GPU do? If you want to plan like, what if I had this one? What, what would it change? It'll give you the results for that as well. There's other parameters like GPU only, which you say, okay, I only want the models to fit in my graphics card vram. And like I said, because it's based on benchmarks, this is real world data. But it also, it weights the model so that you see the recent benchmarks are more important than like old benchmarks.

Jeff Massey [01:40:13]:
So like if a benchmark is an old 2024, it's got not going to have near the same importance as one run last month. Now it'll also let you sort and say, I don't want to see the ones that are going to be too slow because, because some of them, you know, aren't going to work at all. You just don't have the, the horsepower to run it, period. But some of them, like, if you swap from your VRAM to your regular memory, you're going, you know, you'll have massive slowdowns. An example I ran into is they said, you know, maybe you've got, and I'm just pulling these numbers off the top of my head so they could be a little off. But it was really, it was basically like you're running 100 parameters a sec, 100,000 parameters a second, and then you switch to having to hit your regular memory, your, your regular dram. Now you're running like five. So it's just like a 90% type slowdown.

Jeff Massey [01:41:18]:
It's, it's tremendous. So you can, you can avoid things like that. The other thing is, even with everything fitting in vram, there's a limit to how many items you can process at once. So you can define what your lower threshold is. Because even if you say, well, this fits, but I want my waterline of lower performance to be X, you can set that and it will ignore things that fall below that. And the other thing is you can pick a model and then it gives you the results of various hardware. So if you're like, I really want to run this thing, okay, here's what it will do on various graphic cards and, and it even gives you different quantization levels, the quant levels, so that you can see how much you have to compress things to make it work. Because a lot of times these models won't fit in your regular normal PC vram.

Jeff Massey [01:42:13]:
You know, we're excuse me, most of us aren't running the 20,000, $100,000 systems that have just monstrous amounts of VRAM in them. So this kind of says, oh here's, here's what you can run and it gives you like kind of an accuracy number so you can see what levels of compression affect you the most. I mean a lot of times the first few high compressions there's a lot of inaccuracies, but as you go down it starts turning into, you know, 1 or 2% differences between models, even though there's a few gigs in differences in ram. So take a look at the link in the show notes to the GitHub link for which LLM and you know, if you're at all curious on running an AI model on your local hardware and just kind of playing with it, give it a shot and happy playing.

Jonathan Bennett [01:43:10]:
Yeah, absolutely. My laptop here. I'm being told that Google's Gemma 4, one of the Gemma 4 variants is going to be the way to go here. And I've been told by some people that apparently really know what they're talking about that doing inference on laptops with laptop process particularly APUs, is getting to be really interesting because you've got the CPU cores and the GPU cores connected together, but they all can access all of that system RAM and like that is kind of the place that the most interesting things are happening right now with running your models locally. And so it's, it's, interestingly it's becoming less about having a big GPU and a desktop and more about having an integrated apu. I think that's what AMD calls them with a bunch of RAM on it. And so that's, that's pretty interesting that it's moved to laptops is just about become the place to do inference now. Pretty.

Jeff Massey [01:44:09]:
Yeah, because you don't have that step where you, you're drop going through the PCIe buses and the system, you know all the, the overhead in there. Yeah, for me when I ran it, it's the, the Quin 3.6 27B. So 27 billion token model was the best it said for me. But at the, the quant was the level 4. The Q4/ K underscore M was the sweet spot.

Jonathan Bennett [01:44:38]:
Yeah, I have to play with some of these, these look, do look really interesting.

Jeff Massey [01:44:43]:
Yeah, I kind of got lost and sidetracked on playing with it and I'm like oh, that's kind of cool.

Rob Campbell [01:44:48]:
Yeah.

Jonathan Bennett [01:44:49]:
Oh you can with it and it

Jeff Massey [01:44:51]:
gives you a chart of not only the kind of the expected speed based on benchmarks, it tells you when the published benchmarks were done. So you can see how recent they are. And then it kind of scores them, gives them a rating based on it gives you like the top 10 models.

Jonathan Bennett [01:45:08]:
Yep. Yep. Very cool. That's a neat trick. That's a neat command line tip.

Jeff Massey [01:45:11]:
I like that a lot.

Jonathan Bennett [01:45:13]:
Very cool. All right, that is the show. I will let each of the guys get the last word in if they want to. We'll let Rob go first. I bet he's going to plug some stuff.

Rob Campbell [01:45:23]:
Yeah, I've got nothing special going on this week, so I'm just plugging my normal old way that you can all connect to me, and that is by going to Robert P. Campbell.com on that page. There's links to my LinkedIn, my Twitter, my Blue Sky, My Mastodon, and a place to donate a coffee. I'd appreciate it.

Ken McDonald [01:45:47]:
Thanks.

Jonathan Bennett [01:45:48]:
All right, I'm getting called out by Gunagoon. Gungwin. Anyway, since that's not a character count, it's a byte count. Yes. Which is the same thing if you're not using any Unicode Extended Unicode characters. Ken, what do you have to plug?

Ken McDonald [01:46:07]:
A couple of things. First, with my command line tip, that's just the beginning of it. Y' all need to go out and explore all the other options that I didn't have time to cover.

Jeff Massey [01:46:19]:
Absolutely.

Ken McDonald [01:46:19]:
And second, I wanted to share with everybody about an article by Hackadays Jenny List that I really enjoyed about an esoteric hobby os for vintage 32bit PCs.

Jonathan Bennett [01:46:34]:
Nice. Very cool. All right. And Jeff, I got a couple things to cover.

Jeff Massey [01:46:42]:
One of them is just a lot of times we have various websites we talk a lot about here on the show. Some of the more popular Linux ones. Make sure you go and donate. Like, I'm a lifetime member to two of them, and one of them I just donated a bunch of coffees to. I just took the standard lifetime membership and just donated that in coffees to them. So, you know, remember to kind of support your Linux community. And other than that, I have a poem which was sent to me and I'm not going to say their name because I don't know if they want me to say their name or not. So if you do in the future and you send me stuff, let me know if you would like your name mentioned or not.

Jeff Massey [01:47:23]:
But I thought it was quite appropriate. Error 404. Your haiku could not be found. Try again later. Have a great week, everybody.

Jonathan Bennett [01:47:37]:
That's great. I'm tired of seeing 404s on the Internet, but yes, very good. All right, thank you guys for being here. It has been a blast. The one thing that I will plug is of course Hackaday and Floss Weekly there. And we had a great show this past week talking about rust and some of the things going on in the rust world and commercialization. This upcoming week, we've got something really special. We're talking with Tris, a lawyer out of England that I met at the Ubuntu Summit.

Jonathan Bennett [01:48:07]:
And there's certain combinations that just give people superpowers. One of those combinations is being both a lawyer and a CPA. I think another of those is being a lawyer and a programmer, someone that understands technology, and that is Tris. He came to the Ubuntu Summit of his own accord and also holds a law degree. And he has got some amazing stories about things that they have done and looking very much forward to get to talk to him on Floss Wiki. That's this Tuesday. Probably going to start a few minutes early, so make sure to be there for that or at least download it later and listen to it. It will be worth it, I'm sure.

Rob Campbell [01:48:43]:
Sure.

Jonathan Bennett [01:48:44]:
Other than that, just want to say thank you to everybody that's here. Everybody that comes. Whether you watch or listen, whether you get us live or on the download, we sure appreciate it. We'll be back. We'll see you next week on the Untitled Linux Show.