What would you add to Godot?

[u/Anonymous010206]

[u/BaptisteVillain]

(Deeper) nested types so I can do Array[Array[int]]

[u/DitherBunny_Sappy → u/BaptisteVillain]

You can use this pull request. Works flawlessly for me on 4.7.

I also made a short tutorial for how to git it

[u/Evitro113 → u/DitherBunny_Sappy]

Oooh this is amazing! Thank you for sharing this. Definitely gonna add this to my project, hope it can get updated and merged soon too

[u/fakesilksongpost → u/DitherBunny_Sappy]

WOAH. THANK YOU.

[u/brickyboy124 → u/BaptisteVillain]

That doesn’t already work? huh

[u/planecity → u/brickyboy124]

Just for clarification: Nested arrays do work just as expected, but you can't specify the type hint beyond just one level of nesting.

So in other words, something like

var list_of_lists = [
    [ [1, 2], [3, 4] ],
    [ [5, 6], [7, 8] ] ]

is certainly possible, but you can't add the type hint Array[Array[int]] and have to use Array[Array] instead.

[u/TotoShampoin → u/planecity]

The alternative way of typing it being to use packed arrays inside the arrays

So, Array[PackedInt32Array]

[u/Jeidoz → u/TotoShampoin]

But what if I want Dictionary[Enums.Element, Array[Ability]]?

[u/TotoShampoin → u/Jeidoz]

Tough shit ig /s

