I have this feeling for sometime. Also noticed few similar tweets online before.

>Hardware-agnostic strategies for accelerating text-to-image diffusion, such as timestep distillation and feature caching, can reduce inference time without custom kernels or system-level optimization. Among them, multi-resolution generation strategies have recently received broad attention, attaining more than 5x speedup without any training. However, the design of performing upsampling in the latent space, together with the selective modification of partial regions, causes these methods to exhibit noticeable blurring or artifacts. To this end, we propose MrFlow, a training-free multi-resolution acceleration strategy for pretrained flow-matching models built upon a staged low-to-high-resolution pipeline. MrFlow first rapidly generates the main structure at low resolution, then performs super-resolution in the pixel space using a lightweight pretrained GAN-based model, subsequently injects low-strength noise to enable high-frequency resampling, and finally refines the details at high resolution. Quantitative and qualitative results on FLUX.1-dev and Qwen-Image show that MrFlow exploits the quadratic token reduction and reduced step requirement of low-resolution sampling to achieve 10x end-to-end acceleration while keeping OneIG within a 1% gap relative to that before acceleration, significantly surpassing other training-free acceleration strategies, and requiring no training or runtime dynamic identification whatsoever. MrFlow can further be directly combined orthogonally with pre-trained timestep distillation strategies, achieving even higher generation acceleration of up to 25x.

Highlights

• Training-free deployment. No finetuning, learned upsampler, or model-specific retraining is required.
• No custom kernels. The implementation uses standard PyTorch, Diffusers pipelines, and scheduler controls.
• Strong aggressive-speed regime. MrFlow reaches more than 10x end-to-end speedup on Qwen-Image while preserving visual quality.
• Works with distilled models. The same pipeline can be combined with pretrained timestep-distilled models such as Pi-Flow and FLUX-schnell.
• Compact staged design. The implementation transfers across Qwen-Image, FLUX.1-dev, FLUX.2 Klein, and Z-Image families.

News

• [2026/07] 💡 We add a Practical Tips section and encourage everyone to share useful observations and takeaways with each other.
• [2026/07] 🌱 We add a community contribution area and welcome developers to share MrFlow ports, workflows, and experiments with each other.
• [2026/07] 📰 MrFlow is featured on Hugging Face Daily Papers.
• [2026/07] ⚡ We release the MrFlow ComfyUI plugin.
• [2026/07] 🔥 The MrFlow paper is available on arXiv, and the source code is released.

Representative end-to-end speedups:

Backbone	Setting	End-to-end speedup
FLUX.1-dev	12 + 1	8.25x
Qwen-Image	12 + 1	10.3x
FLUX.2 Klein Base 9B	12 + 1	8.79x
Z-Image-Turbo	8 + 1	21.0x
Qwen-Image + Pi-Flow	4 + 1	up to 25x

Speedups are measured end to end, including text encoding, VAE encode/decode, super-resolution, noise preparation, and diffusion forward passes.

arXiv : https://arxiv.org/abs/2607.01642

Full Paper : https://arxiv.org/pdf/2607.01642

HuggingFace : https://huggingface.co/Xingyu-Zheng/MrFlow

GitHub : https://github.com/Xingyu-Zheng/MrFlow

>Visual generative models are typically trained in two stages. A tokenizer is first trained for reconstruction and then frozen, after which a generator is trained on its discrete indices or continuous latents. This decoupling leaves the tokenizer unaware of what the generator finds easy to model. We present GEAR (Guided End-to-end AutoRegression), which trains a vector-quantized (VQ) tokenizer and an autoregressive (AR) generator jointly and end-to-end, guided by representation alignment. The key obstacle is that the VQ index fed to the AR model is non-differentiable, so gradients cannot reach the tokenizer, and a straight-through estimator collapses. GEAR resolves this with a dual read-out of the codebook assignment. A hard, one-hot branch trains the AR with next-token prediction, while a differentiable soft branch carries a representation-alignment loss that flows back to guide only the tokenizer. The AR model thereby steers its tokenizer toward an index distribution it can predict more easily. This shifts the alignment burden from the tokenizer to the AR: the tokenizer's own features become less DINOv2-like while the AR's become more so, the opposite of diffusion-side recipes that make the latent itself semantic. GEAR speeds up ImageNet gFID convergence by up to 10x relative to the strong LlamaGen-REPA baseline, learns markedly better patch-level and spatially-coherent features, and generalizes across quantizers (VQVAE, LFQ, IBQ) and to text-to-image generation.

