Hi everyone! Maybe you remember the first tutorial I published this year, which demonstrated a simple algorithm for distorting an image divided into tiles. This time, we'll take that idea a step further and create a simulation of a wall made of differently distorted glass bricks.

Google Chrome Labs keeps an Awesome HTML-in-Canvas list of demos for the API, and one of them is a Godot scene of mine.

Here's how the Godot side works. The three panels in the scene are real HTML, drawn straight into textures Godot already owns. You can select text on a tilted panel while the camera moves, Ctrl+C it, Ctrl+F finds it, right-click translate works. (It's real DOM, so it's also in the accessibility tree, which a canvas HUD normally isn't.)

The bit that's useful even if you never touch this API is getting at Godot's own WebGLTexture from GDScript:

• RenderingServer.texture_get_native_handle(tex.get_rid()) gives you the GL texture id (web export = Compatibility renderer)
• inside JavaScriptBridge.eval, GL.textures[id] is the actual WebGLTexture (emscripten's lookup table)
• write to it from JS, then put the GL state back after (active texture, binding, unpack flags). Godot doesn't expect anyone else touching its context

Chrome changed the API this week: texElementImage2D became texElementSubImage2D, panels need a new drawable attribute, and hit testing moved to updateElementGeometry. For a Godot texture the new version fits better actually, Godot already allocated the storage so it's just a sub-image write. I kept the old path behind feature detection since stable Chrome is still mid-transition.

Caveats up front: Chromium only (origin trial on the demo, or the CanvasDrawElement flag). Mozilla and WebKit haven't taken a position yet, both requests are still open. So it's an experiment, not something to ship a game on.

Source (MIT): https://github.com/Vav-Labs/quest-signal Write-up + live demo: https://vav-labs.com/case-studies/quest-signal/

Hello, everyone! It seems that the cave tunnel shader I created here recently was quite successful, which pleased me enough that I decided to add another effect based on a similar principle. So, let's take a look at how we can program it.

Paco is a free tiny package manager that provides a safer way to manage dependencies by downloading and installing packages from a trusted and predefined array rather than shipping addons and / or binaries directly with the project.

It's pretty much like Python, Go, or Ruby, where project dependencies can be installed from a list of packages and versions.

We’d love to get any feedback on this and know what you'd like to see improved

Thanks! 👋

Hello, everyone! We previously looked at a shader that generated spiral-shaped objects, but back then it was just an elementary implementation. This time, let’s try something more practical, namely a distant view of a spiral galaxy.

Hey everyone!

I've just released v2.0 of CSG Blockout, my open-source plugin for faster CSG-based level blockout in Godot 4.

For this update, I mainly wanted to solve two things that were getting in the way of my own workflow: grid materials getting stretched on slopes and boolean shapes, and having to think about CSG hierarchy every time I created a new shape.

1. Procedural world-aligned grid materials

The new grid_triplanar.gdshader uses world-space triplanar mapping, so the grid stays aligned to the world instead of following the object's UVs.

It supports:

• Major and minor grid lines
• fwidth()-based anti-aliasing
• Clean grid alignment on slopes, ramps, and boolean cutouts
• No UV setup required

I also added Light, Dark, Orange, and Custom material presets, which are stored in ProjectSettings.

You can switch between them or apply one to selected meshes directly from the sidebar.

The Shift+A pie menu also uses the currently active preset when creating new geometry, with full Undo/Redo support.

2. Context-aware CSG node placement

Previously, creating a new CSG shape sometimes meant deciding whether it should be a child or a sibling, either through preferences or modifier keys.

For v2.0, CSG Blockout now uses the current selection to infer what you probably want:

• Selecting a CSGCombiner3D → new shapes are added as children at the bottom.
• Selecting a CSGShape3D → new shapes are inserted as adjacent siblings.
• Selecting something else or nothing → falls back to the normal parent/root placement.

This also required refactoring the creation and deletion logic to keep node order, ownership, and Undo/Redo behavior intact.

Links

GitHub: https://github.com/qwqzhanqwq/Godot-CSG-Blockout

Godot Asset Store: https://store.godotengine.org/asset/qwqzhanqwq/csg-blockout/

I'd love to hear what you think, especially if you run into any edge cases or have other blockout workflow features you'd like to see!

TIL NavigationServer3D.map_get_path() in Godot 4 stops searching after 4096 polygons by default. On a big navmesh the path just ends short and looks like a disconnected island.

With an extra $18 million raised, W4 Games plan to continue to expand their enterprise technology and support for the open-source Godot Engine. This new round of funding that was just announced was led by "Tencent, with support from other investors including OSS Capital, LUX, Naval Ravikant and Tobias Lutke’s family office".

W4 Games said they have also now "signed a multi-year strategic partnership with Tencent" to help them scale up the business and Godot ecosystem across Asia to help with the likes of marketing, localization, ecosystem support, advocacy and so on.

Chaos run is a small game I made with Godot. It’s a side-scrolling runner game where you must avoid or get rid of enemies and obstacles. For each one there is only one way to counter. It’s the chaotic child of a memory game and a game based on reflexes.

The normal mode should be easy to beat in a few attempts and the game is very short, around 3 minutes. Once you beat normal, you unlock hard and nightmare, and, to be honest, I haven’t beaten those yet. But I’d love to hear that someone did it.

The game can be played in your browser on itch.

[https://kuruad.itch.io/chaos-run](Chaos run)

Hello, everyone! Let's expand our collection of tunnel effects with another shader. We've had several fascinating examples here, most of which looked very regular and demonstrated a smooth flight through some kind of corridor. This time, we'll try something more irregular that could resemble flying into some unknown cave.

I made a Godot plugin called CSG Blockout, based on another MIT-licensed plugin. I refactored a large part of the code, added a pie menu, and made some other improvements.

I've been using it in my own workflow, and it makes blockout and level prototyping much more convenient. I recently got it published on the Godot Asset Library, so I figured I'd share it here.

This is my first time making something like this and publishing it on the Asset Library, so I'd love to hear any feedback or suggestions!

https://store.godotengine.org/asset/qwqzhanqwq/csg-blockout/

Project: Hadean chronicles.

Particle-based glow system retired. Shader-based flares and sunspots now in production, fully verified visually.

First Obstacle: The Edge-On Mesh

The Sun’s CPU particle system rendered as a tiny red speck instead of a soft corona. After ruling out data issues, configuration problems, and surface artifacts, the real culprit revealed itself via a diagnostic force-opaque test. The glow quad mesh was facing edge-on to the camera, rendering to near-zero width under the fixed top-down perspective. Once this geometry issue was diagnosed, other mechanical problems became clear.

The death-alpha on the color ramp had been commented out—particles just popped rather than fading. Outward radial acceleration was an entire hemisphere pointed inward, creating a frozen shell instead of a breathing corona.

The Pivot: Swap Particles for Shaders

CPU particles bring hidden costs: per-element simulation, alpha sorting, lifetime checks, and overdraw stacking. For a feature meant to complement a shader-driven surface, the limitations outweighed the benefits.

The final decision: add flares and sunspots directly into the fragment shader. Eliminates draw calls, removes CPU simulation, and lifts the performance and visual ceiling.

Shader Suite: Intrinsic Sun Effects

The new sun sphere shader introduces two independent organic effects:

• Flare Overlay — bright patches sampled from value noise and masked in via additive blending with soft fwidth() edges. Controls handle frequency, threshold, and intensity.
• Sunspot Darkening — dark patches applied as shadows on the surface. To avoid visual clashes with flares, a separate noise sample uses different scale and a fixed phase offset, applied as a multiplicative dimmer after all additive light contributions.

Both effects share a 2-hash, 3-octave value-noise utility—cheap, localized, and flickering in real time.

Visual Duels: Tuning by Screenshot

Several subtle regressions emerged with each adjustment, each caught and corrected through visual verification:

• After decoupling flare frequency from texture tiling, the result looked fractured along hash-lattice edges. Switched to separate spherical UV sampling to fix aliasing.
• With wavelength-limited scale, large regions of the disc interpolated into giant blocky polygons. Increased scale and added a third finer noise octave for smoother, smaller patches.
• Early mixing caused sunspots to be invisible, hidden by additive core and rim passes that ignored the darkening mask. Moved the pass after all additive contributions.
• Sunspot coverage was too heavy, producing oversized, blurry blotches. Tightened threshold and raised scale for sparse, smaller, crisper spots.

Outcome

The particle system code remains in place but dormant, with the glow emission call commented out. A planned hybrid (shader + dedicated arc sprites) was discussed but not adopted. The shader implementation now delivers a living, breathing corona without expensive particle infrastructure.

Hello, everyone! I’ve created a shader here before that simulated a simple animated star. This time, we’ll take that creation to the next level and create a much more interesting type of star using a somewhat more complex approach.

Hello, everyone! Let's create an effect that resembles boiling lava viewed from above, which can be useful for various top-down games. It's also a great demonstration of using four-dimensional noise and slicing it into three-dimensional layers, resulting in the characteristic flowing lava animation.

Would really appreciate any and all feedback for my cooking game. I kind of used making the game as a way to learn the Cogito framework in Godot. If you haven't of it you might want to check it out. It's pretty useful.

https://oneoverzero.itch.io/burger-stack

I am thrilled to announce that the action platformer Amata will be releasing on the 20th of August 2026! This news comes with the final feature update for the main campaign before release <3. This patch contains all the planned content for the final release, though I'll continue working on translations and any bugs that come up!

There won't be much changing between now and Aug 20th so if you'd like to jump in early then try the demo and pick up the game in EA today!

Thank you everyone so much for everything, I hope you enjoy! Come hang out on Discord!

https://store.steampowered.com/app/1841160/Amata/