My Weird Prompts

Ubuntu 26.04 LTS landed in April 2026, and the first point release arrived in late September. So is staying on the LTS track still a meaningful technical compromise, or have point releases, hardware enablement stacks, and stable release updates closed the gap? This episode walks through how Canonical's maintenance model actually works — five years of standard support, up to fifteen with Ubuntu Pro, and the escape hatches that let fast-moving software bypass the freeze. Then it examines where staleness still shows up: the Wayland-only desktop, the application isolation layer, and the one place the model genuinely gets tested — AMD GPU compute, where ROCm is now native in the Ubuntu archive and managed by apt. If you've ever wondered whether to upgrade or hold steady, this is the breakdown.

Key sources:

• Canonical, release cycle & support matrix — https://ubuntu.com/about/release-cycle

• Canonical, kernel lifecycle & HWE — https://ubuntu.com/kernel/lifecycle

• Ubuntu 26.04 LTS release notes — https://documentation.ubuntu.com/release-notes/26.04/summary-for-lts-users/

Episode 5969 — myweirdprompts.com/n/5969 (permanent short link: myweirdprompts.com/979966)

Gentoo has a reputation built in an era of weekend-long installs and hand-compiled kernels — but the distribution has quietly gone through its biggest change in twenty years. Official binary packages arrived in December 2023, and the repository has grown to 89 gigabytes. So what is Gentoo actually like as a daily desktop in 2026? This episode digs into the internal numbers that go the wrong direction, why nobody actually knows how many people run it, what a day with Portage looks like when binaries and source mix in a single command, and whether the difficulty reputation survives contact with modern Gentoo.

Key sources:

• Gentoo homepage, sponsor call dated 2026-10-07, kernel vulnerability post 2026-05-19 — https://www.gentoo.org/

• 2025 in retrospect, 2026-01-05 — https://www.gentoo.org/news/2026/01/05/new-year.html

• Michał Górny, Why Gentoo?, 2026-05-28 — https://blogs.gentoo.org/mgorny/2026/05/28/why-gentoo/

Episode 5968 — myweirdprompts.com/n/5968 (permanent short link: myweirdprompts.com/743974)

If you've run Linux on the desktop for years but never got a straight explanation of firmware, this one's for you. We trace the arc from legacy BIOS boot — where the firmware executes 440 bytes of MBR code and then forgets you exist — through UEFI's structural shift to filesystem-aware firmware launching .efi applications off the EFI System Partition. Then we cleanly separate UEFI from Secure Boot, walk the PK/KEK/DB/DBX key hierarchy, and explain why Ubuntu's chain validates the shim, GRUB, and kernel but leaves the initramfs unchecked. Along the way: why the CSM was never part of the UEFI spec, why the early UEFI bug reputation was earned, and what the Microsoft third-party UEFI CA expiration in 2026 means for machines that never got a firmware update. Practical, concrete, and finally explained.

Key sources:

• ArchWiki — https://wiki.archlinux.org/title/Arch_boot_process

• ArchWiki — https://wiki.archlinux.org/title/Unified_Extensible_Firmware_Interface

• ArchWiki — https://wiki.archlinux.org/title/Unified_kernel_image

Episode 5967 — myweirdprompts.com/n/5967 (permanent short link: myweirdprompts.com/625289)

Daniel built a desktop, hand-picked every part, and closed the case assuming the software knew what it was sitting on. It doesn't. This episode separates the Linux performance advice that's been measured from the advice that's just been repeated, starting with the single UEFI toggle that costs nothing and can be worth forty-two percent in CPU-bound work. From there it's a tour of the second tier — governor sweeps, schedutil versus performance, and why the ACPI platform profile beats both — before wading into the folklore around swappiness, swap, zram, and zswap. Some of it is proven and large. Some is proven and modest. A lot of it is plausible and completely unmeasured, and knowing which tier you're standing in is most of the value.

Key sources:

• kernel.org — https://www.kernel.org/doc/Documentation/cpu-freq/governors.txt

• kernel.org — https://docs.kernel.org/admin-guide/sysctl/vm.html

• XDA, 2026-07-04 — https://www.xda-developers.com/i-tested-the-same-gpu-with-jedec-and-expo-ram-and-the-performance-gap-shocked-me-more-than-any-gpu-upgrade-could/

Episode 5966 — myweirdprompts.com/n/5966 (permanent short link: myweirdprompts.com/102405)

Daniel spent twenty years on Linux desktops without understanding why anyone would compile software from source. This episode takes that question seriously, starting with the assumption everyone carries: that a self-built binary must be better optimized. It mostly isn't. A 1999 kernel recompile gained 1.8 percent; a 2026 Modern C++ benchmark found GCC with profile-guided optimization ran 9.4 percent slower than a plain O2 build, because the optimizer's bets didn't pay off. So why does the source tradition survive? Not for speed — for control over what gets built. USE flags let you compile out codecs, protocols, and integrations you never use, and code that isn't there can't be exploited. We walk through the two poles, Ubuntu's signed reproducible binaries versus Gentoo's Portage, what actually happens during a build, and why watching the compiler work is itself part of what people are buying.

Key sources:

• Gentoo, 2023-12-29 — https://www.gentoo.org/news/2023/12/29/Gentoo-binary.html

• Gentoo wiki — https://wiki.gentoo.org/wiki/Gentoo_Binary_Host_Quickstart

• Gentoo wiki — https://wiki.gentoo.org/wiki/Binary_package_guide

Episode 5965 — myweirdprompts.com/n/5965 (permanent short link: myweirdprompts.com/254954)

