Minguk_Kang

Founding Research Scientist @pika_labs, PhD at POSTECH,
First Author of GigaGAN | Built PikaStream1.0

[Minguk_Kang @minguk_kang]

Our first visual engine for Pika AI Self - and this is just the beginning 🚀 Faster speeds, higher resolutions, better models are all coming.

Technical blog dropping soon 📝 PikaStream1.0 is a full-stack effort: pre-training, SFT, post-training (distillation & RL), plus deep engineering for speed ⚡ Stay tuned 🔥

[Pika @pika_labs]

Conversations tend to go better with a face and a voice. That’s why we’re thrilled to release the beta version of the first video chat skill for ANY agent, powered by our new real-time model, PikaStream1.0.

The skill preserves memory and personality, and enables real-time adaptability. And if you use it with your Pika AI Self, they’ll be able to execute agentic tasks during the call 💅

[Pika @pika_labs]

Your clip no longer has to end where it started. Gemini Omni 1.1 Flash is here—video extension, first & end frame support, up to 3 reference videos, and output all the way to 4K.

[Design Arena @DesignArena]

BREAKING: MiniMax H3 Max sets the new Pareto Frontier for video generation, nearly 50x faster than the base model.

This model is post-trained by @fal on @MiniMax_AI H3, and it's in a league of its own: no other Image to Video model on the arena delivers higher preference at a lower generation time.

Its Image-to-Video generation time is just 6.4 seconds, 18x faster than average, and its Text-to-Video generation time is just 4.7 seconds, 24x faster than the average.

Huge congratulations to the @fal team on this release!

[Minguk_Kang @minguk_kang]

@JXQNHZr1yUAj5Be makes sense. Thank you for explanation!

[Hoosha 🧠 @hooshaaii]

O(N²) attention isn't dead yet.

Tri Dao’s 'FlashAttention-3' squeezes every drop of Hopper GPU performance.

By using FP8 and interleaving block-wise GEMM, it hits 75% of peak hardware FLOPS.

Algorithm + Hardware codesign is undefeated! 📄 https://t.co/5bH8FQwGHG

[Minguk_Kang @minguk_kang]

Quick question — why is it a problem to sample the noise in bf16?

We're already doing mixed precision training for diffusion, so isn't everything cast to bf16 at that point anyway? Is the issue that the normalization inside the model ends up being computed in bf16? I'd love to understand the details!

[Pika @pika_labs]

The wait is over. WAN 3.0 is here—20 references, enhanced visual and audio realism, and 30-second generations. In fact, this entire video was one generation.

Up to 35% less expensive than competitors on the Pika API Club. Always.

[MiniMax (official) @MiniMax_AI]

The real breakthrough in the NVIDIA SANA team’s Sol Engine work on MiniMax H3！

By splitting generation into a 4-step low-res H3 draft and a 3-step LTX refinement pass at target resolution with Sol-Attn, they’ve crushed 10s 768p latency on a single GB200 from 414s down to 14.93s (27.7x speedup). Replacing heavy VAE decodes with TAEH3/TAEHV while holding the latents stable for refinement is a masterclass in co-designing sampling topology with hardware kernel acceleration.

When inference latency collapses this dramatically, unit economics fundamentally shift: a single node can suddenly serve 378K videos a month at 97%+ GPU margins. This is how high-fidelity AI video moves from asynchronous batch rendering to near-instant, interactive infrastructure. Huge respect to the team for setting a new engineering bar for our open-weights ecosystem! 🫡🩵

[Ningcong Chen @JXQNHZr1yUAj5Be]

😅😅😅
Never sample your diffusion noises in bf16/fp16. I spent my last two days to understand why my sampled images grey out.
Also AI is not good at these model training stuffs, this is what happened when you use AI to train a diffusion model.

[ℏεsam @Hesamation]

UC Berkeley + MIT researchers open sourced a new inference engine and so far IT’S CRAZY:

> runs DeepSeek-V4-Flash 284B at 25 tok/s with a RTX 5090 system
> 1.46x faster than llama.cpp on the same test. Ollama can’t even serve it
> up to 3× faster than Ollama on the same Qwen3.6-35B bench

[Percy Liang @percyliang]

