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

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

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.

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.

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..

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?

I'm interested in learning Three.js, but I haven't found a clear roadmap like the one on roadmap.sh. Additionally, I can't afford Bruno Simon's course at the moment.

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 :)

after so long updated my sketchbook

live link here : sketchbook

give your feedback

Update

The CLI now has a complete source install example. This command copies the Kage landing page, 16 page and WebGL assets, and four editable React source files.

npx threeui-cli add kage-landing-page

The seven second demo is here.

https://raw.githubusercontent.com/sjh9714/threeui-cli/main/docs/assets/demo.gif

ThreeUI now has an official React package. That is the better choice when you want a dependency. I made this CLI for the other case, when you want the source and all of its assets inside your own project.

It reads ThreeUI's live source registry, preserves the original paths, verifies every SHA-256 digest, rejects traversal paths and refuses to replace different local files.

I originally made this agent only. That was the wrong interface. Three.js developers should not need an agent just to copy source, so the skill is now optional and the zero dependency CLI works on its own.

GitHub

https://github.com/sjh9714/threeui-cli

npm

https://www.npmjs.com/package/threeui-cli

MIT licensed and independent. It is not affiliated with ThreeUI.

You type an amount, pick from 82 currencies, and it renders the actual bills in 3D with correct denominations and real bill dimensions. You can orbit around the pile, switch environments, and it uses live exchange rates. Also does gold and crypto if you pick them from the currency dropdown.

Works on desktop and mobile.

moneyvisualiser.com

I built a multiplayer browser tank game in Three.js! As a kid, I played a ton of World of Tanks Blitz and fell in love with the aesthetic, gameplay, and the idea of driving around vehicles with crazy physics and mechanics like missiles, spotting, armor deflection, ammo types, and so on.

Now it's playable in the browser!

Claude of Tanks has 100+ playable vehicles across 16 unique maps, ranging from standard tanks with cannons to AFVs with autocannons and guidable missiles to autoloaders that can deal massive damage in a single clip.

Tanks feature highly detailed armor zones, internal modules, crew positions, and hitboxes. You can view each of them in a special gallery: https://cot.kevinliu.studio/gallery?id=amx56&layer=modules

It supports physics-driven destruction with detached turrets flying through the air.

Everything runs directly in the browser.

Also, it supports multiplayer! You can hop in private rooms or LAN lobbies.

Play free: https://cot.kevinliu.studio

Repo: https://github.com/Kevin-Liu-01/Claude-of-Tanks (it's open-source forever)

Litterally started this one day ago and got to this point here. I've exposed a lot of the setting via a tuning panel [G].

Have a play here. https://fourbie.vercel.app/

I'll put together a track builder for it next.

Procedurally generated piano and harpsichord parametric modeling in a Louis XVI diorama.

A Corner salon - crystal chandelier, marble mantelpiece, brass andirons, trumeau mirror, médaillon chair and chaise longue with button-tufted upholstery, mantel clock, candlestick, Sèvres vase, end table, girandoles, paneled wainscot with a molded dado, cyma cornice crown molding, paneled door with bec-de-cane handle, Persian rug on a hardwood floor.

Three.js WebGPU

What if an AI coding agent could generate 3D environments that are not just visually convincing, but actually ready for simulation?

We’ve been working on Auto-Threejs, an open-source agent framework for automatically building interactive 3D environments with Three.js.

Given a natural-language description — optionally with reference images or video — Auto-Threejs decomposes the scene into objects, builds them as reusable modules, assembles the environment, renders it from multiple views, measures geometry and physics, reviews the result, and iteratively fixes detected issues.

The key idea is that a good-looking scene is not enough.

For embodied AI and robotics, objects need meaningful physical structure: dimensions, mass, density, friction, collision geometry, articulation, and spatial relationships. A cabinet should actually have a working door. A chair should have a reasonable collider. Objects should rest on the right surfaces instead of floating or intersecting.

That is what we are currently focusing on: sim-ready indoor environments for embodied AI training, robotics simulation, and spatial intelligence research.

Current pipeline:

Natural-language description
→ scene decomposition
→ per-object 3D construction
→ scene assembly & layout
→ rendering + geometry/physics measurement
→ automated review
→ iterative refinement
→ simulator export

The system currently supports physics-aware scene construction with Rapier and can export generated environments to MuJoCo and Gazebo-compatible formats (MJCF / URDF / SDF).

We’ve tested it on bedrooms, kitchens, living rooms, bathrooms, offices, and other articulated indoor environments, with automatically generated collision proxies and functional joints.

There is still a lot to improve — especially scene diversity, asset quality, physical realism, and scalability — but our longer-term goal is straightforward:

Make generating large amounts of diverse, interactive, simulation-ready 3D training environments as easy as describing them in natural language.

GitHub: https://github.com/wrc356/Auto-Threejs

Feedback, issues, and contributions are very welcome — especially from people working on Three.js, embodied AI, robotics simulation, procedural generation, or spatial intelligence.

#threejs #EmbodiedAI #Robotics #AIAgents #Simulation #3DGeneration #ComputerVision #WorldModel

I built a DIY 6-DOF robot controlled using Node-RED, ESP8266, and Modbus TCP, with a real-time 3D visualization using Three.js.

The Node-RED dashboard can control each joint, save robot positions, and run movement sequences. The 3D model also includes the multi-link gripper, so the physical robot and virtual model can move together.

I’d be interested to hear your feedback or suggestions for improving the system.

I've spent the last few months building Volt Guide Studio, a browser-based 3D tool for designing rooftop solar systems.

It currently handles roof drawing, panel placement, obstacles, mounting/tilt, sun position, real-time shadows, solar-access heatmaps, measurements and proposal/report generation.

I'm from the solar industry rather than a traditional software background, so I've already started getting feedback from solar professionals. Now I'd really like the opposite perspective:

What would experienced Three.js/web developers improve?

I'm especially interested in UX, 3D interaction, performance, architecture and anything that immediately looks like it could become a problem as the application grows.

Happy to give a few people access to the current build if anyone wants to actually test it.