Almighty: type a sentence, get a textured 3D model you can grab and toss (Babylon.js 9 + Havok)

Hi everyone! We built Almighty, a browser studio where you describe anything (or upload a photo), pick one of a few AI concept sketches, and get a textured 3D model on a small museum stage you can orbit, grab and toss. The viewer and stage are all Babylon.js 9, so here is what is under the hood.

Try it: Almighty: AI 3D model generator, describe anything into 3D

almighty-anglerfish-turntable

Stage physics (Havok, Physics V2)

  • Each piece rides an invisible box carrier that is its rigid body, inside a walled enclosure. Grabbing it attaches a spring-damper toward the pointer; let go and it keeps its throw velocity, then settles upright.
  • Rigged pieces with a walk clip walk on their own. The clip animates the legs in place and one propulsion force along the mesh’s forward moves the body. Clip speed is locked to the measured ground speed so the feet don’t skate, and the lowest skinned point is measured over the first cycle so the feet plant on the floor.

Lighting

  • A procedural IBL baked into a RawCubeTexture, KHR PBR Neutral tone mapping, SSAO2 plus the DefaultRenderingPipeline.
  • Contact-hardening (PCSS) shadows. Ours looked like a flat cutout until we fitted the key light’s shadowMinZ/shadowMaxZ tightly around the piece every frame.

Framing

  • Generated meshes come in every shape, and bounding-box framing let round or deep pieces run past the edge. We slice the mesh by height, take the largest radius in each slice, and solve the camera distance so every slice fits the visible area at any turntable angle.

Pipeline

  • The 3D generation itself is Tripo’s API. On our server, gltf-transform re-encodes each GLB to Draco geometry with 2K WebP textures (roughly 50 MB down to 8 MB), and the Draco decoder is served same-origin.

Questions welcome, and we’d love feedback on how the viewer feels on your hardware.

6 Likes

Wow! It’s super great!

cc @PirateJC

1 Like

Thanks Cedric, that octopus came out great! The little numbered dot on top is an explainer highlight: a short note about the piece, pinned to a point on the mesh, that opens when you click it. If you want the model itself, your piece’s page has GLB and STL downloads.

@PirateJC if an entry on the community page would be useful, happy to send a short clip or anything else you need.

2 Likes

Added! This is very cool!!!

Babylon.js Community Demos

Impressive work!

With just a simple prompt, it generated three excellent character variations. The base modeling quality is absolutely spectacular!


I even tried animating one of them directly using my BJS Character Controller, and with just a couple of minor code tweaks, everything worked perfectly!

I also really appreciate the pay-per-credit model. It’s a refreshing alternative to the endless micro-subscriptions we’re seeing with practically every app and service these days.

Highly recommended! Fantastic work!

4 Likes

@PirateJC thank you for adding Almighty to the Community Demos page. That means a lot coming from the Babylon team.

@DRLeria thank you, this made my day! A generated character walking around in your BJS Character Controller is exactly the use I was hoping for. If you have a short clip of it running, I would love to see it in this thread.

I am also curious what the couple of code tweaks were. If any of it came from our side (scale, facing direction, the root node), I would rather fix it in the export so the GLB drops straight into a controller.

And on credits: no subscription is a deliberate choice. You pay only for what you make, and credits never expire.

That’s amazing!

Hi @almighty3d! Once again, congratulations on the amazing work.

A good first step might be to ensure that generated models have their feet aligned with ground level on export.

Another useful improvement could be post-generation mesh optimization, potentially using meshoptimizer ie. Arseny Kapoulkine (package npm meshoptimizer, WASM compiled), especially for high-density meshes.

On my side, I’ve been testing an Almighty-generated character (Ashen) with my BJS Character Controller, and it actually helped me identify and improve several aspects of my experimental auto-rigging system.

Here are some interesting findings:

1. Character orientation

Issue: Ashen originally faces +X, while my auto-rigging system expected characters to face along ±Z. This caused the arms to cross the chest during rig generation.

Solution: I improved the orientation detection using left-right mesh symmetry rather than relying on bounding-box dimensions, which can be unreliable for characters in an A-pose.

For Ashen, the symmetry score improved from 0.51 to 0.87 after a 90° rotation.

I also tested this approach against 11 additional models, with no incorrect rotations observed.

The character is now automatically oriented toward +Z before rigging.

2. Full five-finger detection

Issue: The original detector identified only one finger because the outermost point of the arm in an A-pose wasn’t necessarily the fingertips. Ashen’s actual hand length was approximately 1.41× the initial estimate.

Improvements:

  • Hand length and direction are now estimated directly from mesh geometry.

  • Finger separation is tracked along the mesh surface starting from the wrist.

  • The detector can handle sideways or partially curled fingers while filtering out disconnected geometry.

  • Knuckle placement and thumb positioning have been refined.

  • Finger bone proportions have been adjusted to better match Mixamo-style rigs.