🚢 Marin 535B-A23B started training this week! As usual, the whole process is open.
Voyage plan: pretraining (80%) + midtraining (20%) on 18.75T tokens on 11 x GB200 NVL72 for ~3 months (2.7e24 FLOPs). Post-training will follow.
Before kicking off the run, we trained a 4-rung scaling ladder from 1.6B-A61M (48B tokens) to 27.7B-A1.2B (926B tokens) to debug issues, and to make a forecast of our hero run. This is by far our biggest run, so definitely expecting the unexpected.

[Liam Fedus @LiamFedus]

An excellent history of scaling laws from @jietang.

In 2020, we explored the limits of sparsity in Switch Transformers by routing each token to only 1 out of 2048 experts (in retrospect, a bold choice). The model had fewer than 3B activated parameters, but 1.6T total parameters (comparable to today's frontier models).

The 1.6T model achieved better C4 perplexities than the T5 models using far less compute, set a new SOTA on TriviaQA, but was dumb as bricks on reasoning tasks like SuperGLUE.

The lesson was that the optimal tokens-per-parameter ratio is highly task-dependent. Or as @NShazeer had already intuited: FLOPs were intelligence; parameters were knowledge!

[yinminghuang @adamhuang1828]

Excited to share our work, VA-Judger, the first reward model for joint video-audio generation! 🎥🔊
Powered by VA-Judger, post-trained LTX-2 generates high-quality content that better aligns with human preferences.

📄Paper: https://t.co/qlb1w7xHGo
💻Code: https://t.co/znBST9dPH9

[机器之心 JIQIZHIXIN @jiqizhixin]

"Longer prompts don’t make better images—until now. "

ByteDance Seed researchers found that naively adding text to image-generation prompts actually hurts performance across Qwen-Image, FLUX.1, and others. The fix? Structure, not length.

They introduce a structured-prompt schema that adds image-grounded facts (geometry, semantics) rather than filler prose. Their scaling laws show diffusion loss—a measure of generation quality—decreases linearly with information density, not token count.

Result: their system beats all open-weight models on compositional and reasoning benchmarks, and matches top closed-weight models. The secret? A finetuned prompter trained via verifier-gated distillation. Code, models, and demo are live.

Scaling Properties of Text Conditioning in Visual Generation

Paper: https://t.co/I7EaWAc2dZ
Project: https://t.co/sksziY3awA
Code: https://t.co/e0IFmEtFYH

Our report: https://t.co/n8IRM6LjLb

📬 #PapersAccepted by Jiqizhixin

[Jun-Yan Zhu @junyanz89]

Try out Sheng-Yu's latest work with pip install tpips.

TPIPS is a text-prompted image perceptual similarity metric and a revisit of the classic LPIPS metric.

[jietang @jietang]

Thoughts About Scaling Law

Scaling, but not only of parameters. Every model release now ends with the same question: how many parameters? It isn't a question that can be answered on its own. Parameter count is only meaningful alongside three others — how much data you have, where you intend to spend your compute, and who will run the model, under what conditions.

The field learned this the hard way. Kaplan et al. (2020) fit an exponent that told everyone to grow parameters faster than data — roughly 2.7:1 — and the industry complied: GPT-3, Gopher, MT-NLG. Hoffmann et al. (2022) redid the experiment across four hundred models and found the compute-optimal split is closer to 20 tokens per parameter, and that with sufficient compute the two should grow at the same rate rather than drifting apart. The error in the earlier fit compounded with every order of magnitude of compute, which is why the largest models of that generation were the most misallocated. The trillion-parameter round was, in retrospect, a detour the whole field took together and then reversed.

Chinchilla wasn't the end either. It optimized training compute for models that would be trained once and evaluated. Today a model is called billions of times a day and inference dominates lifetime cost. Put inference into the objective and the optimum moves toward smaller models trained far longer — deliberate over-training, which is what Llama-2-7B and Gemma-2-9B were doing at roughly 290 and 889 tokens per parameter.

Sparsity moved the target again. In a MoE model two quantities have to be kept apart: total parameters govern roughly how much the model can hold — knowledge, facts, the long tail — while activated parameters and effective depth govern roughly how far it can think, how many steps of a causal chain it can carry before it comes apart. A dense 20:1 ratio does not transfer. And the ratio isn't a single number at all: Roberts et al. (2025) find the optimal tokens-per-parameter is task-dependent, with memorization favoring more parameters and reasoning favoring more data. Follow-up work on MoE observes that at fixed TPP, pushing total parameters higher actually degrades reasoning, while activating more experts reliably helps it.

This matters for what we are building toward. Finding a vulnerability is not a retrieval problem. It doesn't come from having memorized more CVEs; it comes from carrying a twenty-step chain of inference to the end without losing the thread. That capability does not live in total parameter count.

Which brings us to this release. Total parameters appear to matter up to a threshold — enough to hold the world — after which additional capability comes from scaling elsewhere: effective depth per forward pass, and above all post-training. GLM-5.3 is our controlled experiment on that claim. Same base, same architecture, same total and activated parameters as GLM-5.2. One month of scaling long-horizon environments and RL. The gains are not marginal. Well, scaling has more than one dial. We turned the post-training one this time because it had the most slack left in it — not because the others are finished. Base model size, pretraining data, compute spent per forward pass: all of them are still on the table, and we will come back to each. What this experiment taught us is that the dials do not have to be turned together, and that the one worth turning next is rarely the one that was worth turning last. We are not done scaling. Next time, maybe mid-training, pre-training, and even more.

[Pika @pika_labs]

Seedance 2.5 is now available in 1080p via the Pika API Club — and it’s up to 60% cheaper than competitors.
Sharper textures. Cleaner details. More room for every shot to land.

[Topaz Labs @topazlabs]

📢 Big release: New video model 🚀
Introducing Hyperion 2.5: convert 8-bit AI video into true HDR - ProRes 10-bit, EXR 16-bit, H.265 10-bit. AI footage can finally sit alongside live action in professional and VFX pipelines. Available now in Astra, coming soon to Topaz Video

[Sheng-Yu Wang @ShengYuWang6]

How similar are two images? Prior metrics (e.g., LPIPS, DreamSim) give just a single score. But actually, there are multiple *senses* of similarity (color, pose, etc.)

We introduce TPIPS -- Text-Prompted Image Perceptual Similarity

"pip install tpips"
https://t.co/L726pdRx6b 🧵

[LunaKim𓆩🩷𓆪 @checheluna3]

Seedance 2.5 쓰는 분들 이 사이트 혹시 알고 있나요?

여기 생각보다 제대로인데요👀

Seedance로 실제 만들어진 영상이랑
사용한 프롬프트를 같이 볼 수 있어요.

특히 2.5 자료도 계속 올라오는 중!!

원테이크, 액션, UGC, K-pop, 카메라 무빙,
캐릭터 일관성까지
카테고리별로 구경하다 보면 시간 순삭입니다.

저 지금 프롬프트 몇 개씩 뜯어보는 중인데
Seedance 영상 만드는 분들은 일단 북마크
해두셔도 될 듯 👀

※ ByteDance 공식 사이트는 아니고, 공개된 커뮤니티 자료를 출처와 함께 모아둔 아카이브예요.

[Superman @thesupermanmx]

NVIDIA has lost it..

Chinese researchers open-sourced a model that writes CUDA better than humans experts.

And it completely rewrites the economics of AI hardware.

Writing low-level CUDA kernels to squeeze every ounce of performance out of a GPU has historically required elite, highly specialized hardware engineers. Standard AI models have always bombed at it, falling far short of traditional compiler systems.

Until now.

A joint team from Tsinghua University and ByteDance published "CUDA Agent”, a massive, large-scale agentic reinforcement learning system built to master GPU architecture.

Instead of relying on static prompts or simple multi-turn bug fixing, they built a closed-loop environment with automated hardware verification, profiling, and synthetic data pipelines.

The model learned how to write parallel, high-performance GPU code through trial, error, and reinforcement learning at scale.

The benchmarks are staggering:

It didn't compete with standard tools. It delivered 100%, 100%, and 92% faster execution rates over PyTorch's compiler on KernelBench Level-1, Level-2, and Level-3 splits.

On the brutal Level-3 benchmarks, it outperformed proprietary giants like Claude Opus 4.5 and Gemini 3 Pro by about 40%.

NVIDIA's moat has always rested on two pillars: elite hardware, and the proprietary software lock-in of CUDA.

If an open agentic system can automatically discover, write, and optimize production-grade CUDA kernels better than human specialists, the software moat starts evaporating.

The hardware matters less when the software can rewrite the metal itself.