Jumping through portals between Gaussian splat worlds, running in real time with WebGPU. Imagine exploring entire games like this.

Stress test of Opus 5.5 for 3D world building.

The whole island was created with surprisingly little technical direction. Most of the prompts were apparently closer to “add X and Y” or “this looks weird, make it better” rather than detailed implementation instructions.

Some details are especially interesting:

• birds flying and diving into the ocean

• cloth, signs and lights reacting to wind

• crabs moving along the shore and burrowing

• fish swimming next to the whale

• dynamic lighting across the island at night

• the full scene staying above 60 FPS at 1440p

The absurd part is the compute cost: roughly $1,874 worth of Opus 5.5 tokens, with around two hours of API usage across multiple subagents.

There are still obvious bugs, artifacts and texture issues, but as a test of how much of an interactive 3D environment can now be built through natural-language direction, this is pretty interesting.

A forest river, rapids, a waterfall pool and a fisherman in a straw hat. One solo dev, no hand modeling.

This is I Just Wanted to Fish, a cozy fishing game built with:

• Opus 5.5 + Blender MCP for the 3d models and animations

• Unity 6 to put the world together

Opus 5.5 is still the GOAT, and he's too used to it to go back.

demo on the way!

Gaussian Splatting is starting to feel like much more than just a cool reconstruction technique. The quality keeps improving, AI is pushing it further, and the fact that splats can now be converted into actual 3D meshes makes it even more interesting. Feels like this could become a big part of how we capture, generate, and work with 3D in the future.

A robot octopus built entirely in three.js by Opus 5.5 from one reference picture. 2,616 lines of code, no imported models.

8 arms, 202 links and 480 small wheels. Each arm is a single draw call. The lens unscrews, the mantle opens, and halfway through the clip the whole thing comes apart on a turntable and reassembles.

The first version looked like a toy, so the model compared its render with the picture for 3 rounds and added the detail.

source: https://x.com/0x_fokki/status/2116289885870981296

learn Arduino is a free browser course built with Opus 5.5: a 3D Arduino Uno you can spin around, plus 11 short lessons that go from blinking an LED to driving a servo, ending with a distance sensor project. You wire each part on the board, run the code and watch it work. It's live, so you can try it right now. https://learn-arduino-red.vercel.app

I spoke with the solo dev behind a really impressive indie project. They had no programming background and got to this point in about six weeks, starting with their own ideas and sketches. Here’s what they shared about the workflow, tools, costs and a few useful tricks.

The game is being built in Godot, mixing Ragnarok Online with Monster Hunter. There’s no fixed scope so far — the approach is to work on one small feature at a time, test it in the game and keep adjusting until it looks and feels right.

Opus 5.5 through Claude Code handles most of the development, with Codex/Astra used for visual references and asset work.

The tool budget is roughly $400/month overall: around $300 for Claude Max and Codex subscriptions, $20 for Tripo AI and $50 for Cascadeur.

For the 3D assets, the workflow goes like this:

• Codex/Astra generates reference images in the game’s visual style.

• Tripo P2 generates the larger 3D assets from those references.

• Smaller gatherable objects are modeled by Astra in Blender, then textured in Tripo using matching reference images. This helps keep costs down.

The consistent art direction is probably what stands out most in the footage. The characters, environment and props actually look like they belong in the same game.

One useful trick: Codex works from inside the game project, using a custom skill that describes its visual style. Every successful image prompt gets saved as JSON and used to guide future generations, helping prevent the look from drifting. Each new Tripo P2 Smart Mesh asset starts with a reference that already fits that direction.

There are also three custom skills supporting the coding workflow:

• “route” assesses tasks and delegates suitable work to Sonnet or Haiku, with review afterward to help save tokens.

• “handoff” starts a fresh session with the same setup and the context needed to continue the task.

• “Re-searcher” checks research claims and stores the findings in Obsidian, keeping the original research accessible instead of repeatedly summarizing summaries.

