I literally chortled at this one. I had no idea Apple had done this bad an icon for what is likely the only game they ever shipped with early OS X.

These days I spend a lot of my free time in CAD software (including Blender and OpenSCAD), so those years were a great learning experience that has really paid off.

• I have been spending far too much time messing about with AI instead of reading.
• I end up zoning out in front of YouTube and, even with serious attempts at curating my feed, I spend far more time than I should there.

I’ve griped about this before, but this week I decided to take some time to fine-tune the friction around those activities–removing or adding it as needed.

My Calibre library has grown somewhat out of hand, either due to automated additions (I have been getting the web edition of The Economist delivered through it for well over a decade) or lack of proper curation, so I decided to use AI to see if I could remove the friction involved in finding something to read (or re-read) and have it either e-mailed to my Nomad via Kindle or easily accessible on my Xteink X4.

That mostly meant figuring out how to get an MCP server working with Calibre, but it ended up including a parallel side quest to improve bun-readlater-epub and bun-opds-server to see if I could make it easier to queue up and download long-form content.

As an aside, recent revisions of CrossPoint have a Wi-Fi bug that prevents the Xteink X4 from joining our Wi-Fi (apparently because it fails to use a coherent MAC address), so I have to import things via its hotspot (which automatically optimises the EPUBs). I suspect I will eventually have to fix it myself when I have more time, because the maintainers have been unable to do it for two releases now…

The real improvement, though, was how I decided to design my own MCP server for automating Calibre. Most existing implementations out there are either sidecars that can’t manipulate Calibre data or CLI wrappers that inevitably contend with Calibre access to its library databases, so I took the plugin route and built one that runs inside it and can thus use everything: metadata editing, conversions, moving books between libraries, e-mailing them to me, the works:

This effectively means I can now point any AI agent to Calibre and tell it literally:

• find me the last three books by X and e-mail them to my Kindle address
• grab this URL and import it into the Incoming library
• change ratings programmatically
• find and remove duplicates across libraries…

There’s no practical limit, really, although I might need to hack a few more things in. And since it uses the native job engine, everything works correctly.

The biggest quality-of-life improvement is that I don’t need to access the UI anymore. Since I have been running the extra-clunky Selkies-based container (which streams the desktop using its own thing and works very poorly on the iPad), there’s no more browser logins, slow wading through listings, or finicky right-clicking.

As an encore, since I wanted to maximise the time I could spend on the Nomad, I also updated picoflux and tweaked the e-ink theme I bolted on a month or so ago.

That removed a lot of the friction around reading. Next, I needed to add friction to watching YouTube videos.

I recently spent a little while fiddling with Jellyfin–partly because I do that on occasion to see if it’s finally a decent alternative to Plex (spoiler: not yet, by miles), but also due to my infrequent investigations into the state of hardware video decoding (go-264 will eventually go down that path).

This time I wanted to hack it into a sort of anti-YouTube setup and see if I could replicate the old-timey, “synchronous” TV-watching experience, so I literally told piclaw:

I want you to create a Debian 13 LXC in radxax4 to host Jellyfin, mounting smb://zfs/video as a read-only remote media library (so keep the LXC filesystem small, please). You can pick the best way to deploy Jellyfin as long as you manage to get hardware video processing working and document it in Obsidian. After that is done install jellyfin-plugin-livechannels or a similar TV simulation channel and create appropriate “channels” based on the contents of the media library.

Fifteen minutes later, I had the entire thing working. Not half-assed or poorly installed, working, with the media mounted read-only (twice, once on the Proxmox host and again inside the LXC), QSV hardware transcoding and a full installation and configuration brief in Obsidian (the output is a tad long, but here’s the last part):

Of course Jellyfin immediately filled the filesystem with artwork and people metadata, so that was (automatically) upgraded, but hey, it was a valiant effort.

Then I went to town on the original plugin and decided to bolt on Invidious as a YouTube source:

I call it jellyfin-livetube, and it’s been working pretty well–even the standard library-backed channels have been a surprising amount of fun (I ended up rewatching Flash Gordon purely by chance).

