🏡

October 12, 2026
1. 🔗 MetaBrainz MetaBrainz Summit 2026 rss
  
  Hi everyone! Sorry if we react slowly this week, that's because our brains are all slowed down digesting all of the chocolate! Which long term readers will know means we are in Barcelona at our yearly summit all week.
  
  Today Monday 12 we will have mostly an internal organizational day to figure out how to do things with our new Executive Director Silona.
  
  Tomorrow Monday 13 we will have the traditional presentations about how each project has been doing the past year. Those will be live-streamed on YouTube at https://www.youtube.com/live/OQzlSWMbX8I starting around 14:00 CEST, and we will take some questions from the community in the MetaBrainz room in Matrix/Discord after each presentation!
  
  More generally, we have a list of topics we are planning to discuss on our Summit wiki page. If you feel there's some other topic that we really should be discussing, please bring it up in our chat and we'll see if we can fit it!
  
  We will update this post with more info about the rest of the week as we figure things out - please forgive us for any organizational mishaps and slowness since we are still working to figure out the changes we need to the summit format for this year after the loss of Rob, who was always the main organizer of the event. And, of course, because of all the chocolate we are trying to digest…
  
  Current planning (to be fleshed out):
  
  | MON 12| TUE 13| WED 14| THU 15| FRI 16
  ---|---|---|---|---|---
  10:00| Org day| Org day| TBD| TBD| TBD
  14:00| Org day| State of projects (streamed)| TBD| TBD| TBD
2. 🔗 smol-machines/smolvm smolvm v1.27.1 release
  What's Changed
  - Branch concurrent requests with pinned ports from one source checkpoint by @BinSquare in #1725
  - Create machines from local images over the API under an opt-in local image directory by @BinSquare in #1707
  - Bump version to 1.27.1. by @BinSquare in #1726
  Full Changelog : v1.27.0...v1.27.1
3. 🔗 smol-machines/smolvm smolvm v1.27.0 release
  What's Changed
  - Retry removing a machine's data while something still writes into it, and log what was left by @BinSquare in #1679
  - Keep public HTTPS trust in credentialed minimal images by @BinSquare in #1697
  - Load the native root certificates once per process by @BABTUNA in #1692
  - Read only the data ranges of a VM disk when packing it by @BABTUNA in #1690
  - Run idle reclaim on Windows by @BinSquare in #1685
  - Prevent guest file reads from hanging on named pipes by @BinSquare in #1684
  - Bump libkrunfw to the Linux 6.18.55 guest kernel by @BinSquare in #1704
  - Preserve split UTF-8 characters in streamed exec output by @BinSquare in #1715
  - Forward stdin through streamed machine exec by @BinSquare in #1714
  - Keep streamed exec responsive to partial stdin frames by @BinSquare in #1716
  - Prepare file access without running commands from guest images by @BinSquare in #1700
  - Keep running VMs alive when serve startup fails by @BinSquare in #1717
  - Reuse a manifest pulled by digest instead of fetching it from the registry again by @BinSquare in #1718
  - Fix mirrored image cache keys and credential scoping by @BinSquare in #1686
  - Answer the readiness doorbell in pack run by @BABTUNA in #1720
  - Bound queued output for streamed API exec by @BinSquare in #1711
  - Report guest exec timeouts in direct and streaming responses by @BinSquare in #1703
  - Give each embedded control test its own database even within one clock tick by @BinSquare in #1677
  - Confirm macOS process exit events before reporting VM shutdown by @BinSquare in #1670
  - Bump libkrun to the Windows performance work by @BinSquare in #1722
  - Allow HTTP fallback for credentialed WebSocket clients by @BinSquare in #1698
  - Allow opt-in OAuth form credential substitution by @BinSquare in #1699
  - Accept pure OCI archives as local machine images by @BinSquare in #1710
  - Give credential interception leaves Authority and Subject Key Identifiers so strict TLS verification accepts them by @BinSquare in #1723
  - Bump version to 1.27.0. by @BinSquare in #1724
  Full Changelog : v1.26.1...v1.27.0
October 11, 2026
1. 🔗 HexRaysSA/plugin-repository commits sync plugin-repository.json rss
```
sync plugin-repository.json

No plugin changes detected
```
2. 🔗 r/Harrogate What is the glass pyramid about? rss
  
  | I have questions about this building…
  - What is it?
  - What goes on in there? There’s no signage
  - How did they get planning permission for it to be so tall and visible?
  - Why is the landscaping so out of keeping with the building? The brick paving looks like it should lead to a 1950s semi-detached submitted by /u/djodell
  [link] [comments]
  ---|---
3. 🔗 MetaBrainz Picard 3.0.2 released rss
  Picard 3.0.2 is a maintenance release for the recently released Picard 3.0 with fixes for reported issues and updated translations. This releases fixes a crash in the Setup Wizard if Picard was packaged with the automatic update check disabled and several color theme related fixes.
  
  The latest release is available for download on the Picard download page.
  
  The detailed changes for this maintenance release are below. For an overview of the new features since Picard 2.13 please see our detailed release announcement for Picard 3.0.
  
  Thanks a lot to everyone who gave feedback and reported issues.
  
  What’s new?
  
  Bugfixes
  - [PICARD-3484] - Hardcoded link styling in Audio Player options
  - [PICARD-3485] - Sticky grey background in metadata pane
  - [PICARD-3490] - Program crash after wizard if build with --disable-autoupdate
  - [PICARD-3491] - Text color issues in dark mode in metadata pane and placeholder texts
  - [PICARD-3494] - Plugin manager "View Repository" fails silently when remote is a local path
  Download
  
  Picard 3.0.2 is available for download from the download page of the Picard website. For Windows 10 and 11 users installing from the Microsoft Store the update to Picard 3.0.2 is now available and can be installed from the Microsoft Store app. Linux users can get the latest Snap package. The Linux Flatpak package is maintained separately and will be updated soon.
  
  Picard is free software and the source code is available on GitHub.
  
  Get in touch
  
  Please use the MetaBrainz community forums and the ticket system to give feedback, suggest new features or report bugs.
  
  Acknowledgements
  
  Code contributions by Philipp Wolfer and Laurent Monin.
  Translations were updated by st.esser (German).
