Melison

Major in ML DL and NLP/CV/AIGC😋.

[Melison @Melison48436887]

Our new work on image to video with first frame preservation.
SteadyDancer is a strong animation framework based on Image-to-Video paradigm, ensuring robust first-frame preservation.

[Guofeng Zhang @ZhangGuofeng99]

Our new 3DGS generation model Topos-Lite will be released soon, with source code and technical report. With just a few sparse multi-view images, it can generate a high-quality, renderable 3D scene in few seconds.

[Congyu Shao @CongyuS2578]

🔁 Gravity 4D closes the loop from 4D imagination to robot action.

🤖 Rather than using 3D/4D features only as perception inputs or auxiliary supervision, Gravity 4D jointly predicts future RGB video and 4D representations—pointmaps for spatial structure and scene flow for 3D motion—and routes the generated 4D latent back into action generation.

The model first imagines how the future world should look and move in 3D, then uses inverse dynamics to produce the corresponding action chunk.

📈 Trained on LIBERO and evaluated zero-shot on LIBERO-Plus, Gravity 4D improves success from 73.73% to 78.62%, with +11.21 pp under camera-viewpoint shifts and +8.69 pp under sensor noise.

🧪 Ablations show that RGB and 4D are complementary: RGB retains semantic and appearance priors, while 4D provides geometry and motion-aware robustness.

📄 Paper coming soon.

[Hugging Models @HuggingModels]

Just dropped: a fine-tuned Qwen3.5 2B model that packs a punch for text generation. It's small enough to run locally but smart enough for real tasks. Perfect for devs who want quality without the cloud cost.

[もやっしー / マイクラMOD製作所（製作依頼受付中） @moyashiall]

お題の「マグロ」「スチームパンクロボ」「ラーメン」を全部作って、今日はマイクラに入れて動かしてみました。

マイクラのモデルをAIで作るツール #mcmodelkit で生成しています。

お題は常に募集中！このリプに送ってくれたら作って動画で返します。

#マイクラ #Minecraft

[Zehuan-Huang @huanngzh]

⚽️ Model layout in 3D space

LaviGen #cvpr26, a native 3D layout generation model that models layout arrangement combining LLM knowledge with 3D generation priors.

Paper: https://t.co/K2jmvTiSnP
Project: https://t.co/Z4WLQLCl3C
Code (coming later): https://t.co/SRU3IgoNCy

[Mithril_MEX @Mithril_MEX]

This New Method Cuts Color 3D Printing Time In Half! https://t.co/zoJN7SbRtH @YouTubeより

[Daily Dose of Data Science @DailyDoseOfDS_]

The ultimate Full-stack AI Engineering roadmap to go from 0 to 100.

Bookmark this.

This is the exact mapped-out path on what it actually takes to go from Beginner → full-stack AI engineer.

> Start with coding fundamentals.
> Learn Python, Bash, Git, and testing.
> Every strong AI engineer starts with fundamentals.

> Learn how to interact with models by understanding LLM APIs.
> This will teach you structured outputs, caching, system prompts, etc.

> APIs are great, but raw LLMs still need the latest info to be effective.
> Learn how LLMs are usually augmented with more info/patterns.
> This will teach you the basics of fine-tuning, RAG, prompt/context engineering, etc.

> Strong LLMs are useless without context. That’s where Retrieval techniques help.
> Learn about vector DBs, hybrid retrieval, indexing strategies, etc.

> Once retrieval is solid, move into RAG.
> Learn to build retrieval + generation pipelines, reranking, and multi-step retrieval using popular orchestration frameworks.

> Now, step into AI Agents, where AI moves from answering to acting.
> Learn memory, multi-agent systems, human-in-the-loop design, Agentic patterns, etc.

> Learn how to ship in production with Infrastructure.
> This will teach you CI/CD, containers, model routing, Kubernetes, and deployment at scale.

> Focus on observability & evaluation.
> Learn how to create eval datasets, LLM-as-a-judge, tracing, instrumentation, and continuous evaluation pipelines.

> Security is crucial.
> Learn how to implement guardrails, sandboxing, prompt injection defenses, and ethical guidelines.

> Finally, explore advanced workflows.
> This covers voice & vision agents, CLI agents, robotics, agent swarms, and self-refining AI systems.

This is the actual journey to becoming a full-stack AI Engineer and not just "use” AI, but designing full-stack AI systems that can survive in production.

If you need specific resources, we wrote a detailed article that provides a structured learning roadmap for AI engineers in 2026.

It covers prompting, RAG, fine-tuning, agents, MCP, evals, and inference, with guidance on what to prioritize and in what order.

Read it below.

[80 LEVEL @80Level]