Speaking of YouTube, Wendell Wilson (hi there!) featured my new wrdp project in the latest Linux weekly video, which was fun to see (especially since I found out over breakfast while checking my messages, before coffee kicked in).

Right now it is mostly working, even though I am still waiting on a critical PR to make it into IronRDP to improve internal session management. But login and Wayland session creation both work, it’s all hardware-accelerated (both EGL desktop acceleration and VA-API video encoding), and… there are all sorts of edge cases to sort through.

I will be poking at it irregularly over the next few weeks–I want to do ARM/Vulkan acceleration next and set up two separate remote desktops I use “regularly”, but first I need a bit of digital detoxing, which is something I am very much failing at.

Because I was clearly left unsupervised and can’t really stop doing agent-related stuff, I went down the rabbit hole of setting up Open Minis on my iPad Pro, and I did it in the most “me” way possible–I got it to connect to Memento and “learn” from the accumulated knowledge of all my piclaw agents, which is awesome because it proves two points:

• Memento works perfectly for the purpose it was designed for.
• It doesn’t matter which agent harness you use as long as you document things properly.

Thirty minutes after I began, I already had most of the SKILL.md files and scripts ported across, and an hour later I had “native” equivalents to manage Proxmox and Portainer and was doing various shenanigans to generate and post screenshots along with my link post drafts, which these days are posted using the GitHub API directly (again, refactoring an existing SKILL.md).

I can now confirm that Open Minis is, indeed, the Siri I have been wishing for. It’s by no means perfect, but with a SOTA model driving it, it can build its own tools, and… I really should stop now and go read a book or something.

Most EPUB publications are reflowable, allowing a reading system to adapt text to the screen and the reader’s font, spacing and colour preferences. The format also supports fixed layouts, media overlays, scripting, page lists and landmarks, but readers implement those features inconsistently.

An .epub file is an Open Container Format ZIP archive with the media type application/epub+zip. Its root mimetype file identifies the format, and META-INF/container.xml points to the package document.

The package document contains the publication metadata, a manifest of resources and a spine that defines the default reading order. A separate XHTML navigation document provides the table of contents and can also include page and landmark navigation.

EPUB 3.3 is the W3C Recommendation as of 13 January 2026. It retains the EPUB 3 package version value 3.0 and supersedes the EPUB 2 specifications. The companion Reading Systems specification requires readers to attempt to process older publications.

EPUB 2 remains common in older libraries and devices. Its NCX table of contents and other legacy package features can be included in EPUB 3 files for compatibility, but new publications should use the EPUB 3 navigation document and current metadata model.

EPUB content uses the accessibility semantics of XHTML, SVG and related web standards. EPUB Accessibility 1.1 adds publication-wide conformance and discoverability requirements, including accessibility metadata, logical reading order and navigation.

EPUBCheck verifies format conformance, and Ace by DAISY reports many accessibility issues. Complete validation also requires testing the publication with representative reading systems and assistive technology.

EPUB itself does not require digital rights management. Its container supports encryption metadata, but distributors apply mutually incompatible commercial DRM schemes. Those schemes can block copying, text-to-speech or transfer between reading systems even when the underlying EPUB is valid.

DRM-free publications can still render differently because reading systems vary in CSS, font, scripting, fixed-layout and media support. Reflowable XHTML with conservative CSS works across the widest range of readers.

Calibre can convert, inspect and manage EPUB files, while Sigil edits the package and its content directly. A publishing workflow should run EPUBCheck after every structural change, then use Ace and manual accessibility testing.

Since an EPUB is a ZIP archive, ordinary archive tools are useful for inspection, but repackaging must preserve the OCF rules–in particular, mimetype must be the first entry and must remain uncompressed.

Standard Ebooks publishes free, carefully produced public-domain books in EPUB format, with consistent typography, metadata and compatibility across reading systems.

Reusable instruction packs, workflow recipes, and prompt modules live in Agentic Skills.

OpenClaw-specific projects and lightweight variants live in OpenClaw Ecosystem.

Pi.dev is the home of the Pi coding agent and its ecosystem of extensions, adapters, and clients. See the Pi.dev Ecosystem page for the curated project list.

