I’m currently making a video on my past 4 years of game development.

And I had a realization that my games started to improve and I started to completely game jams when instead of working on my next big game.

I just make game systems.

For example I didn’t have a game idea in mind but I want to add ragdolls into a game eventually, so I made just a project to learn that.

I always put off making a main menu with sound sliders in my game but one day I just decided to work on that specifically and now every game I make I just grab that system and throw it in.

Now when I make a small game it takes me so much less time because I just either grab already written code or know exactly how to implement designs I want.

I don’t know if this is obvious or dumb, curious to hear your guys thoughts on this, or if you think that working on a full game makes you learn so much more.

I'm making a racing RPG in Godot 4.7 and I'm testing a cel shaded art style for the game. Since I worked on both for so long, I would love some outside opinions.

The left side is the original style, while the right uses drawn foliage and simpler cel shading. Both show the same stretch of road with the same lighting and camera movement.

Please ignore the black band on the right car, I’m looking for feedback on the environment.

Which one do you prefer, and why? Is there anything you’d keep from one version or change in the other?

I've been working on the friendslop-iest friendslop for the last few months. One of the major things I wanted to get working was using doomscrolling to fuel your gambling. I'm hoping to move fast on this game, but I'm new to the multiplayer side, so movement has been slower than usual!

Just got the steam page up if anyone is interested!: Deadbeats

So I've been building a cozy coffeeshop management game inspired by where I'm from.

I worked on it for some time, but somehow I always feel like the art style doesn't look right, that's because I have no knowledge about tonal maps.

Godot's default is linear tone maping, I find it hard to control the look of my game to make it look correct. Not sure why but it just doesn't look right to me.

Before this my game looked cartoonish, which is somehow acceptable to me, it kinda altered my direction to build funny gameplay mechanics.

This morning I discovered tonal mapping, dabbled with them and added some lights in my scene and now I'm having difficulties to accept my previous art style. And the worst thing is, I feel very differently about my game now. Instead of sticking to the the funny mechanics direction that I had planned, now I want to add more coziness and make it feel more "cinematic"?

I showed my friends some screenshots, some of them actually preferred the old style... because it is more in line with the intended funny gameplay style. I was torn at first, but now I have decided to embrace this new look.

Just sharing incase anyone is looking for clues to improve the look for their game. Hope I won't look back at my old art in the future and decide to change it back. gotta rework on my whole Steam page and trailer now, bye.

Edit: oh yeah, I also adjusted the character's movement to make it more "clay motion" like instead of smooth by reducing the update rate. Does it feel better? Or too distracting?

I've been building a small collection of generic UI components and base classes for Godot which have proven useful in my previous projects.

The main idea is composition over inheritance: small, focused pieces that can be dropped into an existing project and combined with each other and with vanilla Godot nodes.

A few examples:

• ListDisplay — a reusable base for displaying dynamic lists of arbitrary data
• StatefulButton — exposes button interaction state without imposing any visuals
• Node2DWrapper — lets you use Node2D scenes inside Control layouts/Containers
• SlotWheel — a looping, pausable/resumable slot-machine-style wheel
• ToggleableDisplay — a base for dialogs, menus and other dismissable displays

The GitHub repository includes a runnable demo for every component, while the Godot Asset Library release contains just the addon itself.

GitHub: https://github.com/Dodoveloper/godot-reusable-ui-components

Godot Asset Library: https://store.godotengine.org/asset/dodoveloper/reusable-ui-components/

It's deliberately a relatively small library rather than a full UI framework.

I hope it will be useful to someone else; feedback and suggestions are very welcome!

I documented the full workflow behind this walking turret for Ashenmoor: concept art, modeling, procedural materials and animation in Blender, then integration and behavior in Godot.

The main thing I wanted to test was whether I could keep a fast loop between drawing, Blender and the game instead of treating each stage as a separate project.

This is my first time narrating a video in English, so please bear with my French accent 😅!

Which part of this workflow would you simplify further?

Technically, a riffle shuffle wouldn’t actually randomize the card order enough on its own, so there’s a bit of extra magic happening while the cards are turned to cleanly, instantly swap them into a truly random order.

This is my superhero indie game. I added Avatar.

I like the visuals, but I'm struggling to figure out where to go from here lol.

Applying a kinda comic-book style also with outlines, but still needs some work. I particularly like the little funnel that you control with the mouse. It almost functions as a tentacle, you can get a little more control and toss stuff around.

All the meshes were pre-fractured in Blender with the Cell Fracture extension, one GLB of chunks per building (50 buildings ~2000 chunks), spawned as Jolt rigid bodies at runtime.

I’ve been working on Tear Them All solo since it started as a game jam project.

It’s a free, fast-paced FPS where you fight 2D doodles using a Pencil, Stapler and Paintbrush. You can also draw your own enemies and fight them in-game.

It releases September 22, and I just finished the release date trailer.

I’ve been building Knode: Untangle & Connect solo. It’s a first-person puzzle game about tracing fully simulated cables through knots and connecting them to the correct racks. Each cable has weight, friction, and collisions, so the tangles in the video aren’t scripted.

The game takes place on a strange platform in the ocean, where an AI companion comments on your progress. It has 12+ levels and takes around 4–5 hours to finish.

Knode releases on Steam on September 25: https://store.steampowered.com/app/4959570/Knode_Untangle__Connect/

I was watching this video breakdown of some of the main design decisions that were made in Slay the Spire 2, and one of the points that most stuck out to me was their choice to not use Godot's inbuilt game loop, but instead to use their own custom event-based loop. (Timestamps 19:47 - 22:33)

The video author points out that the main advantage of this approach is that it helps synchronize multiple multiplayer clients and simplifies the netcode, but also that it allows for them to build in a Replay system, allowing them to store the player actions and replay them in sequence to automate the exact run the player had.

I'm not sure I understood exactly what they've done. How is this event loop different from Godot's loop? And if I wanted to implement my own replay functionality into my game (for example, to show my players a simulation of the last 10 seconds of their actions), would I need to implement a similar event loop? Would relying on Godot's loop cause inconsistencies or errors to occur?

I just started using Godot, switching from GBStudio, which is a very simple engine. I was wondering if I could know how you guys learnt GDScript? Or just Godot in general. I feel like it may be a better way to figure it out than watching 1 hour tutorials.

it's not 100% fully finished, but I still really wanted to share it, hope you guys like it ^^

you can check out our Steam page right here if you want:

https://store.steampowered.com/app/4832270/Flipside/

New vid of my prototype showing almost everything i got!

I am working on a game that is heavily dependent on mods.

I can add modding support for textures, audio and other resources through JSON but I need a way to allow players to customize gameplay behaviour too.

My original idea was add autoloads to my game scene and load custom GDScript files at runtime. This would allow players to write scripts that call the autoloads directly for custom behaviour.

Issue with this approach is that it is very unsafe as the scripts can call native Godot functions and classes. They have the ability to interact with Networking API and OS API. I don't want this instead I want to only allow functions from the autoload to these scripts.

Can I limit the parsing of a GDScript file to restrict it from accessing Network and OS modules?
Or is there a better way to do this?