Michelle Arreola presented a sketch-like take on Jinx from Arcane, which is actually a 3D model made in Blender.

See more: https://t.co/wBViOWTPoK

[David Hendrickson @TeksEdge]

🤩 A 124B model activating only 5.1B parameters while approaching its 1T sibling’s performance.

It's ~ as good as Sonnet-4.6 to run locally.

The mystery model that appeared before its announcement is official.

@TheInclusionAI has officially released Ling-3.0-flash, a hybrid-reasoning MoE built for production-scale AI agents.

Stats:
🧠 124B total parameters
⚡ Just 5.1B active per token
📚 256K native context
🔭 Designed to scale toward 1M context

InclusionAI says with roughly 1/8 the total parameters and 1/12 the active parameters, Ling-3.0-flash matches or beats its 1-trillion-parameter flagship on most of the benchmarks shown.

What is different with Ling-3?
🧬 Hybrid linear attention

Ling stacks:
🔹 5 KDA layers for efficient long-range memory
🔹 1 MLA layer for precise attention

The goal is to preserve long-context agent performance without paying full-attention costs across every layer.

InclusionAI demonstrated Ling-3.0-flash by 🏙️ building and rendering a complete 3D city through Blender MCP, 🔬 coordinating a five-agent scientific research team 📊 editing Word proposals and validating Excel financials ��� generating full design systems without external images, 🎹 building an interactive browser synthesizer with Web Audio 📱 adapting one source into X, Instagram and LinkedIn content and 📅 reading messages, finding availability and updating calendars through OpenClaw

It is designed to receive a goal, coordinate tools and close the workflow.

You can try it now
🆓 Live on OpenRouter
📅 Free through August 3, 2026

🔌 Model ID:
inclusionai/ling-3.0-flash

The API is live, but InclusionAI has not yet confirmed downloadable weights, a license or a consumer-local deployment path.

Localmaxxers can test its agent behavior today but cannot yet load it into LM Studio or llama.cpp.

[Ivan Fioravanti ᯅ @ivanfioravanti]

Mage-Flow coming soon to Apple Silicon with MLX through MFLUX!

Work in progress but text-to-image is working!

For 1024x1024 on M5 Max:
- total time loading model ~5.5 secs
- generation time ~1.5
- quality TOP!

Love this model, thanks @Microsoft and @filipstrand be ready for PR!

[BasicAI @BasicAIteam]

#ECCV Ground3D-LMM unifies 3D grounding, metric reasoning, and multi-turn conversation in one framework, producing text, point-level masks, and real-world measurements from natural-language questions.
Project: https://t.co/GqdozdrqqR

[Ian Curtis @XRarchitect]

Here’s how to create this cool 3D scene from a single image! 📸

Midjourney (isometric image generation)
Trellis (Image to 3D Gaussian Splat)
Browser Lab (3D Editor Splat Import)

[80 LEVEL @80Level]

Have a look at this cool animation featuring Shimo from Godzilla x Kong: The New Empire unveiled by 3D Character Rigger Franco Ferrari.

More: https://t.co/RnFEznOQsA

[Alok @analogalok]

MTP (Multi Token Prediction) with 4 bit KV Cache quantization is the ultimate local AI cheat code.

Ran the updated Gemma 4 31B QAT (dense) at 65 tokens/second at 140k context on one a single RTX 4090 (24 GB VRAM).

Following up on the baseline numbers in my previous post, I pulled the latest llama.cpp source code on Ubuntu 22 (CUDA 13) to test Gemma 4 31B QAT (dense)

Fed it the same 28k token prompt. The throughput scaling is violent. Here are the exact commands and benchmarks:

# 1. The Pure Speed Run (Unquantized KV)

Maxed out the 24GB VRAM ceiling at a 36k context limit.

llama.cpp flags:
./build/bin/llama-server -m gemma-4-31B-it-qat-UD-Q4_K_XL.gguf --spec-type draft-mtp --spec-draft-model mtp-gemma-4-31B-it.gguf --spec-draft-n-max 4 --spec-draft-p-min 0.7 -c 36000 -ngl 99 -fa on --port 8080 -v

Prefill: 2093.45 t/s | Decode: 81.22 t/s
(A massive 2.5x lossless speedup from the 32 t/s baseline without MTP)

# 2. The Mid Ground (Q8 KV Quantization)

Squeezed the cache to 8-bit to double the context to 80k (23.94GB VRAM).

llama.cpp flags:
./build/bin/llama-server -m gemma-4-31B-it-qat-UD-Q4_K_XL.gguf --spec-type draft-mtp --spec-draft-model mtp-gemma-4-31B-it.gguf --spec-draft-n-max 4 --spec-draft-p-min 0.7 -c 80000 -fa on --port 8080 -ngl 99 --cache-type-k q8_0 --cache-type-v q8_0 -v

