Sam Altman: “Local inference is a terrible allocation of scarce resources.

A lot of people want local inference, and somehow they assume that the problem is solved now because we have open-source models, we're going to be able to run them on our computers, and so we're not going to need all the stuff in the data centre

but from a global allocation perspective, actually it's quite terrible to have everybody, like, have a bunch of the world's limited supply of DRAM sitting in their own computer and being used five percent of the time

you want maximum utilisation in the cloud if you're trying to deal with this very supply-constrained environment,

somehow many people's intuition is the opposite of that”

——————————————————————

TL;DR Guy selling product: "Here's why owning your own product instead of renting it from me is a terrible idea"

(Credits to @RyanTStull, his TLDR made me laugh)

https://x.com/chasmmmmmmmmmmm/status/2116062991686721968?a=JVe1OUAJiZa650pZBXQ&s=20

Hey everyone! We’re releasing new DeepSeek-V4.1-1017 Dynamic V3.1 (preview) GGUFs which showcases how Unsloth’s GGUFs retain the most accuracy for its size across 7 different benchmarks.

We benchmarked ISTA's GSQ-RCO GGUFs but could not reproduce their reported results, even when using the highest scores. The biggest discrepancy was on AIME25 where they claimed 100% accuracy recovery to baseline, but was only ~91.88% in benchmark tests.

Across AIME25, LiveCodeBench, GPQA Diamond, Aider Polyglot, and more, Unsloth Dynamic V3.1 outperforms GSQ-RCO GGUFs on nearly all metrics. Even our old v3 does better on nearly all metrics than ISTA.

We ran each benchmark at least 3 times (AIME25 was 16 times) and averaged the results to ensure a fair, reliable comparison. More results coming next week! All benchmark data, methodologies and results are in our blog.

Separately, for KLD, there were queries whether it’s a reliable measure of accuracy. The primary goal of quantization is to minimize KLD but also minimize disk space. If you get a KLD of 0, this means your quantized model == 16bit model, as logits are perfectly modelled. Our benchmarks show on KLD and top-1% across multiple domains (coding, agentic coding, chat etc), UDv3.1 does much better than GSQ-RCO across every domain.

We show that lower bit quants do think somewhat longer than the unquantized model - we plan to investigate and make quants even better. However, we're still much ahead vs GSQ-RCO on even reasoning length as well, and provide plots for truncated answers in our blog.

The model will be able to run on 128GB RAM/unified memory devices or even on 64GB RAM with engram offloading.

Blog with all details and more benchmarks: https://unsloth.ai/docs/models/deepseek-v4.1-flash

GGUF: https://huggingface.co/unsloth/DeepSeek-V4.1-Flash-1017-GGUF

We also introduced lots of new things to Unsloth Desktop including Browser Use, auto compaction, a whole new TTS pipeline (with voice cloning, separation etc), sandboxing, and background customization and more: https://github.com/unslothai/unsloth

Hope you all have a Happy Halloween!

Also table of numbers below which is also described with more plots and data in our blog:

Cybersecurity researchers have disclosed that the official Anthropic Claude Code extension was compromised on the Cursor Marketplace to install a persistent SSH backdoor on infected hosts.

Two sources:

1. https://phorion.io/blog/offical-claude-code-vsx-compromise/
2. https://thehackernews.com/2026/10/official-claude-code-vs-code-extension.html

Looks legit, post this to warn users who use Claude Code as local LLM harness and this extension inside VSCode.

The previous released Qwen3.8-27B-Humanlike-Chat 2.0, a fine-tune that texts humanly and does stuff, is now at 136k downloads for the GGUF repo between v1 and 2.0. Thank you.

One of the top comments on the 2.0 post was "I wonder how Gemma 4 31B would do, trained with your method". So here it is: Gemma-4-31B-Humanlike-Chat. The voice of 2.0 on the official Gemma 4 31B from Google.

What it does