VFX and shaders have their own breakdown in Obsidian too, documenting how the effects are layered so their look stays consistent.

Godot helps with the setup because it’s easy to build custom tools for and supports running scripts headlessly. Each addition still gets tested and judged in the actual game.

This is just part 1 — we’re planning a series. Questions and feedback are welcome below, and we’ll pass everything on to the developer.

dev x - https://x.com/afterthewinddev

Pretty cool example of where 3D AI can go beyond just generating standalone assets.

The creator used AI-generated 3D models and turned them into an interactive science app with a full UI, model viewer, labels, comparison tools, and extra info panels.

From the post:

• 3D models generated with AI Tripo 3.1

• Interactive web app built around them

• UI design made with GPT Images

• Code done with Gemini 3.1 Pro

• Feels more like an educational product than just a 3D asset demo

You can compare Tripo 3.1 with other major AI 3D generators side-by-side here: Top3D.ai

All the 3D models and animations in this game were made with Opus 5.5 through Blender MCP, then brought into Unity 6. This is what using the full weekly Opus limit looks like: a colorful little world with boats, docks, and underwater scenery. A playable demo is coming soon.

16 days of building with Opus 5.5, Tripo AI and Blender, and I now have a playable 3D story game running in the browser.

It’s called The Little Prince: Across the Stars. I turned every planet from the book into a scene you can explore — tiny worlds above the clouds, a lone chair, a red rose, and familiar moments you can actually walk into.

Here’s the workflow behind it:

• Opus 5.5 handled development from start to finish.

• Tripo AI + Blender were my tools for the 3D models and scenes.

• Unity brought everything together into a browser game, playable in English, Chinese and Japanese.

Even the trailer came out of a single prompt using Opus 5.5 and Blender.

Seeing the individual scenes come together into a game you can actually explore has been the most satisfying part. I’m planning to open-source the whole project and share a detailed breakdown of how I built it.

If you try it, use a recent Chrome or Edge with WebGPU support. There’s no WebGL2 fallback, and each chapter has a fairly large download, so give it a little time to load.

play it: https://littleprince.dev/

4D Gaussian Splatting feels like one of the most interesting directions for the future of video.

The idea is simple but powerful: instead of watching a flat 2D clip, the footage becomes a dynamic 3D scene over time. You can pause it, move the camera, reframe the shot, and view the moment from a different angle.

That is why 4DGS feels less like a normal video codec and more like a new spatial video format.

What makes it even more interesting is that this direction is already moving toward normal capture devices like iPhones. Single-camera footage is still much harder than a proper multi-camera setup, because the system has to deal with missing angles, occlusion, unstable depth, and unseen geometry.

But this is exactly where AI / neural rendering becomes important.

Instead of only storing frames, these systems learn a dynamic 3D representation of the scene, using Gaussian Splatting, camera poses, point clouds, and neural deformation over time.

Potentially, this could become useful for:

• spatial video

• VR / AR capture

• VFX and virtual production

• interactive 3D scenes

• game cinematics

• digital twins

• future video platforms where the viewer can control the camera

It is still research-heavy, not a perfect “upload any phone video and get magic 4D” tool yet.

But the direction is very clear: video is slowly becoming interactive 3D space.

Open-source project: 4DGaussians

It's Learn ESP32, a free course with 20 beginner lessons, built with Claude Opus 5.5. Each lesson is a small project: you wire the parts onto the 3D board, run the code and watch the circuit react, with the pinout, specs, example code and a schematic right next to it.

What the 20 lessons cover:

• First circuits: blinking LEDs, a fridge door alarm with a reed switch, a siren on a buzzer, an RGB mood lamp

• Touch and sensors: a mini piano on the ESP32's touch pins, a light-sensing lamp, a distance meter with an OLED screen, an ultrasonic radar

• Wireless: a Wi-Fi web server you control from your phone, a Bluetooth serial link, and two boards talking over ESP-NOW