Wow, 30 years. Part of that seems to have whizzed by, and it has been a long while since I last played Quake. I always hated the hellish look, but the technology was irresistible–and looking back, it is pretty amazing how much it shaped my career, or at least my pastimes.

Running Quake servers at an ISP is quite literally how I initially ended up in marketing instead of engineering, and it got me exploring networking, servers, real-time graphics and all sorts of other things I am still interested in today. I may have to make time for this new free episode, if only to see what thirty years of hindsight looks like inside the original engine.

Right now I have three 3D printers (down from four):

• The KP3S Pro, which is my “tiny”, near-silent printer
• The Two Trees SK1, my former workhorse
• A brand-new Flashforge Creator 5 Pro, which I am still getting to know and taking copious notes on

However, this all started (as many 3D printing stories start) with a Prusa. Or, rather, a clone.

A few years back, when I was organising the first editions of the Lisbon Maker Faire, I got a BQ Prusa clone, which stood me in good stead for a long while–I printed many kilos of PLA/PETG with it, the vast majority of it going into functional parts of various descriptions (some, as you’d expect, were 3D printer parts), to the point where the nozzle wore out and widened from its 0.4mm to somewhere between 0.6 and 0.8mm (which only made it more useful for some functional prints).

Last weekend I retired it and gave it to a friend–which, given how tight space is in my office these days, was a necessity. Instead of dismantling it and saving the non-printed parts, I tried to make sure it would go to someone who could rebuild it.

Since I took care to keep all the STLs (Prusa originals and derivatives are awesome in terms of long-term maintenance), had spare Arduino boards and ample extras–including a Raspberry Pi touchscreen and an unused extruder kit I had intended to fit it with–it left the house almost like it came in (i.e., as a kit), and even though I’ll miss it to a fair degree, I hadn’t really used it in almost a year.

This printer had a great run, and was extraordinarily maintainable–I replaced many of its parts over the years (including nearly replacing its extruder assembly before I got the other ones).

It also became my first Klipper printer, and the excitement from that upgrade and the realisation that 3D printing was going through a stepwise evolution was pretty much the reason I got my second.

The KP3S Pro was my choice as a follow-up printer, and an attempt to regain finer print quality (which I did) while retaining some control over the hardware and software–I bought it intending from the start to run Klipper, and it has served me very well.

After swapping out its extruder assembly and bolting on a Bambu clone hotend and an inductive sensor a little while ago (which I also made a video about), it is now the quietest (and, funnily enough, most hassle-free) of my printers, even considering that its cantilever setup makes it a tad wonky.

Despite the limitations of its relatively small 220x220 build plate, I use it a lot during the day to print small jigs, calibration samples and slices of prototypes, to the fascination of some of the people I have video calls with. Being quiet, precise and low-friction for small functional work, it is perfect for the kind of slow, iterative prototyping that I can squeeze in during some work weeks, although to be completely fair it is a tad small, so for most final prints I have to move “up”.

I had the good fortune of getting an SK1 when Two Trees dipped its toes into the 3D printer manufacturing business (which they appear to have since exited, sadly), and upgraded it from its Bambu Lab P1-like barebones frame to a fully enclosed configuration including auxiliary part cooling fans, and I have quite enjoyed the ride.

As my first Core XY, the thing was a pretty amazing leap in terms of print speed and quality, and it is still rock solid provided you can deal with its somewhat uneven temperament and a few quirks.

There is a lot to like mechanically–since it (cleverly) uses Bambu clone hotends, it has been the printer I’ve used with most of my tougher abrasive filaments, and coupled with a BIQU cool plate it has been perfect for stuff that would never print reliably on the KP3S Pro. The stepper motors and mechanics have been rock solid (the only part that broke down was the toolhead fan, which somehow lost a blade), and ever since I enclosed it it’s only improved.

It does have one significant hardware foible–the extruder is very prone to heat creep, and it’s impossible to reliably print PLA on it with it fully enclosed unless you use a vent like this one and turn on the fans–which, even if only slightly on, just add to the noise, especially when the printer is running at speed.

