Hello, everyone! Let's create a simple shader that distorts an image into a spiral, simulating flying through some kind of abstract tunnel. It's a very simple piece of code, which I will now explain in detail.

Why don't all games do this? it would make loading so much faster!

Link to the original post on Reddit.

I got the idea for this some time last week, I think. Pretty good, but it doesn't yet work on everything, such as ShaderMaterials.

Found this post on Reddit, decided to cross-post:

Found a paper on Weighted Blended Order-Independent Transparency https://www.jcgt.org/published/0002/02/09/ posted in 2013.

Turned out it was the key to 3D translucent billboard clouds where the order doesn't flip-flop. Think it turned out pretty cool!

Link to the original post.

Hopefully this is the last time I have to implement the backend for this - I'm going to reuse the code for this from now on. (The display, however, could definitely use some work.)

You don't have to go through the same ordeal. Get the source code from my Codeberg repo - it's MIT licensed and GenAI-free.

You can also follow the plugin development on my:
Mastodon
Bluesky

I had this idea lying around in pieces for a while, a much, much tighter and more flexible tweening API for Godot.

What inspired was this repo (unity-tweens) by Jeffrey Lanters, I used it a few times for Unity and after an upgrade, the API got super weird. All the fluent stuff was gone...

... until I realized it was so, so, so much better this way. ♥️

Well, Godot is full of fluent API for tweens, and I always found it bewildering and a bit clunky to use; even though Godot is my absolute favourite game engine right now.

Long (very looooong, tweens.gd users will get the joke later) story short - tweens.gd became a bit of a monster project, not gonna lie. Godot has, surprise!, a boatload of nodes, each with boatloads of properties.

... here it is. Still a little rough around the edges (generated docs at the end are dense, and the Godot in-engine samples are still very much WIP).

This has been a really fun practice effort to make a 'nice' asset/plugin for the Godot Asset Store. I want to keep maintaining it, of course (I run a small org on github called ⤜outfox⤏, making tools and libraries for fun rather than profit.

https://store.godotengine.org/asset/outfox/tweens/

Call to action - I would absolutely love for some indie devs to try it out and let me know what you think.

• does the API make sense? (both C# and GDScript ... I know I'm getting kind of cute with a few of the concepts to eke out more legibility and less verbosity)

• is the performance and stability okay? (I have a super basic benchmark that says it's doing okay, comparable to the built-in Godot Tween class.)

• what's missing? what's needed from your end?

Cheers, and thanks in advance. I'll be here in the thread to answer questions.

Hello, everyone! It's time for another simple tutorial that could find its use in a 2D game. We've covered something similar here before, but in a much more simplified form. This time, we'll be shaking an image or the screen using a slightly more sophisticated algorithm. So let's program it.

https://youtu.be/hPN2TpN3FSs

I've been working on CSG Blockout, a Godot plugin for blocking out levels with Godot's built-in CSG nodes. Version 3.0 is out today. It's the first version I'd call a level prototyping tool rather than a shape helper. It's free and MIT licensed.

What it does

• Build. Drag on any surface to draw a box or a whole room, click a wall to cut a door or a window, push faces with arrows, type exact sizes.
• Measure. A player reference shows your character's height, jump height and sprint-jump arc. Select two platforms to check whether the gap is jumpable, or run a level check that flags slopes too steep to walk and ceilings too low to stand under.
• Play. Play From Here drops a first-person test character where you're looking. It jumps exactly as high and as far as your player metrics say, the same numbers the checks use, so when the jump check says a gap is jumpable, the character can actually make it.
• Freeze. A finished room becomes a plain mesh with collision, and Unfreeze gives you the exact CSG back. When the level moves on, you can export to a MeshLibrary for GridMap, or send it to Blender as .glb and swap the refined mesh back in.

It's just Godot nodes

Every shape you draw is a stock CSGBox3D, CSGCylinder3D and so on. There's no level format of its own and no hidden data. Disable the plugin and your scenes open and run exactly as before.

If you delete it entirely, here's what changes: stairs are a CSGPolygon3D underneath and keep their shape; frozen blockout stays a regular MeshInstance3D with collision, you just can't unfreeze it; the grid materials live in the addon folder, so copy them out first; and bake any Repeater/Spreader before you go.

"Isn't CSG slow?"

It can be, so I measured it. Godot only rebuilds the CSG tree you change. With one tree per room, moving a wall takes about 2 ms no matter how big the level is; with 400 primitives in a single tree, it's about 30 ms. In a running game, live CSG costs nothing per frame, but it has to compute everything while the scene loads: on my machine a 400-primitive level started in 166 ms live and 38 ms frozen. Freezing it takes under 0.1 s, and exports strip the stored CSG. The benchmark is in the repo if you want to run it on your own hardware.

What it isn't

It's not a brush editor: there's no vertex editing and no per-face UVs. If that's what you need, Cyclops Level Builder or TrenchBroom with func_godot are good choices. CSG Blockout is for the step before that: getting the layout right and knowing it plays.

Godot 4.6+. Interface in 7 languages.

• GitHub: https://github.com/qwqzhanqwq/Godot-CSG-Blockout
• Asset Library: https://store.godotengine.org/asset/qwqzhanqwq/csg-blockout/
• Benchmarks: https://github.com/qwqzhanqwq/Godot-CSG-Blockout/blob/main/BENCHMARKS.md

It started as a rewrite of LuckyTepot's CSG Toolkit. I'd love to hear what's missing from your blockout workflow, and bug reports are very welcome.

The closest tag on the official forums is "networking" which I don't think is relevant. I'm talking Paid, Unpaid, on Contract, Part Time, Full Time, the works.

Hello, everyone! Let’s again create a spatial shader for a 3D object. This tutorial is special because for the first time I will touch on a function that I have completely ignored so far. It is the function called light, and I will show how we can work with it.

This is a marble run builder I've been working on for my son. Its inspired by Townscaper with just clicking to build and find the different patterns like tunnels, spirals, steps, and more!

Decided to take my hand at making a trailer for it as well. What do y'all think?

Found this on r/godot and thought it was worth sharing here. Link to the original post: https://www.reddit.com/r/godot/comments/1wohnea/godot_can_do_really_amazing_things/

Probably not going to be much of a game. My goal is to make strandbeest you can climb and then control. I'm going camping this week so I'm only getting like 3 days to work on this.

Hi everyone! I think after several relatively long videos, it would be nice to do something simpler for a change. We’re going to program an effect that simulates looking at an image through square-shaped curved glass.

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.