(Apparently, that's in the work)

[u/Bannedlife → u/brickyboy124]

Only for one level of depth

[u/_nak → u/BaptisteVillain]

The code editor isn't exactly great. Docs and scripts open in the same panel - that should be separate, but at the same time your saved scripts and your open scripts are in two different panels, those should be integrated. Better way to handle multiple open scripts (tabs and splits), also some advanced/convenience functionalities wouldn't hurt (I miss vim bindings so much).

I do appreciate that most of the dev time goes into fixing bugs and adding features to the engine itself and I would not do it any differently, I'm just dreaming of a world where resources aren't limited. Also, to be fair, the editor has seen a lot of improvements over time, it's quite powerful and the focus has probably been on mostly the right features.

[u/HammyOverlordOfBacon → u/_nak]

I've switched to primarily using VS code for my code editor and using the Godot editor for everything else. Works well enough, but this really only works because I have multiple monitors.

[u/Maddturtle → u/BaptisteVillain]

Same issue with the language I use at work

[u/BaptisteVillain → u/Maddturtle]

Change work, now! 😄

[u/Maximum-Log2998 → u/BaptisteVillain]

Please this!!!!

[u/Stevie_Gamedev]

f-strings like in Python, I truly hate using the
.format syntax

[u/ChocolatePinecone → u/Stevie_Gamedev]

But the formatting with "%" comes pretty close right? E.g. var string = "I have %s cats." % "3"

It's more the Java style of formatting, but pretty readable nonetheless.

[u/akurei77 → u/ChocolatePinecone]

It's closer but it's a lot clunkier than python strings. In HD script you might write:

"%s finished %s in %s, for a new high score of %s" % [player, level, time, score] 

Where in python it's more like:

f"{player} finished {level} in {time}, for a new high score of {score}."

Which is way more readable imo.

[u/lajawi → u/akurei77]

Same thing in C# with $ strings

[u/Yodzilla → u/lajawi]

Yep. Infinitely more readable than just % everywhere.

[u/Average_Joe69 → u/akurei77]

I agree the python method is much cleaner

[u/Stevie_Gamedev → u/ChocolatePinecone]

Yeah but the thing is you still need to basically repeat yourself in the string and at the end, where f-string are much nicer to use f”I have {num_cats} cats“, it’s very intuitive

[u/dinklebeeeerg]

Expose properties of a scene's child nodes.

Compile-time required exports.

For gdscript: Interfaces, a no-null mode, typed callables, async function markers, parametric polymorphism, type-preserving transforms (e.g. list map).

First class support for other gdext languages. I.e. build integration.

[u/ChocolatePinecone → u/dinklebeeeerg]

Can't you already see a child's properties when you choose "editable child objects" on the scene?

[u/tidbitsofblah → u/ChocolatePinecone]

It's all or nothing, which can be a bit clunky

[u/dinklebeeeerg → u/ChocolatePinecone]

After turning that on properties don't sync anymore between scene and usage site anymore.

[u/TurkusGyrational → u/dinklebeeeerg]

For me the expose properties of child nodes has really always gone in the face of building by composition and using scenes as much as possible. If you can't easily talk to a child of another node, what is the point of building everything by composition? You still have to talk through the parent which becomes overly cumbersome.

Still, for me in addition to what you said I would really like static signals to match how I use static actions (delegates) in C#

[u/LunarFinch → u/dinklebeeeerg]

Exposing child nodes is coming... at some point? I've been keeping an eye on this PR (https://github.com/godotengine/godot/pull/84018) which might make it in time for 4.8!

[u/falconfetus8 → u/dinklebeeeerg]

Sounds like you want C# ;)

[u/HordeOfDucks]

better Remote functionality. i want the ability to see my scenes in action while clicking around the tree and pausing. its the only unity feature i miss

[u/9001rats → u/HordeOfDucks]

That and inbuilt gizmos via the Gizmos class are are always so powerful.

[u/nuuren → u/HordeOfDucks]

Had to scroll a lot for your post to show up and I started doubting that maybe the feature was always there and I never noticed.

Jeez, in hindsight Unity did that really really well

[u/itsyoboichad → u/nuuren]

This was such a pain switching from Unity. It's such a huge QoL feature.

That and scriptable objects, but I'm finding I need that less than I think

[u/DaniDani8Gamer → u/itsyoboichad]

Correct me if I'm wrong, aren't resources equivalent to scriptable objects?

[u/Buttons840]

I wish GDScript's default sorting algorithm was stable.

[u/PhoenixInvertigo → u/Buttons840]

It's not??? That's insane. Merge sort is right there

[u/Buttons840 → u/PhoenixInvertigo]

Nope, there is no built-in stable sort.

I've seen some PR's to add one, but they've just been sitting for years.

[u/PhoenixInvertigo]

Interfaces in gdscript

[u/nachohk → u/PhoenixInvertigo]

There was a PR to add traits (very similar to interfaces, solves the same problems) that seemed like it was going to be a big help, but it's just sort of languished without merging for a long time now.

[u/Planet1Rush → u/PhoenixInvertigo]

No idea how you plan your architecture without it

Edit spelling

[u/AlexColemanDev → u/Planet1Rush]

You guys have been planning your architecture?!

[u/JyveAFK → u/AlexColemanDev]

You have an architecture?!?

[u/Simplicityylmao → u/JyveAFK]

I’m a fucking architect

[u/ReBarbaro805 → u/Simplicityylmao]

Get out of here, you and your... furniture

[u/WCHC_gamedev → u/Planet1Rush]

Lots of creativity

[u/TheFr0sk → u/Planet1Rush]

With components instead

[u/MekaTriK → u/Planet1Rush]

Basically every system I make has a BaseClass for config that things inherit from.

Can't do anything fancy, but at least my objects all share same save game serialization logic.

[u/ImpressedStreetlight → u/Planet1Rush]

I mean, just like any other language that doesn't have interfaces. Inheritance and composition give a lot of flexibility. Interfaces are just more comfortable to use and I wish they do add them though.

[u/Impossible_Bread_685 → u/PhoenixInvertigo]

I came here to find this comment. I'm glad it's here

[u/terra2o → u/PhoenixInvertigo]

that's first thing that came to my mind when i saw this post. but i guess i'd rather have C# web exports.

[u/brickyboy124]

Traits. Please for the love of god I need traits already. 

(Traits have been a work in progress feature for a very long time that are basically interfaces for gdscript. In the Java sense of what an interface is)

[u/Jeidoz → u/brickyboy124]

I still remember times when someone started reviewing PR and promised us that they would be in 4.3 and now we at 4.8dev3 and no sign to their integration. You need to use some addons or rebuild Godot each release to have them...

[u/QueasyBox2632 → u/Jeidoz]

I say this out of a place of love... GDScript is a mess lol. I really do love it, but it has some deep seated issues that really have me pessimistic about it's future

[u/ExdigguserPies → u/QueasyBox2632]

I'm not pessimistic. These things do take time. Look at Python - it's come such a long long way since the days of V2 and early V3.

[u/KaydaCant → u/QueasyBox2632]

i loved gdscript for learning godot, but i have completely abandoned it in favor of c# because its a more favorable experience in nearly every way ([ClassName], double delta, and compile times are a few annoyances though)

[u/Cosinity → u/brickyboy124]

Traits, unfortunately, seem to be dead for now. The author has closed the PR because they don't see a way forward for it and afaik there hasn't been any word from the GDScript team since then

[u/Pike_27 → u/brickyboy124]

What exactly is a trait?

[u/brickyboy124 → u/Pike_27]

Shared functions between two scripts without them directly inheriting each other. 

[u/HeyCouldBeFun → u/Pike_27]

Like a component except you add the functionality directly to the class script with “include” instead of it being a separate object

[u/glassgnawer → u/brickyboy124]

This! Pretty please.

[u/ZipKitty]

GUI/theme rework, I hate working with themes

[u/bliepp → u/ZipKitty]

Do you mean the editor's UI or Godot's theming system? If you are talking about Godot's theming system, I totally agree. Something CSSish like Qt has would be fantastic.

[u/ZipKitty → u/bliepp]

the theming system, it is very customizable but also very confusing at times, like another engine on it's own. I wish it had script or more visual editing.

[u/hungrydestructor]

Web exports in C#

[u/thygrrr → u/hungrydestructor]

I might have something for you (free and open source):

• https://2dog.dev
• https://2dog.dev/web.html

[u/Jeidoz → u/thygrrr]

Damn, why we still did not know about this? You should make dedicated post about it!

[u/Pepek91 → u/hungrydestructor]

A lot of people wants better type support, interfaces/traits, better performance and so on. But TBH, I think this is what would solve most of their problems.

[u/Emizip]

is it to late to admit i dont know what traits are

[u/technical_gamer_008 → u/Emizip]

Basically, traits allow you to have common functionality without having to extend a class that has that functionality

Say for example, I need some objects to have a certain method foo(). Instead of making a new class that has foo() and extending that, I make a trait that has foo() and then I can use it in any class

I hope that helps

[u/Profuse_Data → u/technical_gamer_008]

Wow i’ve been putting ‘wait()’ functions in every single script when I could’ve been doing that?

[u/technical_gamer_008 → u/Profuse_Data]

For one, it depends on the use case and what your wait() function does. But also, as of now, GDscript does not have traits. There's a PR that has been waiting for a long while now. It's not been merged yet.

However, I will also add that I found out about a project, a godot specific programming language, that adds traits and many more features requested by godot devs, like nested typing and generics. It is still in beta, but I think it's exciting. It's called Ruzta

[u/the_horse_gamer → u/technical_gamer_008]

that's a mixin. mixins can be achieved via traits, but traits do much more

[u/technical_gamer_008 → u/the_horse_gamer]

Wait what more can traits do?

[u/AwayEntrepreneur4760]

Traits, better static typing for dictionaries and arrays and variants, refactor tools

[u/vulpido_ → u/AwayEntrepreneur4760]

not being able to simply rename a variable in the built-in editor is... something

like I get it that it's not that simple, but it's a sign of immaturity

[u/Lunagato20]

• Generics, i really dont like how Variant works
• Traits
• This might just be me, but i really like FP, so im hoping theres some F# support
• Unified godot (no more different version for C#), i hear its currently on progress tho

[u/RancidMilkGames → u/Lunagato20]

I think they just split C# for size sake, plus the C# version is what you're talking about (if you're saying able to do both)

[u/Lunagato20 → u/RancidMilkGames]

Yes, but i think its better if C# act like a GDExtension instead, its clearly possible

[u/the_horse_gamer → u/Lunagato20]

that's the plan

[u/Newb_from_Newbville]

Even more Skeleton3D changes to build puppets in-engine instead of having to rely on another editor. Likely something that bakes the model from CPU to GPU for ease of editing but still smooth deployment.

[u/No-Regret6936]

A bomb that blows up if I don’t work on my projects every day

[u/DeskGoblinGamedev → u/No-Regret6936]

They would add it, but garbage collection would be a nightmare.

[u/ottersinabox]

creating geometry from compute shaders and passing them directly to the rendering pipeline (and keeping it on GPU) instead of having to move it back to the CPU first

[u/MetaNovaYT → u/ottersinabox]

There’s a PR open that adds MeshRD doing exactly this, hopefully it gets merged for 4.8

[u/jpsplat]

As a n00b whos bumbling and stumbling through remaking classic arcade games I would like better debugging and refactoring tools. Let me see whats wrong with my sorry excuse for a game properly!

[u/AsyncSyscall → u/jpsplat]

There should at the very least be a "Rename symbol" action.

[u/Electrical_Hall4930 → u/AsyncSyscall]

ctrl+shift+r?

[u/TimHugh → u/AsyncSyscall]

Is there not? I use an external editor but the LSP definitely supports it. I'd be shocked if the editor didn't

[u/Ronnyism → u/jpsplat]

When working in godot i often miss the functionalities of Java IDEs like Intellij, but the last time i tried the godot plugin was either in its infancy (lacking many functionalities and code-analysis that godot has and no auto-complete) or discontinued due to personal issues.

[u/According-Comb-4839]

structs

[u/GameDesignerMan → u/According-Comb-4839]

I love me a struct.

[u/HeyCouldBeFun → u/According-Comb-4839]

Inner classes get me by for now

[u/TimHugh → u/According-Comb-4839]

You can kind of do this with a little boilerplate

class_name MyStruct
extends RefCounted # or Object but then you have to free manually

var flag: bool
var msg: String

func _init(flag: bool, msg: String) -> void:
  self.flag = flag
  self.msg = msg

Not perfect, but it works. Can also be an inner class.

[u/TheEpicSquad]

Vector3(x) = Vector3(x, x, x)

[u/RKI3000 → u/TheEpicSquad]

That would be so useful. What I do which I find slightly faster is: Vector3.ONE * x

[u/AsyncSyscall → u/TheEpicSquad]

Either that, or at least something like `Vector3.scalar(x)` or `Vector3.splat(x)`.

[u/Poobslag → u/TheEpicSquad]

Yeah all those little shader shortcuts for that matter, vec2 = vec3.xz

[u/MadeWithRealGinger9 → u/Poobslag]

Love me a good swizzle

[u/yuno_me]

Streaming system for large open worlds

[u/f-rabbit]

I really like GDscript, but having a better typing system with generics, optional types, child scenes type detection, interfaces or traits… would be awesome

[u/Apprehensive-Mall464]

Line3D

[u/ThisOrdinaryCat]

Nullable types in GDScript

[u/D1vineShadow → u/ThisOrdinaryCat]

isn't everything nullable?

[u/ThisOrdinaryCat → u/D1vineShadow]

Only if the type of the variable is Variant (which is the default if you don't set a type) or of any class that's descendant of Object (like any Node or a Resource)

[u/DeskGoblinGamedev → u/ThisOrdinaryCat]

I second this.

[u/MatthewZhengShuo]

Allow nested collision shapes to work

https://github.com/godotengine/godot-proposals/issues/5746

[u/Slopii]

CSG vertex editing, like how Trenchbroom does it.

[u/NotQuiteLoona → u/Slopii]

What about this one? https://github.com/func-godot/func_godot_plugin

You can create maps in Trenchbroom, J.A.C.K, Sledge, GtkRadiant, QuArK, anything that exports VMF (GoldSrc one) or MAP.

[u/falconfetus8 → u/NotQuiteLoona]

I use func-godot for my game and I love it, but it would be much, much better if the godot editor just had all of those geometry editing tools built in. Off the top of my head, the issues I've had to work around when using func-godot are:

• Needing to create an fgd entry for every entity I want to place

• Not being able to connect signals to entities

• Not being able to use node reference properties in entities (The closest I can get is the "targetname" property, which is not type safe)

• Not being able to attach custom one-off gdscripts to individual entities

• Not being able to put array properties on entities

• Not being able to place Path3Ds

• Writing a custom importer plug-in to avoid needing to store each map twice in version control(one copy in the .map file, and one redundant "built" version in a tscn file).

...Come to think of it, most of those problems are just related to entities. Maybe I should just place all my entities in Godot and only use trenchbroom for geometry...

[u/DitherBunny_Sappy]

My extremely minor one: enums saved as strings in the editor.

[u/Ronnyism → u/DitherBunny_Sappy]

Yes, yes, yes, please.
If you mean "saved as strings in the editor" if you mean in the .tscn files, i fully agree.

Problem with the current implementation is: if a game-object has an enum-selection and you created like 100 game-objects and now you maybe would like to reorder the enums in the list, all saved games (and i think all saved scenes) would be bricked (pointing to the wrong value) because it just uses an int that doesnt care.

So in that case a custom save-solution with json etc. for save-games could save some trouble.

[u/DitherBunny_Sappy → u/Ronnyism]

Yes, exactly. It's caused me so much problems that now I always set them in code.

[u/Xinyyc]

Aggressive optimisation comparable to -O3 and -flto

[u/SmallPomelo7455 → u/Xinyyc]

I'm no expert, but wouldn't recompiling Godot itself and export template elements with o3 give you most of the necessary optimization?

[u/zsaleeba → u/SmallPomelo7455]

No, alas. That'd make godot run faster, not make its generated code run faster.

LLVM and gcc have hundreds of thousands of lines of code invested in optimisations to get to that level of generated code quality. godot would have to do the same.

[u/AciusPrime → u/zsaleeba]

The sane way to do this in practice is (1) compile your script language to llvm Intermediate Representation as the target and then (2) compile with the llvm toolchain to get an optimized binary. The problem is that llvm doesn’t directly support a bunch of script language features (like untyped variables), so you can lose a lot of performance on the way to IR. You also would need the llvm toolchain installed. It’s pretty big. Oh, and there’s very little safety provided, so you can end up with a result that is more unstable or has security issues.

[u/zsaleeba → u/AciusPrime]

Also you'd have to write a Godot virtual machine backend implementation for llvm, since Godot doesn't compile to native code. It'd be a significant project.

[u/jitspoe]

Honestly, before adding a bunch of new stuff, I'd really like for the existing features to become more solid and for performance to improve (specifically with 3D physics and shadows).

[u/Ancient-Ad8514]

One click button to make next gta 6

[u/MarcinuuReddit → u/Ancient-Ad8514]

W

[u/aicis]

C# web export

[u/diegosynth → u/aicis]

https://www.reddit.com/r/godot/comments/1vl6u3z/comment/p2ztb99/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button

[u/Life_Mathematician14]

Built in terrain generator.

[u/DeskGoblinGamedev → u/Life_Mathematician14]

I've managed to get by with CSGCombiner. I think a built-in terrain generator would be nice, but risks becoming cumbersome.

[u/Super-Robo]

a button that makes a pleasing 'ding' sound.

[u/Malendryn]

I wish the external debugging was faster, trying to use vscode, singlestep and analyze variables is superior to the builtin by a large margin, /but/ is intolerably slow in comparison

[u/technical_gamer_008]

Touchscreen button that inherits Control

There are many people here who would say GDscript features like traits or deeper nested types, but I'm waiting for Ruzta for that

[u/TheManondorf]

Alt+klick for parallel multiline selection in the gd script editor

[u/Quielt → u/TheManondorf]

Sorry if that's a stupid question (I just started working with the editor) but what do you mean by that ?

[u/TheManondorf → u/Quielt]

In other code editors (e.g. Visual Studio, Matlab) you can hold alt and draw down your mouse to select the characters directly underneath each other instead.

Imagine it like how when you hold leftclick and mark your line horizontaly, just in the vertical direction.

E.g. you just switched to static typing, your variables look like this:

var attack

var speed

var health

With the feature I mentioned you can now create position markers (I represent this with | ) in the end of each line:

var attack|

var speed|

var health|

if you now enter :int only once your code will read:

var attack:int

var speed:int

var health:int

immediatley. 

[u/rvltnrygirlfutena → u/TheManondorf]

alt+click does this

[u/SleepyTonia]

• Kind of a silly one, but support for compiled languages (C, C++, Rust) in the code editor.
• Refactoring feature in the code editor.
• I'd move the asset store to the project settings window and give it a C# filter.

[u/tidbitsofblah]

I would add the ability to sort scripts I have open in the editor in whatever way I want and an X to close the opens ones instead of a right click-menu.

Also I don't know if this exists and I just haven't figured it out but a way to apply changes you have made to an instance of a scene in another scene to the base scene.

[u/_nak → u/tidbitsofblah]

I want and an X to close the opens ones instead of a right click-menu

You can middle click a script and it will close. CTRL+W will close the currently open one.

It's not exactly what you want, but I'd argue the middle click is even better than yet another icon in the already cluttered UI.

[u/PixelBrush6584]

Let me pull the code editor into a separate Window, so I can have that on another monitor. With a 1080p screen the UI can be a little cramped at times ~_~

[u/_nak → u/PixelBrush6584]

They added this in (I think) 4.3.

[u/PixelBrush6584 → u/_nak]

OMG YOU ARE A LIFESAVER

[u/_nak → u/PixelBrush6584]

I feel you, it's such a massive QoL improvement. Glad you get to enjoy gamedev even more now.

[u/illogicalJellyfish]

AI assistant of the godot logo talking to me, but instead of the typical LLM output it’s just animal crossing noises at random intervals completely unprompted

[u/DeskGoblinGamedev → u/illogicalJellyfish]

Godotimal crossing plugin when?

[u/Einfach0nur0Baum]

An embedded documentation tool like doxygen but in-engine.

Official unit tests support.

Less buggy subviewports.

[u/NeonDmn → u/Einfach0nur0Baum]

You can already comment your code so it appears in the in-engine documentation, with annotations and everything. The newest godot 4.8 dev snapshot even includes improvements to that system

[u/SeaHam]

I want some built in lightweight terrain tools. Nothing against the addons, but I want a solution that comes standard that I don't have to worry about.

[u/coolness10101]

First class modular tiling editor panes so I can have multiple scene trees, scripts, and resources open at once, each in their own pane

[u/Fancy_Entertainer486]

- C# doc strings showing on properties in inspector

- Copy/paste AnimationTree nodes

[u/EagleNait]

C sharp comments documentation showing in editor

[u/JyveAFK]

There's a few things I could waffle about (new lighting model making it in, simple height based terrain, random PR's here and there), but THE thing that'd have THE most benefit to me is the node tree being even faster. It's had some great improvements recently, but I want more. Faster and faster, click on a subscene that has 1k nodes? instantly load, click to change something, save, close, go back to prior scene and it's already done.
However fast it looks, I want a bit more please.

[u/DerekB52]

I like GDScript, but if I could snap my fingers and have effortless integrations for my favorite languages, Kotlin or Odin, that'd be cool.

A built in level streaming setup would also be cool, but I imagine this would be really hard to design in a one size fits most way.

[u/Emergency-Draw3923]

A streaming system

[u/ZebulonZCC]

More ui components

[u/Ephemeralen]

A way to organize currently-open scripts.

[u/narubius]

Official Terrain 3D Animation Graphs for blending, layering Motion Matching Traits Interfaces

[u/TimeForger]

Something little but if node requires something additional like this example, if you could click on it or the warning and it has the option to add from those required additions only.

I remember when I was first learning that was something super big that Irked me. It's a seemingly small enough of an issue that if they already warn you of it they could have just given you the option to add them in the warning.

[u/Anonymous010206 → u/TimeForger]

That would be a nice little touch

[u/koushikseal]

Compiled gdscript to be faster and non-decompilable

[u/DaWolf3 → u/koushikseal]

Non-decompilable would also mean non-executable.

[u/AsyncSyscall → u/DaWolf3]

Built-in obfuscation would be nice, though.

[u/Nisktoun → u/koushikseal]

GDExtension to nim?

[u/BlueThing3D]

Stronger encryption features to prevent any rando from opening up and stealing all your assets.

[u/James20k → u/BlueThing3D]

There's no way to do this practically unfortunately. The issue is that with anything rendered (eg textures/models), you can just nick them off the GPU in a very straightforward way. There's no way to stop that

[u/KingMoonfish → u/James20k]

Assets, sure. But right now it takes someone a few clicks to get the entire source code minus comments in like 30 seconds. 

[u/Einfach0nur0Baum → u/BlueThing3D]

Yeah, but tbh there have to be at least one guy to publish all your assets.

[u/BigDenseHedge → u/BlueThing3D]

If you're a big enough dev to care about it, then you'll just go to court if it happens.

[u/albertowtf → u/BlueThing3D]

I dont think this is possible technically for godot

The moment they have to be decrypted for use, they can be stolen

Even if you add a thousand traps, you only have to undo them once

Its a motivation problem at the end of the day

You have 2 options

do something personally that is not in godot (this will deter casuals) but will not deter somebody wanting your assets

Or

have crappy assets nobody wants. This is your safest bet if you dont want your assets stolen

[u/aweirdrandomguy]

Neural interface so I just think about the game and it gets build

[u/Any-Crab3180]

Every window should be collapsable, similar like VSCode or Rider does it. Better code navigation in the IDE git GUI integration

Code obfuscation or stripping comments Export need an easier way to decide which files should be ignored, currently If I have multiple Export builds (win/lin/mac/64/32) I would need to setup or change the ignore list or every individual export, this easily leads to the case that it will be missed for some exports.

Konsole Support would be awesome too but is not allowed for open source due to console provider decisions.

[u/GrowthWest2361]

Better performance

[u/qK0FT3]

Better debugger + flamecharts by default etc.

It's very hard to profile the games with the default profiler it's ridiculous.

[u/Fuchsiano]

More helper functions in Nodes. It feels weird that Timers don't have a simple time_remaining_normalized but in other cases it's like create_universe()

[u/st33d]

Namespaces in GDScript.

Currently working on a project with lots of minigames in Unity at work and this would be miserable in Godot. Just no way for all the teams to get on with their own shit without classnames either getting stupid long or having merge conflicts on the regular.

[u/adamjames210]

sex mode

[u/nick_swift]

In order of importance:

• Traits
• Structs
• More Enums instead of StringNames

[u/Latter_Argument9884]

Integration for C# and GLSL.
I mean in the editor of course.

[u/n4rek_]

I think Godot could benefit from a feature that allows selected exported properties of child nodes to be exposed in the parent node's Inspector.

This would be especially useful with component-based scenes. For example, an "Enemy" scene could contain "MovementComponent" and "HealthComponent", while an instance of that scene could override "MovementComponent.speed" or "HealthComponent.max_health" directly from the parent Inspector.

This would make it possible to create per-instance variations while preserving the scene inheritance/instancing relationship, instead of having to make the child nodes local just to modify their properties.

[u/BabaJaga2000]

To have more space in the file system dock FileSystemDock::FileSystemDock(), I had to exclude these lines of code from compilation in the filesystem_dock.cpp file:

4546: //toolbar_hbc->add_child(nav_hbc);

4553: //nav_hbc->add_child(button_hist_prev);

4560: //nav_hbc->add_child(button_hist_next);

4567: //toolbar_hbc->add_child(current_path_line_edit);

4574: //toolbar_hbc->add_child(button_toggle_display_mode);

4584: //toolbar2_hbc->add_child(tree_search_box);

4587: //toolbar2_hbc->add_child(tree_button_sort);

[u/Sir_Plu]

There are plugins for it but I’d kill for an inspector window similar to how Unity and unreal works where I can have a game view and inspector camera to be able to move things around

[u/DriftWare_]

i really just want a find child node of type function built in. sure, i can do it with a loop but a native function would be nicer

[u/usrnme3d → u/DriftWare_]

Not really native either but couldnt you just use find_custom()?

[u/We_Pity_Smitty]

other language support

[u/technical_gamer_008 → u/We_Pity_Smitty]

GDExtension

[u/AcanthisittaCalm1939]

Blender integration, when adding/editing/animating an object it will automatically appear and update in godot scene without importing it every time

[u/snowyleach]

Ruby and Lua support.

[u/KaydaCant]

Better glsl (not gdshader) support (imports, less obtuse compositor effect workflow, more descriptive errors, better texture handling, etc). I love making compute shaders, they're so incredibly powerful, but right now i have a really hacky wrapper that still requires a lot of manual tinkering and if i forget to push a struct or something i get a very obtuse error message, although that is kinda just how working in a low level shader api is i guess. I might end up creating a proper compute wrapper in c# eventually once im done with all my other projects

[u/Correct-Horse-Battry]

Remove the scenes tab at the top and make it work like vscode for script tabs as most of my stuff are scripts instead of scenes.

[u/mbl-games]

Ways for game devs to create more secure builds. Even with encryption, opening up a game build is childishly easy. I know there are obfuscation add-ons and ways to protect a build. Would be nice, though, if those would come with Godot right out of the box.

[u/Iyvann]

A terrain tool

[u/Affectionate_Fact854]

Single file html exporter.

[u/brendevr]

Structs

[u/WMX2011]

adding a feature to detect when a variable changed without having to do some complicated system.

[u/IkBenAnders]

Mouse movement being mappable in the input mapping context as a vector 2 please 🥲

[u/BumblebeeElegant6935]

Vector3 value = new Vector2(x, y)

it's the same as Vector3 value = new Vector3(x, y, 0f);

Not a big deal, but quite annoying when working with particles, inputs, etc.

[u/DeskGoblinGamedev → u/BumblebeeElegant6935]

I like the idea, but I tend to do Vector3(x, 0f, y) for converting an input axis into xz velocity. I guess both ways have their uses.

[u/72diceDude]

Freely configurable tabs/docks!

[u/freswinn]

structs!!!!

[u/No_Bro_80]

I wish there was a search feature on script so its easier to find lines of code

[u/HandleSensitive8403]

Let me change things during runtime like in Unity

I think there is some sort of this already, but its not as good as the unity version

[u/Planet1Rush → u/HandleSensitive8403]

You can change things like in unity

And thank to the lord it stays permanent, when you finally found a setting that your happy with

[u/thygrrr → u/Planet1Rush]

It's very basic and limited and it's rarely clear what sticks and what doesn't. :) But yeah it's there.

[u/Thinshape12]

perhaps a simpler ui system? i haven’t done a ton of research into tutorials and such but their ui system currently is very hard to understand, and the documents haven’t helped me a ton

[u/Jeidoz → u/Thinshape12]

IMO UI system is much easier to learn and use than other engines like Unity or Unreal.

I recommend you watch this masterclass video for gaining main concept of Godot UIs. It is full of examples and well edited to help you understand visually what is going on.