The shipping Klipper firmware has always been a little buggy, and although I did some creative upgrading and replaced the screen with a USB-networked Pi, it still has some weird pre-print slowdowns and glitches due to the rather complex Voron Trident-like homing sequence that I’ve yet to fully iron out.

My plans for it, now that I have a new “big” printer, include completely reflashing the entire thing with more modern firmware and, eventually (if I can figure out a good, reliable replacement that isn’t a major pain to mechanically assemble), upgrading the toolhead to a more future-proof combination.

But the excellent mechanics aren’t really compromised by a few software and thermal-design decisions, and I suspect it will stick around for a while.

I will write more about the whys, hows, and outcomes, but I spent a long while making up my mind about this one, and it’s going to both replace and complement the SK1–it’s roughly the same size (except for the ludicrous top cover), but I needed something to print (slightly) tougher materials, use multi-material for supports, and, overall, enjoy a bit less tweaking and more automated tuning.

And yes, I decided to get in on the toolchanger craze, but not because I want to print multi-coloured baubles–I want to print functional parts with different materials, and toolchangers are another stepwise evolution in the 3D printing world that I want to explore.

I’m slowly getting used to it and jotting down notes for an in-depth post in a few weeks (maybe months, depending on how summer pans out), but I’ve already used it to print that SK1 vent and a few small precision multi-colour and multi-material tests. It is noisy enough that I don’t enjoy running it at full speed while I’m in the office (and its “silent” mode is quieter, but still not something I want to put up with during meetings), so I’m using it mostly on weekends.

OrcaSlicer works (almost) perfectly with it (and is sure to improve), and I’ve already dipped my toes into building a monitoring app since I am still thinking of it as a sealed appliance, but I know that there will be alternate firmware versions soon(ish) and expect it to become just another Klipper printer (or close enough) in due time–that, and the simple, no-frills mechanicals, were two of my bets when I picked it out; the third was that maintainability would win out over its somewhat spartan feature set. It’s early days for that, of course.

And of course I’ve gone and started patching around some of Flashforge’s shortcomings myself–besides that Swift-based desktop app to talk to it, I’ve also printed my own version of a purge bucket (a rite of passage for any modern printer, including toolchangers, it seems), and am actively trying to get around to actually using it for the stuff I want–for which all I really need is the most precious commodity: time.

That and, of course, working my way up to the final print jobs it’s meant to do–the other printers still have their work cut out for them…

• Support for direct access to other LANs (and outbound Internet connections) via “exit nodes”
• Support for every single operating system I use (including both major mobile platforms)
• Ability to run an exit node on the Apple TV
• Availability of an alternate central management service.

I have been using it for a couple of years as a way to remotely access my home machines (and other stuff) when traveling, and have been very happy with it.

This is something I picked up on github but modified to use vdf:

#!/bin/env python
import os
from pathlib import Path
import vdf

LOGIN_USERS = Path(Path.home() / ".local/share/Steam/config/loginusers.vdf")
REGISTRY = Path(Path.home() / ".steam/registry.vdf")

def main():
    print("Current account:", get_account())

    accounts = get_accounts()
    account = choose_account(accounts)
    set_account(account)

    if input("\nRestart steam? [Y/n]: ").lower() != "n":
        os.system("killall steam")

def get_accounts():
    with open(LOGIN_USERS, ‘r’) as f:
        user_registry = vdf.load(f)
    return user_registry[‘users’]

def choose_account(accounts):
    accounts_to_choose = {
        account[‘AccountName’]: [str(i), account[‘AccountName’], account[‘PersonaName’]]
        for i, account in enumerate(accounts.values())
    }
    while True:
        print("\nChoose an account:")
        for i, name, username in accounts_to_choose.values():
            print(f"{i}: {name} ({username})")
        acc = input()
        for account, names in accounts_to_choose.items():
            if acc in names:
                return account

def get_account():
    with open(REGISTRY, ‘r’) as f:
        registry = vdf.load(f)
    return registry[‘Registry’][‘HKCU’][‘Software’][‘Valve’][‘Steam’][‘AutoLoginUser’]