>

✨ Highlights

• 🔗 Guided end-to-end. The soft-assignment bridge lets the AR guide the tokenizer, succeeding exactly where the straight-through estimator collapses; the next-token loss never touches the tokenizer.
• 🔄 Alignment flips to the AR. Opposite of diffusion-side REPA (REPA-E / VA-VAE): the tokenizer becomes less DINOv2-like and lower-entropy, while the AR's per-patch features track DINOv2 far more closely — reconstruction preserved.
• ⚡ Faster & better. ~10× faster ImageNet gFID convergence; on GPIC text-to-image a fresh AR on the frozen tokenizer hits the baseline's NTP loss 2.5× and REPA loss 11.1× faster, with better gFID at B / L / XL.
• 🧩 General & drop-in. Works across VQVAE / LFQ / IBQ and across class-conditional ImageNet and text-to-image — freeze the tuned tokenizer and drop it into a standard pipeline.

arXiv : https://arxiv.org/abs/2606.32039

Full Paper : https://arxiv.org/pdf/2606.32039

HuggingFace : https://huggingface.co/collections/BinLin203/gear-tokenizer

GitHub : https://github.com/Tencent-Hunyuan/GEAR

>Block Diffusion Language Models (BD-LMs) improve diffusion-based text generation with KV caching and flexible-length generation. A natural next step is to extend them from Single-Block Diffusion (SingleBD) to Multi-Block Diffusion (MultiBD), where a running-set of consecutive blocks is decoded concurrently for inter-block parallelism. However, existing BD-LMs are mostly trained under teacher forcing, where the model observes only one noisy block conditioned on a clean prefix. While the recent diffusion forcing strategy introduces visibility among multiple noisy blocks, its training states still differ from MultiBD inference, where decoding operates on a bounded running-set with heterogeneous slot-wise noise patterns. To bridge this gap, we propose Multi-Block Diffusion Language Models (MBD-LMs), obtained by post-training BD-LMs with Multi-block Teacher Forcing (MultiTF). MultiTF integrates teacher forcing and diffusion forcing by training on bounded noise-groups conditioned on clean prefixes, with randomized noise-schedulers that better match MultiBD inference states. To make MultiBD practically executable, we further introduce an optimized decoding algorithm based on the Block Buffer mechanism that preserves prefix-cache reuse, keeps input shapes static, and translates increased decoding parallelism into wall-clock acceleration. Empirically, MBD-LLaDA2-Mini increases average Tokens Per Forward pass (TPF) from 3.47 to 6.19 and improves average accuracy from 79.95% to 81.03%; when combined with DMax, MBD-LLaDA2-Mini-DMax reaches an average TPF of 9.34 with only a 1.02% accuracy drop on math and code benchmarks.

arXiv : https://arxiv.org/abs/2606.29215

Full Paper : https://arxiv.org/pdf/2606.29215

GitHub : https://github.com/SJTU-DENG-Lab/mbd-lms

>To reduce memory consumption during LLM inference, a handful of methods have been proposed for KV cache pruning. While these techniques can accomplish lossless memory reduction on many datasets, they often hinge on an under-emphasized condition: an input/domain-specific threshold for KV cache budget needs to be pre-determined to achieve the optimal performance. However, such input-sensitive design may be considerably limited in real-world scenarios, as open-domain inputs span diverse domains, lengths and difficulty levels, without clear boundaries for threshold selection. As a result, the dependence of such input-sensitive threshold can be a fundamental limitation that causes large degradation on arbitrary inputs. In this work, we propose a new objective that lifts the threshold constraints for robust KV compression, advocating for "threshold-free" methods that adaptively adjust budget allocation while preserving full-cache performance. We then propose a novel method, ReFreeKV, serving as the first instantiation of this objective. Extensive experiments across 13 datasets with diverse context lengths, task types, and model sizes demonstrate its efficacy and efficiency.