Daniel asked a simple question: what do you actually pay when you move an open-weight model off bare metal and into a container or a KVM virtual machine with PCIe passthrough? The published numbers don't agree — one paper measures containers at 0.03% overhead, another measures VMs at 21% average and up to 36% on the worst run. Both are correct. This episode unpacks why the benchmark literature quietly conflates four different isolation models under the single word "virtualization," where the overhead actually lives (spoiler: it's the IOMMU and the host scheduler, not the GPU), and which workload shapes feel it most. We also walk through a real deployment that booted perfectly, reported all eight GPUs healthy, and had silently lost GPU-to-GPU peer-to-peer — the kind of failure that doesn't show up until you're already in production.

Key sources:

• ICCS 2026 — https://www.iccs-meeting.org/archive/iccs2026/papers/167840464.pdf

• AMD Instinct docs — https://instinct.docs.amd.com/projects/virt-drv/en/latest/userguides/Getting%5Fstarted%5Fwith%5FMxGPU.html

• AMD MxGPU-Virtualization GIM 9.0.0.K release notes — https://github.com/amd/MxGPU-Virtualization/releases/tag/9.0.0.K

Episode 5964 — myweirdprompts.com/n/5964 (permanent short link: myweirdprompts.com/023477)

You own two GPUs, so you bolt them together and expect the model to spread itself across both. It almost never works that way. This episode breaks down the three real techniques for running one open-weight model across multiple cards on a single Linux box: tensor parallelism, pipeline parallelism, and offloading. Each one is a different trade between capacity, speed, and the cost of cards talking to each other — and the interconnect, not the compute, sets that price. We walk through what vLLM and llama.cpp actually support, why tensor mode is still experimental, why attention head counts can veto your card count, and what the documentation quietly admits about mismatched hardware. If you're speccing a new multi-GPU server or just adding a second card to an existing machine, this is the honest version of whether that second card is worth it.

Key sources:

• llama.cpp `docs/multi-gpu.md` — https://raw.githubusercontent.com/ggml-org/llama.cpp/refs/heads/master/docs/multi-gpu.md

• vLLM Parallelism and Scaling — https://docs.vllm.ai/en/stable/serving/parallelism_scaling/

• vLLM repo (docs/serving/parallelism_scaling.md, csrc/rocm, Dockerfile.rocm) — https://github.com/vllm-project/vllm

Episode 5963 — myweirdprompts.com/n/5963 (permanent short link: myweirdprompts.com/900787)

Word error rate has a formula that fits on a napkin, yet it's the number that ends up in every headline about speech recognition. This episode digs into the mechanics: how edit distance at the word level gets computed, why WER has no upper bound, and when character error rate is the more honest lens. Then it goes after everything a single score buries — normalization choices that swing results by forty points, a Whisper normalizer that strips vowel signs out of Indic scripts, inverse text normalization for numbers, named entities, code-switching, punctuation, and speaker attribution. Along the way: why WER agrees with human judgment less than any other metric tested, and what semantic metrics are doing about it.

Key sources:

• HuggingFace Audio Transformers Course, ch. 5 Evaluation metrics for ASR — https://github.com/huggingface/audio-transformers-course/blob/main/chapters/en/chapter5/evaluation.mdx

• Wikipedia, Word error rate — https://en.wikipedia.org/wiki/Word_error_rate

• TorchMetrics, WordErrorRate docs — https://torchmetrics.readthedocs.io/en/v1.1.2/text/word_error_rate.html

Episode 5962 — myweirdprompts.com/n/5962 (permanent short link: myweirdprompts.com/398196)

You've got the model loaded, VRAM to spare, and the GPU reports near-total utilization — so why is generation crawling? This episode pulls apart the single number everyone screenshots and looks at the physical mechanisms hiding underneath it. VRAM capacity is a feasibility check, not a performance prediction; decode is a streaming memory workload that runs sixty to two hundred times to the memory-bound side of the roofline. Along the way: why a warp stalled on a memory read still counts as "active," how tensor core fragments sixty-four rows tall turn eight real requests into a high-speed multiplication of zeros, and why the CPU can eat thirty percent of decode time at large batch sizes. Then the practical half — consumption versus saturation, what to measure on the rest of the box, and how to walk up to a slow Linux server and actually figure out what's wrong.

Key sources:

• NVIDIA DCGM Profiling module docs — https://docs.nvidia.com/datacenter/dcgm/latest/learn/modules/profiling.html

• DCGM Exporter metrics — https://docs.nvidia.com/datacenter/dcgm/latest/reference/dcgm-exporter-metrics.html

• nvidia-smi man page — https://man.archlinux.org/man/nvidia-smi.1.en

Episode 5961 — myweirdprompts.com/n/5961 (permanent short link: myweirdprompts.com/741090)

Everyone quotes tokens per second and time to first token as if they're the whole picture. They're not — an LLM serving system doesn't have a performance number, it has a surface. This episode breaks down prefill versus decode, why one is compute-bound and the other memory-bandwidth-bound, the latency and throughput metric families that quietly disagree with each other, and how to design a benchmark that doesn't lie to you. Plus: goodput, the queue cliff, and the worked example where 2,000 tokens per second turns out to mean four out of ten requests were acceptable.

Key sources:

• vLLM Docs — https://docs.vllm.ai/en/latest/benchmarking/cli.html

• vLLM Docs — https://docs.vllm.ai/en/latest/usage/metrics.html

• vLLM Docs — https://docs.vllm.ai/en/latest/design/metrics.html

Episode 5960 — myweirdprompts.com/n/5960 (permanent short link: myweirdprompts.com/710002)