4. 🔗 Stephen Diehl MLIR Part 14 - GPT-2 on the GPU rss
  GPT-2 on the GPU
  
  Part 8 built the GPU path by hand: kernels in the gpu dialect, NVVM lowering, PTX, and the driver calls that allocate memory and launch a grid. Parts 9 through 13 built a tensor compiler whose output ran on the CPU. This chapter joins the two. The same traced tensor programs, with the same formulas and the same reference checks, run on an NVIDIA GPU.
  
  There are three pieces of work. The parallel loops that remain after bufferization have to become kernels. Matrix multiplication needs a schedule that uses shared memory, since a naive thread-per-output mapping wastes the hardware. And the boundary between host arrays and device memory has to be decided. All of it lives in tinymlir/gpu.py, a module of about two hundred and fifty lines that the CPU path never calls into.
  
  The chapter ends with a second way to compile the model. Rather than one function per sublayer, the whole NumPy reference forward pass is traced into a single module, and that module is handed to either target.
  
  You need Linux on x86_64, an NVIDIA driver and a card of compute capability sm_75 or newer. A Tesla T4 on Google Colab is enough; the repository includes a notebook that installs the CUDA build of the bindings and runs everything below. Nothing else in the series requires a GPU.
  
  Where the Targets Diverge
  
  Recall the shape of the pipeline from Part 12. Fusion runs on tensors. Bufferization assigns storage and inserts deallocations. The result is a module of linalg operations over memrefs, and that module is what each target receives:
```
PassManager.parse(BUFFERIZATION_PIPELINE).run(lowered.operation)
if target == GPU:
    gpu.lower(lowered)
else:
    blas.rewrite(lowered)
    PassManager.parse(LOWERING_PIPELINE).run(lowered.operation)
```
  The GPU side has the same two-step structure as the CPU side, a substitution followed by a pipeline:
```
def outline(module):
    tiled_matmuls(module)
    PassManager.parse(KERNEL_PIPELINE).run(module.operation)
    managed_allocations(module)


def lower(module):
    outline(module)
    PassManager.parse(llvm_pipeline()).run(module.operation)
```
  outline is the part that is independent of hardware. It runs in the test suite on every platform, including machines with no GPU, and asserts that every loop in the module became a kernel launch. lower continues to PTX and needs the CUDA build of MLIR, which exists only for Linux.
  
  The order within outline matters. The matmul substitution has to come before the loop passes, otherwise the matmuls would be converted to parallel loops and nothing would be left to substitute. And both have to come after bufferization and buffer deallocation. The hand-written kernel contains gpu.barrier, whose memory effects the deallocation analysis can't see through. By the time the kernel is inserted, storage has already been assigned and released.
  
  Loops to Kernels
  
  The second step is a pipeline of existing MLIR passes:
```
KERNEL_PIPELINE = (
    "builtin.module("
    "convert-linalg-to-parallel-loops,"
    "func.func(scf-parallel-loop-tiling{parallel-loop-tile-sizes=16,16 "
    "no-min-max-bounds=true}),"
    "func.func(gpu-map-parallel-loops),"
    "convert-parallel-loops-to-gpu,"
    "gpu-kernel-outlining,canonicalize)"
)
```
  Each linalg.generic becomes an scf.parallel loop nest over its parallel iterators, with any reduction iterators as ordinary sequential scf.for loops inside. A softmax row reduction is therefore a parallel loop over rows containing a serial loop along each row. One thread handles one row. That is the right mapping for GPT-2's shapes, where the reduced dimension is at most a few thousand elements, and it is the only reduction strategy this backend has.
  
  Tiling splits each parallel loop into an outer loop over tiles of sixteen and an inner loop within the tile. The mapping pass annotates the outer loops as block dimensions and the inner loops as thread dimensions. Conversion turns the annotated nest into a gpu.launch, and outlining moves its body into a gpu.func inside a gpu.module, replacing it with gpu.launch_func. For the GELU of a (64, 256) matrix, the host function after this pipeline is:
```
%memref = gpu.alloc host_shared () : memref<64x256xf64>
gpu.launch_func @kernel_kernel::@kernel_kernel
    blocks in (%c4, %c16, %c1) threads in (%c16, %c16, %c1)
    args(%c16 : index, %c0 : index, %c16 : index, %c1 : index, %c0 : index,
         %arg0 : memref<64x256xf32>, %cst_2 : f32, %cst_1 : f32,
         %cst_0 : f64, %cst : f64, %cst_3 : f32, %memref : memref<64x256xf64>)
memref.copy %memref, %arg1 : memref<64x256xf64> to memref<64x256xf64>
```
  A grid of four by sixteen blocks of sixteen by sixteen threads covers the matrix. The kernel's body is the fused GELU region from Part 10 with gpu.block_id and gpu.thread_id in place of loop induction variables:
```
gpu.func @kernel_kernel(..., %arg5: memref<64x256xf32>, ..., %arg11: memref<64x256xf64>) kernel {
  %block_id_x = gpu.block_id x
  %thread_id_x = gpu.thread_id x
  ...
  %6 = memref.load %arg5[%4, %5] : memref<64x256xf32>
  %7 = math.powf %6, %arg6 : f32
  ...
  %12 = math.tanh %11 : f64
  ...
  memref.store %16, %arg11[%4, %5] : memref<64x256xf64>
  gpu.return
}
```
  The no-min-max-bounds option tells the tiling pass not to clamp the inner loop with min expressions when a dimension is not a multiple of sixteen, and to use a conditional in the body instead. The clamped form produces loop bounds that the GPU conversion can't map to a fixed block size.
  
  The test suite checks the outcome structurally. For GELU, softmax, layer normalization, matmul, gather and attention, the host function after outline must contain gpu.launch_func and no scf, linalg or memref.alloc operations. Everything that iterated now runs on the device.
  
  A Tiled Matrix Multiplication
  
  Running linalg.matmul through the same pipeline would work, and would be slow. It becomes a parallel loop over the output with a serial loop over $K$ inside, so each thread reads a full row of $A$ and a full column of $B$ from global memory. Adjacent threads in a block read overlapping data and nothing is shared. Part 8 introduced shared memory precisely for this case.
  
  The backend therefore replaces every floating-point linalg.matmul and linalg.batch_matmul with a call to a kernel written by hand. The kernel is a textual MLIR template, formatted for the operand rank and element type, parsed with ir.Module.parse and moved into the module. Omitting the batch handling and some of the bounds checks, its structure is:
```
func.func private @tiled_matmul_2d_f32(%a: memref<?x?xf32, ...>, %b: ..., %out: ...) {
  %m = memref.dim %a, %i0 : ...
  %k = memref.dim %a, %i1 : ...
  %n = memref.dim %b, %i1 : ...
  %gx = arith.ceildivui %n, %tile : index
  %gy = arith.ceildivui %m, %tile : index
  gpu.launch blocks(%bx, %by, %bz) in (%sx = %gx, %sy = %gy, %sz = %i1)
             threads(%tx, %ty, %tz) in (%ux = %tile, %uy = %tile, %uz = %i1)
             workgroup(%sa : memref<16x16xf32, #gpu.address_space<workgroup>>,
                       %sb : memref<16x16xf32, #gpu.address_space<workgroup>>) {
    %row = arith.addi (arith.muli %by, %tile), %ty
    %col = arith.addi (arith.muli %bx, %tile), %tx
    %sum = scf.for %k0 = %i0 to %k step %tile iter_args(%acc = %zero) -> (f32) {
      // each thread stages one element of the A tile and one of the B tile
      memref.store (load %a[%row, %k0 + %tx] or zero), %sa[%ty, %tx]
      memref.store (load %b[%k0 + %ty, %col] or zero), %sb[%ty, %tx]
      gpu.barrier
      %part = scf.for %kk = %i0 to %tile step %i1 iter_args(%s = %acc) -> (f32) {
        %x = memref.load %sa[%ty, %kk]
        %y = memref.load %sb[%kk, %tx]
        scf.yield (%s + %x * %y)
      }
      gpu.barrier
      scf.yield %part : f32
    }
    scf.if (%row < %m and %col < %n) {
      %old = memref.load %out[%row, %col]
      memref.store (%old + %sum), %out[%row, %col]
    }
    gpu.terminator
  }
  return
}
```
  Each block owns a sixteen by sixteen tile of the output. It walks the reduction dimension in steps of sixteen. At every step each of the block's two hundred and fifty-six threads loads one element of the current $A$ tile and one of the current $B$ tile into the two workgroup buffers, out-of-range positions reading as zero. A barrier makes the tile visible to every thread. Each thread then accumulates sixteen products from shared memory, and a second barrier keeps the next step's loads from overwriting a tile still being read. Every global element is loaded once per block instead of once per thread, a factor of sixteen fewer global loads.
  
  Two details connect the kernel to the surrounding program. The final store adds to the output rather than overwriting it, because linalg.matmul accumulates into its destination; the builder's linalg.fill with zero runs first as its own small kernel. And the kernel takes memrefs with fully dynamic sizes, strides and offset. The substitution inserts a memref.cast for each operand, so a single kernel per rank and element type serves every shape in the model, and strided views from slicing and transposition work without copies:
```
%cast = memref.cast %arg0 : memref<64x256xf32> to memref<?x?xf32, strided<[?, ?], offset: ?>>
%cast_0 = memref.cast %arg1 : memref<256x32xf32> to memref<?x?xf32, strided<[?, ?], offset: ?>>
%cast_1 = memref.cast %memref : memref<64x32xf32> to memref<?x?xf32, strided<[?, ?], offset: ?>>
call @tiled_matmul_2d_f32(%cast, %cast_0, %cast_1)
```
  The batched variant adds a third grid dimension indexed by the batch, which attention's per-head products use.
  
  This is the classic shared-memory matmul from the CUDA programming guide, no more. There is no register tiling, no vectorized or asynchronous loads, no tensor cores, and the tile size is fixed. cuBLAS would be several times faster on these shapes. The point is that the kernel is sixty lines of readable IR, inserted at the one place in the pipeline where a matrix multiplication is still a matrix multiplication, and it is enough to run the model.
  
  Managed Memory
  
  Part 8 moved data with explicit copies to and from the device. This backend avoids that bookkeeping with CUDA managed memory, which both the host and the device address through the same pointer. The compiler-side change is small. Every memref.alloc left by bufferization becomes a gpu.alloc with the host_shared attribute, and every memref.dealloc becomes the asynchronous gpu.dealloc bracketed by gpu.wait, which is the form the runtime library implements:
```
%memref = gpu.alloc host_shared () : memref<64x32xf32>
...
%0 = gpu.wait async
%1 = gpu.dealloc async [%0] %memref : memref<64x32xf32>
gpu.wait [%1]
```
  The runtime side is a Python class wrapping the same allocator. It calls mgpuMemAlloc from MLIR's CUDA runtime library with the host-shared flag and exposes the pointer through the NumPy array interface:
```
class Managed:
    def __init__(self, shape, dtype):
        self.pointer = runtime().mgpuMemAlloc(size, None, True)
        self.__array_interface__ = {
            "shape": tuple(shape), "typestr": dtype.str,
            "data": (self.pointer, False), "version": 3,
        }
```
  np.asarray on such an object is an ordinary NumPy array backed by managed memory. The JIT's call path places each input in managed memory, skipping arrays that already live there, and allocates the output there too. Since the output of one compiled sublayer is the input of the next, the residual stream never leaves the device during a forward pass. The model places its weights in managed memory once at load time.
  
  The cost is that the driver, not the program, decides when pages migrate. A first touch from the host after a kernel writes faults the page back. For this model, where the host reads one row of logits per step, that is the right trade. A latency-sensitive backend would want explicit transfers and streams, and the gpu dialect's async tokens are how it would express them.
  
  The execution engine loads the CUDA runtime library alongside the usual runner utilities. The PTX for each gpu.module is embedded in the host module as a gpu.binary, and a global constructor loads it into the driver when the engine initializes. Launching a kernel from the host function is then a call into the same runtime library that Part 8 called by hand.
  
  From NVVM to PTX
  
  The last pipeline carries the outlined module to LLVM on both sides of the launch boundary:
```
builtin.module(
  expand-strided-metadata,lower-affine,convert-scf-to-cf,
  nvvm-attach-target{chip=sm_75 O=3},
  gpu.module(convert-gpu-to-nvvm),
  gpu-to-llvm,finalize-memref-to-llvm,
  convert-arith-to-llvm,convert-func-to-llvm,convert-cf-to-llvm,convert-index-to-llvm,
  reconcile-unrealized-casts,
  gpu-module-to-binary{format=isa toolkit=<path to nvidia-cuda-nvcc>})
```
  The passes are the ones from Part 8. The target attribute names the chip. convert-gpu-to-nvvm rewrites the body of each kernel into NVVM intrinsics for thread indices, barriers and shared memory. gpu-to-llvm rewrites the host side, turning allocations, launches and waits into calls into the runtime library. gpu-module-to-binary serializes each kernel module to PTX, with format=isa keeping the result as text rather than assembling it to SASS, which the driver does at load time for whatever card is present.
  
  The toolkit option points the serializer at libdevice. math.tanh and math.exp inside a kernel aren't single PTX instructions; they link against NVIDIA's bitcode library of math routines. The project gets libdevice and ptxas from the nvidia-cuda-nvcc package on PyPI, so no system CUDA installation is needed, and finds them by importing the package and asking where it lives.
  
  Having ptxas available means the PTX can be checked without a GPU. A test lowers each of the six cases above, extracts every gpu.binary, and assembles it for sm_75. Continuous integration runs this on an ordinary Linux runner. Malformed PTX from a bad conversion or a missing libdevice link fails the build long before anyone has hardware in hand. The test that compares GPU results with CPU results for the same six functions runs only when a device is present.
  
  Running It
  
  Pass --gpu to the example or to the verification script:
```
uv run python example.py "Alan Turing theorized that computers would one day become" --tokens 10 --gpu
uv run python verify.py --gpu
```
  Nothing in model.py changed for this. The functions embed, attend, feedforward and project are the ones from Part 13, and the target is a keyword passed through to the JIT. On a Colab T4, with compilation included, the ten-token generation took about half a minute and produced the same completion as the CPU and the NumPy reference. The verification script compared embeddings, every block's residuals, logits and token IDs at all ten steps. All ten tokens matched, with a largest absolute difference across the captured arrays of about $1.1\times10^{-5}$, against about $8\times10^{-6}$ on the CPU. The difference is the accumulation order: the tiled kernel sums sixteen products at a time in a fixed order, and the BLAS does something else.
  
  That number is the whole claim. The GPU target produces the reference's required output and agrees with its intermediate values to within tolerance on one card. It isn't fast by the standards of a production runtime.
  
  The Whole Model as One Kernel
  
  The per-sublayer design compiles four small functions and calls them in a Python loop over blocks. That was a deliberate choice for the series: each compiled function is small enough to print and read. The compiler itself doesn't require it. With the array protocols from Part 9 and the tree-structured arguments from Part 12, a traced function can take the entire parameter record and contain the entire forward pass.
  
  The fused.py module does exactly that with the NumPy reference. Its gpt2 function is the one from tiny-gpt2, pasted in and decorated:
```
@jit
def gpt2(inputs, params, *, n_head):
    x = params.words[inputs] + params.positions[range(len(inputs))]
    seq_len, embedding_dim = x.shape
    head_size = embedding_dim // n_head

    for block in params.blocks:
        ln1_mean = np.mean(x, axis=-1, keepdims=True)
        ln1_variance = np.var(x, axis=-1, keepdims=True)
        ln1_normalized = (x - ln1_mean) / np.sqrt(ln1_variance + 1e-5)
        ln1_output = block.attention_norm.weight * ln1_normalized + block.attention_norm.bias

        qkv_proj = ln1_output @ block.attention_in.weight + block.attention_in.bias
        q_proj, k_proj, v_proj = np.split(qkv_proj, 3, axis=-1)
        ...
        causal_mask = np.triu(np.ones((seq_len, seq_len), dtype=x.dtype) * -np.inf, k=1)
        attention_scores = attention_scores + causal_mask
        ...
```
  Every NumPy call dispatches to our symbolic value. params is the model's named tuple of weights, flattened to arrays by the JIT and reassembled inside the trace. The np.triu mask is evaluated by NumPy itself, because none of its arguments is symbolic; the resulting array is captured as a constant and lifted to a trailing kernel argument. There are twelve of them, one per block, each a (T, T) matrix. This implementation masks with -np.inf where Part 11's mask used $-10^{10}$; after the softmax both give the future positions exactly zero weight.
  
  Tracing produces one graph for the twelve blocks. Before optimization the module holds six hundred and fifty-two linalg.generic operations; elementwise fusion reduces them to two hundred and nine. The forty-nine linalg.matmul and twenty-four linalg.batch_matmul operations pass through untouched, which is what the tensor.reshape decision in Part 11 was protecting. On the CPU every one of them becomes a GEMM call. On the GPU every one becomes a launch of the tiled kernel.
  
  A separate specialization per sequence length would mean a compilation per generated token, and compiling this module is not cheap. The fused mode pads the token sequence to the next power of two and reads back the row of logits for the last real token:
```
def logits(ids, weights, config, target):
    padded = np.zeros(min(1 << (len(ids) - 1).bit_length(), config.context), np.int32)
    padded[: len(ids)] = ids
    output = gpt2(padded, weights, n_head=config.heads, target=target)
    return output[len(ids) - 1 : len(ids)]
```
  The causal mask guarantees that positions after the last real token don't influence it, so padding changes nothing in the row we read. A ten-token prompt generating ten tokens needs lengths sixteen and thirty-two, two compilations instead of ten.
```
uv run python example.py "Alan Turing theorized that computers would one day become" --tokens 10 --fused
uv run python verify.py --fused
uv run python example.py "..." --tokens 10 --gpu --fused
```
  All three produce the same sentence. In the fused mode the forward pass is one function with no intermediate values to capture, so the verification script compares only the final logits and the selected tokens. On a laptop the fused run took roughly three times as long as the per-sublayer run, nearly all of it LLVM compiling two large modules. On the T4 the two modes took about the same time.
  
  What the fused mode demonstrates is a property of the compiler rather than a performance result. The program that was compiled is the reference implementation, unmodified. The series spent four chapters building a frontend with its own operator set so that each piece could be examined in isolation. The same frontend, given an existing NumPy program, traces it whole.
  
  What the Structure Bought
  
  Look back at what didn't change to add the GPU target. The tensor language, the builder, the optimization pipeline, bufferization and every formula in ops.py and model.py are the ones from the CPU chapters. The target is a keyword argument. The additions are a loop-to-kernel pipeline assembled from existing passes, one hand-written kernel, and a hundred lines of memory plumbing.
  
  That was possible because the pipeline preserved structure for as long as it could. Matrix multiplication stayed a named operation through fusion and bufferization, so each target could substitute an implementation. Parallel iterators stayed parallel, so a pass could map them to threads. Allocations stayed explicit, so they could be redirected to managed memory. Each decision deferred in the earlier chapters became a seam here.
  
  The limits are equally visible. There is one reduction strategy, one tile size, one element type for the kernel, no key/value cache and no attention schedule that avoids materializing scores. A production compiler would decide each of these per shape and per device. This one makes them readable, and checks the result against the reference on real hardware.
  
  External Resources
  Previous: Part 13 - Running GPT-2 · Series contents
October 10, 2026
1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-10-10 rss
  IDA Plugin Updates on 2026-10-10
  
  New Releases:
  Activity:
  - augur
    
    9c95985e: Merge pull request #13 from 0xdea/dependabot/github_actions/actions-d…
  - idasql
    
    6212ece6: README: support links
2. 🔗 HexRaysSA/plugin-repository commits sync repo: +1 release, -1 release rss
```
sync repo: +1 release, -1 release

## New releases
- [IDASQL](https://github.com/allthingsida/idasql): 0.0.19

## Changes
- [IDASQL](https://github.com/allthingsida/idasql):
  - removed version(s): 0.0.10
```
3. 🔗 smol-machines/smolvm smolvm v1.26.1 release
  What's Changed
  - Reap a child after its exit event so a stopped VM is not left a zombie on macOS by @BinSquare in #1675
  - Bump version to 1.26.1. by @BinSquare in #1676
  Full Changelog : v1.26.0...v1.26.1