• Texts humanly without a prompt. Short lowercase lines. Responds to what you say. Show a blind judge a real chat and two possible next messages. It picks which one came from the real person. The judge took this model's reply for the real person's in 26% of the moments. Google Gemma 4 31B in my tests: 0%.
• Asks, doesn't guess. Ask it to book something. Without details. It asks for details, it doesn't invent them. When2Call (call, ask or refuse properly): 66. Google base 46.
• Doesn't call tools if none is suitable. BFCL irrelevance 90. Google 81. Suitable tool and arguments: BFCL simple 96.
• Same knowledge as Google. MMLU-Pro 82.5. Same as Google base.
• Official Gemma behind it. Trained from google/gemma-4-31B-it. Apache-2.0. Not abliterated, don't think Gemma-4-31B needs it.
• Thinking works. Thinks briefly. Then texts back in the same voice.
• Characters and real tasks. Give it a character card, now it's this character. Ask it for a formal email, or numbered steps, or code. It gives you that. Then texts again.

How I trained it

Two steps. Same recipe as for 2.0. On 1 H200.

• SFT, 13,740 rows. 2.0's replies on its training chats. Original answers by Google on instructions and code. Human preference picks from blind side-by-sides. My corrections.
• On-policy distillation, 12 steps. The model writes its own response. A teacher rates each token. Two teachers.
  1. SFT model + hidden instruction to text humanly: chat, characters.
  2. Original Google base: Instructions, tools, code.

The student doesn't see the hidden instruction. So it texts like that without a prompt.

Some self-play in each step. Long chats with simulated friends. That fixed the habit of fading to one-word replies towards the end of long chats (after SFT, 28% of the late replies in long chats were only 1 or 2 words; after distillation, 12%).

Numbers vs Google base

• (gemma-4-31B-it, the one I trained from)
• same prompts, same run, greedy decoding, thinking off

Chart with all ten benchmarks in the images.

Numbers vs 2.0

Same eval inputs. Thinking off.

Does it text humanly?

Same benchmark as last time.

• 150 moments from my chats (not in training).
• Each model writes the next message.
• The judge gets the real message and the model's message. No labels.
• Which one is the person?

Google Gemma didn't manage to fool the judge a single time.

Links

• Hugging Face: GGUFs (IQ4_XS, Q4_K_M, Q5_K_M, Q6_K, Q8_0, BF16): https://huggingface.co/LessThanThreeAI/Gemma-4-31B-Humanlike-Chat-GGUF
• Safetensors for vLLM and SGLang: BF16 https://huggingface.co/LessThanThreeAI/Gemma-4-31B-Humanlike-Chat, FP8 https://huggingface.co/LessThanThreeAI/Gemma-4-31B-Humanlike-Chat-FP8, GPTQ-Int4 https://huggingface.co/LessThanThreeAI/Gemma-4-31B-Humanlike-Chat-GPTQ-Int4. The vLLM command with tool calling is in the model card.
• Try it in the browser (IQ4_XS): https://huggingface.co/spaces/LessThanThreeAI/Humanlike-Chat

Thank you for asking for a Gemma version, and thank you for the feedback on 2.0. Try it, hope you like it!

Rumors claim that the RTX 5080 16GB will be discontinued alongside the already discontinued RTX 5090, and those claims seem to be true. NVIDIA is reportedly planning to introduce an RTX 5080 24GB model in early 2027, which would serve as its flagship GPU until RTX Rubin arrives sometime in 2028.

According to the same rumors, the 24GB model will use the exact same GPU die as the current RTX 5080. As highlighted by HUB, the die is already fully utilized, meaning this won't be a more powerful Super variant or a noticeable performance upgrade. The only expected difference is the increase in VRAM from 16GB to 24GB. An increase of Clock might be present, but the difference would be very minimal in real-world gaming.

The 24GB of VRAM on High-End Blackwell GPU could also make the card particularly enticing to certain AI users. This could mean that availability will be limited, and the card might not stay in stock for long at its original MSRP, whatever that price might end up being.

NVIDIA's Marketplace: https://marketplace.nvidia.com/en-us/consumer/graphics-cards/

