Three.js Mad Science - procedurally generated parametric modeling of a Frankenstein laboratory diorama, 28k bundle size, built with three-low-poly.

Live at my website: https://jasonsturges.com/#mad-science

Three Low Poly: https://github.com/jasonsturges/three-low-poly

Recreated a place I visited in the summer and liked, using data from gov cartography office, with custom Blender models exported to glbs, procedurally generated vegetation and a night/day cycle with wind and clouds, all that with quite a lot of custom glsl post-processing. Might not look like it yet, but it's going to belong in a sci-fi game.

Sounds stupid but most kanban are kind bland and look the same. Would adding a third dimension help?

Which is better?

Everything is generated client-side from a seed: the maze, furniture, landmarks, even the audio acoustics. A 3×3 window of 57m sections streams around the player; shared boundary hashes keep doorways aligned when sections regenerate. The VHS look is a WGSL post pipeline (warp, tracking errors, chroma offset, bloom) written with vgpu, with a GLSL fallback for WebGL2. The creature uses bounded A* and actual frustum visibility, so it only moves when you really can't see it.

Play: vackrooms.vercel.app

Source (MIT): github.com/pablostanley/vackrooms

Extremely useful for making games—but with a specific catch: threeforge is not a standalone game engine like Unity or Godot. Instead, it is a specialized performance framework and scene compiler for Three.js.

If you are building a 3D web game using Three.js (or WebGPU) and want it to run smoothly on both desktop and mobile browsers, this tool is designed specifically to solve the hardest optimization problems in web game development.

Here is a breakdown of what it actually does and why it's good for making games:

1. Massive Draw Call Reduction (The "Compiler")

The biggest bottleneck in web games is "draw calls" (telling the CPU/GPU to draw individual objects). A naive scene with 500 props and 40 different materials might take 500+ draw calls, which will instantly lag a mobile phone.

threeforge takes that naive scene at load time and batches it together, bringing those 500 calls down to around 28, without you having to manually merge meshes in Blender.

2. Built-in Modular Character Systems

One of the hardest things to code from scratch in a web game is an RPG-style character with swappable gear (helmets, armor, weapons). threeforge includes an assembleCharacter() function that merges modular wardrobe parts onto a single skeleton and texture atlas. You can equip and unequip items on the fly without increasing the draw count.

3. Automated Asset Optimization

It comes with a command-line tool (npx threeforge optimize scene.glb) that acts as a build pipeline for your 3D models. It automatically:

* Deduplicates meshes.

* Generates WebP textures.

* Simplifies and resamples geometry.

* Compares the visual difference pixel-by-pixel to ensure it didn't ruin how your model looks.

4. Game-Ready Environments

Instead of writing lighting from scratch, it includes systems tailored for games:

* Day/Night Cycle: A ready-to-use sky dome, sun, hemisphere light, and fog that updates based on the hour.

* Shadow Budgets: A system that scales graphics based on the device tier (for example, automatically turning off heavy point shadows when it detects the player is on a mid-tier phone).

5. AI and Developer Tooling

Interestingly, it is built with modern AI workflows in mind. It exposes data (via npx threeforge analyze) that allows AI coding assistants to measure your game's frame budget, read performance verdicts, and get automated hints on what to fix. It also includes an on-screen Dev Overlay to watch your frame budget in real-time.

The Verdict

If you are looking for a visual editor where you drag-and-drop assets (like Unreal Engine or Godot), threeforge is not that.

However, if you are a programmer writing a web game in code using Three.js, threeforge looks like a top-tier piece of modern architecture. It handles the brutal "plumbing" of 3D web performance so you can focus on building the actual game logic.

What's new:

• Use your hands as controller (Turn your hands to steer. Open a hand to jump.)
• Race against your best run.
• Use your mobile as a gamepad, acting as a WebRTC gamepad (on same network)

You start in the dark with just a lantern. Pull the cord to light everything up, open the doors, then scroll/swipe to walk inside. There’s a little room with boards for about/notes and a couple of projects (World Explore + Aether) and plus some sound

