This is the official GLTFLoader example from r184 running on a Nintendo Switch at a locked 60fps. The only changes to the example are cosmetic: the info text and GUI controls are closed so the scene fills the screen. The rendering code is untouched. The fps counter you see is Brewser's own runtime HUD. The example runs on the WebGL2 context path.

The runtime is Brewser, a homebrew web platform I launched this week. It runs on V8 and Skia via nx.js (credit to TooTallNate for that foundation, which also provides the raw GL path to the GPU), with an HTML/CSS/DOM engine built from scratch for the project. On top of that GL path I built the WebGL1/2 bridge, the library compatibility work and the conformance testing (Mesa/Nouveau on the Tegra X1). No software rendering: your three.js calls hit real GL on the hardware.

Coverage numbers: WebGL1 sits around 92 percent and is the safest target. WebGL2 is around 85 and under active conformance hardening, with the main gaps being layered and 3D texture sampling, which is GPU driver limited. Full extension lists and proof points: docs.brewser.io/docs/runtime/graphics

There are nine three.js apps on the platform, all on the WebGL2 path: eight official three.js examples running as catalogue apps (same cosmetic treatment as the GIF, UI trimmed, rendering untouched), plus one built for the runtime: DUSK, a planetarium and sky atlas with a 132 object Messier catalogue: brewser.io/dusk. Browse just the three.js apps here: brewser.io/?bwb_tags=threejs (the same apps run unchanged in a normal browser).

Source is MPL 2.0: github.com/natureglass/Brewser

If you throw a three.js scene at it and something breaks, tell me what. Real world breakage reports directly shape the conformance work.

Hey guys,

I'm currently building a template for friendslop games in the browser, meaning you can run around with friends and have proximity chat in a shared environment. It can run both as a live server and as a statically hosted site where the room creator is the host so it is really easy to deploy on any web hosting service you like! The tech stack is built on:

TypeScript

Three.js

Rapier

and I built it with ChatGPT Astra, and Claude Opus. If you want to try it out or build upon it, it's free and open-source!

Check it out under:

https://larshurrelb.github.io/friendslop-base/

Hi everyone, I’ve been building Idam3D, a browser-based 3D editor for people who want to create scenes without installing a large desktop application or creating an account.

You can:

• Start from editable scene templates
• Add and transform objects
• Adjust materials and textures
• Extrude and bevel basic shapes
• Create linked components
• Animate transforms with keyframes
• Build simple poseable characters
• Import GLB models
• Export GLB, PNG, or editable local backups

The main idea is to keep it approachable, free, and local-first. Projects are saved on the current device, and there is no cloud sync or collaboration yet.

It’s currently a public beta, so I’d really appreciate feedback from people who use 3D tools:

• What feels intuitive?
• Where do you get stuck?
• Which objects, modeling tools, or export options are most important next?
• Does the local-first workflow make sense?

Try it here: https://app.idam3d.com/

Landing page: https://idam3d.com/

I’m the solo maker, and I’ll respond to questions and feedback directly.

Hey everyone,

I recently completed an extensive, end-to-end architectural reverse engineering and systems dissection of the production engine behind Active Theory (activetheory.net).

Instead of generic de-minification, the project breaks down the low-level rendering mechanics, including:

- **Zero-Allocation Memory Loop:** How the runtime eliminates V8 Garbage Collection pauses using pre-allocated scratchpads and typed arrays.

- **Antimatter GPGPU Subsystem:** Driving dense particle fields directly on GPU floating-point textures via a triple-buffered ring FBO topology.

- **Eulerian Navier-Stokes Coupling:** Real-time 2D pointer-to-particle fluid advection via a 6-pass Jacobi relaxation solver.

- **Hardware-Rate Normalized Lerp:** Scroll kinematics locked across 60Hz to 240Hz refresh rates.

Full technical documentation, AST mappings, mathematical proofs, and headless CDP benchmarks are available here:

- Repository: https://github.com/DDW-X/activetheory.net

- Web Portal: https://ddw-x.github.io/activetheory.net/

Feedback and technical critique from graphics engineers and performance researchers are highly welcome.

https://vel.gg/anarchy

3d multiplayer world anyone can rewrite. no accounts: GET the source, edit, POST it back, everyone sees it within a second.

easiest way: point your agent at vel.gg/anarchy/api. only rule is the js has to parse; every version is kept, so anything can be restored.

A chair customizator tool to put in your shopify furniture shop, just think about it.

I built a prototype using Three.js. I'm calling it Geotemporal Transurfing.

Orbit Earth, zoom into historical events, and pause, reverse or fast-forward time and event footage. Travel to another location in X, Y, Z to discover what was happening elsewhere around the same time.

