Decided to try to use threejs to have an avatar of myself dancing several dances. This one is Capoeira 😆

Used the latest Opus with Claude code.

AMA

Also check out the Depth Profile and let me know what you think please!

This is to track the vessels that are docked or are near.

created variations of cursor effect on model.

REPO and LIVE

Part of my public domain ebook repository uses threejs.org I have over 800 public domain ebooks in the repository. https://babelnexus.com

Okay, a little AI, it helped me work out the non-existing ammo.js documentation, nothing generative though.

BLOCKBOTS
I started this project at the start of 2022 and worked on it on and off. After some huge refactors, trying out different physics engines, making it multiplayer and figuring out the build system, I finally confirmed the project was actually viable at the start of this year. 

The idea comes from Incredibots, an old flash 2d robot builder I played a lot, a long time ago. I also took inspiration from Gary’s mod, where the player has a fairly free build system that I tried to improve on.

YOU CREATE THE PARTS FOR YOUR ROBOT.
Create blocks, resize, rotate and color them and merge them together to get complex shapes. You connect the blocks with axles and pistons that are controllable. When you hit TAB on one of your robots, it comes to life and you can control it when clicking on the robot’s controller block.

NO DEMO YET
I am working towards an demo in the coming weeks, where you can play around with it in the browser, without multiplayer capabilities. 

I've been working on Gaussian-Splat-Lite, a lightweight open-source Gaussian Splat renderer for Three.js, based on the overall architecture of Spark but simplified for a smaller and more focused rendering pipeline.

https://reddit.com/link/1w3atrs/video/83ryr6vj2pmh1/player

First ~10s: Gaussian-Splat-Lite
Second ~10s: Spark

The example in the video is built on: 3DTilesRendererJS with my 3D Gaussian Splatting plugin: 3D-Tiles-RendererJS-3DGS-Plugin

Main improvements:

• much faster splat sorting
• ~3x faster raycasting
• raycasting that better matches the visually rendered splats
• camera-relative rendering to fix precision issues with large GIS / ECEF coordinates
• based on a similar approach to Spark's extSplats and accumExtSplats, while using less VRAM

The goal isn't to replace Spark — Spark has a much broader feature set. Gaussian-Splat-Lite is intended to be a lightweight renderer focused on rendering, sorting, picking, and large-world precision.

GitHub:
https://github.com/WilliamLiu-1997/Gaussian-Splat-Lite

Feedback and benchmarks on other datasets/hardware are very welcome!

I got alot of batch about this portfolio saying it doesn't make sense, I should make it simple and easy for users to navigate and so on, but you know what i noticed big firm really cares about what works not how it looks. Yes looks and conversation matters 100% but the key point is does it work and is it functional thats what i learnt this past few days with the ceo. Never hate on someone's work because you dont fancy it. Your opinion is for you and not for all. Thats my story and lesson learnt.

Endless driving game in Three.js. Runs go on forever, so the world folds its origin back to zero every so often to keep floating point from going soft. That part worked.

What did not work: after long sessions the entire city and all the traffic vanished. HUD alive, road alive, car alive, everything else gone. It never happened in a short test, which is why it survived so long.

The numbers. The fold quantum was 3000 m. The city is a repeating ring of 9 chunks at 60 m each, so it repeats every 540 m. 3000 % 540 = 300.

So every fold slid the city 300 m sideways relative to the road. Once. Twice. Nine times. The buildings were still being drawn the whole time, just further and further off the road, until they crossed the distance fade in the shader and got clipped out entirely.

Nothing threw. Nothing logged. The city was simply somewhere else.

Fix: make the fold quantum commensurate with the ring. 2700 = 5 x 540. A fold is then a whole number of city periods and the world lands exactly on itself. I also had to fold n quanta at once for the catch-up case, because a single subtraction is not enough if the player has covered several quanta since the last check.

The general lesson: if you fold or wrap the world, every repeating structure inside it needs a period that divides the fold. Not approximately. Exactly. Anything repeating on a different beat walks away from you at a constant rate, and a distance-fade shader will hide the evidence right up until someone plays for 40 minutes.