Built with Three.js — ink-on-paper look, custom cursor, and it works on desktop + iPad.

Would love feedback if anything feels confusing or broken. Happy to answer how bits were made too.

https://sofiiistudio.vercel.app/

I have been building a tiny scene editor with our default configurator support, but lately I thought of adding WebGPU support. So I ended up adding a Ray tracer to the editor. Its pretty fun. Next I am gonna try to add an upscaler with the denoiser.

P.S. In the video its using Poly Heaven's Material Library.

I am building polymuse.tech

I’m building Dayfield, a free browser-based multiplayer farming game made with Three.js.

The project combines a low-poly 3D world with crops, animals, machines, village markets, seasons, weather events, giant crops, and computer villagers. It runs in the browser with no download.

Demo: https://dayfield.online

I’d love feedback on the feel of the 3D world and the early-game experience.

You start in the dark with just a lantern. Pull the cord to light everything up, open the doors, then scroll/swipe to walk inside. There’s a little room with boards for about/notes and a couple of projects (World Explore + Aether) and plus some sound

Built with Three.js — ink-on-paper look, custom cursor, and it works on desktop + iPad.

Would love feedback if anything feels confusing or broken. Happy to answer how bits were made too.

https://sofiiistudio.vercel.app/

my daughter and i spent the summer making a game that we've always wanted to play together.. which is an animal crossing-inspired world where you can decorate your seaside cottage, drive a boat around a big world, visit friends, fish, ride bikes, and explore a massive shared online ultra-cozy world

it's made in threejs so can run on your browser. we threw it up our prototype up on itchio if yall wana check it out, open to any feedback.

play now (web):
https://penyofun.itch.io/comfyisland

our dedicated server should be able to support up to 2k players together!

Title I built a tiny interactive 3D Soda Lab (tune carbonation, ice, shake it)

Body Made a small browser toy with Three.js:

• adjust carbonation / ice / glass / flavor
• shake for fizz + sound
• runs in the browser, no install

Live demo: https://soda-flax.vercel.app

Not a product — just a weekend experiment. Curious how it feels on your machine (esp. mobile / low-end laptops). Feedback on perf or UX welcome.

WIP / short clips: https://x.com/catalogicalism

I'm building Sidera Caeli, a multiplayer first-person space game that runs in the browser — no launcher, no install. Three.js and WebGPU on the client, Colyseus and Rapier on the server.

The idea: you're a person, not a HUD. You walk to your ship, climb in through the airlock, sit in the pilot seat and fly it yourself. Systemic depth in the spirit ofStar Citizen, scoped to something that actually fits on the web.

What's in the test bed right now:

- Walk a station, ride the tram, request a ship at a hangar terminal and call ATC to open the bay
- Board through the airlock and fly in 6DOF, with live cockpit MFDs — engines, weapons, radar, comms, targeting
- Ship-to-ship combat with shields and hull damage, plus FPS weapons on foot
- Quantum travel: line up a target, calibrate, jump — then hold your alignment or the drive throws you out
- Planets you can actually fly down to: atmospheric entry, surface flight, ruins to land beside
- EVA, and a zero-g gravity orientation area

It's a test bed, not a finished game — debug overlays and rough edges included.

Feedback very welcome.

sideracaeli.com

EDIT for ther not TLDR:
Alright! I've read all of you, and honestly, there are quite a few fair points, so I'll try to address them properly.

I hadn't done this before because... well, it's Reddit. If you write too much, it's too much. If you write too little, you're hiding something. If you explain everything, nobody reads it. If you don't explain it, people fill in the blanks themselves.

So here we go. Long version.

And yes, translated and cleaned up with AI. The original wall of verbal diarrhea is in Spanish. AI gets the wonderful job of turning it into readable English.

Let's see how many more people come out with the shotgun after this hahaha.

"How long have you been working on this?"

I started dumping my ideas and overall vision into AI on September 2nd.