def set_account(account):
    with open(REGISTRY, ‘r’) as f:
        registry = vdf.load(f)
    registry[‘Registry’][‘HKCU’][‘Software’][‘Valve’][‘Steam’][‘AutoLoginUser’] = account
    with open(REGISTRY, ‘w’) as f:
        vdf.dump(registry, f, pretty=True)

if __name__ == "__main__":
    main()

This is something I wrote to manage shortcuts for Linux emulators:

#!/bin/env python
from os import environ, remove
from os.path import join, exists, splitext
from pathlib import Path
from vdf import binary_load, binary_dump, dump, parse
from requests import Session
from requests.structures import CaseInsensitiveDict
from logging import getLogger, basicConfig, INFO, DEBUG, WARN
from zlib import crc32
from click import group, option, command, argument, secho as echo, pass_context, STRING
from shutil import copyfile
from shlex import quote

basicConfig(level=INFO, format='%(asctime)s %(levelname)s %(message)s')

log = getLogger(__name__)

STEAM_ID             = environ.get("STEAM_ID", "901194859")
STEAM_PATH           = environ.get("STEAM_PATH","/home/me/.steam/steam")
STEAM_USER_DATA_PATH = join(STEAM_PATH,"userdata",STEAM_ID,"config")
STEAMGRIDDB_API_KEY  = environ.get("STEAMGRIDDB_API_KEY","dc5b9820c178614336d7659eb7b64453")
GRID_FOLDER          = join(STEAM_USER_DATA_PATH,'grid')
CACHE_PATH           = join(environ.get("HOME"),".cache","steamgriddb")
SHORTCUTS_FILE       = join(STEAM_USER_DATA_PATH,'shortcuts.vdf')
LOCALCONFIG_FILE     = join(STEAM_USER_DATA_PATH,'localconfig.vdf')

for f in [GRID_FOLDER, CACHE_PATH]:
    if not exists(f):
        Path(f).mkdir(parents=True, exist_ok=True)

@group()
def tool():
    """A simple CLI utility to manage Steam shortcuts for Linux emulators"""
    pass

@tool.command()
def list_shortcuts():
    """List all existing shortcuts"""
    with open(SHORTCUTS_FILE, "rb") as h:
        data = binary_load(h)
    data = data[‘shortcuts’]
    headers = "appid AppName Exe LaunchOptions LastPlayTime".split()
    rows = []
    for i in range(len(data)):
        r = CaseInsensitiveDict(data[str(i)])
        rows.append([r[k] for k in headers])
    column_widths = {header: max(len(header), *(len(str(row[i])) for row in rows)) for i, header in enumerate(headers)}
    header_format = " | ".join(f"{{:{column_widths[header]}}}" for header in headers)
    row_format = header_format
    echo(header_format.format(*headers))
    echo("-+-".join(‘-’ * column_widths[header] for header in headers))
    for row in rows:
        echo(row_format.format(*row))

@tool.command()
def list_steam_input():
    """List Steam Input settings"""
    with open(SHORTCUTS_FILE, "rb") as h:
        data = binary_load(h)
    data = CaseInsensitiveDict(data[‘shortcuts’])
    apps = {}
    for k,v in data.items():
        apps[str(v[‘appid’])]=v[‘AppName’]
    with open(LOCALCONFIG_FILE, "r", encoding="utf8") as h:
        data = parse(h)
    if ‘UserLocalConfigStore’ not in data:
        return
    data = data[‘UserLocalConfigStore’][‘apps’]
    for k in data:
        data[k]["appid"] = k
        if k in apps:
            data[k]["AppName"] = apps[k]
        else:
            data[k]["AppName"] = "(Unknown)"

    headers = "appid AppName OverlayAppEnable UseSteamControllerConfig SteamControllerRumble SteamControllerRumbleIntensity".split()
    rows = []
    for r in data:
        rows.append([data[r][k] if k in data[r] else "" for k in headers])
    column_widths = {header: max(len(header), *(len(str(row[i])) for row in rows)) for i, header in enumerate(headers)}
    header_format = " | ".join(f"{{:{column_widths[header]}}}" for header in headers)
    row_format = header_format
    echo(header_format.format(*headers))
    echo("-+-".join(‘-’ * column_widths[header] for header in headers))
    for row in rows:
        echo(row_format.format(*row))