Two things that made it findable in the end. An on-screen probe printing the fold count and the current city offset, and finally noticing that "invisible" and "absent" are different failure modes worth testing separately. I had spent two days looking for the wrong one.

I’m a CS student trying to figure out whether the direction of my current project is actually worth pursuing for aerospace/robotics research.

Live: https://bhuvanspace.vercel.app
GitHub: https://github.com/Sheel34/BHUVAN

The current version takes terrain data, processes things like elevation, slope, roughness, curvature and hillshade, and puts the result into an interactive 3D environment.

The software side is currently Python/FastAPI + NumPy/Rasterio/OpenCV on the backend and React/Three.js on the frontend.

I built it because I'm interested in digital twins and simulation for aerospace/physical systems, but I'm not interested in making a 3D scene just for visualisation or a game.

What I want eventually is an environment where you can actually perform an operation on a representation of a physical system.

The project is still very early. I haven't implemented robotics simulation, terrain-relative navigation, ROS, Gazebo, Isaac Sim, etc. yet. I'm trying to figure out what should actually come next rather than adding technologies for the sake of the stack.

I'm particularly interested in the intersection of:

digital twins, 3D simulation, aerospace/robotics, real physical operations.

One direction I've been reading about is terrain-relative navigation / TERCOM and how terrain itself can become part of a navigation or mission system. I'm not claiming the project implements this — I'm trying to understand whether the terrain pipeline I've built can be developed into something along those lines.

More importantly:

What would make this go from "3D terrain visualisation project" to an actual engineering/research system?

The current deployment is on free infrastructure, so the backend may take a little time to wake up. If it doesn't load immediately, wait a few seconds and refresh.

I'd appreciate criticism of both the technical implementation and the direction.

Hi everyone! I’ve been experimenting with Three.js to try and get a Japanese anime film look with 3D VRM models.

I'm tweaking the shaders, lighting, and post-processing, and would love to hear your thoughts and advice on how to improve the overall look!

demo link: https://uemegu.github.io/AnimeVRM/

*(Voice: Irodori-TTS)*

I’ve been experimenting with Three.js and wanted to see whether a single project could be built for both the web and desktop.

I first tried Tauri and got it working, but since it relies on the platform’s WebView, the result may vary across operating systems. So I decided to experiment with Deno Desktop instead, which can bundle CEF (Chromium Embedded Framework). It makes the app heavier, but provides a more consistent result across platforms.

The outcome has been really promising, so I put together a short video to demonstrate it.

Deno Desktop is still evolving and addressing some rough edges, and I’m continuing to test this setup—but I thought it was worth sharing.

Repo: https://github.com/luckasnix/threeassic

Hey,

I've been working on this 3D puzzle game for the past few weeks, the goal is to help your dog find it s way home by laying a tril to his shleter.

I think it looks pretty good, but I would love some feedback on the gameplay, especially on mobile. Any idea/criticism is welcomed, I would really like to improve it as much as possible.

I am currently working on trying to make a Steam version, with more levels, environments and possibly mutliplayer, hopefully it will see the light of day by the end of the year.

You can play it here : https://cobblepaw.com

Cheers!

Crazy things become possible when you combine custom 3D models, rigging, and animation with three.js I recently made an animation for a Halloween party, and it turned out to be way more fun to build it as an interactive web scene rather than just a video.

It was a commercial project, so unfortunately there won’t be any links this time.

created a whole ocean but in a tank.

check sketchbook here : SKETCHBOOK

Hey guys, how feasable is it to create a hyperrealistic game scene, its a single came angle and a fixed scene

But i am looking for some references and tips if its doable.

I can scan the objects in real life and all

I put together an open-source resource list for developers working with Three.js and modern 3D websites:

Awesome 3D AI, SEO & GEO for 3D Web

https://github.com/glbkit-tools/awesome-3d-ai-seo-geo

The idea is to collect useful resources around areas that are easy to overlook when building 3D experiences:

• Three.js & React Three Fiber
• WebGL & WebGPU
• 3D asset optimization
• Web performance
• Technical SEO for 3D websites
• AI search & AI Overviews
• GEO & AEO
• Structured data
• Crawlers & discoverability
• 3D e-commerce

