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/

Hello,

I'm trying to use Godot on Linux (CachyOS) for the first time but it keeps crashing on a specific point. There is no error message or anything, it just closes. I've been following this tutorial on Youtube: https://youtu.be/AdN27y_-UHA , at around 9 minutes it crashes every time.

I tried to record it: https://streamable.com/3fcbv8

I'm using Godot v4.7.1.stable.arch_linux [a13da4feb]

Has anyone an idea why this happens? thank youu

Over the past 2 months I've been working on a stream overlay for my streams implemented in @godot, and last night I finally got animated emotes working which has been the biggest hurdle to making the app usable on stream!

Hello, everyone! For the third time, we'll be working with a shader based on a line graph with many vertices. This time, we'll program an effect that loosely resembles a seismograph or another instrument with a similar display. It's a fairly simple algorithm and, as usual, comes with plenty of parameters to customize its appearance.

Hi all, I'm new to Godot and recently returned to my project that I have started last year. I've been trying to create a reusable button and use it in my GUI scenes. I created a separate scene round_button.tscn which has the following structure:

Control
 └─ RoundTextureButton
     └─ CenterContainer
        └─ IconTextureRect

RoundTextureButton is a TextureButton that reacts to mouse hover and IconTextureRect is a TextureRect that is meant to be an icon with texture set as an AtlasTexture. I made the following script that is attached to Control:

extends Control
class_name RoundButton

enum IconID { play, pause, back, forward, … }

const ICON_REGIONS =  [
	Vector2i(64, 0),
	Vector2i(64, 16),
	…]

@export var icon_id: IconID = IconID.play
@onready var icon_rect: TextureRect = $RoundTextureButton/CenterContainer/IconTextureRect

func _ready() -> void:
	icon_rect.texture.region = Rect2(ICON_REGIONS[icon_id], Vector2i(16, 16))

This creates a dropdown in Godot GUI which allows me to comfortably set the type of a button. It works as expected when I run the button scene.

Then I Instantiate Child Scene… in my menu scene menu.tscn to add a few buttons to my game menu. One button works fine, but when I add two or more, they all have the same icon, the last button that I added and set. What am I missing here with sharing attributes? I read that exported arrays are shared by all instances because the variables are really pointers to some memory location, but my icon_id is an enum value. To test this I have put a print statement in _ready() and it seems like the buttons have distinct values, but the icons are still shared by all of them.

https://backstitch.dev/

https://github.com/inkandswitch/backstitch/

paraphrasing one attendee: I didn't know that I wanted this

https://ghostarchive.org/archive/bxUO3

Released my first Godot Asset! A retro voice synthesizer :mycomputer:

Asset: https://store.godotengine.org/asset/eibriel/tts-079/

Try it on Itchio: https://eibriel.itch.io/scp-079-voice