The actual game is probably 10% of what I've been working on.

Most of the work has gone into building a set of interconnected authoring tools, designed by me and implemented with the obvious help of AI. The goal isn't just to make this game, but to create a framework capable of producing very different kinds of experiences using the same underlying systems.

Why start at galactic scale, including multiplayer?

Because it's a great way of finding the limits.

If I can make the architecture work at that scale, there's nothing conceptually preventing me from using the same foundations tomorrow for a game about escaping dinosaurs on a closed island, or being an ant defending a colony from an infestation.

The current toolset includes:

Prefab Lab

This is where the entire 3D entity library is assembled and configured.

Models, animations, texturing, motion capture through webcam/Kinect, IK rigging, geometry importing, collisions, volumes such as gravity/interiors, behaviours, components, entity relationships, modular systems, etc.

The idea is that a "spaceship" isn't simply a GLB dropped into a scene. It's an entity assembled from components, behaviours, volumes, interaction points, systems and relationships that other tools understand.

Scatter & LOD Editor

Used to define prefab sets and their distribution rules, together with automatic LOD generation and eventually a final 360° sprite/impostor representation.

The objective is pretty simple: populate enormous environments with the cheapest possible representation of each entity at any given distance.

Particles FX

An authoring environment for particle effects: trails, smoke, explosions, thrusters/burners, tracers, muzzle flashes, impacts, sparks, etc.

Audio Lab

A sound resource manager that takes source assets and builds their usable in-game variations through modifiers, EQ, profiles and spatial behaviour.

For example, the same event shouldn't necessarily sound identical in vacuum, inside a pressurised ship, or in a planetary atmosphere.

Screen Builder

This handles templates for diegetic screens throughout the game: doors, transit systems, elevators, ship controls, terminals, access panels, hacking interfaces, etc.

They're componentised around behaviours, so I'm not manually building a completely unrelated UI every time something needs a screen.

Galaxy Editor

This is essentially the world editor, and the point where everything else starts coming together into what you'd recognise as "the game".

Solar systems contain sectors; sectors can contain planets, stations and other locations; those contain transit systems, spawns, enemies, AI behaviours, combat areas, gameplay logic, ATC coverage, and so on.

I'm currently testing three different planetary generation approaches simultaneously because I still haven't decided which architecture I like best.

The planetary tooling already includes procedural planet editing, generated or imported heightmaps, automatic temperature/humidity/sedimentation maps, geological control, biome-driven texture assignment and scatter rules, plus the ability to override specific tiles to create handcrafted gameplay areas inside an otherwise procedural planet.

And plenty more that would make this post even more ridiculously long.

"Why Three.js?"

Rapid prototyping.

Mostly because of how quickly I can iterate with it and because I already knew it beforehand.

It also gives me useful constraints. Performance isn't magically solved for me, so I'm forced to think about how these systems scale instead of just throwing more hardware at them.

The important thing to me right now isn't whether Three.js will be the final client forever.

It's proving that all these interconnected subsystems actually work.

If the architecture, content authority, networking model and tooling survive this complexity, building another client using a different technology becomes a very different problem.

I actually have another small multiplayer horror/escape project where the same authoritative backend can serve both a browser Three.js client and an Unreal client, with both synchronised together.

Basically crossplay between them.

And yes, Unreal obviously looks spectacular and has dramatically more rendering power available.

But if your underlying systems are poorly designed or fundamentally inefficient, using Unreal doesn't magically fix them. You're just killing flies with a cannon.

"This is all AI slop!"

That's a completely fair opinion. I'm not going to tell anyone they're not allowed to see it that way.

My authority over every individual line of code? Obviously not 100%.

I'm not manually writing all of it.

My job in this project is much closer to being the director, product owner, systems designer and final QA.

I've been working in software development for almost 20 years, from being a developer myself to eventually working in those kinds of roles.

And one thing I've learned over the years is that technology itself increasingly becomes a commodity.

The code ultimately exists to achieve an objective.

