u/SuspiciousHunter1359

made this character in Tripo AI and used Fable 5.5 to transfer motion onto it. It even managed to get the character to sheathe the sword, which I honestly wasn’t expecting.

I couldn’t get this working in my earlier attempts with Fable 5.1 or Opus 5.5. Still tweaking the animation and working through some foot sliding and jitter, but the character is finally doing more than standing in a T-pose.

Started with a single image of a small winter scene and rebuilt it as an interactive 3D environment, including the cabin, trees, rocks, character, and surrounding landscape.

img2threejs analyzes the image and breaks it down into individual elements. Hyper3D provides the 3D references, while GPT-6 works through the img2threejs pipeline to reconstruct and assemble everything in Three.js, handling placement, proportions, lighting, and interactive behavior.

You can walk around, leave footprints in the snow, open the gate, adjust the time of day, and place a campfire beside the cabin after dark. The original image becomes a small world you can actually explore.

Hyper3D deserves a shoutout here. Having solid 3D references makes it much easier to translate the image into a cohesive scene, especially when you’re working with a whole environment full of different objects. It’s a useful bridge between the initial concept and a world you can actually explore.

Still an early showcase, so the reconstruction isn’t perfect and this isn’t a finished game. But it shows how much you can build from a single image.

What would you compare first: the object shapes, scene layout, or lighting?

Project: https://github.com/img2threejs/img2threejs

I ran a simple side-by-side test with GPT-6 Astra and Opus 5.5: create a procedural low-poly horse with a gallop animation.

KaiNinja is a new approach that extends TRELLIS.2 to generate a 3D asset as separate part meshes directly from a single image. This makes the result much more practical for editing, materials, assembly, animation, or other downstream work.

Some highlights:

• generates separate parts directly instead of one fused mesh
• no input masks or separate segmentation network
• built on top of TRELLIS.2
• preserves contact surfaces between connected parts using a dual-volume representation
• parts can be individually selected, moved, styled, or animated
• also improves whole-object fidelity in their reported benchmarks
• inference code and pretrained weights are planned, but not released yet

github; https://alaya-lab.github.io/KaiNinja/

The character starts as a reference image, then I generate the 3D model locally with TRELLIS 2 in ComfyUI.

For animation, I create a video reference for the movement and give it to Opus 5. Opus works directly inside Blender through Blender MCP: it prepares the character, handles the rig/skin where needed, analyzes the reference motion and builds the animation on the character.

After that it can keep iterating inside Blender, fix obvious problems, test the animation and export the result for the engine.

So the workflow is basically:

reference image → TRELLIS 2 → Blender → video motion reference → Opus 5 + Blender MCP → animated character

Right now I’m testing it with basic movement like idle, walk, run, jump and some upper-body actions. The results still need cleanup, especially around deformation, but getting from a generated mesh to an actually animated character this way is already pretty interesting.

I’m working on a medieval Unity project and needed a faster way to create lots of different buildings.

Generating an entire house as one AI mesh worked, but editing it later was pretty painful. So instead, I generated separate walls, windows, doors, roof pieces and other parts, then turned them into a reusable modular kit.

I used Tripo AI batch generation to process all the pieces together, with Tripo P2 / Smart Mesh to keep the geometry relatively lightweight and usable. After that, I assembled everything in Blender and imported the result into Unity.

The topology comes out clean enough that I can actually continue working with it in Blender instead of spending half the time fixing the geometry first. Small edits, cuts, resizing and fitting modular pieces together are pretty straightforward.

This ended up saving me a lot of time. Now I can reuse the same assets to build completely different houses, add interiors and openable doors, and expand the village without generating every building from scratch.

For game environments, this modular approach makes much more sense to me than generating one giant house every time.

I literally made a skin of myself for Bully using AI

Tried a small experiment and somehow ended up putting myself into Bully lol.

I used a few photos of myself as reference, generated the base model with Tripo AI / Tripo P1, did some cleanup and adjustments, then converted everything into a usable skin for the game.

The part that surprised me most was actually the mesh. I expected the usual messy AI geometry that would need a ton of fixing, but P1 handled it way better than I expected. The forms were clean enough that getting it ready for the game was pretty straightforward.

Still needed some manual work obviously, but overall this worked much better than I thought it would.

I've been experimenting with AI-generated characters lately and wanted to see how far I could push facial expressions while still keeping everything usable with native Unreal Engine tools.

I built the character as 4 separate parts instead of trying to generate everything as one mesh, which gave me much more control over the final result.

For the 3D generation I used 3DAIStudio to generate all of the character parts. What I liked here was being able to switch between different 3D AI generators in one place depending on which model handled a specific part better, rather than constantly jumping between separate platforms. I also generated the reference images directly inside 3DAIStudio, so most of the early concept-to-3D workflow stayed in the same place.

After that I brought everything into Blender, assembled the parts and did the usual manual cleanup and geometry fixes.

One thing that surprised me was baking the high-poly details onto the generated low-poly character. It worked much better than I expected, and the final result ended up at around 34k triangles while still keeping a lot of the original detail.

The facial setup was definitely the harder part.

I created 58 different facial expression references and used them as a guide for building the blendshapes. It still needed a fair amount of manual work, but generating the head with an open mouth helped a lot with preserving details around the mouth, teeth and inner geometry.

Finally, I brought the character into Unreal Engine / UEFN and used Control Rig for the animation setup, so the finished character still works inside a pretty normal Unreal workflow.

WorldStereo is an open-source AI framework from researchers at Zhejiang University and Tencent Hunyuan that turns a single image or panorama into a controllable, multi-view-consistent environment.

Instead of generating every camera angle independently and slowly transforming the scene into visual soup, it maintains a growing geometric memory of the world.

What it can do:

• Generate new views along a custom camera trajectory
• Preserve objects and scene geometry across different viewpoints
• Expand perspective images and panoramas into explorable environments
• Reconstruct dense 3D point clouds from the generated views
• Export data for Gaussian Splat reconstruction through HY-World 2.0
• Run a faster distilled version using only four generation steps

The system combines a global point-cloud memory for the overall scene structure with spatial correspondence between previously generated views, helping reduce flickering and the usual geometry changes between camera angles.

This is not a one-click game-ready mesh generator. The main outputs are consistent videos, point clouds and optionally Gaussian Splats. The full multi-trajectory workflow also appears fairly GPU-heavy, with the official examples showing distributed inference across multiple GPUs.

Still, this could be useful for virtual environments, cinematic previsualization, world generation, 3D reconstruction and creating navigable scenes from a single reference image

Code Apache 2.0 - https://github.com/FuchengSu/WorldStereo