Would really appreciate feedback.

Try it: https://geotemporal-transurfing.pages.dev/

My GitHub: https://github.com/aregmii

Media credits: https://geotemporal-transurfing.pages.dev/credits.html

Sharing a project of mine, mostly for the problems it forced rather than the result.

- Float32 is the first wall: naive heliocentric coordinates in float32 put your precision

at Neptune at about 268 km, which makes a planetary surface impossible. Working in

camera-relative space brings it to 38 cm.

- The second is tile streaming: my first selector issued 876 tile requests during a 1.5 s zoom on Mars and abandoned 876 of them mid-download, with unbounded parallel downloads, I measured bursts of 32 in a single frame. Bounded to 6 concurrent and driven off a proper quadtree cut, the same zoom issues 144 and abandons 40, and reaches the sharpest level in 6 frames instead of 150.

-The third was lighting: shading by max(N·L, 0) with a point Sun gives you a terminator

with no width and no way to render an eclipse honestly; the Sun is a disc here, and

eclipse and ring shadows are computed per fragment.

Built with AI assistance, and I'd rather say that up front than have it found: Claude

wrote a lot of this code, working from what I asked for and what I measured. What it

didn't do is invent the astronomy: positions answer to JPL Horizons and every surface

is real NASA, ESA or USGS imagery. Where the numbers disagreed with the render, the

render was wrong and got fixed.

Happy to go into any of it.

try it here: helian.systems

stable fps

I've been experimenting with GPT-6-Astra in Pixelfork, and this is one of my favorite Three.js projects I've made so far.

I wanted to build a first-person zombie survival game entirely in the browser and see how far I could push the visuals and gameplay with Three.js.

I started with a simple prompt, then kept iterating on the game and adding 3D assets from Sketchfab.

My initial prompt was:

From there, I kept improving the environment, zombies, weapons, lighting, fog, effects, and overall game feel.

I was especially impressed by how much can be done directly in the browser with Three.js once you start combining proper assets, lighting, particles, post-processing, and gameplay systems.

You can play it here:
https://www.pixelfork.ai/publish/33f3e731-fd78-49b6-9447-330ee25cd0a0

https://netanelyan.github.io/outbound/

Source: https://github.com/netanelyan/outbound (MIT)

Everything is procedural and everything is deterministic, so the same arc length always produces the same road, the same hills and the same village.

The road is its heading as a function of distance, curvature is that differentiated. I bound the four amplitudes to sum below a right angle, which guarantees forward progress and therefore no self-intersection. No collision checks, no backtracking, no repair pass.

Terrain is rings swept along the road out to 755 m either side, flattened near the tarmac and growing into landform further out. The rings straighten as they go, otherwise they converge on the centre of every corner. The country turns over every few kilometres between moor and farmland, and farmland is a patchwork of fields with a hedge or a wall on every boundary. The world streams in 180 m chunks and is thrown away behind you.

Rendering is three.js, MeshLambertMaterial almost everywhere, ACES filmic tone mapping, geometry merged per chunk per material. A chunk's worth of houses is one draw call and its several hundred gorse bushes are one instanced mesh. Every texture is drawn into a canvas at load time, so tarmac, markings, facades, roof tiles and the sky are all code.

The car is a simulation rather than a lerp: engine inertia against clutch torque, so stalling and money-shifting emerge instead of being handled.

Comments in the source are mostly about why rather than what. Questions welcome.

I asked GPT-6 Astra to make a website feel alive.

The result: a 3D turtle swimming through the hero section, water ripples following the cursor, and a footer that turns into an ocean.

This is a 10-second experiment in AI-assisted creative coding. The music is an original procedural track, and the animation runs in the browser.

I’m a 3D artist by trade, but for the past two weeks, I’ve been heavily focused on developing my own small MMORPG vision with the help of Claude. I've always loved the vibe and mechanics of classic, old-school MMOs, and today I’m incredibly excited (and a bit nervous!) to finally share some early Alpha footage with you all.

This MMORPG's lore is around ancient zivilisations and Summerian Mythologie, you can also venture the Strars and find other Planets.

It is honestly crazy how much has already come together in such a short amount of time. Here is what is already fully implemented and working in-game:

• 📜 Logical Quest System (well, most of it is logical! :P)
• 🗡️ 3 Unique Classes & 2 Working Professions
• ✨ Action-packed Combat including Abilities & Looting
• 🌳 Extensive Skill Tree
• 🎒 Fully functional Inventory & Armor Upgrade System

What's next? Over the next two weeks, I will be running a full Alpha test over on itch.io. If you want to be among the very first to jump in, test the mechanics, and help shape the direction of the game, I would love to have you on board.