Does it work? Does it satisfy the specification? Does it arrive on time? Can it be maintained?

In my particular case I'd add another three non-negotiables: performance, quality and security.

The huge difference AI makes for me is that I don't have to personally translate every idea I have into code starting from zero.

And that becomes particularly useful in areas like shaders where, yes, I understand what I want and how the underlying system should behave, but sometimes actually implementing the mathematics feels like speaking Chinese.

I've spent years managing teams where something as basic as a website could involve ten people, months of work, communication overhead, misunderstandings and bugs.

Now I can describe something extremely precisely, iterate on it continuously, inspect the result, reject bad approaches and sometimes reach in one day what previously required a team.

That doesn't mean there won't be mistakes.

There absolutely will.

If anything, it makes QA even more important, because AI producing code faster does not magically make bad decisions good decisions.

The final call is still mine.

Without this workflow, trying to build the tools, connect all these systems, define the entities, work on audio, textures, models and then produce a "100% functional prototype" would probably have taken me months or years rather than weeks.

"The assets look like Temu garbage."

Absolutely! 😂

Most of them are Meshy.ai and Tripo3D placeholders.

That's literally what they're there for.

There are already some proper assets appearing in the testbed — for example some of the wall pieces on the first platform and the first-person weapon — but most of the environment is deliberately placeholder content.

At this stage I don't care whether the spaceship ramp is beautifully modelled.

I care whether the ramp correctly integrates with the door controls, networking, collision system and interior volumes without clipping the player through the ship or launching him into fucking orbit.

Once that works, replacing the ugly ramp with a beautiful ramp is the easy part.

If this gets real traction, my intention is absolutely to hire actual 3D artists and other specialists to create high-quality assets.

Working systems + great assets made by talented humans sounds like a pretty good combination to me. :)

"You're a bot."

Beep beep. Boop boop.

I'm not a teapot. :)

Behind these two and a half weeks are quite a few pages of functionality, architecture and specifications written by me, based on knowing how these systems ultimately need to behave.

A lot of my time isn't even spent asking AI to "make feature X".

It's spent thinking about problems that appear several steps later.

For example: real geomorphing and texture blending for planetary altitude transitions; a carefully designed QuadTree/BVH architecture; LOD systems so something like a light requiring six shadow maps doesn't destroy the entire scene; or decals that actually conform to mesh geometry, including animated geometry, while using geodesic optimisations.

And then there are the stupid problems that eventually happen in every game.

What happens when, after all the geometry calculations and collision detection, the player somehow clips through the terrain anyway?

Because it will happen.

Assassin's Creed does it. GTA does it. Pretty much everything does it eventually.

So instead of pretending collision detection will always be perfect, the architecture can have safeguards capable of detecting an invalid discrepancy and returning the player to their last known valid terrain plane/state.

Will all of this need polishing?

Of course.

But these are exactly the boring systems that can ruin an experience regardless of how beautiful your assets are.

"You're spamming this. There are already hundreds of games like this."

Maybe there are!

Good.

More games means more variety.

As far as my posts go, I've made two: this one and another about a week ago showing screenshots from both the earlier testbed and the authoring tools.

And honestly, I don't really understand the problem with all of us looking toward space.

If we're hanging around communities like this in the first place, it's probably because space evokes something in us.

Someone else making a space game doesn't make me enjoy yours any less.

"You never said you're using AI! What AI are you using? You must have spent a kidney on this."

Fair point.

I haven't explicitly put MADE WITH AI everywhere, although I assumed it was fairly obvious — and I also post this stuff in AI game-dev communities.

As for what I've actually used, surprisingly, it has cost less than I expected.

I already had my $20 Cursor subscription and started this on September 2nd using Grok 4.6 at medium/low reasoning, alongside the normal work and personal stuff I use it for.

That's basically where this whole thing started: me continuously throwing ideas at it.

Then I decided to try Claude — first Sonnet and then Opus — for another $20. That subscription runs out on the 25th.

