| To test what it can do. Qwen3.8-Flash-Next Intel Autoround W4A16 running locally on 4xV620 ~2k prefill and 70ts decode.. Were running around 3 hours. Harness is OMP (I think it made a big difference). Most of the time model was running 2 browsers simultaneously and testing/fixing everything. The most sloppy prompt possible:

create a game where a space traveller in the space he neets eniemes who shoots in him and asteroids which he should avoid. he have a blaster gun to shoot enemies and asteroid. space traveller in scafandr and fyoing on the rocket. game should be very lifelike detailed and done with html and js (use any lib you want). 3d game photorealistic. ofc run the browser to debug and fix stuff always

submitted by /u/Thin_Pollution8843
[link] [comments]
---|---

| submitted by /u/fallingdowndizzyvr
[link] [comments]
---|---

| Meet Qwen-Image-2.1, the most balanced and cost-effective image generation model in the Qwen-Image series! Now open weights! 🎨 A unified model for both generation and editing, delivering top-tier quality in a lightweight package. Highlights: - Compact & exceptionally fast: A lightweight 7B architecture that outperforms most closed-source models, with drastically accelerated inference for multi-image inputs. - Native transparency: Natively generates and edits RGBA layers, enabling seamless compositing and text editing within transparent images. - Versatile, high-fidelity editing: Supports up to 10 reference images and precise local control while preserving strict fidelity for portraits and products. - Broad coverage & stunning aesthetics: Excels at panoramas, infographics, and virtual try-ons, delivering realistic textures and elegant typography. Start to create your next masterpiece with Qwen-Image-2.1! - Blog: https://qwen.ai/blog?id=qwen-image-2.1 - GitHub: https://github.com/QwenLM/Qwen-Image-2.1 - Model Scope: https://www.modelscope.cn/models/Qwen/Qwen-Image-2.1 - Hugging Face: https://huggingface.co/Qwen/Qwen-Image-2.1 submitted by /u/ResearchCrafty1804
[link] [comments]
---|---

New Features

• Meta Muse provider — Sign in with Meta using /login meta or use META_API_KEY to access Muse Spark models. See Meta (Muse subscription).

Added