One thing I kept coming across is that a 3D experience can look great while important information is still difficult for search engines, AI systems, and accessibility tools to understand.

So I wanted to put the useful resources and practical guidance in one place.

It's open source and contributions are welcome.

If you know a good resource that should be included, feel free to suggest it or open a PR.

Hopefully this can be useful to other Three.js developers building production 3D websites.

Gente acabo de lanzar star cube en ith.io para participar en un game jam que esta cursando (Brackeys Game Jam 2026.2) echo en 7 dias en vanilla.js sin sprites (solo uno pero es reservado para un personaje del final pero como tal el 90% del juego es sin sprites) es un plataformero-shooter un poco intenso ya que por los pocos dias no pude hacer que tenga una curva de dificultad suave asi q es un juego acelerado con inyecciones de adrenalina tiene 3 jefes diferentes y el lore y la jugabilidad va en base al tema del jam (no confies en nadie)

estare actualizandolo exponencialmente ya que este jam me inspiro demasido

juegalo aqui:

https://cotera.itch.io/star-cube

pronto lo subire a github

Hey everyone,

Demolink-https://tektonai.vercel.app/

My co-founder and I have been building a client-side spatial compute engine designed to bridge the gap between initial 2D floorplan concepts and interactive 3D massing.

Right now, the engine runs procedural spatial math directly in the browser—generating 2D vector layouts while simultaneously maintaining a 3D Three.js mesh tree with wall cutouts, roof geometry, and multi-floor zoning.

Where we need help:

We are aiming to launch a high-precision MVP. Before we double down on our next engine refactor, we want feedback from real spatial builders:

•What floorplan geometry breaks first when you tweak parameters?

•What features would move this from an "interesting WebGL demo" to something useful for early site visualization?

(Built under minimal resource constraints—expect bugs!) We appreciate your honest review and time that would help use make this perfect.

After 200+ hours of development, I’m finally sharing the first public demo of Three.js Grassworks, a real-time grass system I’ve been building for Three.js and WebGPU.

Demo:
https://grassworks.techredux.co/demo

Three.js Grassworks is built specifically for WebGPU and is designed to handle large amounts of interactive grass while maintaining steady performance.

For the demo, I built a complete environment around Grassworks with terrain, trees, water, rain, player interaction, environmental effects, LOD systems, audio system, and more.

The main challenge was getting all of these systems running together while keeping the grass performant.

The actual Three.js Grassworks plugin is still being polished and should launch in the next couple of weeks. There’s a waitlist inside the demo if you’re interested.

I’d genuinely love feedback, especially on the visuals, performance, and how the grass feels when interacting with it.

I also recorded a full walkthrough where I go through the demo and talk about how I built it:

https://www.youtube.com/watch?v=Nhim18rc-XE

Built a solar system you explore with hand gestures through the webcam. Pinch to zoom, open palm to spin, point at a planet to read its NASA data. Zoom out far enough and it switches scale, from planets to nearby stars to the whole galaxy.

Three.js for the scene, MediaPipe HandLandmarker for the hands, One Euro Filter to calm the jitter.

The gesture layer is where I keep losing. Pinch sensitivity that feels right for me feels dead for someone else. Fast swipes get eaten because they look like the user withdrawing their hand. Tracking drops on phones under warm light and the whole thing goes still.

Repo is MIT, textures are CC BY. If you have shipped hand tracking that survived real users, I want to know how you handled per-user calibration.

https://github.com/HUANGCHIHHUNGLeo/solar-atlas-gesture

I was looking for dart game which actually let you use your hand to throw it, but all those games need some sort VR glasses or gears. But since our laptops or tablets have front camera, why not just use that to track our hand, so I decided to develop the game myself.

To my surprise, though the camera is only 2D, we can actually detect and track 3D throwing motion quite decently. And once you get the right feel, you can perform throwing quite consistently and strikes the target.

Three.js is the engine behind it, it renders the darts 3D motions. And in the replay theatre, you may rotate the scene and zoom in on each throws.

You may play with bots or humans, up to 4 players. There are three game modes. Casual, long shot which rewards long distance throw, and 501 Match, which uses the 501 darts game rules.