@tool.command()
@argument(‘appid’, type=STRING)
def disable_steam_input(appid):
    """Disable Steam Input for an appid"""
    if isinstance(appid, str):
        with open(SHORTCUTS_FILE, "rb") as h:
            data = binary_load(h)
        data = data[‘shortcuts’]
        apps = {}
        for k,v in data.items():
            apps[str(v[‘appid’])]=v[‘AppName’]
        if appid not in apps:
            log.error(f"invalid appid {appid}")
            return
        with open(LOCALCONFIG_FILE, "r", encoding="utf8") as h:
            data = parse(h)
        if ‘UserLocalConfigStore’ not in data:
            data[‘UserLocalConfigStore’] = {‘apps’:{}}
        apps = data[‘UserLocalConfigStore’][‘apps’]
        if appid not in apps:
            apps[appid]={}
        apps[appid]["OverlayAppEnable"] = "1"
        apps[appid]["UseSteamControllerConfig"] = "0"
        apps[appid]["SteamControllerRumble"] = "-1"
        apps[appid]["SteamControllerRumbleIntensity"] = "320"
        with open(LOCALCONFIG_FILE, "w", encoding="utf8") as h:
            dump(data, h)


@tool.command()
@argument(‘grid_id’)
def fetch(grid_id):
    """Fetch media for <grid_id> from SteamGridDB"""
    fetch_images(grid_id)

