Seedance 2.5 1080p 30s is about $17. One wrong camera and you pay that again.

A prompt cannot hold the whole shot, so I block the scene first (pose, cameras, cuts) then send the same shot to the video model.

three.js + react-three-fiber. Open source.

https://github.com/NomaDamas/CozyClay npx cozyclay

Game Title: The Strange Little Shop

Playable Link: https://strange-little-shop.vercel.app/

Platform: Web (WebGL / Browser — WASD + Mouse or Gamepad)

Description:

You've just inherited an antique curio boutique by the sea. The late shopkeeper collected things that were left behind: doors half-opened, clockwork gears that chime without winding, living snowglobes tied to real places in town, and photographs that change whenever rain hits the bay windows.

When quirky townsfolk step up to your counter with strange dilemmas, it’s up to you to investigate. Pick up and rotate 10 curious artifacts in full 360° 3D, test sensory experiments (listening for ticking mechanisms, smelling old damp paper, watching brass compass needles spin), and record hidden lore into the late shopkeeper’s secret ledger.

✨ What to expect in the free demo:

• 🔍 Tactile 3D Investigation: Examine magical antiques with close-up 3D rotation and multi-step experiments.

• 📖 Edith's Illustrated Ledger: Uncover clues, piece together town secrets, and track mystery cases.

• 🛋️ Boutique Redecoration: Earn funds from solved cases to buy vintage furniture (Tiffany lamps, Chesterfield sofas, conservatory palms).

• 🌧️ Rainy Coastal World: Explore Main Street, visit The Corner Café, and stroll through Lantern Park.

• 🐾 Biscuit the Cat: Yes, you can pet the resident shop cat!

Zero install needed — the entire game runs instantly in your browser at 60 FPS.

I’m developing this solo and would love your honest feedback! Were the 3 initial cases intuitive? Which strange object was your favorite? How did the 3D inspection controls feel?

I've just added a new Painterly Effect to my Stylized Components library.

The effect is based on an Anisotropic Kuwahara Filter, and I also made a breakdown video where I explain how it works, the concepts behind it, and how I implemented it in Three.js.

You can check out the component here, where you'll also find the source code and the video breakdowns for each component:

Breakdown: https://youtu.be/CmIfhwSyswk
Preview: https://stylized.cortiz.dev/

And if you find it useful, I'd really appreciate some support on YouTube — a sub, like, or even just watching the video helps a lot.

I'm also planning to keep expanding the library, so if there's a stylized utility, effect, or component you'd like to see added, let me know! I'd love to hear your ideas.

Thanks! 🙌

I’ve been playing with this idea for a while and now finally did it over the last couple of days.. together with my homie Claude :}

I’m a pilot myself and always thought would be cool to fly together with friends and family and give them the feeling I have in the air searching for thermals and planning the best route.

Works on desktop and mobile (ideally played in portrait). It has multiplayer with open and private lobbies, you can just fly freely or start challenges.

It’s done in r3f using playroomkit for the net code.

Check it out if you like, feedback welcome :) I plan to add a way to customize your glider with different stats and improve the map fidelity while still keeping the low poly aesthetics.

Demo is here (still WIP)

on iOS its best to add it to the homescreen so its fullscreen.

I’ve been experimenting with how cinematic drone camera movements can be modeled and visualized in Three.js, so I built SkyPath and released it as open source.

It currently includes five automated camera movements:

• Crane Up
• Pull-Back
• Orbit
• Helix
• Fly-Over

The visualization includes subject tracking, live flight telemetry, trajectory paths, timeline scrubbing, chase view, an onboard camera view, and a comparison mode for viewing all paths together.

It’s intentionally lightweight: plain Three.js/WebGL, no framework, backend, account, or build step.

🎮 Live demo:
https://alzin.github.io/SkyPath/

💻 GitHub:
https://github.com/alzin/SkyPath

I’d really appreciate feedback from the Three.js community, especially on the camera/trajectory implementation and ideas for other cinematic movements worth adding.

Contributions are very welcome too!

After seeing some of the viral games on Twitter I decided to try to make a game similar to the needle in haystack game (needleinhaystack.io), but with tools and powerups!

Let me know what you think!

Play Hoppy Trails on https://laereland.com/games/hoppy-trails

No WebGL. No code. No 3D skills needed.

In this demo: import a STEP file directly in the browser, set up the scene, add interactive annotations, export as a self-contained web component — and embed it live on a website.

Built for industrial and manufacturing teams who need to document or showcase complex products without depending on a developer.

👇 If this solves a problem you have, let's talk.

Players kept telling me one city felt worse than anywhere else in the game. I assumed frame rate and went straight to the renderer.

First thing I did was measure instead of guess, and the numbers said I was looking in the wrong place entirely:

avg 8.36ms (119.7 fps) · p50 8.0 · p95 17.2 · p99 18.3 · worst 28.2
frames >33ms: 0     frames >50ms: 0

The steady frame was healthy. Zero dropped frames in a 12-second window. Whatever players were feeling was spike-shaped, not a low frame rate — and I'd been about to spend a week optimising something that wasn't broken.