arXiv : https://arxiv.org/abs/2502.16886

Full Paper : https://arxiv.org/pdf/2502.16886

GitHub : https://github.com/Patrick-Ni/ReFreeKV

>Speculative decoding accelerates inference by using a lightweight draft model to generate candidate tokens in parallel, and are then verified by the target model, enabling lossless acceleration. Recently, diffusion-based speculative decoding further improves parallelism by generating multiple tokens per forward pass via block-level diffusion, achieving state-of-the-art (SOTA) performance. However, existing methods adopt a fixed inference block size and assume a uniform optimal decoding strategy across all inputs. In this paper, we show that this assumption is suboptimal, as the optimal block size varies across samples and plays a critical role in speculative decoding performance. Moreover, these values exhibit a clear local structure, concentrating around the training block size, which reduces the problem to a low-dimensional and structured decision space. Based on these insights, we propose BlockPilot, a sample-adaptive policy that predicts the optimal block size from the prefilling representation. Specifically, we formulate block size selection as a lightweight policy learning problem and propose an instance-adaptive decision mechanism that predicts the optimal block size based on the representation of the prefilling stage. The prediction is performed only once after prefilling, allowing for seamless integration. Extensive experiments demonstrate that our method is plug-and-play, introduces minimal overhead, and consistently improves efficiency, achieving an acceptance length of 5.92 and a 4.20× speedup on Qwen3-4B under temperature T=1.

arXiv : https://arxiv.org/abs/2606.31315

Full Paper : https://arxiv.org/pdf/2606.31315

GitHub : https://github.com/AMAP-ML/BlockPilot

>In prefill-decode (PD) disaggregated LLM serving, each request is assigned to a decode worker after prefill. Existing decode routers balance only load; for mixture-of-experts (MoE) models this is incomplete: equally loaded workers can differ in latency, since each decode step loads the weights of every distinct expert its batch activates. We present ELDR, an expert-locality-aware decode router for PD-disaggregated MoE serving. From a request's prefill expert activations, ELDR builds an expert signature predicting the experts it will activate during generation. Offline, balanced K-means partitions signature space across decode workers; online, locality-band routing sends each request to the least-loaded worker among those best matching its signature. A signature cache, co-indexed with the KV cache at KV-block granularity, keeps signatures exact under prefix caching. Implemented in vLLM and evaluated on deployments of up to 40 GPUs, ELDR reduces median TPOT by 5.9-13.9% over the strongest of four load-balancing baselines across three MoE models and two workloads, with model outputs unchanged.

arXiv : https://arxiv.org/abs/2607.00466

Full Paper : https://arxiv.org/pdf/2607.00466

MODs, can we have a separate flair(Paper) for paper threads?

After overwhelming April, OK May, here's June. Yeah, Graph has only less items. Because we got other items here last month.

Finetunes:

• Nex-N2
• Ornith-1.0
• Agents-A1
• Holo3.1
• Tmax-27b
• MusaCoder-27B
• VibeThinker-3B

NVFP4 from NVIDIA for below models:

• NVIDIA-Nemotron-3-Ultra-550B-A55B
• diffusiongemma-26B-A4B-it
• Qwen3.6-27B
• GLM-5.2
• MiniMax-M3
• Qwen3.5-397B-A17B

MXFP4 from AMD for below models:

• Kimi-K2.7-Code
• GLM-5.2
• Qwen3.5-397B-A17B
• MiniMax-M3

AutoRound from Intel for below models:

• DiffusionGemma-26B-A4B
• DeepSeek-V4-Pro
• Gemma-4-31B-it
• Gemma-4-12B-it

Misc:

• Gemma-4-QAT
• Nemotron-Labs-TwoTower-30B-A3B-Base (Diffusion) by NVIDIA
• DeepSpec (Eagle3, DFlash, DSpark) by DeepSeek

Benchmark from its model card. Removed online models & Qwen-AgentWorld-397B-A17B from the table.

Just Open models.