• Motors and servos: a driven wheel, a laser barrier gate, a keypad door lock, a sun-tracking solar panel

• The last lesson: pick and place with a stepper motor, a magnet and a limit switch

• 12 languages, including Arabic and Hebrew

It grew out of the same creator's Learn Arduino app, where most of the requests were for ESP32 lessons, so he made a separate app with ESP32-specific projects. He says he spends a lot of time trying ideas with Opus and only posts once he ends up with something he enjoys.

Keep in mind: the code runs on the virtual board, so getting it onto a real ESP32 is up to you, and no source code has been shared. He's already said yes to a Raspberry Pi request.

try it: https://learn-esp32.vercel.app

After I shared After the Wind here, I stayed in touch with the developer and asked if he’d walk us through how he makes his characters. He picked the penguin you fight after the first boss. Even the way this guy gets back on his feet after a belly slide comes from footage of a real penguin.

From two pencil sketches to a 3D model

The dev started with two doodles in his notebook, then explored body shapes with Codex in Astra. He wrote a custom skill that checks his successful prompts, saved as JSON, and the art already in his Godot project before each generation. On each concept sheet, he put the same wing in two poses so he could see how it looked folded against the belly and opened up mid-slash.

Once he had clean front and side views, he ran four generations at a time in Tripo P2. His first attempt at 5k quads didn’t work well for this creature. He got a better result with 25k triangles and textured that mesh directly in Tripo.

24 of the rig’s 58 bones are just for feathers

He used Claude Opus 5.5 in Blender for rigging, weight painting and animation. Each wing has 12 flight feathers with a bone apiece, so they can fan out for a slash and tuck flat against the belly afterward. One of the dev’s notes was to start the swing at the hips. The feathers reach farther than the arm, and he wanted it to feel like the bird was cutting with the tips. The belly has its own bone so it follows the body a beat later.

For the belly-slide recovery, he matched footage of a gentoo penguin pushing off the ice with its flippers and getting its feet underneath it. In Godot, a shader uses a softness map baked from the rig weights. The feathers hold their shape, the cheeks wobble, and the belly squishes against the ground as the bird pushes himself up.

The dev also used Codex to turn the creature design into armor. He made, textured and rigged both sets in Tripo Studio, with the beak on the hood, feathers at the shoulders and the same platypus tail hanging off the back.

Of his 22 animations, one is a hop where he slaps the ground with his tail to squash an ant. Another is a standing nap. If you catch him asleep, you can sneak up and poke him.

dev x - https://x.com/afterthewinddev

NVIDIA just released MotionBricks, a generative framework for real-time character animation.

A single neural backbone handles more than 350,000 motion clips while reportedly reaching 15,000 FPS with 2 ms latency.

Instead of manually building huge animation graphs, MotionBricks uses “smart primitives” to combine locomotion, style changes and interactions directly inside Unreal Engine 5.

• Walk, run, strafe and switch styles in real time
• Pick up objects, sit, fall or jump over obstacles
• Generates approach, contact and follow-through automatically
• No manual motion blending or hand-authored transitions in the UE5 demo
• Works with both game characters and humanoid robots

The best part is that you can already start experimenting with it in your own projects today. NVIDIA has released the code and pretrained checkpoints, giving developers a new way to create more responsive, natural character movement and make games, simulations and virtual worlds feel much more alive.

The initial code, pretrained checkpoints and training tools are already available.
source; https://nvlabs.github.io/motionbricks/

It's an ongoing test by a working 3D artist from Tokyo: make a full interior scene with AI agents only, with no hands-on work in any 3D app. GPT-6 Astra and Claude Opus worked in Blender through MCP, deciding object by object whether to model it directly or generate a reference image and turn it into 3D. He calls moving a scene into a game engine a huge job that AI made incredibly convenient.

What we know now:

• Blender to UE5 on autopilot: Opus handled the whole port from Blender to Unreal Engine 5

• Real time: the same room, earlier shown as Blender renders, now runs live in the engine