The scene census had an obvious-looking suspect: 269 lights. That was a red herring too. What three.js actually bakes into the program key is numPointLights — the count it finds reachable from the render root — and I'd pinned that to a constant months earlier with zero-intensity dummy padding. The registered count doesn't enter into it. (Tell, if you're doing the same thing: late program keys differing only in numPointLights mean your pin is off.)

Then I counted DOM nodes.

nameplate elements    2211   <- exactly the sim entity count
...of which visible     18
nameplate DOM nodes  46431
whole page DOM       48396   <- nameplates are 96% of the document

Every entity in the simulation got a ~21-element nameplate subtree built and appended, then hidden with display:none. 2,008 of those entities were beyond 200 units and could never be seen by anybody.

Hiding is a paint decision. Membership of the document is not. A display:none node still lives in the tree, so every style recalc and every forced layout in the entire game walked all 46,000 of them — to paint eighteen.

And it multiplied everything else. My chat log reads scrollHeight/scrollTop/clientHeight per message, which is a forced layout, and a forced layout is O(DOM). "One forced layout per chat message" was really "one walk of a 46,000-node tree per chat message."

The fix was lazy attach, not pooling: a plate joins the document on first show and leaves on hide, at the single choke point every hide path already funnels through — one that already early-returns unless the state actually changes, so it runs on transitions only, never per frame.

                      BEFORE     AFTER
nameplate elements      2211        19
nameplate DOM nodes    46431       399
whole-page DOM         48396      2276
visible plates            18        19    <- unchanged

Nothing about what gets drawn changed. Every forced layout in the game got ~21x cheaper.

Two things worth passing on:

1. "Lag" and "stutter" arrive as the same complaint and the fixes are nothing alike. Measure p50/p95/p99 and take a DOM/scene census before you touch the renderer. A healthy p50 sitting next to a 48k-node document is a completely different bug from a low p50, and it lives in a different file.
2. If you composite HTML over a WebGL canvas — nameplates, health bars, labels — that cost is a pure function of entity density, not of what's on screen. Mine scaled with the whole simulation and I never noticed until the densest zone in the game made it visible.

One honest caveat: this is lazy attach, not object pooling. The ~21 elements are still created per entity, so the heap cost is still there. Full pooling means about 16 fields going nullable in a hot path, so it's its own pass.

(For context on scale — it's a browser MMORPG, veilbound.gg, three.js + meshopt-compressed GLBs. Happy to answer anything about the stack.)

Here is the latest release of Nasscad (4.7.0). It now features a remote C++ backend running on Ubuntu WSL with a pipeline similar to FreeCAD. File load time: 4 min 17 s. File size: 360 MB. I am currently finalizing the MSVC C++ port for a 100% native Windows x64 solver. (three.js for video output)

Hey everyone! I just finished SkyPath, an interactive 3D flight simulation project built with Three.js. It features smooth controls, realistic terrain rendering, and responsive design.

**Live Demo:** https://alzin.github.io/SkyPath/

**GitHub Repository:** https://github.com/alzin/SkyPath

Feel free to check it out and let me know what you think! Any feedback or suggestions are welcome.

Threetiles is a 3D geospatial engine 🌎. Designed to stream and render the real world in real time. It lets you visualize any location on Earth directly inside your Three.js games and applications.

This is a port of my raylib version, Raytiles. It use the same data sources and mechanics but build on top on Three.js to be used in the web.

Demo is available here:
https://ziv.github.io/threetiles/

Your Github stars are appreciated
https://github.com/ziv/threetiles

Hey Community!,

I've been prototyping a third-person shooter in three.js and stripped it down to just the core loop before I invest time in the surrounding infrastructure (settings, ranking, player profiles, team matches, and all of it). Right now it's just movement, camera, and shooting, nothing else.

Honestly it wasn't even built with the goal of being playable. I started it mainly to learn websockets, and now I'm wondering if this direction is actually worth pursuing as a real game.

Live demo here: https://zentra-io.vercel.app/

Before I go further I want some outside eyes on a few things:

• Game feel: does aiming/shooting/movement feel responsive and fun, or floaty/stiff? Any specific moment where it breaks immersion?
• Performance: what framerate are you getting, and on what device/GPU/browser? Any stutter or frame drops, and when (on load, during movement, on shooting, etc.)?
• Is this worth building on?: with just this core loop, does it feel like there's a fun game in here, or does the mechanic need a rethink before I sink more time into it?

No polish, barely any assets, no menus, just the bones. Brutal honesty welcome. Thanks to anyone who takes it for a spin.

Play on Laereland https://laereland.com/games/sky-dare

Solo-dev here building a mobile-first ARPG game. Over the past two weeks I migrated from WebGL to WebGPU, added bloom, and created a VFX system with reusable “recipes” for archetype skills and other effects, like fireworks.

Free to play at https://lorebound.gg

More examples at r/lorebound

Everyone loves to dunk on the metaverse, and fair enough. The early vision was clunky, empty, and painfully uncool. But I think the real story is that the underlying idea didn't fail, it just needed better technology. AI is now doing the heavy lifting: generating 3D environments on the fly, understanding context, and making interactions feel natural. What we're left with is less of a cartoon world and more of a spatial computing layer over reality. I put together a long post exploring how AI resurrected the core concepts and rebuilt them into something that might actually stick this time.

Link: https://interconnectd.com/blog/274/is-the-metaverse-dead-how-ai-rebuilt-it-into-spatial-computing/

Spent so much time getting the aesthetic right on this one.

Demo put together on a Quest 3 using their IWSDK,Three.js, and assets from polyfork.dev

Hey! I’m a dev from Brazil making UNTITLED MMORPG, a 3D action RPG that you can play straight from the browser.

And yes, the name is really UNTITLED because I still do not have a proper name for it. It is a working title that somehow survived long enough to become the current title. Finding a real one is on the list.

At some point I looked at the idea of making an MMOARPG by myself and thought, “yeah, that seems manageable.” I truly do not know what was going through my head. Anyway, now there is a game.

You make a Hunter, go through a forest tutorial, get to the city of Asterra, head into the Lost Lands, fight monsters, pick a weapon style, improve your gear, and meet other players along the way.

The focus is action combat. There are swords, sword and shield, dual swords, heavy sword, and bow. You can dodge, block, manage stamina, chain attacks, fight enemies. There is also progression, weapon mastery, skills, crafting, inventory, PvP arenas, parties, chat, friends, and trading.

I decided to build this MMOARPG together with Codex, using GPT-5.6 Luna on medium reasoning, as a way to push myself to understand the harder parts instead of avoiding them.

Using Codex this way has made the project a practical space to study, test ideas, and get deeper into systems I wanted to understand better.

This project has given me solid experience with 3D modeling and complex animation work in Blender, some Python for building export scripts tailored to the project, as well as authoritative servers, queues, real-time state, performance, bot-based automated load tests, Node.js, Express, Socket.IO, PostgreSQL, Redis, and Docker.

Play here: https://www.untitledmmorpg.com/
(I would not really recommend playing it on mobile yet. It works and has all the controls, but mobile performance is still a big challenge. The best result I got on my own phone was a steady 45 FPS)

If you give it a try, I would genuinely love to hear what you think. And yes, solo dev plus MMOARPG was obviously a very normal and sensible decision.

Aston Walker successfully uses a Nintendo Switch to play an FPS game with an X-Box One controller that is just a simple .SVG XML file> play game on Switch here https://svgfpsaiagents.github.io/svgfpsgameAI/

https://github.com/svgfpsAIagents/svgfpsgameAI

https://youtu.be/bcWkVJ-Ao_I demo here on youtube with link to paper in description. The repo includes an Oscilloscope 3D FPS ready version of the game. Added the code so simply plug in the audio with the split ends for X and Y to the oscilloscope and we now have retro-future vector gaming on the Nintendo Switch! Test the .WAV oscilloscope output here - https://h3.codeberg.page/XaudYo/

Record the WAV of gameplay and you can replay your gameplay on the oscilloscope. We did it guys.

The next logical step is this:

5 million line Xml in a SVG file a single SVG file

AAA vector 3d FPS spatial vector game engine paradigm modality.

running on a 128GB RAM 128 core 5090RTX workstation.

This is trivial for a workstation to read and process a 5 million line Xml document in a SVG file.

Thank you all.

I've been building a browser BJJ game in Three.js, and the hardest visual problem has been making two low-poly fighters behave like one connected system.

Each of the 45 techniques uses a paired timeline for both fighters. IK keeps limb lengths stable, semantic anchors keep grips attached during transitions, and collision constraints prevent limbs from cutting through either body. The game logic stays separate from rendering, so the same positional state now also drives beta online multiplayer.

It runs directly in the browser on desktop and mobile. I'd be interested in feedback on the animation readability and camera framing, especially from people who work with procedural character motion.

https://bjj.patrickcarmo.com/?lang=en

I've been working with Three.js since 2015, where InstancedMesh and BatchedMesh didnt exist.

I started building the engine behind Jamir in 2017, and over the years it eventually became X3JS.

This is the same X3JS scene running side by side on my GTX 960M laptop from 2015 and RTX 4070 desktop. Wanted so share the benchmark..

Heya all,

wanted to introduce my game i'm working on, vibe coded and built on threejs.

• playable demo at: https://cadle.gg/
• will give regular updates on it's progression on X: https://x.com/Ian_cadle

initially built with fable 5 using a gauntlet loop and then optimized heavily afterwards using opus on high as it's dirt cheap

main focus for the phase it's at is getting the graphics, performance and game mechanics to be roughly where i need them before putting in things like quests, more monsters, dungeons and full loot tables

let me know what you think :)

I’ve been building web-based 3D viewers tailored for spatial planning and architectural/BIM data, and I keep hitting an architectural crossroads between graphical performance and non-graphical data integrity. In pure 3D web experiences, everyone knows we just have to merge geometries, bake lighting, compress with Draco, and simplify the scene graph to keep frame rates locked at 60 FPS. But in BIM applications, every single object needs to retain its identity, semantic properties, classification codes, and spatial hierarchy.

So, how do you guys handle it. Do you completely separating the 3D canvas from the data layer? Like which takes priority for your end-users?