A Developer's Review of a Snapdragon X Laptop (Lenovo Yoga Slim 7x)

wes@wezm.net (Wesley Moore) — Tue, 16 Jul 2024 07:19:09 +1000

Lenovo Yoga Slim 7x Snapdragon</figcaption> </figure>

For the last two weeks I’ve been testing out my new laptop, a Lenovo Yoga Slim 7x (14", Gen 9) Snapdragon</a>. This laptop is interesting because it’s one of the initial batch based on Qualcomm’s Snapdragon X Elite Arm CPUs</a>. In this post I aim to provide a detailed review of the device and the experience of using it from the perspective of a software developer. This post was written on the Yoga 7x.

Introduction & Purchasing</h3>
All prices are quoted in Australian dollars. You can select a different currency, which will use exchange rates at the time I purchased the laptop. Currency:
</th> </th></tr></thead>

CPU</td> Qualcomm Snapdragon X Elite X1E-78-100 Arm CPU, 12 cores, max Turbo up to 3.4GHz, all core turbo 3.4Ghz, with fan</td></tr>
RAM</td> 32Gb LPDDR5X-8448</td></tr>
Storage</td> 1TB SSD M.2 2242 PCIe 4.0x4 NVMe</td></tr>
GPU</td> Qualcomm Adreno X integrated GPU</td></tr>
Display</td> 14.5" 3K (2944×1840) OLED 1000nits (Peak) / 500nits (Typical), 100% DCI-P3 with touchscreen</td></tr>
Camera</td> 1080p (2.0MP) + IR, with E-shutter, fixed focus</td></tr>
Speakers</td> 4 stereo speakers, 2 x 2W (woofers), 2 x 2W (tweeters), Dolby Atmos</td></tr>
Microphone</td> Quad-mic array</td></tr>
Ports</td> 3 x USB-C® (USB4® 40Gbps), with USB PD 3.1 and DisplayPort™ 1.4</td></tr>
Wi-Fi</td> Wi-Fi 7, 802.11be 2x2 Wi-Fi + Bluetooth 5.4</td></tr>
Battery</td> 70Wh</td></tr>
Power Adapter</td> 65W USB-C</td></tr>
Case Material</td> Aluminium</td></tr>
Weight</td> 1.28kg</td></tr> </tbody></table>
Qualcomm hyped up these CPUs for months before their release with frequent comparisons to Apple’s MacBook Air. While it seems unlikely that they would woo Mac users into switching, the point is that there are now laptops in the PC market that can compete with Apple’s M-series laptops.
The Yoga 7x sits somewhere in between the MacBook Air and the MacBook Pro spec-wise, while managing to be significantly cheaper than both. I configured a 15-inch MacBook Air^{1</a> and 14-inch MacBook Pro to similar specifications as my
7x and came up with the following:}
MacBook Air 15-inch

Apple M3 chip with 8-core CPU with four performance cores and four efficiency cores, fanless</li>
24GB unified memory</li>
1TB SSD storage</li>
15.3-inch Liquid Retina display (2880×1864), 500 nits brightness</li>
1080p FaceTime HD camera</li>
Two Thunderbolt/USB 4 ports</li>
70W USB-C Power Adapter</li> </ul> AU$3399
MacBook Pro 14-inch

Apple M3 Pro chip with 12-core CPU with six performance cores and six efficiency cores, with fan</li>
36GB unified memory</li>
1TB SSD storage</li>
14-inch Liquid Retina XDR display² with notch, 3024x1964

XDR brightness: 1,000 nits sustained full-screen, 1,600 nits peak 2</a> (HDR content only)</li>
SDR brightness: 600 nits</li>
ProMotion technology for adaptive refresh rates up to 120Hz</li> </ul> </li>
96W USB-C Power Adapter</li>
Three Thunderbolt 4 ports, HDMI port, SDXC card slot, headphone jack, MagSafe 3 port</li> </ul> AU$4799
The Air comes out AU$932 more than the Yoga 7x, and the Pro is whopping AU$2332 more (almost enough to buy a second Yoga 7x), but it is admittedly more full-featured.
Usage</h3>
Case Construction</h4>
</a>
Top of laptop, back to the reader.</figcaption> </figure>
The laptop is dressed in a lovely blue-grey colour that Lenovo call Cosmic Blue. The surface/colour of the case is a bit of fingerprint magnet but cleans up easily with a micro-fibre cloth. The build quality and construction is top-notch. The case is made of aluminium and is rigid and nicely finished. The edges are rounded (not sharp) and pleasant to touch/be in contact with.
Display</h4>
The display is amazing! It’s bright, with vivid colours and true blacks owing to the OLED technology. The bezels around the display are narrow and the entire display is usable as there is no notch. It came set to 60Hz by default but supports 90Hz as well. After changing it to 90Hz I didn’t initially notice much difference. However, after changing back to 60Hz I can see that scrolling in Firefox is a lot smoother with the 90Hz refresh rate. Windows 11 supports dynamic refresh rate but the 7x does not appear to be compatible.
</a>
Camera bump.</figcaption> </figure>
Instead of a notch there’s a slightly taller region at the top of the screen where the camera, and other sensors are. There is also a camera bump behind this part of the display. I saw at least one video deriding this, but I think it’s an excellent compromise. The bump on the top edge of the display is a nice affordance for your fingers when opening the laptop. It also means there’s no need for a cutout on the bottom half of the laptop like on MacBooks.
The movement of the display hinge is firm and smooth. It can be opened with one hand without the bottom lifting. When closing the lid there is a positive feel when the two halves meet, as though they are attracted to each other magnetically. There is a very thin plastic surround on the top half to prevent the display contacting the bottom half. I’ve not seen any keyboard prints on the display.
The laptop lid is rigid and does not exhibit wobble even when using it on your lap. The rigidity allows the touchscreen to work well too, although I’ve not really worked out how a touchscreen fits into my workflow. I tried the Precision Pen 2 that came with my Lenovo tablet on the screen but it didn’t work. It seems they sell a version specifically for laptops</a>.
Keyboard</h4>
</a>
Keyboard and trackpad. Yes, free of the tyranny of Intel Inside stickers what did Lenovo do? More stickers! The tall one peeled off ok, but you could see where it had been. A quick wipe with an alcohol swab sorted it out. I left the Snapdragon one on for now. I don't know what's wrong with me.</figcaption> </figure>
The keyboard is pleasant to type on. It has an unsurprising layout without any weird quirks. It has a firm feel and slightly more travel than my old laptop, which did take a moment to adjust to. It has full height left and right arrow keys, which I find bad for positioning without looking. I would have preferred an inverted-T layout like that on a MacBook. I also miss the dedicated Page Up/Down Home/End keys from the HP Aero.
There is an Fn key next to the outermost Ctrl key on the left for accessing function keys, as well as home, end, page up, and page down on the arrow keys. The UEFI has a “Fool Proof Fn Ctrl” feature enabled by default that will “Treat Fn as Ctrl when combined with non function key for some frequently-used shortcut key”.
Trackpad</h4>
The trackpad is quite large—in my opinion larger than it needs to be. The surface is pleasant to use and motion is accurate. Multitouch gestures work as expected. It is top-pivoting with a physical button underneath like pretty much all PC laptops. I would have preferred a haptic action like Apple’s, but I’m used to tap-to-click at this point. I have had the odd unintentional action from my palm or stray finger so perhaps the automatic rejection could be better.
Battery & Fan</h4>
The experience of using this laptop is superior to any other PC laptop I’ve owned. It runs cool and quiet and has an amazing battery life. Battery life is hard to quantify without time-consuming tests but Lenovo claims the following and I think they’re probably in the right ballpark:

MobileMark® 25@250nits: up to 16.4 hours</li>
Local video (1080p) playback@150nits: up to 23.8 hours</li> </ul>
I think I easily get double the runtime out of the 7x compared to the Aero. Depending on what you’re doing I think it would be perfectly feasible to go a typical work day without the need to plug in.
As I write this, the battery is down to 51% and it’s reporting 7h 25m left.
While almost any activity beyond the basic would spur the fan on my HP Aero into action the fan on the Yoga 7x pretty much only comes on when you’re doing something multicore intensive like compiling software. From what I’ve gathered it does turn on more frequently than a MacBook Pro, which I’ve heard need pretty strong motivation to get the fan going. I’d rate the fan pitch when it is running at higher speeds in the middle of the road—it’s not bad, but it’s not a neutral white noise type sound either.
Audio/Visual</h4>
The camera does not seem to be anything remarkable. In indoor conditions without any direct lighting of the subject it produces an image that shows heavy noise reduction but is fairly bright.
</a>
Photo of the author taken with the built-in webcam.</figcaption> </figure>
I have not used the built-in microphones. The speakers are extremely crisp and clear in mid and high ranges. They are capable of going very loud without distortion. As with most laptops the low-end bass is limited but better than some I’ve heard. I can feel very little vibration in the case even with the volume cranked.
There is no 3.5mm headphone jack. I paired some Bluetooth Sennheiser headphones but ran into an issue with audio being out of sync with the video when watching YouTube. These headphones work fine with iOS, Android, and Linux, so I’m not sure what going on with them in Windows. Some searching online suggests this is not an uncommon issue with Windows, but I suspect they’re a noisy minority—at least I’m hoping that’s the case.
Ports & Power</h4>
</a>
The left-side ports.</figcaption> </figure>
On the left hand side are two of the three USB-C ports. Between them is an LED that glows orange when charging and white when full. On the right hand side is the other USB-C port as well as a power button and camera privacy switch. The power button is a thin phone-style unit on the edge of the body. It has a small white LED the glows when the laptop is on and pulses slowly while it is sleeping.
</a>
The right-side ports.</figcaption> </figure>
Pressing the power button will sleep/wake the laptop. You must dwell with the button pressed for just a moment to have it work, which helps prevent accidental presses. Although, it is natural to brace the right side where the button is when plugging in something to the left, which can result in the power button being pressed if you aren’t careful.
</a>
The camera privacy switch. This sticker was easy to remove with the little red pull tab.</figcaption> </figure>
There is no fingerprint reader, instead Windows Hello uses the camera and IR sensor to use your face to authenticate. The utility of the camera privacy switch is somewhat diminished because it also prevents Windows Hello from working. If there was a separate fingerprint reader the camera could remain disabled unless it was specifically needed.
Waking from suspend is nearly instant. If opening the laptop it’s usually resumed and ready to go before you’ve finished moving the display into position.
</video>
Video showing the laptop waking from sleep. Windows Hello uses the camera to grant access without having to type in a password.</figcaption> </figure>
Compatibility & Gaming</h3>
The big question with a new architecture 2</a> is how much does it impact day-to-day activities. As with most things in the tech world: it depends. For a typical computer user the situation is quite good. Most, if not all the software included with Windows is Arm native. I do all my browsing with Firefox and a native Arm version of it has been available for many years</a>. The note-taking tool Obsidian</a> has an Arm native version, as does 1Password</a> (in preview), Rust Rover</a>, and Rufus</a> to name a few more.
However, there’s still plenty of software out there that assumes Windows = x86. For that there’s the Prism x86 emulator built into Windows</a>. This allows most x86 Windows applications to run seamlessly on Windows Arm, albeit with some hit to performance. The emulation is often not noticeable, aside from an initial delay when first launching an application.
I took note of the architecture of everything I installed. Of the 27 things I installed 44% were native.
Most x86 software I tried such as Inkscape</a> and Handbrake</a> ran fine. It wasn’t all perfect though. I installed Stardew Valley</a> using GOG Galaxy</a>, which went fine but when clicking the Play button it never started. There was a `stardewvalley.exe</code> process in Task Manager, but it never opened a window. Curiously, if the exe is run directly from Explorer then it works fine.`
`I also tried` `Factorio</a> and Cities Skylines</a> installed via Steam</a> (all x86 executables). Factorio ran great at the native resolution of the display and did a constant 60fps, at least in the early game. With a reduced (from native) resolution of 1600×900 Cities Skylines ran acceptably at 25–30fps in a city with a population of a bit under 10k.`
</a> Screenshot of Factorio taken while moving diagonally down and to the left.</figcaption> </figure> As you can probably guess I’m not much of a gamer and this is not a gaming PC, but for older, or lighter games it does just fine under emulation. I didn’t find a native game to try out, but I then I didn’t really try hard to find one either. WSL & Virtualisation</h3> Windows is a strange beast, an outlier in a world that has mostly settled on UNIX/POSIX inspired systems. Being the outlier there are a plethora of ways that Microsoft and the community have come up with to make it integrate with the rest of the computing world. The Windows Subsystem for Linux</a> (WSL) is one of them, and it works great on this system. I installed Debian GNU/Linux</a> as well as Chimera Linux</a> in WSL. Debian was installed using the built-in mechanism wsl --install -d Debian</code>. Chimera was installed manually by downloading the aarch64</code> root file system, gunzipping it and then importing it. Both distros work well. It was particularly satisfying to apt install x11-apps</code> in the Debian install, then run xeyes</code> and have it just work™. </a> xeyes running via WSL.</figcaption> </figure> WSL2 uses Hyper-V virtualisation under the covers but frustratingly creating virtual machines manually with Hyper-V requires Windows Pro and the 7x comes with Windows Home. Through a website of dubious legitimacy I was able to purchase a Windows Pro key for considerably less than the AU$169 Microsoft was asking on the Microsoft Store for a Home to Pro upgrade. After the updates were applied I fired up Hyper-V Manager and tried booting the Chimera Linux aarch64</code> ISO. The grub menu is shown promptly but after selecting an entry it seems to hang. I also tried a Debian ISO but got the same result. Some searching online revealed that I was not alone</a>. I let the Debian installer go for a while. It turns out that it is running, just at a glacial pace. This doesn’t seem to be an issue with Windows on Arm in general. I also have a Windows Dev Kit 2023</a> WIth a Snapdragon 8cx Gen 3 CPU and Hyper-V works fine on it. Hopefully this is just a bug/early issue that will be resolved. It’s also worth noting that Hyper-V is the only option for Windows on Arm. VMWare and Virtual Box only work on x86 systems. In desperation, I managed to get QEMU</a> running in the Msys2</a> environment. However, while the qemu-system-aarch64</code> binary is native it is emulating a system and there is no acceleration available. For lightweight systems such as Chimera Linux this works, but it’s not ideal. Development</h3> The development experience on this laptop is a bit of a mixed bag, which I will detail below. Rust</h4> Pretty much all my personal projects are implemented in Rust</a> and for the most part it works great. The one gotcha is that when using the MSVC toolchain on Windows for Arm the ring</code> crate requires that clang</code> is installed. This is straightforward to achieve with the Visual Studio Installer, but it’s not quite the just works experience you get on x86 Windows. rustup</code> is an x86 binary but the toolchain it installs is a native aarch64</code> one. Windows compatible Rust projects that don’t have C/C++ dependencies tend to build and run fine. I worked on a few my projects without issue and also published some releases to crates.io</a>. It is more challenging if C/C++ dependencies are involved. There’s multiple ways to approach them such as vcpkg</code> but I have so far avoided the issue. If I run into a project that has tricky dependencies I think I’ll use WSL. Python</h4> I tried to install pyinfra</a>, which as the name suggests is implemented in Python. Running python</code> in a PowerShell session opens up the Windows Store to the Python page if it’s not already installed. Initially I installed this version, but I noticed that it had installed the x86 version. Searching with winget</code> revealed a native version, so I uninstalled the Store version and reinstalled via winget</code>. I then tried to install pyinfa</code> into a venv and was met with failure. Pre-built wheels were not available for some packages, so it was attempting to build from source. I had Rust installed for my other work but cryptography</code> failed because it couldn’t find OpenSSL. I installed it via vcpkg</code> but it still complained about not being able to find OpenSSL despite my attempts to point it at it. pynacl</code> also failed to build because it couldn’t find make</code>. There has been an issue open on the pynacl</code> repo</a> since 2022 asking for Arm support. An issue requesting Arm Windows support for cryptography</code> was previously closed with the note: We won’t ship a wheel for a platform we can’t test in CI and GitHub does not currently offer arm64 windows runners. When they do we’ll revisit this though! </blockquote> Since GitHub have announced Arm Linux and Windows runners</a> I opened a new issue in cryptography</code> asking for Arm Windows support. I didn’t notice that the Arm runners are currently only available to GitHub Enterprise and Team plans though. So the cryptography</code> folks are still waiting for general availability before they are willing to tackle the issue. It’s pretty strange that Microsoft own GitHub and are making this push for developers to support Windows on Arm but still haven’t made Arm GitHub Actions runners available to the wider open-source community. At this point I suspected that the Microsoft Store may have been on to something when it installed the x86 version of Python. I uninstalled Python once again and replaced it with the Store version. This time pyinfa</code> installed and ran fine. Sadly it was at this point that I discovered that Hyper-V was broken as described earlier, so my pyinfra</code> experiments had to move to my Linux system. Node.js</h4> I hear JavaScript is pretty popular these days. I didn’t have a particular need to run Node.js</a> but wanted to try it out on this system. I installed a native Node.js via winget</code> and tried to build a couple of projects. Both failed to build due to a change that was made to address a security issue on Windows in April 2024</a>—The joys of being on the odd-one-out OS. I then thought I’d try building the TypeScript compiler—another Microsoft project. This was immediately blocked by the lack of a native binary for the dprint</code> package: Error: Cannot find module ‘@dprint/win32-arm64/package.json’ </blockquote> Again pretty wild that an extremely popular Microsoft project still doesn’t build on Windows for Arm despite the platform being years old at this point. dprint</code> is actually a Rust project, and in this case npm</code> is used to install it. Unlike the Python packages the dprint</code> npm package didn’t try to build a binary when a pre-built one was unavailable. I opened an issue on the repo suggesting that an Arm Windows binary be published. The maintainer was amazingly responsive and had a fix released the following day. They encountered issues building a native binary, but a script was changed to recognise win32-arm64</code> and install the pre-built x86 binary, which worked. After opening the issue on the dprint</code> repo I was having flashbacks to my Python experience, so I uninstalled node and used the installer on the Node.js website to install the x86 version. Perhaps unsurprisingly this worked fine, and I was able to build the TypeScript compiler. The takeaway from this and the Python experience (and likely Ruby too) is that these ecosystems are not ready for Windows on Arm yet. Unless your project and its dependencies have no dependencies on native binaries/libraries/extensions then you’re you’re better off using the x86 version for now. C/C++/C#</h4> Yes one of these is not like the others, but they all start with C, so together they go! I built a couple of C# projects that I came across on GitHub without drama in Visual Studio Community Edition. Note: The following section is mostly me complaining about Windows and is not specific to Windows on Arm. Feel free to skip. Most open-source projects I come across implemented in C or C++ use Makefiles, autotools, cmake, or meson to build. This isn’t specific to Windows on Arm but as far as I can tell you’re more or less sweet out of luck when it comes to Makefiles and autotools on Windows—you pretty much have to use a third-party toolchain like Msys2 to build these projects. camke</code> and meson</code> projects might work… I did some searching for a make</code> implementation that would run natively, by that I mean in PowerShell and not some other environment like Msys2. I did find ezwinports</a>, which seems to be a heroic effort by a single person, Eli Zaretskii to port various UNIX tools to Windows. I looked into installing the GNU make</code> port but there was this note about installing libgcc</code> and libstdc++</code>: Warning: all the ports produced since the year 2021 onwards depend on the libgcc DLL, and some depend on libstdc++-6.dll, which are not provided in the zip files. For the reasons, see below. If you don’t have these DLLs on your system, you can download them from this site: https://osdn.net/projects/mingw/releases Specifically, download and install these two archives: https://osdn.net/projects/mingw/downloads/72215/libgcc-9.2.0-3-mingw32-dll-1.tar.xz/ https://osdn.net/projects/mingw/downloads/72210/libstdc%2B%2B-9.2.0-3-mingw32-dll-6.tar.xz/ </blockquote> I have no idea where these are supposed to go and wasn’t really in the mood for going down this path, so I gave up and concluded if I ran into projects that needed make</code> or autotools I’d just use Linux (via WSL). I did revisit the topic about a week later though as I wanted to test an extremely basic Makefile in one of my projects. I found pymake</a>, which seems to have been created specifically to improve the make</code> experience on Windows. I was able to pip install py-make</code> and do what I needed to do in my project. Update 26 Jul 2024: Adam on Mastodon pointed out</a> that GNU make has a bat</code> file for building with MSVC on Windows. I tried this and it built successfully without the need to install any other dependencies. It did however build an x86 binary and not an Arm one. End rant I tried to find a nice little C or C++ project to test with that: Used cmake or meson</li> Was Windows compatible</li> Didn’t have extra dependencies to deal with</li> </ul> Those were hard to find. Eventually I settled on the Janet</a> scripting language, which built quickly and easily once I worked out what a Visual Studio Command Prompt was: D:\Source\janet>janet.exe Janet 1.35.2-local windows/aarch64/msvc - '(doc)' for help repl:1:> (print "Hello from Janet") Hello from Janet nil repl:2:></code></pre>Performance</h3> From feel alone the laptop performs very well. Actions are snappy and responsive. Web-browsing even on heavy websites does not bog down. First things first, these are the GeekBench scores I got on the Yoga 7x</a>: 2,457 Single-Core, 13,088 Multi-Core</li> </ul> For reference, my other systems: 2,966 Single-Core, 20,174 Multi-Core - Desktop Linux system with AMD Ryzen 7950X</a></li> 1,938 Single-Core, 6,348 Multi-Core - HP Aero Laptop</a></li> </ul> I wanted to find a relatively easy to reproduce “real-world” benchmark to include in this post so that other people can run the same benchmark to get an idea of how this system performs comparatively. I settled on the time to build the Gleam</a> programming language tooling. If you want to play along at home this is what you need to do (assuming you have Rust installed): Windows: git clone https://github.com/gleam-lang/gleam cd gleam git checkout v1.2.1 cargo fetch cargo clean; Measure-Command { cargo build --release --locked }</code></pre> Not Windows: git clone https://github.com/gleam-lang/gleam cd gleam git checkout v1.2.1 cargo fetch cargo clean && time cargo build --release --locked</code></pre> Some friends also graciously ran the test for me too. These are the results I collected. In each case the last line was run multiple times and I selected the fastest run, rounded to the nearest second. </th> Device</th> CPU</th> Topology</th> Arch</th> OS</th> rustc</th> Time</th></tr></thead> </td> Yoga 7x</td> X Elite</td> 12c</td> ARM</td> Debian 12 (WSL)</td> 1.79.0</td> 0:52</td></tr> </td> Yoga 7x</td> X Elite</td> 12c</td> ARM</td> Windows 11</td> 1.79.0</td> 0:60</td></tr> </td> Yoga 7x</td> X Elite</td> 12c</td> ARM</td> OpenBSD -current</td> 1.79.0</td> 4:04</td></tr> </td> </td> </td> </td> </td> </td> </td> </td></tr> </td> Desktop</td> Ryzen 9 7950X</a></td> 16c/32t</td> x86</td> Arch Linux</td> 1.79.0</td> 0:23</td></tr> </td> MacBook Pro</td> M3 Max</td> 12p/4e</td> ARM</td> macOS 14.5</td> 1.79.0</td> 0:34</td></tr> </td> Desktop</td> Ryzen 9 3900X</a></td> 12c/24t</td> x86</td> Arch Linux</td> 1.77.1</td> 0:44</td></tr> </td> Dell XPS 15</td> i7-13700H</a></td> 6p/8e</td> x86</td> Ubuntu 22.04 (WSL)</td> 1.79.0</td> 0:55</td></tr> </td> MacBook Pro</td> M1 Pro</td> 8p/2e</td> ARM</td> macOS 13.6.7</td> 1.76.0</td> 1:02</td></tr> </td> HP Aero</a></td> Ryzen 7 5800U</a></td> 8c/16t</td> x86</td> Arch Linux</td> 1.79.0</td> 1:09</td></tr> </td> HP Aero</a></td> Ryzen 7 5800U</a></td> 8c/16t</td> x86</td> Windows 11</td> 1.79.0</td> 2:03</td></tr> </td> Dev Kit 2023</a></td> 8cx Gen3</a></td> 8c</td> ARM</td> Windows 11</td> 1.79.0</td> 2:39</td></tr> </tbody></table> Key: c = core, t = thread, p = performance core, e = efficiency core Notes: As part of collecting these results I have noticed that the build time is heavily influenced by the memory allocator and possibly libc used by rustc</code>. On the exact same system with different Linux/allocator combinations I’ve seen times ranging from 24s to 1m55s, so as with all benchmarks they may be complete rubbish.</li> The tests I performed on the Yoga 7x were all in the Balanced power mode. I did try the Best Performance mode and it was about 3 seconds faster. However, it got hotter and the fan ran for longer after the build was finished. Since part of my motivation for wanting an Arm system is cooler, quieter computing I’m going to stick with the Balanced setting.</li> For Windows testing the code was checked out onto a Dev Drive</a> volume.</li> This machine was configured to use 14 cores in WSL and was not using a Dev Drive.</li> </ul> Overall I think the Snapdragon X Elite does very well. It’s in between an M1 Pro and an M3 Max, it handily beat my outgoing laptop (comparing Windows times), and it’s not far off a much more power hungry desktop AMD CPU from a few years ago. Copilot & AI</h3> The Yoga 7x is a so-called Copilot+PC because the SoC includes a neural processing unit (NPU) capable of more than 40 trillion Int8 operations per second (TOPS)—Qualcomm claim up to 45 TOPS. I have very little interest in these Copilot features. Although, I was honestly curious to try out Windows Recall after they announced the improvements to it. Alas, they canned it for the initial release and probably for good reason. There is a dedicated Copilot key on the keyboard as mandated by Microsoft. Pressing it opens an app with a chat interface a-la ChatGPT. It turns out the Copilot “app” is just an Edge “App”, an app-like shortcut for opening a website, in this case copilot.microsoft.com</code>. As a result it can be a bit janky and is completely dependent on an internet connection to render the UI and respond to prompts. </a> Copilot 'app' when you're offline.</figcaption> </figure> I did use it a few times when seeking answers for how to do something I know how to do on Linux in Windows. The responses were generally helpful. One detail I particularly like is that the response is marked up with numbered links intended to provide a source for the information. Belying its Edge underpinnings clicking these links opens in Edge instead of the default browser. </a> Copilot response with links to sources.</figcaption> </figure> Non-Windows Operating Systems</h3> As I mentioned at the start of this post I intend to run Linux on the 7x as soon as that is viable. Qualcomm has been upstreaming support to the Linux kernel for some time and looking over the Linux kernel mailing list there is a bunch more being proposed for Linux 6.11. Just to be sure Linux was definitely not functional yet I tried booting a Chimera Linux and Ubuntu-daily ISO. Perhaps worth noting that the 7x runs good old UEFI and after turning off Secure Boot loaded up grub off these Linux install disks just fine. However, after selecting an entry in grub it would say loading Linux then promptly reboot… definitely not working yet. Update Dec 2024: There’s still some rough edges, but Linux now works. See my post on running Ubuntu</a> for more details. All was not lost though. The keen eyed among you may have noticed the OpenBSD entry in the benchmark table. Yep OpenBSD runs on it right now. After resizing the Windows partition I was able to install a recent snapshot of OpenBSD -current. </a> OpenBSD running on the Yoga 7x.</figcaption> </figure> Now it’s all still pretty bleeding edge and I can’t say the experience is particularly good at this point. It runs pretty hot with the fan going most of the time. The built-in Wi-Fi didn’t work, so I had to use a USB Wi-FI dongle. There is no GPU acceleration and I couldn’t work out how to get fvwm to honor the X DPI settings so everything was tiny, at least Firefox honored it. Complaints aside this is proof, only a month or so after release that alternative OSes are pretty easy to run on these systems. Conclusion</h3> </a> YOGA</figcaption> </figure> Overall I’m very happy with the Yoga 7x. It has mostly met my expectations for a device this early in its release cycle. It is not without its quirks, bugs, and compromises, but I have a pretty high threshold for those things. Those compromises mean that computing on the PC Arm platform will not be for everyone, but I’m glad it’s now an option for the non-Mac users. It’s also worth noting that the X1E-78-100 CPU in the 7x is the bottom of the X Elite range, there’s two others with higher clock speeds announced by Qualcomm that should make for pretty nice machines too. If there’s anything about the Snapdragon X experience that I didn’t cover feel free to get in contact and I’ll do my best to answer any questions. Comments</h4> Lobsters</a></li> Hacker News</a></li> Reddit</a></li> </ul> Credits</h4> Foreign exchange rates</a></li> Apple logo</a></li> Windows logo</a></li> OpenBSD mascot</a></li> Tux</a></li> </ul> The 15-inch is the closest match in display resolution. ↩</a> </li> While Windows on Arm is not new the X Elite CPUs are the first ones to be widely adopted by PC manufacturers. ↩</a> </li> </ol> </section> Why Chimera Linux wes@wezm.net (Wesley Moore) — Thu, 04 Jul 2024 08:48:55 +1000 I received a reply to my Tech Stack 2024</a> post asking: Why Chimera Linux? I wrote a response that turned out longer than anticipated and figured I may as well post it here too. I’m not trying to convince you to use Chimera with this post, just note down why it appeals to me. That’s really the crux of it: there’s dozens of distros out there all with different goals and values and Chimera really speaks to me, for you it might be something else. Below is a lightly edited version of my email response. I like Chimera Linux</a> because it’s the closest distro I’ve found to what I would build if I was building my own (something I’ve tinkered with a few times over the years). I like that it is a comparatively small and easy to understand system without giving up quite as much as you do with Alpine Linux, which to be clear, I like as well and use on my server. The userland from FreeBSD</a> is capable and easy to understand code wise, Dinit</a> provides an init system with process monitoring, dependency tracking, and a service file format that doesn’t require writing shell scripts like in FreeBSD and Alpine. musl</a> is designed to be secure and uses quite straightforward implementations of libc functions while sticking closely to the POSIX standard. See the recent OpenSSH vulnerability where remote code execution was not possible on musl based systems</a>. I really like the cbuild</a> system for building packages. It uses a real programming language (Python) to define packages and share library code. This makes package templates easier to write and understand over Make and shell based packaging systems. Packages are built in an isolated sandbox, preventing them depending on the host system accidentally—this is definitely an advantage over building packages on Arch. Most run-time dependencies are automatically determined so you don’t have to list all those out in the package template. apk</a> is fast (although not as fast as Pacman when doing updates1</a>). It has a clever way of tracking packages where the world file</a> specifies all the packages that should be present and it uses a solver to determine what needs to be installed/removed. The neat bit is that when you apk del</code> a package it can remove all packages that are no longer specifically requested, whereas in Arch it’s easy to end up with orphaned packages that are dead weight and require manual maintenance to clean up</a>. Chimera is also a rolling distro (like Arch) so things stay up to date. There’s a low barrier to submitting new packages and updates, you don’t have to have a special “committer” or “developer” account, you can just open a pull request like any other open-source project. Packages in the repo are built automatically with a build bot server for all supported architectures, whereas I believe Arch is still working towards automated packaging. Additionally first class support for multiple CPU architectures allows me to run the same system on different devices I use such as Raspberry Pis, RISC-V single board computers, and hopefully eventually my new ARM based Snapdragon X Elite laptop</a>. Having written that all out I guess Chimera feels like a distro that is full-featured but also simple enough that you can poke around and understand all the parts. It’s also easy to get involved with the project. Pacman downloads in parallel (5 at a time in my config), then does the actual upgrades. apk</code> fetches one package at at time and then stages the upgrade before moving on to the next one. There’s a couple of related open issues: https://gitlab.alpinelinux.org/alpine/apk-tools/-/issues/10963</a></li> https://gitlab.alpinelinux.org/alpine/apk-tools/-/issues/5977</a></li> </ul> ↩</a></li> </ol> </section> How Much Is a Browser Worth? wes@wezm.net (Wesley Moore) — Wed, 03 Jul 2024 17:22:01 +1000 Apparently people are excited about funding independent browser efforts this week. I have little interest in funding yet another browser built in C++ in 2024 but Servo</a> is still alive. Since Mozilla refuse to let us directly fund Firefox I shall set up a recurring donation to Servo. The next question is how much is a web browser worth to me? Based on minutes spent using a browser, quite a lot! Once upon a time you could pay for Netscape. It seems that in 1996 Netscape 3.0 cost US$49</a>. Adjusting for inflation that’s US$97 in 2024. Let’s round that up to an even US$100. At the time of writing Numbat</a> tells me that’s AU$150 or AU$12.50 per month, which seems reasonable. Some other services for comparison (I don’t actually have an active YouTube Premium subscription): Netflix: AU$18.99/m</li> YouTube Premium: AU$16.99/m</li> JetBrains Rust Rover: US$129/y (AU$194, AU$16/m)</li> </ul> A browser is a least as useful as these, almost certainly more. So, I’ve set up a US$15/m (AU$22.50) recurring sponsorship on GitHub. I encourage you to do the same</a>. Tech Stack 2024 wes@wezm.net (Wesley Moore) — Sat, 01 Jun 2024 10:13:48 +1000 Inspired by Alex Chan’s Tools of the trade</a> post I thought I’d note down my current tech stack and then revisit it in a few years to see how things evolve. As per Alex’s post I’ll break it down into three sections: software, (development) tech stack, and hardware. </a> My desk. The computer is behind the displays.</figcaption> </figure> Software</h3> My dotfiles are public so if you’re curious about the configuration of some of the tools mentioned below check out https://github.com/wezm/dotfiles</a>. Linux</h4> I use Linux for everything. On my desktop machine, which I use for work as well as personal computing I run Arch Linux</a>. On my laptop, which is more of an ancillary device that I use for tinkering and occasional travel I run Chimera Linux</a>. My goal is to run Chimera on the desktop too (it actually dual boots already) but I need to get my work development environment working on it before I can do that. My desktop is my primary computer, the rest of the post will focus on that. Awesome</h4> I’ve been using the Awesome window manager</a> since 2019. It’s deceptively good. When I try out other desktop environments it’s surprising how many little details that Awesome gets right. It’s also very stable, meaning I don’t get surprise updates to my UI in new releases. However the writing is on the wall for X11. My current arrangement of two 4K 24" displays running at 2x scaling with one of them rotated to a portrait orientation is really pushing the limits of X11. It’s my goal to switch to a Wayland based system at some point in the future. Most likely System 76’s COSMIC desktop</a>, which I’ve been periodically testing during its development. Alacritty</h4> Somewhere around 75% of the windows I have open at any time are terminal windows. I like Alacritty</a> because it’s devoid of UI chrome and features like tabs. Awesome takes care of all window organisation so there is no need for tabs, splits and things like that. I also like that it’s responsive to use. Z Shell</h4> I’ve used the Z shell</a> since at least 2008. I’ve tried out some of the newer shells but quickly run into limitations or things I miss from Z shell. Some things I like about it: Extensive, full-featured completion support</li> Spelling correction/did you mean</li> Synced history: history across all shells is added to history after every command and available in all running shells.</li> Path expansion: ls /h/w/P/rss<Tab></code> → ls /home/wmoore/Projects/rsspls</code></li> Command stack (Esc-q</code>)</li> </ul> Espanso</h4> Espanso</a> is a text expander. It allows me to do things like type ;mdl</code> and have that be replaced with a Markdown link using the contents of the clipboard (E.g. [](<clipboard url>)</code>), or ;em</code> and have that be replaced with my email address. CLI</h4> I use a bunch of CLI tools, aside from standard POSIX/UNIX tools I use these a lot: bat</a> — cat</code> with syntax highlighting</li> fd</a> — file finder</li> fzf</a> — fuzzy finder (integrated with zsh and vim)</li> lsd</a> — ls</code> but better</li> ripgrep</a> — clever regex search</li> tig</a> — git TUI</li> paru</a> — pacman</code> wrapper</li> </ul> Obsidian</h4> I note down ideas, thoughts, howtos, and things in Obsidian</a>. I picked it because the notes store is just plain Markdown files and they sync between Linux and iOS. ZFS</h4> /home</code> on my system is a mirror of two 2Tb NVMe drives. I use ZFS</a> for its data integrity (resistance to bit rot), redundancy (I can lose a drive an not lose data), compression (compressratio</code> is 1.40x at the time of writing), and lightweight snapshots. I use zfs-autosnap</a> to periodically take snapshots of /home</code>, which allows me roll back files if I get them into an undesirable state. Text Editing</h4> I’m currently in a bit of transitional period with text editors: Rust Rover</a> for Rust</li> Zed</a> migration in progress for Rust</li> Neovim</a> for everything else, it’s hard to beat</li> </ul> I have started using Zed for Rust development. Ideally it would be my primary editor but it doesn’t support enough languages yet. I imagine I will shift more tasks to it as it continues to improve. 1Password</h4> I returned to 1Password</a> when they released the Linux version. Not a lot say here, it’s reliable and works across all the devices I use. Firefox</h4> Like everyone I use a web browser a lot. I use Firefox</a> as it’s fast, works well, is mostly user focused, has built-in ad blocking, and is not a made by Google. Multi-account containers</a> are a killer Firefox feature that allows me to segregate things like Google and Facebook off into their own little container. This separates them so that for my usual browsing I’m not logged into a Google or Facebook account so it’s harder for them to associate my activities across the web and on first-party sites (like Google Maps) with my account. I’ve read some people say that they can’t use Firefox because too many websites don’t work with it but I don’t run into this problem at all with the sites I visit. Stylus</h5> I don’t use a lot of browser extensions but Stylus</a> is a great one. It lets me apply custom styles to websites (or all sites). This enables me to fix poor font choices or hide that annoying Sign-In With Google across all websites. Shotwell</h4> I recently got a new DSLR and did some research to find a decent non-destructive photo editor and library manager. I settled on Shotwell</a> and while I still dearly miss Aperture</a>, Shotwell gets the job done. keyd</h4> keyd</a> lets me customise and remap keys on my keyboard at the system level so that it works everywhere. I previously relied solely on programmable mechanical keyboards for this functionality but I’ve now been able to use a board that does not have a customisable firmware with the help of keyd</code>. CopyQ</h4> Clipboard history is an essential part of any desktop computing environment and CopyQ</a> is what provides it for me. Dev Stack</h3> Rust</h4> Pretty much all software I write these days in done with Rust</a>. I also use a lot of software written in Rust as it tends to be efficient with resources, reliable, and easy for me to delve into the code if needed. mold</h4> Linking is slow, I do a lot of linking working on personal and work projects. Mold</a> makes this faster. Rocket</h4> For building web applications my go-to is Rocket</a>. It’s not quite as batteries included as something like Rails</a> but it includes a lot of stuff that’s missing from other Rust options. Zola</h4> For blogs and simple static sites I love Zola</a>. It’s full-featured, customisable, and super fast. Gleam</h4> On occasions I need to write code targeting JavaScript. When that is non-trivial I’ve been reaching for Gleam</a>. It’s kinda of like Elm but actively maintained and with fewer restrictions. Hardware</h3> Desktop Computer</h4> My computer is a desktop machine that I assembled myself in 2023: AMD Ryzen 9 7950X 16-Core/32-Thread Processor</li> 64 Gb DDR5 6000 MT/s RAM</li> Storage: Root disk: Crucial T700 1TB PCIe Gen5 NVMe M.2 SSD</li> /home: 2x WD_BLACK 2TB SN850X PCIe Gen4 NVMe in ZFS mirror</li> </ul> </li> AMD Radeon RX 6700 XT GPU with 12Gb VRAM</li> 2x Dell 24" 4K displays, one in portrait orientation</li> Razer Kiyo web cam</li> Audio Technica ATR2100X microphone</li> Logi Lift vertical mouse + BenQ ZOWIE FK2-C mouse</li> WK870 mechanical keyboard</a> with Gateron G Pro 2.0 brown switches</li> </ul> All of this is packed into a monstrous Fractal Design Torrent case</a> with a lot of slow, quiet fans to try to keep all the hot things under control. This build was optimised for my development activities (both work and personal) with occasional gaming. For future comparisons it does a clean Prince</a> build1</a> in 1m50s and scores 2966/20174 in Geekbench 6. In early 2024 I started having trouble with pain in my hands from mousing. For nearly 20 odd years I’ve alternated mouse hands to load balance the wear on my hands. However this was an issue in both. That led me to try a vertical mouse, which didn’t initially help. I then tried a wrist rest but it was super hard and the pain remained. I got a different softer one and now the vertical mouse is comfortable and my hands have stopped complaining. Laptop</h4> My laptop is a 13“ HP Pavilion Aero Laptop 13-be0203AU I bought it because it was cheap (~AU$1000), had an 8 core AMD CPU, and was lightweight (~1kg). The case construction is not great as parts of it are painted plastic, which has dings and scratches on it now. In contrast to my old 2013 MacBook Pro, which still looks new. I’ve pre-ordered a Lenovo Yoga Slim 7x (14“, Gen 9) Snapdragon to replace this machine. It’s got one of the new Snapdragon X Elite ARM CPUs in it. I expect I’ll have to make do with Windows & WSL until Linux support for this new hardware catches up. time ./bin/build prince</code> with mold</code> as linker. ↩</a> </li> </ol> </section> Exporting YouTube Subscriptions to OPML and Watching via RSS wes@wezm.net (Wesley Moore) — Mon, 06 May 2024 10:38:22 +1000 This post describes how I exported my 500+ YouTube subscriptions to an OPML file so that I could import them into my RSS reader. I go into fine detail about the scripts and tools I used. If you just want to see the end result the code is in this repository</a>, which describes the steps needed to run it. I was previously a YouTube Premium subscriber but I cancelled it when they jacked up the already high prices. Since then I’ve been watching videos in NewPipe</a> on my Android tablet or via an Invidious</a> instance on real computers. To import my subscriptions into NewPipe I was able to use the subscriptions.csv</code> file included in the Google Takeout dump of my YouTube data. This worked fine initially but imposed some friction when adding new subscriptions. If I only subscribed to new channels in NewPipe they were only accessible on my tablet. If I added them to YouTube then I had to remember to also add them in NewPipe, which was inconvenient if I wasn’t using the tablet at the time. Inevitably the subscriptions would drift out of sync and I would have to periodically re-import the subscriptions from YouTube into NewPipe. This was cumbersome as it doesn’t seem to have a way to do this incrementally. Last time I had to nuke all its data in order to re-import. To solve these problems I wanted to manage my subscriptions in my RSS reader, Feedbin</a>. This way Feedbin would track my subscriptions and new/viewed videos in a way that would sync between all my devices. Notably this is possible because Google actually publishes an RSS feed for each YouTube channel. To do that I needed to export all my subscriptions to an OPML file that Feedbin could import. I opted to do that without requesting another Google Takeout dump as they take a long time to generate and also result in multiple gigabytes of archives I have to download (it includes all the videos I’ve uploaded to my personal account) just to get at the subscriptions.csv</code> file within. Generating OPML</h3> I started by visiting my subscriptions page</a> and using some JavaScript to generate a JSON array of all the channels I am subscribed to: copy(JSON.stringify(Array.from(new Set(Array.prototype.map.call(document.querySelectorAll('a.channel-link'), (link) => link.href))).filter((x) => !x.includes('/channel/')), null, 2))</code></pre> This snippet: queries the page for all channel links</li> gets the link URL of each matching element</li> Creates a Set</code> from them to de-duplicate them</li> Turns the set back into an Array</code></li> filters out ones that contain /channel/</code> to exclude some links like Trending that also appear on that page</li> Turns the Array into pretty printed JSON</li> Copies it to the clipboard</li> </ul> With the list of channel URLs on my clipboard I pasted this into a subscriptions.json</code> file. The challenge now was that these URLs were of the channel pages like: https://www.youtube.com/@mooretech</code> but the RSS URL of a channel is like: https://www.youtube.com/feeds/videos.xml?channel_id=<CHANNEL_ID></code>, which means I needed to determine the channel id for each page. To do that without futzing around with Google API keys and APIs I needed to download the HTML of each channel page. First I generated a config file for curl</code> from the JSON file: jaq --raw-output '.[] | (split("/") | last) as $name | "url \(.)\noutput \($name).html"' subscriptions.json > subscriptions.curl</code></pre> jaq</a> is an alternative implementation of jq</a> that I use. This jaq</code> expression does the following: .[]</code> iterate over each element of the subscriptions.json</code> array.</li> (split("/") | last) as $$name</code> split the URL on /</code> and take the last element, storing it in a variable called $name</code>. for a URL like https://www.youtube.com/@mooretech</code> this stores @mooretech</code> in $name</code>.</li> </ul> </li> "url \(.)\noutput \($$name).html"</code> generates the output text interpolating the channel page url and channel name.</li> </ul> This results in lines like this for each entry in subscriptions.json</code>, output to subscriptions.curl</code>: url https://www.youtube.com/@mooretech output @mooretech.html</code></pre> I then ran curl</code> against this file to download all the pages: curl --location --output-dir html --create-dirs --rate 1/s --config subscriptions.curl</code></pre> --location</code> tells curl to follow redirects, for some reason three of my subscriptions redirected to alternate names when accessed.</li> --output-dir</code> tells curl to output the files into the html</code> directory.</li> --create-dirs</code> tells curl to create output directories if they don’t exist (just the html</code> one in this case).</li> --rate 1/s</code> tells curl to only download at a rate of 1 page per second—I was concerned YouTube might block me if I requested the pages too quickly.</li> --config subscriptions.curl</code> tells curl to read additional command line arguments from the subscriptions.curl</code> file generated above.</li> </ul> Now that I had the HTML for each channel I needed to extract the channel id from it. While I was processing each HTML file I also extracted the channel title for use later. For each HTML file I ran this script on it. I called the script generate-json-opml</code>: #!/bin/sh set -eu URL="$1" NAME=$(echo "$URL" | awk -F / '{ print $NF }') HTML="html/${NAME}.html" CHANNEL_ID=$(scraper -a content 'meta[property="og:url"]' < "$HTML" | awk -F / '{ print $NF }') TITLE=$(scraper -a content 'meta[property="og:title"]' < "$HTML") XML_URL="https://www.youtube.com/feeds/videos.xml?channel_id=${CHANNEL_ID}" json_escape() { echo "$1" | jaq --raw-input . } JSON_TITLE=$(json_escape "$TITLE") JSON_XML_URL=$(json_escape "$XML_URL") JSON_URL=$(json_escape "$URL") printf '{"title": %s, "xmlUrl": %s, "htmlUrl": %s}\n' "$JSON_TITLE" "$JSON_XML_URL" "$JSON_URL" > json/"$NAME".json</code></pre> Let’s break that down: The channel URL is stored in URL</code>.</li> The channel name is determined by using awk</code> to split the URL on /</code> and take the last element.</li> The path to the downloaded HTML page is stored in HTML</code>.</li> The channel id is determined by finding the <meta></code> tag in the html with a property</code> attribute of og:url</code> (the OpenGraph metadata</a> URL property). This URL is again split on /</code> and the last element stored in CHANNEL_ID</code>. Querying the HTML is done with a tool called scraper</a> that allows you to use CSS selectors to extract parts of a HTML document.</li> </ul> </li> The channel title is done similarly by extracting the value of the og:title</code> metadata.</li> The URL of the RSS feed for the channel is stored in XML_URL</code> using CHANNEL_ID</code>.</li> A function to escape strings destined for JSON is defined. This makes use of jaq</code>.</li> TITLE</code>, XML_URL</code>, and URL</code> are escaped.</li> Finally we generate a JSON object with the title, URL, and RSS URL and write it into a json</code> directory under the name of the channel.</li> </ul> Update: Stephen pointed out on Mastodon</a> that the HTML contains the usual <link rel="alternate"</code> tag for RSS auto-discovery. I did check for that initially but I think the Firefox dev tools where having a bad time with the large size of the YouTube pages and didn’t show me any matches at the time. Anyway, that could have been used to find the feed URL directly instead of building it from the og:url</code>. Ok, almost there. That script had to be run for each of the channel URLs. First I generated a file with just a plain text list of the channel URLs: jaq --raw-output '.[]' subscriptions.json > subscriptions.txt</code></pre> Then I used xargs</code> to process them in parallel: xargs -n1 --max-procs=$(nproc) --arg-file subscriptions.txt --verbose ./generate-json-opml</code></pre> This does the following: -n1</code> read one line from subscriptions.txt</code> to be passed as the argument to generate-json-opml</code>.</li> --max-procs=$(nproc)</code> run up the number of cores my machine has in parallel.</li> --arg-file subscriptions.txt</code> read arguments for generate-json-opml</code> from subscriptions.txt</code>.</li> --verbose</code> show the commands being run.</li> ./generate-json-opml</code> the command to run (this is the script above).</li> </ul> Finally all those JSON files need to be turned into an OPML file. For this I used Python: #!/usr/bin/env python import email.utils import glob import json import xml.etree.ElementTree as ET opml = ET.Element("opml") head = ET.SubElement(opml, "head") title = ET.SubElement(head, "title") title.text = "YouTube Subscriptions" dateCreated = ET.SubElement(head, "dateCreated") dateCreated.text = email.utils.formatdate(timeval=None, localtime=True) body = ET.SubElement(opml, "body") youtube = ET.SubElement(body, "outline", {"title": "YouTube", "text": "YouTube"}) for path in glob.glob("json/.json"): with open(path) as f: info = json.load(f) ET.SubElement(youtube, "outline", info, type="rss", text=info["title"]) ET.indent(opml) print(ET.tostring(opml, encoding="unicode", xml_declaration=True))</code></pre> This generates an OPML file (which is XML) using the ElementTree library. The OPML file has this structure: <?xml version='1.0' encoding='utf-8'?> <opml> <head> <title>YouTube Subscriptions</title> <dateCreated>Sun, 05 May 2024 15:57:23 +1000</dateCreated> </head> <body> <outline title="YouTube" text="YouTube"> <outline title="MooreTech" xmlUrl="https://www.youtube.com/feeds/videos.xml?channel_id=UCLi0H57HGGpAdCkVOb_ykVg" htmlUrl="https://www.youtube.com/@mooretech" type="rss" text="MooreTech" /> </outline> </body> </opml></code></pre> It does the following: Generates the top level OPML structure.</li> For each JSON file, read and parse the JSON and then use that to generate an outline</code> entry for that channel.</li> Indent the OPML document.</li> Write it to stdout using a Unicode encoding with an XML declaration (<?xml version='1.0' encoding='utf-8'?></code>).</li> </ul> Whew that was a lot! With the OPML file generated I was finally able to import all my subscriptions into Feedbin. All the code is available in this repository</a>. In practice I used a Makefile</code> to run the various commands so that I didn’t have to remember them. Watching videos from Feedbin</h3> Now that Feedbin is the source of truth for subscriptions, how do I actually watch them? I set up the FeedMe</a> app on my Android tablet. In the settings I enabled the NewPipe integration and set it to open the video page when tapped: </a> Screenshot of the FeedMe integration settings</figcaption> </figure> Now when viewing an item in FeedMe there is a NewPipe button that I can tap to watch it: </a> Screenshot of FeedMe viewing a video item</figcaption> </figure> Closing Thoughts & Future Work</h3> Could I have done all the processing to generate the OPML file with a single Python file? Yes, but I rarely write Python so I preferred to just cobble things together from tools I already knew. Should I ever become a YouTube Premium subscriber again I can continue to use this workflow and watch the videos from the YouTube embeds that Feedbin generates, or open the item in the YouTube app instead of NewPipe. At some point I’d like to work out how to get Feedbin to filter out YouTube Shorts. It has the ability to automatically filter items matching any of the supported search syntax</a> but I’m not sure if Shorts are easily identifiable. Update 6 June 2024: Feedbin has a media_duration</code> search term. I was able to use that in an action</a> to filter out YouTube items less than 90 seconds long, successfully filtering out Shorts. </a> Shorts filter in Feedbin</figcaption> </figure> Lastly, what about desktop usage? When I’m on a real computer I read my RSS via the Feedbin web app. It supports custom sharing integrations</a>. In order to open a video on an Invidious instance I need to rewrite it from a URL like: https://www.youtube.com/watch?v=u1wfCnRINkE</a> to one like: https://invidious.perennialte.ch/watch?v=u1wfCnRINkE</a>. I can’t do that directly with a Feedbin custom sharing service definition but it would be trivial to set up a little redirector application to do it. I even published a video on building a very similar thing</a> last year. Alternatively I could install a redirector browser plugin</a>, although that would require set up on each of the computers and OS installs I use so I prefer the former option. Comments</h3> Fediverse</a></li> Lobsters</a></li> </ul> 7bit Projects: Dew Point Forecast, MacBinary, RSS Please, Titlecase wes@wezm.net (Wesley Moore) — Sat, 04 May 2024 16:20:49 +1000 Today I compiled my titlecase</a> Rust crate to Web Assembly and wrapped a web-page around it so that it can be used online. It’s published on my “projects domain”, 7bit.org</a>. After I published it I realised I hadn’t written about the other projects that are on 7bit.org</code>. They are Dew Point Forecast, MacBinary, RSS Please, and Titlecase. A few years ago I decided that it was a bad idea to speculatively register domains for projects because: I don’t finish all (cough* most) projects</li> They get expensive</li> </ol> In an attempt to curb spending on domain names I searched for a short, nondescript domain to use as a dumping ground for projects that were complete, but not significant enough to warrant their own domain. Thus 7bit.org</code> was born. So far I’ve published four projects to it, all of which are open-source. Titlecase</h3> Titlecase</a> is one of the earliest Rust crates I wrote. The first commit was in 2017. It converts text into title case. Specifically it uses a style described by John Gruber</a> for post titles on his website Daring Fireball</a>. Instead of simply capitalizing each word titlecase</code> does the following (amongst other things): Lower case small words like an, of, or in.</li> Don’t capitalize words like iPhone.</li> Don’t interfere with file paths, URLs, domains, and email addresses.</li> Always capitalize the first and last words, even if they are small words or surrounded by quotes.</li> Don’t interfere with terms like “Q&A”, or “AT&T”.</li> Capitalize small words after a colon.</li> </ul> I have compiled it to WebAssembly so that it can be used online</a>. </a> Screenshot of the Titlecase web page</figcaption> </figure> RSS Please</h3> RSS Please</a> is a tool to generate RSS feeds from web pages. It uses CSS selectors to extract parts of the page to generate the feed from. It’s implemented as a command line tool in Rust. </a> Screenshot of the RSS Please website</figcaption> </figure> Dew Point Forecast</h3> Dew Point Forecast</a> provides weather forecasts that include the dew point. The dew point relates to how humid it feels. It’s a better measure than relative humidity as the value does not vary with the air temperature the way the relative humidity percentage does. I built this one after moving to Queensland in 2021 and it was the first project published to 7bit.org</code>. It’s implemented in Rust using the Rocket</a> web framework. </a> Dewpoint forecast for Brisbane</figcaption> </figure> MacBinary</h3> MacBinary</a> allows inspection and downloading of individual components in MacBinary encoded files that were used by the classic Mac OS. It’s available as a Rust crate for use in third-party projects. I have compiled it to WebAssembly for use on the web page</a>. I wrote more about this project in this post</a>. </a> Screenshot of the MacBinary web page</figcaption> </figure> Comments</h3> Fediverse</a></li> </ul> Testing a $4 Micro SD Card From AliExpress wes@wezm.net (Wesley Moore) — Sun, 07 Apr 2024 15:06:25 +1000 I needed three low capacity micro SD cards for an upcoming project. There’s plenty of these available on AliExpress but its very difficult to know if you if the actual capacity will match the packaging. I did some research and came across this interesting video</a> that tested 16 different cards. Their recommendation was the Lexar ones. So I found some 32Gb ones for AU$4.13</a> and placed an order1</a>. </a> The card being tested.</figcaption> </figure> As per the video’s suggestion I tested one with an open-source tool called F3 (Fight Flash Fraud)</a> when they arrived. F3 verifies the capacity against what the drive advertises and verifies that that amount of data can be written and read back without error. The card passed all tests. The packaging said up to 100MB/s read and is marked C10/U1/V10, which is minimum 10MB/s sequential write. The tests showed a write speed of 30.7MB/s and a read speed of 90.9MB/s, which feels within the values advertised. No idea what the endurance of the flash memory will end up being but I intend to use them in a low-write environment, where failure doesn’t really matter. If the data the cards was storing was not easily replaced, such as photos, I would still purchase from a repeatable local seller. However, for holding an operating system image for a non-critical single board computer these seem fine. Full Results</h3> $ doas f3probe --destructive --time-ops /dev/sde F3 probe 8.0 Copyright (C) 2010 Digirati Internet LTDA. This is free software; see the source for copying conditions. WARNING: Probing normally takes from a few seconds to 15 minutes, but it can take longer. Please be patient. Good news: The device `/dev/sde' is the real thing Device geometry: Usable size: 29.54 GB (61952000 blocks) Announced size: 29.54 GB (61952000 blocks) Module: 32.00 GB (2^35 Bytes) Approximate cache size: 0.00 Byte (0 blocks), need-reset=no Physical block size: 512.00 Byte (2^9 Bytes) Probe time: 1'02" Operation: total time / count = avg time Read: 347.8ms / 4815 = 72us Write: 1'02" / 4192321 = 14us Reset: 0us / 1 = 0us $ f3write /run/media/wmoore/8BF0-E09E/ F3 write 8.0 Copyright (C) 2010 Digirati Internet LTDA. This is free software; see the source for copying conditions. Free space: 29.53 GB Creating file 1.h2w ... OK! Creating file 2.h2w ... OK! Creating file 3.h2w ... OK! Creating file 4.h2w ... OK! Creating file 5.h2w ... OK! Creating file 6.h2w ... OK! Creating file 7.h2w ... OK! Creating file 8.h2w ... OK! Creating file 9.h2w ... OK! Creating file 10.h2w ... OK! Creating file 11.h2w ... OK! Creating file 12.h2w ... OK! Creating file 13.h2w ... OK! Creating file 14.h2w ... OK! Creating file 15.h2w ... OK! Creating file 16.h2w ... OK! Creating file 17.h2w ... OK! Creating file 18.h2w ... OK! Creating file 19.h2w ... OK! Creating file 20.h2w ... OK! Creating file 21.h2w ... OK! Creating file 22.h2w ... OK! Creating file 23.h2w ... OK! Creating file 24.h2w ... OK! Creating file 25.h2w ... OK! Creating file 26.h2w ... OK! Creating file 27.h2w ... OK! Creating file 28.h2w ... OK! Creating file 29.h2w ... OK! Creating file 30.h2w ... OK! Free space: 0.00 Byte Average writing speed: 30.71 MB/s $ f3read /run/media/wmoore/8BF0-E09E/ F3 read 8.0 Copyright (C) 2010 Digirati Internet LTDA. This is free software; see the source for copying conditions. SECTORS ok/corrupted/changed/overwritten Validating file 1.h2w ... 2097152/ 0/ 0/ 0 Validating file 2.h2w ... 2097152/ 0/ 0/ 0 Validating file 3.h2w ... 2097152/ 0/ 0/ 0 Validating file 4.h2w ... 2097152/ 0/ 0/ 0 Validating file 5.h2w ... 2097152/ 0/ 0/ 0 Validating file 6.h2w ... 2097152/ 0/ 0/ 0 Validating file 7.h2w ... 2097152/ 0/ 0/ 0 Validating file 8.h2w ... 2097152/ 0/ 0/ 0 Validating file 9.h2w ... 2097152/ 0/ 0/ 0 Validating file 10.h2w ... 2097152/ 0/ 0/ 0 Validating file 11.h2w ... 2097152/ 0/ 0/ 0 Validating file 12.h2w ... 2097152/ 0/ 0/ 0 Validating file 13.h2w ... 2097152/ 0/ 0/ 0 Validating file 14.h2w ... 2097152/ 0/ 0/ 0 Validating file 15.h2w ... 2097152/ 0/ 0/ 0 Validating file 16.h2w ... 2097152/ 0/ 0/ 0 Validating file 17.h2w ... 2097152/ 0/ 0/ 0 Validating file 18.h2w ... 2097152/ 0/ 0/ 0 Validating file 19.h2w ... 2097152/ 0/ 0/ 0 Validating file 20.h2w ... 2097152/ 0/ 0/ 0 Validating file 21.h2w ... 2097152/ 0/ 0/ 0 Validating file 22.h2w ... 2097152/ 0/ 0/ 0 Validating file 23.h2w ... 2097152/ 0/ 0/ 0 Validating file 24.h2w ... 2097152/ 0/ 0/ 0 Validating file 25.h2w ... 2097152/ 0/ 0/ 0 Validating file 26.h2w ... 2097152/ 0/ 0/ 0 Validating file 27.h2w ... 2097152/ 0/ 0/ 0 Validating file 28.h2w ... 2097152/ 0/ 0/ 0 Validating file 29.h2w ... 2097152/ 0/ 0/ 0 Validating file 30.h2w ... 1102208/ 0/ 0/ 0 Data OK: 29.53 GB (61919616 sectors) Data LOST: 0.00 Byte (0 sectors) Corrupted: 0.00 Byte (0 sectors) Slightly changed: 0.00 Byte (0 sectors) Overwritten: 0.00 Byte (0 sectors) Average reading speed: 90.93 MB/s</code></pre> While these were branded Lexar there’s really no way to know when ordering if they are genuine or not. The main thing I care about is whether they hold as much data as they say. ↩</a> </li> </ol> </section> Building a Hybrid Native Application With Gleam and Tauri wes@wezm.net (Wesley Moore) — Mon, 19 Feb 2024 09:56:49 +1000 I took a few hours this weekend to experiment with building a hybrid native app with Gleam and Tauri. This post is a summary of that project. If you’d just like to see the code, I have published that at: https://forge.wezm.net/wezm/gleam-tauri-experiment</a> </a> Screenshot of the application.</figcaption> </figure> Introduction</h3> Gleam</a> is statically typed functional language originally written to target the Erlang virtual machine. Now it also has a JavaScript back-end that allows Gleam code to run in the browser as well as in node.js</a> and Deno</a>. The generated JavaScript is quite readable similar to Elm</a> and ReScript</a>/ReasonML</a>. Gleam appeals to me as an option for writing front-end code because it’s stricter than TypeScript, has nominal types, is fast to compile, has a nice all-in-one developer experience like cargo with the gleam</code> CLI. One of the things that makes writing front-end applications in Gleam feasible is the delightful Lustre</a> package. It’s an implementation of the Elm architecture</a> in Gleam. If you’ve used Elm a Lustre application will look extremely familiar. In this context Gleam is kind of like an actively maintained Elm without the restrictions on interop with existing JavaScript code. To get started here’s some Gleam code that demonstrates a decent chunk of the language: import gleam/io import gleam/list import gleam/int pub type Temperature { F(Float) C(Float) } pub type Celsius { Celsius(Float) } pub fn main() { let temps = [C(22.0), C(-5.0), F(0.0), C(0.0), F(32.0)] io.debug(avg(temps)) } pub fn avg(measurements: List(Temperature)) -> Celsius { let sum = list.fold(measurements, 0.0, fn(sum, val) { let Celsius(c) = to_c(val) sum +. c }) let length = list.length(measurements) |> int.to_float Celsius(sum /. length) } fn to_c(temp: Temperature) -> Celsius { case temp { C(c) -> Celsius(c) F(f) -> Celsius({ f -. 32.0 } /. 1.8) } }</code></pre> When run it outputs: Celsius(1.8444444444444443)</code></pre> The generated JavaScript (as of Gleam v1.0.0-rc2) is shown below. While it’s certainly longer than what you might naively write in JavaScript directly it’s pretty clear what’s going on. import * as $int from "../gleam_stdlib/gleam/int.mjs"; import * as $io from "../gleam_stdlib/gleam/io.mjs"; import * as $list from "../gleam_stdlib/gleam/list.mjs"; import { toList, CustomType as $CustomType, divideFloat } from "./gleam.mjs"; export class F extends $CustomType { constructor(x0) { super(); this[0] = x0; } } export class C extends $CustomType { constructor(x0) { super(); this[0] = x0; } } export class Celcius extends $CustomType { constructor(x0) { super(); this[0] = x0; } } function to_c(temp) { if (temp instanceof C) { let c = temp[0]; return new Celcius(c); } else { let f = temp[0]; return new Celcius(divideFloat((f - 32.0), 1.8)); } } export function avg(measurements) { let sum = $list.fold( measurements, 0.0, (sum, val) => { let $ = to_c(val); let c = $[0]; return sum + c; }, ); let length = (() => { let _pipe = $list.length(measurements); return $int.to_float(_pipe); })(); return new Celcius(divideFloat(sum, length)); } export function main() { let temps = toList([ new C(22.0), new C(-5.0), new F(0.0), new C(0.0), new F(32.0), ]); return $io.debug(avg(temps)); }</code></pre>Building a Hybrid Native App</h3> 💡</div> Version Information I used the following pre-release versions of Gleam and Tauri: Gleam 1.0.0-rc2</li> Tauri 2.0.0-beta.1.</li> </ul> </aside> Tauri</a> is a framework for building hybrid native applications. By that I mean an application that uses native code for the back-end and web technology for the user interface. This is similar to Electron</a> except that Tauri does not include a copy of Chromium in every application, instead relying on the system web view on the host operating system. You implement your application logic in Rust and communicate with the UI by emitting and listening to events. The end result is a cross-platform desktop app that is a lot smaller than if it were built with Electron. This weekend I decided to try combining these things to see how feasible it would be to build a hybrid desktop app with Gleam and Tauri. I started by following the Tauri guide for setting up a Vite project</a>. Vite</a> is a bundler that takes care of transforming source files on the front-end as well is providing a nice auto-reloading development experience. Once that was working I initialised a Gleam project in the same directory: gleam new --name gleamdemo gleam-demo</code></pre> Note: I originally called my application videopls</code> there are still some references to it in the code. I then followed Erika Rowland’s guide to using Gleam with Vite</a>. This resulted in a simple counter demo running in the Tauri window. At this point the Gleam code was almost identical to Erika’s post. </a> Phase 1 complete.</figcaption> </figure> Now came the uncharted waters: how to integrate Tauri’s command system</a> to invoke commands in the back-end. Commands are a sort of in-process communication mechanism where the UI can invoke a function implemented in Rust on the back-end. I added a Tauri command to the back-end: // src-tauri/src/main.rs #[tauri::command] fn greet(name: &str) -> String { format!("Hello, {}!", name) }</code></pre> I then needed to be able to use the invoke</code> function</a> from the @tauri-apps/api npm package</a>. Following the pattern I observed in other Gleam packages I created a JavaScript file to act as a bridge between Gleam and @tauri-apps/api</code>: // src/ffi/commands.js import { invoke } from '@tauri-apps/api/core'; import { Ok, Error } from "../../build/dev/javascript/videopls/gleam.mjs"; export async function greet(name) { try { return new Ok(await invoke('greet', { name: name })); } catch (error) { return new Error(error.toString()); } }</code></pre> I could then define the external function in the Gleam code and call it: // src/demo.gleam @external(javascript, "./ffi/commands.js", "greet") pub fn greet(name: String) -> Promise(Result(String, String))</code></pre> The next challenge was greet</code> is an async function, so it returns a promise, which does not integrate into a lustre.simple</a> application well. Fortunately there is the less simple lustre.application</a> that adds effects. After looking at some existing code I was finally able to come up with a working solution. The full Gleam code is shown below. get_greeting</code> and do_get_greeting</code> being the main parts of interest. // src/demo.gleam import gleam/int import gleam/javascript/promise.{type Promise} import lustre import lustre/attribute as attr import lustre/element.{type Element} import lustre/element/html import lustre/event import lustre/effect.{type Effect} pub fn main() { let app = lustre.application(init, update, view) let assert Ok(dispatch) = lustre.start(app, "#app", Nil) dispatch } type Model { Model(count: Int, greeting: String, name: String) } fn init(_) -> #(Model, Effect(Msg)) { #(Model(0, "", ""), effect.none()) } pub type Msg { Increment Decrement Greet GotGreeting(String) UpdateName(String) } fn update(model: Model, msg: Msg) -> #(Model, Effect(Msg)) { case msg { Increment -> #(Model(..model, count: model.count + 1), effect.none()) Decrement -> #(Model(..model, count: model.count - 1), effect.none()) Greet -> #(model, get_greeting(model.name)) GotGreeting(greeting) -> #( Model(..model, greeting: greeting), effect.none(), ) UpdateName(name) -> #(Model(..model, name: name), effect.none()) } } fn get_greeting(name: String) -> Effect(Msg) { effect.from(do_get_greeting(name, _)) } fn do_get_greeting(name: String, dispatch: fn(Msg) -> Nil) -> Nil { greet(name) |> promise.map(fn(response) { case response { Ok(greeting) -> GotGreeting(greeting) Error(err) -> GotGreeting("Error: " <> err) } }) |> promise.tap(dispatch) Nil } @external(javascript, "./ffi/commands.js", "greet") pub fn greet(name: String) -> Promise(Result(String, String)) fn update_name(text: String) -> Msg { UpdateName(text) } // -- VIEW fn view(model: Model) -> Element(Msg) { let count = int.to_string(model.count) html.div([], [ html.h1([], [element.text("Gleam + Vite + Tauri")]), html.div([attr.class("field text-center")], [ html.label([attr.for("greet_name")], [element.text("Name")]), element.text(" "), html.input([ attr.type_("text"), attr.name("greet_name"), event.on_input(update_name), ]), ]), html.p([attr.class("text-center")], [ element.text(model.greeting <> " " <> count <> " ✨"), ]), html.div([attr.class("text-center")], [ html.button([event.on_click(Decrement)], [element.text("-")]), html.button([event.on_click(Increment)], [element.text("+")]), html.button([event.on_click(Greet)], [element.text("Greet")]), ]), ]) }</code></pre> I added a Greet</code> message for when the “Greet” button is clicked. The update</code> function that doesn’t update the model but calls get_greeting</code> as its side-effect. That builds an Effect</code> from do_get_greeting</code>, which calls the FFI function and maps the Result</code> to a GotGreeting</code> message containing the greeting or an error message. update</code> handles the GotGreeting</code> message by updating the model, which in turn updates the UI. I’m skipping over the Model</code>, view</code>, update</code> architecture of this Lustre application since it’s basically the Elm architecture</a>. A similar pattern is seen in Reason React, ReScript, and React with actions and reducers</a>. At this point I had worked out how to invoke Rust functions in the back-end via Tauri commands but I wanted to take it step further. In a real application you can imagine that the back-end might be performing actions that it needs to tell the UI about. For example, when updated data is available after a sync. To do this Tauri provides a way for both parts of the application to emit events with a payload, and listen for those events. It’s all very similar to how events work in JavaScript. I wanted to test this out by periodically having the back-end emit an event and have the UI listen for the event and update as a result. I decided to have the back-end emit the current time each second as a UNIX timestamp. Working out how to do this on back-end stumped me for a bit but I eventually worked out I could spawn a thread in the setup</code> function: // src-tauri/src/main.rs use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH}; use tauri::EventTarget; use tauri::Manager; fn main() { tauri::Builder::default() .setup(|app| { let app = app.handle().clone(); std::thread::spawn(move || { loop { let now = SystemTime::now(); let duration = now.duration_since(UNIX_EPOCH).unwrap(); app.emit_to(EventTarget::any(), "tick", duration.as_secs()) .unwrap(); std::thread::sleep(Duration::from_secs(1)); } }); Ok(()) }) .invoke_handler(tauri::generate_handler![greet]) .run(tauri::generate_context!()) .expect("error while running tauri application"); }</code></pre> In a production application you’d want a mechanism for cleanly shutting the thread down but for experimentation purposes I skipped that. Now I needed to listen for the tick</code> event in the UI. I added another glue function to the FFI file: // src/ffi/commands.js export async function listenForTick(handler) { await listen('tick', (event) => { handler(event.payload); }); }</code></pre> And added a function to the Gleam code to call it and dispatch a message when it was received: // src/demo.gleam fn bind_clock() -> Effect(Msg) { effect.from(fn(dispatch) { listen_for_tick(fn(time) { tick(time) |> dispatch }) Nil }) }</code></pre> As a first pass I just rendered the number in the UI but I then extended it to parse the timestamp into a JavaScript Date and render the stringified version of it. Surprisingly the gleam_javascript</a> package doesn’t have Date bindings yet so I created some for what I needed: // src/ffi/js_extra.js export function from_unix(timestamp) { return new Date(timestamp 1000); } export function date_to_string(date) { return date.toString(); }</code></pre> I think in an ideal world simple bindings like this (especially toString</code>) would be able to be expressed solely though the @external</code> attribute. That doesn’t seem to be possible yet but if it is please let me know. I bound those in Gleam: // src/demo.gleam pub type Date @external(javascript, "./ffi/js_extra.js", "from_unix") pub fn new_date(timestamp: Int) -> Date @external(javascript, "./ffi/js_extra.js", "date_to_string") pub fn date_to_string(date: Date) -> String</code></pre> and updated the application to use them. The result is a clock at the bottom of the page that updates each second: </video> </div> The final Gleam application looks like this: // src/demo.gleam import gleam/int import gleam/javascript/promise.{type Promise} import lustre import lustre/attribute as attr import lustre/element.{type Element} import lustre/element/html import lustre/event import lustre/effect.{type Effect} pub fn main() { let app = lustre.application(init, update, view) let assert Ok(dispatch) = lustre.start(app, "#app", Nil) dispatch } type Model { Model(count: Int, greeting: String, name: String, time: Int) } fn init(_) -> #(Model, Effect(Msg)) { #(Model(0, "", "", 0), bind_clock()) } pub type Msg { Increment Decrement Greet GotGreeting(String) UpdateName(String) Tick(Int) } fn update(model: Model, msg: Msg) -> #(Model, Effect(Msg)) { case msg { Increment -> #(Model(..model, count: model.count + 1), effect.none()) Decrement -> #(Model(..model, count: model.count - 1), effect.none()) Greet -> #(model, get_greeting(model.name)) GotGreeting(greeting) -> #( Model(..model, greeting: greeting), effect.none(), ) UpdateName(name) -> #(Model(..model, name: name), effect.none()) Tick(time) -> #(Model(..model, time: time), effect.none()) } } fn get_greeting(name: String) -> Effect(Msg) { effect.from(do_get_greeting(name, _)) } fn do_get_greeting(name: String, dispatch: fn(Msg) -> Nil) -> Nil { greet(name) |> promise.map(fn(response) { case response { Ok(greeting) -> GotGreeting(greeting) Error(err) -> GotGreeting("Error: " <> err) } }) |> promise.tap(dispatch) Nil } fn bind_clock() -> Effect(Msg) { effect.from(fn(dispatch) { listen_for_tick(fn(time) { tick(time) |> dispatch }) Nil }) } @external(javascript, "./ffi/commands.js", "greet") pub fn greet(name: String) -> Promise(Result(String, String)) type UnlistenFn = fn() -> Nil @external(javascript, "./ffi/commands.js", "listenForTick") pub fn listen_for_tick(handler: fn(Int) -> Nil) -> Promise(UnlistenFn) pub type Date @external(javascript, "./ffi/js_extra.js", "from_unix") pub fn new_date(timestamp: Int) -> Date @external(javascript, "./ffi/js_extra.js", "date_to_string") pub fn date_to_string(date: Date) -> String fn update_name(text: String) -> Msg { UpdateName(text) } fn tick(time: Int) -> Msg { Tick(time) } // -- VIEW fn view(model: Model) -> Element(Msg) { let count = int.to_string(model.count) let time = model.time |> new_date |> date_to_string html.div([], [ html.h1([], [element.text("Gleam + Vite + Tauri")]), html.div([attr.class("field text-center")], [ html.label([attr.for("greet_name")], [element.text("Name")]), element.text(" "), html.input([ attr.type_("text"), attr.name("greet_name"), event.on_input(update_name), ]), ]), html.p([attr.class("text-center")], [ element.text(model.greeting <> " " <> count <> " ✨"), ]), html.div([attr.class("text-center")], [ html.button([event.on_click(Decrement)], [element.text("-")]), html.button([event.on_click(Increment)], [element.text("+")]), html.button([event.on_click(Greet)], [element.text("Greet")]), ]), html.div([attr.class("clock text-center")], [ element.text("Clock: " <> time), ]), ]) }</code></pre>Conclusion</h3> I successfully built a hybrid native application with Gleam and Tauri. While what I built is clearly experimental code I think it was enough to work out the approach and patterns you could use to build a larger application. Using Gleam to build a web components or web front-ends seems quite feasible. Some unanswered questions I have from this experiment are: Does binding to external functions in the JS platform or npm packages always require some JS glue code? It seems it does at the moment.</li> What is the right way to import gleam.mjs</code> from JavaScript code?</li> What is the structure of the Gleam build</code> directory? I see dev</code> and prod</code> sub-directories.</li> Is the prod</code> on used when targeting JavaScript I can’t see any equivalent of Cargo’s --release</code> in the gleam</code> CLI help.</li> </ul> </li> </ul> </li> </ol> The full project code is available here: https://forge.wezm.net/wezm/gleam-tauri-experiment</a> Thanks</h4> Special thanks to the following folks: Hayleigh Thompson</a> for building Lustre.</li> Enderchief</a> for vite-gleam</a>, which makes it super easy to integrate Gleam code with Vite.</li> Erika Rowland</a> for her Gleam Vite guide</a>. The follow up on esgleam</code></a> is also good.</li> </ul> systemd-sysusers and Chimera Linux wes@wezm.net (Wesley Moore) — Mon, 18 Dec 2023 11:25:57 +1000 I use As the name implies systemd-sysusers</code> users (and groups) easier. System users are system processes to use for privilege separation. printing system runs as the _cups</code> In systemd-sysusers Before the introduction of systemd-sysusers</code> and groups that were required in the package generate scripts</a> from a template that as well as disable them when packages are uninstalled. handle things like the user/group already groups missing, failures creating users/groups, The generated scripts were then embedded tied to “pre-install”, “pre-upgrade”, For example, here is the scripts section chrony</code> NTP client/server:< As you can see this not super pretty and duplicated. Enter systemd-sysusers</code>. sysusers.conf</code>, which is installed is installed: u _chrony - "chrony When building the package cbuild</code> into usr/lib/sysusers.d</code> package, which contains the systemd-sysusers</code> In turn, the systemd-utils</code> </code></ As you can see individual packages are now of managing the system users and groups is delegated An added benefit of the removal of hook scripts add/delete) become more atomic. For example run and makes changes, then the install step script will not be rolled back. In contrast the package action has successfully been committed. the package action the transaction will be rolled run. Wrap Up</h3> I found learning about this change valuable hidden aspect of package management works, I see more posts like this feel free to let me Fixing OpenBSD panic dc_atapi_start: not wes@wezm.net (Wesley Moore) — Sun, 17 Sep ra-linux.org/">Chimera Linux</a> as the primary OS on my laptop (as opposed to my desktop, Chimera was created in 2021 and built from scratch and as the of components: ;www.kernel.org/">Linux</a></li> x2F;llvm.org/">LLVM</a></li> usl.libc.org/">Musl</a> with Scudo allocator</a></li> F;/github.com/chimera-linux/chimerautils">FreeBSD (with some NetBSD and OpenBSD too)</a></li> avmac.org/projects/dinit/">Dinit</a></li> x2F;/gitlab.alpinelinux.org/alpine/apk-tools">apk</a></li> x2F;/github.com/chimera-linux/cports/blob/e11b91cfa66cc5c45657de4b33215ccdff51b1b7/Usage.md">cbuild</a></li> very useful to me for seeing how a time. Watching it progress (and 2F;/pkgs.chimera-linux.org/packages?name=&arch=x86_64&origin=&maintainer=Wesley+Moore">maintaining some packages</a>) has helped expose up a typical Linux system, and ;www.freedesktop.org/software/systemd/man/latest/systemd-sysusers.html">systemd-sysusers</a> was introduced. Some folks might find this the role of pid 1/init. As ://davmac.org/projects/dinit/">Dinit</a> for this. Some standalone parts of systemd are ;li> previously (even though it’s probably before), so I thought I’d jot down (at the time of writing) in Chimera. id="what-is-systemd-sysusers">What is systemd-sysusers?</h3> is designed to make managing system users that a typically created for For example, the CUPS user. b.com/systemd/systemd/commit/1b99214789101976d6bbf75c351279584b071998">the commit that introduced sysusers</a> into systemd Lennart /etc/passwd and /etc/group of inspiration from information about system normal users these field for each user, but or shell, which is systems that can solely from static data and will never override and not via some user as this tool is supposed for creating system remote databases anyway. RPM scriptlets, instead of user descriptions in RPM to be created can either be chosen dynamic, in the file system, in IDs for files that shall be file, that should be are expected to patch with fixed UIDs for for RPM. Specifically are used to describe the system in Chimera Linux</h3> packages declared system users template.py</code> and cbuild</code> would added the users and groups, These scripts had to existing, tools for adding users or etc. into the final apk package as scripts and “post-deinstall” actions. (formatted by adbdump</code> as YAML) for the F;p> #2E3440;">scripts: pre-install: | #!/bin/sh _chrony_homedir=/var/lib/chrony system_users=_chrony _system_accounts_invoke() { local USERADD USERMOD [ -z "$system_users" -a -z "$system_groups" ] && return 0 if command -v useradd >/dev/null 2>&1; then USERADD="useradd" fi if command -v usermod >/dev/null 2>&1; then USERMOD="usermod" fi show_acct_details() { echo " Account: $1" echo " Description: '$2'" echo " Homedir: '$3'" echo " Shell: '$4'" [ -n "$5" ] && echo " Additional groups: '$5'" } group_add() { local _pretty_grname _grname _gid if ! command -v groupadd >/dev/null 2>&1; then echo "WARNING: cannot create $1 system group (missing groupadd)" echo "The following group must be created manually: $1" return 0 fi _grname="${1%:}" _gid="${1##:}" [ "${_grname}" = "${_gid}" ] && _gid= _pretty_grname="${_grname}${_gid:+ (gid: ${_gid})}" groupadd -r ${_grname} ${_gid:+-g ${_gid}} >/dev/null 2>&1 case $? in 0) echo "Created ${_pretty_grname} system group." ;; 9) ;; ) echo "ERROR: failed to create system group ${_pretty_grname}!"; return 1;; esac return 0 } # System groups required by a package. for grp in ${system_groups}; do group_add $grp || return 1 done # System user/group required by a package. for acct in ${system_users}; do _uname="${acct%:}" _uid="${acct##:}" [ "${_uname}" = "${_uid}" ] && _uid= eval homedir="\$${_uname}_homedir" eval shell="\$${_uname}_shell" eval descr="\$${_uname}_descr" eval groups="\$${_uname}_groups" eval pgroup="\$${_uname}_pgroup" [ -z "$homedir" ] && homedir="/var/empty" [ -z "$shell" ] && shell="/usr/bin/nologin" [ -z "$descr" ] && descr="${_uname} user" [ -n "$groups" ] && user_groups="-G $groups" if [ -n "${_uid}" ]; then use_id="-u ${_uid} -g ${pgroup:-${_uid}}" _pretty_uname="${_uname} (uid: ${_uid})" else use_id="-g ${pgroup:-${_uname}}" _pretty_uname="${_uname}" fi if [ -z "$USERADD" -o -z "$USERMOD" ]; then echo "WARNING: cannot create ${_uname} system account (missing useradd or usermod)" echo "The following system account must be created:" show_acct_details "${_pretty_uname}" "${descr}" "${homedir}" "${shell}" "${groups}" continue fi group_add ${pgroup:-${acct}} || return 1 ${USERADD} -c "${descr}" -d "${homedir}" \ ${use_id} ${pgroup:+-N} -s "${shell}" \ ${user_groups} -r ${_uname} >/dev/null 2>&1 case $? inhttps://github.com/systemd/systemd/commit/1b99214789101976d6bbf75c351279584b071998 0) echo "Created ${_pretty_uname} system user." ${USERMOD} -L ${_uname} >/dev/null 2>&1 if [ $? -ne 0 ]; then echo "WARNING: unable to lock password for ${_uname} system account" fi ;; 9) ${USERMOD} -c "${descr}" -d "${homedir}" \ -s "${shell}" -g "${pgroup:-${_uname}}" \ ${user_groups} ${_uname} >/dev/null 2>&1 if [ $? -eq 0 ]; then echo "Updated ${_uname} system user." else echo "WARNING: unable to modify ${_uname} system account" echo "Please verify that account is compatible with these settings:" show_acct_details "${_pretty_uname}" \ "${descr}" "${homedir}" "${shell}" "${groups}" continue fi ;; ) echo "ERROR: failed to create system user ${_pretty_uname}!" return 1 ;; esac done return 0 } _system_accounts_invoke 'chrony' '4.4' || exit $? post-deinstall: | #!/bin/sh _chrony_homedir=/var/lib/chrony system_users=_chrony _system_accounts_invoke() { local USERMOD [ -z "$system_users" ] && return 0 if command -v usermod >/dev/null 2>&1; then USERMOD="usermod" fi for acct in ${system_users}; do _uname="${acct%:}" comment="$( (getent passwd "${_uname}" | cut -d: -f5 | head -n1) 2>/dev/null )" comment="${comment:-user} - removed package ${1}" if [ -z "$USERMOD" ]; then echo "WARNING: cannot disable ${_uname} system user (missing usermod)" continue fi ${USERMOD} -L -d /var/empty -s /usr/bin/false \ -c "${comment}" ${_uname} >/dev/null 2>&1 if [ $? -eq 0 ]; then echo "Disabled ${_uname} system user." fi done return 0 } _system_accounts_invoke 'chrony' '4.4' || exit $? pre-upgrade: | #!/bin/sh _chrony_homedir=/var/lib/chrony system_users=_chrony _system_accounts_invoke() { local USERADD USERMOD [ -z "$system_users" -a -z "$system_groups" ] && return 0 if command -v useradd >/dev/null 2>&1; then USERADD="useradd" fi if command -v usermod >/dev/null 2>&1; then USERMOD="usermod" fi show_acct_details() { echo " Account: $1" echo " Description: '$2'" echo " Homedir: '$3'" echo " Shell: '$4'" [ -n "$5" ] && echo " Additional groups: '$5'" } group_add() { local _pretty_grname _grname _gid if ! command -v groupadd >/dev/null 2>&1; then echo "WARNING: cannot create $1 system group (missing groupadd)" echo "The following group must be created manually: $1" return 0 fi _grname="${1%:}" _gid="${1##:}" [ "${_grname}" = "${_gid}" ] && _gid= _pretty_grname="${_grname}${_gid:+ (gid: ${_gid})}" groupadd -r ${_grname} ${_gid:+-g ${_gid}} >/dev/null 2>&1 case $? in 0) echo "Created ${_pretty_grname} system group." ;; 9) ;; ) echo "ERROR: failed to create system group ${_pretty_grname}!"; return 1;; esac return 0 } # System groups required by a package. for grp in ${system_groups}; do group_add $grp || return 1 done # System user/group required by a package. for acct in ${system_users}; do _uname="${acct%:}" _uid="${acct##:}" [ "${_uname}" = "${_uid}" ] && _uid= eval homedir="\$${_uname}_homedir" eval shell="\$${_uname}_shell" eval descr="\$${_uname}_descr" eval groups="\$${_uname}_groups" eval pgroup="\$${_uname}_pgroup" [ -z "$homedir" ] && homedir="/var/empty" [ -z "$shell" ] && shell="/usr/bin/nologin" [ -z "$descr" ] && descr="${_uname} user" [ -n "$groups" ] && user_groups="-G $groups" if [ -n "${_uid}" ]; then use_id="-u ${_uid} -g ${pgroup:-${_uid}}" _pretty_uname="${_uname} (uid: ${_uid})" else use_id="-g ${pgroup:-${_uname}}" _pretty_uname="${_uname}" fi if [ -z "$USERADD" -o -z "$USERMOD" ]; then echo "WARNING: cannot create ${_uname} system account (missing useradd or usermod)" echo "The following system account must be created:" show_acct_details "${_pretty_uname}" "${descr}" "${homedir}" "${shell}" "${groups}" continue fi group_add ${pgroup:-${acct}} || return 1 ${USERADD} -c "${descr}" -d "${homedir}" \ ${use_id} ${pgroup:+-N} -s "${shell}" \ ${user_groups} -r ${_uname} >/dev/null 2>&1 case $? in 0) echo "Created ${_pretty_uname} system user." ${USERMOD} -L ${_uname} >/dev/null 2>&1 if [ $? -ne 0 ]; then echo "WARNING: unable to lock password for ${_uname} system account" fi ;; 9) ${USERMOD} -c "${descr}" -d "${homedir}" \ -s "${shell}" -g "${pgroup:-${_uname}}" \ ${user_groups} ${_uname} >/dev/null 2>&1 if [ $? -eq 0 ]; then echo "Updated ${_uname} system user." else echo "WARNING: unable to modify ${_uname} system account" echo "Please verify that account is compatible with these settings:" show_acct_details "${_pretty_uname}" \ "${descr}" "${homedir}" "${shell}" "${groups}" continue fi ;; ) echo "ERROR: failed to create system user ${_pretty_uname}!" return 1 ;; esac done return 0 } _system_accounts_invoke 'chrony' '4.4' || exit $?</code></pre> the “pre-install” & “pre-upgrade” scripts are Now the chrony</code> package includes a file into /usr/lib/sysusers.d/chrony.conf</code> when the package #2E3440;"># Create chrony system user user" /var/lib/chrony /usr/bin/nologin</code></pre> detects the presence of a file installed and adds a runtime dependency on the systemd-utils</code> binary. package contains a trigger. #x2F;chimera-linux/cports/blob/2ff6e8bdd6e3e5f6663f0aa19200f7ce75d84cc2/Packaging.md#hooks-and-triggers">Triggers</a> are a concept built into the apk</code> package manager. run whenever a package changes In this case the systemd-utils</code> ;syusers.d</code> or /usr/lib/tmpfiles.d</code> changes for another day). part of the trigger script is concerned it which uses the declarative contents of to determine what system users and groups should exist and systemd-utils-254-r5.44c71395.apk</code> showing the > #2E3440;">scripts: trigger: | #!/bin/sh # package script set -e # invoking sysusers is always harmless /usr/bin/systemd-sysusers || : # always create/remove/set TMPFILES_ARGS="--create --remove" # a little heuristical but unassuming with userland # the idea is that if /run is mounted, it's probably a running system # (doesn't matter if container or real) and has pseudo-filesystems # in place, otherwise we avoid messing with them if [ ! -r /proc/self/mounts -o ! -x /usr/bin/awk ]; then # bare system, don't mess with pseudofs TMPFILES_ARGS="$TMPFILES_ARGS -E" else RUN_FSTYPE=$(/usr/bin/awk '{if ($2 == "/run") print $1;}' /proc/self/mounts) RUN_FSTYPE=$(/usr/bin/awk '{if ($2 == "/run") print $1;}' /proc/self/mounts) if [ "$RUN_FSTYPE" != "tmpfs" ]; then # /run is not mounted or is something bad, don't mess with pseudofs TMPFILES_ARGS="$TMPFILES_ARGS -E" fi fi /usr/bin/systemd-tmpfiles $TMPFILES_ARGS || : triggers: # 2 items - /usr/lib/sysusers.d - /usr/lib/tmpfiles.d ;pre> much simpler and all the complexity to systemd-sysusers</code>. is package actions (such as if a “pre-install” hook script is fails the changes made by the trigger scripts are only run after If something fails during back before any scripts are for better understanding how a hope you did too. If you’d like to know. ready in KVM 2023 12:13:24 +1000 I tried creating an OpenBSD 7.3 virtual machine on my new computer (Arch Linux host) and the installer kept crashing with the error: </a> Screenshot of the installer crash.</figcaption> </figure> dc_atapi_start: not ready, st = 50 fatal protection fault in supervisor mode trap type 4 code 0 rip ffffffff810089d9 cs 8 rflags 10282 cr2 287eb3000 cpl 6 rsp ffff800014fd11a0 gssbase Oxffffffff818fbff0 kgsbase Ox0 panic: trap type 4, code=0, pc=ffffffff810089d9 syncing disks...12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 _</code></pre> I did a bunch of searching online and tried a several different suggestions but that one that worked for me was from this Reddid thread</a>: tinneriw31 Switch the virtual cd drive from ide to sata. Worked for me. Exact same issue. </blockquote> I use virt-manager</a> to manage VMs. These are the steps to do that when creating the VM: Create the VM and at the last step choose “Customize configuration before install”</li> Click on the “IDE CDROM 1” tab and change “Disk bus” to SATA</li> Then click Apply, and then Begin installation in the top left.</li> </ol> After that the VM installed successfully. </a> Customize configuration before install.</figcaption> </figure> </a> Disk bus: SATA</figcaption> </figure> Australian and New Zealand Makers on YouTube wes@wezm.net (Wesley Moore) — Tue, 11 Apr 2023 10:04:27 +1000 I decided I wanted to add some more local folks into my YouTube subscriptions. I put the call out on Mastodon</a> for suggestions for folks doing videos about machining, woodworking, electronics, software, that type of thing. I received a number of helpful replies and thought it might be useful to collect the list (as well as ones I’m already subscribed to) on this page in case others are looking for new channels to check out. Andrew Newton</a></li> Artisan Makes</a></li> BensWorx</a></li> Clickspring</a></li> Cutting Edge Engineering Australia</a></li> EEVblog</a></li> iforce2d</a></li> Luke Towan</a></li> Mach Super</a></li> Maker’s Muse</a></li> MattKC</a> (Matt moved to the US but he still counts 🙂)</li> MooreTech</a> – It’s me!</li> Pask Makes</a></li> Primitive Technology</a></li> Psivewri</a></li> SuperHouseTV</a></li> Unexpected Maker</a></li> </ul> That’s the list for now. If you have other suggestions (especially if they can mix up the diversity of the list a bit) please let me know. Building a Classic Mac OS App in Rust wes@wezm.net (Wesley Moore) — Fri, 31 Mar 2023 13:26:07 +1000 Instead of using my funemployment to build useful things I have continued to build things for old versions of Mac OS. Through some luck and a little persistence I have actually managed to get Rust code running on classic Mac OS (I’ve tried Mac OS 7.5 and 8.1). In this post I’ll cover how I got here and show a little network connected demo application I built—just in time for the end of #MARCHintosh</a>. Before I get into the details this is where we’re headed: </video> Ferris Weather, a weather app built with Rust (and some C)</figcaption> </figure> DeRez Redux</h3> In the last post</a> I got Nim code running on Mac OS and toyed with DeRez. The author of mpu-emu</code> replied on Mastodon</a> letting me know that DeRez should run via mpw-emu</code> on Linux as the filesystem layer transparently handles MacBinary</a> files. I spent some time in the debugger and worked out that mpw-emu</code> supported MacBinary III but Retro68</a> produced MacBinary II files. I contributed code to mpw-emu</code> to add MacBinary II support and enabled some latent support for UNIX paths. After that DeRez did work (almost): $ mpw-emu ~/Documents/Classic\ Mac/Shared\ 2/DeRez.bin Root:home:wmoore:Projects:classic-mac-rust:cmake-build-retro68ppc:Dialog.bin [2023-03-31T04:51:34Z ERROR emulator] Unimplemented call to InterfaceLib::SetFScaleDisable @10012C6C [2023-03-31T04:51:34Z ERROR stdio] Unimplemented format character: P [2023-03-31T04:51:34Z ERROR emulator] Unimplemented call to InterfaceLib::SecondsToDate @1000B2A4 data 'DITL' (128) { $"0007 0000 0000 00A0 00E6 00B4 0136 0404" /* .......†.Ê.¥.6.. / $"5175 6974 0000 0000 009B 00E1 00B9 013B" / Quit.....õ.·.π.; / $"0000 0000 0000 0046 000A 005A 0136 0818" / .......F...Z.6.. / $"436F 6E76 6572 7369 6F6E 2070 6F77 6572" / Conversion power / $"6564 2062 7920 5E30 0000 0000 001E 000A" / ed by ^0........ / $"003E 002A A002 0080 0000 0000 0014 0032" / .>.†..Ä.......2 / $"0024 007D 8807 4365 6C73 6975 7300 0000" /* .$.}à.Celsius... / $"0000 0014 00AA 0024 00F5 8809 4661 7265" / .....™.$.ıà∆Fare / $"6E68 6569 7400 0000 0000 0029 0036 0039" / nheit......).6.9 / $"0081 1002 3235 0000 0000 002B 00AE 003B" / .Å..25.....+.Æ.; / $"00F9 1002 3737" / .˘..77 / }; / etc */</code></pre> Success! DeRez running on Linux… only thing is that when you point at the type definitions to get structured output instead of hex dumps it hits an unimplemented function in mpw-emu</code>. It’s on my to-do list to fix that: $ mpw-emu ~/Documents/Classic\ Mac/Shared\ 2/DeRez.bin Root:home:wmoore:Projects:classic-mac-rust:cmake-build-retro68ppc:Dialog.bin Root:home:wmoore:Source:github.com:autc04:Retro68:InterfacesAndLibraries:Interfaces\&Libraries:Interfaces:RIncludes:Carbon.r [2023-03-31T04:53:07Z ERROR emulator] Unimplemented call to InterfaceLib::SetFScaleDisable @10012C6C [2023-03-31T04:53:07Z ERROR stdio] Unimplemented format character: P [2023-03-31T04:53:07Z ERROR emulator] Unimplemented call to InterfaceLib::SecondsToDate @1000B2A4 [2023-03-31T04:53:07Z ERROR emulator] Unimplemented call to StdCLib::fseek @10006A8C File "Root:home:wmoore:Source:github.com:autc04:Retro68:InterfacesAndLibraries:Interfaces&Libraries:Interfaces:RIncludes:CoreServices.r"; Line 0; ### /home/wmoore/Documents/Classic Mac/Shared 2/DeRez.bin - Can't FSeek on file Root:home:wmoore:Source:github.com:autc04:Retro68:InterfacesAndLibraries:Interfaces&Libraries:Interfaces:RIncludes:CoreServices.r. File "Root:home:wmoore:Source:github.com:autc04:Retro68:InterfacesAndLibraries:Interfaces&Libraries:Interfaces:RIncludes:CoreServices.r"; Line 0; ### /home/wmoore/Documents/Classic Mac/Shared 2/DeRez.bin - Fatal Error, can't recover.</code></pre>MacBinary</h3> Poking at the MacBinary code in mpw-emu</code> got me wondering if there was already a MacBinary crate that could be used. Turns out there wasn’t so I somehow nerd-sniped myself into building one</a>. The first challenge was finding a decent specification for the three versions of MacBinary. I was eventually I was able to dig up the following: MacBinary I</a></li> MacBinary II</a></li> MacBinary III</a></li> </ul> I then set about building the parser. I reused the binary parser code from Allsorts</a> since I was already familiar with that code. I hit another roadblock when it came to the CRC in the header. Nothing describes the actual CRC algorithm used. I tried the CRC reversing tool CRC RevEng</a> without success. A lot of existing code seemed to use an implementation that originated in a late 80’s UNIX utility, mcvert</a>, that has unclear licensing. I wanted to use the Rust crc crate</a> instead. I eventually stumbled on the blog post, Detecting MacBinary format</a>, which included the line: Note that the spec does not even tell you what CRC algorithm to use — you have to be a detective to figure it out. (It’s the one sometimes called CRC16-CCITT.) </blockquote> That was the tip I needed and with a little trial an error I eventually worked out that it was CRC-16/XMODEM</a> also known as CRC-16/CCITT-FALSE</code>. In hindsight I could probably have worked this out from the discussion of XMODEM in the MacBinary I spec</a>. With that sorted I was able to wrap up the parser and do some testing. I could now read the resource and data forks and figured it would be interesting to be able to parse the resource data too, so I added a resource fork parser as well. I wrote the parsers in a way that does not require heap allocation—only borrowing from the underlying data. Due to this it was straightforward to make the crate compatible with no_std</code>, which allows it to be used in embedded environments and WebAssembly. As something of a test-bed I created some WebAssembly bindings and built a page that allows you to inspect MacBinary files online, with all parsing done client-side via the crate. You can try it out at: https://7bit.org/macbinary/</a> Rust on Mac OS</h3> Now that I was well and truly in the classic Mac space again I took another stab at compiling Rust for PPC Mac OS (see this post for my previous attempt</a>). It seemed that using the powerpc-ibm-aix</code> LLVM target was most likely to produce a compatible library (Apple used AIX conventions for PPC Mac OS). Problem was that it was hitting unimplemented code in LLVM: LLVM ERROR: relocation for paired relocatable term is not yet supported </blockquote> I set about trying to work out how this code path was being hit and ran rustc</code> in a debugger. Unsurprisingly there were no debug symbols so I built rustc</code> and LLVM from source. This was my config.toml</code> for the Rust repo: [llvm] release-debuginfo = true download-ci-llvm = false link-jobs = 4</code></pre> After repeatedly running out of disk space and memory compiling LLVM (the binaries with debug info are huge) I eventually had new Rust compiler. Some of the LLVM binaries: .rwxr-xr-x 2.0G wmoore 26 Mar 20:05 llc .rwxr-xr-x 2.1G wmoore 26 Mar 20:10 llvm-opt-fuzzer .rwxr-xr-x 2.1G wmoore 26 Mar 20:04 bugpoint .rwxr-xr-x 2.2G wmoore 26 Mar 20:09 llvm-lto2 .rwxr-xr-x 2.2G wmoore 26 Mar 20:06 llvm-lto .rwxr-xr-x 2.2G wmoore 26 Mar 20:11 opt .rwxr-xr-x 2.3G wmoore 26 Mar 20:11 llvm-reduce</code></pre> I linked the new compiler into rustup</code> and then repeated my previous steps in the debugger… except this time the code compiled and did not hit the unimplemented LLVM code. This was my first lucky break. I’m not sure what changed but it was now happily compiling the code. I switched to a recent nightly compiler and that worked too! No need to build from source. I repeated the step described in my original post of using powerpc-linux-gnu-objcopy</code> to convert the static library archive (.a</code>) to a format that Retro68 would accept. After some fighting with binutils</code> I was finally able to get it to link! </iframe>

Device</th>	CPU</th>	Topology</th>	Arch</th>	Time</th></tr></thead>
Yoga Slim 7x</td>	Snapdragon X Elite</td>	12c</td>	ARM</td>	0:49</td></tr>
Yoga 7 2-in-1</td>	AMD Ryzen AI 7 350</td>	8c/16t</td>	x86_64</td>	1:21</td></tr> </tbody></table> So, the 7x with its 4 additional cores is a good bit faster.</p> The 2-in-1 does have USB-A ports, which is nice. I didn’t make use of the 2-in-1 functionality, or the included stylus. It doesn’t seem like GNOME detects the different lid configurations, and the on-screen keyboard didn’t appear when the screen was flipped around (although this could be a setting I missed).</p> In the end the 7x is cooler, faster, lighter, and thinner. I plan to sell the 2-in-1.</p> Conclusion</h3> The experiment was a success. This has given me more confidence to pursue setting up my dev environment on my primary desktop computer, but there’s still some things to address. Currently that machine runs the COSMIC Desktop</a>, which is not packaged for Chimera, and doesn’t look like it would be a lot of fun to implement.</p> The switch to COSMIC was prompted by X11 having unfixable tearing on my Intel B580 GPU. Prior to that I ran AwesomeWM</a> for many years, and would like to explore Pinnacle</a> (an Awesome-like Wayland compositor) as an alternative. It is simpler to package than COSMIC, and I’ve already partially completed it</a>. I shall continue to check things off the TODO list and will get there eventually.</p> Trying to Get Chimera Linux Running on Pentium Class Hardware wes@wezm.net (Wesley Moore) — Sun, 04 May 2025 08:09:28 +1000 Since declaring in my last post</a> that “it was time to return to slightly less frivolous projects for a bit” I instead spent the last week-and-change attempting to make Chimera Linux</a> run on Pentium class 32-bit x86 hardware.</p> </a> I was moderately successful.</figcaption> </figure> This was sparked by a friend linking to the EoL page on the PC Engines website</a> quoting the fact that they were exiting the market:</p> Despite having used considerable quantities of AMD processors and Intel NICs, we don’t get adequate design support for new projects. In addition, the x86 silicon currently offered is not very appealing for our niche of passively cooled boards. After about 20 years of WRAP, ALIX and APU, it is time for me to move on to different things.</p> </blockquote> This reminded me that I had two ALIX boards in neat little aluminium cases sitting in the cupboard: an alix2d13</a> purchased in 2011, and an alix3d2</a> purchased in 2012. My immediate thought was the alix3d2 would be perfect for hosting my retro website</a>.</p> </a> alix3d2</figcaption> </figure> They are powered by an AMD Geode LX800 CPU clocked at 500Mhz with 256Mb of RAM. The Geode is mostly an i686</a> class 32-bit x86 CPU. Instead of installing an OS that I know works on them like OpenWRT</a> or NetBSD</a> I have spent the last week and a bit bringing up Chimera Linux on i586 (Pentium).</p> I wanted to use Chimera Linux because:</p> I was already hosting my retro site with it.</li> I had already packaged the Rust binary that serves part of the site. Chimera makes cross-compiling that package super easy, as well as service monitoring with Dinit</a>.</li> I thought it would be fun to use a modern distro on Pentium class hardware.</li> </ol> The process of bringing up a new platform on Chimera Linux was interesting, but tested me at times. Especially early on when I was getting segfaults in `apk</code>, thus preventing anything from working. This post aims to document the steps I took (which may not be optimal) in case it happens to be useful.</p> </span>` `As I was working this out as I went, I made a few missteps along the way and had to repeat the process a few times (I compiled LLVM many</em> times). I’ll mostly leave those missteps out, and describe the process that ended up working.</p>` `All of this work was completed on my Arch Linux system. Since the Chimera tooling does everything in a sandbox, this works fine. These are the steps I took:</p>` `Add a new x86 build profile.</li>`Cross-compile a toolchain via the `base-cbuild</code> package.` Update various packages to accept the x86 architecture.</li> </ol> </li> Re-build the toolchain in a native sandbox.</li> Attempt to build `base-full</code>, addressing issues along the way.</li>` `Bootstrap Rust and Cargo.</li>` `Build fastfetch</code>, addressing issues along the way.</li>` `Build limine</code> and grub</code>.</li>` `Define and build a Linux kernel.</li>` `Update chimera-live</code> to produce an ISO.</li>` `Use the ISO to boot and install into virtual machine.</li> </ol>`Note: These steps are partially from memory, so may not be perfectly reproducible. All of the code changes are captured in my i586 cports branch</a>.</p> Add New Build Profile and Cross-Compile Toolchain</h3> Everything starts with etc/build_profiles/x86.ini</code>, which defines what we’re building for:</p> [</span>profile</span>]</span></span> endian</span> =</span> little</span></span> wordsize</span> =</span> 32</span></span> triplet</span> =</span> i586-chimera-linux-musl</span></span> repos</span> =</span></span> goarch</span> =</span> 386</span></span> [</span>flags</span>]</span></span> # clang defaults to pentium4 on i86- triples.</span></span> # see https://github.com/llvm/llvm-project/issues/61347</span></span> CFLAGS</span> =</span> -</span>march</span>=</span>pentium</span></span> CXXFLAGS</span> =</span> ${CFLAGS}</span></span> FFLAGS</span> =</span> ${CFLAGS}</span></span></code></pre> With that in place I tried cross-compiling base-cbuild</code>: ./cbuild -a x86 main/base-cbuild</code>.</p> This revealed various packages that are restricted to specific architectures. Updating them to accept x86</code> and regenerating sub-package links (./cbuild relink-subpkgs</code>) gets us a cross-build toolchain.</p> Starting Afresh</h3> With base-cbuild</code> built it was now possible to bootstrap an x86 build root: ./cbuild -A x86 bootstrap</code>. I initially wasted a bunch of time with an Alpine x86 virtual machine here, before discovering the neat -A</code> argument to ./cbuild</code>. The docs describe -A</code> as follows:</p> -A ARCH</code>, --host-arch ARCH</code> Override the host architecture. The given host arch must be runnable on the current kernel. This is typically useful for e.g. 32-bit builds on 64-bit architectures, or for emulated targets.</p> </blockquote> I then found out that the cross-built apk</code> would segfault, seemingly due to a recursive call in libatomic</code> causing stack overflow:</p> thousands more omitted</span></span> ⋮</span></span> frame #174557: 0xf7f925e8 apk.static`__atomic_load + 312</span></span> frame #174558: 0xf7f925e8 apk.static`__atomic_load + 312</span></span> frame #174559: 0xf7f925e8 apk.static`__atomic_load + 312</span></span> frame #174560: 0xf7f925e8 apk.static`__atomic_load + 312</span></span> frame #174561: 0xf7f925e8 apk.static`__atomic_load + 312</span></span> frame #174562: 0xf7db48e4 apk.static`CRYPTO_atomic_load + 68</span></span> frame #174563: 0xf7d7eb44 apk.static`OPENSSL_init_crypto + 148</span></span> frame #174564: 0xf7d44852 apk.static`ossl_err_get_state_int + 50</span></span> frame #174565: 0xf7d45b8a apk.static`ERR_new + 26</span></span> frame #174566: 0xf7d492f9 apk.static`___lldb_unnamed_symbol12090 + 329</span></span> frame #174567: 0xf7d49874 apk.static`EVP_DigestInit_ex + 36</span></span> frame #174568: 0xf7bec625 apk.static`apk_digest_ctx_init at crypto_openssl.c:101:6</span></span> frame #174569: 0xf7bebe30 apk.static`apk_ctx_init at context.c:33:2</span></span> frame #174570: 0xf7bd1703 apk.static`main at apk.c:587:2</span></span> frame #174571: 0xf7f96cbf apk.static</span></span> frame #174572: 0xf7f96c7d apk.static`__libc_start_main + 61</span></span> frame #174573: 0xf7bd148d apk.static`__dls2 at rcrt1.c:13:2</span></span> frame #174574: 0xf7bd1400 apk.static`_start_c at dlstart.c:162:2</span></span> frame #174575: 0xf7bd101b apk.static`_start + 27</span></span></code></pre> After quite a lot of challenging debugging and staring at assembly in the Compiler Explorer</a> I eventually concluded that __atomic_load</code> ended up calling itself through __atomic_load_n</code></a>. This was extra tricky for me to debug because there were compiler builtins in play, so I also had to poke through LLVM source as well.</p> Eventually I started gathering the information necessary to open a bug on LLVM, since libatomic-chimera</a> is derived from atomic.c</code> in LLVM’s compiler-rt</code>. I wrote a small reproducer based on the current LLVM version of atomic.c</code>, only to discover that it worked fine. In the end I was able to work out that libatomic-chimera</code> was triggering a code path in __atomic_load_n</code> for misaligned atomics, even though it was only making that call after checking for compatibility with:</p> (</span>__atomic_always_lock_free</span>(</span>size</span>,</span> p</span>)</span> \|\|</span> \</span></span> (</span>__atomic_always_lock_free</span>(</span>size</span>,</span> 0</span>)</span> &&</span> ((</span>uintptr_t</span>)</span>p </span>%</span> size</span>)</span> ==</span> 0</span>))</span></span></code></pre> I didn’t chase this into LLVM to find the root cause. Instead I updated libatomic-chimera</code></a> based on the newer version of atomic.c</code> in LLVM, and this resolved the problem. It was possible to re-build base-cbuild</code> in the x86 build root.</p> Attempt to Build base-full</h3> Next was to build base-full</code>, which provides the core packages for a Chimera system. This was a somewhat iterative process of run ./cbuild -A x86 pkg main/base-full</code> until a package failed to build, and then work out how to fix it. The fixes were usually one of:</p> Fix the package to make it build (unrelated to x86), like setting -DCMAKE_POLICY_VERSION_MINIMUM=3.5</code> to make it build under CMake 4.0.</li> Patch the package so that it builds on x86. Patches from Alpine and Debian were often helpful here.</li> Tweak the package template to skip tests that fail on x86.</li> Tweak the package template to skip the check</code> phase entirely on x86.</li> Patch the package template to build without dependencies that were currently broken (mostly doxygen).</li> </ul> This was a fairly straightforward iterative process. I was pretty free and easy about skipping failing tests if it was just one or two, since my initial goal was to get stuff compiling.</p> Rust</h4> Eventually I ran into a failure that I was anticipating: Rust. It gets pulled in by pipewire</code> via a curious chain of dependencies ultimately leading to mesa</code> and rust</code>:</p> pipewire</span></span> alsa-lib</span></span> alsa-ucm-conf</span></span> avahi</span></span> gtk+3</span></span> adwaita-icon-theme</span></span> hicolor-icon-theme</span></span> at-spi2-core</span></span> libsm</span></span> libice</span></span> libxtst</span></span> libxi</span></span> libxfixes</span></span> colord</span></span> lcms2</span></span> libgudev</span></span> vala</span></span> graphviz</span></span> gdk-pixbuf</span></span> shared-mime-info</span></span> libgd</span></span> libavif</span></span> dav1d</span></span> libaom</span></span> libwebp</span></span> freeglut</span></span> glu</span></span> mesa</span></span> cbindgen</span></span> cargo-auditable</span></span> cargo</span></span> cargo-bootstrap</span></span> libgit2</span></span> http-parser</span></span> rust</span></span> rust-bootstrap</span></span> wasi-libc</span></span></code></pre> Once I worked out the process this was straightforward to deal with:</p> Add patches so that Rust knows about i586-chimera-linux-musl</code>.</li> Generate a Rust bootstrap compiler via cross-compilation: ./cbuild -a x86 invoke-custom bootstrap main/rust</code>. This also requires building a new host Rust compiler so that it knows about the new triple too.</li> Upload the boostrap binaries and update the rust-bootstrap</code> package so that it has an entry for x86</code>.</li> Repeat for cargo: ./cbuild -a x86 invoke-custom bootstrap main/cargo</code></li> </ol> With that in place it’s possible to return to trying to build base-full</code>. The rust</code> package is able to be built from the rust-bootstrap</code> package. I actually took this a step further and rebuild the bootstrap binaries using the non-cross-compiled rust</code> and republished them.</p> Eventually base-full</code> succeeded, which was quite satisfying.</p> Build fastfetch</h3> Now because I wanted to be able to show pretty screenshots of my handiwork I also built fastfetch</a>. It happens to have a quite deep dependency tree, which was more of the same iteration to get everything building.</p> Full build graph for fastfetch</summary> fastfetch chafa automake autoconf base-files gm4 texinfo ncurses pkgconf perl bzip2 zlib-ng-compat docbook-xsl-nons docbook-xml xmlcatmgr libtool help2man perl-locale-gettext freetype brotli cmake curl c-ares ca-certificates debianutils openssl3 linux-headers libidn2 gettext libarchive acl attr lz4 musl-bsd-headers xz zstd meson ninja python autoconf-archive bluez-headers libedit libexpat libffi8 sqlite python-build python-flit_core python-installer python-packaging python-pyparsing python-pyproject_hooks python-setuptools python-wheel libunistring libxml2 icu gtk-doc-tools itstool libxslt libgcrypt libgpg-error slibtool python-lxml python-cython python-html5lib python-six python-webencodings python-pytest python-iniconfig python-hatch_vcs python-hatchling python-editables python-pathspec python-pluggy python-setuptools_scm python-typing_extensions python-trove-classifiers python-calver python-sphinx python-alabaster python-babel python-docutils python-pygments python-imagesize python-jinja2 python-markupsafe python-requests python-charset-normalizer python-idna python-urllib3 python-roman-numerals-py python-snowballstemmer python-sphinxcontrib-applehelp python-sphinxcontrib-devhelp python-sphinxcontrib-htmlhelp python-sphinxcontrib-jsmath python-sphinxcontrib-qthelp python-sphinxcontrib-serializinghtml libpsl libssh2 bash bison readline mandoc less nghttp2 cppunit jansson libev libevent nghttp3 libuv rhash freetype-bootstrap harfbuzz cairo fontconfig gperf util-linux bash-completion file flex byacc libcap-ng linux-pam docbook-xsl linux-pam-base shadow base-shells chimerautils libxo sd-tools libcap glib-bootstrap dbus libx11 libxcb libxau xorg-util-macros xorgproto libxdmcp xcbproto xtrans xmlto ugetopt elfutils argp-standalone json-c libmicrohttpd gnutls gmp libtasn1 nettle p11-kit tpm2-tss cmocka libftdi1 libconfuse libusb udev kmod scdoc trousers unbound dns-root-data hiredis libsodium protobuf-c boost protobuf abseil-cpp gtest musl-obstack pcre2 libpng libxext libxrender lzo pixman glib gobject-introspection python-mako python-markdown python-pyyaml libyaml sysprof-capture graphite2 libavif dav1d nasm asciidoc gdk-pixbuf libtiff jbigkit check libjpeg-turbo shared-mime-info libaom libwebp freeglut glu mesa cbindgen cargo-auditable cargo cargo-bootstrap libgit2 heimdal e2fsprogs fuse openldap libsasl perl-json perl-test-pod http-parser rust llvm fortify-headers libatomic-chimera llvm-bootstrap musl rust-bootstrap wasi-libc cargo-auditable-bootstrap glslang spirv-tools spirv-headers libclc spirv-llvm-translator libdrm libpciaccess libva-bootstrap libxdamage libxfixes libxrandr libxshmfence libxv libxxf86vm lm-sensors lua5.4 python-ply python-pycparser rust-bindgen vulkan-loader libxkbcommon wayland wayland-protocols xkeyboard-config gawk xkbcomp libxkbfile vulkan-headers libxi giflib librsvg cargo-c pango fribidi libthai libdatrie libxft vala graphviz fonts-liberation fontforge-cli libspiro libuninameslist woff2 mkfontscale libfontenc python-fonttools python-brotli python-pytest-xdist python-execnet python-filelock python-pexpect python-ptyprocess zsh python-psutil libgd libheif libde265 x265 numactl dconf gtk+3 adwaita-icon-theme hicolor-icon-theme at-spi2-core libsm libice libxtst colord dinit-dbus libdinitctl lcms2 libgudev libgusb json-glib polkit duktape elogind libseccomp gsed tangle turnstile dinit-chimera dinit snooze tzdb sane-backends avahi-bootstrap libdaemon libgphoto2 libexif v4l-utils cups libpaper xdg-utils lynx xset libxfontcache libxmu libxt libxxf86misc iso-codes libcloudproviders libepoxy libxcomposite libxcursor libxinerama tinysparql libsoup glib-networking gsettings-desktop-schemas chimera-artwork fonts-adwaita-ttf libproxy python-gobject python-cairo ddcutil imagemagick djvulibre fftw ghostscript ijs jasper jbig2dec openjpeg libjxl gflags highway openexr imath libdeflate libraw libpulse libsamplerate libsndfile flac libogg lame libvorbis opus orc perl-xml-parser ocl-icd opencl-headers ruby xfconf libxfce4util xfce4-dev-tools xwayland-run weston libdisplay-info hwdata libinput libevdev libwacom python-libevdev python-pyudev mtdev libseat libva pipewire alsa-lib alsa-ucm-conf avahi python-dbus xmltoman bluez libical fdk-aac gst-plugins-base cdparanoia graphene gstreamer libtheora ldacbt libcamera libcanberra tdb libfreeaptx liblc3 libmysofa cunit lilv lv2 serd sord zix sratom rtkit sbc webrtc-audio-processing xauth xwayland font-util bdftopcf font-alias libei python-attrs python-dbusmock libnotify modemmanager libmbim libqmi libqrtr-glib ppp libpcap libnl networkmanager iproute2 iptables libmnl libnetfilter_conntrack libnfnetlink libnftnl libndp mobile-broadband-provider-info newt popt slang nss nspr resolvconf openresolv wpa_supplicant pcsc-lite python-structlog python-freezegun python-dateutil python-pretend python-pytest-asyncio python-simplejson libtirpc libxcvt libxfont2 xserver-xorg-protocol yyjson </pre> </details> Bootloaders</h3> Back to necessary things. The Chimera ISOs use the Limine bootloader</a> on most platforms, although it’s not currently fully supported for installations, so GRUB is also needed (systemd-boot is another option but does not support x86). Limine does not officially support i585 class CPUs, but it seemed to work:</p> For 32-bit x86 systems, support is only ensured starting with those with Pentium Pro (i686) class CPUs.</p> </blockquote> Limine and GRUB built fine once x86 was added to their arch</code> list in the template.</p> Linux kernel</h3> The final piece of the puzzle was a kernel. It’s a little unclear to me how distros go about defining the config for a new platform. I first tried starting with a defconfig</code> kernel, but that didn’t boot the system in a VM. Next I tried taking the x86_64 kernel config and tweaking it to turn it into an i586 kernel. This resulted in a pretty large kernel, but one that actually booted in a VM.</p> The process for tweaking the kernel config was to initially populate main/linux-lts/files/config-x86.generic</code>, then run ./cbuild -A x86 invoke-custom generate-configs main/linux-lts</code>. This pauses on each architecture allowing you to enter the chroot and mess with the config. Running kernel make commands is done with the assistance of the chimera-buildkernel</code> command.</p> ./cbuild chroot main/linux-lts</span></span> chimera-buildkernel config</span></span></code></pre> The latter command runs make menuconfig</code>, you make and save your changes, exit, and then hit enter in the other window running generate-configs</code> and it updates main/linux-lts/files/config-x86.generic</code>. It’s then possible to build the kernel the usual way: ./cbuild -A x86 pkg main/linux-lts</code>.</p> Building an ISO</h3> After making some small tweaks</a> to the chimera-live</a> repo to recognise x86 it was possible to build an ISO. This process requires the main/xorriso</code> and base-live</code> packages to be built first.</p> doas ./mklive-image.sh -b base -k linux-lts -p fastfetch -- -a x86 -r ../cports-i586/packages/main -k ../cports-i586/etc/keys</span></span></code></pre> After a short time this will spit out an ISO that you can try booting in a VM or real hardware.</p> Extra Challenges</h3> During my time working on this the freedesktop.org project was in the process of migrating their infrastructure and at various times tarballs from freedesktop.org, gitlab.freedesktop.org, mesa.freedesktop.org, and x.org were down, which caused the fetch</code> phase that pulls source code to fail for affected packages. Additionally it seems that mirror sites for these projects were all either down or last updated late 2023. I was able to work around these by:</p> Switching to GitLab archives from published tarballs when the former was up but not the latter.</li> Pull archives from the Internet Archive.</li> </ul> Will it Run?</h3> With ISOs built, I was able to boot and install Chimera into a virtual machine with the CPU set to pentium</code>, as shown at the top of the post. Next it was time to try running it on the ALIX. The ALIX boards I have use tinyBIOS</a> and don’t support booting from USB. They also don’t have any graphical output, only supplying a serial port. The primary storage is a 2Gb Compact Flash card. These constraints provided some challenges.</p> First I created a virtual machine and passed-through the CF card connected via an IDE to USB cable:</p> <!-- libvirt config --></span></span> <disk</span> type</span>=</span>"</span>block</span>"</span> device</span>=</span>"</span>disk</span>"</span>></span></span> <driver</span> name</span>=</span>"</span>qemu</span>"</span> type</span>=</span>"</span>raw</span>"</span>/></span></span> <source</span> dev</span>=</span>"</span>/dev/sdd</span>"</span>/></span></span> <target</span> dev</span>=</span>"</span>vdb</span>"</span> bus</span>=</span>"</span>virtio</span>"</span>/></span></span> <boot</span> order</span>=</span>"</span>3</span>"</span>/></span></span> </disk></span></span></code></pre> I then booted from the ISO and did a normal installation onto the CF card.</p> After that I’d shutdown the VM, remove the CF card, swap it into the ALIX and see if it would boot. Initially I was not getting any output, not even from GRUB. That was fixed through tweaking the GRUB and kernel command line to output on the serial port (ttyS0</code>) and use 115200 baud rate to match tinyBIOS. At this point I could get the machine to boot GRUB and try to start Chimera, but it never got further than that.</p> I tried a bunch of different avenues, including coming up with a new kernel package tailored specifically for the ALIX hardware. This also didn’t work. Lastly I confirmed that OpenWRT boots on the machine and then copied their kernel config over and tweaked it a little (to enable some things like compressed initramfs that Chimera uses). That still failed to start. After the GRUB menu and choosing an entry this is all that is seen:</p> </a> Serial output captured from the ALIX when booting.</figcaption> </figure> Given more-or-less the same config is able to boot on OpenWRT, there must be something particular about the Chimera build that’s causing it to fail.</p> This is where I have decided to pause this project. If I pick it up again I think I’d need to delve into kernel debugging to try to work out what’s happening on the machine when it stops.</p> Finally the code from this adventure is in my i586 cports branch</a>.</p> Building a Website Fit for 1999 wes@wezm.net (Wesley Moore) — Mon, 21 Apr 2025 08:29:24 +1000 Over the last week I’ve had a lot</em> of fun building a little retro-themed website</a> that I’m hosting at home. Inspired by Ruben’s Retro Corner</a> I’ve been meaning to do this for a while, and actually started on it in June last year. More recently Joel Humphries shared on The Sizzle</a> forum that he’d built a little site</a> that he was hosting at home on a Raspberry Pi. This reignited my interest in getting my own site up again. For the fun of it I decided to implement it in HTML4</a> and serve it over plain HTTP so that it would work on old computers.</p> </a> The site in IE 4.01 on Mac OS 8.1</figcaption> </figure> </span>Website on a Microcontroller?</h3> Sticking with the retro theme I initially thought it might be fun to host the site on an resource constrained device. So, on the first evening I put together a simple page hosted on a RISC-V ESP32-C3 microcontroller using bare-metal Rust (with the exception of some C libraries used for Wi-Fi support). This was fine, but felt a little too</em> constrained, and there was some non-ideal behaviour</a> of the http crate I used. Nonetheless I published the code</a> to my git forge.</p> </a> The ESP32 Rust powered web sever</figcaption> </figure> </a> The ESP32 web page</figcaption> </figure> The Best Server Is the Server You Already Have</h3> The next version I threw together went back to basics. Digging up my website building knowledge from university I constructed a two page site using HTML4, complete with 88×31 buttons. Akin to my university website I hosted it on a ~wmoore path:</p> http://home.wezm.net/~wmoore/</a></p> This one was hosted by the mini fanless Qotom computer</a> running Chimera Linux</a> already sitting on my desk. I wanted it to be slightly</em> more interesting than just static HTML so I included free</code> and uptime</code> information about the server on the home page:</p> Update 30 May 2025:</strong> I migrated the hosting of the site to another fanless computer I had in a drawer today: a LattePanda V1 single-board computer</a>. See the about page</a> for more info.</p> </a> Server stats and 88×31 buttons!</figcaption> </figure> I used the MiniJinja</a> CLI, jaq</a>, and make</a> to regenerate the static HTML from templates, funnelling the dynamic content into a JSON file.</p> # minijinja-cli creates files with 600 perms, due to using a tempfile</span></span> # library to generate output. Fixed in main, but not released yet.</span></span> public/about.html</span>:</span> about.j2 data.json</span></span> minijinja-cli </span>$^</span> -o </span>$@</span></span> chmod 644 </span>$@</span></span> </span> public/index.html</span>:</span> index.j2 data.json</span></span> minijinja-cli </span>$^</span> -o </span>$@</span></span> chmod 644 </span>$@</span></span> </span> data.json</span>:</span> memory.json uptime.json generated.json</span></span> cat </span>$^</span> \| jaq -s add > </span>$@</span></span> </span> memory.json</span>:</span></span> free -h \| jaq -Rs '{memory: .}' > </span>$@</span></span> </span> uptime.json</span>:</span></span> uptime \| jaq -Rs '{uptime: .}' > </span>$@</span></span> </span> generated.json</span>:</span></span> date \| jaq -Rs '{generated: .}' > </span>$@</span></span></code></pre> To get the site online I made use of Tailscale</a>. This allowed me to avoid dealing with port forwarding on my Wi-Fi router, Dynamic DNS, and things like that. The server hosting the page you are reading now (a VPS with Vultr</a>^{(affiliate link)</sup>) uses Nginx to reverse proxy to the Tailscale IP of the Qotom server. Nginx on the Qotom serves the website. I set up a cron job to run make</code> and regenerate the dynamic content every 5 minutes.</p>} Internet │ │ │ ┌─────────────────────┐ │ │ │ Vultr Server │ │ │ │ ┌─────────────┐ │ │ │ nginx │ │ │ └─────────────┘ │ │ ┌──┐ │ └────────│──│─────────┘ │ │ │ │ Tailscale │ │ ┌───────────────────────────────┐ │ │ │ │ │ ┌────────│──│─────────┐ │ │ │ └──┘ │ │ │ │ ┌─────────────┐ │ │ │ │ │ nginx │ │ │ │ │ └─────────────┘ │ │ │ │ │ │ │ │ Qotom │ │ │ │ │ │ │ └─────────────────────┘ │ │ │ │ Home Network │ │ behind Router │ │ │ └───────────────────────────────┘ </pre> </div> What if I Used CGI Instead?</h3> This was fine, but I didn’t like the idea that regenerating the site every five minutes was causing unnecessary writes to the disk. It’s just a cheap 32Gb mSATA drive, and is the second one this machine has used over its lifetime. For more retro nostalgia I thought it would be neat to generate the dynamic content with Common Gateway Interface</a> (CGI) scripts, served from cgi‑bin</code> of course.</p> I tinkered with this but in the end decided not to use actual CGI. Firstly, Nginx doesn’t support it, only FastCGI. Secondly it complicated development as it required a dev server that supported CGI and static file hosting. The best/closest option I found was Lighttpd</a>, but this all seemed harder than it needed to be.</p> I fell back on the more modern approach of having web applications talk HTTP directly behind a proxy. I put together a small Rust</a> server with Axum</a>. Sticking the with theme though, the dynamic pages are served on paths like cgi-bin/about.cgi</code>. In development the Rust binary serves the static files and dynamic pages. In a release build it only serves dynamic content and Nginx does the static files.</p> The Joy of HTML4</h3> Here’s where the fun really began. I thoroughly enjoyed filling out the pages on what was now known as “Wes’ Nonsense Website”—nonsense in the extravagant foolishness or frivolity</em> sense. It was genuinely fun to write about growing pineapples</a>, include pixelated GIF icons, and the odd animated GIF.</p> Coding in HTML4 Transitional is somewhat freeing. CSS is great, but it’s large and sprawling. Throwing that away and sticking to only what you can achieve with a comparatively small set of HTML tags and their attributes dramatically reduces the scope of things. Also feels a bit cheeky to mix content and style with wild abandon.</p> It wouldn’t be the classic web without feeding your pages through the W3C Validator</a>. Amazingly the validator still accepts and validates HTML4. The checks were useful for finding messed up closing tags and other mistakes.</p> Now part of the reason to use HTML4 and serve the site over plain HTTP is so that it has a chance of working on old computers. As I was building the site I continually tested it in Internet Explorer 4.01 and Netscape Navigator 3.01 running in Mac OS 8.1 in the Basilisk II 68k emulator</a>.</p> </a> Testing in IE4 and Netscape 3</figcaption> </figure> These posed some unique challenges, mostly around text encoding. The content is authored and served as UTF-8, but this was only supported by version 4 onwards of IE and Netscape. To try to avoid issues, I initially stuck to the ASCII subset of UTF-8 and used HTML entities for all characters outside this. Despite my intentions I discovered that there were a number of newly added entities</a> that were unsupported by the browsers I was testing on. These included ’</code> for ’, and ¹</code> for ¹. Annoyingly, the default encoding for HTML in the HTML4 era was ISO/IEC 8859-1 (aka Latin 1), which doesn’t encode curly quotes</a> at all, unlike Mac Roman, which had them in 1984.</p> The unknown entities were rendered as text like “Wesrsquo Nonsense”, which was not ideal. Since the version 4 browsers supported UTF-8 I switched to including the desired characters directly. For ’ this worked as desired in Netscape 4 and IE 4 (on Mac OS 8 at least). Neither of them handled ¹ properly though. IE shows a normal 1, and Netscape a ?, For browsers that don’t understand UTF-8, like Netscape 3 most of the content is fine as it is just ASCII, but the UTF-8 encoded chars come out using a Latin-1 rendition, such as “Wesâ™ Nonsense” for “Wes’ Nonsense”. For a silly website, that’s good enough.</p> Along with the static content I included some dynamic content. The home page</a> shows live energy information about the Qotom server. This is pulled from an Athom smart plug</a> running Tasmota</a> that the server is plugged into. The Rust server refreshes this information every 10s. The about page</a> shows uptime and memory information, and the Sunshine Coast page</a> includes climate and season information for the current month.</p> The primary drawback to sticking to HTML4 tags is that it somewhat implies table based layouts, which are not responsive. Therefore the site isn’t great on smartphone sized screens. However, because it’s only 640 pixels across it does render respectably on a smartphone in landscape orientation.</p> Deployment</h3> Deployment is comprised of two parts:</p> The Rust binary</li> The rest of the content</li> </ol> The content is placed onto the server via a simple git pull</code>. The Rust binary is installed as an apk</code> package. I am able to build this package on my Arch Linux desktop and copy it over to the server to install. This is possible because the Chimera Linux package tooling does all building in a sandbox and doesn’t require the host to be running Chimera. This is the package template:</p> pkgname</span> =</span> "</span>nonsense</span>"</span></span> pkgver</span> =</span> "</span>0.1.2_git20250420</span>"</span></span> pkgrel</span> =</span> 0</span></span> _gitrev</span> =</span> "</span>27dc77c</span>"</span></span> build_style</span> =</span> "</span>cargo</span>"</span></span> hostmakedepends</span> =</span> ["</span>cargo-auditable</span>"]</span></span> makedepends</span> =</span> [</span></span> "</span>rust-std</span>",</span></span> ]</span></span> pkgdesc</span> =</span> "</span>Nonsense web application</span>"</span></span> license</span> =</span> "</span>custom:none</span>"</span></span> url</span> =</span> "</span>https://forge.wezm.net/wezm/home.wezm.net</span>"</span></span> source</span> = f</span>"https://forge.wezm.net/wezm/home.wezm.net/archive/</span>{</span>_gitrev</span>}</span>.tar.gz>nonsense-</span>{</span>pkgver</span>}</span>.tar.gz"</span></span> sha256</span> =</span> "</span>7bdbadb1e1f4b1fceadb7a8f3ccce3ec0b0a5b2d3b9e776e2d9dc13682d906c4</span>"</span></span> </span> </span> def</span> post_install</span>(</span>self</span>):</span></span> self</span>.</span>install_service</span>(</span>self</span>.</span>files_path</span> /</span> "</span>nonsense</span>")</span></span></code></pre> Included in the package</a> is a Dinit</a> service file that runs the binary and provides process monitoring to restart it if it should exit for some reason.</p> type = process</span></span> command = /usr/bin/nonsense</span></span> working-dir = /home/wmoore/home.wezm.net</span></span> run-as = wmoore</span></span> env-file = nonsense.env</span></span> logfile = /var/log/nonsense.log</span></span> depends-on = local.target</span></span> smooth-recovery = true</span></span></code></pre> For basic content updates I can do git pull</code>, and then run make</code> if the changes are to static files or doas dinitctl restart nonsense</code> if the dynamic stuff has changed.</p> What’s Next</h3> I still want to add more content on the Computer</a> and Calculator</a> pages, but decided it was time to return to slightly less frivolous projects for a bit. If you haven’t checked out the site itself, you can do so at: http://home.wezm.net/~wmoore/</a>.</p> Finally, all the code is published on my git forge</a>.</p> Making the Web More Readable With Stylus wes@wezm.net (Wesley Moore) — Mon, 17 Feb 2025 10:21:22 +1000 Stylus</a> is an open-source browser extension for managing and applying “user styles”—custom snippets of CSS—to websites. It allows you to tweak sites you visit to tailor them to your preferences. In this post I list the ways I use Stylus to make my browsing experience nicer.</p> </span> Stylus has the ability to share and use shared-styles, but I just use styles I write myself. Styles can by applied to all sites, specific sub-domains, domains, or domains + paths. I note the matching rule of each style at the top of each entry.</p> You will probably notice that are large number of my rules are just tweaks to fonts. What can I say, I have opinions about fonts and I use Stylus to express them.</p> Sign in with Google</h3> Applies to:</strong> Everything</p> Hide the stupid Sign in with Google popup that appears on sites using a Log in with Google button, such as StackOverflow. I never</em> want to Sign in with Google on a third-party site.</p> #</span>credential_picker_container</span>:</span>has</span>(</span>iframe</span>[</span>src</span>=</span>"</span>accounts.google.com</span>"]) {</span></span> display</span>:</span> none;</span></span> }</span></span></code></pre>arstechnica.com</h3> Applies to:</strong> URLs on the domain: arstechnica.com</a></p> Remove auto-playing videos in the middle of articles.</p> .</span>ars-interlude-container</span> {</span></span> display</span>:</span> none;</span></span> }</span></span></code></pre>d-shoot.net</h3> Applies to:</strong> URLs on the domain: d-shoot.net</a></p> Set a font and max-width</code> more suited to reading.</p> body</span> {</span></span> max-width</span>:</span> 640</span>px;</span></span> font-family</span>:</span> sans-serif;</span></span> margin</span>:</span> 0</span> auto;</span></span> }</span></span></code></pre>danluu.com</h3> Applies to:</strong> URLs on the domain: danluu.com</a></p> Set a max-width</code> more suited to reading.</p> body</span> {</span></span> max-width</span>:</span> 600</span>px;</span></span> margin</span>:</span> 0</span> auto;</span></span> }</span></span></code></pre>feedbin.com</h3> Applies to:</strong> URLs on the domain: feedbin.com</a></p> Put my single glyph WMAppleLogo font first in the stack so that when people use the Apple logo in text it appears correctly on non-Apple devices; use Muli as the article font.</p> On Apple devices you can type an Apple logo, which uses the Private Use Area code point U+F8FF. I created a font with an Apple logo mapped to this code point so that posts that use it appear as intended</a>.</p> .</span>font-default</span> .</span>content-styles</span> {</span></span> font-family</span>:</span> WMAppleLogo</span>,</span> Muli</span>,</span> sans-serif;</span></span> }</span></span></code></pre>github.com</h3> Applies to:</strong> URLs on the domain: github.com</a></p> Use the default sans-serif</code> font for body text on GitHub. I have my system font set to Cantarell, which unlike many I actually like for system controls like menus, buttons, and titles. I don’t however want to see prose written in it. So I override GitHub’s use of system-ui</code>.</p> body</span>, .</span>markdown-body</span> {</span></span> font-family</span>:</span> sans-serif;</span> / Use sans-serif font instead of system UI font /</span></span> }</span></span></code></pre>gkeenan.co</h3> Applies to:</strong> URLs on the domain: gkeenan.co</a></p> This blog uses a typewriter font for body text which I don’t like visually, nor find particularly easy to read. Replace it with Work Sans</a>, which still fits the vibe of the site.</p> html</span> {</span></span> font-family</span>:</span> Work Sans</span>,</span> sans-serif;</span></span> }</span></span></code></pre>goughlui.com</h3> Applies to:</strong> URLs on the domain: goughlui.com</a></p> Uses a Times New Roman font by default, which is a bit ugly on my system. Replace with a nicer serif font.</p> body</span>,</span></span> input</span>,</span></span> textarea</span>,</span></span> .</span>page-title</span> span</span>,</span></span> .</span>pingback</span> a</span>.</span>url</span> {</span></span> font-family</span>: "</span>TeX Gyre Pagella</span>",</span> serif</span></span> }</span></span></code></pre>lwn.net</h3> Applies to:</strong> URLs on the domain: lwn.net</a></p> LWN allows you to choose from a selection of fonts, but I still chose to override it with the Source Sans 3</a> variable font. I also adjust the headings to be less bold and also constrain the article text width.</p> body</span> {</span></span> font-family</span>:</span> SourceSans3VF</span>,</span> sans-serif;</span></span> }</span></span> h1</span>,</span>h2</span>,</span>h3</span>,</span> b</span> {</span></span> font-weight</span>:</span> 600</span></span> }</span></span> DIV</span>.</span>PageHeadline</span>,</span></span> DIV</span>.</span>ArticleText</span> {</span></span> max-width</span>:</span> 800</span>px;</span></span> }</span></span></code></pre>news.ycombinator.com</h3> Applies to:</strong> URLs on the domain: news.ycombinator.com</a></p> The post text in Hacker News self-posts like “Ask HN” posts is shown in barely legible light grey. Fix this.</p> / Make HN post text readable /</span></span> .</span>toptext</span> {</span></span> color</span>: #</span>333</span>;</span></span> }</span></span> .</span>toptext</span> a</span> {</span></span> color</span>: #</span>1973c2</span>;</span></span> }</span></span></code></pre>https://okmij.org/ftp/papers/DreamOSPaper.html</h3> Applies to:</strong> URLs starting with: https://okmij.org/ftp/papers/DreamOSPaper.html</a></p> Readable max-width</code>.</p> body</span> {</span></span> max-width</span>:</span> 640</span>px;</span></span> margin</span>:</span> 1</span>em auto;</span></span> }</span></span></code></pre>phanpy.social</h3> Applies to:</strong> URLs on the domain: phanpy.social</a></p> Custom font.</p> body</span> {</span></span> font-family</span>:</span> Figtree</span>,</span> sans-serif;</span></span> }</span></span></code></pre>thingspool.net</h3> Applies to:</strong> URLs on the domain: thingspool.net</a></p> Readable max-width</code>.</p> body</span> {</span></span> max-width</span>:</span> 700</span>px;</span></span> }</span></span></code></pre>wikipedia.org</h3> Applies to:</strong> URLs on the domain: wikipedia.org</a></p> Better font on desktop.</p> html</span>,</span> body</span> {</span></span> font-family</span>: '</span>Lato</span>',</span> sans-serif;</span> / Lato is used by m.wikipedia /</span></span> }</span></span></code></pre>www.bleepingcomputer.com</h3> Applies to:</strong> URLs on the domain: www.bleepingcomputer.com</a></p> Nicer font.</p> .</span>bc_main_content</span> p</span>,</span></span> .</span>bc_main_content</span> li</span></span> {</span></span> font-family</span>:</span> Figtree</span>,</span> sans-serif;</span></span> font-weight</span>:</span> normal;</span></span> }</span></span></code></pre>yeslogic.element.io</h3> Applies to:</strong> URLs on the domain: yeslogic.element.io</p> This is a hosted Matrix instance using the Element client.</p> Use the system emoji font (JoyPixels</a>) instead of the heinous Noto Color Emoji.</li> Use the system monospace font (PragmataPro</a>) instead of a custom one.</li> Reduce line height of monospace text to match other places monospace text shown on my system.</li> Stop the aptly named “Spaces” bar from wasting space.</li> </ul> body</span> {</span></span> font-family</span>:</span> Inter</span>,</span> sans-serif;</span></span> / Make it use system emoji font /</span></span> }</span></span> </span> .</span>mx_EventTile_content</span> .</span>markdown-body</span> code</span>,</span></span> .</span>mx_EventTile_content</span> .</span>markdown-body</span> pre</span> {</span></span> font-family</span>:</span> monospace !important;</span></span> }</span></span> .</span>mx_EventTile_content</span> .</span>markdown-body</span> pre</span> {</span></span> line-height</span>:</span> 1.3</span>;</span></span> }</span></span> </span>[</span>aria-label</span>=</span>"</span>Spaces</span>"] {</span></span> display</span>:</span> none;</span></span> }</span></span></code></pre> Replicating My Alacritty Appearance in Ghostty wes@wezm.net (Wesley Moore) — Fri, 10 Jan 2025 08:54:40 +1000 Ghostty</a> by Mitchell Hashimoto is the new hotness in the terminal emulator world. It recently came out of private beta launching publicly as 1.0. It’s similar to other GPU accelerated terminal emulators like Alacritty</a> and Kitty</a>, but differs in that it uses the native toolkit on macOS and Linux (GTK). For nerds it’s also interesting because it’s implemented in Zig</a>.</p> </span> Initially I dismissed Ghostty as not offering me anything over my current terminal emulator, Alacritty</a>. Largely because of my use of the Awesome window manager</a>. Using a tiling window manager means I have no need for tabs in my terminal emulator, and I have Awesome configured to show no window decorations on most windows. I thought this meant that Ghostty using a native UI offered me very little. However, after some recent discussions I noted that Ghostty did support two longstanding missing features in Alacritty:</p> Text rendering with ligatures</li> Bitmap image support, such as sixel</li> </ol> This prompted me to take another look at Ghostty. I set about tweaking the settings to remove all the UI chrome and get the theme to match my Alacritty config. This is the result:</p> </a> fastfetch output in Ghostty.</figcaption> </figure> Compared to Alacritty:</p> </a> fastfetch output in Alacritty.</figcaption> </figure> For some reason Ghostty is rendering PragmataPro slightly wider than Alacritty despite them both being set to the same font size.</p> Finally here’s a sample document in mdcat</a> showing image and ligature support:</p> </a> mdcat rendering a sample Markdown document.</figcaption> </figure> With the visuals out of the way, now I just need to spend some time with Ghostty to see how it compares in practice. My configuration for both terminal emulators can be found in my dotfiles repo:</p> Alacritty</a> (I need to migrate this one to TOML)</li> Ghostty</a></li> </ul> Update 15 Jan 2025:</strong> I have suspended my use of Ghostty for now, as the text rendering is not right</a>. I’ve been staring at PragmataPro for more than a decade, so the difference from how I expect it to look keeps distracting me. If that issue is fixed I will likely revisit Ghostty as I did enjoy some of the features.</p> Building a Tiny CDN With pyinfra and Chimera Linux wes@wezm.net (Wesley Moore) — Mon, 09 Dec 2024 10:02:49 +1000 In my quest to make linkedlist.org</a>—my link blog—faster, I set up multiple deployments around the world. I used pyinfra</a> to automate the process and Chimera Linux</a> as the host operating system. Join me on this adventure in over-engineering to see how I dropped the average response time across nine global locations from 807ms to 189ms without spending a fortune.</p>

Wesley Moore

Exploring Linux on a LoongArch Mini PC

Specifications</h4> CPU:</strong> Loongson-3A6000 4-core/8-thread 64-bit @ 2.5Ghz</li> RAM:</strong> 16Gb DDR4 SO-DIMM, 1 of 2 slots populated</li> GPU:</strong> Loongson LG100</li> Chipset:</strong> 7A2000</li>

Performance & Efficiency</h3> The Loongson-3A6000 is not particularly fast or efficient. At idle it consumes about 27W and under load it goes up to 65W.</p>

Tech Stack 2026

Hardware</h3>

Desktop Computer</h4> My computer is a desktop machine that I assembled myself in 2023, it has had a few upgrades since I last documented it—how great are upgradeable computers!</p>

Doing My Day Job on Chimera Linux

Trying to Get Chimera Linux Running on Pentium Class Hardware

Rust</h4> Eventually I ran into a failure that I was anticipating: Rust. It gets pulled in by pipewire</code> via a curious chain of dependencies ultimately leading to mesa</code> and rust</code>:</p>

Building a Website Fit for 1999

Deployment</h3> Deployment is comprised of two parts:</p> The Rust binary</li>

Making the Web More Readable With Stylus

yeslogic.element.io</h3> Applies to:</strong> URLs on the domain: yeslogic.element.io</p> This is a hosted Matrix instance using the Element client.</p>

Replicating My Alacritty Appearance in Ghostty

Building a Tiny CDN With pyinfra and Chimera Linux

Ubuntu Linux on Snapdragon X Laptop (Lenovo Yoga Slim 7x)

Bluetooth</h4> I was able to pair and use some Sennheiser Bluetooth headphones.</p>

Graphics</h4> The display works fine. I was able to change it to run at the full 90Hz in the GNOME settings. The Wayland based GNOME desktop appears to be using GPU acceleration and runs smoothly.</p>

Input Devices</h4> The keyboard and trackpad work, including tap-to-click out of the box on the trackpad. The brightness and volume controls work on the keyboard.</p>

Generating a Static Website From a Pleroma Archive

Building and Launching My New Link Blog, linkedlist.org (Twice)

Polish</h3> There was a long tail of smaller things that I implemented before the initial launch, such as:</p> Dark mode</li>

Generate a JSON Feed for a Zola Website

Australian Chimera Linux Mirror

Announcing Feedlynx

Implementation Notes</h3> Some notes on the implementation:</p>

A Developer's Review of a Snapdragon X Laptop (Lenovo Yoga Slim 7x)

Usage</h3>

Why Chimera Linux

How Much Is a Browser Worth?

Tech Stack 2024

Hardware</h3> Desktop Computer</h4> My computer is a desktop machine that I assembled myself in 2023:</p>

Desktop Computer</h4> My computer is a desktop machine that I assembled myself in 2023:</p>

Exporting YouTube Subscriptions to OPML and Watching via RSS

7bit Projects: Dew Point Forecast, MacBinary, RSS Please, Titlecase

Bluetooth</h4>
I was able to pair and use some Sennheiser Bluetooth headphones.</p>

Input Devices</h4>
The keyboard and trackpad work, including tap-to-click out of the box on the trackpad. The brightness and volume controls work on the keyboard.</p>