Prefill: 2050.04 t/s | Decode: 65.09 t/s
(decode was 33 t/s without MTP. 2x lossless jump)

# 3. The "God Tier" Tradeoff (Q4 KV Quantization)
Dropped to 4-bit cache to push an insane 140,000 context (23.85GB VRAM).

llama.cpp flags:

./build/bin/llama-server -m gemma-4-31B-it-qat-UD-Q4_K_XL.gguf --spec-type draft-mtp --spec-draft-model mtp-gemma-4-31B-it.gguf --spec-draft-n-max 4 --spec-draft-p-min 0.7 -c 140000 -fa on --port 8080 -ngl 99 --cache-type-k q4_0 --cache-type-v q4_0 -v

Prefill: 2150.43 t/s | Decode: 65.85 t/s
(decode was 33 t/s without MTP. 2x lossless jump)

The Architecture Insight:

Notice how quantizing the KV cache drops MTP decode speed from 81 t/s down to 66 t/s?

Standard generation is bottlenecked by memory bandwidth, every token requires restreaming the full 18GB of weights off VRAM, and the GPU's compute cores mostly sit idle waiting on that transfer. MTP doesn't remove that bandwidth cost, but it amortizes it. by verifying multiple drafted tokens in a single forward pass, you get several tokens of output per weight load instead of one, which is why the effective throughput jumps so much.

That's also why quantizing the cache eats into the gain. The q8_0/q4_0 cache has to be unpacked back into usable values on every attention step before the GPU can run the actual attention math on it. an extra compute step that plain f16 cache doesn't need.

Flash Attention's fastest kernels are built around f16 memory, so feeding it a quantized cache adds real compute latency per step, which lines up with what I measured: decode speed barely moved between Q8 and Q4 (65.09 vs 65.85 t/s) even though Q4 moves half the bytes Q8 does.

You are effectively trading ~15 tokens/second of throughput to unlock over 100,000 extra tokens of context on consumer hardware.

If you’re on a single 3090 or 4090 and benched this model earlier, the new update is your sign to run it again.

Hugging Face links to the Unsloth QAT quants and performance graph are in the replies below.

[Min Choi @minchoi]

This AI is pretty wild.

LingBot-Map can turn a live video stream into a 3D reconstruction in real time.

20 FPS

Code + Model 👇

[Akshay 🚀 @akshay_pachaar]

CPU vs GPU vs TPU vs NPU vs LPU, explained visually:

5 hardware architectures power AI today.

Each one makes a fundamentally different tradeoff between flexibility, parallelism, and memory access.

> CPU

It is built for general-purpose computing. A few powerful cores handle complex logic, branching, and system-level tasks.

It has deep cache hierarchies and off-chip main memory (DRAM). It's great for operating systems, databases, and decision-heavy code, but not that great for repetitive math like matrix multiplications.

> GPU

Instead of a few powerful cores, GPUs spread work across thousands of smaller cores that all execute the same instruction on different data.

This is why GPUs dominate AI training. The parallelism maps directly to the kind of math neural networks need.

> TPU

They go one step further with specialization.

The core compute unit is a grid of multiply-accumulate (MAC) units where data flows through in a wave pattern.

Weights enter from one side, activations from the other, and partial results propagate without going back to memory each time.

The entire execution is compiler-controlled, not hardware-scheduled. Google designed TPUs specifically for neural network workloads.

> NPU

This is an edge-optimized variant.

The architecture is built around a Neural Compute Engine packed with MAC arrays and on-chip SRAM, but instead of high-bandwidth memory (HBM), NPUs use low-power system memory.

The design goal is to run inference at single-digit watt power budgets, like smartphones, wearables, and IoT devices.

Apple Neural Engine and Intel's NPU follow this pattern.

> LPU (Language Processing Unit)

This is the newest entrant, by Groq.

The architecture removes off-chip memory from the critical path entirely. All weight storage lives in on-chip SRAM.

Execution is fully deterministic and compiler-scheduled, which means zero cache misses and zero runtime scheduling overhead.

The tradeoff is that it provides limited memory per chip, which means you need hundreds of chips linked together to serve a single large model. But the latency advantage is real.

AI compute has evolved from general-purpose flexibility (CPU) to extreme specialization (LPU). Each step trades some level of generality for efficiency.

The visual below maps the internal architecture of all five side by side.

Notice the thread connecting all five. Every generation exists to move data less, because the math was never the hard part. Feeding the math units fast enough is.