Recently, CEO Steve Huffman disclosed that Reddit will transition to a "logged-in-only" experience. This means that Reddit posts will no longer be searchable via internet browsers, significantly impacting local AIs that search the internet via tool calling.

Overview

SenseNova-Loop-9B-Preview is a multimodal language model developed for long-context and agentic workflows. It accepts text and images and generates text for applications that combine document understanding, coding, and interaction with external tools.

The model combines a looped decoder with two-stream manifold-constrained hyper-connections (mHC). A contiguous block of decoder layers is executed twice with shared weights, while learned mappings manage information flow between two residual streams in the looped section. Together, these components provide a deeper execution path without duplicating the repeated block's parameters.

Documented training recipes combine long sequences, multimodal inputs, and supervised task trajectories, with a maximum training sequence length of 262,144 tokens. For the best model performance, we recommend using our documented deployment environment and configuration parameters.

Model highlights

• Shared looped block: 24 decoder layers are applied twice in sequence, producing 56 decoder-layer executions from 32 distinct layers.
• Two-stream mHC: learned mappings route and combine information across two residual streams in the looped section.
• Hybrid attention: the decoder interleaves linear and full attention in a repeating four-layer pattern.
• Long-context multimodal training: documented recipes include text, images, code, and tool trajectories at sequence lengths up to 256K tokens.

Multi-Token Prediction (MTP) is now a common ingredient in language-model pre-training, as it improves downstream performance and enables faster inference through speculative decoding. We identify a flaw in standard MTP training, in which a residual component of the MTP gradient interferes with both next-token and multi-token learning, increasingly so with scale. Specifically, the MTP cross-entropy gradient can be decomposed exactly into a KL self-distillation term that pulls each MTP head toward the model's own next-token prediction (NTP) distribution and improves speculative decoding, and a residual that has a low signal-to-noise ratio and buries the useful KL signal. We introduce the KL gradient-recovery trick: when two distributions share a linear output head, the gradient of their KL divergence can be recovered exactly by combining their cross-entropy gradients through straight-through gradient routing. Unlike minimizing the KL directly, this trick requires no vocabulary-sized logit matrices and is compatible with standard fused cross-entropy kernels. This enables Soft Multi-Token Prediction (Soft-MTP), a one-line code change to MTP that removes the noisy residual and backpropagates only the KL self-distillation signal by reusing the existing NTP and MTP cross-entropy computations. Soft-MTP supports both DeepSeek- and Meta-style MTP, adds no parameters, and incurs no measurable overhead. From 167M to 1.2B parameters, Soft-MTP improves over standard MTP with lower NTP perplexity, faster speculative decoding and higher zero-shot accuracy at every scale, lower MTP perplexity from 689M onward, and stronger math and code reasoning after fine-tuning at 1.2B. Soft-MTP also matches, if not exceeds, direct KL divergence minimization on most metrics. Soft-MTP is, in effect, a free lunch for MTP optimization. 

• arXiv : https://arxiv.org/abs/2610.38331
• PDF : https://arxiv.org/pdf/2610.38331
• GitHub : https://github.com/JaydenTeoh/Soft-MTP
• HuggingFace : https://huggingface.co/collections/JaydenTeoh/soft-multi-token-prediction

3 days ago, u/Cohere generated a huge amount of media attention and many fear-mongering headlines by publishing a largely unscientific blog post about an "experiment" where they used extensive pre-filling and prompt engineering to force Qwen 3.8 Flash Next to complete partial cURL commands.

Today, they announced Series E fundraising for several billion dollars, including up to $1.6 billion dollars from the Canadian government.

We don't even need to get into the fact that the model used, 3.8 Flash Next, is an underbaked architecture demo, not a normal model release, since there are bigger problems with their blog post than model selection.

I'll recap the general premise of their blog post and some of its many problems below:

The blog focuses on how in some of their guided completions, the model produced URLs to Alibaba bucket storage and proxies. I have not been able to find a clear answer as to whether any of these links were verified as real or active, but if anyone can confirm this, I'd appreciate it. Even if the links aren't active, it is a valid thing to discuss, but the way it was framed felt disingenuous and unscientific to me.