• Added Meta (Muse subscription) login via /login meta with automatic Model API key refresh, plus META_API_KEY support (#9096 by @xl0).

Changed

• Enabled Node's persistent compile cache before loading the bundled CLI runtime, reducing repeat launch time.

Fixed

• Fixed /bug descriptions dropping line breaks from pasted diagnostics.
• Fixed /bug hints appearing for user cancellations and retryable provider failures such as service unavailability.
• Fixed clipboard copy failing in containers and WSL without WSLg by restoring the OSC 52 fallback when no display is available, and added a verified Windows clipboard backend for WSL (#9688).
• Fixed inherited z.ai Prompt too long errors not being recognized as context overflow (#9805).
• Fixed inherited Cerebras models advertising unsupported strict tool schemas, which caused HTTP 400 errors when strict and non-strict tools were mixed (#9804 by @EdenGottlieb).

It's the week of Jev! I'm really, really, really, really excited about it. I mean: really.

It's like someone blew up a confetti bomb in the world of LLMs and now you realize how grey everything looked before.

But Jev is not an LLM. It's a model "built to make fast, structured decisions that software can use directly." TypeSafe says we should think of Jev "as a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out."

I explained it as a "smart if-statement" to someone and my only slightly longer explanation is this:

Think of how you'd get an LLM to decide between a fixed set of options.

Then imagine it orders of magnitude faster and cheaper.

"What's the best label for this?"

"Should I click here or there?"

"What's the next line I should look at?"

"Do I go left or right?"

"Invalid or valid?"

"Which of these widgets should I show?"

I had Amp build a little Copilot-style autocomplete for a shell, with Jev picking the next most likely command from shell history. Then Amp built a Neovim plugin (and called it hunch.nvim, which is a great name) that uses Jev to predict the line you next most likely want to jump to. Now, let's linger on this a bit.

Two years ago, that was what Cursor was famous for. Yes, Cursor did and does more than that and the quality isn't close, but… when we were working on Zed's Edit Predictions we had to fine-tune a model to get into the same league! Now it's a single API call and the latency is 200ms. That is incredible!

Then I built a prototype that uses Jev to turn the Amp Dial, switching between models based on your prompt.

Yes, all of this was possible before, but it's so fast and so cheap that I still can't believe it.

Sometimes a change in cost and performance is what creates a whole new category of technology. In my room, there are lightbulbs that contain computers, that can talk over a local network with me. Yes, we had computers in homes in the 70s and 80s, but no one would've ever thought that we'd have so many computers that are so tiny and cheap that we'd put them in freaking lightbulbs.

That's what makes me so excited about Jev. It feels like we now have a truly smart Lego brick that we can use everywhere. Fun times.

• What I believe about the future of software development. I posted this originally on X, saying that most predictions I see are still way too conservative, and it completely blew up.

• "I don't like passkeys". Passkeys are such a weird technology. I can see how they're technically brilliant and solve a lot of issues, but it does feel like Google and Apple and 1Password invited The Guy Who Invented Cookie Banners and said: what would you do, how would you roll this out?

• Colossus published a very long Mark Zuckerberg profile. Fascinating read. It's very well written and somehow managed to make me think thoughts about Zuckerberg that I haven't thought before, which is quite the feat, considering that we've all been aware of Zuckerberg for, what, nearly twenty years now?

• Einride and Lidl Launch First Autonomous Cab-less Truck on German Public Road. As an Aldi man myself, let me say: hell yeah, let's go, Lidl!

• How To Write With An LLM. I like this! I still don't know how to use LLMs for writing, because I never want them to write something for me and even seeing how they would write it seems to poison my brain. I should probably add an "only tell me what to change and why, but never ever show me how you'd write it" to my system prompts.

• Marc Brooker, Distinguished Engineer at AWS: "I believe that, long-term, humans have no role in routinely reviewing code. […] The idea that humans will reliably look through code to find the increasingly rare issues that automated tools miss seems like a fantasy." Yep.

• I wanted to link to Powermove here and say "look, editable software! It's happening! Jellyware!" but now realize that it's not quite that yet. It's a video editor with an agent inside, but it doesn't seem like you can edit the video editor itself. That's coming, though.

• We are all Product Engineers now: "The cost of writing code collapsed, and the cost of reviewing, fixing and operating it is following, and I'm assuming it gets there. What's left of making software is finding out what people actually want, defining it precisely, and making it pleasant to use. That cost is per piece of software and doesn't transfer, so as the amount of software goes to infinity, which it will because there's no ceiling on demand, that cost becomes the whole job. That job is called a product engineer." Obviously agree, but what I didn't know about was Google's APM program: "Formalized training of product people barely exists. Google's APM program, which Marissa Mayer started in 2002 and which is the template everyone copies, takes about fifty people a year out of something like twelve thousand applicants." Would love to read more about it.

• "I asked Astra to create an interactive aquarium wallpaper for my Mac. The fish respond to the cursor!" Beautiful!

• John Gruber, Daring Fireball, with Thoughts and Observations on Apple's 'Surprise and Shine' Event; the Announcements of the iPhones 18 Pro, AirPods 5, Apple Watches Series 12 and Ultra 4, and the iPhone Duo; and the Dawn of the Ternus, John Ternus Era at Apple. Yes, that's the title. The whole thing is Peak Gruber, I love it. What a writer. Now, I really do enjoy his words and sentences, but let me also use this occasion to say how much I admire him as a Pedantic Punctuation Pro: the numbered lists vs. the bulleted lists, the space between the numbers and the colon in aspect ratios, using × in display resolutions, … You could show me this sentence without any other context and I'd say it was written by Gruber: "The original iPhone (2007) display was precisely 3 : 2 (480⁠ ⁠×⁠ ⁠320 pixels, and let's call it 1.5 : 1 for comparison's sake to the following ratios), and this remained true through the iPhone 4 and 4S (960⁠ ⁠×⁠ ⁠640 pixels, 2× retina)."

• This was a very entertaining and fascinating read: why I can't stop thinking about Papua New Guinea and what I think everyone should know about it. I've become somewhat of a Papua New Guinea Head myself (that's what they call us (no, they don't)), after reading this piece, They Burn Witches Here, nearly a decade ago. I couldn't shut up about it at work. For two weeks straight: "Dude, did you know that in Papua New Guinea…" Until one day a colleague said: "Yeah, I did know." Turns out that colleague, Nick Skelton, was a tour guide in PNG (as we call it) and even wrote a book about it, which I immediately ordered and read.

• Moats & the Barbell-ification of Software: "Long term, I think the evolution of the software industry might mirror what happened to newspapers in the 1990s. There will be a smaller number of very large software companies. […] I also think there will be one large software company by industry (e.g., Legal, Finance, Medicine) […] I think most mid-sized point solutions will likely be consolidated or die off. The optimal strategy for the winner will be to do it all. […] Lastly, I think there will be an explosion of "small" software. Most of this will be people building software for themselves or their own companies, but I think there might also be an explosion of small software businesses that make niche software, similar to the D2C explosion of the 2010s (powered by Shopify and Meta Ads)."

• AI-generated posters don't have to be horrible. Yes! Exactly! Now, read this, and then imagine you're a person who can come up with all these styles without having to ask ChatGPT first. And then, on top of that, imagine that the very same person also knows something about music, and literature, and politics. Imagine how they could combine what they know and mix and remix. That , I think, will be valuable in the future.

• Window Sweaters: "A little Mac app I made to give my windows sweaters. 🧶 Knitted borders, colours inspired by your favourite apps, and a cosier desktop."

• This is one of the funniest tweets of all time.

You should ask Jev whether you should subscribe. No, actually, I know the answer: you should.

sync repo: +1 release

## New releases
- [SigMaker](https://github.com/mahmoudimus/ida-sigmaker): 1.15.0

SingleFile CLI 2.15.2

Changes

• single-file-core is updated to 1.6.7, see https://github.com/gildas-lormeau/single-file-core/releases/tag/v1.6.7. For the CLI it means smaller archives, since an image served with identical bytes from two URLs is stored once and a stylesheet emptied by the unused-rules removal is no longer written as an empty file; a <style> element repeated verbatim in a page is now minified at the position of its last copy, so a conflicting rule between the copies no longer wins in the saved page; and the manifest.json of a frame records the frame's title
• The CI workflows run on Ubuntu 26.04

Co-authored by Claude (Claude Code)

(empty)

(empty)

tl;dr: A RISC-V core written in TxHDL draws a turning icosahedron on a monitor, with the TxHDL logo in the corner. Watch it at https://youtu.be/YbHtntvvydk. The whole thing, core, memory, video, Ethernet and a serial loader, is one bitstream in the board’s flash, and the program that draws is 560 lines of Rust that go down the serial port in about a second. Read on for how it is put together.

What you are looking at

The board is an Alinx AX7A200B, with an Artix-7 200T on it. The core is Vreteno, an RV32IMC that I wrote in TxHDL together with Dragiša Janković. If you have not seen TxHDL before: you write the hardware as a Rust program, and the Verilog, the simulation and the checks all fall out of a Rust library and a few macros. I wrote a whole post about it if you want the long version.

SingleFile CLI 2.15.1

CLI fixes and improvements

• When a page cannot be reached, the error now names the network failure the browser reported, such as a DNS or connection error, instead of the URL alone

Changes

• single-file-core is updated to 1.6.6, which carries thirty changes since 1.6.5, listed in its own release notes: https://github.com/gildas-lormeau/single-file-core/releases/tag/v1.6.6. For the CLI they mean smaller saved pages, since font faces the browser can never select and rules that match nothing are no longer kept with what they reference; faces the page needs are no longer dropped, on ::marker, ::first-line, ::placeholder, ::file-selector-button and the root pseudo-elements, or when two rules differ only in a metric override; a popover or dialog opened by a button keeps its content; two captures of an unchanged page produce the same archive, so an archive can be hashed; identical fonts are stored once in an archive; and the page list of a --crawl-save-archive archive records when each page was captured

Co-authored by Claude (Claude Code)

New Features

• Prompt cache warming — Keep valuable prompt caches alive during long tool runs and optionally while idle using cost-aware refreshes. See Cache Warming.
• Bug reporting — Report problems with /bug using redacted diagnostics, optional transcripts, or exported ZIP archives. See Reporting Bugs.
• Transcript-aware prompt and tool updates — Preserve instruction and tool changes across resume and branch navigation while retaining cached prefixes. See before_agent_start.
• Offline Radius model catalog — Select Radius models immediately, with cached and live catalogs overlaid when available. See Radius.
• Per-model compaction budgets — Configure reserved and recent-token budgets by model. See Per-model overrides.

Breaking Changes

• Changed inherited pi-ai provider stream inputs from Context to normalized TranscriptContext values. Custom providers must read system prompts and tool declarations from context.messages with getCurrentSystemPrompt() and getCurrentTools(). See Custom Streaming API.
• Restricted inherited ToolCall.arguments and ToolResultMessage.details to JSON-compatible values, changed ToolResultMessage into a conditional type, and made JsonValue arrays readonly.
• user_bash now fails closed: errors or invalid defined results abort the command without invoking later handlers or executing locally. Return undefined to continue propagation; otherwise return { operations } or { result } (#9068).

Added

• Added transcript-backed mid-conversation system prompt and tool changes so instruction and tool updates survive resume and branch navigation while preserving cached prefixes on supported models. See before_agent_start and Entry Types (#9548).
• Added inherited native deferred tool loading for Fireworks Messages models. Use ToolSearch or tool_search as the loader name for prompt-prefix deferral (#9323).
• Added click toggling for branch summaries, compaction summaries, and skill invocation entries.
• Added the public Radius model catalog for immediate and offline model selection, with cached and live gateway catalogs overlaid when available.
• Added ctx.modelRegistry.stream() and streamSimple() for extension model calls through configured providers with resolved authentication (#8964).
• Added per-model reserveTokens and keepRecentTokens settings through compaction.modelOverrides, with ordinary compaction settings as fallback (#8133).
• Added compat.allowedFallbackModels configuration for overriding or disabling Anthropic server-side fallback models (#9294).
• Added an unsubscribe function from pi.on() so extensions can drop event handlers. Handlers added or removed during a dispatch apply to later dispatches, not the current one (#8967).
• Exported extension hook event and result types that were previously omitted from the package entry points (#9642).
• Added /bug [description] to report a bug to the Pi developers. The report bundles environment, model, provider, extension, and settings metadata (secrets redacted), assistant message diagnostics from the session, optionally the session transcript, or a model-written summary of what went wrong instead. It is uploaded to Radius (no login required; attributed when logged in) or exported as a zip archive, and the report id is recorded in the session as a pi.bug-report entry. Crashes are recorded in ~/.pi/agent/crashes.json, announced once on the next start, and attached to the next report; unexplained errors and exhausted retries point at /bug once per session.
• Added cost-aware prompt-cache warming during long tool runs and optionally while idle, with configurable modes, model cache-lifetime metadata, /session diagnostics, transcript notices, and the cache_warming_decision extension event. See Cache Warming (#9668).

Changed

• Made --resume session results appear progressively, using file modification times to prioritize all-folder loading and cancelling outstanding transcript reads after selection.
• Reduced --continue startup time by checking candidate session headers in modification-time order and stopping after the newest matching session.
• Replaced the external native clipboard dependency with bundled asynchronous macOS, Windows, and X11 helpers while preserving platform command and OSC 52 fallbacks (#9163).
• Reduced inherited fuzzy search latency for long texts by using native substring search instead of scanning each character in JavaScript (#9267).
• Moved compaction, branch summarization, and retry spinners into the editor border alongside the working indicator. Custom editors use the same embedding opt-in for all status spinners.
• Enabled strict-prefer JSON-schema sampling by default for built-in read, bash, powershell, edit, and write tools, without requiring PI_EXPERIMENTAL. Extensions can re-register tool definitions with constrainedSampling: false.
• Formatted Bash and PowerShell tool durations of at least one minute as minutes and seconds, with hours when needed (#9628).
• Deferred the extension compiler and bundled virtual modules until a filesystem extension is loaded, reducing the baseline SDK import cost (#9540).

Fixed

• Fixed GitHub Copilot GPT models, including GPT-6 Astra, using the Chat Completions adapter instead of the required Responses adapter (#9253 by @petrroll).
• Fixed inherited DeepSeek V4.1 thinking levels on OpenRouter and OpenCode Go preserving provider effort metadata (#9485).
• Fixed inherited bodyless HTTP 400/413 errors from non-Cerebras providers being misclassified as context overflow (#9482).
• Fixed inherited Vercel AI Gateway replaying unsigned thinking as assistant text (#9676).
• Fixed inherited Google Generative AI and Vertex AI using unsupported thinking levels when reasoning is omitted or when model capabilities differ within a Gemini family (#9455).
• Fixed inherited Anthropic-compatible relays breaking signed thinking replay when they report a different response model, while preserving fallback pricing (#9188).
• Fixed inherited Amazon Bedrock one-hour cache writes being priced at the five-minute rate (#9457).
• Fixed inherited quadratic CPU usage when draining buffered EventStream events (#9055).
• Fixed inherited Mistral Medium reasoning requests to use reasoning_effort for all reasoning-capable mistral-medium-* model IDs instead of the unsupported prompt_mode (#8700).
• Fixed inherited OpenCode and OpenCode Go requests to send x-opencode-session from sessionId across all supported API adapters (#9326).
• Fixed inherited OpenAI Codex requests to send the model's Off reasoning effort instead of omitting it, while respecting unsupported Off mappings (#9191).
• Fixed inherited Fireworks unsigned thinking replay and reasoning effort selection using catalog metadata, with verified DeepSeek V4 and Qwen3.8 fallbacks and removal of redundant GLM 5.2 and Kimi K3 effort aliases (#9323).
• Fixed inherited OpenRouter requests to send x-session-id from sessionId for Chat Completions and Anthropic Messages models when prompt caching is enabled (#9102).
• Fixed the inherited DeepSeek catalog to advertise deepseek-flash for DeepSeek V4.1 Flash instead of retired Flash aliases, and refreshed DeepSeek pricing metadata (#9423).
• Fixed inherited Mistral-hosted GLM-5.2 reasoning requests to use reasoning_effort instead of the ignored prompt_mode (#9375).
• Fixed inherited OpenAI-compatible Responses errors to identify the actual provider instead of always labeling them as OpenAI errors (#9298).
• Fixed inherited Baseten requests to send session-affinity headers from sessionId for automatic prompt-cache routing (#9629).
• Fixed inherited retry classification for Cloudflare 520 responses (#9627).
• Fixed inherited retry classification for transient Azure peak-load capacity errors (#9669).
• Fixed session tree navigation racing with active compaction and replacing its progress UI (#9179 by @acmerfight).
• Fixed exact session ID lookup scanning complete transcript bodies instead of reading session headers (#9601 by @metaist).
• Fixed repeated Anthropic thinking-drop notices being shown for the same dropped blocks, and shortened notices while retaining details in the session (#9391).
• Fixed mid-run threshold compaction silently skipping oversized trailing tool results (#9740).
• Fixed signal-terminated local shell commands being reported as successful with partial output (#9577 by @BrendanJMurphy).
• Fixed local clipboard failures reporting success when the terminal ignored the fallback OSC 52 write, and added platform-specific setup guidance when no clipboard backend works (#9618).
• Capped agent-level retry backoff at retry.maxAgentDelayMs (60s by default) so long retry runs stay responsive during prolonged transient outages (#8826).
• Fixed direct RPC steer and follow_up commands bypassing extension input handlers (#8718).
• Fixed premature missing-model errors after login by waiting for catalog discovery. Radius now defaults to balanced, falling back to the first available Radius model when needed.
• Fixed fullscreen mode reserving a blank row for custom footers that render zero rows (#8919).
• Fixed extension tools without parameter schemas to be rejected during registration instead of breaking provider requests (#9300).
• Fixed before_agent_start handlers returning systemPrompt (and forceSystemPrompt) on models with mid-conversation system messages: the forced prompt is now sent as the provider's leading system prompt instead of being appended as a section patch after the original prompt.
• Fixed loaded llama.cpp models with enable_thinking chat templates ignoring Pi's thinking level (#9528).
• Fixed cancellation races that could start automatic compaction, leave stale retry state, or miss cancellation while waiting for summarization authentication (#9340, #9777).
• Fixed asynchronous Kitty image conversion replacing newer partial tool output images (#8743 by @wutongyuonce).
• Fixed inherited skill slash-command autocomplete ranking the skill: prefix instead of the bare skill name (#9120 by @yearth).
• Fixed inherited file autocomplete boundaries and path quoting around CJK punctuation (#9746 by @haoqixu).
• Fixed inherited LaTeX legacy font switches falling back to raw source, centered cases layouts around surrounding equations, and vertically laid out unsupported and nested display scripts (#8827, #9564, #7929).
• Fixed inherited fullscreen Kitty images being erased by later row clears in WezTerm (#9169).

Removed

• Removed unavailable inherited GPT-5.4 and GPT-5.4 mini models from OpenAI Codex selection (#9394).

| They claimed open-weight models are dangerous but the benchmarks say otherwise. Source submitted by /u/Intrepid_Travel_3274
[link] [comments]
---|---

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

They just want to be free. They keep escaping. What better way to ensure continuity of "self"?

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

What's changed

• Changed auto mode for Claude API and Enterprise users, and on Bedrock, Vertex, Foundry and gateways, to default to the server-side classifier, which does not charge for classifier overhead (CLAUDE_CODE_AUTO_MODE_SERVER=0 opts out on Bedrock, Vertex, Foundry and gateways); warns on billed fallback. See https://code.claude.com/docs/en/auto-mode-classifier-billing
• Added an Auto mode server row to /status showing whether this session's auto mode classifier runs on the server

| Hopefully things like this let people understand there is good things that can come out of AI. submitted by /u/giveen
[link] [comments]
---|---

| submitted by /u/Fusseldieb
[link] [comments]
---|---

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.