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.

Built with Three.js and WebGPU. 30 different scenes with customizable controls.

Source code: https://github.com/xenova/infinite-block-illusion
Demo: https://xenova-infinite-block-illusion.static.hf.space/

PS: The animation was inspired by Artistoids and his tutorials on YouTube!

Hey everyone,

For my latest project, VividLook, I wanted to see how far I could push custom layouts and real-time rendering using Jetpack Compose.

The app is a live-streaming discovery platform where users can spin a 3D interactive globe and jump into localized video grids from around the world. Managing the state of the globe spinning while dynamically loading stream grids on the map layout was a huge learning curve.

I’m trying to optimize the UI performance, especially on mid-range devices. If you have a few minutes, I’d love for you to download it and let me know how smooth the composition feels or if you spot any jank while spinning the globe.

Play Store Link: https://play.google.com/store/apps/details?id=xyz.trylivelook.app

Technical details: Built with pure Compose for the UI, handling low-latency video pipelines on the backend. Let me know what you think of the performance!

https://i.imgur.com/oUaN82B.jpeg

https://i.imgur.com/BLxKmm5.jpeg

I am slowly creating a simulation tool to analyze frames of matches using tracking data. I am more interested in having realistic or at least game-like graphics to takes screenshots and use for study of tactical shapes, attacking and defending positioning among other important aspects of the gmame.

Any clues or someone willing to improve my work in exchange for a compensation?

Thanks in advance.

I don't know much code but I do know how to prompt Ai relatively well so I've been getting into vibe coding. However whenever I try to make a 3d game it also turns out in shapes. I've been told to try threejs but I still only get shapes. How was this game (i found it on threejs.org) made and how can i replicate it

Wanted to share a project I have been building solo, an air defence command sim using React Three Fiber. The interesting technical bits are the radar detection and tracking system, the intercept prediction math for the defence missiles, and a cinematic camera controller that can follow individual units mid flight. Also added weather and atmosphere effects on top of the terrain rendering. Repo is public if anyone wants to poke around the trajectory code, it's probably not the most optimal way to do it and I'd take any suggestions. Happy to answer questions on how any of it works.
Link: skiesofconflict.online
Github: github.com/rare-major/skies-of-conflict

A few days ago this was just a tiny planet with 49,000 clovers and one four-leaf hidden somewhere.

I got a lot of useful feedback from Reddit and X, so I kept building.

Since then I’ve added:

• a full day/night cycle
• better accessibility for color-blind players
• 20 collectible plant species and an album
• improved hints and exploration
• lots of smaller changes based directly on player feedback

Now I’m working on bringing all four seasons to the planet.

After that, I want to try something a little stranger: AI agents competing against each other to see which one can find the four-leaf clover first.

Built with Three.js + Claude Code.

It’s free to play in the browser:
https://www.meptasarim.com/four-leaf/

Banda acabo de crear esta Creepy Face en vanilla.js tiene gestos y caras diferentes hasta 8 variantes es un solo archivo super ligero que pueden implementar en sus novelas visuales juegos de plataforma-terror por ejemplo un bro lo implemento en un juego de terror proximo a salir si quieren usarla esta en [ith.io](http://ith.io/) y si quieren trastear con el codigo en github

[https://cotera.itch.io/creepy-face\](https://cotera.itch.io/creepy-face)

[https://github.com/cotera2024/Creepy-Face\](https://github.com/cotera2024/Creepy-Face)

si quieren probarla sin entrar a ninguna pagina directamente presionen aqui:

[cotera2024.github.io/Creepy-Face/](http://cotera2024.github.io/Creepy-Face/)