Model	MCP	Search	Term.	SWE	Android	Web	OS	Overall
DeepSeek-V4-Pro	63.27	27.61	51.26	59.44	55.17	50.32	63.70	52.97
GLM-5.1	67.60	22.46	47.32	52.07	59.10	51.50	59.13	51.31
Kimi K2.6	65.23	27.48	52.54	58.77	58.93	50.20	60.80	53.42
MiniMax-M2.7	55.82	27.30	41.62	37.44	52.40	50.52	57.73	46.12
Qwen3.5-35B-A3B	57.87	25.98	46.13	47.58	53.18	47.10	56.27	47.73
Qwen3.5-397B-A17B	68.31	30.81	55.30	64.44	54.90	48.55	60.85	54.74
Qwen-AgentWorld-35B-A3B	64.79	36.69	53.96	65.63	58.17	49.55	65.92	56.39

Just Qwen models

Model	MCP	Search	Term.	SWE	Android	Web	OS	Overall
Qwen3.5-35B-A3B	57.87	25.98	46.13	47.58	53.18	47.10	56.27	47.73
Qwen3.5-397B-A17B	68.31	30.81	55.30	64.44	54.90	48.55	60.85	54.74
Qwen-AgentWorld-35B-A3B	64.79	36.69	53.96	65.63	58.17	49.55	65.92	56.39

AgentWorld's numbers seem good comparing to other models.

I remember that many still waiting for Qwen3.7-27B/35B/etc., models.

1. So meanwhile, this AgentWorld model is worthy to use on Coding?
2. First of all, this model is suitable for chatting & writing stuffs or not?

Found this message on HF discussion of that model.

>first impression:
much better quality and accuracy than Qwen3.6-27B when handling long-term agent tasks.
Huge Thanks to Qwen Team !
Local Agent Model No.1

Boogu-Image-0.1 is a competitive Apache-2.0 open-source unified image generation and editing model family, including Base, Turbo, Edit, and other variants that provide stable, practical capabilities for high-quality text-to-image generation, fast generation, image editing, and Chinese-English text rendering. Closed-source multimodal understanding and generation systems like Nano Banana Pro and GPT-Image-2 achieve remarkable performance not because of a single model, but through a highly unified suite of system capabilities. However, under training compute that is extremely limited compared with closed-source systems, we find that systematically improving a model's understanding ability, data quality, and training pipeline can still significantly improve image generation and editing performance. Specifically, compared with some existing open-source models, our training data scale is roughly one order of magnitude smaller. We hope our empirical study and open-source release will help advance the open-source ecosystem for multimodal generation and understanding.

• 📸 Photography with reliable text rendering — Boogu-Image-0.1-Turbo delivers realistic photography, while also offering solid performance on both simple and dense text rendering.

• 📝 Strong dense text rendering — Boogu-Image-0.1-Base shows competitive results on dense, layout-heavy text scenarios such as posters, documents, brand guides, and complex bilingual designs.

• 💡 Recommendation — When your workload is dominated by dense / ultra-dense text rendering needs, we recommend running Boogu-Image-0.1-Base at 2K output resolution for the best layout fidelity and character accuracy.

• Boogu-Image-0.1-Base: Foundation model with strong diversity and controllability — ideal for fine-tuning and downstream development. Mainly intended for ultra-dense text rendering; for photorealism, Turbo is usually the better default.

• Boogu-Image-0.1-Edit: Image editing and transformation variant.

• Boogu-Image-0.1-Turbo: Distilled variant with the same parameter count, typically requiring only 3~4 steps. Focuses on high-quality generation and photorealism while preserving bilingual text rendering and prompt adherence.

Model size : 10B (12-80GB VRAM needed depends on config, check Model card for more info**)**

Models:

• https://huggingface.co/Boogu/Boogu-Image-0.1-Base
• https://huggingface.co/Boogu/Boogu-Image-0.1-Turbo
• https://huggingface.co/Boogu/Boogu-Image-0.1-Edit

GitHub:

• https://github.com/boogu-project/Boogu-Image
• https://github.com/boogu-project/ComfyUI-Boogu

Misc:

• https://huggingface.co/Comfy-Org/Boogu-Image

