Signal Radar

2026-10-15

Tech news with the retellings removed: first-party announcements, measured numbers, and things you can use today.

196papers read
→
25shortlisted
→
12must-read

150 s · 178,486 input tokens · ≈ $0.0075 · jev-1.13.0 via typesafe

Must-read ≥ 90%

98%releasereleases-llama-cpp

llama.cpp b11636

github-actions[bot]

Measured result 98%First-party 81%Usable today 81%
Abstract

sycl: IQ3 code reorder ( #29107 ) sycl: persistent IQ3_S/IQ3_XXS weight reorder for SYCL decode and prefill Add persistent reordered weight layouts for IQ3_S and IQ3_XXS. Weights are reordered once at load time; the reordered MMVQ dot products then walk dense super-blocks with dp4a and SWAR sign expansion instead of gathering bits from the interleaved standard layout. Reorder-aware dequantization feeds the batched prefill GEMMs so prompt processing sees the same benefit. Also harden the oneDNN build check: a missing DNNL package or a CPU-only DNNL build now fails at configure time instead of silently producing a degraded backend. Measured on Intel Arc Pro B70 with Qwen3.8-27B-GSQ-RCO-IQ3_S (MTP), -ngl 999 -b 4096 -ub 1024 -fa on: tg256 @ 0 ctx 12.92 -> 23.54 tok/s (+82%) tg256 @ 9,216 12.33 -> 21.69 tok/s (+76%) tg256 @ 64,000 9.76 -> 14.91 tok/s (+53%) pp8192 833.9 -> 833.6 tok/s (flat) Qwen3.5-9B Q4_K_M / Q3_K_M are unchanged within noise (largest delta -0.5% pp, tg flat), so standard quants are not affected. The MMVQ GLU fusion widening and rms_norm+scale fusion are intentionally not part of this change; master already carries them via #28931 . removing wait as per review request sycl : fix fusion.cpp line ending Website: https://llama.app Attestations: https://github.com/ggml-org/llama.cpp/attestations/56116978 macOS/iOS: macOS Apple Silicon (arm64) macOS Apple Silicon (arm64, KleidiAI enabled) DISABLED macOS Intel (x64) iOS XCFramework Linux: Ubuntu x64 (CPU) Ubuntu arm64 (CPU) Ubuntu s390x (CPU) Ubuntu x64 (Vulkan) Ubuntu arm64 (Vulkan) Ubuntu x64 (CUDA 12) - CUDA 12.8 libraries Ubuntu x64 (CUDA 13) - CUDA 13.4 libraries Ubuntu arm64 (CUDA 13) - CUDA 13.4 libraries Ubuntu x64 (ROCm 10.0) Ubuntu x64 (OpenVINO) Ubuntu x64 (SYCL FP32) Ubuntu x64 (SYCL FP16) Linux arm64 (Snapdragon: CPU, Adreno GPU, Hexagon NPU) - setup guide Android: Android arm64 (CPU) Android arm64 (Snapdragon: CPU, Adreno GPU, Hexagon NPU) - setup guide Windows: Windows x64 (CPU) Windows arm64 (CPU) Windows arm64 (OpenCL Adreno) Windows x64 (CUDA 12) - CUDA 12.4 DLLs Windows x64 (CUDA 13) - CUDA 13.4 DLLs Windows arm64 (CUDA 13) - CUDA 13.4 DLLs Windows x64 (Vulkan) Windows arm64 (Vulkan) Windows x64 (OpenVINO) Windows x64 (SYCL) Windows x64 (ROCm 10.0) openEuler: DISABLED openEuler x86 (310p) openEuler x86 (910b, ACL Graph) openEuler aarch64 (310p) openEuler aarch64 (910b, ACL Graph) UI: UI

rss:dfca8fcb97f0bdeaUseful?👍👎
97%releasehn

Show HN: Petal, open-source CoScreen/ScreenHero finally free

thedracle

Usable today 97%First-party 76%
Abstract

Hi HN! I’m Jason Thomas, one of the founders of CoScreen. As some of you may know, Datadog sunset the CoScreen service on July 31st. Four of us from the original CoScreen team have spent the last couple months building a free and open source pair programming tool inspired by those that came before us: It’s called Petal ( https://github.com/kiruna-labs/petal ) Some history first, because when we started CoScreen we had hoped to break the sad and established pattern of this industry. Screenhero was an exceptional tool that a lot of us loved for pairing. Multiple cursors, low latency, you could click your partner’s editor, and just start typing. It felt like magic while we had it. Then Slack bought it in 2015, and shut down the standalone app in December 2017. When Till, Max, and I started CoScreen, we were aware of this history, and wanted to build an even more magical collaboration and screen sharing experience: the entire concept was “throw a window from your laptop up on someone else’s screen, and start collaborating with zero friction.” Datadog acquired us in 2022, and thus began the great adventure of adapting our real-time technology into Datadog products, while also continue developing CoScreen as a standalone tool from the Datadog ecosystem. Datadog invested in the product for years and we’re thankful for that. But CoScreen itself proved, like so many other screen sharing tool acquisitions, to be too tangential from the customer base and core mission. We instead built other communication features in Datadog, the integrations with other video platforms, and also its wildly successful MCP server. We weren't the only ones. Around was bought by Miro and shut down in March 2025. Multi (formerly Remotion) was acqui-hired by OpenAI in 2024 and shut down about a month later. It's nearly always the same story: a small team builds something hard that people love, a platform buys it for the team or the feature, and the standalone product doesn't survive the integration. So we decided firmly to do things differently this time. Petal is completely free and open source and we aren't monetizing it. If we lose interest or get hit by a bus, you can self-host it or fork it, and nobody can sunset it on you. Honestly it's a love letter to everyone in this community that supported us, believed in us, and to liberate collaborative screen sharing from this vicious cycle. We hope through this we can help foster a large and vibrant community around innovating in this product sector. What Petal does: shared windows show up as real windows on your desktop, movable and resizable, not tiles in a grid. Several people can share at once, everyone gets a labeled cursor, and you can click into any shared window to type and scroll. Rooms are persistent, so you click once to join "eng-sync" instead of passing links around. It runs on macOS and Windows (Linux is next, this time for real and you can help us!), plus a web app. Media goes over LiveKit. You can use our hosted instance with zero config, or point the app at your own LiveKit server with one docker-compose if you want the traffic to stay on your network or even use an entirely different video backend if you want to. The part that still feels strange to us: CoScreen took almost six years to build. The first version of Petal took under eight weeks, from scratch, with frontier models like Fable and Astra doing a lot of the work. Real-time video and window capture is some of the most unforgiving code we have ever written, so we didn't expect that. We will do a proper writeup on what worked and what didn't, and are happy to answer questions about it here. Till, Darren, Max and I will be in the thread. Comments URL: https://news.ycombinator.com/item?id=50092470 Points: 154 # Comments: 36

rss:02d40dc978646ab3Useful?👍👎
96%measurementreddit-releases

Minimax H3 Character Swap: Time Consumption and Performance Test Across Different Acceleration Schemes

/u/Mysterious_Pride_858

Measured result 96%Usable today 49%
Abstract

Tech Step Cost Sampling Cost Turbo LoRA 4 632.448s 602.129s Turbo+Sol 4 717.549s 579.753s Turbo+Spark-H3 4 682.326s 652.085s Turbo+VEDA 4 353.355s 321.554s Sol (Only) 16 2309.627s 2280.068s Spark-H3(Only) 16 2441.209s 2411.523s VEDA(Only) 16 993.426s 963.193s Test Environment: RTX 5090 + 96 GB RAM. The reference video has a total duration of 18 seconds; only the first 15 seconds were tested, with a resolution of 1MP. The tests are driven via Codex Sol 6.1, so the results may not be rigorous. Workflow link: https://github.com/wangweihong/comfyui-ecosystem/tree/main/workflows/006%20%E8%A7%86%E9%A2%91%E7%94%9F%E6%88%90/minimaxh3/BFS-Character-Swap/%E5%8A%A8%E4%BD%9C%E5%8F%82%E8%80%8315%E7%A7%92_%E5%8A%A0%E9%80%9F%E5%AF%B9%E6%AF%94 submitted by /u/Mysterious_Pride_858 to r/StableDiffusion [link] [comments]

rss:8f29ef0a9295b4aaUseful?👍👎
94%measurementreddit-ai

Google's Gemini 4 Argon takes #1 in understanding the physical world beyond what it sees. It can reconstruct past events, predict what happens next, and infer hidden objects and human intentions. Argon scored 59.1% on long videos, versus under 41% for rivals, while its spatial reasoning jumped 21 po

/u/141_1337

Measured result 94%
Abstract

submitted by /u/141_1337 to r/singularity [link] [comments]

rss:ef94733aed039a15Useful?👍👎
93%measurementreddit-ai

GPT-6 Astra autonomously solves 49 out of 50 unpublished theoretical physics research problems, scoring 98% at under $3 per problem. Researchers initially marked several answers wrong, only to discover the AI had caught errors in the calculations of world-class physicists.

/u/lovesdogsguy

Measured result 93%
Abstract

submitted by /u/lovesdogsguy to r/accelerate [link] [comments]

Same story elsewhere (1)
rss:e281173ee1fc763cUseful?👍👎
93%measurementreddit-ai

GPT-6 Astra Autonomously Solved 49/50 Unpublished Theoretical Physics Research Problems (@ Under $3 Per Problem)

/u/44th-Hokage-

Measured result 93%
Abstract

Link to the Paper: TheoPhysEval: Assessing AI agents at autonomous theoretical physics problem solving submitted by /u/44th-Hokage- to r/accelerate [link] [comments]

rss:af39b1c765d309e0Useful?👍👎
93%releasereddit-releases

Fizgig 8 is out - A web UI finally! One app for your PC, your other PCs, and RunPod

/u/shootthesound

Usable today 93%First-party 60%
Abstract

Every PC, one app. Fizgig finds your other computers on your network by itself. Train on the desktop's 5090 from your laptop, send a dataset across in one click, and see what every machine is training and what's queued. Web UI. Its own window, or any browser. Start a run at your desk and check it from the sofa or your phone: live loss, previews, time left. RunPod, built in. Your pods are listed and it logs you in. It shows which cards are free right now, ranked by cost per run, deploys in one click, sends your dataset up from your own PC, and can stop the pod when the run's done. Plus: the queue on every tab, every run kept with its settings, and a block-by-block LoRA editor. Updating keeps everything you had. LoRAs and full fine-tunes for Klein 9B, Krea 2, MiniMax H3, Qwen Image 2.1, Z-Image, SDXL, Anima and ACE-Step. Free and open source. GitHub 80-second tour What's new EDIT: Patched a few bugs, missing help text, missing input on the edit/sliders etc.. There will likely be a few updates for a few days lol. submitted by /u/shootthesound to r/StableDiffusion [link] [comments]

rss:dfb87b4c246ad26cUseful?👍👎
93%opinionbluesky39 likes · 8 reposts · 2 replies

Formlabs Has a 3D Printer for Normies

WIRED · @wired.com, buff.ly · discussion

Measured result 93%Usable today 80%
Abstract

The Form Studio 1 is a $699 desktop-sized printer that fits on a desk and only stinks a little bit. Linked page: The Form Studio 1 is a $699 desktop-sized printer that fits on a desk and only stinks a little bit.

bsky:97ea6f14a466b218Useful?👍👎
92%announcementbluesky25 likes · 3 reposts · 2 replies

Honey, Xbox shrunk its controller

The Verge · @theverge.com, theverge.com · discussion

Measured result 92%Usable today 68%
Abstract

Microsoft's Xbox Nano controller is $49.99 and designed for gaming on the go. www.theverge.com/news/1011216... Linked page: The Xbox Nano is designed for gaming on the go

bsky:7c95182942df4f87Useful?👍👎
92%releasereleases-ollama

ollama v0.40.5

github-actions[bot]

First-party 92%Usable today 74%
Abstract

What's Changed mlx: port the Metal custom kernels to CUDA by @dhiltgen in #18657 docs: model recs and language standardization by @anra8571 in #18981 openai: accept custom tool calls in Responses history by @hoyyeva in #18911 app: clarify cloud payment errors by @willietran in #18986 MLX: version bump by @dhiltgen in #18993 New Contributors @willietran made their first contribution in #18986 Full Changelog : v0.40.4...v0.40.5-rc0

Same story elsewhere (3)
rss:3aec6950f84e7848Useful?👍👎
91%releasereddit-ai

Event2Vec: additive event embeddings where a linear score on a history decomposes exactly into per-event terms [P]

/u/sulcantonin

Usable today 91%
Abstract

I've been working on Event2Vec, a small library for learning embeddings of discrete event sequences (purchases, logs, clinical codes, etc.) with a deliberately simple structure: a history is the running sum of its event vectors. h_t = h_{t-1} + e_{x_t} (norm-clipped) p(x_{t+1} | h_t) = softmax(W h_t + b) Training is self-supervised next-event prediction, plus a reconstruction term that asks h_t - h_{t-1} to recover e_{x_t} . No labels needed (details why the machinery works are in NeurReps@NeuralIPS Workshop paper , it is a bunch of losses that attempts the reconstruction and obey the arithmetic during training)) The history is a sum, any linear model on top of it is also a sum. For instance, a churn or risk score (see teaser ) score = w·h + b = Σ_i (e_i·w) + b One might question, e 1 +e 2 = e 2 +e 1 = e 3 , but training is, so while vector embedding in (Euclidean) space is commutative, the training isn't. Furthermore, there are several alternative spaces that are gyro/non-commutative, that are part of the library (checkout the website ) hyperbolic (Möbius addition), for hierarchies κ-stereographic, one curvature dial from hyperbolic through flat to spherical (Bachmann et al., 2020) spherical, for cyclic structure SO(n) rotations, which are non-commutative, so order changes the endpoint Heisenberg group, same endpoint but a signed-area coordinate that records order products of the above I started this for root-cause analysis of fault sequences at the Advanced Light Source (Berkeley Lab), where I'd been naively using Word2Vec on event logs and needed directionality without going to an opaque sequence model. Links Paper: arXiv 2509.12188 Code (MIT): github: event2vec_public , pip install event2vector Docs with interactive figures: event2vec.com scikit-learn-style API ( fit / transform , gensim-style most_similar ), PyTorch backend, runs on CPU/CUDA/MPS submitted by /u/sulcantonin to r/MachineLearning [link] [comments]

rss:dfdacf2c81409e8bUseful?👍👎
91%announcementreddit-releases

I built an MCP server with Claude Code that lets Claude search and apply to jobs. Here’s how the build went (and what you can learn)

/u/Cojj25

Usable today 91%Measured result 85%First-party 82%
Abstract

In August I posted here about a job search platform I started building with Claude Code after Indeed laid off my wife. The most common question afterward was “cool, but can I do this from inside Claude?” So we built an MCP server, again mostly with Claude Code. It launched last Thursday and now has 450 users with 75 daily active. We're also seeing 83 interviews per 100 paid subscribers (who use autopilot) since our X announcement. It was a cool build I wanted to share. What it does You add the MCP and can instantly start searching the jobs database for free, drop a resume in to see matches, get custom tailored resumes, and have our back end submit on the employer’s own site once you approve. You can set a schedule to have your agent give you new matches every day (we pull in about 15K new jobs per day). How we built it entirely with Claude (and what you can mimic) Create one capability list for the web app and the MCP. Claude Code built a typed registry of everything a user can do on the Dreamwork website. Each MCP tool is generated from that registry, so a feature added to the web app shows up in the MCP. If a capability is deliberately kept out of the MCP, the code has to state why or it doesn’t compile. Start with a mega-PR series on day 1. I wrote a handoff doc describing the server I wanted, based on the web app. Claude Code split it into 12 PRs, one per capability: search, application prep, readiness checks, document handling, submissions, inbox, and so on. Each PR ran integration tests against our real Postgres. Create a hosted version with OAuth. Claude Code wrote the HTTP server and an OAuth 2.1 sign-in flow (dynamic client registration and PKCE), so you can add it as a connector in claude.ai without pasting an API key. Note for discoverability: you have to submit connectors to Anthropic for approval for them to show up in the connector library. This is a necessary prerequisite for that. Figure out what can and can't be done in the chat UI. We had to figure out how to send edited resumes to users that kept the formatting of the PDF. We ended up deciding on delivering a download link that lasts for 10min because the specialized formatting that we use to increase interview chances wouldn't pass through if the local agent rewrote it. Dogfood hard. We used the connector in Claude ourselves, applied to real jobs (and got interview offers with fake resumes...oops), wrote down 20 things that felt wrong, then 10, then 5, then 1, then o. When you get your first power users, ask them how things are going! After we thought we were down to bug zero, we got our first set of power users who then recommended another 30+ changes that we've since implemented. Because LLMs are probabilistic, you really need to continue testing and iterating and fixing over time. The number of scenarios power users will run into that you didn't think of is mind boggling. Free to try Job search, setting up notifications for new matches, resume editing and many other features are free via the MCP. You only have to start paying for the auto-submission feature - those tokens are expensive. To try it out ask your agent to add this: npx -y u/dreamworkhq/mcp or add https://mcp.dreamworkhq.com/mcp as a custom connector in claude.ai or Claude Desktop (Settings > Connectors) More info here: https://www.dreamworkhq.com/agents submitted by /u/Cojj25 to r/ClaudeAI [link] [comments]

rss:d31887fd02527916Useful?👍👎

Maybe 80% to 90%

89%releasehn

We’re releasing Jev 1.14.0 along with experimental features for dreamers

emschwartz

First-party 89%Usable today 63%
Abstract

Article URL: https://typesafe.ai/blog/jev-1-14 Comments URL: https://news.ycombinator.com/item?id=50095353 Points: 261 # Comments: 85

rss:700f9632b615d959Useful?👍👎
88%measurementreddit-ai

The AI race: China's open-weight models trail US closed models by just 7 months

/u/jakecoolguy

Usable today 88%First-party 47%Measured result 44%
Abstract

Source: whatmodel.sh , an open source AI leaderboard I built (and launched here yesterday). Every point comes from published benchmark results: 22,113 of them across 987 benchmarks, from 1,011 sources, each one linked to where it was published. This chart uses data for the text models: 18,755 results for 1,211 models on 617 benchmarks. - 14,436 results are independent evaluations: papers whose authors ran the models themselves (mostly CC BY papers from the ACL Anthology and arXiv), Epoch AI, the LMArena dataset, EvalPlus, the EleutherAI harness and others. - 7,677 are scores labs report for their own models, labelled as lab-reported. Everything is open: the dataset (CC BY-SA 4.0) and the scoring code (MIT) are at https://github.com/jakemanger/whatmodel , with CSV downloads at https://whatmodel.sh/data/manifest.json . Every number links back to its source, and each source's licence is recorded. Interactive version (click any model to see its scores and sources): https://whatmodel.sh/race Please star on github if you find it useful! submitted by /u/jakecoolguy to r/LocalLLaMA [link] [comments]

rss:06fffd69f83e7744Useful?👍👎
85%analysisreddit-ai

A 35B multimodal model running on a phone with ~3GB memory? MiniCPM-V 4.7 demo is pretty wild

/u/Equivalent-Grass-527

Usable today 85%First-party 47%
Abstract

Just saw this demo from OpenBMB for MiniCPM-V 4.7 , and the on-device capability is pretty impressive. A 35B-A3B MoE vision-language model running locally on mobile devices is already interesting, but the use cases are what caught my attention: 📷 Reading real-world signs 📄 Understanding complex documents 🧠 Reasoning over visual information 🗺️ Planning with real-world constraints The key piece seems to be LES (Lookahead Expert Scheduling) — instead of just making the model smaller, they optimize MoE inference by predicting and preloading experts to reduce bottlenecks. They also released a smaller MiniCPM-V 4.7 1B model for more resource-constrained devices. Another interesting addition is Self-Replay Fine-Tuning (SRFT) , which aims to let developers customize the model for specific tasks while keeping general capabilities. The direction is interesting: instead of sending every image/question to the cloud, we're getting closer to having capable multimodal assistants running directly on phones. Links: GitHub: https://github.com/OpenBMB/MiniCPM-V Hugging Face: https://huggingface.co/collections/openbmb SRFT details: https://openbmb.cn/en/blog/self-replay-fine-tuning submitted by /u/Equivalent-Grass-527 to r/LocalLLaMA [link] [comments]

rss:6b46f3e2db9cb5c4Useful?👍👎
85%announcementhn

LFM2.5-24B-A2B: Built for fast on-device agents

gmays

First-party 85%Usable today 36%Measured result 32%
Abstract

Article URL: https://www.liquid.ai/blog/lfm2-5-24b-a2b Comments URL: https://news.ycombinator.com/item?id=50097369 Points: 162 # Comments: 38

rss:f2b15b791b00ca9eUseful?👍👎
83%measurementreddit-releases

Taking Krea-2 apart, one piece at a time

/u/ItalianArtProfessor

Measured result 83%Usable today 67%
Abstract

Hellow fellow AI-generated goblins of r/StableDiffusion For a few weeks I’ve been stress-testing my tool, Arthemy Krea-2 Tuner: https://github.com/aledelpho/comfyui-arthemy-krea2-tuner I wanted to investigate if nudging the weights of single blocks of Krea-2 can teach us something about its internal structure. https://preview.redd.it/ouhfy67e1gvh1.png?width=1600&format=png&auto=webp&s=d96358fb07c9b2d6e81145d79cf93d5aa8c1bb61 I worked on two parts: the model and the text encoder (I only started on the last one recently but it seems much more interesting than the previous one) . The underlying question was whether the models already holds “ knobs ” that change style, look, colours or literally anything else in the image, without training anything. After weeks of work and thousands upon thousands of renders I found a grand total of… one ! (underwhelming, I know, but better than nothing) The upside, if something cool comes out of it: It’s still sci-fi at this point, but if we manage to map the inside of a model this way, we might be able to make presets that do the job of a small fine-tune with nothing trained: the presets I use now are 34 numbers, a few hundred bytes, against the tens or hundreds of MB of a typical LoRA. I know the approach is crude. It’s like shooting a car with a shotgun to understand how it works. But it can still tell where the windows are (they make a specific noise) and which parts are vital. Breaking a piece and watching what stops working is an old trick in interpretability and it tells where something happens, not how . Said so: when we know so little about these models, I don’t think that’s useless. Of course, I fixed the test rules before looking at the data, and I started summoning my girlfriend (who doesn't know anything about AI or what I'm trying to do) to do the most important blind tests. Limits: one model, almost always one observer (yours truly) , small samples. When a conclusion goes beyond the data, I mark it with "🔎" that’s a lead, not proof. TEXT ENCODER 1. Text-encoder edits change what is drawn (genre, style, who the character is) and hurt image quality much less than edits to the drawing model Each row is one character with the same seed and prompt. Left: the original. Right: the same seed after DOUBLING one layer of the text encoder. Nothing gets noisy or broken, but the style and even the person change, and the same layer pushes the two characters in different directions. This part I measured : with standard quality metrics, text-encoder edits don’t make the image worse, while a preset on the drawing model does. Even at full strength (x2.0), no picture fell apart. In exchange, they are less “consistent”: the same edit pushes different characters in different directions. Only 4 edits out of 20 moved them all the same way. 🔎 My impression is that instead of damaging the picture, these edits break the links between the words of the prompt. I tried to test it, but on the images I had I couldn’t define it consistently, so I need renders made for the purpose. 2. Anime isn’t the only fallback for illustration. https://preview.redd.it/rr88gxsmvfvh1.png?width=1600&format=png&auto=webp&s=2cb02f9546af6ed1ca194d5d779ac5b5b82d50d3 People often say that "anime" is the default of almost every model when it comes to illustration. In Krea-2 it isn’t. ( 🔎 I was surprised because I was coming from Anima and Illustrious where Anime seems to be a stronger "default" fallback) When I removed the style words from the prompt, one character became anime every time, while seven others turned into paintings or photographs: each one has its own fallback. Weight edits, on the other hand, don’t lead to the character’s fallback . Each edit has its own destination (one towards realism, one towards cartoon), whoever is being drawn. 🔎 My hypothesis: every concept falls back on the style, and the traits, that the model has seen with it most often. A text-encoder edit doesn’t seem to push toward one default, but toward some of the styles that concept already lives near. That would explain why a character can change style so heavily, but only within a small set: my "elf" prompt turned into comics, anime or cartoons, never into a photo, while the same edit turned most other characters realistic. What I found points that way, though it doesn’t prove it. I have no access to Krea-2’s training data, and the same effect could come from an aesthetic fine-tuning stage or from the text encoder’s own associations. Some clues: Single words, generated on their own, carry preconceptions: “female dwarf” gets a beard 4 times out of 4 (Gimli approved); “uniform” becomes an anime schoolgirl; “western” draws cowboys. What a surprise, right? When I alter the text encoder, characters lose their specific traits first and drift towards a more “average” version later. My half-orc becomes an ordinary human woman, still drawn as a comic and THEN it loses its style. A random push of the same strength doesn’t do this: it depends on where the edit points, not on how strong it is. https://preview.redd.it/qcsmi2l42gvh1.png?width=1600&format=png&auto=webp&s=debb17fb96f0d7f172800b123468b5224d99776a 3. Commas seem to act as borders https://preview.redd.it/yhfsnolzvfvh1.png?width=1600&format=png&auto=webp&s=9936729238e8c722726b2e39cc74e94cc121c374 When I edit the text encoder, the meaning the model gives each word shifts a little . The shift has two parts. One is the same for the whole prompt, like a filter laid over everything. The other is local: neighbouring words move together in packets of 2–4, and the packets tend to break exactly where there’s a comma. For example, in “dark green hooded cowl, brass buckles”, “dark green hooded cowl” moves as one block and “brass buckles” as another. 🔎 This might suggests the text encoder uses commas to decide which words belong together. For prompt writers that could be an important lead: maybe putting an object and its colour inside the same comma-phrase helps keep them bound. But I measured this on the numbers the text encoder hands to the image model, not on the pictures. I haven’t yet checked whether moving commas actually changes the result, or by how much. 4. Shuffled prompts (still under study). 🔎 Edits to the drawing model seem to give more or less the same look even when the phrases of the prompt are shuffled, but that test came out inconclusive. With the text encoder it depends on the edit: some send every phrase order to the same result, others scatter them across different genres. I don’t know why yet, I’m working on it. Each column shows the same prompt with its phrases rearranged. the first row shows the baseline and it gives you an idea about what I was supposed to get - now take a look at the last row ... what the hell is going on? it's the same edit! 5. Switch off the first layer of the text encoder, and the model writes your prompt instead of drawing it. https://preview.redd.it/dint6566kgvh1.png?width=1600&format=png&auto=webp&s=ee191728324fa575da5402e445b19aea89e3e072 With the attention of layer 0 switched off, Krea-2 drew pages of text in 4 prompts out of 4, with readable fragments of the prompt (“close-up”, “frontal view”; in the cleanest case realistic western comics style and the prompt’s own Lighting: section). Switching off the MLP did it in 2 of 4. Switching off the whole layer gave no text at all, only repeating noise. So it isn’t “the model sees raw words and writes them”: it takes a half-broken layer, and I don’t know why . https://preview.redd.it/qd0dy7r7kgvh1.png?width=1600&format=png&auto=webp&s=b29e3c557573e86b60826a02afb43d91d0c9428e THE MODEL 1. Different blocks do different things. https://preview.redd.it/yp5xuef73gvh1.png?width=1600&format=png&auto=webp&s=c3c3834a958a27226acca9e9e75efe088da9bd26 The last blocks touch colour and grain. The middle ones change the content, and you can push them harder with fewer visual defects: surface damage in 19% of cases, against 79% for the last ones. They’re not free, though. 2. Block 23 alone works as a saturation knob. Writing “colorful” or “high saturation” in the prompt changes the content much more. That said, it works less well than a correction in post-production (afterall these aren't true knobs, just approximations of knobs) . it can still be useful to tweak it, if your merges tend, on average, towards colours that are too vivid or too dull. https://preview.redd.it/aqdfpmh5wfvh1.png?width=1600&format=png&auto=webp&s=332042b7652ea03c3c3e1e3d84f70d2f4ad2e059 3. A specific calibration of the weights keeps its look even on characters it has never seen. I calibrated a set of weight shifts by eye (a preset) on four portraits and applied it to three new characters. Someone who didn’t know which image carried the preset picked it as closer to the look I had described 56 times out of 56. Faces do change a bit more than a change of seed would. The Preset: It was meant to be a very light touch towards animation: flatter colours, simpler lines and shapes. CONFIRMED WITH PRE-REGISTERED TESTS Renders reproduce identically, pixel for pixel , even days apart, and the tuner at zero adds nothing. It sounds trivial, but everything rests on it: the differences come from the edit, not from the pipeline. Without this, the whole study would have been pointless. You can predict how much an image will change without rendering it , by measuring how far the edit moves the text encoder’s output (correlation 0.71 and 0.80). It works mostly for telling different kinds of edit apart. Quality metrics don’t see everything. DINOv2, BRISQUE and the like missed exactly the content changes made by the middle blocks, which were obvious by eye. On top of that, I haven’t yet found a reliable automatic “impartial judge”: in my attempts with LLMs, the judgements weren’t trustworthy. So for now I look at many images by hand, like a primitive. WHAT’S NEXT? I don’t know whether any of this holds for other models, but it’s not yet time to experiment on other architectures. First I want to collect many properties of these shifts, to have solid ground (and to understand what they’re really doing) . Then I’ll check whether they hold on models with different architectures. If they do, they would be properties of diffusion models in general. One last tip for those interested in asking Claude or Gemini for help. I'm not afraid to say that I use LLMs to help me produce the data, and I’ve already seen some problems: numbers quoted from memory (with all the errors that brings) and hasty conclusions. If you want to run experiments with Claude Code or Antigravity, have the AI write only scripts. That way the numbers never pass through the “generative” side of the AI, only through linear processes that you run yourself, outside its environment. The full report, with every image and the things that turned out to be wrong: https://aledelpho.github.io/diffusion-models-weight-steering-report/results/index.html I'll let you know if something interesting comes out from it, Cheers! submitted by /u/ItalianArtProfessor to r/StableDiffusion [link] [comments]

rss:d481201b0511ce1cUseful?👍👎
83%releasereleases-llama-cpp

llama.cpp b11640

github-actions[bot]

Usable today 83%First-party 81%
Abstract

vulkan: Use L2-friendly workgroup scheduling for cm2 mulmat ( #30215 ) Website: https://llama.app Attestations: https://github.com/ggml-org/llama.cpp/attestations/56139256 macOS/iOS: macOS Apple Silicon (arm64) macOS Apple Silicon (arm64, KleidiAI enabled) DISABLED macOS Intel (x64) iOS XCFramework Linux: Ubuntu x64 (CPU) Ubuntu arm64 (CPU) Ubuntu s390x (CPU) Ubuntu x64 (Vulkan) Ubuntu arm64 (Vulkan) Ubuntu x64 (CUDA 12) - CUDA 12.8 libraries Ubuntu x64 (CUDA 13) - CUDA 13.4 libraries Ubuntu arm64 (CUDA 13) - CUDA 13.4 libraries Ubuntu x64 (ROCm 10.0) Ubuntu x64 (OpenVINO) Ubuntu x64 (SYCL FP32) Ubuntu x64 (SYCL FP16) Linux arm64 (Snapdragon: CPU, Adreno GPU, Hexagon NPU) - setup guide Android: Android arm64 (CPU) Android arm64 (Snapdragon: CPU, Adreno GPU, Hexagon NPU) - setup guide Windows: Windows x64 (CPU) Windows arm64 (CPU) Windows arm64 (OpenCL Adreno) Windows x64 (CUDA 12) - CUDA 12.4 DLLs Windows x64 (CUDA 13) - CUDA 13.4 DLLs Windows arm64 (CUDA 13) - CUDA 13.4 DLLs Windows x64 (Vulkan) Windows arm64 (Vulkan) Windows x64 (OpenVINO) Windows x64 (SYCL) Windows x64 (ROCm 10.0) openEuler: DISABLED openEuler x86 (310p) openEuler x86 (910b, ACL Graph) openEuler aarch64 (310p) openEuler aarch64 (910b, ACL Graph) UI: UI

rss:d1c5fa40c59c072cUseful?👍👎
83%releasereleases-llama-cpp

llama.cpp b11633

github-actions[bot]

Usable today 83%First-party 72%
Abstract

ggml-cpu : size set_rows conversion buffer for all threads ( #30454 ) ggml-cpu : size set_rows conversion buffer for all threads SET_ROWS is planned with n_tasks = 1, but every thread runs it and uses its own row of the F16 -> F32 conversion buffer, so threads > 0 wrote past the work buffer when the graph had another multi-threaded op. move set_rows to n_task = n_threads group Website: https://llama.app Attestations: https://github.com/ggml-org/llama.cpp/attestations/56100739 macOS/iOS: macOS Apple Silicon (arm64) macOS Apple Silicon (arm64, KleidiAI enabled) DISABLED macOS Intel (x64) iOS XCFramework Linux: Ubuntu x64 (CPU) Ubuntu arm64 (CPU) Ubuntu s390x (CPU) Ubuntu x64 (Vulkan) Ubuntu arm64 (Vulkan) Ubuntu x64 (CUDA 12) - CUDA 12.8 libraries Ubuntu x64 (CUDA 13) - CUDA 13.4 libraries Ubuntu arm64 (CUDA 13) - CUDA 13.4 libraries Ubuntu x64 (ROCm 10.0) Ubuntu x64 (OpenVINO) Ubuntu x64 (SYCL FP32) Ubuntu x64 (SYCL FP16) Linux arm64 (Snapdragon: CPU, Adreno GPU, Hexagon NPU) - setup guide Android: Android arm64 (CPU) Android arm64 (Snapdragon: CPU, Adreno GPU, Hexagon NPU) - setup guide Windows: Windows x64 (CPU) Windows arm64 (CPU) Windows arm64 (OpenCL Adreno) Windows x64 (CUDA 12) - CUDA 12.4 DLLs Windows x64 (CUDA 13) - CUDA 13.4 DLLs Windows arm64 (CUDA 13) - CUDA 13.4 DLLs Windows x64 (Vulkan) Windows arm64 (Vulkan) Windows x64 (OpenVINO) Windows x64 (SYCL) Windows x64 (ROCm 10.0) openEuler: DISABLED openEuler x86 (310p) openEuler x86 (910b, ACL Graph) openEuler aarch64 (310p) openEuler aarch64 (910b, ACL Graph) UI: UI

rss:20f39f3dc1e9a39dUseful?👍👎
82%announcementhn

Better HTTP/1 connection reuse in Go 1.27

allddd

First-party 82%
Abstract

Article URL: https://go.dev/blog/http-connection-reuse Comments URL: https://news.ycombinator.com/item?id=50090369 Points: 234 # Comments: 34

rss:571c7aac33fa3819Useful?👍👎
82%releasereleases-llama-cpp

llama.cpp b11639

github-actions[bot]

Usable today 82%First-party 79%
Abstract

opencl: support CLAMP on non-contiguous views ( #30186 ) The clamp kernel indexed source and destination as one flat contiguous array, so a strided view as input (the new CLAMP v=1 case) read the wrong elements. Add a strided kernel_clamp_nc, as the other unary ops have, and take it whenever the source is not contiguous. Website: https://llama.app Attestations: https://github.com/ggml-org/llama.cpp/attestations/56132091 macOS/iOS: macOS Apple Silicon (arm64) macOS Apple Silicon (arm64, KleidiAI enabled) DISABLED macOS Intel (x64) iOS XCFramework Linux: Ubuntu x64 (CPU) Ubuntu arm64 (CPU) Ubuntu s390x (CPU) Ubuntu x64 (Vulkan) Ubuntu arm64 (Vulkan) Ubuntu x64 (CUDA 12) - CUDA 12.8 libraries Ubuntu x64 (CUDA 13) - CUDA 13.4 libraries Ubuntu arm64 (CUDA 13) - CUDA 13.4 libraries Ubuntu x64 (ROCm 10.0) Ubuntu x64 (OpenVINO) Ubuntu x64 (SYCL FP32) Ubuntu x64 (SYCL FP16) Linux arm64 (Snapdragon: CPU, Adreno GPU, Hexagon NPU) - setup guide Android: Android arm64 (CPU) Android arm64 (Snapdragon: CPU, Adreno GPU, Hexagon NPU) - setup guide Windows: Windows x64 (CPU) Windows arm64 (CPU) Windows arm64 (OpenCL Adreno) Windows x64 (CUDA 12) - CUDA 12.4 DLLs Windows x64 (CUDA 13) - CUDA 13.4 DLLs Windows arm64 (CUDA 13) - CUDA 13.4 DLLs Windows x64 (Vulkan) Windows arm64 (Vulkan) Windows x64 (OpenVINO) Windows x64 (SYCL) Windows x64 (ROCm 10.0) openEuler: DISABLED openEuler x86 (310p) openEuler x86 (910b, ACL Graph) openEuler aarch64 (310p) openEuler aarch64 (910b, ACL Graph) UI: UI

rss:ba551940ac5c587fUseful?👍👎
82%releasereleases-llama-cpp

llama.cpp b11632

github-actions[bot]

Usable today 82%First-party 80%
Abstract

cuda, hip: GDN chunked kernel ( #29353 ) cuda, hip: GDN chunked kernel Ported-from: tetherto#257 Source-commit: 53f0027 Co-authored-by: Aman Gupta aman.gupta@tether.io fix older builds review fixes cuda: enable GDN MMA on tested Ampere and Ada GPUs Enable SM86 and SM89 after RTX 3090 and RTX 4090 correctness and prefill benchmarks. Keep other untested architectures on the existing fallback. Assisted-by: Codex cuda : use refactored swizzle API in GDN MMA ggml : GDN only guarantees the final state when n_tokens > K cuda : add short GDN MMA phase comments Co-authored-by: gianni-cor gianfranco.cordella@tether.io Co-authored-by: Aman Gupta aman.gupta@tether.io Website: https://llama.app Attestations: https://github.com/ggml-org/llama.cpp/attestations/56096976 macOS/iOS: macOS Apple Silicon (arm64) macOS Apple Silicon (arm64, KleidiAI enabled) DISABLED macOS Intel (x64) iOS XCFramework Linux: Ubuntu x64 (CPU) Ubuntu arm64 (CPU) Ubuntu s390x (CPU) Ubuntu x64 (Vulkan) Ubuntu arm64 (Vulkan) Ubuntu x64 (CUDA 12) - CUDA 12.8 libraries Ubuntu x64 (CUDA 13) - CUDA 13.4 libraries Ubuntu arm64 (CUDA 13) - CUDA 13.4 libraries Ubuntu x64 (ROCm 10.0) Ubuntu x64 (OpenVINO) Ubuntu x64 (SYCL FP32) Ubuntu x64 (SYCL FP16) Linux arm64 (Snapdragon: CPU, Adreno GPU, Hexagon NPU) - setup guide Android: Android arm64 (CPU) Android arm64 (Snapdragon: CPU, Adreno GPU, Hexagon NPU) - setup guide Windows: Windows x64 (CPU) Windows arm64 (CPU) Windows arm64 (OpenCL Adreno) Windows x64 (CUDA 12) - CUDA 12.4 DLLs Windows x64 (CUDA 13) - CUDA 13.4 DLLs Windows arm64 (CUDA 13) - CUDA 13.4 DLLs Windows x64 (Vulkan) Windows arm64 (Vulkan) Windows x64 (OpenVINO) Windows x64 (SYCL) Windows x64 (ROCm 10.0) openEuler: DISABLED openEuler x86 (310p) openEuler x86 (910b, ACL Graph) openEuler aarch64 (310p) openEuler aarch64 (910b, ACL Graph) UI: UI

rss:18539ec7ca24bce0Useful?👍👎
81%businessreddit-ai

Ben Affleck actually understands AI architecture, explains why he sold his AI company to Netflix for $587M

/u/oemsyrup · discussion

Measured result 81%
Abstract

Ben Affleck sat down for a surprisingly technical interview discussing tensors, convolutional neural networks, and why video generation scaling is entirely different from LLMs. submitted by /u/oemsyrup to r/singularity [link] [comments]

rss:68b797d481a58f16Useful?👍👎
81%releasereleases-llama-cpp

llama.cpp b11635

github-actions[bot]

Usable today 81%First-party 76%Measured result 65%
Abstract

ggml-cpu : keep the FP16->FP32 lookup table on x86 with F16C ( #30342 ) ( #30343 ) ggml-cpu : keep the FP16->FP32 lookup table on x86 with F16C ( #30342 ) #30270 routed both scalar conversions through F16C. For FP16->FP32, Clang 20.1.8 lowers the intrinsic to a vpinsrw merging into the live accumulator register of the quantized dot products, which serialises the loop (19 vs 4 cycles/iteration estimated, 45-65% slower Q8_0/Q4_0 MUL_MAT_ID kernels measured). Keep F16C for FP32->FP16 as intended and the table for FP16->FP32. ggml-cpu : comment out the F16C FP16->FP32 define instead of removing it (review) Website: https://llama.app Attestations: https://github.com/ggml-org/llama.cpp/attestations/56105849 macOS/iOS: macOS Apple Silicon (arm64) macOS Apple Silicon (arm64, KleidiAI enabled) DISABLED macOS Intel (x64) iOS XCFramework Linux: Ubuntu x64 (CPU) Ubuntu arm64 (CPU) Ubuntu s390x (CPU) Ubuntu x64 (Vulkan) Ubuntu arm64 (Vulkan) Ubuntu x64 (CUDA 12) - CUDA 12.8 libraries Ubuntu x64 (CUDA 13) - CUDA 13.4 libraries Ubuntu arm64 (CUDA 13) - CUDA 13.4 libraries Ubuntu x64 (ROCm 10.0) Ubuntu x64 (OpenVINO) Ubuntu x64 (SYCL FP32) Ubuntu x64 (SYCL FP16) Linux arm64 (Snapdragon: CPU, Adreno GPU, Hexagon NPU) - setup guide Android: Android arm64 (CPU) Android arm64 (Snapdragon: CPU, Adreno GPU, Hexagon NPU) - setup guide Windows: Windows x64 (CPU) Windows arm64 (CPU) Windows arm64 (OpenCL Adreno) Windows x64 (CUDA 12) - CUDA 12.4 DLLs Windows x64 (CUDA 13) - CUDA 13.4 DLLs Windows arm64 (CUDA 13) - CUDA 13.4 DLLs Windows x64 (Vulkan) Windows arm64 (Vulkan) Windows x64 (OpenVINO) Windows x64 (SYCL) Windows x64 (ROCm 10.0) openEuler: DISABLED openEuler x86 (310p) openEuler x86 (910b, ACL Graph) openEuler aarch64 (310p) openEuler aarch64 (910b, ACL Graph) UI: UI

rss:061826ab7ddf49b9Useful?👍👎
80%analysisreddit-industry

A failed launch took me from €0 to €16,000 total (No Promotion)

/u/Extra-Donkey-9152

Measured result 80%First-party 46%
Abstract

Launched on Product Hunt a few months ago. Built the whole thing solo for about €1,000. Assumed if I just shipped it and posted everywhere, users would show up. They didn't. The launch completely flopped. Hardly any upvotes. Was pretty gutted for a day or two. But a few people left feedback. Honest, specific, and a bit brutal. I stopped treating it like a failed launch and treated it like a free audit. It forced me to ask questions I'd been avoiding. Why is the onboarding only clear to me? Why am I wasting weeks marketing on platforms my buyers don't even use? What happens in the first 60 seconds after someone lands on the page? What's actually solving a problem versus what I just thought was cool to build? Had to actually find the answers. Some were uncomfortable. The marketing channels I'd spent weeks grinding on were complete dead ends. The features I thought were clever were just creating friction. I was building in an echo chamber and calling it traction. But fixing those blind spots uncovered strengths I'd completely missed. Once the core value was obvious, people actually converted. Users who got past the initial friction stuck around. Stopping the spammy marketing gave me time to talk to the niche that actually cared. This month the dashboard hit €€3,278 MRR. Today it sits at €16,000. life-changing money, and meaningful money. Profitable. The launch failed, but the clarity was worth way more than a #1 badge. Highly recommend letting strangers tear your product apart early and asking yourself the uncomfortable questions. You'll save months of guessing. submitted by /u/Extra-Donkey-9152 to r/SaaS [link] [comments]

rss:43d0ccc35b4b40f2Useful?👍👎
Near misses (10): just under your maybe bar, useful for tuning thresholds
Filtered by your exclusions (66)