diff --git a/source/blender/CMakeLists.txt b/source/blender/CMakeLists.txt
index b6aa0d1d8b8..593897d4a43 100644
--- a/source/blender/CMakeLists.txt
+++ b/source/blender/CMakeLists.txt
@@ -69,7 +69,7 @@ set(SRC_DNA_INC
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_screen_types.h
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_sdna_types.h
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_sequence_types.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_session_uuid_types.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_session_uid_types.h
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_shader_fx_types.h
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_sound_types.h
   ${CMAKE_CURRENT_SOURCE_DIR}/makesdna/DNA_space_types.h
diff --git a/source/blender/asset_system/intern/asset_storage.hh b/source/blender/asset_system/intern/asset_storage.hh
index 89a7247b2e0..91de06703fe 100644
--- a/source/blender/asset_system/intern/asset_storage.hh
+++ b/source/blender/asset_system/intern/asset_storage.hh
@@ -29,7 +29,7 @@ class AssetStorage {
 
   StorageT external_assets_;
   /* Store local ID assets separately for efficient lookups.
-   * TODO(Julian): A [ID *, asset] or even [ID.session_uuid, asset] map would be preferable for
+   * TODO(Julian): A [ID *, asset] or even [ID.session_uid, asset] map would be preferable for
    * faster lookups. Not possible until each asset is only represented once in the storage. */
   StorageT local_id_assets_;
 
diff --git a/source/blender/blenkernel/BKE_action.h b/source/blender/blenkernel/BKE_action.h
index 86d48394274..fb8dfea95c0 100644
--- a/source/blender/blenkernel/BKE_action.h
+++ b/source/blender/blenkernel/BKE_action.h
@@ -260,7 +260,7 @@ void BKE_pose_copy_data(struct bPose **dst, const struct bPose *src, bool copy_c
  * \note use when copying bones in edit-mode (on returned value from #BKE_pose_channel_ensure)
  */
 void BKE_pose_channel_copy_data(struct bPoseChannel *pchan, const struct bPoseChannel *pchan_from);
-void BKE_pose_channel_session_uuid_generate(struct bPoseChannel *pchan);
+void BKE_pose_channel_session_uid_generate(struct bPoseChannel *pchan);
 /**
  * Return a pointer to the pose channel of the given name
  * from this pose.
@@ -316,7 +316,7 @@ struct bPoseChannel *BKE_pose_channel_ensure(struct bPose *pose, const char *nam
 struct bPoseChannel *BKE_pose_channel_get_mirrored(const struct bPose *pose,
                                                    const char *name) ATTR_WARN_UNUSED_RESULT;
 
-void BKE_pose_check_uuids_unique_and_report(const struct bPose *pose);
+void BKE_pose_check_uids_unique_and_report(const struct bPose *pose);
 
 #ifndef NDEBUG
 bool BKE_pose_channels_is_valid(const struct bPose *pose) ATTR_WARN_UNUSED_RESULT;
diff --git a/source/blender/blenkernel/BKE_compute_contexts.hh b/source/blender/blenkernel/BKE_compute_contexts.hh
index c019aa58ced..f724133e51f 100644
--- a/source/blender/blenkernel/BKE_compute_contexts.hh
+++ b/source/blender/blenkernel/BKE_compute_contexts.hh
@@ -22,7 +22,7 @@ class ModifierComputeContext : public ComputeContext {
   static constexpr const char *s_static_type = "MODIFIER";
 
   /**
-   * Use modifier name instead of something like `session_uuid` for now because:
+   * Use modifier name instead of something like `session_uid` for now because:
    * - It's more obvious that the name matches between the original and evaluated object.
    * - We might want that the context hash is consistent between sessions in the future.
    */
diff --git a/source/blender/blenkernel/BKE_global.h b/source/blender/blenkernel/BKE_global.h
index 17b5621f14d..21dfe283244 100644
--- a/source/blender/blenkernel/BKE_global.h
+++ b/source/blender/blenkernel/BKE_global.h
@@ -208,10 +208,10 @@ enum {
   G_DEBUG_DEPSGRAPH_TIME = (1 << 11),       /* depsgraph timing statistics and messages */
   G_DEBUG_DEPSGRAPH_NO_THREADS = (1 << 12), /* single threaded depsgraph */
   G_DEBUG_DEPSGRAPH_PRETTY = (1 << 13),     /* use pretty colors in depsgraph messages */
-  G_DEBUG_DEPSGRAPH_UUID = (1 << 14),       /* Verify validness of session-wide identifiers
+  G_DEBUG_DEPSGRAPH_UID = (1 << 14),        /* Verify validness of session-wide identifiers
                                              * assigned to ID datablocks */
   G_DEBUG_DEPSGRAPH = (G_DEBUG_DEPSGRAPH_BUILD | G_DEBUG_DEPSGRAPH_EVAL | G_DEBUG_DEPSGRAPH_TAG |
-                       G_DEBUG_DEPSGRAPH_TIME | G_DEBUG_DEPSGRAPH_UUID),
+                       G_DEBUG_DEPSGRAPH_TIME | G_DEBUG_DEPSGRAPH_UID),
   G_DEBUG_SIMDATA = (1 << 15),               /* sim debug data display */
   G_DEBUG_GPU = (1 << 16),                   /* gpu debug */
   G_DEBUG_IO = (1 << 17),                    /* IO Debugging (for Collada, ...). */
diff --git a/source/blender/blenkernel/BKE_idtype.hh b/source/blender/blenkernel/BKE_idtype.hh
index 79646edea57..6c34de86ade 100644
--- a/source/blender/blenkernel/BKE_idtype.hh
+++ b/source/blender/blenkernel/BKE_idtype.hh
@@ -48,8 +48,8 @@ enum {
 };
 
 struct IDCacheKey {
-  /* The session UUID of the ID owning the cached data. */
-  unsigned int id_session_uuid;
+  /* The session UID of the ID owning the cached data. */
+  unsigned int id_session_uid;
   /* Value uniquely identifying the cache within its ID.
    * Typically the offset of its member in the data-block struct, but can be anything. */
   size_t identifier;
diff --git a/source/blender/blenkernel/BKE_lib_id.hh b/source/blender/blenkernel/BKE_lib_id.hh
index 13f7e1fe74b..8625c40d3de 100644
--- a/source/blender/blenkernel/BKE_lib_id.hh
+++ b/source/blender/blenkernel/BKE_lib_id.hh
@@ -73,29 +73,29 @@ void BKE_libblock_init_empty(ID *id) ATTR_NONNULL(1);
  */
 void BKE_libblock_runtime_reset_remapping_status(ID *id) ATTR_NONNULL(1);
 
-/* *** ID's session_uuid management. *** */
+/* *** ID's session_uid management. *** */
 
 /**
- * When an ID's UUID is of that value, it is unset/invalid (e.g. for runtime IDs, etc.).
+ * When an ID's UID is of that value, it is unset/invalid (e.g. for runtime IDs, etc.).
  */
-#define MAIN_ID_SESSION_UUID_UNSET 0
+#define MAIN_ID_SESSION_UID_UNSET 0
 
 /**
- * Generate a session-wise UUID for the given \a id.
+ * Generate a session-wise UID for the given \a id.
  *
  * \note "session-wise" here means while editing a given .blend file. Once a new .blend file is
- * loaded or created, undo history is cleared/reset, and so is the UUID counter.
+ * loaded or created, undo history is cleared/reset, and so is the UID counter.
  */
-void BKE_lib_libblock_session_uuid_ensure(ID *id);
+void BKE_lib_libblock_session_uid_ensure(ID *id);
 /**
- * Re-generate a new session-wise UUID for the given \a id.
+ * Re-generate a new session-wise UID for the given \a id.
  *
  * \warning This has a few very specific use-cases, no other usage is expected currently:
  *   - To handle UI-related data-blocks that are kept across new file reading, when we do keep
  * existing UI.
  *   - For IDs that are made local without needing any copying.
  */
-void BKE_lib_libblock_session_uuid_renew(ID *id);
+void BKE_lib_libblock_session_uid_renew(ID *id);
 
 /**
  * Generic helper to create a new empty data-block of given type in given \a bmain database.
@@ -203,7 +203,7 @@ void BKE_libblock_ensure_unique_name(Main *bmain, ID *id) ATTR_NONNULL();
 
 ID *BKE_libblock_find_name(Main *bmain, short type, const char *name) ATTR_WARN_UNUSED_RESULT
     ATTR_NONNULL();
-ID *BKE_libblock_find_session_uuid(Main *bmain, short type, uint32_t session_uuid);
+ID *BKE_libblock_find_session_uid(Main *bmain, short type, uint32_t session_uid);
 /**
  * Duplicate (a.k.a. deep copy) common processing options.
  * See also eDupli_ID_Flags for options controlling what kind of IDs to duplicate.
diff --git a/source/blender/blenkernel/BKE_main.hh b/source/blender/blenkernel/BKE_main.hh
index 174eb7dec05..f7a25b9e7c5 100644
--- a/source/blender/blenkernel/BKE_main.hh
+++ b/source/blender/blenkernel/BKE_main.hh
@@ -55,8 +55,8 @@ struct MainIDRelationsEntryItem {
     /* For `to_ids` list, an ID used by the hashed ID. */
     struct ID **to;
   } id_pointer;
-  /* Session uuid of the `id_pointer`. */
-  uint session_uuid;
+  /* Session uid of the `id_pointer`. */
+  uint session_uid;
 
   int usage_flag; /* Using IDWALK_ enums, defined in BKE_lib_query.hh */
 };
@@ -67,8 +67,8 @@ struct MainIDRelationsEntry {
   /* Linked list of IDs used by that ID. */
   struct MainIDRelationsEntryItem *to_ids;
 
-  /* Session uuid of the ID matching that entry. */
-  uint session_uuid;
+  /* Session uid of the ID matching that entry. */
+  uint session_uid;
 
   /* Runtime tags, users should ensure those are reset after usage. */
   uint tags;
@@ -105,7 +105,7 @@ struct MainIDRelations {
   /* Mapping from an ID pointer to all of its parents (IDs using it) and children (IDs it uses).
    * Values are `MainIDRelationsEntry` pointers. */
   struct GHash *relations_from_pointers;
-  /* NOTE: we could add more mappings when needed (e.g. from session uuid?). */
+  /* NOTE: we could add more mappings when needed (e.g. from session uid?). */
 
   short flag;
 
diff --git a/source/blender/blenkernel/BKE_main_idmap.hh b/source/blender/blenkernel/BKE_main_idmap.hh
index 92d4a167efb..91146da8b14 100644
--- a/source/blender/blenkernel/BKE_main_idmap.hh
+++ b/source/blender/blenkernel/BKE_main_idmap.hh
@@ -25,7 +25,7 @@ struct Main;
 
 enum {
   MAIN_IDMAP_TYPE_NAME = 1 << 0,
-  MAIN_IDMAP_TYPE_UUID = 1 << 1,
+  MAIN_IDMAP_TYPE_UID = 1 << 1,
 };
 
 /**
@@ -57,5 +57,5 @@ ID *BKE_main_idmap_lookup_name(IDNameLib_Map *id_map,
 ID *BKE_main_idmap_lookup_id(IDNameLib_Map *id_map, const ID *id) ATTR_WARN_UNUSED_RESULT
     ATTR_NONNULL(1, 2);
 
-ID *BKE_main_idmap_lookup_uuid(IDNameLib_Map *id_map, uint session_uuid) ATTR_WARN_UNUSED_RESULT
+ID *BKE_main_idmap_lookup_uid(IDNameLib_Map *id_map, uint session_uid) ATTR_WARN_UNUSED_RESULT
     ATTR_NONNULL(1);
diff --git a/source/blender/blenkernel/BKE_modifier.hh b/source/blender/blenkernel/BKE_modifier.hh
index 6f22690218d..e4379f5f4df 100644
--- a/source/blender/blenkernel/BKE_modifier.hh
+++ b/source/blender/blenkernel/BKE_modifier.hh
@@ -421,8 +421,8 @@ void BKE_modifier_free(ModifierData *md);
  */
 void BKE_modifier_remove_from_list(Object *ob, ModifierData *md);
 
-/* Generate new UUID for the given modifier. */
-void BKE_modifier_session_uuid_generate(ModifierData *md);
+/* Generate new UID for the given modifier. */
+void BKE_modifier_session_uid_generate(ModifierData *md);
 
 void BKE_modifier_unique_name(ListBase *modifiers, ModifierData *md);
 
@@ -472,7 +472,7 @@ void BKE_modifiers_foreach_tex_link(Object *ob, TexWalkFunc walk, void *user_dat
 
 ModifierData *BKE_modifiers_findby_type(const Object *ob, ModifierType type);
 ModifierData *BKE_modifiers_findby_name(const Object *ob, const char *name);
-ModifierData *BKE_modifiers_findby_session_uuid(const Object *ob, const SessionUUID *session_uuid);
+ModifierData *BKE_modifiers_findby_session_uid(const Object *ob, const SessionUID *session_uid);
 void BKE_modifiers_clear_errors(Object *ob);
 /**
  * used for buttons, to find out if the 'draw deformed in edit-mode option is there.
@@ -584,7 +584,7 @@ void BKE_modifier_deform_vertsEM(ModifierData *md,
  */
 Mesh *BKE_modifier_get_evaluated_mesh_from_evaluated_object(Object *ob_eval);
 
-void BKE_modifier_check_uuids_unique_and_report(const Object *object);
+void BKE_modifier_check_uids_unique_and_report(const Object *object);
 
 void BKE_modifier_blend_write(BlendWriter *writer, const ID *id_owner, ListBase *modbase);
 void BKE_modifier_blend_read_data(BlendDataReader *reader, ListBase *lb, Object *ob);
diff --git a/source/blender/blenkernel/BKE_object.hh b/source/blender/blenkernel/BKE_object.hh
index 493bf63b354..48f4056556c 100644
--- a/source/blender/blenkernel/BKE_object.hh
+++ b/source/blender/blenkernel/BKE_object.hh
@@ -685,7 +685,7 @@ Curve *BKE_object_to_curve(Object *object, Depsgraph *depsgraph, bool apply_modi
 
 void BKE_object_to_curve_clear(Object *object);
 
-void BKE_object_check_uuids_unique_and_report(const Object *object);
+void BKE_object_check_uids_unique_and_report(const Object *object);
 
 /**
  * Return the last subsurf modifier of an object, this does not check whether modifiers on top of
diff --git a/source/blender/blenkernel/intern/action.cc b/source/blender/blenkernel/intern/action.cc
index 8098d4d260e..d16df153cac 100644
--- a/source/blender/blenkernel/intern/action.cc
+++ b/source/blender/blenkernel/intern/action.cc
@@ -28,7 +28,7 @@
 #include "BLI_math_matrix.h"
 #include "BLI_math_rotation.h"
 #include "BLI_math_vector.h"
-#include "BLI_session_uuid.h"
+#include "BLI_session_uid.h"
 #include "BLI_string_utils.hh"
 #include "BLI_utildefines.h"
 
@@ -593,9 +593,9 @@ void action_groups_clear_tempflags(bAction *act)
 
 /* *************** Pose channels *************** */
 
-void BKE_pose_channel_session_uuid_generate(bPoseChannel *pchan)
+void BKE_pose_channel_session_uid_generate(bPoseChannel *pchan)
 {
-  pchan->runtime.session_uuid = BLI_session_uuid_generate();
+  pchan->runtime.session_uid = BLI_session_uid_generate();
 }
 
 bPoseChannel *BKE_pose_channel_find_name(const bPose *pose, const char *name)
@@ -629,7 +629,7 @@ bPoseChannel *BKE_pose_channel_ensure(bPose *pose, const char *name)
   /* If not, create it and add it */
   chan = static_cast<bPoseChannel *>(MEM_callocN(sizeof(bPoseChannel), "verifyPoseChannel"));
 
-  BKE_pose_channel_session_uuid_generate(chan);
+  BKE_pose_channel_session_uid_generate(chan);
 
   STRNCPY(chan->name, name);
 
@@ -793,7 +793,7 @@ void BKE_pose_copy_data_ex(bPose **dst,
     }
 
     if ((flag & LIB_ID_CREATE_NO_MAIN) == 0) {
-      BKE_pose_channel_session_uuid_generate(pchan);
+      BKE_pose_channel_session_uid_generate(pchan);
     }
 
     /* warning, O(n2) here, if done without the hash, but these are rarely used features. */
@@ -1033,9 +1033,9 @@ void BKE_pose_channel_runtime_reset(bPoseChannel_Runtime *runtime)
 
 void BKE_pose_channel_runtime_reset_on_copy(bPoseChannel_Runtime *runtime)
 {
-  const SessionUUID uuid = runtime->session_uuid;
+  const SessionUID uid = runtime->session_uid;
   memset(runtime, 0, sizeof(*runtime));
-  runtime->session_uuid = uuid;
+  runtime->session_uid = uid;
 }
 
 void BKE_pose_channel_runtime_free(bPoseChannel_Runtime *runtime)
@@ -1778,31 +1778,31 @@ void what_does_obaction(Object *ob,
   }
 }
 
-void BKE_pose_check_uuids_unique_and_report(const bPose *pose)
+void BKE_pose_check_uids_unique_and_report(const bPose *pose)
 {
   if (pose == nullptr) {
     return;
   }
 
-  GSet *used_uuids = BLI_gset_new(
-      BLI_session_uuid_ghash_hash, BLI_session_uuid_ghash_compare, "sequencer used uuids");
+  GSet *used_uids = BLI_gset_new(
+      BLI_session_uid_ghash_hash, BLI_session_uid_ghash_compare, "sequencer used uids");
 
   LISTBASE_FOREACH (bPoseChannel *, pchan, &pose->chanbase) {
-    const SessionUUID *session_uuid = &pchan->runtime.session_uuid;
-    if (!BLI_session_uuid_is_generated(session_uuid)) {
-      printf("Pose channel %s does not have UUID generated.\n", pchan->name);
+    const SessionUID *session_uid = &pchan->runtime.session_uid;
+    if (!BLI_session_uid_is_generated(session_uid)) {
+      printf("Pose channel %s does not have UID generated.\n", pchan->name);
       continue;
     }
 
-    if (BLI_gset_lookup(used_uuids, session_uuid) != nullptr) {
-      printf("Pose channel %s has duplicate UUID generated.\n", pchan->name);
+    if (BLI_gset_lookup(used_uids, session_uid) != nullptr) {
+      printf("Pose channel %s has duplicate UID generated.\n", pchan->name);
       continue;
     }
 
-    BLI_gset_insert(used_uuids, (void *)session_uuid);
+    BLI_gset_insert(used_uids, (void *)session_uid);
   }
 
-  BLI_gset_free(used_uuids, nullptr);
+  BLI_gset_free(used_uids, nullptr);
 }
 
 void BKE_pose_blend_write(BlendWriter *writer, bPose *pose, bArmature *arm)
@@ -1868,7 +1868,7 @@ void BKE_pose_blend_read_data(BlendDataReader *reader, ID *id_owner, bPose *pose
 
   LISTBASE_FOREACH (bPoseChannel *, pchan, &pose->chanbase) {
     BKE_pose_channel_runtime_reset(&pchan->runtime);
-    BKE_pose_channel_session_uuid_generate(pchan);
+    BKE_pose_channel_session_uid_generate(pchan);
 
     pchan->bone = nullptr;
     BLO_read_data_address(reader, &pchan->parent);
diff --git a/source/blender/blenkernel/intern/blendfile.cc b/source/blender/blenkernel/intern/blendfile.cc
index 10de3a1df53..8bc9f97495b 100644
--- a/source/blender/blenkernel/intern/blendfile.cc
+++ b/source/blender/blenkernel/intern/blendfile.cc
@@ -373,8 +373,8 @@ static void swap_old_bmain_data_for_blendfile(ReuseOldBMainData *reuse_data, con
   }
 
   FOREACH_MAIN_LISTBASE_ID_BEGIN (new_lb, reused_id_iter) {
-    /* Necessary as all `session_uuid` are renewed on blendfile loading. */
-    BKE_lib_libblock_session_uuid_renew(reused_id_iter);
+    /* Necessary as all `session_uid` are renewed on blendfile loading. */
+    BKE_lib_libblock_session_uid_renew(reused_id_iter);
 
     /* Ensure that the reused ID is remapped to itself, since it is known to be in the `new_bmain`.
      */
diff --git a/source/blender/blenkernel/intern/idtype.cc b/source/blender/blenkernel/intern/idtype.cc
index 40618cb8e9c..dc900d9dd37 100644
--- a/source/blender/blenkernel/intern/idtype.cc
+++ b/source/blender/blenkernel/intern/idtype.cc
@@ -32,7 +32,7 @@
 uint BKE_idtype_cache_key_hash(const void *key_v)
 {
   const IDCacheKey *key = static_cast<const IDCacheKey *>(key_v);
-  size_t hash = BLI_ghashutil_uinthash(key->id_session_uuid);
+  size_t hash = BLI_ghashutil_uinthash(key->id_session_uid);
   hash = BLI_ghashutil_combine_hash(hash, BLI_ghashutil_uinthash(uint(key->identifier)));
   return uint(hash);
 }
@@ -41,7 +41,7 @@ bool BKE_idtype_cache_key_cmp(const void *key_a_v, const void *key_b_v)
 {
   const IDCacheKey *key_a = static_cast<const IDCacheKey *>(key_a_v);
   const IDCacheKey *key_b = static_cast<const IDCacheKey *>(key_b_v);
-  return (key_a->id_session_uuid != key_b->id_session_uuid) ||
+  return (key_a->id_session_uid != key_b->id_session_uid) ||
          (key_a->identifier != key_b->identifier);
 }
 
diff --git a/source/blender/blenkernel/intern/image.cc b/source/blender/blenkernel/intern/image.cc
index e8aa73d04ae..1dbb23f5718 100644
--- a/source/blender/blenkernel/intern/image.cc
+++ b/source/blender/blenkernel/intern/image.cc
@@ -235,7 +235,7 @@ static void image_foreach_cache(ID *id,
 {
   Image *image = (Image *)id;
   IDCacheKey key;
-  key.id_session_uuid = id->session_uuid;
+  key.id_session_uid = id->session_uid;
   key.identifier = offsetof(Image, cache);
   function_callback(id, &key, (void **)&image->cache, 0, user_data);
 
diff --git a/source/blender/blenkernel/intern/lib_id.cc b/source/blender/blenkernel/intern/lib_id.cc
index ffdd5f83771..25eb944fbef 100644
--- a/source/blender/blenkernel/intern/lib_id.cc
+++ b/source/blender/blenkernel/intern/lib_id.cc
@@ -206,9 +206,9 @@ void BKE_lib_id_clear_library_data(Main *bmain, ID *id, const int flags)
   }
 
   /* Conceptually, an ID made local is not the same as the linked one anymore. Reflect that by
-   * regenerating its session UUID. */
+   * regenerating its session UID. */
   if ((id->tag & LIB_TAG_TEMP_MAIN) == 0) {
-    BKE_lib_libblock_session_uuid_renew(id);
+    BKE_lib_libblock_session_uid_renew(id);
   }
 
   if (ID_IS_ASSET(id)) {
@@ -1021,7 +1021,7 @@ void BKE_libblock_management_main_add(Main *bmain, void *idv)
   bmain->is_memfile_undo_written = false;
   BKE_main_unlock(bmain);
 
-  BKE_lib_libblock_session_uuid_ensure(id);
+  BKE_lib_libblock_session_uid_ensure(id);
 }
 
 void BKE_libblock_management_main_remove(Main *bmain, void *idv)
@@ -1268,11 +1268,11 @@ void *BKE_libblock_alloc(Main *bmain, short type, const char *name, const int fl
       BLI_strncpy(id->name + 2, name, sizeof(id->name) - 2);
     }
 
-    /* We also need to ensure a valid `session_uuid` for some non-main data (like embedded IDs).
+    /* We also need to ensure a valid `session_uid` for some non-main data (like embedded IDs).
      * IDs not allocated however should not need those (this would e.g. avoid generating session
-     * uuids for depsgraph CoW IDs, if it was using this function). */
+     * uids for depsgraph CoW IDs, if it was using this function). */
     if ((flag & LIB_ID_CREATE_NO_ALLOCATE) == 0) {
-      BKE_lib_libblock_session_uuid_ensure(id);
+      BKE_lib_libblock_session_uid_ensure(id);
     }
   }
 
@@ -1301,26 +1301,26 @@ void BKE_libblock_runtime_reset_remapping_status(ID *id)
   id->runtime.remap.skipped_indirect = 0;
 }
 
-/* ********** ID session-wise UUID management. ********** */
-static uint global_session_uuid = 0;
+/* ********** ID session-wise UID management. ********** */
+static uint global_session_uid = 0;
 
-void BKE_lib_libblock_session_uuid_ensure(ID *id)
+void BKE_lib_libblock_session_uid_ensure(ID *id)
 {
-  if (id->session_uuid == MAIN_ID_SESSION_UUID_UNSET) {
+  if (id->session_uid == MAIN_ID_SESSION_UID_UNSET) {
     BLI_assert((id->tag & LIB_TAG_TEMP_MAIN) == 0); /* Caller must ensure this. */
-    id->session_uuid = atomic_add_and_fetch_uint32(&global_session_uuid, 1);
+    id->session_uid = atomic_add_and_fetch_uint32(&global_session_uid, 1);
     /* In case overflow happens, still assign a valid ID. This way opening files many times works
      * correctly. */
-    if (UNLIKELY(id->session_uuid == MAIN_ID_SESSION_UUID_UNSET)) {
-      id->session_uuid = atomic_add_and_fetch_uint32(&global_session_uuid, 1);
+    if (UNLIKELY(id->session_uid == MAIN_ID_SESSION_UID_UNSET)) {
+      id->session_uid = atomic_add_and_fetch_uint32(&global_session_uid, 1);
     }
   }
 }
 
-void BKE_lib_libblock_session_uuid_renew(ID *id)
+void BKE_lib_libblock_session_uid_renew(ID *id)
 {
-  id->session_uuid = MAIN_ID_SESSION_UUID_UNSET;
-  BKE_lib_libblock_session_uuid_ensure(id);
+  id->session_uid = MAIN_ID_SESSION_UID_UNSET;
+  BKE_lib_libblock_session_uid_ensure(id);
 }
 
 void *BKE_id_new(Main *bmain, const short type, const char *name)
@@ -1477,12 +1477,12 @@ ID *BKE_libblock_find_name(Main *bmain, const short type, const char *name)
   return static_cast<ID *>(BLI_findstring(lb, name, offsetof(ID, name) + 2));
 }
 
-ID *BKE_libblock_find_session_uuid(Main *bmain, const short type, const uint32_t session_uuid)
+ID *BKE_libblock_find_session_uid(Main *bmain, const short type, const uint32_t session_uid)
 {
   ListBase *lb = which_libbase(bmain, type);
   BLI_assert(lb != nullptr);
   LISTBASE_FOREACH (ID *, id, lb) {
-    if (id->session_uuid == session_uuid) {
+    if (id->session_uid == session_uid) {
       return id;
     }
   }
diff --git a/source/blender/blenkernel/intern/main.cc b/source/blender/blenkernel/intern/main.cc
index fb4a7574885..ae4d61fe5bb 100644
--- a/source/blender/blenkernel/intern/main.cc
+++ b/source/blender/blenkernel/intern/main.cc
@@ -470,17 +470,17 @@ static int main_relations_create_idlink_cb(LibraryIDLinkCallbackData *cb_data)
               bmain_relations->relations_from_pointers, self_id, (void ***)&entry_p))
       {
         *entry_p = static_cast<MainIDRelationsEntry *>(MEM_callocN(sizeof(**entry_p), __func__));
-        (*entry_p)->session_uuid = self_id->session_uuid;
+        (*entry_p)->session_uid = self_id->session_uid;
       }
       else {
-        BLI_assert((*entry_p)->session_uuid == self_id->session_uuid);
+        BLI_assert((*entry_p)->session_uid == self_id->session_uid);
       }
       MainIDRelationsEntryItem *to_id_entry = static_cast<MainIDRelationsEntryItem *>(
           BLI_mempool_alloc(bmain_relations->entry_items_pool));
       to_id_entry->next = (*entry_p)->to_ids;
       to_id_entry->id_pointer.to = id_pointer;
-      to_id_entry->session_uuid = (*id_pointer != nullptr) ? (*id_pointer)->session_uuid :
-                                                             MAIN_ID_SESSION_UUID_UNSET;
+      to_id_entry->session_uid = (*id_pointer != nullptr) ? (*id_pointer)->session_uid :
+                                                            MAIN_ID_SESSION_UID_UNSET;
       to_id_entry->usage_flag = cb_flag;
       (*entry_p)->to_ids = to_id_entry;
     }
@@ -491,16 +491,16 @@ static int main_relations_create_idlink_cb(LibraryIDLinkCallbackData *cb_data)
               bmain_relations->relations_from_pointers, *id_pointer, (void ***)&entry_p))
       {
         *entry_p = static_cast<MainIDRelationsEntry *>(MEM_callocN(sizeof(**entry_p), __func__));
-        (*entry_p)->session_uuid = (*id_pointer)->session_uuid;
+        (*entry_p)->session_uid = (*id_pointer)->session_uid;
       }
       else {
-        BLI_assert((*entry_p)->session_uuid == (*id_pointer)->session_uuid);
+        BLI_assert((*entry_p)->session_uid == (*id_pointer)->session_uid);
       }
       MainIDRelationsEntryItem *from_id_entry = static_cast<MainIDRelationsEntryItem *>(
           BLI_mempool_alloc(bmain_relations->entry_items_pool));
       from_id_entry->next = (*entry_p)->from_ids;
       from_id_entry->id_pointer.from = self_id;
-      from_id_entry->session_uuid = self_id->session_uuid;
+      from_id_entry->session_uid = self_id->session_uid;
       from_id_entry->usage_flag = cb_flag;
       (*entry_p)->from_ids = from_id_entry;
     }
@@ -533,10 +533,10 @@ void BKE_main_relations_create(Main *bmain, const short flag)
     MainIDRelationsEntry **entry_p;
     if (!BLI_ghash_ensure_p(bmain->relations->relations_from_pointers, id, (void ***)&entry_p)) {
       *entry_p = static_cast<MainIDRelationsEntry *>(MEM_callocN(sizeof(**entry_p), __func__));
-      (*entry_p)->session_uuid = id->session_uuid;
+      (*entry_p)->session_uid = id->session_uid;
     }
     else {
-      BLI_assert((*entry_p)->session_uuid == id->session_uuid);
+      BLI_assert((*entry_p)->session_uid == id->session_uid);
     }
 
     BKE_library_foreach_ID_link(
diff --git a/source/blender/blenkernel/intern/main_idmap.cc b/source/blender/blenkernel/intern/main_idmap.cc
index fe76f4c0597..8fd262ed4c7 100644
--- a/source/blender/blenkernel/intern/main_idmap.cc
+++ b/source/blender/blenkernel/intern/main_idmap.cc
@@ -54,7 +54,7 @@ struct IDNameLib_TypeMap {
  */
 struct IDNameLib_Map {
   IDNameLib_TypeMap type_maps[INDEX_ID_MAX];
-  GHash *uuid_map;
+  GHash *uid_map;
   Main *bmain;
   GSet *valid_id_pointers;
   int idmap_types;
@@ -94,14 +94,14 @@ IDNameLib_Map *BKE_main_idmap_create(Main *bmain,
   BLI_assert(index == INDEX_ID_MAX);
   id_map->type_maps_keys_pool = nullptr;
 
-  if (idmap_types & MAIN_IDMAP_TYPE_UUID) {
+  if (idmap_types & MAIN_IDMAP_TYPE_UID) {
     ID *id;
-    id_map->uuid_map = BLI_ghash_int_new(__func__);
+    id_map->uid_map = BLI_ghash_int_new(__func__);
     FOREACH_MAIN_ID_BEGIN (bmain, id) {
-      BLI_assert(id->session_uuid != MAIN_ID_SESSION_UUID_UNSET);
+      BLI_assert(id->session_uid != MAIN_ID_SESSION_UID_UNSET);
       void **id_ptr_v;
       const bool existing_key = BLI_ghash_ensure_p(
-          id_map->uuid_map, POINTER_FROM_UINT(id->session_uuid), &id_ptr_v);
+          id_map->uid_map, POINTER_FROM_UINT(id->session_uid), &id_ptr_v);
       BLI_assert(existing_key == false);
       UNUSED_VARS_NDEBUG(existing_key);
 
@@ -110,7 +110,7 @@ IDNameLib_Map *BKE_main_idmap_create(Main *bmain,
     FOREACH_MAIN_ID_END;
   }
   else {
-    id_map->uuid_map = nullptr;
+    id_map->uid_map = nullptr;
   }
 
   if (create_valid_ids_set) {
@@ -144,12 +144,12 @@ void BKE_main_idmap_insert_id(IDNameLib_Map *id_map, ID *id)
     }
   }
 
-  if (id_map->idmap_types & MAIN_IDMAP_TYPE_UUID) {
-    BLI_assert(id_map->uuid_map != nullptr);
-    BLI_assert(id->session_uuid != MAIN_ID_SESSION_UUID_UNSET);
+  if (id_map->idmap_types & MAIN_IDMAP_TYPE_UID) {
+    BLI_assert(id_map->uid_map != nullptr);
+    BLI_assert(id->session_uid != MAIN_ID_SESSION_UID_UNSET);
     void **id_ptr_v;
     const bool existing_key = BLI_ghash_ensure_p(
-        id_map->uuid_map, POINTER_FROM_UINT(id->session_uuid), &id_ptr_v);
+        id_map->uid_map, POINTER_FROM_UINT(id->session_uid), &id_ptr_v);
     BLI_assert(existing_key == false);
     UNUSED_VARS_NDEBUG(existing_key);
 
@@ -174,11 +174,11 @@ void BKE_main_idmap_remove_id(IDNameLib_Map *id_map, ID *id)
     }
   }
 
-  if (id_map->idmap_types & MAIN_IDMAP_TYPE_UUID) {
-    BLI_assert(id_map->uuid_map != nullptr);
-    BLI_assert(id->session_uuid != MAIN_ID_SESSION_UUID_UNSET);
+  if (id_map->idmap_types & MAIN_IDMAP_TYPE_UID) {
+    BLI_assert(id_map->uid_map != nullptr);
+    BLI_assert(id->session_uid != MAIN_ID_SESSION_UID_UNSET);
 
-    BLI_ghash_remove(id_map->uuid_map, POINTER_FROM_UINT(id->session_uuid), nullptr, nullptr);
+    BLI_ghash_remove(id_map->uid_map, POINTER_FROM_UINT(id->session_uid), nullptr, nullptr);
   }
 }
 
@@ -251,10 +251,10 @@ ID *BKE_main_idmap_lookup_id(IDNameLib_Map *id_map, const ID *id)
   return nullptr;
 }
 
-ID *BKE_main_idmap_lookup_uuid(IDNameLib_Map *id_map, const uint session_uuid)
+ID *BKE_main_idmap_lookup_uid(IDNameLib_Map *id_map, const uint session_uid)
 {
-  if (id_map->idmap_types & MAIN_IDMAP_TYPE_UUID) {
-    return static_cast<ID *>(BLI_ghash_lookup(id_map->uuid_map, POINTER_FROM_UINT(session_uuid)));
+  if (id_map->idmap_types & MAIN_IDMAP_TYPE_UID) {
+    return static_cast<ID *>(BLI_ghash_lookup(id_map->uid_map, POINTER_FROM_UINT(session_uid)));
   }
   return nullptr;
 }
@@ -274,8 +274,8 @@ void BKE_main_idmap_destroy(IDNameLib_Map *id_map)
       id_map->type_maps_keys_pool = nullptr;
     }
   }
-  if (id_map->idmap_types & MAIN_IDMAP_TYPE_UUID) {
-    BLI_ghash_free(id_map->uuid_map, nullptr, nullptr);
+  if (id_map->idmap_types & MAIN_IDMAP_TYPE_UID) {
+    BLI_ghash_free(id_map->uid_map, nullptr, nullptr);
   }
 
   BLI_assert(id_map->type_maps_keys_pool == nullptr);
diff --git a/source/blender/blenkernel/intern/modifier.cc b/source/blender/blenkernel/intern/modifier.cc
index 39380be89a6..40150b4d53b 100644
--- a/source/blender/blenkernel/intern/modifier.cc
+++ b/source/blender/blenkernel/intern/modifier.cc
@@ -36,7 +36,7 @@
 #include "BLI_linklist.h"
 #include "BLI_listbase.h"
 #include "BLI_path_util.h"
-#include "BLI_session_uuid.h"
+#include "BLI_session_uid.h"
 #include "BLI_string.h"
 #include "BLI_string_utf8.h"
 #include "BLI_string_utils.hh"
@@ -162,7 +162,7 @@ ModifierData *BKE_modifier_new(int type)
 {
   ModifierData *md = modifier_allocate_and_init(ModifierType(type));
 
-  BKE_modifier_session_uuid_generate(md);
+  BKE_modifier_session_uid_generate(md);
 
   return md;
 }
@@ -220,9 +220,9 @@ void BKE_modifier_remove_from_list(Object *ob, ModifierData *md)
   BLI_remlink(&ob->modifiers, md);
 }
 
-void BKE_modifier_session_uuid_generate(ModifierData *md)
+void BKE_modifier_session_uid_generate(ModifierData *md)
 {
-  md->session_uuid = BLI_session_uuid_generate();
+  md->session_uid = BLI_session_uid_generate();
 }
 
 void BKE_modifier_unique_name(ListBase *modifiers, ModifierData *md)
@@ -266,10 +266,10 @@ ModifierData *BKE_modifiers_findby_name(const Object *ob, const char *name)
       BLI_findstring(&(ob->modifiers), name, offsetof(ModifierData, name)));
 }
 
-ModifierData *BKE_modifiers_findby_session_uuid(const Object *ob, const SessionUUID *session_uuid)
+ModifierData *BKE_modifiers_findby_session_uid(const Object *ob, const SessionUID *session_uid)
 {
   LISTBASE_FOREACH (ModifierData *, md, &ob->modifiers) {
-    if (BLI_session_uuid_is_equal(&md->session_uuid, session_uuid)) {
+    if (BLI_session_uid_is_equal(&md->session_uid, session_uid)) {
       return md;
     }
   }
@@ -370,14 +370,14 @@ void BKE_modifier_copydata_ex(const ModifierData *md, ModifierData *target, cons
   }
 
   if (flag & LIB_ID_CREATE_NO_MAIN) {
-    /* Make sure UUID is the same between the source and the target.
-     * This is needed in the cases when UUID is to be preserved and when there is no copy_data
+    /* Make sure UID is the same between the source and the target.
+     * This is needed in the cases when UID is to be preserved and when there is no copy_data
      * callback, or the copy_data does not do full byte copy of the modifier data. */
-    target->session_uuid = md->session_uuid;
+    target->session_uid = md->session_uid;
   }
   else {
-    /* In the case copy_data made full byte copy force UUID to be re-generated. */
-    BKE_modifier_session_uuid_generate(target);
+    /* In the case copy_data made full byte copy force UID to be re-generated. */
+    BKE_modifier_session_uid_generate(target);
   }
 }
 
@@ -985,7 +985,7 @@ Mesh *BKE_modifier_get_evaluated_mesh_from_evaluated_object(Object *ob_eval)
 ModifierData *BKE_modifier_get_original(const Object *object, ModifierData *md)
 {
   const Object *object_orig = DEG_get_original_object((Object *)object);
-  return BKE_modifiers_findby_session_uuid(object_orig, &md->session_uuid);
+  return BKE_modifiers_findby_session_uid(object_orig, &md->session_uid);
 }
 
 ModifierData *BKE_modifier_get_evaluated(Depsgraph *depsgraph, Object *object, ModifierData *md)
@@ -994,30 +994,30 @@ ModifierData *BKE_modifier_get_evaluated(Depsgraph *depsgraph, Object *object, M
   if (object_eval == object) {
     return md;
   }
-  return BKE_modifiers_findby_session_uuid(object_eval, &md->session_uuid);
+  return BKE_modifiers_findby_session_uid(object_eval, &md->session_uid);
 }
 
-void BKE_modifier_check_uuids_unique_and_report(const Object *object)
+void BKE_modifier_check_uids_unique_and_report(const Object *object)
 {
-  GSet *used_uuids = BLI_gset_new(
-      BLI_session_uuid_ghash_hash, BLI_session_uuid_ghash_compare, "modifier used uuids");
+  GSet *used_uids = BLI_gset_new(
+      BLI_session_uid_ghash_hash, BLI_session_uid_ghash_compare, "modifier used uids");
 
   LISTBASE_FOREACH (ModifierData *, md, &object->modifiers) {
-    const SessionUUID *session_uuid = &md->session_uuid;
-    if (!BLI_session_uuid_is_generated(session_uuid)) {
-      printf("Modifier %s -> %s does not have UUID generated.\n", object->id.name + 2, md->name);
+    const SessionUID *session_uid = &md->session_uid;
+    if (!BLI_session_uid_is_generated(session_uid)) {
+      printf("Modifier %s -> %s does not have UID generated.\n", object->id.name + 2, md->name);
       continue;
     }
 
-    if (BLI_gset_lookup(used_uuids, session_uuid) != nullptr) {
-      printf("Modifier %s -> %s has duplicate UUID generated.\n", object->id.name + 2, md->name);
+    if (BLI_gset_lookup(used_uids, session_uid) != nullptr) {
+      printf("Modifier %s -> %s has duplicate UID generated.\n", object->id.name + 2, md->name);
       continue;
     }
 
-    BLI_gset_insert(used_uuids, (void *)session_uuid);
+    BLI_gset_insert(used_uids, (void *)session_uid);
   }
 
-  BLI_gset_free(used_uuids, nullptr);
+  BLI_gset_free(used_uids, nullptr);
 }
 
 void BKE_modifier_blend_write(BlendWriter *writer, const ID *id_owner, ListBase *modbase)
@@ -1245,7 +1245,7 @@ void BKE_modifier_blend_read_data(BlendDataReader *reader, ListBase *lb, Object
   BLO_read_list(reader, lb);
 
   LISTBASE_FOREACH (ModifierData *, md, lb) {
-    BKE_modifier_session_uuid_generate(md);
+    BKE_modifier_session_uid_generate(md);
 
     md->error = nullptr;
     md->runtime = nullptr;
diff --git a/source/blender/blenkernel/intern/movieclip.cc b/source/blender/blenkernel/intern/movieclip.cc
index 92702409758..b1e86e81b78 100644
--- a/source/blender/blenkernel/intern/movieclip.cc
+++ b/source/blender/blenkernel/intern/movieclip.cc
@@ -141,7 +141,7 @@ static void movie_clip_foreach_cache(ID *id,
 {
   MovieClip *movie_clip = (MovieClip *)id;
   IDCacheKey key{};
-  key.id_session_uuid = id->session_uuid;
+  key.id_session_uid = id->session_uid;
   key.identifier = offsetof(MovieClip, cache);
   function_callback(id, &key, (void **)&movie_clip->cache, 0, user_data);
 
diff --git a/source/blender/blenkernel/intern/node.cc b/source/blender/blenkernel/intern/node.cc
index fab16d71d72..ded2767c7f3 100644
--- a/source/blender/blenkernel/intern/node.cc
+++ b/source/blender/blenkernel/intern/node.cc
@@ -398,7 +398,7 @@ static void node_foreach_cache(ID *id,
 {
   bNodeTree *nodetree = reinterpret_cast<bNodeTree *>(id);
   IDCacheKey key = {0};
-  key.id_session_uuid = id->session_uuid;
+  key.id_session_uid = id->session_uid;
   key.identifier = offsetof(bNodeTree, previews);
 
   /* TODO: see also `direct_link_nodetree()` in `readfile.cc`. */
diff --git a/source/blender/blenkernel/intern/object.cc b/source/blender/blenkernel/intern/object.cc
index 48d9177780e..dfebe40c36a 100644
--- a/source/blender/blenkernel/intern/object.cc
+++ b/source/blender/blenkernel/intern/object.cc
@@ -5336,10 +5336,10 @@ void BKE_object_to_curve_clear(Object *object)
   object->runtime->object_as_temp_curve = nullptr;
 }
 
-void BKE_object_check_uuids_unique_and_report(const Object *object)
+void BKE_object_check_uids_unique_and_report(const Object *object)
 {
-  BKE_pose_check_uuids_unique_and_report(object->pose);
-  BKE_modifier_check_uuids_unique_and_report(object);
+  BKE_pose_check_uids_unique_and_report(object->pose);
+  BKE_modifier_check_uids_unique_and_report(object);
 }
 
 SubsurfModifierData *BKE_object_get_last_subsurf_modifier(const Object *ob)
diff --git a/source/blender/blenkernel/intern/object_dupli.cc b/source/blender/blenkernel/intern/object_dupli.cc
index c781d216021..3338f27847c 100644
--- a/source/blender/blenkernel/intern/object_dupli.cc
+++ b/source/blender/blenkernel/intern/object_dupli.cc
@@ -417,7 +417,7 @@ static void make_child_duplis(const DupliContext *ctx,
   }
   else {
     /* FIXME: using a mere counter to generate a 'persistent' dupli id is very weak. One possible
-     * better solution could be to use `session_uuid` of ID's instead? */
+     * better solution could be to use `session_uid` of ID's instead? */
     int persistent_dupli_id = 0;
     DEGObjectIterSettings deg_iter_settings{};
     deg_iter_settings.depsgraph = ctx->depsgraph;
diff --git a/source/blender/blenkernel/intern/scene.cc b/source/blender/blenkernel/intern/scene.cc
index 82034cc2c98..8d0f3898802 100644
--- a/source/blender/blenkernel/intern/scene.cc
+++ b/source/blender/blenkernel/intern/scene.cc
@@ -498,8 +498,8 @@ static void scene_foreach_toolsettings_id_pointer_process(
       ID *id_old = *id_old_p;
       /* Old data has not been remapped to new values of the pointers, if we want to keep the old
        * pointer here we need its new address. */
-      ID *id_old_new = id_old != nullptr ? BLO_read_get_new_id_address_from_session_uuid(
-                                               reader, id_old->session_uuid) :
+      ID *id_old_new = id_old != nullptr ? BLO_read_get_new_id_address_from_session_uid(
+                                               reader, id_old->session_uid) :
                                            nullptr;
       /* The new address may be the same as the old one, in which case there is nothing to do. */
       if (id_old_new == id_old) {
@@ -521,10 +521,10 @@ static void scene_foreach_toolsettings_id_pointer_process(
        * There is a nasty twist here though: a previous call to 'undo_preserve' on the Scene ID may
        * have modified it, even though the undo step detected it as unmodified. In such case, the
        * value of `*id_p` may end up also pointing to an invalid (no more in newly read Main) ID,
-       * so it also needs to be checked from its `session_uuid`. */
+       * so it also needs to be checked from its `session_uid`. */
       ID *id = *id_p;
       ID *id_new = id != nullptr ?
-                       BLO_read_get_new_id_address_from_session_uuid(reader, id->session_uuid) :
+                       BLO_read_get_new_id_address_from_session_uid(reader, id->session_uid) :
                        nullptr;
       if (id_new != id) {
         *id_p = id_new;
@@ -964,7 +964,7 @@ static void scene_foreach_cache(ID *id,
 {
   Scene *scene = (Scene *)id;
   IDCacheKey key{};
-  key.id_session_uuid = id->session_uuid;
+  key.id_session_uid = id->session_uid;
   key.identifier = offsetof(Scene, eevee.light_cache_data);
 
   function_callback(id,
diff --git a/source/blender/blenkernel/intern/sound.cc b/source/blender/blenkernel/intern/sound.cc
index 82c2a0075f4..cfd19a02bc4 100644
--- a/source/blender/blenkernel/intern/sound.cc
+++ b/source/blender/blenkernel/intern/sound.cc
@@ -121,7 +121,7 @@ static void sound_foreach_cache(ID *id,
 {
   bSound *sound = (bSound *)id;
   IDCacheKey key{};
-  key.id_session_uuid = id->session_uuid;
+  key.id_session_uid = id->session_uid;
   key.identifier = offsetof(bSound, waveform);
 
   function_callback(id, &key, &sound->waveform, 0, user_data);
diff --git a/source/blender/blenkernel/intern/volume.cc b/source/blender/blenkernel/intern/volume.cc
index 58c1b5ea486..6aff96326aa 100644
--- a/source/blender/blenkernel/intern/volume.cc
+++ b/source/blender/blenkernel/intern/volume.cc
@@ -202,7 +202,7 @@ static void volume_foreach_cache(ID *id,
 {
   Volume *volume = (Volume *)id;
   IDCacheKey key = {
-      /*id_session_uuid*/ id->session_uuid,
+      /*id_session_uid*/ id->session_uid,
       /*identifier*/ 1,
   };
 
diff --git a/source/blender/blenlib/BLI_session_uid.h b/source/blender/blenlib/BLI_session_uid.h
new file mode 100644
index 00000000000..4683046a5d3
--- /dev/null
+++ b/source/blender/blenlib/BLI_session_uid.h
@@ -0,0 +1,64 @@
+/* SPDX-FileCopyrightText: 2023 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+#pragma once
+
+/** \file
+ * \ingroup bli
+ *
+ * Functions for generating and handling "Session UIDs".
+ *
+ * Note that these are not true universally-unique identifiers, but only unique during the current
+ * Blender session.
+ *
+ * For true UUIDs, see `BLI_uuid.h`.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "DNA_session_uid_types.h"
+
+/** Generate new UID which is unique throughout the Blender session. */
+SessionUID BLI_session_uid_generate(void);
+
+/** Check whether the UID is properly generated. */
+bool BLI_session_uid_is_generated(const SessionUID *uid);
+
+/** Check whether two UIDs are identical. */
+bool BLI_session_uid_is_equal(const SessionUID *lhs, const SessionUID *rhs);
+
+uint64_t BLI_session_uid_hash_uint64(const SessionUID *uid);
+
+/* Utility functions to make it possible to create GHash/GSet with UID as a key. */
+
+uint BLI_session_uid_ghash_hash(const void *uid_v);
+bool BLI_session_uid_ghash_compare(const void *lhs_v, const void *rhs_v);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifdef __cplusplus
+
+namespace blender {
+
+inline const bool operator==(const SessionUID &lhs, const SessionUID &rhs)
+{
+  return BLI_session_uid_is_equal(&lhs, &rhs);
+}
+
+template<typename T> struct DefaultHash;
+
+template<> struct DefaultHash<SessionUID> {
+  uint64_t operator()(const SessionUID &value) const
+  {
+    return BLI_session_uid_hash_uint64(&value);
+  }
+};
+
+}  // namespace blender
+
+#endif
diff --git a/source/blender/blenlib/BLI_session_uuid.h b/source/blender/blenlib/BLI_session_uuid.h
deleted file mode 100644
index 421d6c3acb9..00000000000
--- a/source/blender/blenlib/BLI_session_uuid.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/* SPDX-FileCopyrightText: 2023 Blender Authors
- *
- * SPDX-License-Identifier: GPL-2.0-or-later */
-
-#pragma once
-
-/** \file
- * \ingroup bli
- *
- * Functions for generating and handling "Session UUIDs".
- *
- * Note that these are not true universally-unique identifiers, but only unique during the current
- * Blender session.
- *
- * For true UUIDs, see `BLI_uuid.h`.
- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "DNA_session_uuid_types.h"
-
-/** Generate new UUID which is unique throughout the Blender session. */
-SessionUUID BLI_session_uuid_generate(void);
-
-/** Check whether the UUID is properly generated. */
-bool BLI_session_uuid_is_generated(const SessionUUID *uuid);
-
-/** Check whether two UUIDs are identical. */
-bool BLI_session_uuid_is_equal(const SessionUUID *lhs, const SessionUUID *rhs);
-
-uint64_t BLI_session_uuid_hash_uint64(const SessionUUID *uuid);
-
-/* Utility functions to make it possible to create GHash/GSet with UUID as a key. */
-
-uint BLI_session_uuid_ghash_hash(const void *uuid_v);
-bool BLI_session_uuid_ghash_compare(const void *lhs_v, const void *rhs_v);
-
-#ifdef __cplusplus
-}
-#endif
-
-#ifdef __cplusplus
-
-namespace blender {
-
-inline const bool operator==(const SessionUUID &lhs, const SessionUUID &rhs)
-{
-  return BLI_session_uuid_is_equal(&lhs, &rhs);
-}
-
-template<typename T> struct DefaultHash;
-
-template<> struct DefaultHash<SessionUUID> {
-  uint64_t operator()(const SessionUUID &value) const
-  {
-    return BLI_session_uuid_hash_uint64(&value);
-  }
-};
-
-}  // namespace blender
-
-#endif
diff --git a/source/blender/blenlib/BLI_uuid.h b/source/blender/blenlib/BLI_uuid.h
index 64a392bb281..91122776ae3 100644
--- a/source/blender/blenlib/BLI_uuid.h
+++ b/source/blender/blenlib/BLI_uuid.h
@@ -10,7 +10,7 @@
  * Functions for generating and handling UUID structs according to RFC4122.
  *
  * Note that these are true UUIDs, not to be confused with the "session uuid" defined in
- * `BLI_session_uuid.h`.
+ * `BLI_session_uid.h`.
  */
 #include "DNA_uuid_types.h"
 
diff --git a/source/blender/blenlib/CMakeLists.txt b/source/blender/blenlib/CMakeLists.txt
index 5a2a3a0865c..b01224442d0 100644
--- a/source/blender/blenlib/CMakeLists.txt
+++ b/source/blender/blenlib/CMakeLists.txt
@@ -132,7 +132,7 @@ set(SRC
   intern/scanfill.c
   intern/scanfill_utils.c
   intern/serialize.cc
-  intern/session_uuid.c
+  intern/session_uid.c
   intern/smaa_textures.c
   intern/sort.c
   intern/sort_utils.c
@@ -335,7 +335,7 @@ set(SRC
   BLI_resource_scope.hh
   BLI_scanfill.h
   BLI_serialize.hh
-  BLI_session_uuid.h
+  BLI_session_uid.h
   BLI_set.hh
   BLI_set_slots.hh
   BLI_shared_cache.hh
@@ -544,7 +544,7 @@ if(WITH_GTESTS)
     tests/BLI_pool_test.cc
     tests/BLI_ressource_strings.h
     tests/BLI_serialize_test.cc
-    tests/BLI_session_uuid_test.cc
+    tests/BLI_session_uid_test.cc
     tests/BLI_set_test.cc
     tests/BLI_span_test.cc
     tests/BLI_stack_cxx_test.cc
diff --git a/source/blender/blenlib/intern/session_uid.c b/source/blender/blenlib/intern/session_uid.c
new file mode 100644
index 00000000000..d13151e27e9
--- /dev/null
+++ b/source/blender/blenlib/intern/session_uid.c
@@ -0,0 +1,66 @@
+/* SPDX-FileCopyrightText: 2023 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+/** \file
+ * \ingroup bli
+ */
+
+#include "BLI_session_uid.h"
+
+#include "BLI_utildefines.h"
+
+#include "atomic_ops.h"
+
+/* Special value which indicates the UID has not been assigned yet. */
+#define BLI_session_uid_NONE 0
+
+static const SessionUID global_session_uid_none = {BLI_session_uid_NONE};
+
+/* Denotes last used UID.
+ * It might eventually overflow, and easiest is to add more bits to it. */
+static SessionUID global_session_uid = {BLI_session_uid_NONE};
+
+SessionUID BLI_session_uid_generate(void)
+{
+  SessionUID result;
+  result.uid_ = atomic_add_and_fetch_uint64(&global_session_uid.uid_, 1);
+  if (!BLI_session_uid_is_generated(&result)) {
+    /* Happens when the UID overflows.
+     *
+     * Just request the UID once again, hoping that there are not a lot of high-priority threads
+     * which will overflow the counter once again between the previous call and this one.
+     *
+     * NOTE: It is possible to have collisions after such overflow. */
+    result.uid_ = atomic_add_and_fetch_uint64(&global_session_uid.uid_, 1);
+  }
+  return result;
+}
+
+bool BLI_session_uid_is_generated(const SessionUID *uid)
+{
+  return !BLI_session_uid_is_equal(uid, &global_session_uid_none);
+}
+
+bool BLI_session_uid_is_equal(const SessionUID *lhs, const SessionUID *rhs)
+{
+  return lhs->uid_ == rhs->uid_;
+}
+
+uint64_t BLI_session_uid_hash_uint64(const SessionUID *uid)
+{
+  return uid->uid_;
+}
+
+uint BLI_session_uid_ghash_hash(const void *uid_v)
+{
+  const SessionUID *uid = (const SessionUID *)uid_v;
+  return uid->uid_ & 0xffffffff;
+}
+
+bool BLI_session_uid_ghash_compare(const void *lhs_v, const void *rhs_v)
+{
+  const SessionUID *lhs = (const SessionUID *)lhs_v;
+  const SessionUID *rhs = (const SessionUID *)rhs_v;
+  return !BLI_session_uid_is_equal(lhs, rhs);
+}
diff --git a/source/blender/blenlib/intern/session_uuid.c b/source/blender/blenlib/intern/session_uuid.c
deleted file mode 100644
index b8d4e308d79..00000000000
--- a/source/blender/blenlib/intern/session_uuid.c
+++ /dev/null
@@ -1,66 +0,0 @@
-/* SPDX-FileCopyrightText: 2023 Blender Authors
- *
- * SPDX-License-Identifier: GPL-2.0-or-later */
-
-/** \file
- * \ingroup bli
- */
-
-#include "BLI_session_uuid.h"
-
-#include "BLI_utildefines.h"
-
-#include "atomic_ops.h"
-
-/* Special value which indicates the UUID has not been assigned yet. */
-#define BLI_SESSION_UUID_NONE 0
-
-static const SessionUUID global_session_uuid_none = {BLI_SESSION_UUID_NONE};
-
-/* Denotes last used UUID.
- * It might eventually overflow, and easiest is to add more bits to it. */
-static SessionUUID global_session_uuid = {BLI_SESSION_UUID_NONE};
-
-SessionUUID BLI_session_uuid_generate(void)
-{
-  SessionUUID result;
-  result.uuid_ = atomic_add_and_fetch_uint64(&global_session_uuid.uuid_, 1);
-  if (!BLI_session_uuid_is_generated(&result)) {
-    /* Happens when the UUID overflows.
-     *
-     * Just request the UUID once again, hoping that there are not a lot of high-priority threads
-     * which will overflow the counter once again between the previous call and this one.
-     *
-     * NOTE: It is possible to have collisions after such overflow. */
-    result.uuid_ = atomic_add_and_fetch_uint64(&global_session_uuid.uuid_, 1);
-  }
-  return result;
-}
-
-bool BLI_session_uuid_is_generated(const SessionUUID *uuid)
-{
-  return !BLI_session_uuid_is_equal(uuid, &global_session_uuid_none);
-}
-
-bool BLI_session_uuid_is_equal(const SessionUUID *lhs, const SessionUUID *rhs)
-{
-  return lhs->uuid_ == rhs->uuid_;
-}
-
-uint64_t BLI_session_uuid_hash_uint64(const SessionUUID *uuid)
-{
-  return uuid->uuid_;
-}
-
-uint BLI_session_uuid_ghash_hash(const void *uuid_v)
-{
-  const SessionUUID *uuid = (const SessionUUID *)uuid_v;
-  return uuid->uuid_ & 0xffffffff;
-}
-
-bool BLI_session_uuid_ghash_compare(const void *lhs_v, const void *rhs_v)
-{
-  const SessionUUID *lhs = (const SessionUUID *)lhs_v;
-  const SessionUUID *rhs = (const SessionUUID *)rhs_v;
-  return !BLI_session_uuid_is_equal(lhs, rhs);
-}
diff --git a/source/blender/blenlib/tests/BLI_session_uid_test.cc b/source/blender/blenlib/tests/BLI_session_uid_test.cc
new file mode 100644
index 00000000000..87060829037
--- /dev/null
+++ b/source/blender/blenlib/tests/BLI_session_uid_test.cc
@@ -0,0 +1,22 @@
+/* SPDX-FileCopyrightText: 2023 Blender Authors
+ *
+ * SPDX-License-Identifier: Apache-2.0 */
+
+#include "testing/testing.h"
+
+#include "BLI_session_uid.h"
+
+TEST(SessionUID, GenerateBasic)
+{
+  {
+    const SessionUID uid = BLI_session_uid_generate();
+    EXPECT_TRUE(BLI_session_uid_is_generated(&uid));
+  }
+
+  {
+    const SessionUID uid1 = BLI_session_uid_generate();
+    const SessionUID uid2 = BLI_session_uid_generate();
+
+    EXPECT_FALSE(BLI_session_uid_is_equal(&uid1, &uid2));
+  }
+}
diff --git a/source/blender/blenlib/tests/BLI_session_uuid_test.cc b/source/blender/blenlib/tests/BLI_session_uuid_test.cc
deleted file mode 100644
index bd78ef25a73..00000000000
--- a/source/blender/blenlib/tests/BLI_session_uuid_test.cc
+++ /dev/null
@@ -1,22 +0,0 @@
-/* SPDX-FileCopyrightText: 2023 Blender Authors
- *
- * SPDX-License-Identifier: Apache-2.0 */
-
-#include "testing/testing.h"
-
-#include "BLI_session_uuid.h"
-
-TEST(SessionUUID, GenerateBasic)
-{
-  {
-    const SessionUUID uuid = BLI_session_uuid_generate();
-    EXPECT_TRUE(BLI_session_uuid_is_generated(&uuid));
-  }
-
-  {
-    const SessionUUID uuid1 = BLI_session_uuid_generate();
-    const SessionUUID uuid2 = BLI_session_uuid_generate();
-
-    EXPECT_FALSE(BLI_session_uuid_is_equal(&uuid1, &uuid2));
-  }
-}
diff --git a/source/blender/blenloader/BLO_read_write.hh b/source/blender/blenloader/BLO_read_write.hh
index eb54fedca3d..ffdb968e184 100644
--- a/source/blender/blenloader/BLO_read_write.hh
+++ b/source/blender/blenloader/BLO_read_write.hh
@@ -277,9 +277,9 @@ ID *BLO_read_get_new_id_address(BlendLibReader *reader,
                                 ID *id) ATTR_NONNULL(2);
 
 /**
- * Search for the new address of the ID for the given `session_uuid`.
+ * Search for the new address of the ID for the given `session_uid`.
  *
- * Only IDs existing in the newly read Main will be returned. If no matching `session_uuid` in new
+ * Only IDs existing in the newly read Main will be returned. If no matching `session_uid` in new
  * main can be found, `nullptr` is returned.
  *
  * This expected to be used during library-linking and/or 'undo_preserve' processes in undo case
@@ -287,7 +287,7 @@ ID *BLO_read_get_new_id_address(BlendLibReader *reader,
  * coming from the previous, existing Main data, when it is preserved in newly read Main.
  * See e.g. the #scene_undo_preserve code-path.
  */
-ID *BLO_read_get_new_id_address_from_session_uuid(BlendLibReader *reader, uint session_uuid)
+ID *BLO_read_get_new_id_address_from_session_uid(BlendLibReader *reader, uint session_uid)
     ATTR_NONNULL(1);
 
 /* Misc. */
diff --git a/source/blender/blenloader/BLO_undofile.hh b/source/blender/blenloader/BLO_undofile.hh
index 8301bc7c579..c9056c6ac26 100644
--- a/source/blender/blenloader/BLO_undofile.hh
+++ b/source/blender/blenloader/BLO_undofile.hh
@@ -27,9 +27,9 @@ struct MemFileChunk {
    * detect unchanged IDs).
    * Defined when writing the next step (i.e. last undo step has those always false). */
   bool is_identical_future;
-  /** Session UUID of the ID being currently written (MAIN_ID_SESSION_UUID_UNSET when not writing
+  /** Session UID of the ID being currently written (MAIN_ID_SESSION_UID_UNSET when not writing
    * ID-related data). Used to find matching chunks in previous memundo step. */
-  uint id_session_uuid;
+  uint id_session_uid;
 };
 
 struct MemFile {
@@ -41,11 +41,11 @@ struct MemFileWriteData {
   MemFile *written_memfile;
   MemFile *reference_memfile;
 
-  uint current_id_session_uuid;
+  uint current_id_session_uid;
   MemFileChunk *reference_current_chunk;
 
-  /** Maps an ID session uuid to its first reference MemFileChunk, if existing. */
-  blender::Map<uint, MemFileChunk *> id_session_uuid_mapping;
+  /** Maps an ID session uid to its first reference MemFileChunk, if existing. */
+  blender::Map<uint, MemFileChunk *> id_session_uid_mapping;
 };
 
 struct MemFileUndoData {
diff --git a/source/blender/blenloader/intern/readfile.cc b/source/blender/blenloader/intern/readfile.cc
index acb9f9f2a25..bdd942d0667 100644
--- a/source/blender/blenloader/intern/readfile.cc
+++ b/source/blender/blenloader/intern/readfile.cc
@@ -1354,11 +1354,11 @@ void blo_filedata_free(FileData *fd)
     if (fd->libmap && !(fd->flags & FD_FLAGS_NOT_MY_LIBMAP)) {
       oldnewmap_free(fd->libmap);
     }
-    if (fd->old_idmap_uuid != nullptr) {
-      BKE_main_idmap_destroy(fd->old_idmap_uuid);
+    if (fd->old_idmap_uid != nullptr) {
+      BKE_main_idmap_destroy(fd->old_idmap_uid);
     }
-    if (fd->new_idmap_uuid != nullptr) {
-      BKE_main_idmap_destroy(fd->new_idmap_uuid);
+    if (fd->new_idmap_uid != nullptr) {
+      BKE_main_idmap_destroy(fd->new_idmap_uid);
     }
     blo_cache_storage_end(fd);
     if (fd->bheadmap) {
@@ -1591,10 +1591,10 @@ void blo_end_packed_pointer_map(FileData *fd, Main *oldmain)
 
 void blo_make_old_idmap_from_main(FileData *fd, Main *bmain)
 {
-  if (fd->old_idmap_uuid != nullptr) {
-    BKE_main_idmap_destroy(fd->old_idmap_uuid);
+  if (fd->old_idmap_uid != nullptr) {
+    BKE_main_idmap_destroy(fd->old_idmap_uid);
   }
-  fd->old_idmap_uuid = BKE_main_idmap_create(bmain, false, nullptr, MAIN_IDMAP_TYPE_UUID);
+  fd->old_idmap_uid = BKE_main_idmap_create(bmain, false, nullptr, MAIN_IDMAP_TYPE_UID);
 }
 
 struct BLOCacheStorage {
@@ -1611,7 +1611,7 @@ struct BLOCacheStorageValue {
 static void blo_cache_storage_entry_register(
     ID *id, const IDCacheKey *key, void **cache_p, uint /*flags*/, void *cache_storage_v)
 {
-  BLI_assert(key->id_session_uuid == id->session_uuid);
+  BLI_assert(key->id_session_uid == id->session_uid);
   UNUSED_VARS_NDEBUG(id);
 
   BLOCacheStorage *cache_storage = static_cast<BLOCacheStorage *>(cache_storage_v);
@@ -2069,13 +2069,13 @@ static void direct_link_id_common(
     BlendDataReader *reader, Library *current_library, ID *id, ID *id_old, const int id_tag)
 {
   if (!BLO_read_data_is_undo(reader)) {
-    /* When actually reading a file, we do want to reset/re-generate session UUIDS.
+    /* When actually reading a file, we do want to reset/re-generate session UIDS.
      * In undo case, we want to re-use existing ones. */
-    id->session_uuid = MAIN_ID_SESSION_UUID_UNSET;
+    id->session_uid = MAIN_ID_SESSION_UID_UNSET;
   }
 
   if ((id_tag & LIB_TAG_TEMP_MAIN) == 0) {
-    BKE_lib_libblock_session_uuid_ensure(id);
+    BKE_lib_libblock_session_uid_ensure(id);
   }
 
   id->lib = current_library;
@@ -2383,7 +2383,7 @@ static ID *create_placeholder(Main *mainvar,
   }
 
   if ((tag & LIB_TAG_TEMP_MAIN) == 0) {
-    BKE_lib_libblock_session_uuid_ensure(ph_id);
+    BKE_lib_libblock_session_uid_ensure(ph_id);
   }
 
   return ph_id;
@@ -2625,7 +2625,7 @@ static void read_undo_reuse_noundo_local_ids(FileData *fd)
 
     /* Update mappings accordingly. */
     LISTBASE_FOREACH (ID *, id_iter, new_lb) {
-      BKE_main_idmap_insert_id(fd->new_idmap_uuid, id_iter);
+      BKE_main_idmap_insert_id(fd->new_idmap_uid, id_iter);
       id_iter->tag |= LIB_TAG_UNDO_OLD_ID_REUSED_NOUNDO;
     }
   }
@@ -2642,14 +2642,14 @@ static void read_undo_move_libmain_data(
   BLI_addtail(&new_main->libraries, libmain->curlib);
 
   curlib->id.tag |= LIB_TAG_UNDO_OLD_ID_REUSED_NOUNDO;
-  BKE_main_idmap_insert_id(fd->new_idmap_uuid, &curlib->id);
+  BKE_main_idmap_insert_id(fd->new_idmap_uid, &curlib->id);
   if (bhead != nullptr) {
     oldnewmap_lib_insert(fd, bhead->old, &curlib->id, GS(curlib->id.name));
   }
 
   ID *id_iter;
   FOREACH_MAIN_ID_BEGIN (libmain, id_iter) {
-    BKE_main_idmap_insert_id(fd->new_idmap_uuid, id_iter);
+    BKE_main_idmap_insert_id(fd->new_idmap_uid, id_iter);
   }
   FOREACH_MAIN_ID_END;
 }
@@ -2709,7 +2709,7 @@ static bool read_libblock_undo_restore_linked(
   CLOG_INFO(&LOG_UNDO, 2, "UNDO: restore linked datablock %s", id->name);
 
   if (*r_id_old == nullptr) {
-    /* If the linked ID had to be re-read at some point, its session_uuid may not be the same as
+    /* If the linked ID had to be re-read at some point, its session_uid may not be the same as
      * its reference stored in the memfile anymore. Do a search by name then. */
     *r_id_old = library_id_is_yet_read(fd, libmain, bhead);
 
@@ -2729,19 +2729,19 @@ static bool read_libblock_undo_restore_linked(
               libmain->curlib ? libmain->curlib->filepath : "<nullptr>");
     /* The Library ID 'owning' this linked ID should already have been moved to new main by a call
      * to #read_libblock_undo_restore_library. */
-    BLI_assert(*r_id_old == static_cast<ID *>(BKE_main_idmap_lookup_uuid(
-                                fd->new_idmap_uuid, (*r_id_old)->session_uuid)));
+    BLI_assert(*r_id_old == static_cast<ID *>(BKE_main_idmap_lookup_uid(
+                                fd->new_idmap_uid, (*r_id_old)->session_uid)));
   }
   else {
     CLOG_INFO(&LOG_UNDO,
               2,
-              "    from %s (%s): found by session_uuid",
+              "    from %s (%s): found by session_uid",
               libmain->curlib ? libmain->curlib->id.name : "<nullptr>",
               libmain->curlib ? libmain->curlib->filepath : "<nullptr>");
     /* The Library ID 'owning' this linked ID should already have been moved to new main by a call
      * to #read_libblock_undo_restore_library. */
-    BLI_assert(*r_id_old == static_cast<ID *>(
-                                BKE_main_idmap_lookup_uuid(fd->new_idmap_uuid, id->session_uuid)));
+    BLI_assert(*r_id_old ==
+               static_cast<ID *>(BKE_main_idmap_lookup_uid(fd->new_idmap_uid, id->session_uid)));
   }
 
   oldnewmap_lib_insert(fd, bhead->old, *r_id_old, GS((*r_id_old)->name));
@@ -2789,7 +2789,7 @@ static void read_libblock_undo_restore_identical(
    * remapped, so no need to store this info here. */
   oldnewmap_lib_insert(fd, bhead->old, id_old, bhead->code);
 
-  BKE_main_idmap_insert_id(fd->new_idmap_uuid, id_old);
+  BKE_main_idmap_insert_id(fd->new_idmap_uid, id_old);
 
   if (GS(id_old->name) == ID_OB) {
     Object *ob = (Object *)id_old;
@@ -2843,7 +2843,7 @@ static void read_libblock_undo_restore_at_old_address(FileData *fd, Main *main,
 static bool read_libblock_undo_restore(
     FileData *fd, Main *main, BHead *bhead, int id_tag, ID **r_id_old)
 {
-  BLI_assert(fd->old_idmap_uuid != nullptr);
+  BLI_assert(fd->old_idmap_uid != nullptr);
 
   /* Get pointer to memory of new ID that we will be reading. */
   const ID *id = static_cast<const ID *>(peek_struct_undo(fd, bhead));
@@ -2859,8 +2859,8 @@ static bool read_libblock_undo_restore(
 
   /* Find the 'current' existing ID we want to reuse instead of the one we
    * would read from the undo memfile. */
-  ID *id_old = (fd->old_idmap_uuid != nullptr) ?
-                   BKE_main_idmap_lookup_uuid(fd->old_idmap_uuid, id->session_uuid) :
+  ID *id_old = (fd->old_idmap_uid != nullptr) ?
+                   BKE_main_idmap_lookup_uid(fd->old_idmap_uid, id->session_uid) :
                    nullptr;
 
   if (bhead->code == ID_LI) {
@@ -2881,14 +2881,14 @@ static bool read_libblock_undo_restore(
 
     /* If that local noundo ID still exists currently, the call to
      * #read_undo_reuse_noundo_local_ids at the beginning of #blo_read_file_internal will already
-     * have moved it into the new main, and populated accordingly the new_idmap_uuid.
+     * have moved it into the new main, and populated accordingly the new_idmap_uid.
      *
      * If this is the case, it can also be remapped for newly read data. Otherwise, this is 'lost'
      * data that cannot be restored on undo, so no remapping should exist for it in the ID
      * oldnewmap. */
     if (id_old) {
-      BLI_assert(id_old == static_cast<ID *>(
-                               BKE_main_idmap_lookup_uuid(fd->new_idmap_uuid, id->session_uuid)));
+      BLI_assert(id_old ==
+                 static_cast<ID *>(BKE_main_idmap_lookup_uid(fd->new_idmap_uid, id->session_uid)));
       oldnewmap_lib_insert(fd, bhead->old, id_old, bhead->code);
     }
     return true;
@@ -2897,9 +2897,9 @@ static bool read_libblock_undo_restore(
   if (!do_partial_undo) {
     CLOG_INFO(&LOG_UNDO,
               2,
-              "UNDO: read %s (uuid %u) -> no partial undo, always read at new address",
+              "UNDO: read %s (uid %u) -> no partial undo, always read at new address",
               id->name,
-              id->session_uuid);
+              id->session_uid);
     return false;
   }
 
@@ -2908,9 +2908,9 @@ static bool read_libblock_undo_restore(
     /* Local datablock was unchanged, restore from the old main. */
     CLOG_INFO(&LOG_UNDO,
               2,
-              "UNDO: read %s (uuid %u) -> keep identical datablock",
+              "UNDO: read %s (uid %u) -> keep identical datablock",
               id->name,
-              id->session_uuid);
+              id->session_uid);
 
     read_libblock_undo_restore_identical(fd, main, id, id_old, bhead, id_tag);
 
@@ -2921,16 +2921,16 @@ static bool read_libblock_undo_restore(
     /* Local datablock was changed. Restore at the address of the old datablock. */
     CLOG_INFO(&LOG_UNDO,
               2,
-              "UNDO: read %s (uuid %u) -> read to old existing address",
+              "UNDO: read %s (uid %u) -> read to old existing address",
               id->name,
-              id->session_uuid);
+              id->session_uid);
     *r_id_old = id_old;
     return false;
   }
 
   /* Local datablock does not exist in the undo step, so read from scratch. */
   CLOG_INFO(
-      &LOG_UNDO, 2, "UNDO: read %s (uuid %u) -> read at new address", id->name, id->session_uuid);
+      &LOG_UNDO, 2, "UNDO: read %s (uid %u) -> read at new address", id->name, id->session_uid);
   return false;
 }
 
@@ -3051,8 +3051,8 @@ static BHead *read_libblock(FileData *fd,
       /* For undo, store contents read into id at id_old. */
       read_libblock_undo_restore_at_old_address(fd, main, id, id_old);
     }
-    if (fd->new_idmap_uuid != nullptr) {
-      BKE_main_idmap_insert_id(fd->new_idmap_uuid, id_target);
+    if (fd->new_idmap_uid != nullptr) {
+      BKE_main_idmap_insert_id(fd->new_idmap_uid, id_target);
     }
     if (main->id_map != nullptr) {
       BKE_main_idmap_insert_id(main->id_map, id_target);
@@ -3520,10 +3520,10 @@ static int read_undo_remap_noundo_data_cb(LibraryIDLinkCallbackData *cb_data)
     return IDWALK_RET_NOP;
   }
 
-  IDNameLib_Map *new_idmap_uuid = static_cast<IDNameLib_Map *>(cb_data->user_data);
+  IDNameLib_Map *new_idmap_uid = static_cast<IDNameLib_Map *>(cb_data->user_data);
   ID **id_pointer = cb_data->id_pointer;
   if (*id_pointer != nullptr) {
-    *id_pointer = BKE_main_idmap_lookup_uuid(new_idmap_uuid, (*id_pointer)->session_uuid);
+    *id_pointer = BKE_main_idmap_lookup_uid(new_idmap_uid, (*id_pointer)->session_uid);
   }
 
   return IDWALK_RET_NOP;
@@ -3535,7 +3535,7 @@ static int read_undo_remap_noundo_data_cb(LibraryIDLinkCallbackData *cb_data)
  * re-used IDs (the 'unchanged' ones), there is no guarantee that all the ID pointers they use are
  * still valid.
  *
- * This code performs a remapping based on the session_uuid. */
+ * This code performs a remapping based on the session_uid. */
 static void read_undo_remap_noundo_data(FileData *fd)
 {
   Main *new_bmain = static_cast<Main *>(fd->mainlist->first);
@@ -3549,7 +3549,7 @@ static void read_undo_remap_noundo_data(FileData *fd)
     }
 
     BKE_library_foreach_ID_link(
-        new_bmain, id_iter, read_undo_remap_noundo_data_cb, fd->new_idmap_uuid, IDWALK_INCLUDE_UI);
+        new_bmain, id_iter, read_undo_remap_noundo_data_cb, fd->new_idmap_uid, IDWALK_INCLUDE_UI);
   }
   FOREACH_MAIN_ID_END;
 }
@@ -3621,10 +3621,10 @@ BlendFileData *blo_read_file_internal(FileData *fd, const char *filepath)
   }
 
   if (is_undo) {
-    /* This idmap will store uuids of all IDs ending up in the new main, whether they are newly
+    /* This idmap will store uids of all IDs ending up in the new main, whether they are newly
      * read, or re-used from the old main. */
-    fd->new_idmap_uuid = BKE_main_idmap_create(
-        static_cast<Main *>(fd->mainlist->first), false, nullptr, MAIN_IDMAP_TYPE_UUID);
+    fd->new_idmap_uid = BKE_main_idmap_create(
+        static_cast<Main *>(fd->mainlist->first), false, nullptr, MAIN_IDMAP_TYPE_UID);
 
     /* Copy all 'no undo' local data from old to new bmain. */
     read_undo_reuse_noundo_local_ids(fd);
@@ -4858,9 +4858,9 @@ ID *BLO_read_get_new_id_address(BlendLibReader *reader,
   return static_cast<ID *>(newlibadr(reader->fd, self_id, is_linked_only, id));
 }
 
-ID *BLO_read_get_new_id_address_from_session_uuid(BlendLibReader *reader, uint session_uuid)
+ID *BLO_read_get_new_id_address_from_session_uid(BlendLibReader *reader, uint session_uid)
 {
-  return BKE_main_idmap_lookup_uuid(reader->fd->new_idmap_uuid, session_uuid);
+  return BKE_main_idmap_lookup_uid(reader->fd->new_idmap_uid, session_uid);
 }
 
 int BLO_read_fileversion_get(BlendDataReader *reader)
diff --git a/source/blender/blenloader/intern/readfile.hh b/source/blender/blenloader/intern/readfile.hh
index b761d0812d3..51a85457a46 100644
--- a/source/blender/blenloader/intern/readfile.hh
+++ b/source/blender/blenloader/intern/readfile.hh
@@ -118,11 +118,11 @@ struct FileData {
   /** Used for undo. */
   ListBase *old_mainlist;
   /**
-   * IDMap using UUID's as keys of all the old IDs in the old bmain. Used during undo to find a
+   * IDMap using UID's as keys of all the old IDs in the old bmain. Used during undo to find a
    * matching old data when reading a new ID. */
-  IDNameLib_Map *old_idmap_uuid;
+  IDNameLib_Map *old_idmap_uid;
   /**
-   * IDMap using uuids as keys of the IDs read (or moved) in the new main(s).
+   * IDMap using uids as keys of the IDs read (or moved) in the new main(s).
    *
    * Used during undo to ensure that the ID pointers from the 'no undo' IDs remain valid (these
    * IDs are re-used from old main even if their content is not the same as in the memfile undo
@@ -130,7 +130,7 @@ struct FileData {
    *
    * Also used to find current valid pointers (or none) of these 'no undo' IDs existing in
    * read memfile. */
-  IDNameLib_Map *new_idmap_uuid;
+  IDNameLib_Map *new_idmap_uid;
 
   BlendFileReadReport *reports;
 };
diff --git a/source/blender/blenloader/intern/undofile.cc b/source/blender/blenloader/intern/undofile.cc
index 245d713a3fe..d7b101eeded 100644
--- a/source/blender/blenloader/intern/undofile.cc
+++ b/source/blender/blenloader/intern/undofile.cc
@@ -97,17 +97,17 @@ void BLO_memfile_write_init(MemFileWriteData *mem_data,
                                                               reference_memfile->chunks.first) :
                                                           nullptr;
 
-  /* If we have a reference memfile, we generate a mapping between the session_uuid's of the
+  /* If we have a reference memfile, we generate a mapping between the session_uid's of the
    * IDs stored in that previous undo step, and its first matching memchunk. This will allow
    * us to easily find the existing undo memory storage of IDs even when some re-ordering in
    * current Main data-base broke the order matching with the memchunks from previous step.
    */
   if (reference_memfile != nullptr) {
-    uint current_session_uuid = MAIN_ID_SESSION_UUID_UNSET;
+    uint current_session_uid = MAIN_ID_SESSION_UID_UNSET;
     LISTBASE_FOREACH (MemFileChunk *, mem_chunk, &reference_memfile->chunks) {
-      if (!ELEM(mem_chunk->id_session_uuid, MAIN_ID_SESSION_UUID_UNSET, current_session_uuid)) {
-        current_session_uuid = mem_chunk->id_session_uuid;
-        mem_data->id_session_uuid_mapping.add_new(current_session_uuid, mem_chunk);
+      if (!ELEM(mem_chunk->id_session_uid, MAIN_ID_SESSION_UID_UNSET, current_session_uid)) {
+        current_session_uid = mem_chunk->id_session_uid;
+        mem_data->id_session_uid_mapping.add_new(current_session_uid, mem_chunk);
       }
     }
   }
@@ -115,7 +115,7 @@ void BLO_memfile_write_init(MemFileWriteData *mem_data,
 
 void BLO_memfile_write_finalize(MemFileWriteData *mem_data)
 {
-  mem_data->id_session_uuid_mapping.clear_and_shrink();
+  mem_data->id_session_uid_mapping.clear_and_shrink();
 }
 
 void BLO_memfile_chunk_add(MemFileWriteData *mem_data, const char *buf, size_t size)
@@ -132,7 +132,7 @@ void BLO_memfile_chunk_add(MemFileWriteData *mem_data, const char *buf, size_t s
    * perform an undo push may make changes after the last undo push that
    * will then not be undo. Though it's not entirely clear that is wrong behavior. */
   curchunk->is_identical_future = true;
-  curchunk->id_session_uuid = mem_data->current_id_session_uuid;
+  curchunk->id_session_uid = mem_data->current_id_session_uid;
   BLI_addtail(&memfile->chunks, curchunk);
 
   /* we compare compchunk with buf */
diff --git a/source/blender/blenloader/intern/versioning_250.cc b/source/blender/blenloader/intern/versioning_250.cc
index 355e853d3d4..0ca8f91f420 100644
--- a/source/blender/blenloader/intern/versioning_250.cc
+++ b/source/blender/blenloader/intern/versioning_250.cc
@@ -450,7 +450,7 @@ static void versions_gpencil_add_main(Main *bmain, ListBase *lb, ID *id, const c
   /* alphabetic insertion: is in BKE_id_new_name_validate */
 
   if ((id->tag & LIB_TAG_TEMP_MAIN) == 0) {
-    BKE_lib_libblock_session_uuid_ensure(id);
+    BKE_lib_libblock_session_uid_ensure(id);
   }
 
   if (G.debug & G_DEBUG) {
diff --git a/source/blender/blenloader/intern/writefile.cc b/source/blender/blenloader/intern/writefile.cc
index 504c9aa760d..d883efaebdd 100644
--- a/source/blender/blenloader/intern/writefile.cc
+++ b/source/blender/blenloader/intern/writefile.cc
@@ -612,27 +612,27 @@ static bool mywrite_end(WriteData *wd)
 static void mywrite_id_begin(WriteData *wd, ID *id)
 {
   if (wd->use_memfile) {
-    wd->mem.current_id_session_uuid = id->session_uuid;
+    wd->mem.current_id_session_uid = id->session_uid;
 
     /* If current next memchunk does not match the ID we are about to write, or is not the _first_
-     * one for said ID, try to find the correct memchunk in the mapping using ID's session_uuid. */
+     * one for said ID, try to find the correct memchunk in the mapping using ID's session_uid. */
     MemFileChunk *curr_memchunk = wd->mem.reference_current_chunk;
     MemFileChunk *prev_memchunk = curr_memchunk != nullptr ?
                                       static_cast<MemFileChunk *>(curr_memchunk->prev) :
                                       nullptr;
-    if ((curr_memchunk == nullptr || curr_memchunk->id_session_uuid != id->session_uuid ||
+    if ((curr_memchunk == nullptr || curr_memchunk->id_session_uid != id->session_uid ||
          (prev_memchunk != nullptr &&
-          (prev_memchunk->id_session_uuid == curr_memchunk->id_session_uuid))))
+          (prev_memchunk->id_session_uid == curr_memchunk->id_session_uid))))
     {
-      if (MemFileChunk *ref = wd->mem.id_session_uuid_mapping.lookup_default(id->session_uuid,
-                                                                             nullptr))
+      if (MemFileChunk *ref = wd->mem.id_session_uid_mapping.lookup_default(id->session_uid,
+                                                                            nullptr))
       {
         wd->mem.reference_current_chunk = static_cast<MemFileChunk *>(ref);
       }
       /* Else, no existing memchunk found, i.e. this is supposed to be a new ID. */
     }
     /* Otherwise, we try with the current memchunk in any case, whether it is matching current
-     * ID's session_uuid or not. */
+     * ID's session_uid or not. */
   }
 }
 
@@ -647,7 +647,7 @@ static void mywrite_id_end(WriteData *wd, ID * /*id*/)
     /* Very important to do it after every ID write now, otherwise we cannot know whether a
      * specific ID changed or not. */
     mywrite_flush(wd);
-    wd->mem.current_id_session_uuid = MAIN_ID_SESSION_UUID_UNSET;
+    wd->mem.current_id_session_uid = MAIN_ID_SESSION_UID_UNSET;
   }
 }
 
diff --git a/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc b/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc
index 7f4820e6a7f..e813a338c1e 100644
--- a/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc
+++ b/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc
@@ -150,7 +150,7 @@ DepsgraphNodeBuilder::~DepsgraphNodeBuilder()
 
 IDNode *DepsgraphNodeBuilder::add_id_node(ID *id)
 {
-  BLI_assert(id->session_uuid != MAIN_ID_SESSION_UUID_UNSET);
+  BLI_assert(id->session_uid != MAIN_ID_SESSION_UID_UNSET);
 
   const ID_Type id_type = GS(id->name);
   IDNode *id_node = nullptr;
@@ -158,7 +158,7 @@ IDNode *DepsgraphNodeBuilder::add_id_node(ID *id)
   IDComponentsMask previously_visible_components_mask = 0;
   uint32_t previous_eval_flags = 0;
   DEGCustomDataMeshMasks previous_customdata_masks;
-  IDInfo *id_info = id_info_hash_.lookup_default(id->session_uuid, nullptr);
+  IDInfo *id_info = id_info_hash_.lookup_default(id->session_uid, nullptr);
   if (id_info != nullptr) {
     id_cow = id_info->id_cow;
     previously_visible_components_mask = id_info->previously_visible_components_mask;
@@ -397,8 +397,8 @@ void DepsgraphNodeBuilder::begin_build()
     id_info->previously_visible_components_mask = id_node->visible_components_mask;
     id_info->previous_eval_flags = id_node->eval_flags;
     id_info->previous_customdata_masks = id_node->customdata_masks;
-    BLI_assert(!id_info_hash_.contains(id_node->id_orig_session_uuid));
-    id_info_hash_.add_new(id_node->id_orig_session_uuid, id_info);
+    BLI_assert(!id_info_hash_.contains(id_node->id_orig_session_uid));
+    id_info_hash_.add_new(id_node->id_orig_session_uid, id_info);
     id_node->id_cow = nullptr;
   }
 
diff --git a/source/blender/depsgraph/intern/builder/deg_builder_nodes.h b/source/blender/depsgraph/intern/builder/deg_builder_nodes.h
index 9124480ed25..f8a14854726 100644
--- a/source/blender/depsgraph/intern/builder/deg_builder_nodes.h
+++ b/source/blender/depsgraph/intern/builder/deg_builder_nodes.h
@@ -322,7 +322,7 @@ class DepsgraphNodeBuilder : public DepsgraphBuilder {
    * very root is visible (aka not restricted.). */
   bool is_parent_collection_visible_;
 
-  /* Indexed by original ID.session_uuid, values are IDInfo. */
+  /* Indexed by original ID.session_uid, values are IDInfo. */
   Map<uint, IDInfo *> id_info_hash_;
 
   /* Set of IDs which were already build. Makes it easier to keep track of
diff --git a/source/blender/depsgraph/intern/eval/deg_eval_copy_on_write.cc b/source/blender/depsgraph/intern/eval/deg_eval_copy_on_write.cc
index 54f4d71b379..e3e33357b55 100644
--- a/source/blender/depsgraph/intern/eval/deg_eval_copy_on_write.cc
+++ b/source/blender/depsgraph/intern/eval/deg_eval_copy_on_write.cc
@@ -270,11 +270,11 @@ bool id_copy_inplace_no_main(const ID *id, ID *newid)
 {
   const ID *id_for_copy = id;
 
-  if (G.debug & G_DEBUG_DEPSGRAPH_UUID) {
+  if (G.debug & G_DEBUG_DEPSGRAPH_UID) {
     const ID_Type id_type = GS(id_for_copy->name);
     if (id_type == ID_OB) {
       const Object *object = reinterpret_cast<const Object *>(id_for_copy);
-      BKE_object_check_uuids_unique_and_report(object);
+      BKE_object_check_uids_unique_and_report(object);
     }
   }
 
@@ -303,8 +303,8 @@ bool id_copy_inplace_no_main(const ID *id, ID *newid)
 bool scene_copy_inplace_no_main(const Scene *scene, Scene *new_scene)
 {
 
-  if (G.debug & G_DEBUG_DEPSGRAPH_UUID) {
-    SEQ_relations_check_uuids_unique_and_report(scene);
+  if (G.debug & G_DEBUG_DEPSGRAPH_UID) {
+    SEQ_relations_check_uids_unique_and_report(scene);
   }
 
 #ifdef NESTED_ID_NASTY_WORKAROUND
diff --git a/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_object.cc b/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_object.cc
index aca4b4b223b..cd17460ae5b 100644
--- a/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_object.cc
+++ b/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_object.cc
@@ -58,10 +58,10 @@ void ObjectRuntimeBackup::backup_modifier_runtime_data(Object *object)
       continue;
     }
 
-    const SessionUUID &session_uuid = modifier_data->session_uuid;
-    BLI_assert(BLI_session_uuid_is_generated(&session_uuid));
+    const SessionUID &session_uid = modifier_data->session_uid;
+    BLI_assert(BLI_session_uid_is_generated(&session_uid));
 
-    modifier_runtime_data.add(session_uuid, ModifierDataBackup(modifier_data));
+    modifier_runtime_data.add(session_uid, ModifierDataBackup(modifier_data));
     modifier_data->runtime = nullptr;
   }
 }
@@ -70,10 +70,10 @@ void ObjectRuntimeBackup::backup_pose_channel_runtime_data(Object *object)
 {
   if (object->pose != nullptr) {
     LISTBASE_FOREACH (bPoseChannel *, pchan, &object->pose->chanbase) {
-      const SessionUUID &session_uuid = pchan->runtime.session_uuid;
-      BLI_assert(BLI_session_uuid_is_generated(&session_uuid));
+      const SessionUID &session_uid = pchan->runtime.session_uid;
+      BLI_assert(BLI_session_uid_is_generated(&session_uid));
 
-      pose_channel_runtime_data.add(session_uuid, pchan->runtime);
+      pose_channel_runtime_data.add(session_uid, pchan->runtime);
       BKE_pose_channel_runtime_reset(&pchan->runtime);
     }
   }
@@ -149,10 +149,10 @@ void ObjectRuntimeBackup::restore_to_object(Object *object)
 void ObjectRuntimeBackup::restore_modifier_runtime_data(Object *object)
 {
   LISTBASE_FOREACH (ModifierData *, modifier_data, &object->modifiers) {
-    const SessionUUID &session_uuid = modifier_data->session_uuid;
-    BLI_assert(BLI_session_uuid_is_generated(&session_uuid));
+    const SessionUID &session_uid = modifier_data->session_uid;
+    BLI_assert(BLI_session_uid_is_generated(&session_uid));
 
-    optional<ModifierDataBackup> backup = modifier_runtime_data.pop_try(session_uuid);
+    optional<ModifierDataBackup> backup = modifier_runtime_data.pop_try(session_uid);
     if (backup.has_value()) {
       modifier_data->runtime = backup->runtime;
     }
@@ -178,8 +178,8 @@ void ObjectRuntimeBackup::restore_pose_channel_runtime_data(Object *object)
 {
   if (object->pose != nullptr) {
     LISTBASE_FOREACH (bPoseChannel *, pchan, &object->pose->chanbase) {
-      const SessionUUID &session_uuid = pchan->runtime.session_uuid;
-      optional<bPoseChannel_Runtime> runtime = pose_channel_runtime_data.pop_try(session_uuid);
+      const SessionUID &session_uid = pchan->runtime.session_uid;
+      optional<bPoseChannel_Runtime> runtime = pose_channel_runtime_data.pop_try(session_uid);
       if (runtime.has_value()) {
         pchan->runtime = *runtime;
       }
diff --git a/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_object.h b/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_object.h
index 846904df76a..197ab7c7ce5 100644
--- a/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_object.h
+++ b/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_object.h
@@ -9,11 +9,11 @@
 #pragma once
 
 #include "DNA_object_types.h"
-#include "DNA_session_uuid_types.h"
+#include "DNA_session_uid_types.h"
 
 #include "BKE_object_types.hh"
 
-#include "BLI_session_uuid.h"
+#include "BLI_session_uid.h"
 
 #include "intern/depsgraph_type.hh"
 #include "intern/eval/deg_eval_runtime_backup_modifier.h"
@@ -46,8 +46,8 @@ class ObjectRuntimeBackup {
   optional<LightLinkingRuntime> light_linking_runtime;
   short base_flag;
   unsigned short base_local_view_bits;
-  Map<SessionUUID, ModifierDataBackup> modifier_runtime_data;
-  Map<SessionUUID, bPoseChannel_Runtime> pose_channel_runtime_data;
+  Map<SessionUID, ModifierDataBackup> modifier_runtime_data;
+  Map<SessionUID, bPoseChannel_Runtime> pose_channel_runtime_data;
 };
 
 }  // namespace blender::deg
diff --git a/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_sequencer.cc b/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_sequencer.cc
index 753943a7e8d..9d7363b4b53 100644
--- a/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_sequencer.cc
+++ b/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_sequencer.cc
@@ -27,9 +27,9 @@ static bool seq_init_cb(Sequence *seq, void *user_data)
   SequenceBackup sequence_backup(sb->depsgraph);
   sequence_backup.init_from_sequence(seq);
   if (!sequence_backup.isEmpty()) {
-    const SessionUUID &session_uuid = seq->runtime.session_uuid;
-    BLI_assert(BLI_session_uuid_is_generated(&session_uuid));
-    sb->sequences_backup.add(session_uuid, sequence_backup);
+    const SessionUID &session_uid = seq->runtime.session_uid;
+    BLI_assert(BLI_session_uid_is_generated(&session_uid));
+    sb->sequences_backup.add(session_uid, sequence_backup);
   }
   return true;
 }
@@ -44,9 +44,9 @@ void SequencerBackup::init_from_scene(Scene *scene)
 static bool seq_restore_cb(Sequence *seq, void *user_data)
 {
   SequencerBackup *sb = (SequencerBackup *)user_data;
-  const SessionUUID &session_uuid = seq->runtime.session_uuid;
-  BLI_assert(BLI_session_uuid_is_generated(&session_uuid));
-  SequenceBackup *sequence_backup = sb->sequences_backup.lookup_ptr(session_uuid);
+  const SessionUID &session_uid = seq->runtime.session_uid;
+  BLI_assert(BLI_session_uid_is_generated(&session_uid));
+  SequenceBackup *sequence_backup = sb->sequences_backup.lookup_ptr(session_uid);
   if (sequence_backup != nullptr) {
     sequence_backup->restore_to_sequence(seq);
   }
diff --git a/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_sequencer.h b/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_sequencer.h
index 29e85cb8638..9d321a42ea2 100644
--- a/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_sequencer.h
+++ b/source/blender/depsgraph/intern/eval/deg_eval_runtime_backup_sequencer.h
@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "DNA_session_uuid_types.h"
+#include "DNA_session_uid_types.h"
 
-#include "BLI_session_uuid.h"
+#include "BLI_session_uid.h"
 
 #include "intern/depsgraph_type.hh"
 #include "intern/eval/deg_eval_runtime_backup_sequence.h"
@@ -31,7 +31,7 @@ class SequencerBackup {
 
   const Depsgraph *depsgraph;
 
-  Map<SessionUUID, SequenceBackup> sequences_backup;
+  Map<SessionUID, SequenceBackup> sequences_backup;
 };
 
 }  // namespace blender::deg
diff --git a/source/blender/depsgraph/intern/node/deg_node_id.cc b/source/blender/depsgraph/intern/node/deg_node_id.cc
index c9cff6f8cda..3079a2290cd 100644
--- a/source/blender/depsgraph/intern/node/deg_node_id.cc
+++ b/source/blender/depsgraph/intern/node/deg_node_id.cc
@@ -62,7 +62,7 @@ void IDNode::init(const ID *id, const char * /*subdata*/)
   /* Store ID-pointer. */
   id_type = GS(id->name);
   id_orig = (ID *)id;
-  id_orig_session_uuid = id->session_uuid;
+  id_orig_session_uid = id->session_uid;
   eval_flags = 0;
   previous_eval_flags = 0;
   customdata_masks = DEGCustomDataMeshMasks();
diff --git a/source/blender/depsgraph/intern/node/deg_node_id.hh b/source/blender/depsgraph/intern/node/deg_node_id.hh
index 90bae07f5e9..1aef3afa9e1 100644
--- a/source/blender/depsgraph/intern/node/deg_node_id.hh
+++ b/source/blender/depsgraph/intern/node/deg_node_id.hh
@@ -71,7 +71,7 @@ struct IDNode : public Node {
    * Is used on relations update to map evaluated state from old nodes to the new ones, without
    * relying on pointers (which are not guaranteed to be unique) and without dereferencing id_orig
    * which could be "stale" pointer. */
-  uint id_orig_session_uuid;
+  uint id_orig_session_uid;
 
   /* Evaluated data-block.
    * Will be covered by the copy-on-write system if the ID Type needs it. */
diff --git a/source/blender/editors/geometry/node_group_operator.cc b/source/blender/editors/geometry/node_group_operator.cc
index db447842674..0f559cf5441 100644
--- a/source/blender/editors/geometry/node_group_operator.cc
+++ b/source/blender/editors/geometry/node_group_operator.cc
@@ -85,7 +85,7 @@ static const bNodeTree *get_asset_or_local_node_group(const bContext &C,
 {
   Main &bmain = *CTX_data_main(&C);
   if (bNodeTree *group = reinterpret_cast<bNodeTree *>(
-          WM_operator_properties_id_lookup_from_name_or_session_uuid(&bmain, &ptr, ID_NT)))
+          WM_operator_properties_id_lookup_from_name_or_session_uid(&bmain, &ptr, ID_NT)))
   {
     return group;
   }
diff --git a/source/blender/editors/interface/interface_dropboxes.cc b/source/blender/editors/interface/interface_dropboxes.cc
index 0bd7ef280ad..7ceb8ff5cbd 100644
--- a/source/blender/editors/interface/interface_dropboxes.cc
+++ b/source/blender/editors/interface/interface_dropboxes.cc
@@ -93,7 +93,7 @@ static bool ui_drop_material_poll(bContext *C, wmDrag *drag, const wmEvent * /*e
 static void ui_drop_material_copy(bContext *C, wmDrag *drag, wmDropBox *drop)
 {
   const ID *id = WM_drag_get_local_ID_or_import_from_asset(C, drag, ID_MA);
-  RNA_int_set(drop->ptr, "session_uuid", int(id->session_uuid));
+  RNA_int_set(drop->ptr, "session_uid", int(id->session_uid));
 }
 
 static std::string ui_drop_material_tooltip(bContext *C,
diff --git a/source/blender/editors/interface/interface_ops.cc b/source/blender/editors/interface/interface_ops.cc
index a0fe01ff8fd..ff5f99ae475 100644
--- a/source/blender/editors/interface/interface_ops.cc
+++ b/source/blender/editors/interface/interface_ops.cc
@@ -2572,7 +2572,7 @@ static int ui_drop_material_exec(bContext *C, wmOperator *op)
 {
   Main *bmain = CTX_data_main(C);
 
-  Material *ma = (Material *)WM_operator_properties_id_lookup_from_name_or_session_uuid(
+  Material *ma = (Material *)WM_operator_properties_id_lookup_from_name_or_session_uid(
       bmain, op->ptr, ID_MA);
   if (ma == nullptr) {
     return OPERATOR_CANCELLED;
diff --git a/source/blender/editors/mesh/editmesh_undo.cc b/source/blender/editors/mesh/editmesh_undo.cc
index c52d0cb0480..3dcc631311f 100644
--- a/source/blender/editors/mesh/editmesh_undo.cc
+++ b/source/blender/editors/mesh/editmesh_undo.cc
@@ -680,13 +680,13 @@ static void um_arraystore_free(UndoMesh *um)
  */
 static UndoMesh **mesh_undostep_reference_elems_from_objects(Object **object, int object_len)
 {
-  /* Map: `Mesh.id.session_uuid` -> `UndoMesh`. */
+  /* Map: `Mesh.id.session_uid` -> `UndoMesh`. */
   GHash *uuid_map = BLI_ghash_ptr_new_ex(__func__, object_len);
   UndoMesh **um_references = static_cast<UndoMesh **>(
       MEM_callocN(sizeof(UndoMesh *) * object_len, __func__));
   for (int i = 0; i < object_len; i++) {
     const Mesh *mesh = static_cast<const Mesh *>(object[i]->data);
-    BLI_ghash_insert(uuid_map, POINTER_FROM_INT(mesh->id.session_uuid), &um_references[i]);
+    BLI_ghash_insert(uuid_map, POINTER_FROM_INT(mesh->id.session_uid), &um_references[i]);
   }
   int uuid_map_len = object_len;
 
@@ -696,8 +696,8 @@ static UndoMesh **mesh_undostep_reference_elems_from_objects(Object **object, in
   UndoMesh *um_iter = static_cast<UndoMesh *>(um_arraystore.local_links.last);
   while (um_iter && (uuid_map_len != 0)) {
     UndoMesh **um_p;
-    if ((um_p = static_cast<UndoMesh **>(BLI_ghash_popkey(
-             uuid_map, POINTER_FROM_INT(um_iter->mesh.id.session_uuid), nullptr))))
+    if ((um_p = static_cast<UndoMesh **>(
+             BLI_ghash_popkey(uuid_map, POINTER_FROM_INT(um_iter->mesh.id.session_uid), nullptr))))
     {
       *um_p = um_iter;
       uuid_map_len--;
@@ -957,7 +957,7 @@ static bool mesh_undosys_step_encode(bContext *C, Main *bmain, UndoStep *us_p)
 
 #ifdef USE_ARRAY_STORE
     /** As this is only data storage it is safe to set the session ID here. */
-    elem->data.mesh.id.session_uuid = mesh->id.session_uuid;
+    elem->data.mesh.id.session_uid = mesh->id.session_uid;
 #endif
   }
   MEM_freeN(objects);
diff --git a/source/blender/editors/object/add_modifier_assets.cc b/source/blender/editors/object/add_modifier_assets.cc
index 2abb5ebc7b1..df3abf35c22 100644
--- a/source/blender/editors/object/add_modifier_assets.cc
+++ b/source/blender/editors/object/add_modifier_assets.cc
@@ -262,7 +262,7 @@ static bNodeTree *get_asset_or_local_node_group(const bContext &C,
 {
   Main &bmain = *CTX_data_main(&C);
   if (bNodeTree *group = reinterpret_cast<bNodeTree *>(
-          WM_operator_properties_id_lookup_from_name_or_session_uuid(&bmain, &ptr, ID_NT)))
+          WM_operator_properties_id_lookup_from_name_or_session_uid(&bmain, &ptr, ID_NT)))
   {
     return group;
   }
diff --git a/source/blender/editors/object/object_add.cc b/source/blender/editors/object/object_add.cc
index a6d8d61a4c9..38c2e8e2567 100644
--- a/source/blender/editors/object/object_add.cc
+++ b/source/blender/editors/object/object_add.cc
@@ -1809,7 +1809,7 @@ static std::optional<CollectionAddInfo> collection_add_info_get_from_op(bContext
   PropertyRNA *prop_location = RNA_struct_find_property(op->ptr, "location");
 
   add_info.collection = reinterpret_cast<Collection *>(
-      WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_GR));
+      WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_GR));
 
   bool update_location_if_necessary = false;
   if (add_info.collection) {
@@ -2055,8 +2055,7 @@ static int object_data_instance_add_exec(bContext *C, wmOperator *op)
   PropertyRNA *prop_location = RNA_struct_find_property(op->ptr, "location");
 
   const short id_type = RNA_property_enum_get(op->ptr, prop_type);
-  id = WM_operator_properties_id_lookup_from_name_or_session_uuid(
-      bmain, op->ptr, (ID_Type)id_type);
+  id = WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, (ID_Type)id_type);
   if (id == nullptr) {
     return OPERATOR_CANCELLED;
   }
@@ -4055,7 +4054,7 @@ static int object_add_named_exec(bContext *C, wmOperator *op)
   /* Find object, create fake base. */
 
   Object *ob = reinterpret_cast<Object *>(
-      WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_OB));
+      WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_OB));
 
   if (ob == nullptr) {
     BKE_report(op->reports, RPT_ERROR, "Object not found");
@@ -4169,7 +4168,7 @@ static int object_transform_to_mouse_exec(bContext *C, wmOperator *op)
   ViewLayer *view_layer = CTX_data_view_layer(C);
 
   Object *ob = reinterpret_cast<Object *>(
-      WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_OB));
+      WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_OB));
 
   if (!ob) {
     BKE_view_layer_synced_ensure(scene, view_layer);
@@ -4257,10 +4256,10 @@ void OBJECT_OT_transform_to_mouse(wmOperatorType *ot)
       nullptr,
       MAX_ID_NAME - 2,
       "Name",
-      "Object name to place (uses the active object when this and 'session_uuid' are unset)");
+      "Object name to place (uses the active object when this and 'session_uid' are unset)");
   RNA_def_property_flag(prop, (PropertyFlag)(PROP_SKIP_SAVE | PROP_HIDDEN));
   prop = RNA_def_int(ot->srna,
-                     "session_uuid",
+                     "session_uid",
                      0,
                      INT32_MIN,
                      INT32_MAX,
diff --git a/source/blender/editors/object/object_bake_simulation.cc b/source/blender/editors/object/object_bake_simulation.cc
index df93a2bf6be..980d809cddf 100644
--- a/source/blender/editors/object/object_bake_simulation.cc
+++ b/source/blender/editors/object/object_bake_simulation.cc
@@ -778,7 +778,7 @@ static Vector<NodeBakeRequest> bake_single_node_gather_bake_request(bContext *C,
   Main *bmain = CTX_data_main(C);
   Scene *scene = CTX_data_scene(C);
   Object *object = reinterpret_cast<Object *>(
-      WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_OB));
+      WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_OB));
   if (object == nullptr) {
     return {};
   }
@@ -890,7 +890,7 @@ static int delete_single_bake_exec(bContext *C, wmOperator *op)
 {
   Main *bmain = CTX_data_main(C);
   Object *object = reinterpret_cast<Object *>(
-      WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_OB));
+      WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_OB));
   if (object == nullptr) {
     return OPERATOR_CANCELLED;
   }
diff --git a/source/blender/editors/object/object_relations.cc b/source/blender/editors/object/object_relations.cc
index fab99fd2969..c5fa500ff56 100644
--- a/source/blender/editors/object/object_relations.cc
+++ b/source/blender/editors/object/object_relations.cc
@@ -2384,8 +2384,8 @@ static int make_override_library_exec(bContext *C, wmOperator *op)
   }
   else if (!make_override_library_object_overridable_check(bmain, obact)) {
     const int i = RNA_property_int_get(op->ptr, op->type->prop);
-    const uint collection_session_uuid = *((const uint *)&i);
-    if (collection_session_uuid == MAIN_ID_SESSION_UUID_UNSET) {
+    const uint collection_session_uid = *((const uint *)&i);
+    if (collection_session_uid == MAIN_ID_SESSION_UID_UNSET) {
       BKE_reportf(op->reports,
                   RPT_ERROR_INVALID_INPUT,
                   "Could not find an overridable root hierarchy for object '%s'",
@@ -2394,9 +2394,9 @@ static int make_override_library_exec(bContext *C, wmOperator *op)
     }
     Collection *collection = static_cast<Collection *>(
         BLI_listbase_bytes_find(&bmain->collections,
-                                &collection_session_uuid,
-                                sizeof(collection_session_uuid),
-                                offsetof(ID, session_uuid)));
+                                &collection_session_uid,
+                                sizeof(collection_session_uid),
+                                offsetof(ID, session_uid)));
     id_root = &collection->id;
     user_overrides_from_selected_objects = true;
   }
@@ -2441,7 +2441,7 @@ static int make_override_library_exec(bContext *C, wmOperator *op)
   else if (user_overrides_from_selected_objects) {
     /* Only selected objects can be 'user overrides'. */
     FOREACH_SELECTED_OBJECT_BEGIN (view_layer, CTX_wm_view3d(C), ob_iter) {
-      BLI_gset_add(user_overrides_objects_uids, POINTER_FROM_UINT(ob_iter->id.session_uuid));
+      BLI_gset_add(user_overrides_objects_uids, POINTER_FROM_UINT(ob_iter->id.session_uid));
     }
     FOREACH_SELECTED_OBJECT_END;
   }
@@ -2449,7 +2449,7 @@ static int make_override_library_exec(bContext *C, wmOperator *op)
     /* Only armatures inside the root collection (and their children) can be 'user overrides'. */
     FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN ((Collection *)id_root, ob_iter) {
       if (ob_iter->type == OB_ARMATURE) {
-        BLI_gset_add(user_overrides_objects_uids, POINTER_FROM_UINT(ob_iter->id.session_uuid));
+        BLI_gset_add(user_overrides_objects_uids, POINTER_FROM_UINT(ob_iter->id.session_uid));
       }
     }
     FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
@@ -2467,7 +2467,7 @@ static int make_override_library_exec(bContext *C, wmOperator *op)
       }
       LISTBASE_FOREACH (CollectionObject *, coll_ob_iter, &coll_iter->gobject) {
         if (BLI_gset_haskey(user_overrides_objects_uids,
-                            POINTER_FROM_UINT(coll_ob_iter->ob->id.session_uuid)))
+                            POINTER_FROM_UINT(coll_ob_iter->ob->id.session_uid)))
         {
           /* Tag for remapping when creating overrides. */
           coll_iter->id.tag |= LIB_TAG_DOIT;
@@ -2499,7 +2499,7 @@ static int make_override_library_exec(bContext *C, wmOperator *op)
         continue;
       }
       if (BLI_gset_haskey(user_overrides_objects_uids,
-                          POINTER_FROM_UINT(id_iter->override_library->reference->session_uuid)))
+                          POINTER_FROM_UINT(id_iter->override_library->reference->session_uid)))
       {
         id_iter->override_library->flag &= ~LIBOVERRIDE_FLAG_SYSTEM_DEFINED;
       }
@@ -2627,12 +2627,12 @@ static int make_override_library_invoke(bContext *C, wmOperator *op, const wmEve
   }
 
   if (potential_root_collections.is_empty()) {
-    RNA_property_int_set(op->ptr, op->type->prop, MAIN_ID_SESSION_UUID_UNSET);
+    RNA_property_int_set(op->ptr, op->type->prop, MAIN_ID_SESSION_UID_UNSET);
     return make_override_library_exec(C, op);
   }
   if (potential_root_collections.size() == 1) {
     Collection *collection_root = potential_root_collections.pop();
-    RNA_property_int_set(op->ptr, op->type->prop, *((int *)&collection_root->id.session_uuid));
+    RNA_property_int_set(op->ptr, op->type->prop, *((int *)&collection_root->id.session_uid));
     return make_override_library_exec(C, op);
   }
 
@@ -2677,11 +2677,11 @@ void OBJECT_OT_make_override_library(wmOperatorType *ot)
   PropertyRNA *prop;
   prop = RNA_def_int(ot->srna,
                      "collection",
-                     MAIN_ID_SESSION_UUID_UNSET,
+                     MAIN_ID_SESSION_UID_UNSET,
                      INT_MIN,
                      INT_MAX,
                      "Override Collection",
-                     "Session UUID of the directly linked collection containing the selected "
+                     "Session UID of the directly linked collection containing the selected "
                      "object, to make an override from",
                      INT_MIN,
                      INT_MAX);
@@ -2957,7 +2957,7 @@ static int drop_named_material_invoke(bContext *C, wmOperator *op, const wmEvent
   Object *ob = ED_view3d_give_material_slot_under_cursor(C, event->mval, &mat_slot);
   mat_slot = max_ii(mat_slot, 1);
 
-  Material *ma = (Material *)WM_operator_properties_id_lookup_from_name_or_session_uuid(
+  Material *ma = (Material *)WM_operator_properties_id_lookup_from_name_or_session_uid(
       bmain, op->ptr, ID_MA);
 
   if (ob == nullptr || ma == nullptr) {
@@ -3007,8 +3007,8 @@ std::string ED_object_ot_drop_geometry_nodes_tooltip(bContext *C,
     return {};
   }
 
-  const uint32_t session_uuid = RNA_int_get(properties, "session_uuid");
-  const ID *id = BKE_libblock_find_session_uuid(CTX_data_main(C), ID_NT, session_uuid);
+  const uint32_t session_uid = RNA_int_get(properties, "session_uid");
+  const ID *id = BKE_libblock_find_session_uid(CTX_data_main(C), ID_NT, session_uid);
   if (!id) {
     return {};
   }
@@ -3046,8 +3046,8 @@ static int drop_geometry_nodes_invoke(bContext *C, wmOperator *op, const wmEvent
   Main *bmain = CTX_data_main(C);
   Scene *scene = CTX_data_scene(C);
 
-  const uint32_t uuid = RNA_int_get(op->ptr, "session_uuid");
-  bNodeTree *node_tree = (bNodeTree *)BKE_libblock_find_session_uuid(bmain, ID_NT, uuid);
+  const uint32_t uid = RNA_int_get(op->ptr, "session_uid");
+  bNodeTree *node_tree = (bNodeTree *)BKE_libblock_find_session_uid(bmain, ID_NT, uid);
   if (!node_tree) {
     return OPERATOR_CANCELLED;
   }
@@ -3092,12 +3092,12 @@ void OBJECT_OT_drop_geometry_nodes(wmOperatorType *ot)
   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 
   PropertyRNA *prop = RNA_def_int(ot->srna,
-                                  "session_uuid",
+                                  "session_uid",
                                   0,
                                   INT32_MIN,
                                   INT32_MAX,
-                                  "Session UUID",
-                                  "Session UUID of the geometry node group being dropped",
+                                  "Session UID",
+                                  "Session UID of the geometry node group being dropped",
                                   INT32_MIN,
                                   INT32_MAX);
   RNA_def_property_flag(prop, (PropertyFlag)(PROP_HIDDEN | PROP_SKIP_SAVE));
diff --git a/source/blender/editors/space_node/node_add.cc b/source/blender/editors/space_node/node_add.cc
index b6af6260b74..9355480e466 100644
--- a/source/blender/editors/space_node/node_add.cc
+++ b/source/blender/editors/space_node/node_add.cc
@@ -292,7 +292,7 @@ static int node_add_group_exec(bContext *C, wmOperator *op)
   bNodeTree *ntree = snode->edittree;
 
   bNodeTree *node_group = reinterpret_cast<bNodeTree *>(
-      WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_NT));
+      WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_NT));
   if (!node_group) {
     return OPERATOR_CANCELLED;
   }
@@ -511,7 +511,7 @@ static int node_add_object_exec(bContext *C, wmOperator *op)
   bNodeTree *ntree = snode->edittree;
 
   Object *object = reinterpret_cast<Object *>(
-      WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_OB));
+      WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_OB));
 
   if (!object) {
     return OPERATOR_CANCELLED;
@@ -597,7 +597,7 @@ static int node_add_collection_exec(bContext *C, wmOperator *op)
   bNodeTree &ntree = *snode.edittree;
 
   Collection *collection = reinterpret_cast<Collection *>(
-      WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_GR));
+      WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_GR));
 
   if (!collection) {
     return OPERATOR_CANCELLED;
@@ -808,7 +808,7 @@ static int node_add_mask_exec(bContext *C, wmOperator *op)
   Main *bmain = CTX_data_main(C);
   SpaceNode &snode = *CTX_wm_space_node(C);
 
-  ID *mask = WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_MSK);
+  ID *mask = WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_MSK);
   if (!mask) {
     return OPERATOR_CANCELLED;
   }
@@ -861,7 +861,7 @@ static int node_add_material_exec(bContext *C, wmOperator *op)
   bNodeTree *ntree = snode->edittree;
 
   Material *material = reinterpret_cast<Material *>(
-      WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_MA));
+      WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_MA));
 
   if (!material) {
     return OPERATOR_CANCELLED;
diff --git a/source/blender/editors/space_node/space_node.cc b/source/blender/editors/space_node/space_node.cc
index c63920df835..1bfea2c80f7 100644
--- a/source/blender/editors/space_node/space_node.cc
+++ b/source/blender/editors/space_node/space_node.cc
@@ -907,7 +907,7 @@ static void node_group_drop_copy(bContext *C, wmDrag *drag, wmDropBox *drop)
 {
   ID *id = WM_drag_get_local_ID_or_import_from_asset(C, drag, 0);
 
-  RNA_int_set(drop->ptr, "session_uuid", int(id->session_uuid));
+  RNA_int_set(drop->ptr, "session_uid", int(id->session_uid));
 
   RNA_boolean_set(drop->ptr, "show_datablock_in_node", (drag->type != WM_DRAG_ASSET));
 }
@@ -916,7 +916,7 @@ static void node_id_drop_copy(bContext *C, wmDrag *drag, wmDropBox *drop)
 {
   ID *id = WM_drag_get_local_ID_or_import_from_asset(C, drag, 0);
 
-  RNA_int_set(drop->ptr, "session_uuid", int(id->session_uuid));
+  RNA_int_set(drop->ptr, "session_uid", int(id->session_uid));
 }
 
 static void node_id_path_drop_copy(bContext *C, wmDrag *drag, wmDropBox *drop)
@@ -924,7 +924,7 @@ static void node_id_path_drop_copy(bContext *C, wmDrag *drag, wmDropBox *drop)
   ID *id = WM_drag_get_local_ID_or_import_from_asset(C, drag, 0);
 
   if (id) {
-    RNA_int_set(drop->ptr, "session_uuid", int(id->session_uuid));
+    RNA_int_set(drop->ptr, "session_uid", int(id->session_uid));
     RNA_struct_property_unset(drop->ptr, "filepath");
     return;
   }
diff --git a/source/blender/editors/space_outliner/outliner_draw.cc b/source/blender/editors/space_outliner/outliner_draw.cc
index 7a31fe76a41..c71b3754188 100644
--- a/source/blender/editors/space_outliner/outliner_draw.cc
+++ b/source/blender/editors/space_outliner/outliner_draw.cc
@@ -1964,8 +1964,8 @@ static bool outliner_but_identity_cmp_context_id_fn(const uiBut *a, const uiBut
   const ID *id_a = (const ID *)idptr_a->data;
   const ID *id_b = (const ID *)idptr_b->data;
 
-  /* Using session UUID to compare is safer than using the pointer. */
-  return id_a->session_uuid == id_b->session_uuid;
+  /* Using session UID to compare is safer than using the pointer. */
+  return id_a->session_uid == id_b->session_uid;
 }
 
 static void outliner_draw_overrides_restrictbuts(Main *bmain,
diff --git a/source/blender/editors/space_outliner/outliner_tools.cc b/source/blender/editors/space_outliner/outliner_tools.cc
index 54f199cc007..72188001c22 100644
--- a/source/blender/editors/space_outliner/outliner_tools.cc
+++ b/source/blender/editors/space_outliner/outliner_tools.cc
@@ -1056,7 +1056,7 @@ struct OutlinerLibOverrideData {
    * solving broken overrides while not losing *all* of your overrides. */
   bool do_resync_hierarchy_enforce;
 
-  /** A set of the selected tree elements' ID 'uuid'. Used to clear 'system override' flags on
+  /** A set of the selected tree elements' ID 'uid'. Used to clear 'system override' flags on
    * their newly-created liboverrides in post-process step of override hierarchy creation. */
   Set<uint> selected_id_uid;
 
@@ -1067,7 +1067,7 @@ struct OutlinerLibOverrideData {
    * override), or an actual already existing override. */
   Map<ID *, Vector<OutlinerLiboverrideDataIDRoot>> id_hierarchy_roots;
 
-  /** All 'session_uuid' of all hierarchy root IDs used or created by the operation. */
+  /** All 'session_uid' of all hierarchy root IDs used or created by the operation. */
   Set<uint> id_hierarchy_roots_uid;
 
   void id_root_add(ID *id_hierarchy_root_reference,
@@ -1125,10 +1125,10 @@ static void id_override_library_create_hierarchy_pre_process_fn(bContext *C,
 
   /* Only process a given ID once. Otherwise, all kind of weird things can happen if e.g. a
    * selected sub-collection is part of more than one override hierarchies. */
-  if (data->selected_id_uid.contains(id_root_reference->session_uuid)) {
+  if (data->selected_id_uid.contains(id_root_reference->session_uid)) {
     return;
   }
-  data->selected_id_uid.add(id_root_reference->session_uuid);
+  data->selected_id_uid.add(id_root_reference->session_uid);
 
   if (ID_IS_OVERRIDE_LIBRARY_REAL(id_root_reference) && !ID_IS_LINKED(id_root_reference)) {
     id_root_reference->override_library->flag &= ~LIBOVERRIDE_FLAG_SYSTEM_DEFINED;
@@ -1157,7 +1157,7 @@ static void id_override_library_create_hierarchy_pre_process_fn(bContext *C,
     Collection *root_collection = reinterpret_cast<Collection *>(id_root_reference);
     FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (root_collection, object_iter) {
       if (id_root_reference->lib == object_iter->id.lib && object_iter->type == OB_ARMATURE) {
-        data->selected_id_uid.add(object_iter->id.session_uuid);
+        data->selected_id_uid.add(object_iter->id.session_uid);
       }
     }
     FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
@@ -1357,7 +1357,7 @@ static void id_override_library_create_hierarchy(
           BLI_assert(id_hierarchy_root_override == id_hierarchy_root_reference);
         }
         data_idroot.id_hierarchy_root_override = id_hierarchy_root_override;
-        data.id_hierarchy_roots_uid.add(id_hierarchy_root_override->session_uuid);
+        data.id_hierarchy_roots_uid.add(id_hierarchy_root_override->session_uid);
       }
     }
     else if (ID_IS_OVERRIDABLE_LIBRARY(data_idroot.id_root_reference)) {
@@ -1423,12 +1423,12 @@ static void id_override_library_create_hierarchy_process(bContext *C,
     }
     if (id_iter->override_library->hierarchy_root != nullptr &&
         !data.id_hierarchy_roots_uid.contains(
-            id_iter->override_library->hierarchy_root->session_uuid))
+            id_iter->override_library->hierarchy_root->session_uid))
     {
       continue;
     }
-    if (data.selected_id_uid.contains(id_iter->override_library->reference->session_uuid) ||
-        data.selected_id_uid.contains(id_iter->session_uuid))
+    if (data.selected_id_uid.contains(id_iter->override_library->reference->session_uid) ||
+        data.selected_id_uid.contains(id_iter->session_uid))
     {
       id_iter->override_library->flag &= ~LIBOVERRIDE_FLAG_SYSTEM_DEFINED;
     }
diff --git a/source/blender/editors/space_sequencer/sequencer_clipboard.cc b/source/blender/editors/space_sequencer/sequencer_clipboard.cc
index e7070d9859f..d4a62093a21 100644
--- a/source/blender/editors/space_sequencer/sequencer_clipboard.cc
+++ b/source/blender/editors/space_sequencer/sequencer_clipboard.cc
@@ -350,7 +350,7 @@ int sequencer_clipboard_paste_exec(bContext *C, wmOperator *op)
 
   ListBase nseqbase = {nullptr, nullptr};
   /* NOTE: SEQ_sequence_base_dupli_recursive() takes care of generating
-   * new UUIDs for sequences in the new list. */
+   * new UIDs for sequences in the new list. */
   SEQ_sequence_base_dupli_recursive(
       scene_src, scene_dst, &nseqbase, &scene_src->ed->seqbase, 0, 0);
 
diff --git a/source/blender/editors/space_sequencer/sequencer_edit.cc b/source/blender/editors/space_sequencer/sequencer_edit.cc
index a2bab7fd804..2f43aa4aa5f 100644
--- a/source/blender/editors/space_sequencer/sequencer_edit.cc
+++ b/source/blender/editors/space_sequencer/sequencer_edit.cc
@@ -1605,7 +1605,7 @@ static int sequencer_add_duplicate_exec(bContext *C, wmOperator * /*op*/)
   Sequence *seq = static_cast<Sequence *>(duplicated_strips.first);
 
   /* Rely on the `duplicated_strips` list being added at the end.
-   * Their UUIDs has been re-generated by the #SEQ_sequence_base_dupli_recursive(). */
+   * Their UIDs has been re-generated by the #SEQ_sequence_base_dupli_recursive(). */
   BLI_movelisttolist(ed->seqbasep, &duplicated_strips);
 
   /* Handle duplicated strips: set active, select, ensure unique name and duplicate animation
@@ -2004,7 +2004,7 @@ static int sequencer_meta_make_exec(bContext *C, wmOperator *op)
   Sequence *seqm = SEQ_sequence_alloc(active_seqbase, 1, 1, SEQ_TYPE_META);
 
   /* Remove all selected from main list, and put in meta.
-   * Sequence is moved within the same edit, no need to re-generate the UUID. */
+   * Sequence is moved within the same edit, no need to re-generate the UID. */
   LISTBASE_FOREACH_MUTABLE (Sequence *, seq, active_seqbase) {
     if (seq != seqm && seq->flag & SELECT) {
       BLI_remlink(active_seqbase, seq);
@@ -2070,7 +2070,7 @@ static int sequencer_meta_separate_exec(bContext *C, wmOperator * /*op*/)
   }
 
   /* Remove all selected from meta, and put in main list.
-   * Sequence is moved within the same edit, no need to re-generate the UUID. */
+   * Sequence is moved within the same edit, no need to re-generate the UID. */
   BLI_movelisttolist(ed->seqbasep, &active_seq->seqbase);
   BLI_listbase_clear(&active_seq->seqbase);
 
diff --git a/source/blender/editors/space_view3d/space_view3d.cc b/source/blender/editors/space_view3d/space_view3d.cc
index b7c4f67ba69..dcdf237d12c 100644
--- a/source/blender/editors/space_view3d/space_view3d.cc
+++ b/source/blender/editors/space_view3d/space_view3d.cc
@@ -715,9 +715,9 @@ static bool view3d_geometry_nodes_drop_poll(bContext *C, wmDrag *drag, const wmE
       return false;
     }
     if (wmDropBox *drop_box = drag->drop_state.active_dropbox) {
-      const uint32_t uuid = RNA_int_get(drop_box->ptr, "session_uuid");
+      const uint32_t uid = RNA_int_get(drop_box->ptr, "session_uid");
       const bNodeTree *node_tree = reinterpret_cast<const bNodeTree *>(
-          BKE_libblock_find_session_uuid(CTX_data_main(C), ID_NT, uuid));
+          BKE_libblock_find_session_uid(CTX_data_main(C), ID_NT, uid));
       if (node_tree) {
         return node_tree->type == NTREE_GEOMETRY;
       }
@@ -763,7 +763,7 @@ static void view3d_ob_drop_copy_local_id(bContext * /*C*/, wmDrag *drag, wmDropB
 {
   ID *id = WM_drag_get_local_ID(drag, ID_OB);
 
-  RNA_int_set(drop->ptr, "session_uuid", id->session_uuid);
+  RNA_int_set(drop->ptr, "session_uid", id->session_uid);
   /* Don't duplicate ID's which were just imported. Only do that for existing, local IDs. */
   BLI_assert(drag->type != WM_DRAG_ASSET);
 
@@ -797,7 +797,7 @@ static void view3d_ob_drop_copy_external_asset(bContext *C, wmDrag *drag, wmDrop
   DEG_relations_tag_update(CTX_data_main(C));
   WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene);
 
-  RNA_int_set(drop->ptr, "session_uuid", id->session_uuid);
+  RNA_int_set(drop->ptr, "session_uid", id->session_uid);
 
   BKE_view_layer_synced_ensure(scene, view_layer);
   Base *base = BKE_view_layer_base_find(view_layer, (Object *)id);
@@ -821,7 +821,7 @@ static void view3d_ob_drop_copy_external_asset(bContext *C, wmDrag *drag, wmDrop
 static void view3d_collection_drop_copy_local_id(bContext * /*C*/, wmDrag *drag, wmDropBox *drop)
 {
   ID *id = WM_drag_get_local_ID(drag, ID_GR);
-  RNA_int_set(drop->ptr, "session_uuid", int(id->session_uuid));
+  RNA_int_set(drop->ptr, "session_uid", int(id->session_uid));
 }
 
 /* Mostly the same logic as #view3d_ob_drop_copy_external_asset(), just different enough to make
@@ -843,7 +843,7 @@ static void view3d_collection_drop_copy_external_asset(bContext *C, wmDrag *drag
   DEG_relations_tag_update(CTX_data_main(C));
   WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene);
 
-  RNA_int_set(drop->ptr, "session_uuid", int(id->session_uuid));
+  RNA_int_set(drop->ptr, "session_uid", int(id->session_uid));
 
   /* Make an object active, just use the first one in the collection. */
   CollectionObject *cobject = static_cast<CollectionObject *>(collection->gobject.first);
diff --git a/source/blender/editors/space_view3d/view3d_edit.cc b/source/blender/editors/space_view3d/view3d_edit.cc
index 7ed51ba546f..161e0a97b21 100644
--- a/source/blender/editors/space_view3d/view3d_edit.cc
+++ b/source/blender/editors/space_view3d/view3d_edit.cc
@@ -692,7 +692,7 @@ static int drop_world_exec(bContext *C, wmOperator *op)
   Main *bmain = CTX_data_main(C);
   Scene *scene = CTX_data_scene(C);
 
-  World *world = (World *)WM_operator_properties_id_lookup_from_name_or_session_uuid(
+  World *world = (World *)WM_operator_properties_id_lookup_from_name_or_session_uid(
       bmain, op->ptr, ID_WO);
   if (world == nullptr) {
     return OPERATOR_CANCELLED;
diff --git a/source/blender/editors/undo/memfile_undo.cc b/source/blender/editors/undo/memfile_undo.cc
index fa61e8e5d31..afb361ef731 100644
--- a/source/blender/editors/undo/memfile_undo.cc
+++ b/source/blender/editors/undo/memfile_undo.cc
@@ -375,7 +375,7 @@ void ED_undosys_stack_memfile_id_changed_tag(UndoStack *ustack, ID *id)
 
   MemFile *memfile = &((MemFileUndoStep *)us)->data->memfile;
   LISTBASE_FOREACH (MemFileChunk *, mem_chunk, &memfile->chunks) {
-    if (mem_chunk->id_session_uuid == id->session_uuid) {
+    if (mem_chunk->id_session_uid == id->session_uid) {
       mem_chunk->is_identical_future = false;
       break;
     }
diff --git a/source/blender/makesdna/DNA_ID.h b/source/blender/makesdna/DNA_ID.h
index 23ee67b2a84..78f84409ca6 100644
--- a/source/blender/makesdna/DNA_ID.h
+++ b/source/blender/makesdna/DNA_ID.h
@@ -493,7 +493,7 @@ typedef struct ID {
    * A session-wide unique identifier for a given ID, that remain the same across potential
    * re-allocations (e.g. due to undo/redo steps).
    */
-  unsigned int session_uuid;
+  unsigned int session_uid;
 
   IDProperty *properties;
 
@@ -914,7 +914,7 @@ enum {
    * processing, because it is a 'NO_UNDO' type of ID.
    *
    * \note: Also means that such ID does not need to be lib-linked during undo readfile process. It
-   * does need to be relinked in a different way however, doing a `session_uuid`-based lookup into
+   * does need to be relinked in a different way however, doing a `session_uid`-based lookup into
    * the newly read main database.
    *
    * RESET_AFTER_USE
@@ -941,7 +941,7 @@ enum {
    * RESET_NEVER
    *
    * Don't allow assigning this to non-temporary members (since it's likely to cause errors).
-   * When set #ID.session_uuid isn't initialized, since the data isn't part of the session.
+   * When set #ID.session_uid isn't initialized, since the data isn't part of the session.
    */
   LIB_TAG_TEMP_MAIN = 1 << 20,
   /** General ID management info, for freeing or copying behavior e.g. */
diff --git a/source/blender/makesdna/DNA_action_types.h b/source/blender/makesdna/DNA_action_types.h
index 84cf5f62898..b18bf5dd5a6 100644
--- a/source/blender/makesdna/DNA_action_types.h
+++ b/source/blender/makesdna/DNA_action_types.h
@@ -15,7 +15,7 @@
 #include "DNA_ID.h"
 #include "DNA_armature_types.h"
 #include "DNA_listBase.h"
-#include "DNA_session_uuid_types.h"
+#include "DNA_session_uid_types.h"
 #include "DNA_userdef_types.h" /* ThemeWireColor */
 #include "DNA_vec_types.h"
 #include "DNA_view2d_types.h"
@@ -197,7 +197,7 @@ typedef struct bPoseChannel_BBoneSegmentBoundary {
 } bPoseChannel_BBoneSegmentBoundary;
 
 typedef struct bPoseChannel_Runtime {
-  SessionUUID session_uuid;
+  SessionUID session_uid;
 
   /* Cached dual quaternion for deformation. */
   struct DualQuat deform_dual_quat;
diff --git a/source/blender/makesdna/DNA_mesh_types.h b/source/blender/makesdna/DNA_mesh_types.h
index c0e948999a2..ff718c55205 100644
--- a/source/blender/makesdna/DNA_mesh_types.h
+++ b/source/blender/makesdna/DNA_mesh_types.h
@@ -11,7 +11,7 @@
 #include "DNA_ID.h"
 #include "DNA_customdata_types.h"
 #include "DNA_defs.h"
-#include "DNA_session_uuid_types.h"
+#include "DNA_session_uid_types.h"
 
 /** Workaround to forward-declare C++ type in C header. */
 #ifdef __cplusplus
diff --git a/source/blender/makesdna/DNA_modifier_types.h b/source/blender/makesdna/DNA_modifier_types.h
index a22aa241220..9f2f2f6d201 100644
--- a/source/blender/makesdna/DNA_modifier_types.h
+++ b/source/blender/makesdna/DNA_modifier_types.h
@@ -12,7 +12,7 @@
 
 #include "DNA_defs.h"
 #include "DNA_listBase.h"
-#include "DNA_session_uuid_types.h"
+#include "DNA_session_uid_types.h"
 
 #ifdef __cplusplus
 namespace blender {
@@ -138,7 +138,7 @@ typedef struct ModifierData {
   char *error;
 
   /** Runtime field which contains unique identifier of the modifier. */
-  SessionUUID session_uuid;
+  SessionUID session_uid;
 
   /** Runtime field which contains runtime data which is specific to a modifier type. */
   void *runtime;
diff --git a/source/blender/makesdna/DNA_sequence_types.h b/source/blender/makesdna/DNA_sequence_types.h
index f33b2349cc1..4aeed151a02 100644
--- a/source/blender/makesdna/DNA_sequence_types.h
+++ b/source/blender/makesdna/DNA_sequence_types.h
@@ -18,8 +18,8 @@
 #include "DNA_color_types.h"
 #include "DNA_defs.h"
 #include "DNA_listBase.h"
-#include "DNA_session_uuid_types.h" /* for #SessionUUID */
-#include "DNA_vec_types.h"          /* for #rctf */
+#include "DNA_session_uid_types.h" /* for #SessionUID */
+#include "DNA_vec_types.h"         /* for #rctf */
 
 struct Ipo;
 struct MovieClip;
@@ -139,7 +139,7 @@ typedef struct SeqRetimingKey {
 } SeqRetimingKey;
 
 typedef struct SequenceRuntime {
-  SessionUUID session_uuid;
+  SessionUID session_uid;
 } SequenceRuntime;
 
 /**
diff --git a/source/blender/makesdna/DNA_session_uuid_types.h b/source/blender/makesdna/DNA_session_uid_types.h
similarity index 92%
rename from source/blender/makesdna/DNA_session_uuid_types.h
rename to source/blender/makesdna/DNA_session_uid_types.h
index a68dcdb414d..3e3f380f067 100644
--- a/source/blender/makesdna/DNA_session_uuid_types.h
+++ b/source/blender/makesdna/DNA_session_uid_types.h
@@ -17,10 +17,10 @@
  * - It allows to add more bits, more than standard fixed-size types can store. For example, if
  *   we ever need to go 128 bits, it is as simple as adding extra 64bit field.
  */
-typedef struct SessionUUID {
+typedef struct SessionUID {
   /**
    * Never access directly, as it might cause a headache when more bits are needed: if the field
    * is used directly it will not be easy to find all places where partial access is used.
    */
-  uint64_t uuid_;
-} SessionUUID;
+  uint64_t uid_;
+} SessionUID;
diff --git a/source/blender/makesrna/intern/rna_ID.cc b/source/blender/makesrna/intern/rna_ID.cc
index a38c0452fd3..c808e1c0afd 100644
--- a/source/blender/makesrna/intern/rna_ID.cc
+++ b/source/blender/makesrna/intern/rna_ID.cc
@@ -2196,7 +2196,6 @@ static void rna_def_ID(BlenderRNA *brna)
   RNA_def_property_override_flag(prop, PROPOVERRIDE_IGNORE);
 
   prop = RNA_def_property(srna, "session_uid", PROP_INT, PROP_NONE);
-  RNA_def_property_int_sdna(prop, nullptr, "session_uuid");
   RNA_def_property_ui_text(
       prop,
       "Session UID",
diff --git a/source/blender/modifiers/intern/MOD_nodes.cc b/source/blender/modifiers/intern/MOD_nodes.cc
index 933b0723fdf..b403b8cb257 100644
--- a/source/blender/modifiers/intern/MOD_nodes.cc
+++ b/source/blender/modifiers/intern/MOD_nodes.cc
@@ -1565,7 +1565,7 @@ static NodesModifierData *get_modifier_data(Main &bmain,
     return nullptr;
   }
 
-  const Object *object = (Object *)BKE_libblock_find_session_uuid(
+  const Object *object = (Object *)BKE_libblock_find_session_uid(
       &bmain, ID_OB, data.object_session_uid);
   if (object == nullptr) {
     return nullptr;
@@ -1702,7 +1702,7 @@ static void add_attribute_search_button(const bContext &C,
   }
 
   AttributeSearchData *data = MEM_new<AttributeSearchData>(__func__);
-  data->object_session_uid = object->id.session_uuid;
+  data->object_session_uid = object->id.session_uid;
   STRNCPY(data->modifier_name, nmd.modifier.name);
   STRNCPY(data->socket_identifier, socket.identifier);
   data->is_output = is_output;
diff --git a/source/blender/sequencer/SEQ_relations.hh b/source/blender/sequencer/SEQ_relations.hh
index 11234d50085..bd4a8e7c687 100644
--- a/source/blender/sequencer/SEQ_relations.hh
+++ b/source/blender/sequencer/SEQ_relations.hh
@@ -44,14 +44,14 @@ void SEQ_relations_invalidate_cache_in_range(Scene *scene,
  */
 void SEQ_relations_free_all_anim_ibufs(Scene *scene, int timeline_frame);
 /**
- * A debug and development function which checks whether sequences have unique UUIDs.
+ * A debug and development function which checks whether sequences have unique UIDs.
  * Errors will be reported to the console.
  */
-void SEQ_relations_check_uuids_unique_and_report(const Scene *scene);
+void SEQ_relations_check_uids_unique_and_report(const Scene *scene);
 /**
- * Generate new UUID for the given sequence.
+ * Generate new UID for the given sequence.
  */
-void SEQ_relations_session_uuid_generate(Sequence *sequence);
+void SEQ_relations_session_uid_generate(Sequence *sequence);
 
 void SEQ_cache_cleanup(Scene *scene);
 void SEQ_cache_iterate(
diff --git a/source/blender/sequencer/intern/proxy.cc b/source/blender/sequencer/intern/proxy.cc
index 663fa7a83da..de1ae2e2465 100644
--- a/source/blender/sequencer/intern/proxy.cc
+++ b/source/blender/sequencer/intern/proxy.cc
@@ -18,7 +18,7 @@
 #include "BLI_fileops.h"
 #include "BLI_listbase.h"
 #include "BLI_path_util.h"
-#include "BLI_session_uuid.h"
+#include "BLI_session_uid.h"
 #include "BLI_string.h"
 
 #ifdef WIN32
@@ -67,7 +67,7 @@ struct SeqIndexBuildContext {
   Depsgraph *depsgraph;
   Scene *scene;
   Sequence *seq, *orig_seq;
-  SessionUUID orig_seq_uuid;
+  SessionUID orig_seq_uid;
 };
 
 int SEQ_rendersize_to_proxysize(int render_size)
@@ -477,7 +477,7 @@ bool SEQ_proxy_rebuild_context(Main *bmain,
     context->depsgraph = depsgraph;
     context->scene = scene;
     context->orig_seq = seq;
-    context->orig_seq_uuid = seq->runtime.session_uuid;
+    context->orig_seq_uid = seq->runtime.session_uid;
     context->seq = nseq;
 
     context->view_id = i; /* only for images */
diff --git a/source/blender/sequencer/intern/sequencer.cc b/source/blender/sequencer/intern/sequencer.cc
index f133a2e7b9a..00e7c94998f 100644
--- a/source/blender/sequencer/intern/sequencer.cc
+++ b/source/blender/sequencer/intern/sequencer.cc
@@ -155,7 +155,7 @@ Sequence *SEQ_sequence_alloc(ListBase *lb, int timeline_frame, int machine, int
     SEQ_channels_ensure(&seq->channels);
   }
 
-  SEQ_relations_session_uuid_generate(seq);
+  SEQ_relations_session_uid_generate(seq);
 
   return seq;
 }
@@ -488,7 +488,7 @@ static Sequence *seq_dupli(const Scene *scene_src,
   Sequence *seqn = static_cast<Sequence *>(MEM_dupallocN(seq));
 
   if ((flag & LIB_ID_CREATE_NO_MAIN) == 0) {
-    SEQ_relations_session_uuid_generate(seqn);
+    SEQ_relations_session_uid_generate(seqn);
   }
 
   seq->tmp = seqn;
@@ -788,8 +788,8 @@ static bool seq_read_data_cb(Sequence *seq, void *user_data)
   BLI_listbase_clear(&seq->anims);
   seq->flag &= ~SEQ_FLAG_SKIP_THUMBNAILS;
 
-  /* Do as early as possible, so that other parts of reading can rely on valid session UUID. */
-  SEQ_relations_session_uuid_generate(seq);
+  /* Do as early as possible, so that other parts of reading can rely on valid session UID. */
+  SEQ_relations_session_uid_generate(seq);
 
   BLO_read_data_address(reader, &seq->seq1);
   BLO_read_data_address(reader, &seq->seq2);
diff --git a/source/blender/sequencer/intern/strip_relations.cc b/source/blender/sequencer/intern/strip_relations.cc
index a9e7a633214..58d0c1d5415 100644
--- a/source/blender/sequencer/intern/strip_relations.cc
+++ b/source/blender/sequencer/intern/strip_relations.cc
@@ -14,7 +14,7 @@
 #include "BLI_ghash.h"
 #include "BLI_listbase.h"
 #include "BLI_math_base.h"
-#include "BLI_session_uuid.h"
+#include "BLI_session_uid.h"
 
 #include "BKE_main.hh"
 #include "BKE_report.h"
@@ -408,41 +408,41 @@ void SEQ_relations_sequence_free_anim(Sequence *seq)
   BLI_listbase_clear(&seq->anims);
 }
 
-void SEQ_relations_session_uuid_generate(Sequence *sequence)
+void SEQ_relations_session_uid_generate(Sequence *sequence)
 {
-  sequence->runtime.session_uuid = BLI_session_uuid_generate();
+  sequence->runtime.session_uid = BLI_session_uid_generate();
 }
 
-static bool get_uuids_cb(Sequence *seq, void *user_data)
+static bool get_uids_cb(Sequence *seq, void *user_data)
 {
-  GSet *used_uuids = (GSet *)user_data;
-  const SessionUUID *session_uuid = &seq->runtime.session_uuid;
-  if (!BLI_session_uuid_is_generated(session_uuid)) {
-    printf("Sequence %s does not have UUID generated.\n", seq->name);
+  GSet *used_uids = (GSet *)user_data;
+  const SessionUID *session_uid = &seq->runtime.session_uid;
+  if (!BLI_session_uid_is_generated(session_uid)) {
+    printf("Sequence %s does not have UID generated.\n", seq->name);
     return true;
   }
 
-  if (BLI_gset_lookup(used_uuids, session_uuid) != nullptr) {
-    printf("Sequence %s has duplicate UUID generated.\n", seq->name);
+  if (BLI_gset_lookup(used_uids, session_uid) != nullptr) {
+    printf("Sequence %s has duplicate UID generated.\n", seq->name);
     return true;
   }
 
-  BLI_gset_insert(used_uuids, (void *)session_uuid);
+  BLI_gset_insert(used_uids, (void *)session_uid);
   return true;
 }
 
-void SEQ_relations_check_uuids_unique_and_report(const Scene *scene)
+void SEQ_relations_check_uids_unique_and_report(const Scene *scene)
 {
   if (scene->ed == nullptr) {
     return;
   }
 
-  GSet *used_uuids = BLI_gset_new(
-      BLI_session_uuid_ghash_hash, BLI_session_uuid_ghash_compare, "sequencer used uuids");
+  GSet *used_uids = BLI_gset_new(
+      BLI_session_uid_ghash_hash, BLI_session_uid_ghash_compare, "sequencer used uids");
 
-  SEQ_for_each_callback(&scene->ed->seqbase, get_uuids_cb, used_uuids);
+  SEQ_for_each_callback(&scene->ed->seqbase, get_uids_cb, used_uids);
 
-  BLI_gset_free(used_uuids, nullptr);
+  BLI_gset_free(used_uids, nullptr);
 }
 
 Sequence *SEQ_find_metastrip_by_sequence(ListBase *seqbase, Sequence *meta, Sequence *seq)
diff --git a/source/blender/windowmanager/WM_api.hh b/source/blender/windowmanager/WM_api.hh
index eb3a0a902c4..c2df28cdea3 100644
--- a/source/blender/windowmanager/WM_api.hh
+++ b/source/blender/windowmanager/WM_api.hh
@@ -901,33 +901,33 @@ void WM_operator_properties_filesel(wmOperatorType *ot,
                                     short sort);
 
 /**
- * Tries to pass \a id to an operator via either a "session_uuid" or a "name" property defined in
+ * Tries to pass \a id to an operator via either a "session_uid" or a "name" property defined in
  * the properties of \a ptr. The former is preferred, since it works properly with linking and
  * library overrides (which may both result in multiple IDs with the same name and type).
  *
  * Also see #WM_operator_properties_id_lookup() and
- * #WM_operator_properties_id_lookup_from_name_or_session_uuid()
+ * #WM_operator_properties_id_lookup_from_name_or_session_uid()
  */
 void WM_operator_properties_id_lookup_set_from_id(PointerRNA *ptr, const ID *id);
 /**
- * Tries to find an ID in \a bmain. There needs to be either a "session_uuid" int or "name" string
+ * Tries to find an ID in \a bmain. There needs to be either a "session_uid" int or "name" string
  * property defined and set. The former has priority. See #WM_operator_properties_id_lookup() for a
  * helper to add the properties.
  */
-ID *WM_operator_properties_id_lookup_from_name_or_session_uuid(Main *bmain,
-                                                               PointerRNA *ptr,
-                                                               enum ID_Type type);
+ID *WM_operator_properties_id_lookup_from_name_or_session_uid(Main *bmain,
+                                                              PointerRNA *ptr,
+                                                              enum ID_Type type);
 /**
- * Check if either the "session_uuid" or "name" property is set inside \a ptr. If this is the case
- * the ID can be looked up by #WM_operator_properties_id_lookup_from_name_or_session_uuid().
+ * Check if either the "session_uid" or "name" property is set inside \a ptr. If this is the case
+ * the ID can be looked up by #WM_operator_properties_id_lookup_from_name_or_session_uid().
  */
 bool WM_operator_properties_id_lookup_is_set(PointerRNA *ptr);
 /**
- * Adds "name" and "session_uuid" properties so the caller can tell the operator which ID to act
- * on. See #WM_operator_properties_id_lookup_from_name_or_session_uuid(). Both properties will be
+ * Adds "name" and "session_uid" properties so the caller can tell the operator which ID to act
+ * on. See #WM_operator_properties_id_lookup_from_name_or_session_uid(). Both properties will be
  * hidden in the UI and not be saved over consecutive operator calls.
  *
- * \note New operators should probably use "session_uuid" only (set \a add_name_prop to #false),
+ * \note New operators should probably use "session_uid" only (set \a add_name_prop to #false),
  * since this works properly with linked data and/or library overrides (in both cases, multiple IDs
  * with the same name and type may be present). The "name" property is only kept to not break
  * compatibility with old scripts using some previously existing operators.
diff --git a/source/blender/windowmanager/intern/wm_dragdrop.cc b/source/blender/windowmanager/intern/wm_dragdrop.cc
index e975498891d..2c6b3296862 100644
--- a/source/blender/windowmanager/intern/wm_dragdrop.cc
+++ b/source/blender/windowmanager/intern/wm_dragdrop.cc
@@ -782,9 +782,9 @@ void WM_drag_free_imported_drag_ID(Main *bmain, wmDrag *drag, wmDropBox *drop)
   }
 
   ID_Type asset_id_type = asset_drag->asset->get_id_type();
-  /* Try to find the imported ID. For this to work either a "session_uuid" or "name" property must
+  /* Try to find the imported ID. For this to work either a "session_uid" or "name" property must
    * have been defined (see #WM_operator_properties_id_lookup()). */
-  ID *id = WM_operator_properties_id_lookup_from_name_or_session_uuid(
+  ID *id = WM_operator_properties_id_lookup_from_name_or_session_uid(
       bmain, drop->ptr, asset_id_type);
   if (id != nullptr) {
     /* Do not delete the dragged ID if it has any user, otherwise if it is a 're-used' ID it will
diff --git a/source/blender/windowmanager/intern/wm_operator_props.cc b/source/blender/windowmanager/intern/wm_operator_props.cc
index 3f1faba68f9..f7096c7f697 100644
--- a/source/blender/windowmanager/intern/wm_operator_props.cc
+++ b/source/blender/windowmanager/intern/wm_operator_props.cc
@@ -228,11 +228,11 @@ void WM_operator_properties_filesel(wmOperatorType *ot,
 
 void WM_operator_properties_id_lookup_set_from_id(PointerRNA *ptr, const ID *id)
 {
-  PropertyRNA *prop_session_uuid = RNA_struct_find_property(ptr, "session_uuid");
+  PropertyRNA *prop_session_uid = RNA_struct_find_property(ptr, "session_uid");
   PropertyRNA *prop_name = RNA_struct_find_property(ptr, "name");
 
-  if (prop_session_uuid) {
-    RNA_int_set(ptr, "session_uuid", int(id->session_uuid));
+  if (prop_session_uid) {
+    RNA_int_set(ptr, "session_uid", int(id->session_uid));
   }
   else if (prop_name) {
     RNA_string_set(ptr, "name", id->name + 2);
@@ -242,14 +242,14 @@ void WM_operator_properties_id_lookup_set_from_id(PointerRNA *ptr, const ID *id)
   }
 }
 
-ID *WM_operator_properties_id_lookup_from_name_or_session_uuid(Main *bmain,
-                                                               PointerRNA *ptr,
-                                                               const ID_Type type)
+ID *WM_operator_properties_id_lookup_from_name_or_session_uid(Main *bmain,
+                                                              PointerRNA *ptr,
+                                                              const ID_Type type)
 {
-  PropertyRNA *prop_session_uuid = RNA_struct_find_property(ptr, "session_uuid");
-  if (prop_session_uuid && RNA_property_is_set(ptr, prop_session_uuid)) {
-    const uint32_t session_uuid = uint32_t(RNA_property_int_get(ptr, prop_session_uuid));
-    return BKE_libblock_find_session_uuid(bmain, type, session_uuid);
+  PropertyRNA *prop_session_uid = RNA_struct_find_property(ptr, "session_uid");
+  if (prop_session_uid && RNA_property_is_set(ptr, prop_session_uid)) {
+    const uint32_t session_uid = uint32_t(RNA_property_int_get(ptr, prop_session_uid));
+    return BKE_libblock_find_session_uid(bmain, type, session_uid);
   }
 
   PropertyRNA *prop_name = RNA_struct_find_property(ptr, "name");
@@ -264,8 +264,7 @@ ID *WM_operator_properties_id_lookup_from_name_or_session_uuid(Main *bmain,
 
 bool WM_operator_properties_id_lookup_is_set(PointerRNA *ptr)
 {
-  return RNA_struct_property_is_set(ptr, "session_uuid") ||
-         RNA_struct_property_is_set(ptr, "name");
+  return RNA_struct_property_is_set(ptr, "session_uid") || RNA_struct_property_is_set(ptr, "name");
 }
 
 void WM_operator_properties_id_lookup(wmOperatorType *ot, const bool add_name_prop)
@@ -283,12 +282,12 @@ void WM_operator_properties_id_lookup(wmOperatorType *ot, const bool add_name_pr
   }
 
   prop = RNA_def_int(ot->srna,
-                     "session_uuid",
+                     "session_uid",
                      0,
                      INT32_MIN,
                      INT32_MAX,
-                     "Session UUID",
-                     "Session UUID of the data-block to use by the operator",
+                     "Session UID",
+                     "Session UID of the data-block to use by the operator",
                      INT32_MIN,
                      INT32_MAX);
   RNA_def_property_flag(prop, (PropertyFlag)(PROP_SKIP_SAVE | PROP_HIDDEN));
diff --git a/source/blender/windowmanager/intern/wm_operators.cc b/source/blender/windowmanager/intern/wm_operators.cc
index 3bfd88cdbcc..4d2e1d66dfc 100644
--- a/source/blender/windowmanager/intern/wm_operators.cc
+++ b/source/blender/windowmanager/intern/wm_operators.cc
@@ -1564,7 +1564,7 @@ ID *WM_operator_drop_load_path(bContext *C, wmOperator *op, const short idcode)
   }
 
   /* Lookup an already existing ID. */
-  id = WM_operator_properties_id_lookup_from_name_or_session_uuid(bmain, op->ptr, ID_Type(idcode));
+  id = WM_operator_properties_id_lookup_from_name_or_session_uid(bmain, op->ptr, ID_Type(idcode));
 
   if (!id) {
     /* Print error with the name if the name is available. */
diff --git a/source/creator/creator_args.cc b/source/creator/creator_args.cc
index da26e3bc45c..43d89cdf32b 100644
--- a/source/creator/creator_args.cc
+++ b/source/creator/creator_args.cc
@@ -659,7 +659,7 @@ static void print_help(bArgs *ba, bool all)
   BLI_args_print_arg_doc(ba, "--debug-depsgraph-no-threads");
   BLI_args_print_arg_doc(ba, "--debug-depsgraph-time");
   BLI_args_print_arg_doc(ba, "--debug-depsgraph-pretty");
-  BLI_args_print_arg_doc(ba, "--debug-depsgraph-uuid");
+  BLI_args_print_arg_doc(ba, "--debug-depsgraph-uid");
   BLI_args_print_arg_doc(ba, "--debug-ghost");
   BLI_args_print_arg_doc(ba, "--debug-wintab");
   BLI_args_print_arg_doc(ba, "--debug-gpu");
@@ -1107,7 +1107,7 @@ static const char arg_handle_debug_mode_generic_set_doc_depsgraph_no_threads[] =
 static const char arg_handle_debug_mode_generic_set_doc_depsgraph_pretty[] =
     "\n\t"
     "Enable colors for dependency graph debug messages.";
-static const char arg_handle_debug_mode_generic_set_doc_depsgraph_uuid[] =
+static const char arg_handle_debug_mode_generic_set_doc_depsgraph_uid[] =
     "\n\t"
     "Verify validness of session-wide identifiers assigned to ID datablocks.";
 static const char arg_handle_debug_mode_generic_set_doc_gpu_force_workarounds[] =
@@ -2461,9 +2461,9 @@ void main_args_setup(bContext *C, bArgs *ba, bool all)
                (void *)G_DEBUG_DEPSGRAPH_PRETTY);
   BLI_args_add(ba,
                nullptr,
-               "--debug-depsgraph-uuid",
-               CB_EX(arg_handle_debug_mode_generic_set, depsgraph_uuid),
-               (void *)G_DEBUG_DEPSGRAPH_UUID);
+               "--debug-depsgraph-uid",
+               CB_EX(arg_handle_debug_mode_generic_set, depsgraph_uid),
+               (void *)G_DEBUG_DEPSGRAPH_UID);
   BLI_args_add(ba,
                nullptr,
                "--debug-gpu-force-workarounds",