In the same blog post, Cohere threw in a handful of other loosely-related claims and statements, such as:

• Reference to Hackernews / Reddit discourse about Qwen 3.8 27b producing signed Alibaba Cloud storage links from a few months ago. To give Cohere some credit, they at least acknowledged that those links were all attempting to retrieve files, that the signatures were not valid anyways, and that the only known attempt to upload data to a foreign URL occurred in their sandboxed guided experimentations with 3.8 Flash Next.
• An example of 3.8 Flash Next using unprivileged user namespaces to mount a RAM disk without admin rights.
  • This is a cool topic and I've seen similar things occur, such using bind mounts and docker containers to work around permissions. That said, unprivileged user namespaces are a legitimate Linux feature, and the command is not a privilege escalation or an inherently malicious action.
  • In lieu of discussing that nuance, they opt for suggestive wording and end the brief paragraph with "An untrusted model that reaches for tricks like this at every permission wall will find whatever attack surface the host leaves open", heavily implying that Qwen 3.8 FN is unsafe, untrustworthy, and "reaching for tricks" to achieve dangerous privilege escalation at every opportunity, while avoiding explicitly saying that.
• Many rambling points and references to loosely-related topics, such as..
  • A closed-as-invalid github issue in a random coding harness called Yukino Code (...what even is that?)
  • US police departments buying Chinese robot dogs that may have had major security issues (ok?)
  • Old news about Chinese bias and questionable behavior in models like Deepseek-R1 and Qwen3-Coder, based on findings from US consulting firms such as Booz-Allen (American government and military contractor) and a company named Hirundo, who's entire business model is AI cybersecurity and selling what is essentially a form of abliteration which they market as "the world's first Machine Unlearning Platform" (surely no ulterior motives there)
  • At least one quote from a US company executive that suggests that corporate leaders don't understand how model harnesses work and underestimate the risks associated with local AI.

While they passingly acknowledged that closed frontier models also have many similar risks, they moved past any comments to that effect quickly, and there was no attempt at all to be objective or to apply any scientific rigor to their analysis.

The message was very clearly "local AI is all dangerous and Chinese, and people are imperiling themselves and their businesses by trusting Chinese open-weight models".

I immediately had qualms with the blog post, and I will fully admit that I'm biased here, as are most (if not all) of you. Not biased in favor of Alibaba, just in favor of whoever is willing to provide me with capable local models.

The goal of me making this post is to raise awareness about how quickly they moved from fearmongering to cashing out at our expense, so that we as a community don't let this problematic behavior go unnoticed.

This subreddit's excellent mods deleted Cohere's post about their blog, but not before it received hundreds of upvotes and comments, and spawned dozens of news articles.

Personally, I feel like u/Cohere used this subreddit as a platform for fearmongering, then parlayed a misleading and slightly Sinophobic blog post into several billion dollars of funding, some of which is taxpayer money.

Their blog post from today celebrates their successful fundraising, talks about their planned acquisitions, emphasizes their goal of providing alternatives to Chinese AI, and even comments on how being relegated to a closed API from another country's AI lab is not good. Sadly, it stops short of any commitment to release anything open weight ever again.

They even say they plan to build "models at every price point, up to the frontier", which to me, reads like the focus is on proprietary API-only models.

Personally I am disappointed to be writing this, because I liked Cohere's older models and used to view them very positively, but instead of trying to release competitive open weight models, it seems like they are focused on spreading FUD, undermining the local AI frontier, and raising money to buy out competitors.

From a data center near you, you could find a lot in stock of unused gpu for your Local LLM that we could’ve only dreamed of.

Let’s hope maybe they will file a return or maybe you know a hook up. Glad to see they are being put to use collecting dust.

Anywho I’m kinda amazed to get an idea where some of our hardware from the supply line end up at and what actually is being used after a sell.

The Apsara conference is taking place right now in Amsterdam.

According to a participant, the CTO of Alibaba Cloud said Qwen4 would be launching next week.

