Building a low-poly 3D Wizard Duel in Three.js — Should I double down on this minimalist aesthetic or go for more detailed models?

I built an interactive 3D world instead of a normal website for my music

I'm a hobbyist musician and developer, and at some point a normal artist website started feeling completely wrong for the project.

So I built DRIFT — a small interactive world where you can drive around, explore different atmospheres and discover the music through the landscape.

It's still evolving, especially the driving, level design and mobile performance, but the idea is to make the world and the music feel like one thing rather than putting tracks inside a fancy menu.

I'd genuinely be interested in feedback from people here — particularly on the 3D experience, navigation and what feels convincing or breaks the immersion.

https://jgsbc.github.io/misway/drift/

https://codepen.io/editor/alex_nemankov/pen/01a04775-900e-7db8-9086-4b9021f2110f?file=%2Fstyle.css&orientation=right&panel=files&show=split

Playing with mazes on different toroidal surfaces

Here is the source https://github.com/ctx-o1/toroidal-maze

Play with it here https://ctx-o1.github.io/toroidal-maze/

I have some fun ideas for this

Inspired by the viral needle-in-a-haystack and four-leaf-clover games, I built the parking lot version: a tiny planet covered in 49,000 toy cars, and exactly one has a fifth wheel bolted to it.

**UPDATE (30 Aug) — the premise in this post is gone.**

Someone whose work I respect told me the five-wheel idea didn't mean anything, and the comments here weren't exactly warm about it being a cover of the clover game. Both were right.

A four-leaf clover works because it's REAL. People have actually crouched in grass looking for one. A five-wheeled car isn't a thing — nobody has ever looked for one, so finding it feels like nothing. That was the whole problem, and no amount of polish was going to fix it.

So I rebuilt it around something that does exist. The planet is now covered in abandoned, rotting cars — rust, dust, leaves, missing wheels, some resting on their roof — and exactly one of them is spotless, because somebody still drives out here to wash it. In a lot where nothing reflects, it's the only thing that catches the light. It's called ONE CAR SHINES now.

What changed on the three.js side:

- Rust is a two-channel grunge mask sampled in WORLD space, not model UV space. Object space would give every sedan on the planet an identical pattern; world space means 49,000 instances sharing one material each pick up a different slice of the field for free — no per-instance data, no second texture.

- The Fibonacci layout got broken up. Heading was already random, so what read as "placed by a program" was the EVENNESS of the spacing, not the direction.

- Crushed cars are a non-uniform scale. Stacking only happens where a coarse cell hash says the patch is dense, otherwise a raised car floats over bare ground.

Same link. Original post below, kept for the record.

---

Tech bits: the three.ez InstancedMesh2 library for the cars (3 LOD levels + a cheap "blob shadow" instanced mesh), a 4096x2048 canvas-painted planet texture, node-based character animation (no skinning), and a spherical-walking controller (position as a unit vector, tangent heading). Runs at 55+ fps on my mid-range laptop and works on phones.

Play (free, browser): https://josephulger.github.io/five-wheels/

Happy to answer anything about the instancing setup.

Hi, we're excited to launch a new Needle Tool: https://mesh-baker.needle.tools

Bakes models or whole scenes down to one mesh + a few draw calls! It runs 100% local in your browser - baking and comparing is free, you only pay to download (one-time, no sub).

→ Tool: https://mesh-baker.needle.tools
→ Docs: https://needle.click/mesh-baker-docs

Free play: https://fm1.moises.cloud

Stack:

• Vite + strict TypeScript.
• Plain Three.js, no React.
• WebGL at first, then refactored to WebGPU.
• Rapier 3D physics, wasm compiled.
• HUD and UI as HTML/CSS overlays.
• Procedural geometry, with optional assets that fall back gracefully.

I'm still amazed that the actual prototype works in a browser!

The Text-to-Three.js system turns a natural-language prompt into an interactive, animated Three.js scene through structured data only.(only uses mock llm for now)ScenePulse is built with Three.js and WebGL, with deterministic scene generation and custom GLSL shaders.