def find_id(name):
    headers={‘Authorization’: f’Bearer {STEAMGRIDDB_API_KEY}'}
    with Session() as s:
        response = s.get(f’https://www.steamgriddb.com/api/v2/search/autocomplete/{name}',
                         headers=headers)
        log.info(f"{name}:{response.status_code}")
        if response.status_code == 200:
            data = response.json()
            if data[‘success’]:
                return data[‘data’][0][‘id’] # take first result only

def fetch_images(game_id):
    headers={‘Authorization’: f’Bearer {STEAMGRIDDB_API_KEY}'}
    with Session() as s:
        for image_type in [‘banner’,'grid', ‘hero’, ‘logo’]:
            local_path = join(CACHE_PATH,f"{game_id}.{image_type}")
            have = False
            for ext in [".jpg", ".png"]:
                if exists(f"{local_path}{ext}"):
                    have = True
            if have:
                continue

            if image_type == ‘hero’:
                base_url = f’https://www.steamgriddb.com/api/v2/heroes/game/{game_id}'
            elif image_type == ‘banner’:
                base_url = f’https://www.steamgriddb.com/api/v2/grids/game/{game_id}?dimensions=920x430,460x215'
            else:
                base_url = f’https://www.steamgriddb.com/api/v2/{image_type}s/game/{game_id}'

            response = s.get(base_url, headers=headers)
            log.info(f"{game_id},{image_type},{response.status_code}")

            if response.status_code == 200:
                data = response.json()
                if data[‘success’] and data[‘data’]:
                    image_url = data[‘data’][0][‘url’]
                    ext = splitext(image_url)[1]
                    response = s.get(image_url)
                    if response.status_code == 200:
                        with open(f"{local_path}{ext}", ‘wb’) as f:
                            f.write(response.content)
                        log.info(f"{image_url}->{local_path}")

@tool.command()
@option("-e", "–emulator", default="org.retrodeck.RetroDECK", help="flatpak identifier")
@option("-a", "–args", multiple=True, help="arguments")
@option("-n", "–name", default="RetroDECK", help="shortcut name")
@option("-i", "–dbid", help="SteamGridDB ID to get images from")
def create(emulator, args, name, dbid):
    """Create a new shortcut entry"""

    if not dbid:
        dbid = find_id(name)
    fetch_images(dbid)

    if exists(SHORTCUTS_FILE):
        with open(SHORTCUTS_FILE, ‘rb’) as f:
            shortcuts = binary_load(f)
    else:
        shortcuts = {‘shortcuts’: {}}

    appid = str(crc32(name.encode(‘utf-8’)) | 0x80000000)
    new_entry = {
        "appid": appid,
        "AppName": name,
        "Exe": "flatpak",
        "StartDir": "",
        "LaunchOptions": f"run {emulator} {quote(" ".join(args))}",
        "IsHidden": 0,
        "AllowDesktopConfig": 1,
        "OpenVR": 0,
        "Devkit": 0,
        "DevkitGameID": "shortcuts",
        "LastPlayTime": 0,
        "tags": {}
    }
    log.debug(new_entry)
    shortcuts[‘shortcuts’][str(len(shortcuts[‘shortcuts’]))] = new_entry
    log.info(f"added {appid} {name}")

    for image_type in [‘grid’, ‘hero’, ‘logo’,'banner']:
        local_path = join(CACHE_PATH,f"{dbid}.{image_type}")
        for e in [".jpg", ".png"]:
            if image_type == ‘grid’:
                dest_path = join(GRID_FOLDER, f'{appid}p{e}')
            elif image_type == ‘hero’:
                dest_path = join(GRID_FOLDER, f'{appid}_hero{e}')
            elif image_type == ‘logo’:
                dest_path = join(GRID_FOLDER, f'{appid}_logo{e}')
            elif image_type == ‘banner’:
                dest_path = join(GRID_FOLDER, f'{appid}{e}')
            log.debug(f"{local_path+e}->{dest_path}")
            if exists(local_path + e):
                copyfile(local_path+e, dest_path)

    with open(SHORTCUTS_FILE, ‘wb’) as f:
        binary_dump(shortcuts, f)
        log.info("shortcuts updated.")

if __name__ == ‘__main__’:
    tool()

It’s about time. I’ve been running adapted versions of Proxmox on ARM for a few years now–first Pimox on a Raspberry Pi 4, and later on RK3588 boards–and ARM servers have been around for at least as long, so the fact that official support is only arriving now makes me a bit worried about Proxmox’s ability to do off-the-wall things like pve-microvm.

But this is proper support, with feature parity across VMs, LXC, clustering, ZFS, Ceph and backups, plus ISO images and package repositories–and it will be very nice to have official upstream packages when I go back into homelab ARM server land.

airport-utility is an MIT-licensed reimplementation for macOS 27 and later, with a Swift interface and a Python backend for the AirPort Configuration Protocol. It supports both ACP generations and has been tested against several models from all three product lines, so it should let people keep configuring their AirPorts after Apple’s utility disappears.

The project is still in beta, requires macOS 13 or later, Swift 6 and Python 3.10, and some devices and features have not been tested yet. It has no third-party Swift or Python dependencies.

I should probably start marketing piclaw as “Cloudflare OS on your own hardware”, given the amount of convergent evolution agentic workspaces seem to be enjoying these days–persistent chats, tools, generated apps, terminals and guarded access to external services all seem to be arriving independently at roughly the same shape.

The repository is, unsurprisingly, built around Workers and the rest of the Cloudflare stack, including their freshly tweaked inference.

This intrigues me quite a bit, since I’ve been looking into ternary models myself. It isn’t hard (at all) to beat Gemma 4 on quality, or to push tokens quickly through consumer hardware if you accept the quality trade-offs, but there may be a sweet spot at the intersection of quantization, model size and–more importantly–memory bandwidth where local models become genuinely useful without what is now massively expensive prosumer hardware.

As usual, I have quibbles with the benchmarks–Qwen’s MoE models, especially with MTP, are hard to beat at this scale, and Maple’s own table has Qwen3.5 35B-A3B ahead overall. I’m taking the 218 tokens/s and SOTA framing with a large pinch of salt, but this is another useful data point on the number of optimization techniques people are trying.

Update, two days later: I took a stab at getting it to run on AVX2 and it’s… OK. Nothing special, and clearly I’m hamstrung by the hardware, but it works. If they release bigger weights I’ll be ready.