Hey everyone!

For a long time now, our ambition has been to build the most impressive browser voxel engine ever built and shatter previously held beliefs about what's possible in browser games. We want people's first reaction to Jamango! to be "woah - this is running in a browser?"

Three months ago, we embarked on one of our most ambitious technical journeys yet: completely rewriting our chunk building pipeline, rendering system, and lighting architecture.

This wasn't just about making things look prettier (though they definitely do) - it was about solving fundamental performance issues and unlocking lighting capabilities that would help creators build games that look and feel truly epic.

The 3 Engine Challenges We Had to Solve to Cross the Chasm

Over three months, we tackled three fundamental problems that were holding back the vision of what Jamango! could become:

1. Performance bottlenecks that made the platform feel slow, especially on lower-end devices
2. Flat, lifeless worlds with lighting that didn't do our creators' work justice
3. Lack of visual cohesion, with props and characters feeling disconnected from the environment

Let's walk through how we did it.

Stage One: Rebuilding the Foundation

Our old chunk rendering system had hit its limits. Worlds were slow to load, switching between edit and play modes felt sluggish, and memory consumption was becoming a real problem. We've also consistently heard this feedback from our community. We knew that before we could build impressive lighting, we needed a rock-solid foundation.

The first iteration of a game engine will often be built optimizing for quick learning - seeing whether things work in relatively short time. This resulted in some parts of our chunk code not being fast enough. Additionally as you know we've focused on building our own in-world authoring tools for props: allowing you to build at world scale, select and then take off grid. Traditional voxel engines are great at cubic shapes so we had some challenges to make this work with our prop and physics engine.

Given the improved understanding of our requirements, the chunk generation system was fully rewritten for faster geometry building. Due to the improved speeds, some asynchronous building steps could be removed, which was a massive simplification on the codebase in the end.

Likewise, the rendering system was fully rewritten with custom shaders and batching. The rendering performance was improved to a point where we could add shadow-mapping while still running faster than our old chunk rendering ever did.

Another benefit from this rewrite is within the prop system. As props are essentially chunk-like geometry, the chunk generation code improvements carried over into prop mesh generation as well. For props themselves, their rendering was also rewritten for better re-use of geometry and batching.

Stage Two: Lighting That Brings Worlds to Life

We wanted to enable creators on Jamango! to build thematic lighting with depth, especially in indoor scenes, which was quite obviously lacking. Our vision was simple – redefine what's possible in the browser, pushing Jamango!'s visual fidelity and performance into a new league.

What made this especially challenging was that unlike traditional voxel games that work with simple cubes, Jamango! uses Noxels - our "non-cubic voxels" that let you sculpt slopes, curves, and organic geometry. This means some "off-the-shelf" math and algorithms don't easily apply (for example ambient occlusion calculations typically associated with the look). More unique block shapes mean more permutations - unique combinations of neighboring blocks - to calculate lighting for.

Further - we wanted the system to be lightweight, and hence performant. A janky experience is not worth the visuals - we wanted quick light updates and no frame drops.

To solve this we built two distinct flood fill systems that work together. The approach here is fairly typical for voxel engines, but our custom logic handles noxels as well.

Sky Light Flood Fill: This algorithm floods volumetric light into caves and interiors that aren't exposed to the open sky vertically. The color of this light is determined by your sky color environment setting, making underground spaces feel atmospheric instead of fully lit. The algorithm is fairly simple – any blocks not directly exposed to "the sky" will gradually get darker than their neighbors. Averaging out between the values allows for smooth "ambient occlusion" effects. Noxels in this system will partially permit light to traverse the space, but subtract light values faster than full blocks.

Emitter Flood Fill: Want lava that glows? Crystal lamp blocks? In order to emit light, the second pass of our lighting system allows any block in the world to emit a light to neighboring blocks. A similar flood-fill algorithm runs on these blocks, effectively giving you the ability to create light sources with beautiful visuals for any interior space like caves, buildings, or night scenes.

One challenging question we ran into concerned the usage of multi-colored lights. On the trade-offs mentioned above (performance > visuals) we chose a simple one-color approach for lighting, similar to Minecraft. This means that any light emitters in your world will share the same color of your choice – typically a nice warm orange, though you can go wild (we'll use a vibrant purple for Novawars for example).

Stage Three: More Depth & Visual Cohesion

While flood-fill lighting made the environment quite beautiful already, we wanted to add a bit more visual juice and polish to close off this major upgrade. Characters and props did not interact with the chunk lighting system very well, as they do not themselves cast any shadows. Getting this right is and always has been one of the major challenges of building just about any performant game, let alone browsers.

The two options we considered were simple "round shadow" sprites on the ground, or proper shadow-mapping.

In the end, we decided to go with a shadow-map based approach. Testing on Chromebooks confirmed that due to the improved chunk rendering speeds, the culling times on chunks for the shadow pass are now negligible. Further, with shadow mapping, we can allow the user to modify the resolution and drawing size of the shadow area if they are on really weak devices.

Designing for Trade-Offs

None of this came easy. Behind the scenes, every feature required tough decisions and clear priorities:

• Performance vs. Features: We chose single-color emitters over multi-color for better performance, while sacrificing some visual fidelity.
• Accessibility: Shadow-mapping is optional and can be disabled by users for improved performance. There is still a world where drop-shadow sprites could provide a middle-way option in the future.

What This Unlocks for Creators

Every world in Jamango! will look significantly better by default, with way less effort required. These three lighting layers give you:

• Atmospheric interiors with proper volumetric light falloff
• Creative lighting design using strategic emitter block placement
• Realistic shadows that add depth and immersion
• Instant iteration with zero lag between edit and play modes
• Environmental control through sky color and emitter color settings

🚀 What's Next

We're currently running extensive testing across different devices and scenarios. The dev build results are incredibly promising, but we want to ensure everything works flawlessly before release.

The whole point of Jamango! is giving creators tools that make their worlds feel alive. This lighting overhaul unlocks a new level of atmosphere, performance, and visual storytelling. We can't wait to see what you build next.

We'll also be publishing more regular behind-the-scenes posts like this one to the Jamango! blog. From engine improvements to creator tools to game design tips, we want to share more of what we're building (and how we're thinking).

Jump into #chat and tell us: What's the first lighting effect you want to experiment with? What kind of atmosphere are you hoping to create in your worlds?

— branana