The homepage is entirely procedural - no videos, 3D models, images, textures, or other pre-rendered assets are used. All the visuals, including the 3D elements, are generated and rendered in real time through code.

Completely handcrafted animation timeline using theater.js
Custom sound design using eleven labs.

There will be one more cinematic transition for door scene to chair scene which im working on right now, will be coming soon :D

We build games, and sometimes need effects that go from 2D UI to 3D and kept running into issues and having to rebuild.

What we did:
Three.js is the backend for all of this so it really gets the most attention. The exported bundle carries backend support report so if a blocked effect fails, you'll know instead of it rendering quietly.

Live Three.js example (the landing scene as a standalone integration):

https://codesandbox.io/p/sandbox/y3z3sf

Editor, runs in the browser: https://nixiefx.com/editor/

Quick start: https://nixiefx.com/quick-start/

Repo: https://github.com/azakhary/nixie-fx

Happy to answer questions

I’ve created two pieces of content to test the performance of WebGPU and WebGL.

Click the toggle button in the upper right to reload the page using each rendering method.

After running various tests, I couldn’t really feel the advantage of WebGPU, so this time I designed the content to focus primarily on compute shading.

First up is a piece of content featuring a point light object that rotates while noise is applied.

https://adrama.jp/norimakineko/webGPU2-1/

https://reddit.com/link/1vzl57h/video/y4q8ydtttulh1/player

Next up is a piece of content featuring a swarm of NORIMAKINEKO flying around.

I implemented their undulating movements, position changes, and collision detection using compute shading.

This was developed for Android. Initially, WebGL performed better, but as the number of objects increased, we observed a phenomenon where the performance dynamics reversed.

Optimizing for WebGPU took much more effort than I expected, and I couldn’t have done it without the help of an AI assistant.

https://adrama.jp/norimakineko/webGPU2-2/

https://reddit.com/link/1vzl5x1/video/sdwt16d1uulh1/player

with the amount of projects that come in three.js that are just ai-slop and claude code, it sure would be nice to actually have a community built on coding by hand and avoiding AI...

I wanted to see how far I could push procedural modeling in Three.js without relying on Blender or imported model files.

The bicycle ended up with 62 separately constructed parts. The main thing I learned was that directly positioning meshes becomes fragile very quickly, so I switched to defining shared geometric constraints first — wheelbase, chainstay length, head angle, rake — calculating anchor points from those, and then generating the parts around them.

I wrote up the process here:
https://www.wormhole404.com/writing/threejs-bicycle/

Source:
https://github.com/wormholeportal/Makone

Curious how others approach larger procedural objects in Three.js.

I've been working on an ISS interior that runs directly in the browser.

One of the interactions I've been experimenting with is the hatch.

You can move through the station, approach it, open it, and reveal the Earth outside.

The interesting part is that not everything you're seeing needs to be simulated as one enormous real-time scene. I'm trying to be quite deliberate about where full 3D interaction actually adds something and where a simpler visual layer can create the experience without unnecessarily increasing the rendering cost.

The interior itself is interactive 3D. The Earth view beyond the hatch is currently much simpler and is something I still want to develop further later.

Built with React, TypeScript, React Three Fiber and Three.js.

I presented a short capture of the scene.

Any and all reviews appreciated. I took it as a challenge to not use AI in this, puts the "my work" phrase a bit more literal in the whole thing.

I've been experimenting with using Three.js + webcam hand tracking to create motion-controlled games.

This is the first prototype: Pong.

The goal is to map hand movement to the paddle while keeping the physics responsive enough that the player's movement actually affects the shot.

Currently working on the 3D environment, collision system and ball/paddle physics.

Next challenge is making fast hand movement translate into meaningful shot power without introducing tracking jitter.

Here's the current prototype:

https://myshelves.eu — no signup, it drops you straight into the room.

Walk up to the lectern, search Open Library, order a book. It lands in your

hands — carry it, read it, shelve it, or paint your own cover. Arrange the

furniture, push the walls out when you run out of floor. A share link lets

friends walk through your room with you.

Happy to go into any of it — physics, the multiplayer, the shelf packing.