The same battle plays out one layer up in software. During LLM inference, a single GPU produces terabytes of KV cache per day, and nearly all of it gets thrown away and recomputed, which is a big reason agent workloads cost what they do.

I wrote a full breakdown of how a disaggregated caching layer fixes this, with up to 14x faster time-to-first-token. The article is quoted below.

You should also check the @lmcache GitHub repo: https://t.co/TXlaLLu04a

(don't forget to star 🌟)

👉 Over to you: Which of these 5 have you actually worked with or deployed on?

[thehype. @thehypedotnews]

veo 3.1 fast vs seedance 2.0 vs grok imagine vs happyhorse 1.1

four video models pulled from the openrouter video leaderboard by request count this week (skipping the duplicate google/bytedance variants to get four distinct labs):

#1 veo 3.1 fast (@GoogleDeepMind) – 45k requests
#3 seedance 2.0 (bytedance) – 22k requests
#5 grok imagine video (@SpaceXAI) – 9k requests
#8 happyhorse 1.1 (@AlibabaGroup) – 4k requests

so we tested them. 3 prompts, text-to-video, 16:9 / 720p / 8s, real-player likeness fed in as reference images where the model allowed it. all run via @aimlapi

in the run-up to the 2026 world cup final – argentina vs spain – we built three broadcast moments from that tie. each one has to be mechanically correct, not just pretty:

• stadium flyover – 80k-seat bowl, argentina vs spain, one continuous descending aerial spiral, tifo + flares, golden-hour / floodlight split

• penalty – lamine yamal (spain #19) vs emiliano martínez (argentina keeper): run-up, single strike, full-stretch dive, ball in the net. real faces via reference

• free kick – messi 25m out, five-man wall, curl up and over the wall into the top corner. the wall has to face the ball with arms pinned down, like a real wall

the takeaway up front: the gap that decides this isn't quality – it's moderation. three of the four refuse to render real footballers' faces (grok was the only one that took every reference), so most of the test had to be reshot "faceless" – camera behind the player. the price spread on top of that is ~4x

overall results:

cost
#1 grok – $1.56
#2 veo 3.1 fast – $3.12
#3 happyhorse – $4.38
#4 seedance 2.0 – $6.00

generation time
#1 grok – 4m 16s
#2 veo 3.1 fast – 4m 26s
#3 happyhorse – 8m 16s
#4 seedance 2.0 – 10m 38s

avg bitrate (picture density)
#1 grok – 12.0 mbps
#2 veo 3.1 fast – 11.1 mbps
#3 happyhorse – 7.4 mbps
#4 seedance 2.0 – 5.3 mbps

real faces allowed
✅ grok – took every reference
❌ happyhorse – yamal ok, messi blocked
❌ veo – blocked
❌ seedance – blocked

observations:

1. moderation is the whole story. three of the four blocked at least one real face – veo and seedance refused every reference outright, happyhorse took yamal but rejected messi. only grok rendered all of them. everything else had to be shot from behind so no face shows

2. grok is the outlier: cheapest, densest picture, fastest, and the only one that renders real faces. it won on every axis that mattered here

3. seedance is the anti-grok – 4x the cost, 2.5x the time, half the bitrate, and no real faces. worst value in the set

4. none of them understand football out of the box

follow @thehypedotnews for 24/7 ai news, analysis and breakdowns

[PixAI Studio @PixAI_Studio]

PixAI Roadmap
Live now:

Four 2D studios: Sprite, Tiles, Parallax, Props
3D model generation
On-model animation, frame control, engine-ready export
Pay-on-success, 100% burn, fully open source

Shipping next:

3D Model Marketplace, peer to peer in SOL or $PIXAI
AI art-director review on every model
Spine rig export for animators

On the map:

Style Lock across a whole project
Batch generation and asset packs
Staking
Style Marketplace, where creators publish looks others build with
API, SDK, and Unity / Godot plugins

We ship quiet and often. Most of this is already in the repo.

[Zio Yeh @ZioYeh]

Original Design: Medieval Dog
Model: XenoBuster: Synthetic Xenomorph Hunter
Modified & painted : Zio Yeh
Printer: Phrozen Sonic Mighty Revo MAX

Download the model on PIXUP 3D :
https://t.co/9bphkYxQJ5

[Md Ismail Šojal 🕷️ @0x0SojalSec]

a Cybersecurity Ai model specialized fine-tuned for offensive security it think like a penetration tester.
& Run locally

A open-source 6-bit GGUF, it’s designed to support security researchers with:

- Realistic attack scenario paths generation
- adversary simulation
- Exploit reasoning and payload prototyping
- Vulnerable code analysis
- and support ethical red-team workflows all while running locally.