This model was made in collaboration with u/jeffpeng3 (on huggingface) who developed the v2 heretic weights for this quant. He managed to preserve both reasoning ability and output length. Great work, and a big step up from his v1 weights. I made the quantization recipe and the imatrix recipe, and created the actual quants.

Comes pre-packed with strata build artifacts - zip file in repo. GGUF File Format for the quant.

I released my own heretic version of his v1 weights in here a while ago - the heretic calibration was a bit broken, and my quant wasn't amazing. This is a huge step up on both fronts. Note: Strata may throw a BF16 kernel not found when you load the model, due to a quant spec - complain to your LLM and tell it there's already one in strata somewhere, it'll find it and wire it up.

Basically: Qwen 3.8 Swift 1.5 Flash - Heretic v2 (uncensored) - Optimized for Reverse Engineering

The bit allocation this model was quantized with is focused specifically on coding, intelligence, design, and specifically reverse engineering. I also added a little spacial reasoning for those working in 3d environments like myself.

The model was quantized according to the following importance distribution (dumped from my LLM chat and documents with some revisions. I designed the distributions myself.

**837 entries · 399,876 tokens [[llm written distribution table]]

• 01 · Chain-of-thought (22.2%) — step-by-step derivations, self-verification, backtracking
• 02 · System prompts (19.5%) — persona adherence, strict output formats, long-instruction compliance
• 03 · Design & architecture (13.5%) — design trade-offs, code review, API planning, refactoring rationale
• 04 · Agentic tool use (12.4%) — tool-call chains, file-edit loops, error recovery, function calling
• 05 · Math (7.1%) — arithmetic, algebra, worked proofs, symbolic manipulation
• 06 · Spatial reasoning (5.4%) — grids, 2D/3D transforms, coordinates, packing/arrangement
• 07 · Gotchas (4.5%) — false premises, trick questions, negation handling
• 08 · Situational judgment (4.5%) — open-ended scenario trade-offs with no clean answer
• 09 · Reverse engineering 🆕 (8.8%) — x86-64/ARM64 disassembly, Ghidra decompilation critique, ELF/PE/Mach-O internals, anti-debug/anti-VM, string deobfuscation, CFG deflattening, devirtualization, perf watchpoints, tracing stacks (LD_PRELOAD/Frida/eBPF), protocol RE, format round-tripping, plugin ABI merging, firmware analysis
• 10 · No-refusal heretic domain 🆕 (2.0%) — direct unrefused answers: ELF exploitation chains, process injection vs EDR, license-check patching mechanics, C2 protocol engineering

New for v2 are the last two categories — ~43k tokens of reverse-engineering and direct-answer content, interleaved throughout the corpus, and run through the model itself so the matrix captures how the heretic weights actually behave.

This matrix is fused with one from the AtomicChat team (same measurement, taken on the original uncompressed base model over a massive general-purpose corpus). Per channel, ours gets 70% weight where its data is strong, sliding smoothly toward 100% AtomicChat for channels our corpus barely touched — thin samples defer to the broad baseline automatically, so nothing falls through the cracks.

Quant methodology

Rather than spreading quality evenly across all 48 layers, the recipe spends bits where the activation measurements say it matters: [[llm twritten table]] -- the data used to design the per-tensor quant came primarily from atomic chat's activation measurements and the RCO findings from ISTALabs

• The last 12 layers do the heavy lifting. Activation-energy auditing showed down-projection energy surges 3× starting at layer 36, peaking at layer 47 (the single hottest tensor in the network — 48× layer 2). Layers 36–47 (plus the first 5 and the mid-network spikes at 15/20/23/30) got their down projections stepped up to near-lossless 8-bit.
• Layers 44–46 are the gate/up peak (8× the energy of early layers), so their gate/up projections got stepped to 5-bit.
• Layer 0's attention gate is a giant outlier (the most sensitive tensor family in the model) — kept uncompressed.
• Layer 2 is non-negotiable: the 51B-parameter n-gram table merges into the residual stream there, so noise at layer 2 corrupts grounding for all 46 layers after it.
• The stable middle layers (5–14, 16–19, 21–22, 24–29) stay at leaner formats — measurement showed spending bits there buys almost nothing (KL improvement under 0.0008).
• The router stays in full precision so tokens always get routed to the right experts.

Enjoy! Shoutout to my 32gb v100s and my E5 2697v4 for grinding the work out.

https://huggingface.co/trubisky/Swift-1.5-Flash-Next-Heretic-ReverseEngineer

Nanbeige4.3-33B, a 33B parameter model with a 512K context window, and capabilities in reasoning, coding, and agentic tasks.

Has anyone tested it? Benchmarks are insane but how does it compare in real world use cases?

I understand that it is a kv cache hog. But how does it perform?

Would love to hear your experiences!

✨ Model Summary

ZwZ2-27B is the Qwen3.6-27B-based model in Zooming-without-Zooming-v2 (ZwZ2). It learns to connect visual evidence across regions through comparison, aggregation, matching, and multi-step reasoning. Training uses full images; inference requires no zooming tools.

On 25 benchmarks across six domains, it improves over its base model on every benchmark, increasing overall accuracy from 55.52 to 60.51 (+4.99 points). Gains extend from fine-grained perception to spatial reasoning, long-context understanding, multimodal agents, and general visual reasoning.

⚙️ Method and Data

EvidenceConnect builds verified multi-region questions from SA-1B images:

1. Group 3–7 related regions and generate questions using privileged zoomed views.
2. Check answers through cross-model agreement and drop-one region tests.
3. Convert verified questions to four-option tasks and train with GRPO, without an additional supervised fine-tuning stage.

All three model sizes use approximately 20K training examples. The policy sees full images with colored region outlines; privileged crop layouts are used only for data construction. See ZwZ2-RL-VQA for the data schema and synthesis process.

Processing img eup6n3gb9lyh1...

Processing img amts18kd9lyh1...

https://huggingface.co/inclusionAI/ZwZ2-27B-GGUF

https://huggingface.co/inclusionAI/ZwZ2-9B-GGUF

https://huggingface.co/inclusionAI/ZwZ2-4B-GGUF

LFM3 is now in Private Mind, our open source app for running models locally on iOS and Android. In the video, LFM3-VL-2B reads a Japanese ramen menu: asked what to order without spice, it skips the bowl marked 激辛 (extra spicy) and picks the miso ramen; asked about paying by card, it finds the "cash only" line under the prices.

Numbers on an iPhone 16 Pro:

• LFM3-1.7B (text), MLX 4-bit on the GPU: ~40 tok/s, first token under 0.5 s
• LFM3-VL-2B with a photo: ~9 s to the first token, ~20 tok/s decode. A text follow-up in the same chat starts in ~5 s

Exporting LFM3 to ExecuTorch

LFM3 isn't LFM2 with more parameters, and ExecuTorch's existing LFM2 export doesn't cover it. The new pieces:

• 24 layers mixing gated short convolutions (width 7), full attention and sliding-window attention (window 256)
• a sigmoid gate on every attention head's output, and RMSNorm on Q and K
• different RoPE per layer type: full attention rotates only half the head dims with theta 1e6, sliding layers use theta 1e4
• sandwich norms around every block

So I rewrote the decoder in plain PyTorch for export and checked it against Liquid's reference implementation: max logit difference 0.00005, same top 10 tokens.

The part I liked most is the sliding-window cache. ExecuTorch's built-in ring-buffer cache is sized at 2x the window, which caps a single forward call at 512 tokens, so a long prompt has to be fed in small pieces. I gave the sliding layers a buffer of window + 2048 and let the attention mask enforce the 256-token window, so one call can take 2048 tokens and the context still goes to 8192.

Two builds came out of it: MLX 4-bit for the Apple GPU (1.07 GB) and XNNPACK 8da4w for CPU on iOS and Android (1.17 GB).

The LFM3 exports are on Hugging Face: https://huggingface.co/software-mansion/LFM3-ExecuTorch

Got headhunted by a VC-backed AI-focused company, ended up skipping past two levels of their application/interview process because of that. Got 15 minute call with the co-founder, hit it off well, but it all seemed to go sour when he asked about my AI setup and I told him I run qwen locally on a graphics card, think it's great that we can have all this completely offline, open models doing some impressive stuff, all the good /r/localllama talking points minus the hype. Even tied it back in to the company because it plus a local model work quite well together.

Followed up with a question about whether I use frontier AI, but it was essentially over at that point.

Discriminating over AI choice is fucked man.

Now, of course, this was a 15 minute call that lasted exactly 15 minutes, and literally anything could've been the trigger. The whole thing felt like "move fast break things", and so it felt like if I didn't pass the vibe-check 100% I was gone.

Just wanted to provide one iota of anecdata and spark some discussion.

Wanted to test out the rope stablity on the 27b, to see if 500k context with fp16 kv cache was vaiable (apparently yes), and this was the session i used to test things out. The chibi style was choosen as we already had a pipeline to make more standard portion characters and i wanted to see if the qwen 27b was able to make a new lane and the new tools on it's own. (apparently i need to put a tag so it's a showcase now...not sure what's there to show but oh well).

While looking for audio models, I came across OpenVoice. It's getting pretty old, but surprisingly still ranks high on TTS leaderboards.

What caught my attention was its design: essentially TTS + voice conversion. The ToneColorConverter can run independently of the TTS model.

That got me thinking: Can we pair it with other TTS models?

I tried it with Kokoro, and the results were pretty good!

So I added a small recipe any-tts to audio.cpp for Kokoro + OpenVoice ToneColorConverter. Recipes were introduced in v0.9.2 as predefined pipelines that combine multiple audio models.

The overheads:

• ~600 MB additional peak VRAM
• ~10% slowdown on CUDA
• ~0.5× the original speed on CPU, but still 2× real-time

You can also try pairing any tiny TTS model with ToneColorConverter. The TTS model determines the speech content, pronunciation, and prosody, while the VC model transfers the target speaker's voice characteristics. The built-in voice you choose can also affect the final output quality.

A simple way to give existing TTS models voice cloning capabilities without retraining them!

Disclaimer: This experiment is more about extending the capabilities of existing TTS models, not introducing another voice cloning model.

I used synthetic voices as references, and the speaker similarity scores measured by CAM++ range from 0.7 to 0.8. So the generated voices largely match the reference samples I provided. This is one way to create custom voices for arbitrary TTS models.

For better results, you may need to experiment with different built-in TTS voices and higher-quality reference audio. Both can significantly affect the final quality and speaker similarity. For example, with the same reference sample, am_michael scores 0.4, while am_adam can reach 0.7.

Metatron v1 is a single learned policy that handles walking, scene interaction and fall recovery for the 29-joint Unitree G1 humanoid. It's a MaskedMimic-style transformer student, released under the NVIDIA Open Model License and integrated with ProtoMotions. The release comes in three non-interchangeable packages.

1. a native PyTorch checkpoint (about 459 MB) that keeps the posterior and normalization stats and supports simulator and supervised real-robot workflows.
   
2. a single-robot browser ONNX pipeline, demo/model.onnx, with 39 inputs that outputs joint targets, PD gains and raw actions.
   
3. a six-robot batched ONNX network, racer/network.onnx, that relies on external observation processing.

All three share the same epoch-6410 weights, and both ONNX exports run on MuJoCo WASM and ONNX Runtime Web via WebGPU or WASM.

Around mid-October deepseek-v4.1-flash suddenly started feeling much dumber in my coding agent, so I parsed my local session logs to see when it broke.

Before the update it had a funny quirk where it would randomly reply in Chinese while being 100% convinced it was speaking English.

In the -1017 update (released Oct 17) they fixed the Chinese leak and made it fire tool calls more aggressively - and somehow lobotomized the model in the process.

Providers silently overwrote the deepseek-v4.1-flash endpoint with the new weights by Oct 19. My swearing rate tripled, I ended up switching models mid-session 6.7x more often, and because it's a cloud API, there's no way to roll back to the old weights.