Hi everyone! This time, we’ll take a short break from shaders and look at an equally interesting technology — particle systems in Godot 4. It's not the first time I’ve showcased something like this — for example, the fire and smoke we had here quite recently. In this tutorial, we’ll create a quite useful effect: a trail behind a moving 3D object, with the trail based on the same shape as the object itself.

Ideally, modularity would be configured during asset creation. Like how Godot already allows Blender naming to do some stuff like this (even empties into joints/wheels) on import.

For basic use, I assume some of it could be done with an import script to split one scene into multiple variants based on the node tree (and names) with some simple logic/keywords. Likely makes even more sense with component-based code and using the same handling for editing code parameters.

For more advanced capability (particularly up to a character/vehicle editor) I assume it'd involve an add-on as well. At least it'd need a really solid editor script to handle offsets, symmetry/flipping (optionally, more inputs), scaling or other parameters. Something where you could easily create a new variation via a node or function call.

The ultimate form of this would be something that uses a flexible connector system, to the point you could probably assemble characters from 3D-printed parts if not a small scene.

I have explored multiple options. I know gridmap* could likely handle some of this (smaller grid for static objects, maybe other tricks for semi-static entities), I've been working on a custom shader with parameters to help with dynamic stuff (csg/textmesh color, color replacement for effects like emission or animation).

I assume things like Cyclops (level editor) or SDF modeling (and animations) could be used for an in-engine workflow. Though I am already having freezing/crashing (including some data loss) when editing things with shaders/lighting (4.4.1) so I have not tried those yet.

Also on a more basic level, I assume some rigging can be done just with node visibility and animations (+state?) though I haven't tried Blender animation yet.

* though from what I've seen, it seems like it's missing ways to properly configure bigger cell sizes easily. Sort of necessitating multiple grids (even in addition to walls vs decoration) or having cells that can overlap if you don't place them properly. I assume having multiple grids also does not calculate free grid spaces either (unless you mix grid and non-grid to use the new raycast placement).

Games mentioned:

Nested

Nested is a cute grid-based puzzle game made around the concept of russian nesting dolls. Come twist your brain as you stack, push and interact with the various objects you'll find in each levels. Let's see if you can reach the right combination of nesting dolls to solve every one of them!

https://store.steampowered.com/app/3752780/Nested/

Tyto

Take flight and glide through a breathtaking world in this visually stunning platformer, where you play as a lost owlet searching for its family in a vast and perilous forest.

https://store.steampowered.com/app/3579340/Tyto/

Pathogenic

In Pathogenic, you are the disease. Experience a 2D roguelike twin-stick shooter as a lone parasite fighting a war against the immune system to infect your human host. Evolve from a simple cell into a complex engine of destruction and conquer the procedurally generated world of microscopic wonder.

https://store.steampowered.com/app/3808690/Pathogenic/

Spooky Express

Plan the train route for the world’s spookiest theme park! Transport monsters to their destinations — but don’t let them bite the passengers or you’ll have a grave problem.

https://store.steampowered.com/app/3352310/Spooky_Express/

Cell Sword

Your medical emergency is important to us. Our health professionals will be inside you shortly.

https://store.steampowered.com/app/3163320/Cell_Sword/

GodotFest 25 is the official European conference in association with the @godotfoundation featuring keynotes, workshops and more hosted by prominent members of the @godotengine community.

Join us - Nov 11 & 12 2025 @ SmartVillage Bogenhausen, Munich

https://godotfest.com/

More Infos at GameFromScratch: https://gamefromscratch.com/godot-asset-store-launched/

The Roadmap can be found here: https://store-beta.godotengine.org/roadmap

Hi everybody! Do you remember the tilted square grid shader we created here some time ago? If you liked it and would like to try something similar but more irregular, you might be interested in this tutorial, where we’ll create an effect similar to a stone mosaic — which can be a very interesting feature in many games.

• Invidious
• Youtube

Lots of fantastic changes coming in 4.5, some of which are a long time coming.

My personal highlights:

• Proper SVG support and text scaling
• Tilemap chunking which boosts performance and stops glitching in-between tile seams
• Variadic arguments in functions
• In-editor translation previews
• Windows exports no longer need rcedit to change the icon/metadata!
• Build profile now properly detects everything in your game, giving you a file to exclude all the nodes and features not used to easily reduce binary size
• Emission shape gizmos on 2D particles (finally)
• Screenreader support
• Recursive focus modes and mouse passthrough for Control nodes
• Borderless fullscreen mode on Windows finally doesn't have a 1px outline
• Deep duplicates of resources finally work, previously anything in collections like arrays wouldn't get duped and you had to go through them manually
• Lots of optimizations for the web

I'm digging the design. I miss that type of style of RTS.

Hi everybody. This is the sixth part of our tutorial dedicated to rendering 3D scenes using shaders and raymarching technology. This time, I’d like to try improving the materials by adding textures, which we’ll pass into the shader using new uniform parameters, and briefly explain how so-called triplanar mapping works.

I found these two super simple tutorials to get started with a 3d character and its animation tree.

https://www.youtube.com/watch?v=TFj67HbsyIg

https://www.youtube.com/watch?v=Si1Pz_7GIbM

Is there a way to have the script automatically written by the animationtre ?

Robot Anomaly is participating in Steam Next Fest!!

@godot

Share, wishlist or install the demo to support my indie dev journey! :keanu_thanks:

https://store.steampowered.com/app/3619430/Robot/_Anomaly/_Demo/

#Steam #SteamNextFest #NextFest #IndieDev #IndieGame #GameDev #Godot #LinuxGaming

Hey everyone! Today's tutorial is a little bit special because it covers an effect that has been part of my Godot Shader Pack for several weeks now. However, I believe it deserves a more detailed explanation for those who not only want to use this shader but also understand how it works. So, let’s get into it.

This is my first high-effort project using godot, and besides the player animated sprite and movement system (based on a tutorial by HeartBeast!) all the pixel art, sfx, music, programming, etc. was done by me. This was made as part of a physics project about black holes and Einstein's theory of relativity and is partly based on the movie "Interstellar"

I am really proud of this and I think my pixel art has really improved! I really like how the dialogue boxes turned out and the music sounds pretty decent too. The decorations (grass, flowers, rocks) turned out really great as well!

here's the itch.io link: https://spenguin.itch.io/space-holes

and several screenshots of the game:

godot-rust v0.3 brings type-safe signals to the table.
If you register a signal:

#[signal]
fn damage_taken(amount: i32);

you can now freely connect it with other Rust functions:

fn ready(&mut self) {
    // Connect signal to the method:
    self.signals().damage_taken().connect(Self::on_damage_taken);
    
    // Or to an ad-hoc closure:
    self.signals().damage_taken().connect(|amount| {
        println!("Damage taken: {}", amount);
    });
    
    // Or to a method of another object:
    let stats: Gd<Stats>;
    self.signals().damage_taken().connect_other(&stats, |stats, amount| {
        stats.update_total_damage(amount);
    });
}

Emitting is also type-safe:

self.signals().damage_taken().emit(42);

Furthermore, you can now await signals, effectively introducing async tasks:

godot::task::spawn(async move {
    godot_print!("Wait for damage to occur...");
    
    let (dmg,) = player.signals().damage_taken().to_future().await;
    godot_print!("Player took {dmg} damage.");
});

There are many other improvements, see devlog and feel free to ask me anything :)

Huge thanks to all the contributors who helped ship these features!

~this was originally posted by @[email protected] the project author on reddit. I'm just maintaining some parts of the project.~

Hi everybody. Let's continue our series on modeling 3D scenes using shaders and raymarching technology. In the previous fourth part, we managed to render the scene from any position and at any angle, which is very useful in itself, but we were still rendering each object in the same monotonous color. This time, we'll fix that detail and rewrite our code so that we can assign a different material to each object.

Hi everyone! I think every shader developer has at some point found themselves in a situation where they needed to determine certain values in the fragment function, especially when the shader wasn't behaving as expected. The problem is that the shader runs on the GPU, so we don't have anything like an output console available. So, how can we solve that? There are some options, and I’ll demonstrate one of them in this tutorial.