I tested the result by closing the character’s fist in simulation. Finger flexion now looks natural, with each fingertip following its corresponding finger bones.

3. Rigging a million-vertex mesh

This was probably the most interesting technical challenge.

Issue: Enabling finger rigging on Ashen triggered a memory-budget error due to the combination of approximately 1 million vertices and 52 bones.

It also prevented some of the more advanced weight calculations from running, particularly those designed to avoid unwanted deformation between nearby body parts.

Solution: Instead of evaluating all 52 bones for every vertex, the system now retains only the 10 nearest bone candidates.

This reduced the relevant weight-calculation memory usage from approximately 200 MB to just 3 MB.

Results:

  • Approximately 11 seconds for server-side rigging, including fingers.

  • Advanced weight calculations remain enabled across the mesh.

  • A reported skinning validation score of 100/100 in my current tests.

4. Finger skinning in the rig builder

I also discovered that the Symmetric Editing option, enabled by default, was averaging finger markers and moving them out of position.

This prevented automatic skinning from being applied correctly.

Finger markers are now excluded from that symmetry operation, allowing both hands to export with proper skinning.

5. Automatic positioning, rigging and animation

Ashen’s original pivot was located around the middle of the body, with the feet approximately 0.92 m below the origin.

I updated the import pipeline to automatically:

  • Align the feet with ground level.

  • Normalize the character’s root and hip positioning.

  • Detect orientation and generate the skeleton.

  • Apply the animation library.

Final result: Approximately 45 seconds from importing the generated model to having a character ready to use, with 52 bones and 88 animations.

The feet end up within 2 cm of ground level, and the hip alignment is within approximately 3.7 cm of the character’s central axis. Overall, the resulting skeleton is closely aligned with my Mixamo reference character.


Of course, some of these steps could also be handled through external tools or dedicated rigging software.

But I think Almighty Studio’s real strength is the quality of its generated models, and that’s where I’d personally focus development.

The geometry is already impressive, and having a solid, predictable export pipeline would make these models even easier to integrate into Babylon.js projects.

Great work, and thanks for providing such an interesting model to experiment with! :rocket:

Hi again @almighty3d!

I’m currently testing some of your generated models inside my app AO Lightmapper, where I’m integrating Meshoptimizer for an upcoming version.

As part of that work, I made a quick set of tests to evaluate how the mesh behaves under different optimization levels. I prepared 3 screenshots, each one showing a different optimization stage, along with wireframe views for easier inspection.

The comparison includes:

The purpose is simply to explore the balance between geometry density, shape preservation, and runtime efficiency.

The original generation quality is already very good, so this is more about testing how suitable the output is for lightweight Babylon.js workflows, especially when targeting faster downloads, lower memory usage, and better rendering performance on the web.

1 Like

@DRLeria thank you for testing this so thoroughly. Both of your suggestions are built and go live in the download panel today.

Feet on the ground, facing +Z. You were right that Ashen faced +X. The generator points the side shown in the concept image along +X, and static pieces come back centred on the origin, so half the mesh hung below y = 0. Every download (GLB and STL) is now turned a quarter turn about Y so the front faces +Z (the glTF convention), centred on X/Z, with its lowest point at y = 0. On static pieces the transform is baked into the vertices, so every node is identity. On rigged pieces it sits on one root node above the skeleton, since skinned vertices follow their joints.

A Web GLB, simplified with meshoptimizer. A third download button gives the same textured model at about 200K triangles (gltf-transform’s simplify() with MeshoptSimplifier, UV seams kept so the textures stay put). Ashen goes from 1,957,250 triangles and 55 MB to 199,982 triangles and 7.5 MB. A rigged, animated diver goes from 73 MB to 10 MB with its skin and walk clip intact. The full-detail GLB is still there for baking or sculpting.

Keeping only the 10 nearest bone candidates to rig a million-vertex mesh is a great find, and the symmetry-based orientation check is a good safety net for models from anywhere else.

One question back: is around 200K a good target for your controller and AO Lightmapper, or would a lighter game tier (around 50K) be worth adding?

1 Like

Wow!! this is amazing sir!

I also would suggest adding a hyper-optimized version, keeping in mind that many games, for example, display characters from a distance, where such a high polygon count isn’t necessary.

You could also look into further optimization options, such as using Draco compression when exporting your model, applying texture compression (WebP, JPG, KTX2), and adjusting texture resolution.
The same model:

  • Original: 55 MB
  • Optimized (MidQ): aprox. 260,000 verts - 10 MB
  • Optimized (LowQ): aprox. 112.000 verts - 7 Mb
  • MidQ Exported with Draco + WebP texture format + 1024px texture resolution - 1.6 MB
  • LowQ Exported with Draco + WebP texture format + 1024px texture resolution - 800 Kb