4. 🔗 smol-machines/smolvm smolvm v1.26.0 release
  What's Changed
  - Seed host-fetched and local image archives so no-network machines skip re-flattening by @BinSquare in #1635
  - Keep compression admission test stable under Windows CI load by @BinSquare in #1642
  - Keep a TSI guest off a host resolver the egress floor blocks by @BinSquare in #1641
  - Write a large upload into the guest as it arrives instead of holding all of it first by @BinSquare in #1640
  - agent: stop spinning on a child that closed its stdout by @BABTUNA in #1644
  - pack: flatten qcow2 disks on the host, writing only their data by @BABTUNA in #1646
  - Encode streaming exec errors as valid JSON by @BinSquare in #1649
  - Return 404 when a guest file does not exist by @BinSquare in #1648
  - Close guest stdin for streaming exec without input by @BinSquare in #1650
  - Reject incomplete streamed uploads and enforce declared byte counts by @BinSquare in #1647
  - Kill whatever is left in a machine's scope when its VM is torn down, and stop export helpers whose creator is gone by @BinSquare in #1638
  - Remove partial host files after interrupted guest streams by @BinSquare in #1639
  - Explain guest agent version skew during pack export by @BinSquare in #1636
  - Count SSBS that KVM gives guests on hosts that hide it from themselves by @BinSquare in #1657
  - Bump libkrun so a branchable child shares its source's memory by @BinSquare in #1660
  - Embedders register bundle paths in-process, not through the environment by @BinSquare in #1658
  - Let credential bindings set a header, match wildcard hosts, and be created by an embedder by @BinSquare in #1436
  - Avoid dropping virtio-net connections during parallel workloads by @BinSquare in #1661
  - Seed machine run from a local image archive by @BABTUNA in #1656
  - api: skip the create time seed for machines that fetch on the host by @BABTUNA in #1654
  - process: wait on the exit event instead of a polling tick by @BABTUNA in #1652
  - Reject invalid published ports in embedded machine creation by @BinSquare in #1662
  - Reclaim Kubernetes pod state after container and sandbox deletion by @BinSquare in #1666
  - Bump version to 1.26.0. by @BinSquare in #1673
  Full Changelog : v1.25.4...v1.26.0
5. 🔗 Ampcode News Use Your Claude Plan in Amp rss
  
  You can now use your Claude Pro/Max subscription in Amp. It's free and available for everyone now.
  
  When creating a new thread, just pick Mode > Claude Code. It'll ask to link your Claude sub if you haven't already done that.
  
  Under the hood, this mode uses the Claude Agent SDK instead of Amp's own agent. But we made it all work: orbs and runners, thread sharing, portals, multiplayer, thread-to-thread messaging and orchestration, etc.
  
  See the Claude sub docs for more information.
6. 🔗 Baby Steps Why 'externalized' proofs of cyclic trait impls does not work rss
  For this post, I wanted to talk about two different approaches to handling supertraits. I'm calling them modular proofs vs external proofs. The key idea of this post is that, if we want to have cyclic trait impls, we really need to use a modular proof strategy, where the impl establishes all supertraits hold. Previously we had considered an external strategy, where the piece of code using the impl has the obligation to prove the supertraits hold. Modular proofs always seemed better but I did not think they were workable in the past. But I have become convinced that external proofs are incompatible with Rust as designed, and hence modular proofs are really the only option1. This post dives into that reasoning, and also gives a bit of explanation of what I mean by proofs in the first place.
  
  Traits and supertraits
  
  So what do I mean by modular vs external proofs? Well, it all comes down to who is responsible for proving that supertrait obligations hold. Consider a trait like Magic:
```
trait Magic: Copy { }
```
  The supertrait declaration means that, whenever X: Magic for some type X, it should be true that X: Copy. We make use of this in generic functions:
```
fn is_copy<T: Copy>() {
}

fn is_magic<T: Magic>() {
    // Legal, because `T: Magic` implies `T: Copy`
    is_copy::<T>();
}
```
  The trick is that the compiler has to make sure that this implication holds - i.e., for every type X that implements Magic, X also implements Copy. So how does it do it?
  
  Modular proofs: the impl must show supertraits hold
  
  The obvious answer is to make proving supertraits part of deciding whether an impl is valid. For any impl of Magic, we can require that the Copy supertrait holds. So an impl like this would be illegal:
```
// In a modular system, this impl is *illegal*
impl Magic for String { }
```
  This impl is illegal because it would require that String: Copy, and that does not hold. Seems good.
  
  Modular proofs are a bit tricky
  
  I am calling these proofs modular because the idea is that we can prove an entire program is valid by proving each part of it separately. In "programming language" theory, this is typically called a "modular" check, as it works by breaking up the entire program into modules that can be independently checked.
  
  The idea with a modular proof is that we can trust impls to show that the supertrait relationships hold , we don't have to go and re-prove them over and over. If the impl is wrong, the impl will be invalid, but our code is fine. So if we have impl Magic for String, that implies the rest of the program can prove that String: Magic:
```
fn string_is_magic() {
    // Legal, because there is an impl for `String: Magic`:
    is_magic::<String>();
}
```
  In fact, since we know that Magic implies Copy, the rest of the program can even rely on impl Magic for String to conclude that String: Copy:
```
fn string_is_copy() {
    // Legal, because there is an impl for `String: Magic`,
    // and `Magic` implies `Copy`:
    is_copy::<String>();
}
```
  So long as impl Magic for String is invalid, none of this poses a problem to soundness, since the program overall doesn't type-check.
  
  Comparison with functions
  
  An easy way to understand the idea of modular checks is to think of functions. Imagine you have a function like this one:
```
fn compute_sum(a: i32, b: i32) -> i32 {
    format!("{a} + {b}") // <-- Error
}
```
  Clearly, this function is not legal. It takes two integers and promises to return a third integer, but in fact it returns a String. So the function is illegal. But if you have a call to that function from elsewhere, we consider that other call to be legal:
```
fn use_sum() {
    let c: i32 = compute_sum(2, 20); // OK
}
```
  Here, use_sum is relying on compute_sum to obey its contract. It's not the job of use_sum to check that, it can just assume it is true.
  
  The catch: how do we decide the impl is invalid
  
  There is a bit of a catch though. How do we decide if the impl is invalid? The basic idea was that impl Magic for String would have to prove that String: Copy. But we just saw that it could, in fact, do that by using itself. In other words, if we aren't careful, we can provide a proof that String: Copy like…
  - String: Copy because Magic implies Copy and
    
    String: Magic because impl Magic for String exists
  and then we would (incorrectly) conclude that the impl is valid. So clearly we need to do something to rule that out. We need a rule that says, when we are proving that an impl is valid, that proof cannot recursively rely on the impl itself.[^termination] I'll come back in a future post to ways we might do that, but for now, I want to explore another alternative.
  
  External proofs: the user of the impl must show supertraits hold
  
  When we first looked at this problem, way back in 2018 or so, we thought of another approach. What if we said that an impl is not responsible for proving supertraits. Instead, the idea would be that impl Magic for String is not enough to say that String: Magic. It only says that Shallow(String: Magic) - i.e., String implements Magic in a shallow way, but not in a deep way that includes the full supertraits. To prove thatString: Magic, we have to show that Shallow(String: Magic) and Shallow(String: Copy):2
