A (better) UID handling proposal

[fsoft72]

I am looking at the new UID solution that should be shipped with Godot 4.4 and I am really worried it will produce a bigger impact than expected.
I read the article about why UIDs are so important and I completely agree with the article, but among the various approaches that devs have considered it seems that the solution I am going to introduce was missing.

Why the external file is problematic:

• file system pollution
• the user must remember to move two files to be consistent

And this will kill code readability:

# These references point to the same Script resource.
# `other_script.gd` contains a `static func greet()` that prints some text.
var other_script = preload("res://other_script.gd")

# TIP: You can copy any resource's UID from the FileSystem dock's context menu.
# THIS WILL SLOW DOWN DEVELOPMENT IN SO MANY WAYS...
var other_script_uid = preload("uid://fkjlqx8er2sg")

Furthermore, if in the future we want to use AI agents to create files for us, there could be a problem in automatically adding files into the file system.

My proposal is simple, yet effective: embed the UID inside the resource file name. Using 36 decimal notation, we can have rappresent 1.679.615 unique IDs with just 4 characters in the filename.

For eg. the other_script.gd could be called other_script.x653.gd, so the user could continue to write:

var other_script = preload("res://other_script.x653.gd")

when the resource name is parsed, internally Godot could just care for the x653 part and load by UID and not by filename.

Since with the external file solution the user should remember to move two files each time, he/she can also be instructed to just don’t touch the last part of a filename.

This is it, simple and effective.

I don’t know if I am posting in the right place, if not, please tell me and I’ll move the discussion in a more appropriate location.

Thanks for reading

[Calinou]

The downside with this approach is that if you move or rename the script, the path will be outdated even if its UID means the script can still be loaded. This can easily be misleading, especially if you have swapped around two scripts' paths.

The editor would need to modify scripts on the user's behalf when moving files, even outside the editor, which sounds difficult to do. This can also mess with external editors especially on Windows due to file locking limitations.

The best way to make your code easy to understand is to use explicit variable names when preloading() something into a variable. It was true before UIDs and it's still true now.

Furthermore, if in the future we want to use AI agents to create files for us, there could be a problem in automatically adding files into the file system.

There is no hard requirement in using UIDs: using res:// paths in preload() is still valid.

[fsoft72]

The downside with this approach is that if you move or rename the script, the path will be outdated even if its UID means the script can still be loaded. This can easily be misleading, especially if you have swapped around two scripts' paths.

Yesterday I had a look at the Godot Editor source code. I think that a mixed approach uid cache + filenames with embedded uids could be a very good solution, especially considering there is a function in Godot code to recreate the cache from scratch.

The editor would need to modify scripts on the user's behalf when moving files, even outside the editor, which sounds difficult to do. This can also mess with external editors especially on Windows due to file locking limitations.

I am sorry, but I don't 100% understand this sentence. In my scenario things go this way

• starting state:

  root/
       assets/
           file1.x632.png
           file2.k392.png
  

• the user (outside Godot) creates a new folder and move file1

• the user (outside Godot) adds a new new_file.png

  root/
       assets/
           imgs/
               file1.x632.png
               new_file.png       
           file2.k392.png
  

When Godot starts:

• scan the project folder
• updates file locations based on their UID in cache
• if new files where added (with no UID), file names are updated with a fresh UID (this could raise the problem about file locking you were talking about, but I think Godot could throw an error asking to close the file in the external editor)

The best way to make your code easy to understand is to use explicit variable names when preloading() something into a variable. It was true before UIDs and it's still true now.

Of course, but if you have:

var player_anim = preload("uid://fkjlqx8er2sg")

and you created different versions of player_anim you no longer know which one you are referring to.
This will be as bad as Windows registry mess IMHO, and will deeply impact devs workflow.

(about AI agents)

There is no hard requirement in using UIDs: using res:// paths in preload() is still valid.

And this is good, but what if AI agents create new files inside the Godot Project? How is that handled?

Yesterday I compiled Godot from sources, I was able to identify (and modify a bit ;-) the resource_uid.cpp file) and I created a small project to see how UIDs are handled, but in my project I didn't find any additional file for the uid (only the cache in the .godot directory), could you please point me to some cpp files relevant to UID handling?

Thanks