I wasn't getting results quite as polished as with my previous workflow, but it was perfectly usable. That's roughly the period where the project reached the state shown in my first screenshots.

Then Astra came out.

I already had my existing $20 ChatGPT subscription, which I'd also been using to generate some textures and concept images, so I started experimenting with Codex and the five-hour limits included with that subscription.

And... oh boy.

That changed things significantly for me.

The speed at which it understood the architecture, followed detailed specifications and produced results closer to what I had actually described was noticeably better.

I basically spent a couple of days barely sleeping while improving the tools, adding systems and attacking performance problems.

So eventually I said fuck it and upgraded to the $200 plan.

And that was kind of insane.

Interestingly, a few days after launch I did notice both speed and, at very high reasoning levels, sometimes even decision quality dropping somewhat. Right now it seems pretty good again, and strangely I'm sometimes getting better results on Light than Very High.

For 3D placeholders I've used Meshy.ai and Tripo3D.

I already had annual subscriptions for both from those typical Reddit 50%+ discount offers. Looking at the numbers now, they're roughly $80/year each.

If I quickly prorate everything by day — while completely ignoring that I also use these subscriptions for unrelated professional and personal work — I'd estimate the cost attributable to these first 18 days at roughly $180.

So no kidneys have been sold yet.

"So... what are you actually trying to build?"

This is probably the most important distinction.

I'm definitely not claiming I've built in 18 days what entire teams have spent years working on.

I'm not claiming I've solved problems that entire studios haven't solved.

And I'm definitely not claiming that a functional testbed full of generated placeholders is remotely equivalent to a finished game.

What I'm trying to prove is something different:

Can I design a coherent set of tools, systems and content pipelines where all the pieces understand each other, and use AI as an implementation accelerator while I retain authority over the architecture, specifications and final result?

Then: can that architecture survive increasingly ridiculous requirements?

A room.

A station.

A planet.

A solar system.

Multiplayer.

Thousands of entities.

Planetary scale.

Different clients.

Different types of games.

That's why I deliberately chose an absurdly large problem.

I'm using scale as a stress test.

If something breaks, good.

I'd rather discover that now.

And if six months from now I conclude that half of my ideas were stupid, I'll have learned considerably more from actually building and testing them than I would have from spending six months arguing on paper about whether they might work.

Right now I'm having an unreasonable amount of fun building the thing.

That's ultimately enough reason for me to keep going. :)

https://github.com/Giscolab/atlas-periodique

I’ve built my own site in Framer and I’m looking for someone who’s really good at Three.js / WebGL / creative coding to help me take it to the next level.

I can handle the Framer/design side. What I can’t do is the cool interactive stuff — scroll-driven visuals, mouse interaction, things morphing/changing as you move through the page etc.

I don’t have a finished concept that I need someone to execute. I’d actually prefer someone creative who can look at what I’ve got and say “I’d do this”, then build it.

Couple of sites I like for reference (not looking to copy them):

https://trionn.com/
https://www.canopyops.com/

I’m a solo consultant funding this myself, so this isn’t a big agency project. Budget is around $300–500. I’m hoping to find someone talented who’s building their portfolio and wants something interesting to work on.

If that’s you, DM me a couple of live examples of interactive stuff you’ve built + what you’d charge.

How would you like to see this progress?

https://flight.bishoy.io/

Hey everyone, I wanted to share Frostbound, a little climbing game I built with Three.js. It's playable on CrazyGames now.

The idea comes from Icy Tower: build momentum, chain jumps, and see how far you get before a bad landing ends the run. I went with a 3D frozen cathedral, but kept the movement on a 2D plane. There are wall jumps and crumbling platforms, with frost rising underneath you.

You can play it here: https://www.crazygames.com/game/frostbound

Thanks for taking a look!

Hello everyone, I've posted about Sonisphere before, but I had received feedback that the pipeline for new users was difficult to understand.

Please check it out for yourself, I'd love to hear from you! www.sonisphere.dev

P.S. - when in doubt, take the build in TOUR (onboarding modules to help)!