
Building https://xitter.cf/t.co/rjKXqiUKJx. Past: @Cylindo3D/@ChaosGroup, @PinscreenInc, @ImaginationTech, @ILMVFX, @unity3d
Copenhagen, Denmark
Joined February 2009
- Tweets3.3K
- Following1.3K
- Followers1.3K
- Likes2.1K
Jens Fursund retweeted
I may have cracked how to animate non humanoid assets with AI! H3 Max generates a video from front and side then we use a finetuned DINOv2 model to track joints! The vid explains the whole process
Open source: github.com/patch-gg/anymove
Jens Fursund retweeted
After reading Barron et al.'s paper, we'd like to share our #NeurIPS2026 paper! Their fix for Softmax Collapse is elegant, but only briefly explains how it triggers Slingshot loss spikes. Our paper traces the mechanism 5 months ago (1/8)
xitter.cf/jon_barron/status/2113…
Jens Fursund retweeted
Introducing beignet, a new neural field architecture!
beignet uses a multiresolution fourier frequency pyramid to achieve faster convergence and higher precision when solving PDEs and finding singularities.
Teaser: here is beignet at work fitting an image (super fast)!
Jens Fursund retweeted
1/ The tokenizer is a new scaling axis!
We introduce an approach for diffusable representation learning that's principled, scalable, and works when DINO/LeJEPA collapse.
We get joint tokenizer+diffusion scaling laws and it's compute-optimal vs raw diffusion
w/ @drfeifei @GordonWetzstein @jcjohnss @ericryanchan @vincesitzmann @KyleSargentAI
Thread, Paper, and Blogpost below
Jens Fursund retweeted
I'm giving away $1,000 of HF credits 🤗
$10 x 100 people, I want you to experience this:
> having your agent launch hundreds of HF Jobs
> run ~33M tokens of DeepSeek V4.1 Flash
> deploy your own dedicated Qwen3.8 27B endpoint
> Agents + Blender on a GPU because it's 🔥
Just reply with your HF username 👇
Hugging Face Jobs usage is stonking 📈
All thanks to agents: you just need the hf CLI installed and you have access to an insane amount of hardware.
Asked mine to test hundreds of code snippets from Hub model pages: it launched 322 Jobs in 90 minutes, up to 25 at once, CPU to A100 (diffusers, transformers, sklearn, MLX, Keras...)
Total bill: ~$4 🤯
Jens Fursund retweeted
We'll present Déjà View as Oral at #NeurIPS 🎉
TL;DR: we beat VGGT-Ω on average with a 10x smaller, looped architecture.
Check it out 👇
Jens Fursund retweeted
Introducing GAE🥳🥳
Generate once. Decode RGB + point clouds.
GAE generates directly in a geometry-native latent space. The same generated latent supports both appearance and 3D geometry.
The key choice is where generation happens. GAE compresses geometry-foundation features into a shared latent space. A conditional flow model generates directly in that space; RGB and geometry are decoded from its final state.
The video pairs show camera-conditioned world generation; the character pairs show text-to-image generation. These native showcase clouds are not reconstructed from generated RGB.
Code: github.com/TencentARC/GAE
Page: jiah-cloud.github.io/GAE.git…
Nearly half a year of silence. We spent it studying one problem: how far RL can scale.
MiMo-V2.6 is in the middle of its RL run right now. Three things we scaled: compute (~2B tokens per step, 1568 prompts × 16 rollouts, fully async), environments and harnesses (multi-task agentic RL, mixed across multiple harnesses in one run), and grader compute (agentic in-group credit assignment, with test-case and rubric-based rewards). We'll open-source the details piece by piece over the coming weeks.
Streaming the run: mimo.xiaomi.com/rl/
Jens Fursund retweeted
After co-inventing ChatGPT, I kept asking myself: why have superhuman chat models not led to AGI?
I’ve spent the last 2 years in stealth building a new way to train models (RLCD), and a new type of frontier AI model that we are releasing today: Jev
• 20-200x faster
• 40-400x cheaper (w/ output tokens free)
• Frontier composable intelligence optimized for decisions
AFAICT the shortest path to AI-based economic revolution
Jens Fursund retweeted
📢TriFlow: Generating Artist-Like 3D Mesh Topology via Nearest-Vertex Vector Fields (ECCV'26)📢
Compact 3D meshes with clean, artist-like triangle topology - structured connectivity you'd expect a human modeler to make🙂
🌐derkleineli.github.io/triflo…
▶️youtu.be/Nl57QcuKkeA
PRXPixel by @photoroom is pretty good for a small model! Did some experimentation to see if I could get it to run in the browser. You can try it out here: imagegen.sqrm.co/
Jens Fursund retweeted
What if you could turn any number of photos (3, 8, 15, or even 60) into one clean 3D surface (pts & mesh) with Flow Matching?
Check out our new work, Surflo: Consistent 3D Surface Flow Model with Global State. 🧵
1/n
🔗anttwo.github.io/surflo/
Jens Fursund retweeted
Introducing World Tracing
Generative pixel-aligned geometry, beyond the visible.
Faithful to your pixels. Complete in 3D.
One image in — objects, scenes, even dynamic worlds emerge in full geometry, every point traced back to the pixel it came from.
🌐 haoz19.github.io/world-traci… 🧵 [1/6]
Had some fun with the new TripoSplat from Vast.ai, it's a nice model! Got it to run in the browser by quantizing a bunch of the weights and chunked SDPA, you can try it out here: splat.sqrm.co/
For over a decade, we’ve accepted that end-to-end backprop is the only way to train deep networks. But holding the entire network in memory all at once is why AI training is hitting a resource wall.
We found a new way to break the network into blocks and train them independently. The trick? Treating the network’s forward pass like a diffusion model denoising a signal.
This reinterpretation slashes the memory needed to train deep models. In our #ICLR2026 paper (arxiv.org/abs/2506.14202), we matched end-to-end performance across ViTs, DiTs, and LLMs. We did this while training just one isolated block at a time.
Introducing DiffusionBlocks: Block-wise Neural Network Training via Diffusion Interpretation
pub.sakana.ai/diffusionblock…
What if we didn’t have to hold an entire neural network in memory to train it?
Standard neural net training optimizes all parameters jointly. As a result, the memory required during training grows linearly with the depth of the network.
In our #ICLR2026 paper, we propose DiffusionBlocks, a principled framework to train networks one block at a time, drastically reducing memory requirements while matching end-to-end performance.
With DiffusionBlocks, we split the network into blocks and train them one at a time, so you only need memory for a single block.
How? We explicitly assign each block a role: to move the representation a little closer to the target than the block before it did. That role turns out to be precisely what a diffusion model does, step by step. Each block only needs to optimize its own objective and can be trained independently.
We validated this across five different architectures:
• ViT
• DiT
• Masked diffusion
• Autoregressive transformers
• Recurrent-depth transformers
In each case, performance is competitive with end-to-end training while using a fraction of the memory.
This perspective also extends naturally to recurrent-depth (Looped) transformers, which apply the same network iteratively and normally require expensive backpropagation through time (BPTT). Viewed through DiffusionBlocks, we can replace those multiple iterations with a single forward pass during training.
Read our paper and code, to learn more.
Paper: arxiv.org/abs/2506.14202
GitHub: github.com/SakanaAI/Diffusio…
🐟
Jens Fursund retweeted
🚀 Exciting news! We’re introducing VGG-T³: a scalable model for offline feed-forward 3D reconstruction that finally tackles the "quadratic bottleneck."
Ever wanted to have VGGT reconstruct a 1,000-image scene in seconds instead of 10 minutes and use it for visual localization?
Jens Fursund retweeted
High-fidelity generation is hitting a scaling crisis as DiT compute grows with image resolution and video length. But do we need high-resolution denoising at every step?
We introduce Spectral Progressive Diffusion, a plug-and-play framework for efficient image and video generation that directly exploits the spectral autoregression property of diffusion to grow resolution during denoising.
[1/7]























