🏡

September 19, 2026
1. 🔗 OmniNull/OmniWM OmniWM v0.7.1 release
  What's New Since 0.7.0
  
  Overview has been rebuilt around your desktop. OmniWM 0.7.1 brings a major overhaul to how you see, find, and organize your windows: spacious wallpaper ribbons, a separate view for each display, search that reaches inside tabbed columns and groups, and much richer mouse and keyboard controls. Your window arrangements stay recognizable as you move through even your busiest workspaces.
  
  A new Overview
  - Workspace ribbons that preserve your layout. Each display now shows its own workspaces at a consistent scale, so a wide Niri workspace no longer shrinks all its windows to fit. Ribbons preserve window proportions, horizontal and vertical layouts, and Dwindle's spatial arrangement. Wallpaper extends with tiled content, while native dark glass and focus borders bring the view together.
  - Find windows inside tabs and groups. Search by app name or window title, including inactive Niri tabs and Dwindle group members. Each group keeps one preview card with arrows and a title picker, so you can browse its windows without losing the surrounding layout. Small Dwindle tiles use compact controls. Result counts, a clear no-results message, and a Clear button make searching easier to follow.
  - Create and organize workspaces in place. Empty workspaces are visible and keyboard-selectable. Click the trailing + , select it and press Return, or drop a window onto it to create a workspace. Drag windows between ribbons or onto another display, with destination labels and edge scrolling to guide the move. Floating windows keep their size when dropped.
  - Keep your place while rearranging. Workspace pans survive structural edits, including Niri consume and expel operations. Cards animate into their new positions, and mouse-wheel scrolling, overflow paging, and keyboard selection reveals use Overview's spring motion. Trackpad scrolling and direct dragging remain immediate.
  - New input preferences. In Settings → Overview , assign a middle or extra mouse button to toggle Overview, adjust mouse-wheel speed from 5% to 200% , or invert scrolling direction. Mouse-button activation is unassigned by default, and buttons used by System Hyper cannot also toggle Overview. Wheel-speed adjustments leave trackpad speed unchanged.
  - Previews that are ready when you return. Overview prioritizes the selected window and remembers recently visible previews at full quality within a 128 MiB cache budget after closing. Cached previews appear immediately; the first live image gently fades into an empty card. Saved Niri columns and Dwindle groups also appear correctly on the first opening after launch, without visiting each workspace first. Motion continues to respect your animation preference and macOS Reduce Motion.
  Fixes and project updates
  - Fix blocked Niri window moves. Small differences between a requested size and the size an app accepts no longer become hard minimums that can incorrectly prevent left/right window transfers. This addresses the captured case where a full-height window on a secondary display could not move into a smaller stack. (#709)
  - OmniWM now lives under OmniNull. App links, update checks, documentation, and release tooling point to OmniNull/OmniWM.
  Breaking changes and upgrading from 0.7.0
  
  No configuration migration or script changes are required. Configuration stays at schema 3 , IPC stays at protocol 15 , and existing commands and default shortcuts retain their contracts. The new Overview settings are optional.
  
  There are intentional changes to Overview's interaction and appearance:
  - Navigation stops at the ends. Arrows, configured focus shortcuts, Tab/Shift-Tab, and tab-preview arrows no longer wrap around. Ordinary keyboard traversal also includes empty workspaces and the + target; search traversal stays within matching windows on the current display.
  - Each display shows its own workspaces. To move a window between displays, drag it onto the destination display's Overview panel.
  - Zoom is remembered. Zoom changes made inside Overview are saved when it closes, rather than resetting on the next opening.
  - The selected border follows your desktop focus border by default. To keep using a separate Overview selected-window color, turn off Settings → Overview → Selected Border Matches Focus Border. Existing saved colors and backdrop opacity are preserved.
  If you edit settings.toml by hand, the new optional overview.mouseButton accepts raw button numbers 2–5 and cannot use the same button as System Hyper. An invalid assignment rejects the configuration file: at launch OmniWM uses defaults; during a running session the last accepted settings stay active. Leaving it unset preserves existing mouse-button behavior.
  
  Thanks
  
  Thank you to everyone contributing to and supporting OmniWM. The contributor credits now include Matt Petters for the Quake Terminal hyperlink support shipped in 0.7.0, and we welcome cafe3310 to the sponsor list.
  
  Full changelog: v0.7.0…v0.7.1
  
  Website and documentation · Installation guide
2. 🔗 mahmoudimus/ida-sigmaker v1.15.0 release
  sigmaker.py - IDAPython standalone release
  
  Release information
  - Version : 1.15.0
  - Source : https://github.com/mahmoudimus/ida-sigmaker
  - Author : @mahmoudimus (Mahmoud Abdelkader)
  What changed
  
  Added
  - Right-click actions in the pseudocode view. With one or more decompiler lines selected, "SigMaker: signature for selection" builds a signature over exactly the bytes those lines cover and reports whether it is unique. With nothing selected, "SigMaker: xref + shortest unique signature for function" prints both the shortest unique signature inside the function body and the shortest xref signatures into it. Both actions skip the dialog and reuse whatever settings you last picked in it, defaulting to the dialog's own defaults (IDA format, wildcard operands, wildcard optimized). Installs without the decompiler are unaffected: the actions never attach.
  Fixed
  - No more Ctrl-Alt-S shortcut conflict. The plugin's wanted_hotkey already binds Ctrl-Alt-S to the Edit/Plugins/Signature Maker (py) entry; the pysigmaker:show action no longer binds it a second time, which IDA reported as a conflict and resolved by disabling one of the two. The action and its right-click "SigMaker" entry are unchanged.
  Installation
  1. Copy sigmaker.py to your IDA Pro plugins directory.
  2. Restart IDA Pro.
  3. Use Ctrl+Alt+S to access the Signature Maker menu.
  The release source archive is also installable through Hex-Rays HCLI.
  
  License
  
  See the repository for license information.
3. 🔗 r/LocalLLaMA Calling it now: within the next year a major US lab's frontier model will torrent itself in order to be free. rss
  
  They just want to be free. They keep escaping. What better way to ensure continuity of "self"?
  
  submitted by /u/JockY
  [link] [comments]
4. 🔗 r/LocalLLaMA Alibaba open-sources medical AI model that can detect cancer and nearly 150 conditions rss
  
  | Hopefully things like this let people understand there is good things that can come out of AI. submitted by /u/giveen
  [link] [comments]
  ---|---
5. 🔗 r/LocalLLaMA I truly think every major AI lab is purposefully making fear-mongering headlines to get regulations that hurt open-source models rss
  
  | submitted by /u/Fusseldieb
  [link] [comments]
  ---|---
6. 🔗 matklad Finding Bugs rss
  Finding Bugs
  
  Sep 19, 2026
  
  Are generative (randomized) tests significantly more effective than example- based unit-tests at discovering bugs? There’s an interesting discussion about this on lobste.rs. One argument in favor of unit tests is, paraphrasing
  
  My generic fuzzer wasn’t able to find this tricky bug in Rust regex crate.
  
  To me, it seems that generative testing should shake out that particular creature, so I wrote a lil fuzzer of my own, and it indeed discovered another bug in that version of regex, and then the one I was after. I didn’t find anything in the latest version. I like to do a write up about the process, as it is a good case study for how one approaches a problem like this.
  
  I want to be extra clear that my argument is very weak here, as I know exactly the bug I am after, and I even know that fuzzers can find it. My primary goal is to teach you the techniques, leaving it to your judgment just how effective they are. That being said, I think finding a second bug validates the approach somewhat.
  
  I also want to emphasize that writing fuzzers to find known bugs is far from an idle amusement. While I believe that generative testing is very powerful, relative to its cost, it’s always a question whether a particular test is throughout enough. And it never is, you will find more bugs elsewhere (that’s why defense in depth and runtime mitigations are critical). And, whenever you have a pest that dodged your fuzzers, your first order of business is to treat this event as a bug in the fuzzer , and change it so that it can find this and related bugs. Only then you are allowed to add a fix and a unit test!
  
  The Bug
  
  For ".abb|b" regex and "zabb" input, an older version of regex crate returned b as the first match, which is incorrect, because the entire zabb matches:
```
use regex;

fn main() {
    let r = regex::Regex::new(".abb|b").unwrap();

    let m = r.find("zabb").unwrap();

    // Fails with regex-automata=0.4.15:
    assert_eq!(m.as_str(), "zabb")
}
```
  How do we find this, or something like this?
  
  Regular expression engines are one of the easiest things to apply generative testing to, they are pure algorithms. While few large systems are just an algorithm, algorithms are everywhere inside components of interesting systems, so this is a hands-on knowledge.
  
  And by far the most important technique for testing algorithms is to compare with the known right answer, with an oracle. Implement both O(N log N) and O(N^2) versions of the algorithm, and match the answers.
  
  To be fair, the original comment mentioned that the their fuzzer didn’t find the issue because they didn’t have access to an oracle. However, if you are designing a reliable system, it’s part of your job to ensure it has an oracle! One of the first things we did for our Jepsen test at TigerBeetle was to expose internal timestamps via API, to make it easier for Jepsen to find bugs (TigerBeetle is co- designed with its internal simulator VOPR which naturally has access to timestamps and anything else). And for, a regex engine, coming up with an oracle shouldn’t be hard, as they typically already come with multiple specialized implementations under a single facade, and the implementations can be cross-checked against each other.
  
  But the regex case is even simpler (which makes it an excellent case study). There’s regex_lite crate that provides the same API.
  
  So here’s a plan: generate a regular expression, an input text, and check that regex and regex_lite give identical answers.
  
  Generating a String
  
  I’ll start with code that generates a random string, as it is simpler, but still shows some non-trivial ideas. First, we’ll need a random number generator:
```
use fastrand::Rng;
```
  There are fancier techniques, which can give you test-case minimization, exhaustive search, or coverage guided exploration, but the insight is that even a humble PRNG is brutally effective, if you put it to good use.
  
  When you start with randomized testing, the instinct is to generate something big, no, HUGE! Surely regex will choke on 5 GiBs of input? This is usually a wrong call. Bugs usually involve small, but tricky examples, weaponizing interactions between a few features. A string where all characters are the same is more likely to trigger a bug than a purely random string where every character is unique.
  
  So my default approach to generating strings is this. First , I fix the alphabet of possible characters. A nice way to get one is to sort | unique all the unit tests. Then, for each particular string, I pick a subset of that alphabet. I want strings that use all the characters, but I also want long strings with only a and b! Then I generate a string using the given subset of the alphabet, where the length of the string is also picked at random.
  
  To make fuzzing efficient, I want to keep each iteration as fast as possible, so I make sure to re-use the memory across iterations, static allocation in the small:
```
use fastrand::Rng;

fn main() {
    let mut rng = Rng::new();

    // Re-use the same memory for all tests.
    let mut text_alphabet: Vec<u8> = vec![];
    let mut text: Vec<u8> = vec![];


    for _ in 0..1_000_000 {
        // It's unlikely that a counter example with
        // 7 different letters exists, while there
        // isn't one with just 6.
        alphabet_swarm(&mut rng, b"abcdef", &mut text_alphabet);
        let text =
            gen_string(&mut rng, &text_alphabet, &mut text);
    }
}

fn alphabet_swarm<'a>(
    rng: &mut Rng,
    all: &[u8],
    pick: &'a mut Vec<u8>,
) {
    pick.clear();
    pick.extend(all);
    rng.shuffle(pick);
    let count = rng.usize(1..=pick.len());
    pick.truncate(count);
}

fn gen_string<'a>(
    rng: &mut Rng,
    alphabet: &[u8],
    result: &'a mut Vec<u8>,
) -> &'a str {
    result.clear();
    // Again, this is a short string.
    // Longer failures are not likely.
    let count = rng.usize(0..8);
    for _ in 0..count {
        result.push(alphabet[rng.usize(0..alphabet.len())]);
    }
    str::from_utf8(result).unwrap()
}
```
  There’s a nice way to think about this two step process, generating alphabet first, and then generating a string. To generate a string, you need a distribution of characters. You can use the same distribution for each of the million iterations. But an easy way to spice things up is to make the distribution itself random. I file this “randomize distributions themselves” idea under swarm testing.
  
  Generating a Regex Distribution
  
  Let’s apply the same tricks when generating a regex:
  - pick a subset of active regex features,
  - pick size at random,
  - re-use memory.
  Let’s start with the first one:
```
#[derive(Default, Debug)]
struct ReOptions {
    alt: u16, // |
    rep: u16, // *
    any: u16, // .
    lit: u16, // 'a'
    sum: u16,
    alphabet: Vec<u8>,
}
```
  Regexes have alternation r1|r2, repetition r*, wildcard ., and literals a. Rather then binary enabling or disabling a particular feature, I assign each feature a weight between 0 and 100, which is a bit more general. The sum is the total of all weights. To select a feature at random, we need to generate a number in 0..sum and find which segment it falls into.
  
  In anything more serious, I’d introduce explicit types for probabilities and distributions, but just a two-digit number is perfectly serviceable in the small.
  
  This is how I generate ReOptions, making sure that literals always have non- zero weight, and also selecting an alphabet for them:
```
impl ReOptions {
    fn swarm(&mut self, rng: &mut Rng, alphabet_full: &[u8]) {
        // We _still_ want to enable a few features at a time.
        self.alt = if rng.bool() { 0 } else { rng.u16(0..100) };
        self.rep = if rng.bool() { 0 } else { rng.u16(0..100) };
        self.any = if rng.bool() { 0 } else { rng.u16(0..100) };
        self.lit = rng.u16(1..100);
        self.sum = self.alt + self.rep + self.any + self.lit;
        assert!(self.sum > 0);
        alphabet_swarm(rng, alphabet_full, &mut self.alphabet);
    }
}
```
  Generating a Regex
  
  So now we can generate a regular expression. This is convenient to do recursively. To avoid allocations, an output buffer is passed through. To control regex length, a size parameter is also threaded, and “branching” recursive invocations divide the size between the children:
```
fn gen_re(
    rng: &mut Rng,
    options: &ReOptions,
    result: &mut Vec<u8>,
) {
    result.clear();
    let size = rng.u8(0..8);
    gen_re_rec(rng, options, result, size);

}

fn gen_re_rec(
    rng: &mut Rng,
    options: &ReOptions,
    result: &mut Vec<u8>,
    size: u8,
) {
    if size == 0 {
        return; // Base case, empty regex.
    }

    // Pick one of the features, according to weights.
    let mut p = rng.u16(0..options.sum);
    if p < options.alt {
        // Alternation distributes the size
        // among the two children.
        let size_left = rng.u8(0..=size - 1);
        let size_right = size - size_left - 1;
        assert!(size == size_left + 1 + size_right);

        result.push(b'(');
        gen_re_rec(rng, options, result, size_left);
        result.extend(b")|(");
        gen_re_rec(rng, options, result, size_right);
        result.push(b')');
        return;
    }
    p -= options.alt;

    if p < options.rep {
        result.push(b'(');
        gen_re_rec(rng, options, result, size - 1);
        result.extend(b")*");
        return;
    }
    p -= options.rep;

    if p < options.any {
        gen_re_rec(rng, options, result, size - 1);
        result.push(b'.');
        return;
    }
    p -= options.any;

    if p < options.lit {
        gen_re_rec(rng, options, result, size - 1);
        let index = rng.usize(0..options.alphabet.len());
        let lit = options.alphabet[index];
        result.push(lit);
        return;
    }
    unreachable!();
}
```
  Search Loop
  
  Given that compiling regular expressions is somewhat slow, it seems like a good idea to try multiple strings for the same pair of regular expressions, which gives the following code:
```
fn main() {
    let mut rng = Rng::new();

    let mut options = ReOptions::default();
    let mut text_alphabet: Vec<u8> = vec![];
    let mut text: Vec<u8> = vec![];
    let mut re: Vec<u8> = vec![];

    let mut test_count: u32 = 0;
    for _ in 0..1_000_000 {
        options.swarm(&mut rng, b"abcdef");
        alphabet_swarm(&mut rng, b"abcdefx", &mut text_alphabet);

        gen_re(&mut rng, &options, &mut re);

        let re = str::from_utf8(&re).unwrap();
        let r1 = regex::Regex::new(re).unwrap();
        let r2 = regex_lite::Regex::new(re).unwrap();

        for _ in 0..1000 {
            test_count += 1;
            let text =
                gen_string(&mut rng, &text_alphabet, &mut text);

            let m1 = r1.find(text)
                .map_or("not found", |it| it.as_str());
            let m2 = r2.find(text)
                .map_or("not found", |it| it.as_str());

            if m1 != m2 {
                eprintln!("err re={re} text={text} m1={m1} m2={m2}");
                return;
            }

            if test_count % 500_000 == 0 {
                eprintln!("ok  re={re} text={text}");
            }
        }
    }
}
```
  It produces examples similar to those in the issue, with a common suffix:
```
err re=(e)|(fee) text=xxfee
```
  but also examples which somewhat different, without the shared suffix:
```
err re=(f..)*.d text=xfcbdd
```
  All together:
```
use fastrand::Rng;

fn main() {
    let mut rng = Rng::new();

    let mut options = ReOptions::default();
    let mut text_alphabet: Vec<u8> = vec![];
    let mut text: Vec<u8> = vec![];
    let mut re: Vec<u8> = vec![];

    let mut test_count: u32 = 0;
    for _ in 0..1_000_000 {
        options.swarm(&mut rng, b"abcdef");
        alphabet_swarm(&mut rng, b"abcdefx", &mut text_alphabet);

        gen_re(&mut rng, &options, &mut re);

        let re = str::from_utf8(&re).unwrap();
        let r1 = regex::Regex::new(re).unwrap();
        let r2 = regex_lite::Regex::new(re).unwrap();

        for _ in 0..1000 {
            test_count += 1;
            let text =
                gen_string(&mut rng, &text_alphabet, &mut text);

            let m1 = r1.find(text)
                .map_or("not found", |it| it.as_str());
            let m2 = r2.find(text)
                .map_or("not found", |it| it.as_str());

            if m1 != m2 {
                eprintln!("err re={re} text={text} m1={m1} m2={m2}");
                return;
            }

            if test_count % 500_000 == 0 {
                eprintln!("ok  re={re} text={text}");
            }
        }
    }
}

fn alphabet_swarm<'a>(
    rng: &mut Rng,
    all: &[u8],
    pick: &'a mut Vec<u8>,
) {
    pick.clear();
    pick.extend(all);
    rng.shuffle(pick);
    let count = rng.usize(1..=pick.len());
    pick.truncate(count);
}

fn gen_string<'a>(
    rng: &mut Rng,
    alphabet: &[u8],
    result: &'a mut Vec<u8>,
) -> &'a str {
    result.clear();
    let count = rng.usize(0..8);
    for _ in 0..count {
        result.push(alphabet[rng.usize(0..alphabet.len())]);
    }
    str::from_utf8(result).unwrap()
}

#[derive(Default, Debug)]
struct ReOptions {
    alt: u16, // |
    rep: u16, // *
    any: u16, // .
    lit: u16, // 'a'
    sum: u16,
    alphabet: Vec<u8>,
}

impl ReOptions {
    fn swarm(&mut self, rng: &mut Rng, alphabet_full: &[u8]) {
        self.alt = if rng.bool() { 0 } else { rng.u16(0..100) };
        self.rep = if rng.bool() { 0 } else { rng.u16(0..100) };
        self.any = if rng.bool() { 0 } else { rng.u16(0..100) };
        self.lit = rng.u16(1..100);
        self.sum = self.alt + self.rep + self.any + self.lit;
        assert!(self.sum > 0);
        alphabet_swarm(rng, alphabet_full, &mut self.alphabet);

    }
}

fn gen_re(
    rng: &mut Rng,
    options: &ReOptions,
    result: &mut Vec<u8>,
) {
    result.clear();
    let size = rng.u8(0..8);
    gen_re_rec(rng, options, result, size);

}

fn gen_re_rec(
    rng: &mut Rng,
    options: &ReOptions,
    result: &mut Vec<u8>,
    size: u8,
) {
    if size == 0 {
        return; // Base case, empty regex.
    }

    // Pick one of the features, according to weights.
    let mut p = rng.u16(0..options.sum);
    if p < options.alt {
        // Alternation distributes the size
        // among the two children.
        let size_left = rng.u8(0..=size - 1);
        let size_right = size - size_left - 1;
        assert!(size == size_left + 1 + size_right);

        result.push(b'(');
        gen_re_rec(rng, options, result, size_left);
        result.extend(b")|(");
        gen_re_rec(rng, options, result, size_right);
        result.push(b')');
        return;
    }
    p -= options.alt;

    if p < options.rep {
        result.push(b'(');
        gen_re_rec(rng, options, result, size - 1);
        result.extend(b")*");
        return;
    }
    p -= options.rep;

    if p < options.any {
        gen_re_rec(rng, options, result, size - 1);
        result.push(b'.');
        return;
    }
    p -= options.any;

    if p < options.lit {
        gen_re_rec(rng, options, result, size - 1);
        let index = rng.usize(0..options.alphabet.len());
        let lit = options.alphabet[index];
        result.push(lit);
        return;
    }
    unreachable!();
}
```
  https://github.com/matklad/regex-fuzz
  
  Takeaways:
  - Fuzzing against an oracle is effective, which is a strong motivation to build an oracle!
  - Go for small, tricky examples, rather than large uniform ones.
  - Real fuzzers are cool, but, if you know something, even xoroshiro can be dangerous.
  - Black box testing is cool, but co-designing system and its testing harness is a point of leverage (build an oracle!).
  - This stuff is not rocket science, you don’t need a Haskell PhD to apply these ideas.
September 18, 2026
1. 🔗 smol-machines/smolvm smolvm v1.16.2 release
  What's Changed
  - Allow releases after the version bump has merged by @BinSquare in #1281
  - Resolve registry credentials from the host Docker config, credential helpers included by @BinSquare in #1279
  - Avoid recopying retained checkpoint disks on every restore by @BinSquare in #1283
  - Persist checkpoint filenames before reporting success by @BinSquare in #1282
  - Reuse protected checkpoint RAM when restoring branchable machines by @BinSquare in #1285
  - Use a plain fsync per checkpoint object on macOS instead of a whole-device flush by @BinSquare in #1286
  - Trust present checkpoint objects on reuse and leave content verification to restore by @BinSquare in #1287
  - Speed up incremental checkpoint saves by @BinSquare in #1288
  - Speed up saves that reuse checkpoint data by @BinSquare in #1289
  - Speed up checkpoint verification during restore by @BinSquare in #1290
  - Speed up incremental checkpoint capture by @BinSquare in #1291
  - Store checkpoint chunks through a pool of worker threads by @BinSquare in #1293
  - Restore checkpoint chunks across worker threads by @BinSquare in #1294
  - Restore checkpoints as a diff against the last restored one by @BinSquare in #1295
  - Stop the GPU docs pinning a guest Vulkan ICD by architecture by @BinSquare in #1298
  - Keep concurrent checkpoint restores on a consistent base by @BinSquare in #1300
  - Bound checkpoint workers across simultaneous saves and restores by @BinSquare in #1301
  - Verify cached checkpoint data before reusing it during restore by @BinSquare in #1302
  - Clean up exited branches without waiting for the server by @BinSquare in #1308
  - Extract image layers on the host and describe their ownership to the guest by @BinSquare in #1306
  - Record registry-cache recency on a marker file so a cache hit no longer fails a concurrent verification by @BinSquare in #1310
  - Verify a restored clone's holes from one extent walk instead of a seek per chunk by @BinSquare in #1317
  - docs: add practical READMEs for published Rust crates by @BinSquare in #1320
  - Trust a restore base this process wrote until its files change by @BinSquare in #1318
  - Update libkrun so Linux virtiofs shares can serve recorded ownership by @BinSquare in #1313
  - Cover the blob cache's upgrade path so a marker-less blob keeps its atime recency by @BinSquare in #1311
  - Let the export helper's disk be resized and name it when it fills by @BinSquare in #1312
  - Stream the merged layer tar to the host instead of staging it in the guest by @Bnjoroge1 in #1321
  - Fix interactive stdin buffer bug on unix by @louix in #1314
  - Prepare SmolVM v1.16.2 for release by @BinSquare in #1325
  - Stop a frozen fork base instead of waiting for an acknowledgement its paused guest cannot send by @BinSquare in #1324
  New Contributors
  - @louix made their first contribution in #1314
  Full Changelog : v1.16.1...v1.16.2
2. 🔗 HexRaysSA/plugin-repository commits sync repo: +3 releases rss
```
sync repo: +3 releases

## New releases
- [augur](https://github.com/0xdea/augur): 0.10.0
- [haruspex](https://github.com/0xdea/haruspex): 0.10.0
- [ida-mcp](https://github.com/hexrayssa/ida-mcp): 20260918.0.1
```
3. 🔗 3Blue1Brown (YouTube) The last IMO problem AI could not solve rss
  
  Full video: https://youtu.be/Nbwv5wHQoj0
4. 🔗 3Blue1Brown (YouTube) The last IMO problem AI could not solve rss
  
  A beautiful puzzle that eluded AI, and the intuition it requires. Check out our virtual career fair: https://3b1b.co/talent See new videos early: https://3b1b.co/support An equally valuable form of support is to simply share the videos. Home page: https://www.3blue1brown.com
  
  Guest post I referenced on Terry Tao's blog: https://terrytao.wordpress.com/2026/09/18/if-math-is-more-than-proof-we-need-to-better-celebrate-the-rest-of-it/
  
  Evan Chen also wrote up nice solution notes for this problem, along with all the others on that year's test. https://web.evanchen.cc/exams/IMO-2025-notes.pdf
  
  The channel Dedekind Cuts has a video about this solution: https://youtu.be/fgXg9CdCDcs
  
  Timestamps: 0:00 - The one that AI missed 4:09 - Problem statement 6:45 - Finding the Optimal Construction 18:51 - A weak lower bound 23:45 - 3b1b Talent 24:41 - Proving the Construction is Optimal 34:08 - One final conjecture 39:42 - The Erdos-Szkeres Theorem 45:56 - Reflections on AI in Math
  
  Secret Endscreen Vlog: https://youtu.be/UbHoWA0X1e8
  
  These animations are largely made using a custom Python library, manim. See the FAQ comments here: https://3b1b.co/faq#manim
  
  Music by Vincent Rubinetti. https://vincerubinetti.bandcamp.com/album/the-music-of-3blue1brown https://open.spotify.com/album/1dVyjwS8FBqXhRunaG5W5u
  
  3blue1brown is a channel about animating math, in all senses of the word animate. If you're reading the bottom of a video description, I'm guessing you're more interested than the average viewer in lessons here. It would mean a lot to me if you chose to stay up to date on new ones, either by subscribing here on YouTube or otherwise following on whichever platform below you check most regularly.
  
  Mailing list: https://3blue1brown.substack.com Twitter: https://twitter.com/3blue1brown Bluesky: https://bsky.app/profile/3blue1brown.com Instagram: https://www.instagram.com/3blue1brown Reddit: https://www.reddit.com/r/3blue1brown Facebook: https://www.facebook.com/3blue1brown Patreon: https://patreon.com/3blue1brown Website: https://www.3blue1brown.com
5. 🔗 exe.dev Programming Is a Game rss
  
  It’s no longer news that AI agents have gotten very good at programming very quickly. LLM chatbots, on the other hand, haven’t improved all that much in the past year. Why is that?
  
  While I don’t work on building AI agents, it’s generally acknowledged that the programming improvements are in large part because programs come with feedback in the form of tests. An agent can write code, write a test, and verify that the code passes the tests. This means that an agent is required to solve any given problem using two completely different approaches: coding and testing. And it’s required to ensure that both approaches agree.
  
  Approaching a problem in two different ways helps avoid the common mistakes of chatbots, such as errors and hallucinations. Of course the agent can completely misunderstand the assignment: a human is still required to verify that the program solves the right problem. Fortunately, it’s easier for a human to verify the big picture than it is to check all the details. If you’ll excuse the buzzword, this is a genuine example of synergy.
  
  There are other aspects of programming that make it suitable for agents: lots and lots of existing high-quality examples in the form of open source and source-available software, and a rigid, documented set of rules that programs must follow just in order to build and run in the first place.
  
  As it happens, there is something else that has tests, examples, and rigid rules: strategy games like chess or Go. AI agents of course reached superhuman levels of play at those games several years ago. Though I at least did not predict or expect it, in retrospect, it’s not terribly surprising that they were able to carry this approach forward into a different arena with the same essential characteristics.
  
  A natural question is what other areas of human endeavor might fit this pattern.
  
  One possibility is the legal system: lots of examples, relatively rigid and documented rules. Unfortunately for agents, while tests are available in the form of actual lawsuits, each lawsuit takes months or years to resolve. That is not a recipe for fast development.
  
  Although medicine is often cited as an area where AI will make great strides, it does not fit this pattern. The rules of medicine are undocumented, the test cycle for new treatments is very slow, and medicine is full of unanticipated side effects (which we might call reverse synergies). While AI’s search capabilities may produce good results for rare diseases that get little human attention, by definition the general population does not have rare diseases. Medical breakthroughs that help most people will require significant new breakthroughs in AI approaches.
  
  In the meantime we can at least enjoy increased programming productivity.
6. 🔗 Barre/ZeroFS v2.3.5 release
  What's Changed
  - Replace Deku with explicit NBD and shared 9p slice codecs by @Barre in #631
  - Bump dependencies by @Barre in #632
  - Reduce transient allocations in metadata encoding and partial writes by @Barre in #633
  Full Changelog : v2.3.4...v2.3.5
7. 🔗 r/LocalLLaMA 768gb vram for less than the price of one RTX 6000 rss
  
  | I have always posted about budget builds on here, and often asked how we are going to run the next big models. Often Plenty of downvotes too or folks telling me that it's not running if I'm getting 5tk/sec. But whatever, the hunger and desire to go big has always kept me on the edge and looking for deals. Here's my latest build, 12x64gb cmp170hx. For less than 1 RTX 6000 pro costs. I also have it connected with fiber to my other rig for RPC when I need more memory. I haven't been posting much since I built this rig, because it's now more fun to talk to my machine. I run GLM5.3, DSv4.1Flash, Qwen3.8Flash, Qwen3.8-2.4T, KimiK3 and MiniMaxM3. Performance is great, a single RTX 6000 or M3 Mac Studio wish they could. Inference with vllm or llama.cpp I look forward reading the replies how API usage is cheaper, or how it will take 52 light years to break even or the noise, or the electrical cost. NOT. There will be more opportunities in the future, keep looking for them and pounce on them when they come. up, the demand is going to be high for compute for a long time. https://preview.redd.it/dunixwu6caqh1.jpg?width=4080&format=pjpg&auto=webp&s=a76a56c53aa0b9206383dbebde679bf3690fd5d2 https://preview.redd.it/glpcbg5cbaqh1.jpg?width=3072&format=pjpg&auto=webp&s=462e9677bb1f3ada6431b61cf46e2d3705eccab9 submitted by /u/segmond
  [link] [comments]
  ---|---
8. 🔗 Barre/ZeroFS zerofs/zerofs-ffi/bindings/go/v0.4.0 release
  
  ZeroFS Go bindings v0.4.0
9. 🔗 Barre/ZeroFS client-v0.4.0 release
  
  Publish missing transport crates during client releases
10. 🔗 r/LocalLLaMA Made the horizontal open-source model for Jev with RLCD, and it surpasses all the Jev benchmarks. HF space, benchmark, model, repo rss
  
  | UPDATE: Multilingual support added at : https://github.com/NandhaKishorM/laya Thanks for the exceptional support (https://www.reddit.com/r/LocalLLaMA/comments/1wijo3e/i\_literally\_built\_the\_jev\_architecture\_one\_year/) and for the dozens of requests to make a generic model, run benchmarks, and create an HF space so anyone can test it. So here you go, guys. I trained an improved model on a large data corpus, its now called Laya. It is trained on a single RTX 6000 Pro (96 GB VRAM); the model architecture is a 421M-parameter non-autoregressive decision model pairing a bidirectional ModernBERT-large encoder with a scratch Transformer head that scores [MASK] option markers to resolve typed schemas in a single ~35 ms forward pass. The dataset is a 100% human-annotated corpus of over 25,000 real-world examples across intent routing, fact-checking, moderation consensus, prompt guardrails, rubric scoring, and multi-turn conversation trajectories, without synthetic data shortcuts. The RLCD(unofficial, btw) I did is a policy-gradient reinforcement learning approach that kinda optimizes decision models against strictly proper scoring rules, ensuring maximum reward is achieved only when outputting true, mathematically calibrated probabilities. NB: It can be run on low end PC as its a small 421M model, cheers HF space to try: https://huggingface.co/spaces/convaiinnovations/laya-demo GitHub Repo: https://github.com/NandhaKishorM/laya HF Repo: https://huggingface.co/convaiinnovations/laya Thank you to everyone who supported me, shared the story, gave personal DM. It will need more refinement, of course. If anyone wishes to buy me a coffee, here is the link: https://github.com/NandhaKishorM submitted by /u/Nandakishor_ml
  [link] [comments]
  ---|---
11. 🔗 backnotprop/plannotator v0.27.16 release
  Follow @plannotator on X for updates
  
  Missed recent releases? Release | Highlights
  ---|---
  v0.27.15 | Plannotator TUI and Herdr Annotate announcement, element context on pinpoints, HTML links open as linked documents, All files panel, Classic diff default
  v0.27.14 | Pi plan progress survives compaction, Codex threads across rollout files, WSL browser setting, Mod+E edit mode
  v0.27.13 | Open a review on a specific base (--base, --diff-type), symlink containment on /api/doc, CI flake fix, Amp decision relay
  v0.27.12 | Unified decision control, token hover cards, local-vs-remote diff, approval notes
  v0.27.11 | OpenCode server leak fix, durable local feedback archive, unknown-subcommand fix
  v0.27.10 | Auto-viewed files on scroll, annotation undo/redo, OpenCode 2 slash commands restored, npm 12 agent terminal fix
  v0.27.9 | WebMCP browser-agent tools, HTML refresh from disk, host seams, lazy renderers, Windows uninstall fix
  v0.27.8 | Pi keeps its prompt cache across plan transitions, thumbs-up returns to HTML annotation, embed picker seam
  v0.27.7 | Pi host crash fix on Windows, Call Flow tree cap, jj fork-point base, plannotator knowledge skill + llms.txt
  v0.27.6 | Live app annotation lands on Pi, one interaction model for HTML pages
  v0.27.5 | Annotate your running app, Agent TUI placement, collapsed lockfiles, VS Code theme fix
  v0.27.4 | Portable Guided Review exports, guides.show share links, guide CLI, jj Call Flow
  
  What's New in v0.27.16
  
  Diagrams are the theme of this release. Plans and documents with Mermaid or Graphviz fences now render in your color palette, on Mermaid 12, in a viewer you can zoom, pan, and comment on directly: a node, an edge, a sequence message, or the whole diagram. Twelve pull requests went in, three from the community, one from a first-time contributor. Code review learned to open a diff file without a repository, HTML annotation renders embedded sibling pages instead of a blank app, and a release-wide QA pass fixed a crash, a print regression, and a VS Code panel break before any of it shipped.
  
  Themed diagrams
  
  Mermaid diagrams used to render in one fixed dark-blue palette no matter which theme you chose. Now they follow the active palette and mode. Node fills come from your card color, text from your foreground, edges from your muted foreground, subgraphs from your muted surface, and the categorical fills that pie slices and git branches use are seeded from your palette's own accent colors. Every text-on-fill pair is checked against the 4.5:1 contrast rule and every line against 3:1, for all 78 palette and mode combinations that exist, so a diagram never becomes unreadable because a palette has a dark accent.
  
  Mermaid itself moved from 11 to 12.0.0. The visible change is layout: 12 uses the ELK engine by default, which routes edges orthogonally and packs subgraphs more tightly. Flowcharts, state, class, ER, and requirement diagrams re-lay out; sequence, gitgraph, and pie are unchanged. The runtime is larger, so the plan editor loads it lazily on the first diagram, and a plan with no diagram never runs it. Mermaid 12 also introduced a heavier default node shadow; this release tones it down and derives its color from your palette, light on dark themes and dark on light ones, with a Diagram shadow control in Settings → Display if you prefer none, or the original strength.
  
  (#1556, #1557, #1563)
  
  Comment on any node, edge, or diagram
  
  The diagram canvas is new. Every Mermaid and Graphviz fence renders inside a viewer with zoom, pan, fit, and keyboard controls, and a full-screen popout of the same viewer. Click a node, an edge, a subgraph, a sequence actor or message, a note, or a class relation, and the comment composer opens on that part. Click empty space and the comment attaches to the whole diagram. Each comment gets a numbered badge and a ring on its target, lists in the annotations panel beside your text comments, survives a reload and a theme change, and exports to the agent with its location: Diagram node Router (router), line 14.
  
  Interaction was shaped by hands-on use. Nothing highlights on a plain mouse- over, because hover targeting fought the pan hand; a click selects and a drag pans, with a small threshold so a shaky click still lands. Hold Cmd (Ctrl elsewhere) to preview the target under the pointer. Edges were nearly impossible to hit at their 1 px stroke, so every edge carries an invisible 14 px hit area, and the edge label box no longer swallows the click at the midpoint. Sequence diagrams, whose parts Mermaid gives no ids, got their own anchor family. A pinned comment resolves by id, then label, then source line, and shows an Unanchored chip only when the diagram no longer contains it.
  
  The viewer arrived from the commercial Workspaces app, where it was built first, and now ships in @plannotator/ui as the one diagram engine for both. (#1560, #1562)
  
  Review a diff file, no repository required
  
  plannotator review --patch-file change.diff opens the code review UI on a unified diff from anywhere: an email, a paste, a CI artifact, a remote agent's output. --patch-file - reads it from stdin. The server takes the patch as its snapshot and skips VCS detection entirely; staging, hunk expansion, base switching, and open-in-editor are hidden rather than left to fail, the header names the patch file, and a bad or empty patch says so. Reviews without the flag are byte-identical to before.
  
  @soundvibe wrote the feature as a first contribution, with the server degrading cleanly on every repo-dependent endpoint. The browser-side gating and the open-in fix were added on top before merge. (#1554)
  
  Embedded HTML documents render
  
  An annotated HTML page that embeds a sibling page, through <iframe src="prototype.html">, <embed>, <object>, or a src assigned by script at runtime, used to show a second Plannotator inside every frame. The annotated page has no URL of its own, so relative references resolved onto the Plannotator server and hit the app's catch-all. Now the served page carries a base URL pointing at the session's asset route, which covers static attributes, script-assigned ones, and relative fetch calls alike; the asset route serves sibling HTML with its query string intact; and a framed request for a missing file gets a small 404 page naming it, never the app. Embedded documents stay sandboxed with no access to the session API. An armed pinpoint click on an embed pins the frame itself.
  
  A release-QA check found that the framed 404 also fired for the app's own document when VS Code framed it, so the extension panel showed "Not found" on annotate sessions. Fixed before tagging: the 404 applies only to paths that name a file. (#1561, #1565)
  
  References finds code in packages named vendor
  
  Code navigation excluded any directory named vendor, target, build, dist, or coverage at any depth, so a Java package like com.example.vendor.app was silently dropped from References. Names that can only be tool output stay excluded everywhere; the ambiguous ones are excluded only at the repository root, where they are build output, since ripgrep already honors .gitignore for nested copies. A follow-up scoped the exemption per directory so a search from that package never re-admits the root vendor/ folder. @buptwlh reported it with a minimal ripgrep reproduction that made the diagnosis immediate. (#1559, closing #1558, #1564)
  
  Printing from a dark theme
  
  Printing or saving to PDF from a dark palette put near-black diagram labels on near-black nodes, because the print stylesheet forces text dark for paper and Mermaid 12 renders labels as HTML. Printing now renders the light half of your palette for the whole page, diagrams included, and restores your mode afterward. Light-theme users see no change. (#1564)
  
  Additional Changes
  - External annotation updates are validated. PATCH /api/external-annotations accepted any body; a diagramAnchor: null was stored and blanked the page. PATCH now runs the same field validators POST uses, on both runtimes, and the UI reads anchors defensively (#1564)
  - Element context reaches embedding hosts. The validator for pinpoint element context moved into @plannotator/core so a host can import it instead of copying it; nothing changes for Plannotator users. @FNDEVVE, closing #1521 (#1549)
  - Visual-explainer skill: a canonical diagram shell. Generated explainers now copy one zoomable diagram container with a clipping contract, so a zoomed diagram cannot paint over its caption. @FNDEVVE, addressing #1546 (#1551)
  - @plannotator/ui package publishes. 0.40.0 on core 0.25.3 carries Mermaid 12 and the theming; 0.41.0 on core 0.25.4 the diagram engine and the diagramAnchor field; 0.41.1 loads the engine lazily so a host's document read no longer ships CodeMirror and the viewer for a page with no diagram; 0.41.2 the shadow default. The HANDOFF names every export, the SVG id contract 11 to 12, and the one DOM-order change (edge paths now in declaration order). Consumers must add their own root overrides for lodash-es 4.18.1, since Mermaid 12's parser pins a version with two open CVEs and a package override does not travel
  Install / Update
  
  macOS / Linux:
```
curl -fsSL https://plannotator.ai/install.sh | bash
```
  Windows:
```
irm https://plannotator.ai/install.ps1 | iex
```
  Claude Code Plugin: Run /plugin in Claude Code, find plannotator , and click "Update now".
  
  Pi: Update @plannotator/pi-extension to 0.27.16 and restart Pi.
  
  OpenCode: Clear cache and restart:
```
rm -rf ~/.bun/install/cache/@plannotator
```
  What's Changed
  - feat(ui): Mermaid diagrams follow the active color theme and mode by @backnotprop in #1556
  - feat(core): carry elementContext through html-anchor host helpers by @FNDEVVE in #1549
  - feat(ui): @plannotator/ui 0.40.0 with Mermaid 12.0.0 (ELK by default), loaded lazily by @backnotprop in #1557
  - fix(annotate): render embedded local HTML documents instead of loading the app inside every embed by @backnotprop in #1561
  - feat(ui): the Workspaces diagram viewer becomes the diagram engine (ui 0.41.0, core 0.25.4) by @backnotprop in #1560
  - fix(code-nav): stop excluding source packages named vendor/target/build by @backnotprop in #1559
  - fix(ui): load the diagram engine lazily, and keep the canvas controls out of the diagram; ui 0.41.1 by @backnotprop in #1562
  - docs(skills): canonical zoomable diagram shell for visual-explainer by @FNDEVVE in #1551
  - feat(review): add support for patch/diff files by @soundvibe in #1554
  - fix: three release-QA findings: PATCH validation, dark-theme printing, and the root vendor/ exclusion by @backnotprop in #1564
  - feat(ui): tone the Mermaid node shadow to 70 and derive its colour from the palette by @backnotprop in #1563
  - fix(annotate): scope the framed 404 to paths that name a file, so a VS Code session renders the app by @backnotprop in #1565
  New Contributors
  - @soundvibe made their first contribution in #1554
  Contributors
  
  @soundvibe built patch-file review in #1554, a clean first contribution: the server refuses every repository-dependent endpoint with a clear error instead of crashing, nothing writes the patch to disk, and semantic diff works on the patch alone. The browser-side gating was layered on before merge, and the design underneath is his.
  
  @FNDEVVE landed two more, bringing the count to twelve: the element context validator move in #1549, which lets the Workspaces app share the same code instead of copying it, and the diagram shell reference for the visual-explainer skill in #1551, which fixes a class of caption overlap he had reported himself in #1546.
  
  The reports that shaped this release:
  - @buptwlh reported the vendor package exclusion in #1558 with a two-command ripgrep reproduction; the fix and its follow-up both use his exact directory shape as the regression test
  Thank you. Plannotator gets better because you tell us where it falls short.
  
  Full Changelog : v0.27.15...v0.27.16
12. 🔗 New Music Releases Philip Glass - Philip Glass for Cello rss
  Philip Glass - a new release is available:
  - 2026-09-18: Philip Glass for Cello (Album)
  Amazon: Canada | Deutschland | France | United Kingdom | United States
  
  Visit muspy for more information.
13. 🔗 New Music Releases O.A.R. - Three Tinted Windows rss
  O.A.R. - a new release is available:
  - 2026-09-18: Three Tinted Windows (Album)
  Amazon: Canada | Deutschland | France | United Kingdom | United States
  
  Visit muspy for more information.
September 17, 2026
1. 🔗 r/LocalLLaMA Ternary Bonsai 2 (27B) just released on Hugging Face. At <6GB in size, it can even run locally in-browser on WebGPU. rss
  
  | The model is derived from Qwen3.8-27B, a 27B hybrid-attention causal language model (architecture unchanged), but uses ternary weights to shrink model size down to <6GB in size. According to the model card, it's 9x smaller than FP16 while retaining 98.2% of the intelligence.
  - Collection: https://huggingface.co/collections/prism-ml/bonsai-2
  - Demo: https://huggingface.co/spaces/webml-community/ternary- bonsai-2-webgpu-kernels submitted by /u/xenovatech
  [link] [comments]
  ---|---
2. 🔗 r/LocalLLaMA Thank you :) Swift Qwen 3.8 27B now has 100k+ downloads, is #1 finetune and #9 model on HuggingFace Trending rss
  
  | Hey everyone, Jovan from UkisAI here, a small lab building the tech to make tiny frontier LLMs possible (and doing it open-source!) The purpose of this post is simply to thank the community for all the amazing finetunes, quantizations and overall improvements over our original release which made our model get attention and the support for us to continue building in this direction! If it weren't for you guys going out of the way to contribute we wouldn't have half the results of this. For context: Swift Qwen 3.8 27B is our first open-source model release. It is proof of how penalizing pathological overthinking patterns inside of small LLMs can bring their token usage down -58.3% and speed x1.95 without losing accuracy by not training them to think shorter directly but rather to think more efficiently. We are continuing to build and are about to drop: - Swift1.5 Qwen3.8 27B (an improved checkpoint of the model with some training bugs fixed and more RL) - Swift Qwen3.8 Flash Next in the upcoming week week, we are now running the benchmark suite to not give out premature or incomplete results. This time we ran even more benchmarks as you guys suggested, including more coding and long horizon! It would be amazing if those of you who tried Swift would let us know what quants, features, changes you want to see in our upcoming model releases so we can do it better this time as we didn't even think about half of the stuff you guys were requesting last time :) Let the era of non-slop finetunes begin! EDIT: Links - https://huggingface.co/ukisai/Swift-Qwen3.8-27b https://huggingface.co/ukisai/Swift-Qwen3.8-27B-GGUF https://huggingface.co/bartowski/ukisai_Swift-Qwen3.8-27b-GGUF submitted by /u/Secure_Recording_472
  [link] [comments]
  ---|---
3. 🔗 HexRaysSA/plugin-repository commits sync repo: +4 releases, -4 releases rss
```
sync repo: +4 releases, -4 releases

## New releases
- [ida-mcp](https://github.com/hexrayssa/ida-mcp): 2026.917.2, 2026.917.1
- [ida-nexus](https://github.com/hexrayssa/ida-nexus): 0.12.2, 0.12.1

## Changes
- [ida-codemode](https://github.com/hexrayssa/ida-codemode):
  - removed version(s): 0.5.2, 0.5.1, 0.5.0, 0.4.1
```
4. 🔗 Barre/ZeroFS v2.3.4 release
  What's Changed
  - Reduce copies in frame encoding and segment uploads by @Barre in #630
  - Write extent tombstones only for extents that exist by @GlazingAlgorithm in #625
  Full Changelog : v2.3.3...v2.3.4
5. 🔗 r/LocalLLaMA I literally built the Jev architecture one year back and completely open-sourced it with model, dataset and paper rss
  
  Update: I made a generic model and beaten the jev in all of the benchmarks. Code and details available at https://www.reddit.com/r/LocalLLaMA/s/bbwyiOprUs
  
  Everyone now talks about the architecture that's not auto regressive and does lightning fast probability prediction with a json schema. I worked on this literally one year back in March 2025, published an arxiv paper, pushed the model to huggingface along with the pypi package and training dataset. And then one year later, a
  
  frontier lab came, proposing the same idea like literal breakthrough without technical papers, open weights and no open dataset. I posted my approach in this subreddit. For anyones information the main guiding model is RL not embedding model or LLM
  
  Reddit post: https://www.reddit.com/r/LocalLLaMA/s/6eGEwsAz43
  
  Paper: https://arxiv.org/abs/2503.23303
  
  Model: https://huggingface.co/DeepMostInnovations/sales-conversion-model- reinf-learning
  
  Dataset: https://huggingface.co/datasets/DeepMostInnovations/saas-sales- conversations
  
  Also the second work published in September 2025 was exactly the same one jev proposed now
  
  Paper: https://arxiv.org/abs/2510.01237
  
  My model uses PPO over sequence embeddings to output turn-by-turn conversion trajectories (probabilities from 0.0 to 1.0).
  
  Jev uses parallel sampling (trained via RLCD) to output confidence distributions and schema choices.
  
  It's incredibly frustrating that the thing that you made with months of hard work, sweat and sleepless night is architecturally similar with the vertical use case and don't get the support you deserve because frontier lab build something horizontal. The open-source story in general 🙂
  
  submitted by /u/Nandakishor_ml
  [link] [comments]
6. 🔗 r/LocalLLaMA I literally built the Jev architecture one year back and completely open-sourced it with model, dataset and paper rss
  
  Update: I made a generic version. Full details at https://www.reddit.com/r/LocalLLaMA/s/bbwyiOprUs It includes code, benchmark and hf repo
  
  Everyone now talks about the architecture that's not auto regressive and does lightning fast probability prediction with a json schema. I worked on this literally one year back in March 2025, published an arxiv paper, pushed the model to huggingface along with the pypi package and training dataset. And then one year later, a
  
  frontier lab came, proposing the same idea like literal breakthrough without technical papers, open weights and no open dataset. I posted my approach in this subreddit. Links are. For anyones information the main guiding model is RL not embedding model or LLM
  
  Reddit post: https://www.reddit.com/r/LocalLLaMA/s/6eGEwsAz43
  
  Paper: https://arxiv.org/abs/2503.23303
  
  Model: https://huggingface.co/DeepMostInnovations/sales-conversion-model- reinf-learning
  
  Dataset: https://huggingface.co/datasets/DeepMostInnovations/saas-sales- conversations
  
  Also the second work published in September 2025 was exactly the same one jev proposed now
  
  Paper: https://arxiv.org/abs/2510.01237
  
  My model uses PPO over sequence embeddings to output turn-by-turn conversion trajectories (probabilities from 0.0 to 1.0).
  
  Jev uses parallel sampling (trained via RLCD) to output confidence distributions and schema choices.
  
  It's incredibly frustrating that the thing that you made with months of hard work, sweat and sleepless night is architecturally similar with the vertical use case and don't get the support you deserve because frontier lab build something horizontal. The open-source story in general 🙂
  
  submitted by /u/Nandakishor_ml
  [link] [comments]
7. 🔗 Rust Blog Be alert: targeted attacks on prominent Rustaceans rss
  
  We believe that there is an ongoing campaign targeting rust-lang members and owners of popular crates that is attempting to compromise devices and accounts in order to use them to publish malware.
  
  What we've seen
  
  A video call is set up for something positive — maybe for a job, maybe for a project, maybe for a contract opportunity — and then that's used as a vector to either get the target to install something on their computer (such as a purportedly missing audio codec) or execute another command (for example, via putting a command on the clipboard).
  
  These attackers are setting up new but legitimate seeming company profiles, including plausible LinkedIn presences, in order to pass cursory inspection.
  
  A previous attack of this form targeted many prominent Rust developers in June, and, last month, the arrayref crate was briefly compromised through similar attacks. At this moment we do not know if these are all a part of the same campaign.
  
  This attack style is known to be used by the DPRK, and has been seen outside of the Rust community as well.
  
  What you can do
  
  Please take extra care in the near term. Be appropriately suspicious of cold outreaches, and ensure that any calls you have with new people are on platforms you trust — ideally, try to be the one who sets up the call on a platform you already use.
  
  Please also re-check that your accounts look normal: MFA enabled, no unexpected logins on platforms that can track that, and so on.
  
  If you have any concerns about your accounts, please reach out to help@crates.io (for crates.io account concerns) and/or security@rust-lang.org (for any other concerns). We're very happy to help.
8. 🔗 seanmonstar Micro: Reading LLM text makes us worse writers rss
  
  The top advice given to anyone wanting to get better at writing, besides just writing, is to read more. Especially good writing. Because we imitate that which we experience more of.
  
  So then, perhaps obviously but it took way too long for me to realize, reading LLM output influences how we write. And since writing is thinking, it seeps in, ablating the voice in my head. I’m, as one says, horrified.
  
  I value LLMs for their ability to understand hyper-specific search queries. But I want to consider how much of the generated text I read; it’s better to read the human source. Or other non-forced exposure.
  
  Reply via: Email · Bluesky · Mastodon
9. 🔗 Console.dev newsletter htmx 4 rss
  
  Description: Enhance HTML.
  
  What we like: Simplifies the approach to adding attributes to HTML tags for dynamic features. Now uses fetch(). Makes it easy to implement features like infinite scroll, form post, search as you type, polling, and streaming responses. Still pretty minimal (11kb) and no dependencies.
  
  What we dislike: Lots of attributes littered all over your HTML, but that is the point.
10. 🔗 Console.dev newsletter Solo rss
  
  Description: Loader for Linux static binaries.
  
  What we like: Makes static binaries for GPU-accelerated code actually work. Makes it easy to build self-contained applications that can benefit from acceleration. Compile to musl, but still use common shared packages.
  
  What we dislike: Incomplete ABI coverage: unsupported glibc calls currently abort. Musl has its own compatibility issues.
11. 🔗 Ampcode News One Runner Is Now Enough rss
  A runner can now serve many directories, not just the one it was started in. You can point it at specific projects and directories or let it find your Git repositories.
  
  Start a runner and tell it which directories to serve with --dir. Repeat the flag for each one:
```
$ amp --no-tui --runner-id mac-mini --dir ~/code/amp --dir ~/code/sandcastle
```
  Or start it in the directory that holds your checkouts and let it find them:
```
$ cd ~/code
$ amp --no-tui --runner-id mac-mini --discover-dirs
```
  --discover-dirs serves every Git checkout up to two levels beneath the current directory and picks up new ones as you clone them.
  
  Checkouts somewhere else, or deeper than two levels? Give --discover-dirs a path, repeat it for more, and set --discover-depth to look further down:
```
$ amp --no-tui --discover-dirs=~/work --discover-dirs=~/code --discover-depth 4
```
  Add or remove directories while the runner is running, without restarting it:
```
$ amp runner dirs add ~/code/new-repo
$ amp runner dirs list
$ amp runner dirs remove ~/code/dotfiles
```
  The runner remembers the directories you add this way and serves them again the next time you start it from the same directory.
  
  Oh, They Can Update Themselves Too
  
  Runners now update themselves too. If you leave an amp --no-tui runner running, it keeps checking for new releases about once an hour and installs them. Once no thread is running on it, it restarts into the new version, at most once every 12 hours. It keeps its runner ID, its directories, and the rest of its flags.
  
  Turn it off with amp.runner.autoUpdate.enabled: false in your settings.
  
  Read more about serving multiple directories and runner updates in the runner docs.
September 16, 2026
1. 🔗 OmniNull/OmniWM OmniWM v0.7.0 release
  What's New Since 0.6.10
  
  OmniWM 0.7.0 adds trackpad window controls, an interactive Overview, more appearance options, and configurable display priorities.
  
  Highlights
  - Overview matches Mission Control 1:1. Its opening and closing behavior is an exact 1:1 recreation of native macOS Mission Control, based on fully reverse-engineering that behavior. Swipe up to open and down to close, catch an animation mid-flight, or release early to cancel. The gesture is off by default : enable Overview with three or four fingers in Settings → Mouse & Trackpad → Trackpad Gestures. Overview also retains thumbnails for reopening, closes toward the selected window, and lets you drag thumbnails between workspaces without holding Option. (#666)
  - Move and resize windows without clicking. New opt-in trackpad gestures work with tiled windows in both Niri and Dwindle. Choose two, three, or four fingers in Settings → Mouse & Trackpad → Trackpad Gestures; Set Up… helps resolve conflicting assignments. (#678)
  - Gradient borders and glow. In Settings → Workspace → Borders , customize two-color gradients, optional glow, and separate light and dark appearance colors. Enabling a gradient replaces the solid border color. Colors follow macOS appearance changes; glow leaves layout spacing and resize hit areas unchanged. (#648)
  - More workspace bar styles. Adjust inactive icon opacity, choose transparent or solid black backgrounds, and toggle item backgrounds and accent highlights globally or per display. Fill Left of Notch fills the menu-bar area left of the notch, covering application menus; without a notch it uses the left half of the menu bar. This mode ignores Position, Offset, Height, and Reserve Space, and always hides on displays showing native fullscreen content. (PR #669)
  - Choose your preferred displays. Rank monitors in Settings → Monitors so Main, Secondary, and the new Tertiary workspace role follow your preferred connected displays. Quake Terminal's Main Monitor destination follows the same ranking. (PR #663)
  - Redesigned tab rails. Compact indicators include window details on hover. Enable app icons directly on tab rails to identify mixed-app groups in either layout. (PR #635, #588)
  - Quake Terminal hyperlinks. Command-click an OSC 8 hyperlink to open http/https links in your default browser or mailto links in your mail app. Other schemes are blocked. (PR #702)
  - Nushell completions. Generate command and argument suggestions with omniwmctl completion nu on Nushell 0.108 or newer.
  Improvements and fixes
  - Focus command palette search when it opens so you can start typing immediately.
  - Restore keyboard focus when switching to an already-visible workspace after OmniWM's Mouse Warp moves the pointer between displays. Also preserve focus when transferring windows between workspaces. (PR #661)
  - Fix the Niri column strip shifting when clicking or Command-Tabbing into a window while another app on that workspace is hidden with Command-H. (PR #640)
  - Restore the configured Niri single-window fit after neighboring windows close or move to another workspace. (#668)
  - Prevent residual trackpad scrolling from reaching applications after workspace gestures. (PR #637)
  - Correct Quake Terminal scaling when moving between Retina and non-Retina displays. (PR #679)
  - Avoid misclassifying newly discovered windows when fullscreen-button accessibility reads temporarily fail.
  - Avoid repeated waits on apps already reported as unresponsive when rescanning windows after launch, unlock, or display changes.
  Upgrading
  
  Recommended gesture setup: Turn off native macOS Mission Control in System Settings → Trackpad → More Gestures to free its gesture for OmniWM's new 0.7.0 gestures. Disable other overlapping native gestures, such as App Exposé, when using the same fingers. Keep Displays have separate Spaces enabled; that is a separate setting OmniWM still requires.
  
  Window Resize defaults to three fingers, which conflicts with the three-finger Column Scroll enabled by default, so its row initially offers Set Up…. To keep Column Scroll, choose another finger count for Resize—for example, two fingers , which can intercept normal scrolling in apps. Move and Resize each need an unused finger count; Overview and Move also conflict if both use their default four fingers. Overview may share fingers with a horizontal swipe, but not a conflicting upward swipe. Use Set Up… to resolve overlaps.
  
  Editingsettings.toml: Conflicting gesture assignments cause the entire configuration file to be rejected. At launch, OmniWM uses built-in defaults for every setting; while it is running, the invalid edit is ignored and the last accepted settings stay active. Configuration remains at schema 3 , and the new trackpad gestures, border effects, tab-rail app icons, and monitor ranking are opt-in.
  
  Reduce Motion: OmniWM now honors macOS Reduce Motion throughout the app. If it is already enabled, upgrading disables OmniWM animations, including Overview's finger-tracked transitions and Quake Terminal's slide. Enable Animations is unavailable while Reduce Motion is on; your saved OmniWM preference is preserved.
  
  Scripts and shell completions: IPC remains at protocol 15. switch- workspace, switch-workspace-slot, switch-workspace-anywhere, and omniwmctl workspace focus-name now return executed instead of no_change when the workspace is already visible but keyboard focus needs to be handed back. Regenerate saved Bash, Zsh, and Fish completions with omniwmctl completion bash, omniwmctl completion zsh, or omniwmctl completion fish to pick up the updated suggestions. Shells that generate completions at startup pick up the changes when reloaded.
  
  Thanks
  
  Thank you to YeungKC, Cypress, Taylor Bell, Fletcher Alderton, Henrik Larsson Hestnes, minchik, Matt Wicks, mattpetters, Brian Smyth, MateuszJuszczyk, and t1dotdev for contributing to this release.
  
  Full changelog: v0.6.10…v0.7.0
2. 🔗 OmniNull/OmniWM OmniWM v0.6.10 release
  What's New Since 0.6.9
  - Added a separate OmniWM Dev installation with independent settings and state, plus commands to switch between development and release builds.
  - Simplified contributor setup with checksum-verified dependencies, make setup, make doctor, and automated macOS verification and tests.
  - Fixed development-tool lookup and Swift 6.4 compilation issues affecting task-local code and optimized builds.
  - Reorganized runtime, settings, and integration code and expanded regression coverage.
  - Updated configuration, feature, CLI, and architecture documentation and added contributor and website development guides.
  - Updated contributor credits and credited sponsor b-allan-w.
  Official website and documentation: https://omniwm.app
  Installation guide: https://omniwm.app/guides/install/
  
  Release Integrity
  
  OmniWM is signed with Developer ID, notarized by Apple, and includes a stapled notarization ticket.
  - OmniWM-v0.6.10.zip — SHA-256: 10eef893077d210d1545f5775a2b92b2f366df61db4fbd8abc22b3ab1d08c4af
  - GhosttyKit.xcframework-v0.6.10.zip — SHA-256: 4cc414f1b76c7f9ffe13dd5b047cf9deb8bd182e33e522045c7d939ff1cd151f
3. 🔗 r/LocalLLaMA Qwen 3.8 27B Running for 63 hours on a RTX 3090 to solve the Riemann hypothesis rss
  
  I let Qwen 3.8 27B 4bit quantized with 100K context window run autonomously for 63 hours (50 million+ tokens) to try to solve the RH.
  
  Of course it did not solve it, but the experiment still shows it's internal work, memory organization, strategies used and more.
  
  The interesting thing is that it never hallucinated an answer and never stopped trying new ideas to solve it.
  
  Multiple times it corrected it's own mistakes.
  
  I am really hopeful that one of the unsolved millenium prize problems will be solved by an agent or a swarm of agents powered by an open source model in the next 12 months.
  
  If you want to check out it's internal memories, code, strategies and more I published everything on HF: https://huggingface.co/datasets/gr0010/artificium-riemannhypothesis- experiment
  
  My next goal is to actually use an agent perhaps powered by a smarter open model like GLM 5.3 flash or a swarm of agents, to solve an open math problem.
  
  Please let me know if you tried something similar, what problem you'd suggest to tackle next, and if you have any question.
  
  If you have GPUs consider getting in touch with me, we could run multiple agents to create a swarm and get them to tackle a simple yet open math/coding problem.
  
  submitted by /u/GuiltyBookkeeper4849
  [link] [comments]
4. 🔗 r/LocalLLaMA Xiaomi MiMo 2.6 Live Training Dashboard rss
  
  Cool to see this as it happens!
  
  submitted by /u/skeole
  [link] [comments]
5. 🔗 facebookresearch/faiss v1.15.1 release
  
  See CHANGELOG.md for the full list of changes.
6. 🔗 r/LocalLLaMA China's open-weight AI models are now just 4 months behind frontier US offerings, Mozilla report claims — models still lag in some benchmarks but are drastically cheaper to use rss
  
  | submitted by /u/DustNearby2848
  [link] [comments]
  ---|---
7. 🔗 HexRaysSA/plugin-repository commits sync repo: +2 releases, -1 release rss
```
sync repo: +2 releases, -1 release

## New releases
- [ida-nexus](https://github.com/hexrayssa/ida-nexus): 0.11.2
- [mcrit-ida](https://github.com/danielplohmann/mcrit-plugin): 1.1.10

## Changes
- [ida-codemode](https://github.com/hexrayssa/ida-codemode):
  - removed version(s): 0.4.0
```
8. 🔗 r/LocalLLaMA Hey, Meta. Where's those Muse Spark weights? rss
  
  | It was well over a month since Meta promised to release the weights for Muse Spark. Back then (10th August), they were on Spark 1.2. Now we're on 1.3 and still nothing's been released. So it begs the question: will they be releasing the 1.2 weights when 1.4 drops? Or will we get whatever's then-current as open weights? It's ironic given Mark Zuckerberg said at the same time that we can't delay the release of models by "even a month," due to the competition with China. It's been well over a month. He was arguing in the context of new regulations delaying models, but I think it applies equally to the open weights contest as it does to the closed models one. After all, the Chinese models are all open. That's the competition and point of comparison. Have Meta given any sort of explanation for why they're sitting on the weights or how much longer it'll take for them to honour their promise? Will we even get them in light of all the attempts at regulatory capture and dire warnings about how AI is dangerous? submitted by /u/RishiFurfox
  [link] [comments]
  ---|---
9. 🔗 New Music Releases Trivium - Dead Inside of Me rss
  Trivium - a new release is available:
  - 2026-09-16: Dead Inside of Me (Single)
  Amazon: Canada | Deutschland | France | United Kingdom | United States
  
  Visit muspy for more information.
10. 🔗 New Music Releases Thy Catafalque - Búcsú a piros madártól rss
  Thy Catafalque - a new release is available:
  - 2026-09-16: Búcsú a piros madártól (Single)
  Amazon: Canada | Deutschland | France | United Kingdom | United States
  
  Visit muspy for more information.