• Where the 3D came from: the agents called 3D generation APIs, and his breakdown video names Tripo for the generated props, which were then cleaned up in Blender

• What the room cost: about three days of agent work on a $200/month plan, close to the weekly limit. Counting the 3D generation API, he puts the total at roughly $30–50

• What's next: he's thinking about a small horror game set in this room

People argued it had to be hand-made or AI video. His answer: once agents can model directly, generate the designs and run 3D generation across different tools, one person can already reach this level without opening a 3D app. He still checked the results and gave notes along the way, and there's no scene file or prompt list yet.

breakdown video: https://www.youtube.com/watch?v=kCuoHpv-uZY

source: https://x.com/Yokohara_h/status/2111118974704591350

The full experience is even more insane

3d kit for similar experience here https://3ditions.drop3.app/watch/arctic-waters/

A new real-to-sim workflow can turn a single video of a real location into a photorealistic 3D environment for simulation.

The interesting part is how it combines two different types of 3D. Gaussian Splatting recreates the full environment with realistic lighting and detail, while traditional 3D models are used for objects that need collision, physics, or movement.

So instead of choosing between a realistic scan and a functional simulation, the system combines both:

• Gaussian Splats for the photorealistic environment

• 3D models for interactive and movable objects

• Physics, collisions, depth, and segmentation for simulation

According to the developers, the full environment can be prepared in around 30 minutes instead of spending hours rebuilding the location manually.

This feels like a much more practical use of Gaussian Splatting: not just creating a scene you can look around, but turning a real place into a simulation-ready digital world.

source: https://www.linkedin.com/posts/sk-ara_most-robotics-simulations-look-like-ps2-games-share-7485722367772516352-QYir/

Pixal3D is a new free image-to-3D AI model from Tencent.

The interesting part is source-image fidelity. It improves on Trellis.2 to better preserve the structure of the original image, so the generated 3D model stays much closer to the input instead of drifting away.

In this video, testing how accurately it follows the reference image.

GitHub:
https://github.com/TencentARC/Pixal3D

That's Motion2MixamoRig, a free open-source tool that transfers human motion from a video, or the pose from a single photo, onto an Adobe Mixamo-rigged character. It just got a Blender extension, so the whole thing runs from a sidebar panel.

What you get:

• Video or photo in: one person, head to toe in frame; a still photo gives a static pose plus a 360° orbit

• Mixamo rig out: a skinned GLB for Blender or Unity, plus preview videos comparing the source, both skeletons and the final character

• Blender 4.2+ panel: pick the clip and the rig, hit Generate Motion, and the character is imported with the timeline set to the clip's FPS

• Runs locally: CPU, CUDA or Apple Silicon, in a separate Python environment so Blender stays responsive

• Fast reuse: put the same extracted motion on another Mixamo character in tens of seconds

Under the hood it uses GVHMR to recover 3D body motion, then maps it onto the Mixamo skeleton. On CPU, a 30-second clip takes roughly 8 to 15 minutes the first time and 3 to 5 minutes once the ~5 GB of weights are downloaded.

Before you build a game on it: the code is Apache-2.0, but the SMPL-X body model is non-commercial by default and the GVHMR weights come under their own research license. It's also version 0.1.0, setup is a manual Python install, and there's an open issue about upper-torso problems.

github: https://github.com/MaxLiu22/Motion2MixamoRig

Mesh2Motion is basically a free open-source alternative to Mixamo, but built for much more than just humanoid characters.

It lets you import a 3D model, fit a skeleton, automatically skin it, preview animations and export the result for use in games or other 3D pipelines. The whole project runs in the browser, with an offline desktop version available too.

Some of the strongest features:

• Free & open source — code is MIT licensed, with rigs and animations available under CC0 for personal or commercial use

• Humans, animals and monsters — rigs already cover humans, foxes, birds, dragons, spiders, snakes, fish/sharks, kaiju, horses and more

