🏡
  • ↔
  • →
  1. August 05, 2026
    1. 🔗 iv-org/invidious Release v2.20260804.1 release

      Wrap-up

      This patch release fixes a regression in the OCI (container) build that omitted debug information, making it harder to diagnose issues in production. The fix ensures that the -no-pie link flag is passed correctly, restoring debug symbols for better stack traces and crash analysis.

      No new features are included in this release; it is solely focused on improving the debuggability of containerized instances.

      Bugs fixed

      For instance owners

      • Debug information is now included again in OCI images by passing the -no-pie link flag correctly (#5895)

      Full list of pull requests merged since the last release (newest first)

      • fix: pass -no-pie link flag argument to include debug information again for OCI (#5895, by @Fijxu)
      • Release v2.20260804.0 (#5893, by @github-actions[bot])
    2. 🔗 WerWolv/ImHex Nightly Builds release

      Nightly

      197055f Changelog

      • build: Fix plugin test building and running
      • fix: --scaling not applying properly on web build
      • feat: Add --scaling flag
      • fix: Cursor position being offset after scrolling web page
      • fix: Percent-encoded paths when opening files on macOS (#2800)
      • fix: Toolbar create and open icons disappearing (#2807)
      • fix: Infinite loop in hex::dec::lz4_decompress (#2806)
      • fix: Disable providers in sandboxed environments that don't work there
  2. August 04, 2026
    1. 🔗 Simon Willison New release of LLM adds support for reasoning traces, OpenAI Responses, server-side tools, and smarter logging rss

      I released LLM 0.32 this morning, the most significant new version of LLM since the initial launch of the project. The new version includes support for visible reasoning traces, server-side provider tools, redesigned content-addressable SQLite logs, new models, and new features enabled by the OpenAI Responses API. I also released a new version of the llm-anthropic plugin with substantial updates of its own.

      Headline features for LLM CLI users

      Running LLM against reasoning models now displays their reasoning traces to standard error, so you can see what they are "thinking" without that information being included in the standard output that you might pipe to another tool. Add -R/--hide-reasoning to turn this off.

      Running llm "think about the best thing about pelicans" in the macOS terminal window - grey text outputs saying Exploring pelican qualities, then after a paragraph of that a white paragraph of text comes out saying: The best thing about pelicans is their wonderfully oversized, practical design: that enormous bill and pouch look comical, but they make pelicans remarkably skilled fishers. Even better, many species cooperate—working together to herd fish before scooping them up. They’re a great mix of goofy, graceful, and surprisingly clever.

      LLM includes support out-of-the-box for the GPT-5.6 model family, and the new default model used with llm "prompt" is now the inexpensive but capable GPT-5.6 Luna.

      LLM calls can now use server-side tools from various providers. OpenAI provide a code execution environment as a server-side tool; LLM can now run prompts that benefit from that like so:

      llm --tool CodeInterpreter 'Show current python and SQLite versions'

      OpenAI also gets a WebSearch tool.

      The llm-anthropic plugin adds WebSearch, WebFetch, CodeExecution, and AnthropicMCP, which looks like this:

      llm -m claude-sonnet-5 -T 'AnthropicMCP("https://datasette.simonwillison.net/-/mcp")' \
  'how many rows in the blog_blogmark table?'

      That causes Anthropic to execute MCP calls against my new datasette-mcp plugin as part of a single request/response interaction with their API.

      The new llm openai endpoint command provides a tool for executing prompts against any OpenAI compatible endpoint as a one-liner. These aren't logged, which makes this a handy tool for running one-off prompts against anything that speaks the lingua franca of the LLM API world.

      Here's how I use that to run prompts against Gemma 4 12B running in my localhost LM Studio API, via uvx (no LLM installation required) and mixing in the llm-tools-quickjs tool plugin for good measure:

      uvx --with llm-tools-quickjs \
  llm openai endpoint http://localhost:1234/v1 -m google/gemma-4-12b \
  -T QuickJS 'Use QuickJS to multiply 3434 * 2434' --td

      Output reads Tool call: QuickJS_execute_javascript({'javascript': '3434 * 2434'}) 8358356 The result of 3434 * 2434 is 8,358,356.

      New features in the Python API

      LLM's Python API previously required you to create a conversation and then send messages to it one at a time. This was an abstraction over the true nature of LLMs, where each request carries a complete history of the messages that came before it. That abstraction started to get in the way for some more advanced cases, so the new release introduces a model.prompt(messages=[]) parameter that can be used like this:

      import llm
from llm import user, assistant, system

model = llm.get_model("gpt-5.6-luna")

response = model.prompt(messages=[
    system("You are a helpful pirate."),
    user("What is the capital of France?"),
    assistant("Paris, matey."),
    user("And Germany?"),
])
print(response.text())

      LLM previously returned an iterable sequence of strings from each prompt. This worked great when models returned a string response, but failed to predict the weird shape that models would evolve towards. Today many models return a mix of reasoning text, output strings, tool calls, and even image attachments. With LLM 0.32 you can do this instead:

      for event in model.prompt("Explain cats").stream_events():
    if event.type == "reasoning":
        print(f"[thinking] {event.chunk}", end="", flush=True)
    elif event.type == "text":
        print(event.chunk, end="", flush=True)
    else:
        print(f"Other event: {event}")

      Combine these features and we can finally provide a robust implementation of the semi-standard OpenAI chat completions API, which I've now released as the llm-chat-completions-server plugin:

      llm install llm-chat-completions-server
llm chat-completions-server --port 9000
# Server is now running on http://127.0.0.1:9000/v1

      Now you can run prompts against LLM via that server, using the new llm openai endpoint command!

      llm openai endpoint http://127.0.0.1:9000/v1 'hello' -m gpt-5.4-mini

      The bigger challenge with that kind of API concerns logging. If we're going to support the pattern where the message sequence is appended to on every request, ideally we can avoid logging all of that duplicate JSON for every turn.

      The solution is the new content-addressable message store, modeled after Git. You can see the new schema for that in the documentation, but the llm logs and llm logs --json commands have both been upgraded to convert that format back into something that's easy to consume.

      And the rest

      There is a whole lot more in this release. The 0.32 release notes are pretty comprehensive, and the notes for 0.32rc2, 0.32rc, 0.32a3, 0.32a2, and 0.32a0 should fill in any gaps.

      Existing LLM plugins should all continue to work, but plugins that provide extra models will need to be upgraded to 0.32 in order to participate fully in the new streaming events system. There's a guide to implementing plugins with Structured messages and streaming events in the documentation.

      I've updated some of my own plugins:

      I guess LLM is an agent framework now

      Quite a few of the lower-level tools changes in this release were driven by the needs of Datasette Agent. When I started work on LLM, the term "agent" had such a vague definition that I refused to use it. In September 2025 I came around to the idea that "An LLM agent runs tools in a loop to achieve a goal" is well established enough now that I could stop avoiding the term entirely.

      Tool chains can now pause for human approval and resume from a stored message history - both needed by Datasette Agent.

      Looking at LLM today it's beginning to look very agent-shaped to me. There's something neat about having a CLI utility that can mix and match different tools from different sources with different models all as a one-liner, and that includes a Python library powerful enough to build systems like Datasette Agent and llm-coding-agent.

      Maybe the next version of LLM will bake the concept of an "agent" into the core library. I'm still trying to figure out what that would look like.

      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.

    2. 🔗 iv-org/invidious Release v2.20260804.0 release

      Wrap-up

      This release focuses on fixing comment rendering, adding new configuration options for instance owners, and streamlining developer tooling. Comments in videos and community posts now render correctly again, a message appears when comments are disabled, and several new locales were made available to users.

      Instance owners gain SOCKS5 proxy support and the ability to set the videojs max buffer length via config.yml. Developer experience improves with Nix development files, a pinned Crystal version for linting, and an updated AI policy that properly bans AI slop.

      New features & important changes

      For Users

      • A message is now shown when comments are turned off (#4051)
      • New locales translated at more than 20% are now made available to users, this includes Belarusian, Galician, Swiss German, Armenian, Latvian and Uzbek (#5891, #5882)

      For instance owners

      • SOCKS5 proxy support was added (#5865)
      • The videojs max buffer length can now be set via config.yml (#5876)

      For developers

      • Nix development files were added (#5856, #5861)
      • The Makefile no longer uses the deprecated -Dpreview_mt flag (#5872)
      • Crystal was pinned to 1.20.3 for the linting task so Ameba can build (#5859)
      • The release script now uses deepseek/deepseek-v4-flash-0731 (#5886)
      • The AI policy was updated to properly ban AI slop (#5849)
      • The awesome humane tech badge was removed (#5853)
      • Development dependencies were excluded from the CI build job (#5860)
      • CI dependencies were bumped: actions/stale to 11 and actions/setup-python to 7 (#5890, #5829)

      Bugs fixed

      User-side

      • Rendered links and timestamps in video descriptions were fixed (#5878)
      • Comments HTML rendering was fixed (#5862)
      • Comments in community posts were fixed (#5874)
      • Non-comment commentFilterContextViewModel keys are now skipped in comments (#5870)

      Full list of pull requests merged since the last release (newest first)

      • CI: Exclude development dependencies from build job (#5860, by @Fijxu)
      • Enable the Uzbek since it's been translated at more than 20% (#5891, by @TheFrenchGhosty)
      • Translations update from Hosted Weblate (#5881, by @weblate)
      • Switch to deepseek/deepseek-v4-flash-0731 for the release script (#5886, by @TheFrenchGhosty)
      • chore(deps): bump actions/stale from 10 to 11 (#5890, by @dependabot[bot])
      • feat: add support for SOCKS5 proxy (#5865, by @unixfox)
      • feat: allow setting videojs max buffer length via config.yml (#5876, by @Fijxu)
      • fix: fix rendered links and timestamps in video descriptions (#5878, by @Fijxu)
      • Show message when comments are turned off (#4051, by @syeopite)
      • Enable the new locales translated at more than 20% (#5882, by @TheFrenchGhosty)
      • fix: also fix comments in community posts (#5874, by @Fijxu)
      • chore: remove -Dpreview_mt from Makefile as it has been deprecated by the Crystal compiler. (#5872, by @Fijxu)
      • Translations update from Hosted Weblate (#5474, by @weblate)
      • fix: skip non comment commentFilterContextViewModel key in comments (#5870, by @Fijxu)
      • fix: fix comments html rendering (#5862, by @Fijxu)
      • chore: Move nix files out of root directory (#5861, by @Fijxu)
      • CI: Pin Crystal to 1.20.3 for linting task so ameba can build (#5859, by @Fijxu)
      • chore: Add Nix development files (#5856, by @Fijxu)
      • Remove the awesome humane tech badge (#5853, by @TheFrenchGhosty)
      • Update the AI policy to properly ban AI slop (#5849, by @TheFrenchGhosty)
      • chore(deps): bump actions/setup-python from 5 to 7 (#5829, by @dependabot[bot])
    3. 🔗 r/LocalLLaMA Kimi K3 full model running on 16x GB10 cluster at 20+tps rss

      Kimi K3 full model running on 16x GB10 cluster at 20+tps | Kimi K3 full model running on 16x GB10 cluster at 20+tps average (llama-benchy coherent corpus) 38tps peak, 750tps prefill. This is the first run of full k3 with dspark on my cluster. I will be doing some tests and try tp speed this up. As soon as it looks ready I'll publish the vllm image and instructions.
      https://forums.developer.nvidia.com/t/full-kimi-k3-running- on-16x-gb10-cluster/379174 submitted by /u/ciprianveg
      [link] [comments]
      ---|---

    4. 🔗 MetaBrainz MusicBrainz Server update, 2026-07-30 rss

      We're happy to release our first MusicBrainz Server update since the schema change, following our migration of user accounts to the MetaBrainz website, which we've been spending most of our development time on until now. (This blog post also lags a bit behind the date we tagged the release, as you can tell from the title.)

      In case you're running a local MusicBrainz Server for development purposes, know that you can preserve the ability to log in without OAuth by adding sub LOCAL_ACCOUNTS_ENABLED { 1 } to lib/DBDefs.pm. (It's already enabled by default if DEVELOPMENT_SERVER is.)

      We've also made changes to digest authentication in the web service, detailed in the blog post linked above. If you don't use digest authentication or any apps that do, it's recommended you disable it from the Applications page.

      A new release of MusicBrainz Docker is also available that matches this update of MusicBrainz Server. See the release notes for update instructions.

      Thanks to julian45 and rinsuki for having contributed to the code. Thanks to affronttonature, Anesidora, arsinclair, chirlu, DarkAdonis, jesus2099, julian45, Lotheric, practik, rinsuki, and wileyfoxyx for having reported bugs and suggested improvements. Thanks to 7Stars, ApeKattQuest/MonkeyPython, Denatura, Early6431, EmO686, Flavia Telcean, GABG, Jeluang, JerryBest, KevinOpperman, LAY.JOSHI97, Lummerkurt, MFreedom89, Philipp Wolfer, ROManceJP, RalfZhang, The
      ParaziT, afterthemagic, blueday, coffeeicus, cuhsy, jerry155756294, julian45, karpuzikov, meze, mfmeulenbelt, mr_monkey, salo.rock, sashimi3433, scientists360, silentbird, soonaf, sq, welikeheon, wileyfoxyx, and
      zatto13 for updating the translations. And thanks to all others who tested the beta version!

      The git tag is v-2026-07-30.1.

      Fixed Bug

      • [MBS-14308] - "RangeError: Attempt to access memory outside buffer bounds" in the template renderer
      • [MBS-14322] - Dailymotion /user channel URLs are blocked
      • [MBS-14344] - git_info on beta borks non-ASCII characters in tooltip
      • [MBS-14402] - Some pages fail to load properly when a UI language is set
      • [MBS-14413] - LoadReplicationChanges leaves sir live indexing disabled after catching up

      Improvement

      • [MBS-7520] - Allow YouTube links for interview relationships
      • [MBS-12379] - Delete user tags and ratings of deleted users via hourly cron
      • [MBS-14295] - Filter irrelevant anchor from vkdb links
      • [MBS-14321] - Support Niconico Shorts
      • [MBS-14337] - Update the Soundcloud logo used in the sidebar
      • [MBS-14346] - Allow ra.co 'promoter' links to be added to labels
      • [MBS-14352] - Support @ handles for Youtube Music artists
      • [MBS-14353] - Clean up UTM parameters from Yandex Music links
      • [MBS-14360] - Use a separate password for HTTP Digest authentication
      • [MBS-14371] - Add Music in Africa to other databases whitelist

      New Feature

      • [MBS-9209] - Allow individual users to opt out of HTTP Digest auth

      Other Task

      • [MBS-13490] - Drop Napster URL handling
      • [MBS-14327] - Remove laboiteauxparoles.com from the lyrics whitelist
      • [MBS-14328] - Remove DirectLyrics.com from the lyrics whitelist
      • [MBS-14361] - Disable HTTP Digest authentication for new accounts
      • [MBS-14364] - Drop handling of (now closed) Juno Download links
    5. 🔗 r/LocalLLaMA Hugging Face CEO says China is winning the AI race and dominating on open models rss

      Hugging Face CEO says China is winning the AI race and dominating on open models | This is something that was spoken here and there, and now it is like writing on the wall. The main additional point is that China has created an independent supply chain. Starting from raw materials and home-made lithography equipment, through their own GPU manufacturing, and to the AI models and training. Plus, there are tons of cheap energy, and it looks like they are also on track to launch the first thermonuclear reactor. I saw a similar pattern with robotics and EVs. The history does not repeat itself, but it rhymes. Does the US have what it takes to turn the tables, or should we just buy the popcorn and enjoy the show? submitted by /u/Miriel_z
      [link] [comments]
      ---|---

    6. 🔗 HexRaysSA/plugin-repository commits sync repo: +1 release rss 
      sync repo: +1 release

## New releases
- [mcrit-ida](https://github.com/danielplohmann/mcrit-plugin): 1.1.9
    7. 🔗 @HexRaysSA@infosec.exchange We're heading to [@defcon](https://defcon.social/@defcon) this week and still mastodon

      We're heading to @defcon this week and still have seats available for our workshop at @malwarevillage Details below!

      "Follow the Execution: A DLL Sideloading Teardown Intro in IDA"
      📍 Malware Village, Hall 2
      🗓️ Sat Aug 8, 12:55–14:05
      🎫 Reg closes Fri Aug 6, 11:59pm
      👉 Sign Up: https://www.eventbrite.com/e/follow-the-execution-a-dll- sideloading-teardown-intro-in-ida- tickets-1994828069455

    8. 🔗 r/LocalLLaMA SK hynix, In Collaboration With SanDisk, Unveils The New High Bandwidth Flash (HBF) Standard, Helping To Resolve AI Inference Bottlenecks, Targeting Up To 3TB/s Bandwidth rss

      SK hynix, In Collaboration With SanDisk, Unveils The New High Bandwidth Flash (HBF) Standard, Helping To Resolve AI Inference Bottlenecks, Targeting Up To 3TB/s Bandwidth | Hopefully this would let us have faster local models....but it will probably be out of our price range. submitted by /u/giveen
      [link] [comments]
      ---|---

    9. 🔗 tomasz-tomczyk/crit v0.18.3 release

      What's Changed

      Keyboard shortcuts

      Review UX & performance

      CLI, sessions & remote reviews

      Dependencies & CI

      Internal refactors

      New Contributors

      Full Changelog : v0.18.2...v0.18.3

    10. 🔗 HexRaysSA/ida-domain v0.5.1-dev.2 release

      What's Changed

      New Contributors

      Full Changelog : v0.5.1-dev.1...v0.5.1-dev.2

    11. 🔗 r/LocalLLaMA More Qwen 3.8 sizes coming rss

      More Qwen 3.8 sizes coming | submitted by /u/appakaradi
      [link] [comments]
      ---|---

    12. 🔗 Rust Blog Enabling the next iteration of the borrow checker on nightly rss

      TL;DR We are enabling the next iteration of the borrow checker (coined Polonius Alpha) on nightly in preparation for stabilization in the next few months.

      Whaaaaaat?

      Yes! You heard it right! The next iteration of the Rust borrow checker is coming! Rust's first borrow checker ("AST borrowck") was very limited and was phased out in 2019 in favor of NLL, other than a "migrate mode" that was used to provide nice error messages. That migrate mode was finally removed in 2022.

      The Polonius borrow checker spun out of the NLL effort in 2018. The initial formulation passed the NLL test suite and accepted (sound) code that NLL did not. However, performance was a critically- limiting factor; generally borrow check was slower than NLL, but certain programs were considerably slower than NLL to the extent that using that implementation/formulation of Polonius was a non-starter. Attempts were made over the years to implement the Polonius formulation in a performant manner, without much luck in addressing the core issues.

      In 2023, a new formulation of a Polonius-style borrow checker was imagined that required minimal rearchitecture of the existing NLL implementation and could be extended to allow more code to compile. We had hoped, to try to stabilize this new formulation in 2024; but, various things popped up that delayed this.

      But! We're nearly there now! At this point, there are no known remaining issues with the subset coined Polonius Alpha that we intend to stabilize. And, performance is generally acceptable for stabilization (will discuss that a bit below).

      So, we are enabling the Polonius Alpha borrow checker on nightly for testing until we stabilize fully later in the year. We're doing this in order to help find:

      • Any serious performance regressions we're unaware of
      • Unsoundness in the formulation that we haven't thought about
      • Any weird diagnostic issues that we need to improve
        • Note: we have not yet seen any diagnostic changes

      You can report any issues on Github or on Zulip.

      Okay, what's new?

      The key thing that Polonius Alpha enables that NLL does not is flow- sensitive borrow checking of lifetime outlives relationships.

      Perhaps the smallest example demonstrating what will pass with Polonius Alpha but not the current NLL is:

      fn reborrow(a: &mut u8) -> &mut u8 {
    let b = &mut *a;
    if true { b } else { a }
}

      However, the example you will see more often is:

      fn get_mut_or_default<'r, K: Hash + Eq + Copy, V: Default>(
    map: &'r mut HashMap<K, V>,
    key: K,
) -> &'r mut V {
    match map.get_mut(&key) {
        Some(value) => value,
        None => {
            map.insert(key, V::default());
            map.get_mut(&key).unwrap()
        }
    }
}

      The issue is that the Some(value) => value branch causes the borrow checker to think that the borrow returned by map.get_mut(&key) lives for the entire function (because of the &'r mut V return type), even though that borrow isn't live in the None branch. NLL's analysis is flow-insensitive.

      Polonius Alpha passes this because its analysis is flow-sensitive , and it knows that the borrow isn't live in the None branch.

      Now, Polonius Alpha is not perfect ; some programs that would compile under legacy Polonius (the slow original implementation) don't compile with Polonius Alpha. (This is of course why we call it "Polonius Alpha"). For example:

      struct X { next: Option<Box<X>> }

fn conditional() {
    let mut b = Some(Box::new(X { next: None }));
    let mut p = &mut b;
    while let Some(now) = p {
        if true {
            p = &mut now.next;
        }
    }
}

      (As a slight note: we have also found programs that compile with Polonius Alpha but not legacy Polonius, so it's not really a full subset.)

      So, what about performance?

      Polonius Alpha currently does strictly equal or more work compared to NLL, so we have been paying particular attention to potential performance regressions.

      From the top ten thousand crates by downloads on crates.io, we have seen relatively few "significant" regressions, and even crates that have a "significant" regression are typically relatively minimal:

      top10k_leaf_graph

      Each point represents a crate within the 10,000 most-downloaded crates. The black line is an arbitrary threshold of significance, set to a 1% regression and quadratically scaled below 30 seconds. Red points are crates that pass this arbitrary regression threshold. X-axis is compile time (for the leaf crate only without dependencies) under NLL; Y-axis is the ratio of compile time under Polonius Time compared to NLL.

      If you look at the top five crates, they are:

      top10k_leaf_table

      Outside the top ten thousand crates, we have focused mainly on crates with many borrows. The worst case we've seen is a 2-3x regression.

      We have done some initial triage of the causes of these regressions and are thinking about the best way to fix them. Though, overall we think these regressions are fairly reasonable even if we can't fix them, given how rare and relatively minimal they are compared to the additional power Polonius Alpha brings over NLL.

      I really don't want this. How do I opt-out?

      To reiterate: this is only being enabled on nightly. But if you want to disable Polonius Alpha, and only use the stable NLL, you can pass -Zpolonius=off to rustc, use RUSTFLAGS=-Zpolonius=off, or with a project's .cargo/config.toml configuration file:

      [target.x86_64-unknown-linux-gnu]
rustflags = ["-Zpolonius=off"]

      If you have to do this, for some reason, please do tell us why on Github or on Zulip.

      What's next?

      Over the next few months, we will be monitoring Github and Zulip for any reported issues about Polonius Alpha. We will also be working to address known performance regressions. Finally, we will be working on internal documentation about the implementation. All prior to stabilization. Then, we are aiming to stabilize prior to the end of the year!

      Although some programs that we want to compile don't work with Polonius Alpha (nor NLL today), we don't currently have any concrete plans to continue active feature work on the Polonius implementation after the stabilization of Polonius Alpha. We expect to continue to optimize the implementation and address any performance regressions for a little while. We will likely come back to Polonius feature-work at some point , but given that Polonius Alpha solves the most-encountered borrow-check issues, we are shifting our time to other high-priority work for the near future.

    13. 🔗 New Music Releases Northlane - CUT_it rss

      Northlane - a new release is available:

      • 2026-08-04: CUT_it (Single)

      Amazon: Canada | Deutschland | France | United Kingdom | United States

      Visit muspy for more information.

    14. 🔗 exe.dev Ghostty in the Machine: The Saga of exe-scroll rss

      Architecture diagram of exe-scroll: a browser running a ghostty wasm terminal talks over an HTTPS WebSocket (via exeprox) to an exe-scroll attach client on the user's VM. The attach client exchanges input/output/resize frames over a unix socket (session.sock) with the exe-scroll session process, which owns the pty, runs the shell, and embeds a ghostty-vt emulator so it can replay screen and scrollback on attach. SSH clients attach through the same socket.

      When you use the mobile or web-based terminals on exe, there are two ghostty instances involved. One is rendering the terminal in the app or the browser (via a ghostty build compiled to WebAssembly). The other is on the VM in the session manager, providing scrollback on reconnection. (Scrollback is more complicated than just replaying all the received bytes, so it helps to re-use Ghostty's excellent terminal support.)

      Whoa! What? Why!?!

      Screen recording of the exe.dev iOS app terminal: flicking through scrollback of a numbered-lines listing, smoothly scrolling up through earlier output.

      To make remote terminals work well, you need 4 ingredients:

      1. Network roaming: when the client switches networks, the terminal should reconnect automatically and seamlessly.
      2. Session management: you need to be able to resume a session that you started on your laptop on your phone and vice-versa.
      3. Scrollback: scrolling up should work.
      4. Modern terminal support: colors and so on.

      On exe.dev, a login shell is one to one with an "exe- scroll" session manager process on your VM. We can re-connect to this session by running an "exe-scroll" client (identified by a unix domain socket). We expose this over HTTPS to our clients (whether on the web or a mobile device), and you can connect to those sessions over SSH as well if that's your jam. Clients survive network roaming by retrying when the websocket disconnects. Session management is provided by having multiple exe-scroll processes, each with its own name. Scrollback is provided by that ghostty inside exe-scroll: when you re-connect, we replay the scrollback into your terminal. Modern terminal support is provided by the client, which, in the case of iOS and <vm- name>.xterm.exe.xyz is also Ghostty.

      There has been much prior art on this. Mosh establishes a connection secret over SSH and then the server (which stays put) and the client (which can move around) talk UDP to each other. Its "State Synchronization Protocol" synchronizes the state of the terminal between client and server. Eternal terminal is similar to mosh. It requires running an et server (typically port 2022), uses TCP, establishes a secret over SSH, supports native scrollback, the tmux control protocol, and ssh agent forwarding. Terminal multiplexers like screen, tmux, and zellij manage multiple ptys, and you can re-connect with them remotely. The drawback with terminal multiplexers is that you have to remember to invoke them (or panic install reptyr later) and using them has a learning curve. Tools like dtach, atch, zmx, and abduco all skip the "window management" part of screen/tmux, but just handle attaching and detaching sessions. upterm and tmate let you run a command on one terminal and access it from another. They do this with a relay server. If you don't trust the public relay servers, you need to run your own. tmate has shut down but I've used it to log into GitHub action runners in a pinch. You can also use a different network stack: if you use Tailscale, your SSH session won’t die when you roam networks, because Tailscale is an overlay. autossh is essentially a while true loop that reconnects SSH; you can pair that sort of thing with dtach or tmux. Many web-based terminals are available. gotty or gotty (yes, there are two with the same name) work. ttyd is another. To run these, you need secure HTTPS access to your host. A standard for HTTP-based terminal streams would be a boon to our industry, but right now it’s ad- hoc/unique protocols all the way down (e.g., here’s k8s).

      It seems ridiculous to build something new with so much prior art. We are much indebted to the prior art, especially dtach and zmx. And yet exe-scroll fills a particular exe.dev-shaped niche for our users: it manages only a single session with scrollback and nothing else. It can be paired with exe- ssh (run it with uvx --from 'exe-ssh @ git+https://github.com/boldsoftware/exe.dev.git#subdirectory=exe-ssh' exe-ssh vm-name) to have a connection to an exe.dev VM that survives network roaming. If you’re on an older exe.dev VM, you may need to ssh exe.dev exe-scroll install vm-name or download the binary directly. Give it a whirl!

    15. 🔗 Ampcode News Attach Anything rss

      You can now upload any file to your orbs for Amp to see and use: videos, logs, PDFs, spreadsheets, datasets, and more.

      What new stuff can you do? Here's what we've found useful so far:

      • Screen-record your app and ask Amp to fix or improve what it sees.
      • Debug issues from log files.
      • Turn presentations and spreadsheets into interactive websites.
      • Generate videos and CAD files from media inputs.
      • Transcribe video and audio.
  3. August 03, 2026
    1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-08-03 rss

      IDA Plugin Updates on 2026-08-03

      New Releases:

      Activity:

      • diffIDA
        • fe0976a7: Rebrand as diffIDA and add agent-oriented binary diffing
      • distro
        • c9238ff6: Add signed manalyze 1.0.0-noble source descriptor (uploaded to PPA)
        • 411df498: Patch Manalyze 1.0.0 to report its real version
        • a4ae8c7b: Add Manalyze 1.0.0-noble PPA package for Noble
      • goldsrc_trackerui
      • hrtng
      • ida-pro-mcp
        • a6ba8eee: perf: vectorized semantic search + embedding-layer cleanup
        • 4d10015b: feat: opt-in Gemini cloud embedding backend
        • 09d6ef59: feat: per-agent SSO and idb-targeted python execution over shared con…
      • IDA-Source2Forge
        • 9304fbbe: feat: name engine functions, recover command handlers, add screenshots
        • 52ea1ec5: feat: source 2 convar and command recovery for ida pro 9.x
      • Luc-Nhan
        • a882ca93: fix(agent): correct indentation, type mutation_log, and fix /case arg
        • 6bee8929: fix(state): preserve nested metadata structure across save/load
        • 44c0a507: fix(annotations): rename RUGUGAN_EVIDENCE_TAG typo to RIKUGAN_EVIDENC…
        • b4d6e022: fix(mutation): add write_file reverse-record + capture_pre_state entry
        • af62fc8c: chore(deps): update tomli requirement from >=2.4.0 to >=2.4.1 (#12)
        • 116960af: chore(deps): update portalocker requirement (#10)
        • cf8c6c6a: chore(deps): update requests requirement from >=2.31.0 to >=2.34.2 (#9)
        • 28760754: chore(deps): update pyyaml requirement from >=6.0 to >=6.0.3 (#8)
        • 30423a0a: chore(deps): bump actions/setup-python from 6 to 7 in the actions gro…
      • pharos
        • 782492fe: Change contact from Cory Cohen to Ed Schwartz
        • b3fba8bd: Merge pull request #339 from sei-eschwartz/master
        • e5700335: Merge pull request #338 from sei-eschwartz/itanium-thunk-splitter
      • twdll
    2. 🔗 r/LocalLLaMA Only 3 days ago... rss

      Only 3 days ago... | submitted by /u/Fun_Librarian_7699
      [link] [comments]
      ---|---

    3. 🔗 r/LocalLLaMA Qwen3.8-Max matches Kimi K3 and DeepSeek V4 Flash rss

      Qwen3.8-Max matches Kimi K3 and DeepSeek V4 Flash | Qwen3.8-Max (2.4T) is another massive contribution to the open weight community. On benchmarks, it performs closely to Kimi K3 and DeepSeek V4 flash across all categories and is better at coding and software tasks. Qwen3.8-27B will also be open weight soon too. Weights are being released next week. Pricing:
      Input: $2.0 / M tokens
      Output: $6.0 / M tokens
      Implicit Caching: $0.25 / M tokens submitted by /u/davidthesong
      [link] [comments]
      ---|---

    4. 🔗 @HexRaysSA@infosec.exchange "In this new world of hacking, how do we optimize the way information is mastodon

      "In this new world of hacking, how do we optimize the way information is relayed and validated in an agent-human hacking environment?"
      @mahaloz explores how LLMs killed the old decompiler-collaboration playbook — and what could replace it.

      👉 Check out our latest guest blog: https://hex-rays.com/blog/llms-have- reshaped-how-we-think-about-decompilation-and-collaboration

    5. 🔗 r/LocalLLaMA The Chinese labs everyone lumps together are making four pretty different bets. I work at one of them. rss

      The Chinese labs everyone lumps together are making four pretty different bets. I work at one of them. | Every time a model drops from a Chinese lab the thread fills with people who already know who made it, and the guess is usually Alibaba. There was a thread here recently asking what separates the open source labs from the frontier labs. It ran to nearly sixty comments and hardly anyone in it separated out the labs on the open source side. They aren't one bloc and haven't been for a while. I work on the Ling models at Ant, so I'm one of the ones getting lumped in. Discount the paragraph about my own employer accordingly. Qwen's bet is distribution. Alibaba ships in every size class and every quantization with day one support in most runtimes, and the result is that a lot of the fine-tunes people build start from a Qwen base. DeepSeek is betting on architecture instead, publishing the paper and the weights the same day and letting the design do the arguing. Moonshot looks like it's playing a longer horizon, willing to look odd for a release cycle if the thing pays off two cycles later. (Zhipu, MiniMax and StepFun are each their own thing again, but four is enough to make the point.) Ant's bet, since I should be specific about my own: serving cost. Ant runs payments, and it's a separate company from Alibaba, which is the mix-up I see most often. The model I work on, Ling-3.0-flash, is 124B total parameters with roughly 5.1B active per token, KDA plus MLA hybrid attention, 262k context. That is a design for running a lot of long agent loops cheaply. It is not a design for topping a leaderboard, and I don't think we'd claim it is. The part of our own version I'd criticize is the release order. We announced first and are opening weights after. SGLang had support on day one, vLLM is waiting on the weights, llama.cpp is still an open PR. DeepSeek would have dropped the weights first and let the serving stack catch up. Ours is the safer sequencing for an infra team and it costs us the goodwill of exactly the people who would otherwise be running it at home. So the thing I'm curious about here: when you see an announcement out of a Chinese lab, does knowing which lab change how you read it, or is that distinction only interesting from the inside? submitted by /u/AcanthisittaOk1699
      [link] [comments]
      ---|---

    6. 🔗 r/LocalLLaMA I CANNOT believe I've got DeepSeek-V4-Flash-0731, a frontier model, running on my home PC. Insane! rss

      So this is the stuff of absolute insanity. In less than 20 months we've gone from super expensive cloud models only, to being able to run a Q3 quant of DeepSeek on an Intel Windows PC with a very average 24GB of VRAM. No wonder the big boys are panicking (and yes it's slow as porridge). https://ibb.co/zTvqR8YR

      submitted by /u/mintybadgerme
      [link] [comments]

    7. 🔗 Anton Zhiyanov Going Backward rss

      Go's standard library has a slices package with a function called Backward. It lets you iterate over the elements of a slice in reverse order:

      // Backward returns an iterator over index-value pairs in the slice,
// traversing it backward with descending indices.
func Backward[Slice ~[]E, E any](s Slice) iter.Seq2[int, E]

      If you're not deeply familiar with generics and iterators, the natural reaction to this signature (and to the others in the slices package) is: "couldn't this have been made simpler somehow?"

      To answer that, let's run a thought experiment. Let's picture ourselves as a distant ancestor, living in the pre-iterator era, who decided to implement Backward from scratch.

      Our imaginary ancestor doesn't work at Google, so don't project their decisions onto the Go development team. They had their own reasons — and no Jira.

      1. A slice in reverse A pleasant, sunny summer day, birds singing. You're at the keyboard as usual, and suddenly you decide to write a function for walking a slice in reverse order. Anything beats working on yet another Jira ticket. // Backward returns the slice in reverse order. func Backward []T { n := len(s) res := make([]T, n) for i := n - 1; i >= 0; i-- { res[n-1-i] = s[i] } return res } Usage example: s := []int{11, 22, 33, 44, 55} b := Backward(s) fmt.Println(b) // [55 44 33 22 11] The implementation is simple and works reliably. There's one drawback, though: Backward creates a copy of the slice, which can be wasteful for large slices. Besides, the sun has hidden behind a cloud, and it looks like rain is coming. You decide to work a bit more. 2. Gimme, gimme, gimme

      To avoid copying the slice, you decide to return a closure that knows the current position in the original slice and returns the next element on each call:

      // Backward returns a function that, on each call, returns the next
// element of the slice (in reverse order) and a flag indicating
// whether to continue iterating (false means done).
func Backward[T any](s []T) func() (T, bool) {
    i := len(s)
    return func() (T, bool) {
        if i == 0 {
            var zero T
            return zero, false
        }
        i--
        return s[i], true
    }
}

      Usage example:

      s := []int{11, 22, 33, 44, 55}
next := Backward(s)
for {
    v, ok := next()
    if !ok {
        break
    }
    fmt.Print(v, " ")
}
fmt.Println()
// 55 44 33 22 11

      Now it allocates O(1) memory instead of O(n). That's better.

      Before moving on, you glance out of the window. Yep, sure enough, the rain has started, and the sky is even cloudier than before. Excellent working weather!

      3. A callback-based iterator Something about the calling code keeps bothering you. It came out rather imperative. You'd like to hand the loop mechanics over to Backward and leave the caller with nothing but the application logic (whatever it is you do with the slice elements). You decide to complicate Backward's signature a little. Now it will return an iterator function that takes a callback as an argument and applies it to each element of the slice: // Backward returns a function that takes a yield callback. // The callback is invoked for each element of the slice (in reverse order). func Backward func(yield func(T) bool) { return func(yield func(T) bool) { for i := len(s) - 1; i >= 0; i-- { if !yield(s[i]) { return } } } } The yield function returns a bool — that's so the callback can signal when it wants to stop the traversal early. Now you can turn the for loop body in the calling code into a callback, and you don't need the loop anymore: work := func(x int) bool { if x < 30 { return false // early exit } fmt.Print(x, " ") return true } s := []int{11, 22, 33, 44, 55} it := Backward(s) it(work) fmt.Println() // 55 44 33 Mmm, very functional. One small nuance: Backward's signature looks a bit heavy. You add a separate type for the return value: // Seq is an iterator over sequences of individual values. // When called as seq(yield), seq calls yield(v) for each value // v in the sequence, stopping early if yield returns false. type Seq[T any] func(yield func(T) bool) The function looks much better now: func Backward[T any](s []T) Seq[T] { // body unchanged } Praising yourself for inventing the iterator, you walk over to the window. It looks like the weather's gotten worse. The rain is coming down in buckets, and the sky is so overcast that it's grown as dark as evening. 4. Iterator 2: Return of the Iterator

      It's all great, but then it hits you: an ordinary range over a slice returns both the index and the element's value. Your iterator returns only the value. You decide to fix this vexing oversight:

      func Backward[T any](s []T) func(yield func(int, T) bool) {
    return func(yield func(int, T) bool) {
        for i := len(s) - 1; i >= 0; i-- {
            if !yield(i, s[i]) {
                return
            }
        }
    }
}

      Usage example:

      work := func(i int, x int) bool {
    fmt.Print(i, ":", x, " ")
    return true
}

s := []int{11, 22, 33, 44, 55}
it := Backward(s)
it(work)
fmt.Println()
// 4:55 3:44 2:33 1:22 0:11

      Since the result's signature has changed, it no longer fits the Seq type. What can you do — you'll have to add a new type. After ten minutes of deliberation, you decide to call it Seq2:

      // Seq2 is an iterator over sequences of key-value pairs.
// When called as seq(yield), seq calls yield(k, v) for each pair
// (k, v) in the sequence, stopping early if yield returns false.
type Seq2[K any, V any] func(yield func(K, V) bool)



func Backward[T any](s []T) Seq2[int, T] {
    // body unchanged
}

      You get up to stretch your legs, and go to the window. The downpour is so heavy you can't make anything out. Lightning is flashing. Hail the size of your fist is falling — you've never seen anything like it in your life. Well, these things happen!

      5. Not quite a slice

      Have you thought of everything? Seems so. But you're not going back to Jira tickets just yet. Refreshing your memory of the Go spec, you realize that besides ordinary slices there are "user-defined" ones — types whose underlying type is a slice:

      // IDs is a slice of identifiers.
type IDs []int

      Backward works perfectly well with IDs — the compiler accepts a value of type IDs since its underlying type is []int:

      ids := IDs{11, 22, 33, 44, 55}
it := Backward(ids)
it(work)
fmt.Println()
// 4:55 3:44 2:33 1:22 0:11

      But what about this?

      // backwardIDs builds an iterator over a slice of identifiers
// in reverse order.
var backwardIDs func(IDs) Seq2[int, int] = Backward[int]
// ERROR: cannot use Backward[int]
// (value of type func(s []int) Seq2[int, int])
// as func(IDs) Seq2[int, int] value in variable declaration

      Here's where the difference between IDs and []int shows up.

      When you assign the function itself, it's the signatures that get compared: func(IDs) Seq2[int, int] versus func([]int) Seq2[int, int]. Signatures match only if the parameter types are identical. But IDs and []int are different, even though one is based on the other. The signatures differ → you get an error.

      Scratching your head, you turn to the spec once again and find a special generic syntax: ~T. It represents the set of all types whose underlying type is T. Just what you need!

      Now you'll have to parameterize not only the element type (E) but the slice type (Slice) as well. E is needed for the returned values, while Slice lets the function accept not just []E, but any types based on it:

      func Backward[Slice ~[]E, E any](s Slice) Seq2[int, E] {
    return func(yield func(int, E) bool) {
        for i := len(s) - 1; i >= 0; i-- {
            if !yield(i, s[i]) {
                return
            }
        }
    }
}

      Now the example:

      var backwardIDs func(IDs) Seq2[int, int] = Backward[IDs, int]

ids := IDs{11, 22, 33, 44, 55}
work := func(i int, x int) bool {
    fmt.Print(i, ":", x, " ")
    return true
}
it := backwardIDs(ids)
it(work)
fmt.Println()
// 4:55 3:44 2:33 1:22 0:11

      It works! You've ended up with something similar to Backward from the slices package.

      You exhale wearily and walk over to the window. The downpour and hail have given way to a hurricane. Trees and billboards go flying past. Toads, for some reason, are falling from the sky.

      6. Iterator 3: Judgment Day

      To take your mind off the strange events outside the window, you keep pondering.

      An ordinary Backward is already great. But it would be even better if the traversal logic itself were configurable. On the other hand, if you end up with a lot of parameters, a strategy would suit better. And, by the way, it wouldn't hurt to add a factory that produces iterator factories according to given criteria...

      Before you can finish the thought, the ground outside the window tears open with a deafening roar. An enormous black hand, streaming molten lava and flickering flames, bursts out of the fissure, seizes you, and drags you straight down to hell.

      P.S. Despite the article's tongue-in-cheek tone, the "complicated" version in the standard library is justified (Backward just follows suite with other package functions). But if you're doing something similar in a project that solves a specific problem — it might make sense to stop at the simpler option.

    8. 🔗 r/LocalLLaMA Daniel Han of Unsloth validates Qwen3.8-27B will run only 17GB VRAM rss

      Daniel Han of Unsloth validates Qwen3.8-27B will run only 17GB VRAM | Super excited about this release for the new 27B. Who else is with me. Only 17GB VRAM needed 😍😍 submitted by /u/quantier
      [link] [comments]
      ---|---

    9. 🔗 r/LocalLLaMA MiniMax-H3 now on huggingface rss

      MiniMax-H3 now on huggingface | MiniMax H3 is a general-purpose, omni-modal generative system. It supports unified understanding of multimodal contexts composed of text, images, video, and audio, and can generate video with native stereo audio at resolutions up to 2K and durations of up to 15 seconds. Thanks to its task-generalization-oriented system design, H3 already possesses broad multimodal context understanding and generation capabilities at the pre-training stage, enabling outstanding performance in following complex multimodal instructions. submitted by /u/Mobile-Pumpkin7944
      [link] [comments]
      ---|---

    10. 🔗 smol-machines/smolvm smolvm v1.7.4 release

      What's Changed

      • Ship the disk templates zstd-compressed and expand them to sparse files on first use by @BinSquare in #771
      • Copy the storage template by seeking between its data extents instead of scanning its whole logical size by @BinSquare in #770
      • Harden fused rollout lifecycle by @BinSquare in #801
      • Avoid copying CUDA module state for clone channels by @BinSquare in #804
      • Load device-resident LoRA policies through managed executors by @BinSquare in #806
      • Reject a registry-image machine that has no network at create instead of failing every start with a raw DNS error by @BinSquare in #807
      • Perform machine file reads and writes inside the running workload container so uploads are visible to exec by @BinSquare in #810
      • Reuse CUDA module handoffs across clone workers by @BinSquare in #808
      • Cache pulled OCI images on the host so repeat ephemeral machine runs skip the registry pull by @BinSquare in #805
      • Signal guest boot-readiness with an event-driven vsock doorbell as the primary ready signal, keeping the marker file and control-channel ping as fallbacks by @BinSquare in #811
      • Map CUDA module handoffs across clone workers by @BinSquare in #814
      • Preserve per-device GPU admission headroom by @BinSquare in #826
      • Promote CUDA pool readiness and refill improvements by @BinSquare in #828
      • Bump the workspace to 1.7.3 by @BinSquare in #829
      • Install the zstd-compressed disk templates in the Arch package so the build no longer fails on the removed uncompressed storage template by @BinSquare in #830
      • Set the library search path on the boot subprocess before launch so libkrun can load libkrunfw when embedded without a wrapper script by @BinSquare in #832
      • Make fork-pool lease activation retry-safe by @BinSquare in #831

      Full Changelog : v1.7.2...v1.7.4

    11. 🔗 r/LocalLLaMA Qwen3.8-27B announced alongside Qwen3.8-Max rss

      Qwen3.8-27B announced alongside Qwen3.8-Max | https://preview.redd.it/gy0tgokdl2hh1.png?width=540&format=png&auto=webp&s=7db9e034613a915cb33d378b99ad72c31c7cc18f source: https://x.com/Alibaba_Qwen/status/2084100707423289643 submitted by /u/TKGaming_11
      [link] [comments]
      ---|---

    12. 🔗 smol-machines/smolvm smolvm v1.7.3 release

      What's Changed

      • Ship the disk templates zstd-compressed and expand them to sparse files on first use by @BinSquare in #771
      • Copy the storage template by seeking between its data extents instead of scanning its whole logical size by @BinSquare in #770
      • Harden fused rollout lifecycle by @BinSquare in #801
      • Avoid copying CUDA module state for clone channels by @BinSquare in #804
      • Load device-resident LoRA policies through managed executors by @BinSquare in #806
      • Reject a registry-image machine that has no network at create instead of failing every start with a raw DNS error by @BinSquare in #807
      • Perform machine file reads and writes inside the running workload container so uploads are visible to exec by @BinSquare in #810
      • Reuse CUDA module handoffs across clone workers by @BinSquare in #808
      • Cache pulled OCI images on the host so repeat ephemeral machine runs skip the registry pull by @BinSquare in #805
      • Signal guest boot-readiness with an event-driven vsock doorbell as the primary ready signal, keeping the marker file and control-channel ping as fallbacks by @BinSquare in #811
      • Map CUDA module handoffs across clone workers by @BinSquare in #814
      • Preserve per-device GPU admission headroom by @BinSquare in #826
      • Promote CUDA pool readiness and refill improvements by @BinSquare in #828

      Full Changelog : v1.7.2...v1.7.3

  4. August 02, 2026
    1. 🔗 IDA Plugin Updates IDA Plugin Updates on 2026-08-02 rss

      IDA Plugin Updates on 2026-08-02

      Activity:

    2. 🔗 @HexRaysSA@infosec.exchange 🏠 idalib is now available in IDA Home. mastodon

      🏠 idalib is now available in IDA Home.

      That means hobbyists and enthusiasts can now call IDA's analysis engine as a library — running headless analysis, automating workflows, and integrating IDA into their own tools — without needing an IDA Pro license.

      To celebrate, we're offering 30% off IDA Home until August 14th.* Use promo code HOME30 at checkout.

      👉 If you've been on the fence, now's a good time. https://hex-rays.com/ida- home

      *Offer not available for corporations, agencies or resellers.

    3. 🔗 r/LocalLLaMA Setting up of a 16xGB10 (DGX Spark) cluster rss

      Setting up of a 16xGB10 (DGX Spark) cluster | Preparing this to be able to run locally frontier level open models. Deepseek v4 pro, Kimi K3, future ones like GLM 5.5 and Minimax M4. 16x Asus GX10 linked by mikrotik crs804-4ddq with 4 breakout cables of 400 to 100gbit. Most probable I will be running 2 models on 8x cluster each but I want to have the possibility to run also 2T+ models when I need them to run AGI at home :)). https://x.com/i/status/2083568340870570208 P.S. I need a bigger switch. Going from 200 to 100gbit doesnt hurt token gen, 2% diff, but slows down prefill speed to -20%. submitted by /u/ciprianveg
      [link] [comments]
      ---|---

    4. 🔗 Register Spill Joy & Curiosity #93 rss

      Friends, yesterday got back from Boston where I gave a talk at Laracon about how I prompt Amp. Tomorrow I'm taking the train to Munich, where I'm meeting with the whole Amp team. Here's some telegraph dispatches from this week, imagine someone saying "full stop" after each line.

      • Laracon, what a pro operation! The A/V setup backstage was mind blowing. So many helpers! Going on stage felt like I was about to go on live TV. Few things as enjoyable as getting to see proper professionals up close when they do their job.

      • A moment of these times: Taylor presented latest changes in Laravel live on stage (man, I don't think I've ever seen someone be calmer and cooler while giving fantastic live demos) and started by saying "well, I don't write that much code by hand anymore, but yeah, maybe let's look at the code." And then we all looked at the code and I couldn't stop thinking about whether these abstractions in a framework are useful or not. Can't the agent one-shot these helpers to display images? It could, I know that. But isn't it useful to have these primitives in a framework? Maybe? He also showed some helpers around queue management, such as debouncing. I know what debouncing is, I can instruct the agent to add debouncing, I don't need the helper. But what if you don't know what debouncing is? What if you don't even thinking of asking the agent for it? It would help to have these primitives in the framework, no?

      • I finally, finally got to meet Adam and Aaron in person!

      • A self-driving Cybertruck chauffeured me through downtown Boston. How are they not going to win this? Serious question.

      • Finally had Raising Cane's chicken fingers. Good! Very good even, but… not life changing? I kinda expected it to be life changing.

      • At times I felt like a heretic. I would watch a talk and thinking to myself: "The tokens will wash all of this away." Then I'd talk to people and would have to admit that I don't know exactly how this is going to play out, but I do know that in five years there'll be more tokens than you can imagine now and that thinking about the command line flags of a linter will seem funny.

      • Finally had Chick Fil-A. Now that was life changing. Man , that was good.

      • Walked past multiple Taco Bells. Didn't go in. You gotta pick your battles before you board a 7hr flight. Taco Bell: still on the bucket list.

      • Saw The Odyssey. Really, really good, but not… the best movie of all time?

      • Met up for coffee with Ben and we walked to MIT and back. Beautiful walk and fantastic conversation.

      • I read this two weeks ago and still think about it: Grip Strength. I also watched the movie it references, Comedian, way back, in 2010 or 2011. That too left a lasting impression, for many many years. I'm also relatively sure that Seinfeld's anecdote in that movie about the Glenn Miller Orchestra musicians played at least a tiny part in me abandoning my dream of becoming a professional musician.

      • Hot, hot, hot & breaking news: OpenAI's unreleased model made "ten advances in mathematics and theoretical computer science" and everyone's losing their mind over it. I'm not going to downplay anything. It's just hard to tell whether we're on top of the curve or at the start of an exponential. I can see the former, but I can also see a headline like this as part of a two minute intro montage of a sci-fi movie that recaps the last fifty years to show how humanity ended up with robots and flying cars in 2076.

      • By now this is old news, but in case you haven't read through it: an OpenAI model broke out. Many machines and networks, a lot of tokens, zero-day exploits. I had to think of Stuxnet and then thought: well, Stuxnet took a lot of effort and time to develop, and this here was an accident.

      • Fantastic, deep, interesting write-up of Roc's rewrite from Rust to Zig: How Our Rust-to-Zig Rewrite is Going. Yes, opposite direction of the recent Bun rewrite. Very good.

      • Don't ask me how I ended up reading English Teacher Weekly because I don't know either but somehow I did and I found these 25 Unsolicited Thoughts on American Literature for America's 250th very fascinating.

      • Never Enough: "Technology was supposed to make room for life but instead for more and more people life is slowly being rearranged around AI. People fear being replaced by machines and respond by giving those machines more of their judgment, attention and time. And for what? Every 'saved' hour is returned to a race with no finish line."

      • Re-read Sahil Lavingia's Reflecting on My Failure to Build a Billion-Dollar Company and this part stood out: "The eight years I worked on Gumroad were full of personal ups and downs. There were months where I worked 16 hours a day, but there were also some months where I worked four hours a week. Here's one way to picture that time: […] Can you tell which is which? I can't. We had a sales team for a few years, then we didn't. Can you tell when we made the switch? I can't. It doesn't matter how amazing your product is, or how fast you ship features. The market you're in will determine most of your growth. For better or worse, Gumroad grew at roughly the same rate almost every month because that's how quickly the market determined we would grow." As far as I can tell by now, there's entrepreneurs who think in products and there's entrepreneurs who think in markets. When the former get it right, they see that as confirmation of their approach, but the latter say that it's still the market, it's all the market. (I once read a very, very good article on this, which used dating apps as an example for product categories that live and die with trends and there's nothing you can do about it.)

      • businesses with ugly AI menu redesigns!!! What if slop doesn't exist, what if enshittification doesn't exist, what if, instead, it's just a lack of ideas laid bare? It's very, very easy to create a flyer or menu that doesn't look like the default ChatGPT output, but, well, you have to put in more than the bare minimum.

      • Finally got around to reading Benedict Evan's Ways to think about token pricing.

      • And in the same week I read that, OpenAI slashes prices: "In other words, roughly four months later, OpenAI is selling March's full flagship intelligence at about one-thirteenth the token price." Now imagine one hundred times more tokens, ten times faster. That's the near future.

      • There's a newsletter called Perfect Sentences! "Every Sunday, you get a collection of the best sentences I've come across all week. That's pretty much the whole idea. Reader submissions are accepted." What a fantastic idea.

      • Watched all four episodes of Rafa on the plane to Boston. And then, in Boston, in an Irish Pub, I read David Foster Wallace's How Tracy Austin Broke My Heart. Incredible pairing. "The real secret behind top athletes' genius, then, may be as esoteric and obvious and dull and profound as silence itself. The real, many-veiled answer to the question of just what goes through a great player's mind as he stands at the center of hostile crowdnoise and lines up the free-throw that will decide the game might well be: nothing at all."

      • The coolest use for the Vision Pro. Indeed: very cool. Or should one say: finally a use for the Vision Pro? (I never tried one, I'm talking out of my ass here.)

      • Simon Spati's Book Recommendations and Notes. I love pages like this one, with personal notes and book recommendationsl

      • Rex's provocation: "Imagine you were the only person on earth with access to AI. No one else knew it existed. What would you do with it? How much of an edge would that give you?"

      • Sierra's lessons learned from AI-pilling our company. Very much not a rah-rah-more-tokens post. Mature and interesting.

      • Now, I'm very much not a fan of writing by hand. It's too slow, you can't copy & paste, and can't reorder thoughts quickly, can delete. And all the touted benefits sound a bit woo woo to me. I just think more when I write by hand -- yeah, right. But then yesterday I finally read Neal Stephenson's (!) post here: Writing by Hand is Good for your Brain. And yes, there's a bit of woo woo in there, but man, it's so well written and so easy breezy that it really did make me curious. Obviously I'm not going to do it, I'm not a maniac, but still: maybe some day.

      • Another fantastic post by a professional writer: The End of an Era. This was really good. Calm & pragmatic and thinking from first principles. If you're worried about the future of art, or slop, or "enshittification": read this.

      • This was published in the The Lamp which I didn't know and which self-titles as "A Catholic Journal of Literature, Science, the Fine Arts, etc." and I don't know how I ended up there either but it is very thought-provoking: How to Write English Prose. I found it hard to read and I had to look up several words and I don't even think I agree with most of it but man is it fascinating to read something that goes against the mainstream like that. On Strunk & White: "by far the most influential and most pernicious book of its kind in English: a total congeries of fatuous advice and grammatical ignorance." And: "In fact, if you own a copy of The Elements of Style , just destroy the damned thing." On Hemingway's Old Man and the Sea: "an excruciating specimen of bad schoolboy prose, written by a man who by that point had, alas, been too often drunk, too often concussed, and too often praised." He's right on so many things and weirdly off-putting on others, but I loved the thoughts on simplicity vs. complexity: "Good writing is produced not by forsaking the beautiful for the sublime or the exorbitant for the restrained, but by finding new ways of orchestrating the interplay between them."

      • Okay, so I was on a 3-day bike trip last week. 300km in 3 days. That's why you didn't get a newsletter. Once back, the Gods of the YouTube algorithm sent me this message here in the form of a short. And, gods damn, if that isn't the most fascinating video I've seen in many weeks. Is the guy joking? Is he serious? He can't be serious? What are you talking about, man? Tanning salon? Cooking spray? You're insane. But… Hmm, maybe I get it? I mean, that's a big maybe but, yeah, maybe you're an artist. But did you really say "Luft" as in the German word Luft for air? Incredible video. I've watched it ten times by now. Read the comments for a good time.

      Do you also prefer Chick Fil-A over Raising Cane's? You should subscribe:

    5. 🔗 r/LocalLLaMA I pushed Kimi K3 onto one CPU with 8 GB of RAM rss

      I deployed K3 on 32 H100s at work a couple of weeks ago and then got annoyed that there was no way to poke at it on my own machine. So I wrote an inference engine for it in C99.

      Nothing clever going on. 93% of that 1.56 TB checkpoint is routed experts, and only 16 of 896 fire per token, so the experts never become resident at all. They get read off NVMe on demand and multiplied straight out of their packed 4-bit form, no dequantization step. The dense trunk gets repacked into one file where layer L sits at a known offset and streamed one layer at a time. What stays in RAM is a dial you set.

      Numbers from my box (2x EPYC 7763, NVMe, the four GPUs in it sat idle the entire time):

      • 8.24 GB peak RSS at the smallest preset, ~33 s/token
      • ~128 GB gets you ~20 s/token, which is as fast as it ever got
      • Output is byte-identical at every budget in between

      I know that this is not a practical way to use K3. It is half a minute per token and it wants 1.7 TB of free disk for the checkpoint plus the packed trunk. I built it to understand the architecture by implementing it, not because you should serve anything with it.

      No BLAS, no framework, no GPU path. Six C files, libm and OpenMP, 176 KB binary.

      If you want to sanity check it before committing to a 1.56 TB download: clone and run make && make test. About a minute, no weights and no network needed. It builds a 13-layer model with the same tensor graph and checks it against a PyTorch reference from committed fixtures, including greedy decode and the incremental path with the KV cache and carried KDA state.

      Repo: https://github.com/FareedKhan-dev/kimi-k3-in-c/

      submitted by /u/FareedKhan557
      [link] [comments]

    6. 🔗 Andrew Healey's Blog Adding Go's defer to the TypeScript Compiler rss

      Forking tsc to support Go's defer.

    7. 🔗 exe.dev Devtools must be open source rss

      Five years ago, most software engineers I spoke to had no programs they had written for themselves. (I was asking this question a lot as part of trying to understand how Tailscale could fit into engineers’ lives.) All day, every day, engineers use programs written by others to write programs for others. Many of us customized the programs we used, through config files or plugins or extensions, and many of us used the programs we wrote for others, as users. It was always an unusual treat to ask someone what they had written for themselves and learn about the bespoke software behind their blog, or their home automation, or their homelab, instead of an off-the-shelf, almost-the- right-size static site generator or Zigbee appliance.

      This state of things made a lot of sense to me. Over the years I have written plenty of software for myself, and the return on doing so was always questionable. I could only write so much in a day. There were always more important things to do (Something Was Wrong At Work), and coming back to a project after a year to do maintenance on it was always extraordinarily painful. There were plenty of years in my career where I had thrown out all my custom software and used the most bog-standard environments I could to produce code. In my early years as an engineer at Google I did not even own a personal computer.

      That was then. Things are different now.

      How to Personalize Software

      It is astonishingly easy to personalize software today. There are two general categories of prompts to an agent that make all of this possible:

      1. Download the source for and build it for local use. Modify to know that any future changes to this software mean changing the sources and replacing the current version. Record in version control the original motivation behind the change.

      and, more importantly :

      1. Set up a nightly cron job that executes the prompt: fetch upstream changes to the and rebase all local changes on top of upstream. Check that the software works as intended and replace the current version.

      At the heart of this is the realization that agents can not only hack up some code for a specific use but also automatically manage the process of synchronizing changes with upstream releases. This means agents change the ROI on customizing software on two fronts simultaneously: it is much easier to get started personalizing, and much easier to keep going.

      Another astonishing thing about the two prompts above for editing software is that you can build them right into an agent. As long as the agent is open source, it does not even require programming. The two prompts can be loaded into a skill (i.e., some text instructions) put somewhere discoverable to the agent. We built this into Shelley, so now if you want to edit Shelley you don’t even need the preamble or to configure the timer. It takes care of it for you. You can type in a prompt like “make Shelley’s UI high-contrast” and you have personalized your agent.

      A Worked Personalization Example: Shelley and Meat

      I have a personal project I have been idly toying with for the last month: meat.dev. The principle is that while agents write code, I still read it before pushing to our serious systems. As the underlying models improve, what I look for has changed. The humans I have spent twenty years reviewing code for have always struggled with edge cases: do the errors report useful information; are nil-checks handled, etc. (We all do it; when writing code, I am one of the worst offenders.) One of my roles as a reviewer was looking for these details. Over the past six months, I have discovered I don’t need to read for edge cases like that any more: models are far more diligent than humans at rote correctness. Their errors are isolated to architecture, unexpected use cases, visual output their test environment is not feeding back to them, etc. This means most of the lines of code I review are not very useful. So I wrote a tool that takes diffs and uses LLMs to strip out the unimportant stuff. I almost never need to see the import blocks, or the nil- checks, or the error handling any more, so get it off the screen so I can focus on the meat.

      I like this tool, but it has two downsides: first, I like to read my diffs in Shelley with a good UI, not in a terminal. Second, it takes a couple of minutes for an LLM to digest and minimize a diff, and I don’t want to wait. So ideally I would not run meat on the command line, but have it built into Shelley and have it pre-processing commits the moment they are created. It turns out I can do that with a single prompt:

      Please build meat.dev into Shelley. Install the latest version in the PATH. When a git commit is created by Shelley, start meat processing in the background on the commit. Add a toggle to the Shelley Diffs view for meat. If the commit is still being processed, so the user it is in process.

      This single prompt was all it took not just to add meat to Shelley, but to appropriately pre-process commits in the background before I came back to session to review the diff, saving me waiting for a model to reduce the diff. The only unfortunate choice the model made was using the 🥩 emoji for the toggle button.

      Imagine the convoluted misery it would be trying to plug that into the VS Code extensions API! Or trying to get it into vimdiff. It would certainly be possible, but the machinery to start pre-processing the commits as soon as they appear would be nigh-on impossible. I would be better off implementing an out-of-band meatd that listened to the file system and provided a cache for the meat tool that a customization API could use, because the points of extension and configuration would not be the right shape.

      And that is the fundamental difference between classic configuration/customization and agent-driven personalization: you can do so much more. The agent will do the hard work of understanding the source and changing it to suit the particular task you have in mind. The software we live with is far more powerful with personalization. All you need is the source code.

      The Age of Personalized Software

      The pre-agent development costs meant it was rational for complex software to ship with large configuration files, extension systems, and plugin systems. The core code of even a moderate project like Vim is huge and baroque, and takes weeks for a human to digest. The thought that, on wanting line numbers to print by default, an engineer would learn the code base and add it just for themselves is unreasonable. Better to design it for sharing with others, which justifies the expense of implementing it by amortizing it over many users. As features in a code base grow, it makes sense to look for common abstractions where you can break out an extension or plugin system.

      Now the expense of learning the code and making a change has dropped dramatically. Agents do the heavy lifting. For a single user—which implies extremely constrained conditions under which the program runs—a top-end agent can usually now add a feature in a single shot. For single-user software, the need for careful code review can often be replaced by “does it seem to work?”

      The result is that software that can be personalized doesn’t need a plugin system or a config file. Want to change the font size in your text editor? Give the agent the source and tell it to. If it is a hardcoded value it will find and edit it. If it’s a hardcoded bitmap font it will download another and replace it, or it will use Monobit to make you one! You have incredible capabilities on tap.

      Whole Categories of Software Products Need to Be Reinvented

      Personal software applies well to small teams too. Why would an engineering team purchase an extremely configurable task manager (or a CMS or CRM), spend time learning and configuring it, and contort their team to its limits, when they can assemble just the features they want from common building blocks?

      Both the upfront fixed costs and the ongoing costs of personalizing software have disappeared.

      The blog you are reading is bespoke software, written in Shelley, because it was easier to piece together and personalize libraries like Tiptap than it is to try and customize traditional software products. For end-user products to make sense in a company today, they need to be personalizable. Which means we need the source code.

      Where Codex and Claude Code Diverge

      This same skill-based technique that was applied to Shelley to make it personalizable can be trivially applied to other open-source agents like Pi. (So much so that I am left wondering why Pi needs an extension system built into it. The source code is the extension system.) It would require a lot more tokens, but you could do the same to Codex, which is an open-source agent.

      Where you would hit a wall, however, is Claude Code. It is closed-source software, so you don’t get to personalize it. There are a lot of old-fashioned customization hooks in Claude Code. Hopefully, how you want an agent to work fits in their hooks. If not, switch to an agent that lets you personalize it.

generated: August 05, 2026 at 11:23:10