```
Shallow(String: Magic)
Shallow(String: Copy)
---------------------------- Magic fully implemented
String: Magic
```
  This has the somewhat counterintuitive implication that impl Magic for String is actually legal in an "external proof" approach:
```
// In an external system, this impl is LEGAL
// (but unusable)
impl Magic for String { }
```
  The saving grace is that, while this impl is legal, you can't actually use it. This function for example does not compile:
```
fn string_is_magic() {
    // NOT legal in an external system:
    // * We can prove that `Shallow(String: Magic)`
    // * We CANNOT prove that `Shallow(String: Copy)`.
    is_magic::<String>();
}
```
  Here, String: Magic doesn't hold even though there is an impl of Magic for String, because the caller also has to check that String: Copy is implemented, and it is not. Huh, interesting.
  
  Comparison to functions: external is awkward
  
  the "external proof" approach for impls is clearly a bit awkward. If we make the comparison to functions, it's as if the caller has to double check that the callee's body matches its return type, it can't actually trust the declared signature. But, awkward or not, it does resolve our problem: given impl Magic for String, we cannot prove String: Copy, and hence we cannot prove that String: Magic. We can only prove that Shallow(Magic: String), which doesn't imply that the supertraits hold.
  
  But external doesn't work with unsafe traits
  
  Based on the above, for a long time, I was working with the assumption that, weird as they are, we would go with the "external proof" approach. However, as Ralf Jung and lcnr pointed out to me recently, this is very challenging to reconcile with unsafe traits. Consider an unsafe trait like Nullable:
```
// A type that can be safely transmuted from `0_usize`.
unsafe trait NullWord { }
```
  The way that Rust works, when we write an unsafe impl, it is the job of that impl to prove that the unsafe conditions hold. Other parts of the program get to trust the impl. So if I write a function like this one, it should be considered safe:3
```
fn foo<T: NullWord>() -> T {
   std::mem::transmute(0_usize)
}
```
  Now imagine that I wrote an invalid impl like this one:
```
// INVALID: We are asserting that `Box` can be null,
// which is not true!
unsafe impl<T> Nullable for Box<T> { }
```
  Given this program I could clearly call foo::<Box<u32>>(), but that would "go wrong" (cause "undefined behavior"). I think we would all agree that the fault lies in the impl. And yet, that is inconsistent: we say that the impl alone cannot be trusted to figure out if the supertraits are implemented, but it can be trusted to figure out if the unsafe impl is valid?
  
  Conclusion
  
  I definitely believe that we want to treat the "extra conditions indicated by unsafe" as a more general version of the other obligations that an impl has to establish to show that the trait holds- and therefore that we must have modular proofs. That's kind of a relief, because something always felt wrong about external proofs, but it was hard to put my finger on a concrete problem. In the next post in this series (whenever that may be…), I expect to cover the approach to coinductive modular proofs that I landed on. Then I expect to talk about an alternative that was proposed to me that I find quite appealing.
  1. I think this was obvious to Ralf Jung from the start. But it took me a bit. ↩︎
  2. This notation is called an inference rule. The conditions above the line are the premises and the bottom line is the conclusion. It says that, if you know the premises are true, you can infer that the conclusion holds. ↩︎
  3. In point of fact, I believe this will not compile because of special rules about unsafe, but that's not relevant to the point I'm trying to make. ↩︎
