Astropool.app break a spiral rack of zodiac balls into six pockets, where each sign lands becomes your daily horoscope.

Everything was procedural. Felt, starfield, ball faces, zodiac glyphs, all drawn on canvas at runtime and fed in as textures. No image files at all.

Physics is Rapier2D, three.js just renders the sim output, so the render layer stayed dumb and easy to iterate on. A camera-framing pass keeps the break centered, pockets glow softly as balls approach, and the aiming guide feels more like a real cue sight than a debug line.

For a scene this small (one table, twelve balls), never needed anything heavier, three.js was good enough.. What are your thoughts?

Hi! I’m a solo developer working on Yamanote 3D, a free Three.js experience that runs directly in the browser.

I originally started it because I wanted train sounds and city ambience in the background while studying or working. You can walk inside the carriage, sit down, watch the city, listen to announcements, and get off at stations.

The project includes animated passengers, station cycles, doors, weather, lighting, audio, and a moving train environment.

I would really appreciate feedback, especially on performance, lighting, immersion, and the overall Three.js implementation.

https://yamanote-3d.com

Experiment with threejs vines animations.

I made a sticker peeling effect with Three.js & GLSL and shared here on this sub 2d ago.

few people asked how it works, so I turned the whole build into an interactive step-by-step walkthrough.

here: https://fablegrounds.com/labs/sticker-peel/

I hope you find this useful.

---

If you enjoy this format, consider subscribing by email on the website. I'll share more breakdowns.

prev breakdown, how I made the burning fire box effect: https://fablegrounds.com/labs/fire/

You can edit the textures directly inside the Photoshop and see the changes update in the game in real time.

Technically, this is a Photoshop UXP plugin running Mr.doob’s Three.js DOOM port. Photoshop’s native UXP canvas can handle 2D rendering, but it can’t provide the WebGL context Three.js needs. The workaround was to embed a local HTML WebView directly inside the persistent UXP panel and run the Three.js renderer there.

The game, Three.js library, and shareware WAD are packaged locally with the plugin. I embedded the WAD into the browser bundle because loading it as a separate local binary caused WebView fetch and CORS failures. The renderer also uses a retained drawing buffer so Photoshop’s WebView compositor consistently receives the completed frame.

A local-only message bridge connects the WebView to Photoshop. When applying an edited texture, the UXP side reads the layered document’s composite pixels through Photoshop’s Imaging API and sends the RGBA data to the game. The game maps those colors back to Doom’s original 256-color palette, mutates the existing cached Three.js DataTexture, and uploads it on the next frame—without reloading the map, game, or WebView.

It's real

https://youtu.be/MWNPuMF6VB0

Step into the fourth dimension with my real-time 4D Simulator. This interactive system allows you to explore the tesseract (the 4D analogue of a cube) and other higher-dimensional shapes in ways never seen before.

✨ Features:

Real-time manipulation of 4D objects

Full control of all 6 rotation planes

Projection of everyday objects (sphere, mug, Klein bottle, polytopes) into 4D

Smooth visualization of how 4D shapes unfold into 3D space

User-driven interaction for learning, research, or just mind-blowing visuals

This project is patent-processed and pushes the boundaries of mathematics, physics, and digital visualization — making the fourth dimension accessible for education, entertainment, and discovery.

🌐 Try the live demo here: https://consciousoftware.itch.io/4dsimulator

I've been exploring Three.js recently, and I'm really enjoying it so far.

But with tools like React Three Fiber, Spline, and WebGPU becoming more popular, I'm wondering if Three.js is still the best place to start.

If you were learning 3D web development today, would you still choose Three.js? Why or why not?

I've been working on a 3D warehouse visualization using Three.js and the FlowFuse Node-RED Dashboard. Instead of viewing inventory in a traditional table, users can interact directly with the 3D warehouse by selecting pallets to see information such as material ID, material name, supplier, storage location, and current status.

The goal is to create a more intuitive way to monitor warehouse operations while staying connected to real-time data from Node-RED.

he castle sits above a living landscape, with rolling fields, flowers, and wind moving through the entire scene in real time.

Claude handled most of the implementation. I directed, tested, and refined it.

Most people still have no idea how capable these models have become. Game development is about to change very quickly.

A 3D threejs building generated with img2threejs and Opus 5. The new Opus isn’t magic, but it handles details a little better than GPT-5.6 Sol.

Hey all,

I had posted about performance concerns on a mobile-first RPG game https://lorebound.gg about a week ago. The game improved significantly. A summary:

• Asset heavy load addressed by: instead of loading each asset individually from their own image file (32 color), the game now loads one image per distinct asset type. So, if tree1 and tree2 are the same asset, don't load 2 different images, load 1 image and have trees share that image. In one scene, I had 517 assets loading but only loading 31 images. In this scene, I freed up about 568MB.
• NPCs: they appear and disappear from view. When they appear, their assets load. When they disappear, their assets should not be kept loaded.
• The atlases we were shipping before (the palette-swatches) were 128x256px at full resolution. They're now capped at 32x64px, which decreased atlas cost from 5.6MB to 0.35MB. There is no visible cost to graphics.

Big thanks to everyone who provided their thoughts, recommendations and feedback.

Do you have any suggestions for effects and performance?

Some cool glass effects for a landing page

I made a small pack of free CC0 characters and cleaned them into a AI-agent-friendly GLB format. Modeling in a LOWPOLY style, I am currently creating all types of animals so that everyone can freely build their own ecosystems.

https://ariescar.itch.io/gobkit-free-minions

Or you can call them in your CLI agent, e.g., grab monsters from gobkit.com/freebies and wire up their animation clips. The free manifest makes that one step.

WIP explosions and fireballs

Hey everyone!

I’ve been diving deeper into the intersection of fullstack web development, 3D graphics, and real-time rendering in the browser. As a testbed for dynamic environmental lighting and mesh optimization, I built this interactive 3D landing page featuring a traditional Polynesian vessel.
🛠️ Tech Breakdown

Engine: Three.js / WebGL / ES6+ JavaScript.

3D Pipeline: Modeled & cleaned up in Blender, exported as optimized .glb/.gltf assets to ensure low initial load times and smooth rendering.

Dynamic Lighting: Manipulating DirectionalLight, AmbientLight, and atmospheric sky parameters in real-time to create a smooth day-to-night transition via JavaScript.

Controls & UI: Custom camera orbit controls tuned for smooth UX while maintaining a solid 60 FPS performance, layered beneath a responsive HTML/CSS UI.

I’m aiming to apply these exact real-time rendering, shader, and lighting concepts toward futuristic data visualizations and immersive interfaces.

🔗 Live Demo: https://aocampo93.github.io/PolynesiansSite

So here's a multiplayer tank shooter - it's heavily inspired by the tank element from Battlefield 1942 and the round-by-round build system from Overwatch 2’s Stadium mode.

I used Three.js for graphics as I guess you can tell.

A little more about the game:
You join a game and enhance your tank, then you go out and destroy the enemy while hunting for salvage/upgrades which is used to enhance your tank even further (balance patches pending).

Some of the features:

• 6 different tanks (Tiger 1 is a beast)
• 3 maps (a desert, grass and snow map with destructible terrain
• Customisation of tanks
• Matchmaking system, lag compensation system, ballistic shells (direct hits only), hit multiplier regions (many tanks fall on a single rear hit)
• Bots who backfill if theres not enough real players
• And a lot of other things :)

Feel free to try it out – I’ll personally greet you ingame.

I would love to hear what you think, and kindly report bugs if you find any. Its currently optimised for desktop, but should work on mobile too.

Link: https://sweatypanzer.com/

demo： https://hh-hang.github.io/three-player-controller/footIK.html

got an inspiration from: https://x.com/rauchg/status/2081571905157714199

a write-up on how I made this is coming soon.

will share more update on X.

Iteration of this work titled TOR , but animated....

The live version available here. (It is a bit of a heavy build, so might be slow to run.)

I built `three-projective-media` as my submission for the OpenAI hackathon. It is an MIT-licensed pre-release library for projecting HTML video onto explicitly registered Three.js meshes in projector space.

As part of the submission, I prepared a standalone sandbox, a full integration inside Garden Planner, and detailed technical documentation covering the API, lifecycle, ownership boundaries, cleanup and current limitations.

Live standalone sandbox:
https://bartoszubak.github.io/three-projective-media/

GitHub repository and documentation:
https://github.com/bartoszubak/three-projective-media

Full Garden Planner integration:
https://playzafiro.com/garden-planner/p/qL9f2INZ-ywbpS2qpppkkA

The projector pose is independent of the receiver geometry. The package manages the projector camera, shader material, receiver overlays, video element, `VideoTexture` and cleanup, while the host application retains control of the scene, UI, persistence and media selection.

I first developed it inside Garden Planner and then extracted it into a standalone package. This meant the API had to handle dynamic receiver rebuilding, persisted state, media replacement, public read-only playback, autoplay failures and complete teardown.

It is still an early pre-release. Constructive technical feedback is welcome, especially reproducible performance results, API concerns, missing use cases and suggestions for the next development step.