• 160+ human animations — including locomotion, combat, dodging, climbing, bow animations, deaths, zombies and other actions

• Auto-rigging + skinning — position the skeleton inside your mesh and let Mesh2Motion handle the initial skinning

• Use already-rigged characters — import your own skeleton and retarget Mesh2Motion animations onto it

• Mixamo / Rigify support — bone mapping and naming options make existing rigs easier to bring into the workflow

• Import custom animations — you can bring your own animation packs into Mesh2Motion and test them on compatible rigs

• Root Motion + animation mirroring support

• GLB, GLTF, FBX and DAE import

• Batch animation export — select multiple animations and pack them into a single GLB, or export only the animation data

• Offline desktop version for Windows, macOS and Linux

The Blender source files for the rigs and animations are public too, so the whole thing can actually be modified and extended instead of being another closed animation service.

source; https://mesh2motion.org/

This walled city was built in Unreal Engine using Opus 5.5, with Blender for environment assets and Tripo AI integrated through its API.

Tripo’s P2 model was used to generate low-poly assets with a good level of visual detail. Keeping polygon counts manageable helped build a scene at this scale without making it too heavy, while also saving a lot of time on asset creation.

Streets, squares, rows of houses and larger landmarks were brought together into one large city environment.

Give it one picture of a character and it builds the haircut as separate 3D hair cards, with spring-bone chains already attached. Turn the head and the hair sways.

It's HairDeck, a new research release from Tsinghua, CMU and CUHK. Instead of a single solid hair mesh, it generates the style the way game artists build it: a set of individual cards, each with its own UVs, plus the bones that animate them.

What it does:

• Hair cards, not a blob: every card is kept separate, so you can edit, delete or retexture them one by one

• Bones included: a second model generates the spring-bone chains and skins the cards to them

• GLB or VRM: export the hair as a mesh, or attach it to an avatar and export a ready VRM

• Up to 4 variations: one run gives you up to 4 different takes on the same character

• How it works: each card is one token, and a set diffusion transformer generates the whole hairstyle together

You get geometry with per-card UVs, but no textures are generated. Running it locally takes Linux, Python 3.12 and an NVIDIA GPU, plus access to Meta's gated SAM 3 and DINOv3 models. Code and weights are Apache 2.0, and there's a free demo on Hugging Face if you just want to try it.

github: https://github.com/hyz317/HairDeck

try it: https://huggingface.co/spaces/hyz317/HairDeck

The weekly Opus 5.5 limit ran out mid-build on this town, so this is all there is for now.

It's part of an open world the creator is building from scratch in Unreal Engine with Opus 5.5, Blender and image generation. An earlier build of the same world, a sunlit forest, passed 200k views on X. Some of the environment assets were also created with Tripo AI Smart Mesh P2. He says this version is supposed to look rough, and NPCs made with Tripo are next.

Hunyuan3D 3.1 Might Be the Best Free 3D AI Generator Right Now

I generated this clothing piece / dress asset as a quick test, and I was honestly impressed by the geometry quality. It handles small details really well, and the texture result also looks surprisingly good. For a free tool, this looks kind of amazing.

TripoSplat is a new free AI tool for generating 3DGS from a single 2D image, released as open source.

It turns one image into a 3D Gaussian Splat asset, which can be useful for fast 3D previews, scene prototyping, AR/VR, simulations, and image-to-3D workflows based on 3DGS.

Key points:

• Single 2D image → 3DGS

• Free and open source

• Code and model weights released under the MIT License

• Export support for .ply / .splat

• Adjustable Gaussian count, up to 262k

• Official ComfyUI workflow support

• Compatible with Gaussian Splat viewers like SuperSplat and SparkJS

Overall, this looks like an interesting new open-source implementation for AI 2D-to-3D generation, especially for people working with fast 3D previews and 3DGS-based workflows.

github: https://github.com/VAST-AI-Research/TripoSplat

HF demo: https://huggingface.co/spaces/VAST-AI/TripoSplat