October 09, 2026
1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-10-09 rss
  IDA Plugin Updates on 2026-10-09
  
  Activity:
  - augur
    
    316aea1e: ci: bump taiki-e/install-action
  - haruspex
    
    2f5e86b1: Merge pull request #16 from 0xdea/dependabot/github_actions/actions-d…
    
    971faaeb: ci: bump taiki-e/install-action
  - idasql
    
    78245d38: idasql v0.0.19
  - plugin-ida
    
    8407fd6b: Exercise Python 3.14 compatibility (#31)
  - rhabdomancer
    
    c8dc27df: Merge pull request #15 from 0xdea/dependabot/github_actions/actions-d…
    
    633324c7: ci: bump taiki-e/install-action
2. 🔗 smol-machines/smolvm smolvm v1.25.4 release
  What's Changed
  - Remove pack staging directories left behind by a killed pack by @BinSquare in #1631
  - Refuse a rootfs extraction that lost sbin/init instead of booting it by @NickyHeC in #1228
  - Resolve a guest's DNS from the host so a blocked public resolver still works by @NickyHeC in #1226
  - agent: pull cold images through one crane process by @BABTUNA in #1523
  - CUDA fork: fix forking a CUDA golden failing with "rebase guest RAM: Device or resource busy" by @BinSquare in #1373
  - Add host-mediated egress policy and decision protocol by @BinSquare in #1434
  - Keep cache disk layers a branch still reads when collecting unused fork layers by @BinSquare in #1633
  - Bump version to 1.25.4. by @BinSquare in #1634
  - Keep machine execs alive when the image's workload exits by @BinSquare in #1632
  Full Changelog : v1.25.3...v1.25.4
3. 🔗 r/Harrogate Trying to build a social life rss
  
  Hi,
  I recently moved to Harrogate a couple of months ago for work. I’m in my early 20s and it’s been kinda hard trying to find clubs /social things to do which don’t really break the bank. I’m pretty much open to anything but was wondering if anyone was in a similar situation/had any recommendations.
  
  submitted by /u/Several-Zucchini-690
  [link] [comments]
4. 🔗 smol-machines/smolvm smolvm v1.25.3 release
  What's Changed
  - Return 400 when an image archive is not a container image by @BinSquare in #1625
  - fix(agent): propagate file-level fsnotify events from macOS directory changes by @Vishv07 in #1626
  - Start every command in a machine with the machine's environment, secrets and workdir by @BinSquare in #1628
  - Let a running machine's egress allow list be changed without a restart by @BinSquare in #1627
  - Start every command in a machine with the machine's environment, secrets and workdir by @BinSquare in #1629
  - Bump version to 1.25.3 by @BinSquare in #1630
  Full Changelog : v1.25.2...v1.25.3
5. 🔗 Simon Willison A new feature for my blog, built using my voice rss
  I shipped a new feature for my blog today: the Newsletters page, which offers an index of all of the newsletters I've sent out, both my free weekly Substack and my monthly sponsors-only updates. I built the feature almost entirely using my voice, chatting away to my laptop while I cooked dinner.
  
  Codex voice mode
  
  I used the ChatGPT desktop app for this, in the Codex tab, using the voice conversation mode, running against a local development environment. Here's what that looks like:
  
  I started the session against my local simonwillisonblog checkout by typing:
  
  Start dev server and open in browser
  
  This gave me a preview of the site that it would be working on, and meant that I could later ask it to show me the new pages so I could visually track its progress.
  
  Then I clicked the "Start new voice chat" button - that's not the microphone button, it's the one to the right of it - and set my laptop up in the kitchen so I could talk to it while I cooked.
  
  Talking to my computer
  
  I had a pretty good idea of what I wanted to build, and it's a simple enough Django feature that I was certain the model (in this case GPT-6 Astra High) would be able to do it. A new model, a migration, some view code, templates, and a couple of import functions to populate the database from external sources.
  
  Here's an extract of my voice transcript that was captured by Codex:
  
  Um, they do not. Um, this is going to be a new type of content. Um, it's not going to show up... Oh, hold on. Yeah, no- I do not want this to show up in my, um, tag pages and date archive pages and... Actually, no, I think... I don't want it on the tag pages. I don't want it on the, um, blog index page. But I think I do want it to show up on the date-based pages. You know, if you navigate to September the 19th, and I sent a newsletter on that page, I think I want that to show up. So... this is- so I think we probably need a new model. The other thing is that I want them searchable, uh the Substack ones are not searchable, because those are actually just copies of other s- on content on my blog. These monthly ones do contain unique content, and spe- and once they're... published, like once they're made public a month after they've gone out, I want them to show up on my search results.
  
  Apparently this was clear enough that the model knew what I wanted to build! You can read the full transcript, disfluencies and all, in this Gist.
  
  We went on like this for about half an hour (the time it took to cook dinner). The model would reply and occasionally ask clarifying questions, then get to work modifying the code.
  
  What we built
  
  We got a surprisingly long way entirely by voice:
  - A new model and migration to represent imported newsletters in Django, plus Django Admin configuration for that
  - Four working imports:
    
    The most recent Substack items via RSS
    
    Every other Substack item via their undocumented API, which GPT-6 Astra knew about (it tried /api/v1/archive directly) and then ran a search to figure out how to paginate it and found this article by Karen Spinner
    
    All of my published monthly newsletters from my simonw/monthly-newsletter-archive GitHub repository
    
    My most recent private sponsors-only newsletter from a private repository
  - The /newsletters/ and /newsletters/2026/ public archive pages
  - Newsletters showing up on day and month archive pages too, but not on tag pages or my homepage
  - Weekly Substack newsletters link to Substack; archived monthly newsletters have their own pages
  - Integration with my site search engine
  It was almost ready to ship. The catch was the imports: Astra offered to export data from my local copy so I could import that into production, but I wanted it to work like my other import scripts. Since some of the data lived in a private GitHub repository, this would involve creating a new API key, and for that I knew I'd have to sit at the keyboard for a while.
  
  Finishing it with a review
  
  Once I had finished cooking and judged it mostly feature-complete, I had Codex create a branch and open a pull request.
  
  I reviewed the code in the GitHub PR interface. It was nearly what I needed, except it had chosen to use Git in a subprocess for one of the import scripts. I needed one of the imports to pull from a private Git repository, so I figured the API would be a better bet. I switched to typing and had Codex swap that out for an API-based import instead.
  
  You can see the changes I made during the review in the extra commits on the PR. I fixed the import mechanism and made a few tweaks to the display of those public pages. It took an additional half hour of typing-based prompting to get to the point where I was happy to deploy it to production by landing the PR.
  
  The end result
  
  You can see the end result at the new newsletters index page, or view the page for a previous monthly newsletter.
  
  The index page shows my most recent Substack weekly newsletters and GitHub sponsors monthly newsletters mixed together in reverse chronological order. Further down the page are links to my by-year archive pages.
  
  GPT-6 Astra designed the page, and then tweaked that design based on my vocal feedback from glancing at the local preview across the kitchen.
  
  Better for multi-tasking than as a daily driver
  
  OpenAI love using voice-driven demos like this one for things like DevDay - and they do work well in that environment. I don't think this is going to be a daily driver for me though.
  
  I've written before about how much "work" I get done using ChatGPT voice mode on my phone while walking the dog - mostly research and brainstorming, but occasionally actual development work by having ChatGPT write and test out snippets of code.
  
  This feels different. The addition of the visual preview, plus being able to type or paste things in via the keyboard when I need to communicate something that doesn't work vocally, makes this a much more powerful way of interacting with a coding agent.
  
  I still switch back to typing once I get down to the details of things though. Being able to paste in examples and error messages, or directly highlight the code or feature that needs changing, remains more efficient than trying to describe it in words.
  
  I mainly work from home, which is good because there's no way I'd want to talk to my computer like this in a shared workspace!
  
  The killer feature for me is the ability to multi-task. I usually cook with a podcast or TikTok running; now I can actually build stuff instead.
  
  You are only seeing the long-form articles from my blog. Subscribe to /atom/everything/ to get all of my posts, or take a look at my other subscription options.
6. 🔗 streamyfin/streamyfin v0.55.1 release
  What's Changed
  
  0.55.1 is a bug fix release for 0.55.0. Nothing new to learn here: most of it comes straight out of the crash and error reports the new version sent back, plus the issues you filed in the first days after the release
  
  Thanks to everyone who reported a problem, and to @Simon- Eklundh and @whoopsi- daisy for their fixes!
  
  ✨ Highlights
  - Crash when leaving the player on iOS and tvOS 27 is fixed (#2139)
  - Resume points are kept when you leave the player before playback has started (#2154)
  - Sheets that would not open work again: track options, add to playlist, playlist sort, and the PIN and password prompt for a saved account (#2194)
  - Cancelled and failed downloads clean up after themselves , instead of leaving subtitles, trickplay images and partial videos on the device (#2168, #2169, #2170)
  - Sharper artwork , with logos, backdrops and cards requested at the pixel size of the screen (#2176, #2177)
  - Awards show up again on movie and series pages (#2136)
  🎬 Player
  - Fixed a crash when leaving the player on iOS and tvOS 27 (#2139)
  - Leaving the player before playback starts no longer resets the resume position on the server (#2154)
  - Audio and subtitle languages are matched by region, script and variant, so pt-BR is no longer mixed up with pt-PT, or zh-Hans with zh-Hant (#2152, #2174)
  - Items with nothing to play, like a book, a season or a plugin channel, show a notice instead of a Play button that fails (#2141)
  - "Play from here" sent from another client starts at the item you picked instead of the top of the list (#2147)
  - Subtitle search tells you when your account is not allowed to search, instead of saying no provider is set up (#2159)
  - Chromecast subtitle URLs are signed the way Jellyfin 12 accepts by default (#2158)
  - Android: leaving the player while subtitles load no longer freezes the app (#2160)
  - Android TV: the ExoPlayer engine tries once more when an audio track fails to start, before showing an error (#2162)
  - Watch progress is no longer reported in bursts when the app has been busy (#2190)
  📺 TV
  - A series or season tile on the TV home screen (Apple TV Top Shelf, Android TV recommendations) opens the series page, with the right season selected (#2146)
  - Back returns to Home after opening a page from the TV home screen (#2150)
  - A saved account whose credential has gone missing is removed and asks you to sign in again, instead of showing a connection error (#2157)
  ⬇️ Downloads
  - Cancelling a download removes its subtitles, trickplay images and partial video, and so does a download that fails (#2168, #2169)
  - Cancel holds when you press it right as a download starts or finishes (#2170)
  - Android: fixed a crash when a download is started shortly after the device has rebooted (#2186)
  - Deleting the last downloaded episode of a season moves to another season, and leaves the page when nothing is left (#2155)
  - Values sent by the server are cleaned before they are used in download file names (#2172, #2175)
  - The total download size is worked out without an extra render pass (#2163)
  🐛 Fixes
  - Track options, add to playlist, new playlist, playlist sort, and the PIN and password prompt for a saved account open again, and the sheets that only opened once keep working (#2194)
  - Logos, backdrops and card artwork are requested at device pixel size, so they are no longer soft on high density screens (#2176, #2177)
  - Awards load again on movie and series pages (#2136)
  - Library filter chips stay below the navigation bar after changing a filter or the sort order on iOS (#2193)
  - The "Is Favorite Or Liked" library filter is sent under the name the server expects (#2191)
  - Favorites "See all" no longer draws its first row under the header on Android (#2167)
  - Movie pages use the right header height when the device orientation is unknown (#2181)
  - Local network URL: an address the app cannot use is rejected instead of crashing the app at launch, and the field says clearly whether the address was saved (#2140, #2148, #2149, #2151)
  - Plugin settings and admin locks are kept when refreshing them fails, for example right after coming back online (#2187)
  - Seerr no longer attempts a password sign-in with an empty password when Quick Connect does not go through (#2188)
  - Seerr Discover no longer crashes when the server answers with something other than its settings, such as a proxy login page (#2182)
  - Seerr logo sized and aligned with the other rows in the intro sheet (#2164, #2180)
  - Android: fixed a crash at launch from the music player's media session (#2161)
  🔧 Build & Infra
  - Crash reporting sends less: expected responses and repeats of the same failure are skipped, and server addresses and host names are kept out of reports (#2142, #2144, #2156, #2189)
  - Tab bar labels and the search button are correct when the app is built with the iOS 27 SDK, ahead of moving the builds to Xcode 27 (#2196)
  - axios 1.20.0 security update (#2134), plus routine dependency updates (#2098, #2099, #2183, #2184, #2185)
  - CI and test stability (#2143, #2165, #2179)
  🛟 Support & Reporting Bugs
  - Bugs and feature requests: open an issue. Search existing issues first and add to a match if there is one.
  - Questions and help: Discord
  Include in bug reports: app version, platform and device, OS version, Jellyfin server version, direct play or transcoding, the media's codecs and subtitle format, which player you used (native or standard), steps to reproduce, and logs or a screen recording if possible.
  
  Full Changelog : v0.55.0...v0.55.1
7. 🔗 tintinweb/pi-subagents v0.20.0 release
  
  No content.
8. 🔗 HexRaysSA/plugin-repository commits sync repo: +4 releases, -2 releases rss
```
sync repo: +4 releases, -2 releases

## New releases
- [ida-bochs-binaries](https://github.com/hexrayssa/ida-bochs-binaries): 2.0.0, 1.0.5
- [ida-mcp](https://github.com/hexrayssa/ida-mcp): 20261008.0.1
- [ida-nexus](https://github.com/hexrayssa/ida-nexus): 0.13.4

## Changes
- [ida-mcp](https://github.com/hexrayssa/ida-mcp):
  - removed version(s): 0.8.1
- [ida-nexus](https://github.com/hexrayssa/ida-nexus):
  - removed version(s): 0.7.0
```
9. 🔗 smol-machines/smolvm smolvm v1.25.2 release
  What's Changed
  - Add a command that prints shell completion scripts by @0xprames in #1612
  - Install system-wide as root and refuse to serve when per-VM uids cannot reach smolvm by @BinSquare in #1616
  - Cache S3 mount lookups and small files, and serve requests concurrently by @BinSquare in #1618
  - Copy disk templates without writing their zero runs and resize storage before moving /dev by @BinSquare in #1619
  - Let exec refuse to boot a stopped machine with autoStart false, and keep serve on /workspace inside a smol machine by @BinSquare in #1615
  - Bump libkrun so frozen branches of a continued source and branchable clones work correctly and fast by @BinSquare in #1622
  - Record a directory entry's owner on Windows, so packed layers extract by @WynandVStaden in #1617
  - Add cache disk slots, so one checkpoint can be restored with a different cache mounted for each machine by @BinSquare in #1621
  - Bump version to 1.25.2 by @BinSquare in #1623
  - Mount a restored cache slot only into the machine's own containers by @BinSquare in #1624
  New Contributors
  - @0xprames made their first contribution in #1612
  - @WynandVStaden made their first contribution in #1617
  Full Changelog : v1.25.1...v1.25.2
10. 🔗 New Music Releases The Cranberries - Songs for Fall rss
  The Cranberries - a new release is available:
  - 2026-10-09: Songs for Fall (Compilation)
  Amazon: Canada | Deutschland | France | United Kingdom | United States
  
  Visit muspy for more information.
11. 🔗 New Music Releases The Pineapple Thief - Far and Wide rss
  The Pineapple Thief - a new release is available:
  - 2026-10-09: Far and Wide (Album)
  Amazon: Canada | Deutschland | France | United Kingdom | United States
  
  Visit muspy for more information.

generated: October 12, 2026 at 09:53:19

What's Changed

What's Changed

What’s new?

Bugfixes

Download

Get in touch

Acknowledgements

GPT-2 on the GPU

Where the Targets Diverge

Loops to Kernels

A Tiled Matrix Multiplication

Managed Memory

From NVVM to PTX

Running It

The Whole Model as One Kernel

What the Structure Bought

External Resources

IDA Plugin Updates on 2026-10-10

New Releases:

Activity:

What's Changed

What's Changed

Traits and supertraits

Modular proofs: the impl must show supertraits hold

Modular proofs are a bit tricky

Comparison with functions

The catch: how do we decide the impl is invalid

External proofs: the user of the impl must show supertraits hold

Comparison to functions: external is awkward

But external doesn't work with unsafe traits

Conclusion

IDA Plugin Updates on 2026-10-09

Activity:

What's Changed

What's Changed

Codex voice mode

Talking to my computer

What we built

Finishing it with a review

The end result

Better for multi-tasking than as a daily driver

What's Changed

✨ Highlights

🎬 Player

📺 TV

⬇️ Downloads

🐛 Fixes

🔧 Build & Infra

🛟 Support & Reporting Bugs

What's Changed

New Contributors