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'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…
Jens Fursund retweeted
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/
Jens Fursund retweeted
Ported Google's Draco decoder to pure JavaScript.
mrdoob.github.io/draco.js/
4.3× smaller than the WASM build, byte-for-byte identical output, often faster once you factor in load, init and parse.
Jens Fursund retweeted
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]
Jens Fursund retweeted
it's open source time, with a real leap for world models 🎉
NVIDIA's SANA-WM: a camera-conditioned world model that fits on one GPU. 60s of 720p in 34s on a single 5090 - 2.6B params and Apache 2.0!
huggingface.co/Efficient-Lar…
Jens Fursund retweeted
🚀🚀 Introducing Pixal3D (SIGGRAPH’26) — a new pixel-aligned image-to-3D generation paradigm for high-fidelity 3D asset creation.
Today’s Image-to-3D has become pretty good at producing plausible 3D assets. But plausibility is not enough. Fidelity is a hidden bottleneck.
❓A generated model may look “about right,” yet still fail to truly align with the input pixels. Can we make 3D generation as faithful as reconstruction, while still allowing it to complete the unseen?
Pixal3D is our answer.
💡We believe the core bottleneck behind fidelity is 2D–3D correspondence. Most 3D-native generators synthesize shapes in canonical space and inject image cues through cross-attention, forcing the model to implicitly search for which pixels correspond to which 3D regions.
🍀Pixal3D takes a different route. Instead of generating in canonical space, Pixal3D generates directly in pixel-aligned camera space — what you see is what you get. The generated 3D asset is aligned with the input view from the start.
☕️Meanwhile, Pixal3D introduces back-projection-based image condition scheme - explicitly back-projects multi-scale pixel features into 3D voxels, thus resolving the 2D-3D association problem. The input image is no longer just a prompt - it becomes a geometric anchor.
🚩Pixal3D shows that pixel-aligned 3D generation is not only feasible and scalable, but also significantly improves fidelity, pushing 3D-native generation closer to reconstruction-level faithfulness. It also naturally extends to multi-view and scene-level 3D generation.
✅Faithful to the input view. ✅Generative for the unseen.
Closer to reconstruction-level fidelity, with the creativity of 3D generation. Pixal3D also represents an effort towards the unification of 3D generation and reconstruction.
📢Paper, code, and demo are fully released — try it out and let us know your feedback!
🌐Project page: ldyang694.github.io/projects…
🤗Huggingface Demo:
huggingface.co/spaces/Tencen…
💻Code:
github.com/TencentARC/Pixal3…
📄Paper:
arxiv.org/abs/2605.10922