TMax is the strongest open RL recipe for terminal agents to date, bringing open data recipes closer to the frontier. We release two things. The first is TMax-15k, a dataset of 14,600 RL environments built from a compositional pipeline with explicit control over difficulty and diversity. It is over 2.5× larger than the next-largest open terminal dataset that releases full environment data. The second is a simple, outcome-only RL recipe (GRPO plus a few stability fixes), which we use to train a family of open models from 2B to 27B.

TMax-9B reaches 27.2% on Terminal Bench 2.0. Under official Terminal Bench settings this is the strongest open-weights model under 10B we are aware of: it beats 32B terminal agents from prior work and approaches closed models like Claude Haiku 4.5 (29.8%). Scaling the same recipe up, TMax-27B improves to 42.7%, approaching models 10 to 40× its size like the 1T-parameter Kimi K2.5 (43.2%).

• HuggingFace : https://huggingface.co/collections/allenai/tmax
• GitHub : https://github.com/hamishivi/tmax
• Paper : https://github.com/hamishivi/tmax/blob/master/assets/paper.pdf
• Blog : https://wai-org.com/blog/tmax/

#JustSharing. ^(I have no idea what to do with this)

arXiv : https://arxiv.org/abs/2606.15079

Full Paper : https://arxiv.org/pdf/2606.15079

HuggingFace : https://huggingface.co/inclusionAI/models?sort=created

(This month they released base models for both Ling-2.6-1T & Ling-2.6-flash)

--------------------------

Wish they released Ling-mini for 2.6 :( which's good for Poor GPU Club. (At least they released Ling-2.6-flash(100B), 24/32GB VRAM users could enjoy Q4)

Was talking about Ling-mini-2.0 which's 16B-A1.4B. So faster one. Posted a thread last Jan. bailingmoe - Ling(16B) models' speed is better now

>TLDR of above thread:

- Ling-mini-2.0-IQ4_XS - 160 t/s (on 8GB VRAM) - I would love to get 30-50B model from them to get fastest t/s from medium size model. Based on simple math, I would get 80 t/s for 30B Q4 with same 8GB VRAM.

- Ling-mini-2.0-IQ4_XS - 50-70 t/s (on CPU-only inference - 32GB RAM)

No other models given me such faster t/s. Till-date surprised about such faster t/s from CPU-only inference. So faster than even 1-bit version models.

LFM2.5-Embedding-350M is a dense bi-encoder for fast multilingual retrieval. It produces a single vector per document — the smallest, fastest index — for reliable cross-lingual search across 11 languages.

• Best-in-class multilingual accuracy for a dense embedder of its size.
• Inference speed is on par with much smaller models, thanks to the efficient LFM2 backbone.
• You can use it as a drop-in replacement in your current RAG pipelines.

https://huggingface.co/LiquidAI/LFM2.5-Embedding-350M-GGUF

LFM2.5-ColBERT-350M is a late interaction retriever with best-in-class multilingual performance. It stores one vector per token and matches queries to documents with MaxSim, so you can store documents in one language (for example, a product description in English) and retrieve them in many languages with high accuracy.

• LFM2.5-ColBERT-350M offers best-in-class accuracy across 11 languages.
• Inference speed is on par with much smaller models, thanks to the efficient LFM2 backbone.
• You can use it as a drop-in replacement in your current RAG pipelines to improve performance.

https://huggingface.co/LiquidAI/LFM2.5-ColBERT-350M-GGUF

• arXiv : https://arxiv.org/abs/2606.17861
• Full Paper : https://arxiv.org/pdf/2606.17861
• HuggingFace : https://huggingface.co/papers/2606.17861
• GitHub : https://github.com/tongxuluo/gamecraft-bench
• Project : https://tongxuluo.github.io/gamecraft-bench-website/

I see big/large models(Opus-4.7, GPT-5.5, Kimi-K2.6, MiMo-V2.5-Pro, GLM-5.1, MiniMax-M2.7, DeepSeek-V4-Pro) on benchmarks. Curious to know how medium size models(Ex: Qwen3.6-27B, Gemma-4-31B) would perform on this.

Hopefully we get great medium size(30-70B) models with performance of 200B+ models(on everything .... at least on coding & writing) by end of this year.