MidQ Exported with Draco + WebP texture format + 1024px texture resolution - 1.6 MB

LowQ Exported with Draco + WebP texture format + 1024px texture resolution - 800 Kb


LowQ Exported with Draco + WebP texture format + 1024px texture resolution - 800 Kb

AO Lightmapper Optimization Settings

In my case, I’m testing it with AO Lightmapper; although there are many tools capable of performing these functions, it’s not a bad idea for the model to emerge from your application already baked and optimized.
Of course, I’m suggesting all this in case you want to push these options to the absolute limit of optimization.

@DRLeria thank you, that was exactly the right push. There is now a fourth download, Compact GLB, built the way you described:

  • simplified to about 100K triangles (meshoptimizer, UV seams kept)
  • Draco geometry (gltf-transform’s draco() at its default 14-bit position, 10-bit normal, 12-bit UV)
  • WebP textures capped at 1024 px
  • placed like the others: facing +Z, lowest point at y = 0

Measured on real models:

Model Web GLB (200K tris) Compact GLB (100K tris)
Ashen Vanguard Warrior 7.5 MB 558 KB
Springer Spaniel (rigged, walk clip) 10.6 MB 805 KB
Sunken temple diorama 8.7 MB 705 KB

Rigged pieces keep their skeleton and animation (Draco carries the joints and weights). I checked the compact files in Babylon 9 and in three.js with DRACOLoader. Up close the 1K maps are a little softer on faces, which is the trade you described for characters seen at a distance.

The plain Web GLB stays for tools that can’t decode Draco. The Compact button will be in the download panel within the hour.

An AO bake on export isn’t in this one. I’d love to hear how the compact file behaves in your controller and AO Lightmapper.

1 Like

Wow, that was fast! :grinning_face_with_smiling_eyes::clap:

Amazing work! Those numbers are seriously impressive, especially getting a rigged and animated character under 1 MB!

I think having different export options is a great approach, giving developers the flexibility to choose between visual quality and performance depending on their needs.

Regarding AO Lightmapper, it generally handles heavily optimized models of all kinds really well. Ironically, the few issues I’ve encountered have been at the opposite end, with extremely high-poly meshes. But overall, it works great, even with aggressively optimized geometry!

I’ll definitely run some tests with your Compact GLBs to see how they behave through the optimization and AO baking pipeline.

Really glad my suggestions were useful. Keep up the fantastic work! :rocket:

Ehhhhhh, I don’t want to be a hater… but that polygon flow and count is really not it… Looks good for a focus character but is dreadful for optimization. I might have missed it in the thread but what are you using for geometry generation and topology flow? Otherwise really sweet idea, awesome visual quality on the model. Really interested in where this goes!

Challenge if you so choose to accept it.

Keep your current generated 100k model.

Generate three variations with logical topological flow at these steps:

  • 16k

  • 12k

  • 8k
    Each should share the same vertex weights for animations.

    If you do this and the model is still in an “acceptable aesthetic”, then you really have something.
    Try to ensure that looping at the joints follows an industry standard to prevent mesh folds.

1 Like

i wanted to try it , it said 3 free credits , but then i must let stripe capture my card details first .. ? no thank you.

@Pryme8 Not hating at all, that’s the right critique for game use.

The geometry comes from Tripo (image-to-3D, as in the first post). What it returns is a dense, uniformly triangulated surface of about 2 million triangles, closer to a scan than to a modeled mesh: no quads, no edge loops, nothing laid out for deformation. The Web (200K) and Compact (100K) downloads are meshoptimizer decimation of that surface. Decimation keeps the silhouette, the UV seams and the skin weights of every vertex it keeps, which is why a rigged piece still walks at 100K, but it doesn’t create loops at the joints. So you’re right: it’s hero-asset topology, not game topology, and hard bends at knees and elbows can fold.

Your 16K / 12K / 8K challenge is retopology, a different problem, and I’ll take it. The plan: retopologize one rigged piece at those three budgets, transfer the weights from the original skin so all three share one skeleton and the same clips, then check them in wireframe and in motion at the joints. I’ll post the wireframes here whichever way it turns out. It costs real generation credits per pass, so give me a little time.

@shaderbytes Fair, and thanks for saying it plainly. Every model costs us real GPU time at the generator, so the free credits now need a card on file. Stripe holds the card (we never see the number), it is checked but not charged, and nothing is charged unless you choose to buy credits. I understand that’s still a step too far for a quick try, and I’ve passed your point on.

DRLeria, thank you! Looking forward to how the Compact files come through your optimization and AO bake. One detail that may matter for the lightmapper: the files carry a single UV set (TEXCOORD_0), so lightmap UVs would come from your pipeline.

1 Like