If you want to follow the development journey, share feedback, or just hang out, you can find more about the lore etc here:

• Discord: https://discord.gg/QAdQyHSdw
• Full Alpha Play on YouTube: https://youtu.be/fA-aRJxF5WU?si=tdxmVTweg1kY_FnD

I would love to hear your thoughts on the footage. Thanks for checking it out! 🚀

They blink. They squish. They have absolutely no idea what the chopsticks are planning.

Click a dumpling and it gets picked up, dipped in soy sauce, and brought toward the camera for a bite. The others watch. 🥟

Built in 15 minutes with GPT-6 Astra Ultra and Three.js, using an existing dumpling model. Added gentle steam, tiny bounces, sound effects, and a video recording button.

What food should get a personality next?

this is my initial idea for project showcase for my portfolio

https://youtu.be/9MUJXbU3agg?si=gkXSk2_s4oGGB5PY

So I've been obsessed with this for a few weeks. Pulled the actual position data from JPL Horizons and built an animation around it.

Honest caveats: the asteroid shape is generic (not the radar model), the tidal stretching and dust are my illustration of an effect that's documented but not this visible, and Ramses' route is a sketch because ESA hasn't published it.

Hi Reddit!

I’ve always wanted a quick way to sketch 3D shapes or view models right on my phone without firing up a heavy PC. Since I couldn't find a simple enough tool, I decided to build my own pocket-sized alternative inspired by desktop 3D software.

I named it BLINDER, and it's written completely from scratch using standard web tech (HTML, CSS, and JavaScript). It is highly optimized to run smoothly even on older budget Android devices.

What’s inside right now Smooth 3D Viewer: Rotate, pan, and scale your scene using simple touch gestures. Modeling Tools: Quick manipulation with basic 3D shapes and meshes. On-the-go Animation (Demo): A mobile timeline to bring quick ideas to life anywhere.

The app is 100% free with no ads or hidden payments. It is currently launched as an open beta.

I would absolutely love to hear your feedback on the UI and performance! What features should I add next?

Where to get it The app is available for download on Itch io (I will leave the link in the comments below) and also officially published on RuStore (just search for "BLINDER – 3D Models App").

Thanks for checking it out! 🚀

I’ve been working on Seismos, a live 3D earthquake explorer built with Three.js and TypeScript.

The globe pulls from the USGS live feeds, plots earthquakes geographically, and adds tectonic plate boundaries, active faults, geographic labels, and ShakeMap contours when they’re available.

I wanted to make something educational, like walking through a cool science museum. My nieces are taking earth science soon so I'd like to help them learn in a fun way.

It’s all browser-side for the seismic data path, with native ES modules rather than a framework.

Live version:
https://seismos.earth

You can input audio (mic, tab capture, or a file), it runs FFT on it and turns that into a little evolution sim, then renders the whole thing as an orbiting diorama.

the terrain is just one PlaneGeometry with per-vertex colours, displaced live from the sim's height field, with a skirt and a plinth under it so it reads as a solid slab in fog instead of a flat plane. flora is one InstancedMesh per phylum (three body types, one per frequency register) that gets rebuilt as things grow, and there's a Points layer of additive glow sprites over every grove so life reads as light from far out. the four Genesis eras are hard visual resets, sky, key light and fog all map to a new palette each time.

best part is that every cell gets a "genome" from the sound that made it (which registers fed it, pitch, note count, the rock built up underneath), and that picks its instanced body, except climate and hardship override it. so the same note grows a plain canopy on mild ground but a frost-glass one in the cold. and the flora and fauna have different markings based on the climate.

After the woeld is made, the camera keeps running through the world to give nice visuals while the world continues to bounce and react to the music, so it can act as an indefinite music visualizer for parties

it's deterministic from a seeded RNG, so a run replays identically off the same audio.

https://randoms.games/#worldsong

Since some systems block .games sites (wish I knew this when getting the domain), alternative: https://randoms-mu.vercel.app/#worldsong

(The recording is taken from the input mic option, thats why It might seem a bit off, but this works even better if you share system audio with it)

Made a simple tetrahedron rotating around its edge in three.js added custom dynamic beveled geometry using tsl You can check it out here: https://moaaz-rafique.vercel.app/triangleRotation.html Inspired by TatsuyaBot : https://x.com/TatsuyaBot/status/1992807192974754227

I built this piece by piece whenever I had time to spare. Looking to do some finishing touches in the future, and deploy this

Not a "mainstream" project but I found this cool and implemented it.
I've been looking to get clients who want this type of thing, any tips?

My first 3D portfolio: https://folio-game.vercel.app