Merge branch 'master' into temp-geometry-nodes-fields-prototype

165 files changed, 2021 insertions, 1704 deletions

diff --git a/extern/audaspace/plugins/pulseaudio/PulseAudioDevice.cpp b/extern/audaspace/plugins/pulseaudio/PulseAudioDevice.cpp
index cbfb5e96e6c..bf3fad82620 100644
--- a/extern/audaspace/plugins/pulseaudio/PulseAudioDevice.cpp
+++ b/extern/audaspace/plugins/pulseaudio/PulseAudioDevice.cpp
@@ -32,17 +32,24 @@ void PulseAudioDevice::PulseAudio_state_callback(pa_context *context, void *data
 	device->m_state = AUD_pa_context_get_state(context);
 }
 
-void PulseAudioDevice::PulseAudio_request(pa_stream *stream, size_t num_bytes, void *data)
+void PulseAudioDevice::PulseAudio_request(pa_stream *stream, size_t total_bytes, void *data)
 {
 	PulseAudioDevice* device = (PulseAudioDevice*)data;
 
 	void* buffer;
 
-	AUD_pa_stream_begin_write(stream, &buffer, &num_bytes);
+	while(total_bytes > 0)
+	{
+		size_t num_bytes = total_bytes;
+
+		AUD_pa_stream_begin_write(stream, &buffer, &num_bytes);
+
+		device->mix((data_t*)buffer, num_bytes / AUD_DEVICE_SAMPLE_SIZE(device->m_specs));
 
-	device->mix((data_t*)buffer, num_bytes / AUD_DEVICE_SAMPLE_SIZE(device->m_specs));
+		AUD_pa_stream_write(stream, buffer, num_bytes, nullptr, 0, PA_SEEK_RELATIVE);
 
-	AUD_pa_stream_write(stream, buffer, num_bytes, nullptr, 0, PA_SEEK_RELATIVE);
+		total_bytes -= num_bytes;
+	}
 }
 
 void PulseAudioDevice::PulseAudio_underflow(pa_stream *stream, void *data)
@@ -96,7 +103,6 @@ void PulseAudioDevice::runMixingThread()
 
 PulseAudioDevice::PulseAudioDevice(std::string name, DeviceSpecs specs, int buffersize) :
 	m_state(PA_CONTEXT_UNCONNECTED),
-	m_buffersize(buffersize),
 	m_underflows(0)
 {
 	m_mainloop = AUD_pa_mainloop_new();
@@ -187,6 +193,9 @@ PulseAudioDevice::PulseAudioDevice(std::string name, DeviceSpecs specs, int buff
 	AUD_pa_stream_set_write_callback(m_stream, PulseAudio_request, this);
 	AUD_pa_stream_set_underflow_callback(m_stream, PulseAudio_underflow, this);
 
+	buffersize *= AUD_DEVICE_SAMPLE_SIZE(m_specs);
+	m_buffersize = buffersize;
+
 	pa_buffer_attr buffer_attr;
 
 	buffer_attr.fragsize = -1U;
diff --git a/extern/audaspace/plugins/pulseaudio/PulseAudioDevice.h b/extern/audaspace/plugins/pulseaudio/PulseAudioDevice.h
index be34cc9032b..45b813a5755 100644
--- a/extern/audaspace/plugins/pulseaudio/PulseAudioDevice.h
+++ b/extern/audaspace/plugins/pulseaudio/PulseAudioDevice.h
@@ -59,7 +59,7 @@ private:
 	 * \param num_bytes The length in bytes to be supplied.
 	 * \param data The PulseAudio device.
 	 */
-	AUD_LOCAL static void PulseAudio_request(pa_stream* stream, size_t num_bytes, void* data);
+	AUD_LOCAL static void PulseAudio_request(pa_stream* stream, size_t total_bytes, void* data);
 
 	/**
 	 * Reports an underflow from the PulseAudio server.
diff --git a/intern/cycles/blender/CMakeLists.txt b/intern/cycles/blender/CMakeLists.txt
index 2d48563d8a6..ee5c6157338 100644
--- a/intern/cycles/blender/CMakeLists.txt
+++ b/intern/cycles/blender/CMakeLists.txt
@@ -115,6 +115,16 @@ if(WITH_OPENVDB)
   )
 endif()
 
+if(WITH_ALEMBIC)
+  add_definitions(-DWITH_ALEMBIC)
+  list(APPEND INC_SYS
+    ${ALEMBIC_INCLUDE_DIRS}
+  )
+  list(APPEND LIB
+    ${ALEMBIC_LIBRARIES}
+  )
+endif()
+
 if(WITH_OPENIMAGEDENOISE)
   add_definitions(-DWITH_OPENIMAGEDENOISE)
   list(APPEND INC_SYS
diff --git a/intern/cycles/blender/addon/__init__.py b/intern/cycles/blender/addon/__init__.py
index 10b95133912..f728050a3cf 100644
--- a/intern/cycles/blender/addon/__init__.py
+++ b/intern/cycles/blender/addon/__init__.py
@@ -61,6 +61,7 @@ class CyclesRender(bpy.types.RenderEngine):
     bl_use_save_buffers = True
     bl_use_spherical_stereo = True
     bl_use_custom_freestyle = True
+    bl_use_alembic_procedural = True
 
     def __init__(self):
         self.session = None
diff --git a/intern/cycles/blender/addon/properties.py b/intern/cycles/blender/addon/properties.py
index 124223635d1..ac0aca57028 100644
--- a/intern/cycles/blender/addon/properties.py
+++ b/intern/cycles/blender/addon/properties.py
@@ -227,6 +227,11 @@ def update_render_passes(self, context):
     view_layer.update_render_passes()
 
 
+def update_render_engine(self, context):
+    scene = context.scene
+    scene.update_render_engine()
+
+
 class CyclesRenderSettings(bpy.types.PropertyGroup):
 
     device: EnumProperty(
@@ -240,6 +245,7 @@ class CyclesRenderSettings(bpy.types.PropertyGroup):
         description="Feature set to use for rendering",
         items=enum_feature_set,
         default='SUPPORTED',
+        update=update_render_engine,
     )
     shading_system: BoolProperty(
         name="Open Shading Language",
diff --git a/intern/cycles/blender/blender_mesh.cpp b/intern/cycles/blender/blender_mesh.cpp
index ecadc78cbbf..ebba6981502 100644
--- a/intern/cycles/blender/blender_mesh.cpp
+++ b/intern/cycles/blender/blender_mesh.cpp
@@ -1038,23 +1038,6 @@ static void create_subd_mesh(Scene *scene,
 
 /* Sync */
 
-static BL::MeshSequenceCacheModifier object_mesh_cache_find(BL::Object &b_ob)
-{
-  if (b_ob.modifiers.length() > 0) {
-    BL::Modifier b_mod = b_ob.modifiers[b_ob.modifiers.length() - 1];
-
-    if (b_mod.type() == BL::Modifier::type_MESH_SEQUENCE_CACHE) {
-      BL::MeshSequenceCacheModifier mesh_cache = BL::MeshSequenceCacheModifier(b_mod);
-
-      if (MeshSequenceCacheModifier_has_velocity_get(&mesh_cache.ptr)) {
-        return mesh_cache;
-      }
-    }
-  }
-
-  return BL::MeshSequenceCacheModifier(PointerRNA_NULL);
-}
-
 /* Check whether some of "built-in" motion-related attributes are needed to be exported (includes
  * things like velocity from cache modifier, fluid simulation).
  *
@@ -1095,7 +1078,7 @@ static void sync_mesh_cached_velocities(BL::Object &b_ob, Scene *scene, Mesh *me
     return;
   }
 
-  BL::MeshSequenceCacheModifier b_mesh_cache = object_mesh_cache_find(b_ob);
+  BL::MeshSequenceCacheModifier b_mesh_cache = object_mesh_cache_find(b_ob, true, nullptr);
 
   if (!b_mesh_cache) {
     return;
@@ -1258,7 +1241,7 @@ void BlenderSync::sync_mesh_motion(BL::Depsgraph b_depsgraph,
   }
 
   /* Cached motion blur already exported. */
-  BL::MeshSequenceCacheModifier mesh_cache = object_mesh_cache_find(b_ob);
+  BL::MeshSequenceCacheModifier mesh_cache = object_mesh_cache_find(b_ob, true, nullptr);
   if (mesh_cache) {
     return;
   }
diff --git a/intern/cycles/blender/blender_object.cpp b/intern/cycles/blender/blender_object.cpp
index 4711e0cbe76..2dbebac4cc3 100644
--- a/intern/cycles/blender/blender_object.cpp
+++ b/intern/cycles/blender/blender_object.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "render/alembic.h"
 #include "render/camera.h"
 #include "render/graph.h"
 #include "render/integrator.h"
@@ -484,6 +485,68 @@ bool BlenderSync::sync_object_attributes(BL::DepsgraphObjectInstance &b_instance
 
 /* Object Loop */
 
+void BlenderSync::sync_procedural(BL::Object &b_ob,
+                                  BL::MeshSequenceCacheModifier &b_mesh_cache,
+                                  bool has_subdivision_modifier)
+{
+#ifdef WITH_ALEMBIC
+  BL::CacheFile cache_file = b_mesh_cache.cache_file();
+  void *cache_file_key = cache_file.ptr.data;
+
+  AlembicProcedural *procedural = static_cast<AlembicProcedural *>(
+      procedural_map.find(cache_file_key));
+
+  if (procedural == nullptr) {
+    procedural = scene->create_node<AlembicProcedural>();
+    procedural_map.add(cache_file_key, procedural);
+  }
+  else {
+    procedural_map.used(procedural);
+  }
+
+  float current_frame = b_scene.frame_current();
+  if (cache_file.override_frame()) {
+    current_frame = cache_file.frame();
+  }
+
+  if (!cache_file.override_frame()) {
+    procedural->set_start_frame(b_scene.frame_start());
+    procedural->set_end_frame(b_scene.frame_end());
+  }
+
+  procedural->set_frame(current_frame);
+  procedural->set_frame_rate(b_scene.render().fps() / b_scene.render().fps_base());
+  procedural->set_frame_offset(cache_file.frame_offset());
+
+  string absolute_path = blender_absolute_path(b_data, b_ob, b_mesh_cache.cache_file().filepath());
+  procedural->set_filepath(ustring(absolute_path));
+
+  procedural->set_scale(cache_file.scale());
+
+  /* create or update existing AlembicObjects */
+  ustring object_path = ustring(b_mesh_cache.object_path());
+
+  AlembicObject *abc_object = procedural->get_or_create_object(object_path);
+
+  array<Node *> used_shaders = find_used_shaders(b_ob);
+  abc_object->set_used_shaders(used_shaders);
+
+  PointerRNA cobj = RNA_pointer_get(&b_ob.ptr, "cycles");
+  const float subd_dicing_rate = max(0.1f, RNA_float_get(&cobj, "dicing_rate") * dicing_rate);
+  abc_object->set_subd_dicing_rate(subd_dicing_rate);
+  abc_object->set_subd_max_level(max_subdivisions);
+
+  abc_object->set_ignore_subdivision(!has_subdivision_modifier);
+
+  if (abc_object->is_modified() || procedural->is_modified()) {
+    procedural->tag_update(scene);
+  }
+#else
+  (void)b_ob;
+  (void)b_mesh_cache;
+#endif
+}
+
 void BlenderSync::sync_objects(BL::Depsgraph &b_depsgraph,
                                BL::SpaceView3D &b_v3d,
                                float motion_time)
@@ -499,6 +562,7 @@ void BlenderSync::sync_objects(BL::Depsgraph &b_depsgraph,
     light_map.pre_sync();
     geometry_map.pre_sync();
     object_map.pre_sync();
+    procedural_map.pre_sync();
     particle_system_map.pre_sync();
     motion_times.clear();
   }
@@ -539,15 +603,39 @@ void BlenderSync::sync_objects(BL::Depsgraph &b_depsgraph,
 
     /* Object itself. */
     if (b_instance.show_self()) {
-      sync_object(b_depsgraph,
-                  b_view_layer,
-                  b_instance,
-                  motion_time,
-                  false,
-                  show_lights,
-                  culling,
-                  &use_portal,
-                  sync_hair ? NULL : &geom_task_pool);
+#ifdef WITH_ALEMBIC
+      bool use_procedural = false;
+      bool has_subdivision_modifier = false;
+      BL::MeshSequenceCacheModifier b_mesh_cache(PointerRNA_NULL);
+
+      /* Experimental as Blender does not have good support for procedurals at the moment, also
+       * only available in preview renders since currently do not have a good cache policy, the
+       * data being loaded at once for all the frames. */
+      if (experimental && b_v3d) {
+        b_mesh_cache = object_mesh_cache_find(b_ob, false, &has_subdivision_modifier);
+        use_procedural = b_mesh_cache && b_mesh_cache.cache_file().use_render_procedural();
+      }
+
+      if (use_procedural) {
+        /* Skip in the motion case, as generating motion blur data will be handled in the
+         * procedural. */
+        if (!motion) {
+          sync_procedural(b_ob, b_mesh_cache, has_subdivision_modifier);
+        }
+      }
+      else
+#endif
+      {
+        sync_object(b_depsgraph,
+                    b_view_layer,
+                    b_instance,
+                    motion_time,
+                    false,
+                    show_lights,
+                    culling,
+                    &use_portal,
+                    sync_hair ? NULL : &geom_task_pool);
+      }
     }
 
     /* Particle hair as separate object. */
@@ -580,6 +668,7 @@ void BlenderSync::sync_objects(BL::Depsgraph &b_depsgraph,
     object_map.post_sync();
     geometry_map.post_sync();
     particle_system_map.post_sync();
+    procedural_map.post_sync();
   }
 
   if (motion)
diff --git a/intern/cycles/blender/blender_shader.cpp b/intern/cycles/blender/blender_shader.cpp
index 24819bacbb5..de7b2761d00 100644
--- a/intern/cycles/blender/blender_shader.cpp
+++ b/intern/cycles/blender/blender_shader.cpp
@@ -1020,13 +1020,21 @@ static ShaderInput *node_find_input_by_name(ShaderNode *node, BL::NodeSocket &b_
     input = node->input(name.c_str());
 
     if (!input) {
-      /* Different internal numbering of two sockets with same name. */
+      /* Different internal numbering of two sockets with same name.
+       * Note that the Blender convention for unique socket names changed
+       * from . to _ at some point, so we check both to handle old files. */
       if (string_endswith(name, "_001")) {
         string_replace(name, "_001", "2");
       }
+      else if (string_endswith(name, ".001")) {
+        string_replace(name, ".001", "2");
+      }
       else if (string_endswith(name, "_002")) {
         string_replace(name, "_002", "3");
       }
+      else if (string_endswith(name, ".002")) {
+        string_replace(name, ".002", "3");
+      }
       else {
         name += "1";
       }
diff --git a/intern/cycles/blender/blender_sync.cpp b/intern/cycles/blender/blender_sync.cpp
index 298353203ad..26d64b7bf85 100644
--- a/intern/cycles/blender/blender_sync.cpp
+++ b/intern/cycles/blender/blender_sync.cpp
@@ -59,6 +59,7 @@ BlenderSync::BlenderSync(BL::RenderEngine &b_engine,
       b_scene(b_scene),
       shader_map(scene),
       object_map(scene),
+      procedural_map(scene),
       geometry_map(scene),
       light_map(scene),
       particle_system_map(scene),
diff --git a/intern/cycles/blender/blender_sync.h b/intern/cycles/blender/blender_sync.h
index 949482b1f9c..44322dda6b9 100644
--- a/intern/cycles/blender/blender_sync.h
+++ b/intern/cycles/blender/blender_sync.h
@@ -151,6 +151,10 @@ class BlenderSync {
                       TaskPool *geom_task_pool);
   void sync_object_motion_init(BL::Object &b_parent, BL::Object &b_ob, Object *object);
 
+  void sync_procedural(BL::Object &b_ob,
+                       BL::MeshSequenceCacheModifier &b_mesh_cache,
+                       bool has_subdivision);
+
   bool sync_object_attributes(BL::DepsgraphObjectInstance &b_instance, Object *object);
 
   /* Volume */
@@ -221,6 +225,7 @@ class BlenderSync {
 
   id_map<void *, Shader> shader_map;
   id_map<ObjectKey, Object> object_map;
+  id_map<void *, Procedural> procedural_map;
   id_map<GeometryKey, Geometry> geometry_map;
   id_map<ObjectKey, Light> light_map;
   id_map<ParticleSystemKey, ParticleSystem> particle_system_map;
diff --git a/intern/cycles/blender/blender_util.h b/intern/cycles/blender/blender_util.h
index d441575e8af..3cf75b338dc 100644
--- a/intern/cycles/blender/blender_util.h
+++ b/intern/cycles/blender/blender_util.h
@@ -572,6 +572,45 @@ static inline BL::FluidDomainSettings object_fluid_gas_domain_find(BL::Object &b
   return BL::FluidDomainSettings(PointerRNA_NULL);
 }
 
+static inline BL::MeshSequenceCacheModifier object_mesh_cache_find(BL::Object &b_ob,
+                                                                   bool check_velocity,
+                                                                   bool *has_subdivision_modifier)
+{
+  for (int i = b_ob.modifiers.length() - 1; i >= 0; --i) {
+    BL::Modifier b_mod = b_ob.modifiers[i];
+
+    if (b_mod.type() == BL::Modifier::type_MESH_SEQUENCE_CACHE) {
+      BL::MeshSequenceCacheModifier mesh_cache = BL::MeshSequenceCacheModifier(b_mod);
+
+      if (check_velocity) {
+        if (!MeshSequenceCacheModifier_has_velocity_get(&mesh_cache.ptr)) {
+          return BL::MeshSequenceCacheModifier(PointerRNA_NULL);
+        }
+      }
+
+      return mesh_cache;
+    }
+
+    /* Skip possible particles system modifiers as they do not modify the geometry. */
+    if (b_mod.type() == BL::Modifier::type_PARTICLE_SYSTEM) {
+      continue;
+    }
+
+    /* Only skip the subsurf modifier if we are not checking for the mesh sequence cache modifier
+     * for motion blur. */
+    if (b_mod.type() == BL::Modifier::type_SUBSURF && !check_velocity) {
+      if (has_subdivision_modifier) {
+        *has_subdivision_modifier = true;
+      }
+      continue;
+    }
+
+    break;
+  }
+
+  return BL::MeshSequenceCacheModifier(PointerRNA_NULL);
+}
+
 static inline Mesh::SubdivisionType object_subdivision_type(BL::Object &b_ob,
                                                             bool preview,
                                                             bool experimental)
diff --git a/intern/cycles/kernel/geom/geom_triangle.h b/intern/cycles/kernel/geom/geom_triangle.h
index 208338a934b..1e7fbd9c7fb 100644
--- a/intern/cycles/kernel/geom/geom_triangle.h
+++ b/intern/cycles/kernel/geom/geom_triangle.h
@@ -107,6 +107,20 @@ triangle_smooth_normal(KernelGlobals *kg, float3 Ng, int prim, float u, float v)
   return is_zero(N) ? Ng : N;
 }
 
+ccl_device_inline float3
+triangle_smooth_normal_unnormalized(KernelGlobals *kg, float3 Ng, int prim, float u, float v)
+{
+  /* load triangle vertices */
+  const uint4 tri_vindex = kernel_tex_fetch(__tri_vindex, prim);
+  float3 n0 = float4_to_float3(kernel_tex_fetch(__tri_vnormal, tri_vindex.x));
+  float3 n1 = float4_to_float3(kernel_tex_fetch(__tri_vnormal, tri_vindex.y));
+  float3 n2 = float4_to_float3(kernel_tex_fetch(__tri_vnormal, tri_vindex.z));
+
+  float3 N = (1.0f - u - v) * n2 + u * n0 + v * n1;
+
+  return is_zero(N) ? Ng : N;
+}
+
 /* Ray differentials on triangle */
 
 ccl_device_inline void triangle_dPdudv(KernelGlobals *kg,
diff --git a/intern/cycles/kernel/shaders/node_texture_coordinate.osl b/intern/cycles/kernel/shaders/node_texture_coordinate.osl
index ac05e984af2..9cdb925dbfa 100644
--- a/intern/cycles/kernel/shaders/node_texture_coordinate.osl
+++ b/intern/cycles/kernel/shaders/node_texture_coordinate.osl
@@ -58,7 +58,9 @@ shader node_texture_coordinate(
       getattribute("geom:uv", UV);
     }
     else {
-      getattribute("geom:generated", Generated);
+      if (!getattribute("geom:generated", Generated)) {
+        Generated = transform("object", P);
+      }
       getattribute("geom:uv", UV);
     }
 
diff --git a/intern/cycles/kernel/svm/svm_attribute.h b/intern/cycles/kernel/svm/svm_attribute.h
index f598bfb8f8f..62740824ad1 100644
--- a/intern/cycles/kernel/svm/svm_attribute.h
+++ b/intern/cycles/kernel/svm/svm_attribute.h
@@ -72,6 +72,22 @@ ccl_device void svm_node_attr(KernelGlobals *kg, ShaderData *sd, float *stack, u
   }
 #endif
 
+  if (node.y == ATTR_STD_GENERATED && desc.element == ATTR_ELEMENT_NONE) {
+    /* No generated attribute, fall back to object coordinates. */
+    float3 f = sd->P;
+    object_inverse_position_transform(kg, sd, &f);
+    if (type == NODE_ATTR_OUTPUT_FLOAT) {
+      stack_store_float(stack, out_offset, average(f));
+    }
+    else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
+      stack_store_float3(stack, out_offset, f);
+    }
+    else {
+      stack_store_float(stack, out_offset, 1.0f);
+    }
+    return;
+  }
+
   /* Surface. */
   if (desc.type == NODE_ATTR_FLOAT) {
     float f = primitive_surface_attribute_float(kg, sd, desc, NULL, NULL);
@@ -145,6 +161,22 @@ ccl_device void svm_node_attr_bump_dx(KernelGlobals *kg, ShaderData *sd, float *
   }
 #endif
 
+  if (node.y == ATTR_STD_GENERATED && desc.element == ATTR_ELEMENT_NONE) {
+    /* No generated attribute, fall back to object coordinates. */
+    float3 f = sd->P + sd->dP.dx;
+    object_inverse_position_transform(kg, sd, &f);
+    if (type == NODE_ATTR_OUTPUT_FLOAT) {
+      stack_store_float(stack, out_offset, average(f));
+    }
+    else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
+      stack_store_float3(stack, out_offset, f);
+    }
+    else {
+      stack_store_float(stack, out_offset, 1.0f);
+    }
+    return;
+  }
+
   /* Surface */
   if (desc.type == NODE_ATTR_FLOAT) {
     float dx;
@@ -222,6 +254,22 @@ ccl_device void svm_node_attr_bump_dy(KernelGlobals *kg, ShaderData *sd, float *
   }
 #endif
 
+  if (node.y == ATTR_STD_GENERATED && desc.element == ATTR_ELEMENT_NONE) {
+    /* No generated attribute, fall back to object coordinates. */
+    float3 f = sd->P + sd->dP.dy;
+    object_inverse_position_transform(kg, sd, &f);
+    if (type == NODE_ATTR_OUTPUT_FLOAT) {
+      stack_store_float(stack, out_offset, average(f));
+    }
+    else if (type == NODE_ATTR_OUTPUT_FLOAT3) {
+      stack_store_float3(stack, out_offset, f);
+    }
+    else {
+      stack_store_float(stack, out_offset, 1.0f);
+    }
+    return;
+  }
+
   /* Surface */
   if (desc.type == NODE_ATTR_FLOAT) {
     float dy;
diff --git a/intern/cycles/kernel/svm/svm_tex_coord.h b/intern/cycles/kernel/svm/svm_tex_coord.h
index fc46bb584be..fec6a2cc27f 100644
--- a/intern/cycles/kernel/svm/svm_tex_coord.h
+++ b/intern/cycles/kernel/svm/svm_tex_coord.h
@@ -267,7 +267,7 @@ ccl_device void svm_node_normal_map(KernelGlobals *kg, ShaderData *sd, float *st
 
   if (space == NODE_NORMAL_MAP_TANGENT) {
     /* tangent space */
-    if (sd->object == OBJECT_NONE) {
+    if (sd->object == OBJECT_NONE || (sd->type & PRIMITIVE_ALL_TRIANGLE) == 0) {
       /* Fallback to unperturbed normal. */
       stack_store_float3(stack, normal_offset, sd->N);
       return;
@@ -276,10 +276,8 @@ ccl_device void svm_node_normal_map(KernelGlobals *kg, ShaderData *sd, float *st
     /* first try to get tangent attribute */
     const AttributeDescriptor attr = find_attribute(kg, sd, node.z);
     const AttributeDescriptor attr_sign = find_attribute(kg, sd, node.w);
-    const AttributeDescriptor attr_normal = find_attribute(kg, sd, ATTR_STD_VERTEX_NORMAL);
 
-    if (attr.offset == ATTR_STD_NOT_FOUND || attr_sign.offset == ATTR_STD_NOT_FOUND ||
-        attr_normal.offset == ATTR_STD_NOT_FOUND) {
+    if (attr.offset == ATTR_STD_NOT_FOUND || attr_sign.offset == ATTR_STD_NOT_FOUND) {
       /* Fallback to unperturbed normal. */
       stack_store_float3(stack, normal_offset, sd->N);
       return;
@@ -291,7 +289,7 @@ ccl_device void svm_node_normal_map(KernelGlobals *kg, ShaderData *sd, float *st
     float3 normal;
 
     if (sd->shader & SHADER_SMOOTH_NORMAL) {
-      normal = primitive_surface_attribute_float3(kg, sd, attr_normal, NULL, NULL);
+      normal = triangle_smooth_normal_unnormalized(kg, sd->Ng, sd->prim, sd->u, sd->v);
     }
     else {
       normal = sd->Ng;
diff --git a/intern/cycles/render/alembic.cpp b/intern/cycles/render/alembic.cpp
index 6713531c9b0..81f47256739 100644
--- a/intern/cycles/render/alembic.cpp
+++ b/intern/cycles/render/alembic.cpp
@@ -385,6 +385,8 @@ NODE_DEFINE(AlembicObject)
   SOCKET_STRING(path, "Alembic Path", ustring());
   SOCKET_NODE_ARRAY(used_shaders, "Used Shaders", Shader::get_node_type());
 
+  SOCKET_BOOLEAN(ignore_subdivision, "Ignore Subdivision", true);
+
   SOCKET_INT(subd_max_level, "Max Subdivision Level", 1);
   SOCKET_FLOAT(subd_dicing_rate, "Subdivision Dicing Rate", 1.0f);
 
@@ -470,6 +472,33 @@ void AlembicObject::load_data_in_cache(CachedData &cached_data,
 
   cached_data.clear();
 
+  if (this->get_ignore_subdivision()) {
+    PolyMeshSchemaData data;
+    data.topology_variance = schema.getTopologyVariance();
+    data.time_sampling = schema.getTimeSampling();
+    data.positions = schema.getPositionsProperty();
+    data.face_counts = schema.getFaceCountsProperty();
+    data.face_indices = schema.getFaceIndicesProperty();
+    data.num_samples = schema.getNumSamples();
+    data.velocities = schema.getVelocitiesProperty();
+    data.shader_face_sets = parse_face_sets_for_shader_assignment(schema, get_used_shaders());
+
+    read_geometry_data(proc, cached_data, data, progress);
+
+    if (progress.get_cancel()) {
+      return;
+    }
+
+    /* Use the schema as the base compound property to also be able to look for top level
+     * properties. */
+    read_attributes(
+        proc, cached_data, schema, schema.getUVsParam(), get_requested_attributes(), progress);
+
+    cached_data.invalidate_last_loaded_time(true);
+    data_loaded = true;
+    return;
+  }
+
   SubDSchemaData data;
   data.time_sampling = schema.getTimeSampling();
   data.num_samples = schema.getNumSamples();
@@ -781,6 +810,19 @@ void AlembicProcedural::generate(Scene *scene, Progress &progress)
 
   const chrono_t frame_time = (chrono_t)((frame - frame_offset) / frame_rate);
 
+  /* Clear the subdivision caches as the data is stored differently. */
+  for (Node *node : objects) {
+    AlembicObject *object = static_cast<AlembicObject *>(node);
+
+    if (object->schema_type != AlembicObject::SUBD) {
+      continue;
+    }
+
+    if (object->ignore_subdivision_is_modified()) {
+      object->clear_cache();
+    }
+  }
+
   build_caches(progress);
 
   foreach (Node *node, objects) {
@@ -959,14 +1001,6 @@ void AlembicProcedural::read_mesh(AlembicObject *abc_object, Abc::chrono_t frame
 
   update_attributes(mesh->attributes, cached_data, frame_time);
 
-  /* we don't yet support arbitrary attributes, for now add vertex
-   * coordinates as generated coordinates if requested */
-  if (mesh->need_attribute(scene_, ATTR_STD_GENERATED)) {
-    Attribute *attr = mesh->attributes.add(ATTR_STD_GENERATED);
-    memcpy(
-        attr->data_float3(), mesh->get_verts().data(), sizeof(float3) * mesh->get_verts().size());
-  }
-
   if (mesh->is_modified()) {
     bool need_rebuild = mesh->triangles_is_modified();
     mesh->tag_update(scene_, need_rebuild);
@@ -975,13 +1009,13 @@ void AlembicProcedural::read_mesh(AlembicObject *abc_object, Abc::chrono_t frame
 
 void AlembicProcedural::read_subd(AlembicObject *abc_object, Abc::chrono_t frame_time)
 {
-  CachedData &cached_data = abc_object->get_cached_data();
-
-  if (abc_object->subd_max_level_is_modified() || abc_object->subd_dicing_rate_is_modified()) {
-    /* need to reset the current data is something changed */
-    cached_data.invalidate_last_loaded_time();
+  if (abc_object->get_ignore_subdivision()) {
+    read_mesh(abc_object, frame_time);
+    return;
   }
 
+  CachedData &cached_data = abc_object->get_cached_data();
+
   /* Update sockets. */
 
   Object *object = abc_object->get_object();
@@ -996,6 +1030,11 @@ void AlembicProcedural::read_subd(AlembicObject *abc_object, Abc::chrono_t frame
     return;
   }
 
+  if (abc_object->subd_max_level_is_modified() || abc_object->subd_dicing_rate_is_modified()) {
+    /* need to reset the current data is something changed */
+    cached_data.invalidate_last_loaded_time();
+  }
+
   Mesh *mesh = static_cast<Mesh *>(object->get_geometry());
 
   /* Make sure shader ids are also updated. */
@@ -1053,14 +1092,6 @@ void AlembicProcedural::read_subd(AlembicObject *abc_object, Abc::chrono_t frame
 
   update_attributes(mesh->subd_attributes, cached_data, frame_time);
 
-  /* we don't yet support arbitrary attributes, for now add vertex
-   * coordinates as generated coordinates if requested */
-  if (mesh->need_attribute(scene_, ATTR_STD_GENERATED)) {
-    Attribute *attr = mesh->attributes.add(ATTR_STD_GENERATED);
-    memcpy(
-        attr->data_float3(), mesh->get_verts().data(), sizeof(float3) * mesh->get_verts().size());
-  }
-
   if (mesh->is_modified()) {
     bool need_rebuild = (mesh->triangles_is_modified()) ||
                         (mesh->subd_num_corners_is_modified()) ||
@@ -1110,17 +1141,6 @@ void AlembicProcedural::read_curves(AlembicObject *abc_object, Abc::chrono_t fra
 
   update_attributes(hair->attributes, cached_data, frame_time);
 
-  /* we don't yet support arbitrary attributes, for now add first keys as generated coordinates if
-   * requested */
-  if (hair->need_attribute(scene_, ATTR_STD_GENERATED)) {
-    Attribute *attr_generated = hair->attributes.add(ATTR_STD_GENERATED);
-    float3 *generated = attr_generated->data_float3();
-
-    for (size_t i = 0; i < hair->num_curves(); i++) {
-      generated[i] = hair->get_curve_keys()[hair->get_curve(i).first_key];
-    }
-  }
-
   const bool rebuild = (hair->curve_keys_is_modified() || hair->curve_radius_is_modified());
   hair->tag_update(scene_, rebuild);
 }
diff --git a/intern/cycles/render/alembic.h b/intern/cycles/render/alembic.h
index 61c0e40fe4a..9c58af720f6 100644
--- a/intern/cycles/render/alembic.h
+++ b/intern/cycles/render/alembic.h
@@ -353,6 +353,10 @@ class AlembicObject : public Node {
   /* Shaders used for rendering. */
   NODE_SOCKET_API_ARRAY(array<Node *>, used_shaders)
 
+  /* Treat this subdivision object as a regular polygon mesh, so no subdivision will be performed.
+   */
+  NODE_SOCKET_API(bool, ignore_subdivision)
+
   /* Maximum number of subdivisions for ISubD objects. */
   NODE_SOCKET_API(int, subd_max_level)
 
@@ -416,6 +420,11 @@ class AlembicObject : public Node {
     return cached_data_.is_constant();
   }
 
+  void clear_cache()
+  {
+    cached_data_.clear();
+  }
+
   Object *object = nullptr;
 
   bool data_loaded = false;
diff --git a/intern/cycles/render/geometry.cpp b/intern/cycles/render/geometry.cpp
index 6d084e82576..7ec1d2d9abb 100644
--- a/intern/cycles/render/geometry.cpp
+++ b/intern/cycles/render/geometry.cpp
@@ -788,6 +788,11 @@ void GeometryManager::device_update_attributes(Device *device,
     foreach (AttributeRequest &req, attributes.requests) {
       Attribute *attr = geom->attributes.find(req);
 
+      /* Vertex normals are stored in DeviceScene.tri_vnormal. */
+      if (attr && attr->std == ATTR_STD_VERTEX_NORMAL) {
+        continue;
+      }
+
       update_attribute_element_size(geom,
                                     attr,
                                     ATTR_PRIM_GEOMETRY,
@@ -800,6 +805,11 @@ void GeometryManager::device_update_attributes(Device *device,
         Mesh *mesh = static_cast<Mesh *>(geom);
         Attribute *subd_attr = mesh->subd_attributes.find(req);
 
+        /* Vertex normals are stored in DeviceScene.tri_vnormal. */
+        if (subd_attr && subd_attr->std == ATTR_STD_VERTEX_NORMAL) {
+          continue;
+        }
+
         update_attribute_element_size(mesh,
                                       subd_attr,
                                       ATTR_PRIM_SUBD,
@@ -854,6 +864,11 @@ void GeometryManager::device_update_attributes(Device *device,
       Attribute *attr = geom->attributes.find(req);
 
       if (attr) {
+        /* Vertex normals are stored in DeviceScene.tri_vnormal. */
+        if (attr->std == ATTR_STD_VERTEX_NORMAL) {
+          continue;
+        }
+
         /* force a copy if we need to reallocate all the data */
         attr->modified |= attributes_need_realloc[Attribute::kernel_type(*attr)];
       }
@@ -877,6 +892,11 @@ void GeometryManager::device_update_attributes(Device *device,
         Attribute *subd_attr = mesh->subd_attributes.find(req);
 
         if (subd_attr) {
+          /* Vertex normals are stored in DeviceScene.tri_vnormal. */
+          if (subd_attr->std == ATTR_STD_VERTEX_NORMAL) {
+            continue;
+          }
+
           /* force a copy if we need to reallocate all the data */
           subd_attr->modified |= attributes_need_realloc[Attribute::kernel_type(*subd_attr)];
         }
diff --git a/release/scripts/startup/nodeitems_builtins.py b/release/scripts/startup/nodeitems_builtins.py
index bb8db65f4a0..cf9b66cf35b 100644
--- a/release/scripts/startup/nodeitems_builtins.py
+++ b/release/scripts/startup/nodeitems_builtins.py
@@ -486,6 +486,7 @@ geometry_node_categories = [
         NodeItem("GeometryNodeAttributeFreeze"),
     ]),
     GeometryNodeCategory("GEO_COLOR", "Color", items=[
+        NodeItem("ShaderNodeMixRGB"),
         NodeItem("ShaderNodeRGBCurve"),
         NodeItem("ShaderNodeValToRGB"),
         NodeItem("ShaderNodeSeparateRGB"),
diff --git a/source/blender/blenfont/BLF_api.h b/source/blender/blenfont/BLF_api.h
index 7e92f79a523..eb3f9805240 100644
--- a/source/blender/blenfont/BLF_api.h
+++ b/source/blender/blenfont/BLF_api.h
@@ -271,7 +271,7 @@ void BLF_state_print(int fontid);
 #define BLF_ROTATION (1 << 0)
 #define BLF_CLIPPING (1 << 1)
 #define BLF_SHADOW (1 << 2)
-#define BLF_KERNING_DEFAULT (1 << 3)
+// #define BLF_FLAG_UNUSED_3 (1 << 3) /* dirty */
 #define BLF_MATRIX (1 << 4)
 #define BLF_ASPECT (1 << 5)
 #define BLF_WORD_WRAP (1 << 6)
diff --git a/source/blender/blenfont/intern/blf_font.c b/source/blender/blenfont/intern/blf_font.c
index d9396bd0f90..00d3cfb09eb 100644
--- a/source/blender/blenfont/intern/blf_font.c
+++ b/source/blender/blenfont/intern/blf_font.c
@@ -308,19 +308,14 @@ void blf_font_size(FontBLF *font, unsigned int size, unsigned int dpi)
   blf_glyph_cache_release(font);
 }
 
-static void blf_font_ensure_ascii_kerning(FontBLF *font,
-                                          GlyphCacheBLF *gc,
-                                          const FT_UInt kern_mode)
+static void blf_font_ensure_ascii_kerning(FontBLF *font, GlyphCacheBLF *gc)
 {
-  KerningCacheBLF *kc = font->kerning_cache;
-
-  font->kerning_mode = kern_mode;
-
-  if (!kc || kc->mode != kern_mode) {
-    font->kerning_cache = kc = blf_kerning_cache_find(font);
-    if (!kc) {
-      font->kerning_cache = kc = blf_kerning_cache_new(font, gc);
-    }
+  if (font->kerning_cache || !FT_HAS_KERNING(font->face)) {
+    return;
+  }
+  font->kerning_cache = blf_kerning_cache_find(font);
+  if (!font->kerning_cache) {
+    font->kerning_cache = blf_kerning_cache_new(font, gc);
   }
 }
 
@@ -353,30 +348,23 @@ BLI_INLINE GlyphBLF *blf_utf8_next_fast(
   return g;
 }
 
-#define BLF_KERNING_VARS(_font, _has_kerning, _kern_mode) \
-  const bool _has_kerning = FT_HAS_KERNING((_font)->face); \
-  const FT_UInt _kern_mode = (_has_kerning && !((_font)->flags & BLF_KERNING_DEFAULT)) ? \
-                                 FT_KERNING_UNFITTED : \
-                                 FT_KERNING_DEFAULT;
-
 BLI_INLINE void blf_kerning_step_fast(FontBLF *font,
-                                      const FT_UInt kern_mode,
                                       const GlyphBLF *g_prev,
                                       const GlyphBLF *g,
                                       const uint c_prev,
                                       const uint c,
                                       int *pen_x_p)
 {
-  /* `blf_font_ensure_ascii_kerning(font, gc, kern_mode);` must be called before this function. */
-  BLI_assert((font->kerning_mode == kern_mode) && (font->kerning_cache != NULL));
+  /* `blf_font_ensure_ascii_kerning(font, gc);` must be called before this function. */
+  BLI_assert(font->kerning_cache != NULL || !FT_HAS_KERNING(font->face));
 
-  if (g_prev != NULL) {
+  if (g_prev != NULL && FT_HAS_KERNING(font->face)) {
     if ((c_prev < KERNING_CACHE_TABLE_SIZE) && (c < GLYPH_ASCII_TABLE_SIZE)) {
       *pen_x_p += font->kerning_cache->ascii_table[c][c_prev];
     }
     else {
       FT_Vector delta;
-      if (FT_Get_Kerning(font->face, g_prev->idx, g->idx, kern_mode, &delta) == 0) {
+      if (FT_Get_Kerning(font->face, g_prev->idx, g->idx, FT_KERNING_DEFAULT, &delta) == 0) {
         *pen_x_p += (int)delta.x >> 6;
       }
     }
@@ -400,9 +388,7 @@ static void blf_font_draw_ex(FontBLF *font,
     return;
   }
 
-  BLF_KERNING_VARS(font, has_kerning, kern_mode);
-
-  blf_font_ensure_ascii_kerning(font, gc, kern_mode);
+  blf_font_ensure_ascii_kerning(font, gc);
 
   blf_batch_draw_begin(font);
 
@@ -415,9 +401,7 @@ static void blf_font_draw_ex(FontBLF *font,
     if (UNLIKELY(g == NULL)) {
       continue;
     }
-    if (has_kerning) {
-      blf_kerning_step_fast(font, kern_mode, g_prev, g, c_prev, c, &pen_x);
-    }
+    blf_kerning_step_fast(font, g_prev, g, c_prev, c, &pen_x);
 
     /* do not return this loop if clipped, we want every character tested */
     blf_glyph_render(font, gc, g, (float)pen_x, (float)pen_y);
@@ -451,9 +435,7 @@ static void blf_font_draw_ascii_ex(
 
   GlyphCacheBLF *gc = blf_glyph_cache_acquire(font);
 
-  BLF_KERNING_VARS(font, has_kerning, kern_mode);
-
-  blf_font_ensure_ascii_kerning(font, gc, kern_mode);
+  blf_font_ensure_ascii_kerning(font, gc);
 
   blf_batch_draw_begin(font);
 
@@ -467,9 +449,7 @@ static void blf_font_draw_ascii_ex(
         continue;
       }
     }
-    if (has_kerning) {
-      blf_kerning_step_fast(font, kern_mode, g_prev, g, c_prev, c, &pen_x);
-    }
+    blf_kerning_step_fast(font, g_prev, g, c_prev, c, &pen_x);
 
     /* do not return this loop if clipped, we want every character tested */
     blf_glyph_render(font, gc, g, (float)pen_x, (float)pen_y);
@@ -556,9 +536,7 @@ static void blf_font_draw_buffer_ex(FontBLF *font,
   int chx, chy;
   int y, x;
 
-  BLF_KERNING_VARS(font, has_kerning, kern_mode);
-
-  blf_font_ensure_ascii_kerning(font, gc, kern_mode);
+  blf_font_ensure_ascii_kerning(font, gc);
 
   /* another buffer specific call for color conversion */
 
@@ -571,9 +549,7 @@ static void blf_font_draw_buffer_ex(FontBLF *font,
     if (UNLIKELY(g == NULL)) {
       continue;
     }
-    if (has_kerning) {
-      blf_kerning_step_fast(font, kern_mode, g_prev, g, c_prev, c, &pen_x);
-    }
+    blf_kerning_step_fast(font, g_prev, g, c_prev, c, &pen_x);
 
     chx = pen_x + ((int)g->pos[0]);
     chy = pen_y_basis + g->dims[1];
@@ -687,8 +663,6 @@ void blf_font_draw_buffer(FontBLF *font, const char *str, size_t len, struct Res
 }
 
 static bool blf_font_width_to_strlen_glyph_process(FontBLF *font,
-                                                   const bool has_kerning,
-                                                   const FT_UInt kern_mode,
                                                    const uint c_prev,
                                                    const uint c,
                                                    GlyphBLF *g_prev,
@@ -702,9 +676,7 @@ static bool blf_font_width_to_strlen_glyph_process(FontBLF *font,
   if (UNLIKELY(g == NULL)) {
     return false; /* continue the calling loop. */
   }
-  if (has_kerning) {
-    blf_kerning_step_fast(font, kern_mode, g_prev, g, c_prev, c, pen_x);
-  }
+  blf_kerning_step_fast(font, g_prev, g, c_prev, c, pen_x);
 
   *pen_x += g->advance_i;
 
@@ -722,18 +694,13 @@ size_t blf_font_width_to_strlen(
   GlyphCacheBLF *gc = blf_glyph_cache_acquire(font);
   const int width_i = (int)width;
 
-  BLF_KERNING_VARS(font, has_kerning, kern_mode);
-
-  if (has_kerning) {
-    blf_font_ensure_ascii_kerning(font, gc, kern_mode);
-  }
+  blf_font_ensure_ascii_kerning(font, gc);
 
   for (i_prev = i = 0, width_new = pen_x = 0, g_prev = NULL, c_prev = 0; (i < len) && str[i];
        i_prev = i, width_new = pen_x, c_prev = c, g_prev = g) {
     g = blf_utf8_next_fast(font, gc, str, &i, &c);
 
-    if (blf_font_width_to_strlen_glyph_process(
-            font, has_kerning, kern_mode, c_prev, c, g_prev, g, &pen_x, width_i)) {
+    if (blf_font_width_to_strlen_glyph_process(font, c_prev, c, g_prev, g, &pen_x, width_i)) {
       break;
     }
   }
@@ -758,11 +725,7 @@ size_t blf_font_width_to_rstrlen(
   GlyphCacheBLF *gc = blf_glyph_cache_acquire(font);
   const int width_i = (int)width;
 
-  BLF_KERNING_VARS(font, has_kerning, kern_mode);
-
-  if (has_kerning) {
-    blf_font_ensure_ascii_kerning(font, gc, kern_mode);
-  }
+  blf_font_ensure_ascii_kerning(font, gc);
 
   i = BLI_strnlen(str, len);
   s = BLI_str_find_prev_char_utf8(str, &str[i]);
@@ -783,8 +746,7 @@ size_t blf_font_width_to_rstrlen(
       BLI_assert(i_tmp == i);
     }
 
-    if (blf_font_width_to_strlen_glyph_process(
-            font, has_kerning, kern_mode, c_prev, c, g_prev, g, &pen_x, width_i)) {
+    if (blf_font_width_to_strlen_glyph_process(font, c_prev, c, g_prev, g, &pen_x, width_i)) {
       break;
     }
   }
@@ -811,14 +773,12 @@ static void blf_font_boundbox_ex(FontBLF *font,
   size_t i = 0;
   rctf gbox;
 
-  BLF_KERNING_VARS(font, has_kerning, kern_mode);
-
   box->xmin = 32000.0f;
   box->xmax = -32000.0f;
   box->ymin = 32000.0f;
   box->ymax = -32000.0f;
 
-  blf_font_ensure_ascii_kerning(font, gc, kern_mode);
+  blf_font_ensure_ascii_kerning(font, gc);
 
   while ((i < len) && str[i]) {
     g = blf_utf8_next_fast(font, gc, str, &i, &c);
@@ -829,9 +789,7 @@ static void blf_font_boundbox_ex(FontBLF *font,
     if (UNLIKELY(g == NULL)) {
       continue;
     }
-    if (has_kerning) {
-      blf_kerning_step_fast(font, kern_mode, g_prev, g, c_prev, c, &pen_x);
-    }
+    blf_kerning_step_fast(font, g_prev, g, c_prev, c, &pen_x);
 
     gbox.xmin = (float)pen_x;
     gbox.xmax = (float)pen_x + g->advance;
@@ -911,9 +869,7 @@ static void blf_font_wrap_apply(FontBLF *font,
 
   GlyphCacheBLF *gc = blf_glyph_cache_acquire(font);
 
-  BLF_KERNING_VARS(font, has_kerning, kern_mode);
-
-  blf_font_ensure_ascii_kerning(font, gc, kern_mode);
+  blf_font_ensure_ascii_kerning(font, gc);
 
   struct WordWrapVars {
     int wrap_width;
@@ -935,9 +891,7 @@ static void blf_font_wrap_apply(FontBLF *font,
     if (UNLIKELY(g == NULL)) {
       continue;
     }
-    if (has_kerning) {
-      blf_kerning_step_fast(font, kern_mode, g_prev, g, c_prev, c, &pen_x);
-    }
+    blf_kerning_step_fast(font, g_prev, g, c_prev, c, &pen_x);
 
     /**
      * Implementation Detail (utf8).
@@ -1169,9 +1123,7 @@ static void blf_font_boundbox_foreach_glyph_ex(FontBLF *font,
     return;
   }
 
-  BLF_KERNING_VARS(font, has_kerning, kern_mode);
-
-  blf_font_ensure_ascii_kerning(font, gc, kern_mode);
+  blf_font_ensure_ascii_kerning(font, gc);
 
   while ((i < len) && str[i]) {
     i_curr = i;
@@ -1183,9 +1135,7 @@ static void blf_font_boundbox_foreach_glyph_ex(FontBLF *font,
     if (UNLIKELY(g == NULL)) {
       continue;
     }
-    if (has_kerning) {
-      blf_kerning_step_fast(font, kern_mode, g_prev, g, c_prev, c, &pen_x);
-    }
+    blf_kerning_step_fast(font, g_prev, g, c_prev, c, &pen_x);
 
     gbox.xmin = pen_x;
     gbox.xmax = gbox.xmin + MIN2(g->advance_i, g->dims[0]);
diff --git a/source/blender/blenfont/intern/blf_glyph.c b/source/blender/blenfont/intern/blf_glyph.c
index c5abc5982e8..5fb69251466 100644
--- a/source/blender/blenfont/intern/blf_glyph.c
+++ b/source/blender/blenfont/intern/blf_glyph.c
@@ -57,16 +57,7 @@
 
 KerningCacheBLF *blf_kerning_cache_find(FontBLF *font)
 {
-  KerningCacheBLF *p;
-
-  p = (KerningCacheBLF *)font->kerning_caches.first;
-  while (p) {
-    if (p->mode == font->kerning_mode) {
-      return p;
-    }
-    p = p->next;
-  }
-  return NULL;
+  return (KerningCacheBLF *)font->kerning_caches.first;
 }
 
 /* Create a new glyph cache for the current kerning mode. */
@@ -75,7 +66,6 @@ KerningCacheBLF *blf_kerning_cache_new(FontBLF *font, GlyphCacheBLF *gc)
   KerningCacheBLF *kc = MEM_mallocN(sizeof(KerningCacheBLF), __func__);
   kc->next = NULL;
   kc->prev = NULL;
-  kc->mode = font->kerning_mode;
 
   GlyphBLF *g_table[KERNING_CACHE_TABLE_SIZE];
   for (uint i = 0; i < KERNING_CACHE_TABLE_SIZE; i++) {
@@ -99,7 +89,7 @@ KerningCacheBLF *blf_kerning_cache_new(FontBLF *font, GlyphCacheBLF *gc)
         continue;
       }
       FT_Vector delta;
-      if (FT_Get_Kerning(font->face, g_prev->idx, g->idx, kc->mode, &delta) == 0) {
+      if (FT_Get_Kerning(font->face, g_prev->idx, g->idx, FT_KERNING_DEFAULT, &delta) == 0) {
         kc->ascii_table[i][j] = (int)delta.x >> 6;
       }
     }
diff --git a/source/blender/blenfont/intern/blf_internal_types.h b/source/blender/blenfont/intern/blf_internal_types.h
index ece9a5ffae4..caa10b2b125 100644
--- a/source/blender/blenfont/intern/blf_internal_types.h
+++ b/source/blender/blenfont/intern/blf_internal_types.h
@@ -51,10 +51,6 @@ extern BatchBLF g_batch;
 
 typedef struct KerningCacheBLF {
   struct KerningCacheBLF *next, *prev;
-
-  /* kerning mode. */
-  FT_UInt mode;
-
   /**
    * Cache a ascii glyph pairs. Only store the x offset we are interested in,
    * instead of the full #FT_Vector since it's not used for drawing at the moment.
@@ -242,9 +238,6 @@ typedef struct FontBLF {
   /* freetype2 face. */
   FT_Face face;
 
-  /* freetype kerning */
-  FT_UInt kerning_mode;
-
   /* data for buffer usage (drawing into a texture buffer) */
   FontBufInfoBLF buf_info;
 
diff --git a/source/blender/blenkernel/BKE_cachefile.h b/source/blender/blenkernel/BKE_cachefile.h
index a6b2aa8540a..58d876b184b 100644
--- a/source/blender/blenkernel/BKE_cachefile.h
+++ b/source/blender/blenkernel/BKE_cachefile.h
@@ -32,6 +32,7 @@ struct CacheReader;
 struct Depsgraph;
 struct Main;
 struct Object;
+struct Scene;
 
 void BKE_cachefiles_init(void);
 void BKE_cachefiles_exit(void);
@@ -60,6 +61,15 @@ void BKE_cachefile_reader_open(struct CacheFile *cache_file,
                                const char *object_path);
 void BKE_cachefile_reader_free(struct CacheFile *cache_file, struct CacheReader **reader);
 
+/* Determine whether the CacheFile should use a render engine procedural. If so, data is not read
+ * from the file and bouding boxes are used to represent the objects in the Scene. Render engines
+ * will receive the bounding box as a placeholder but can instead load the data directly if they
+ * support it.
+ */
+bool BKE_cache_file_uses_render_procedural(const struct CacheFile *cache_file,
+                                           struct Scene *scene,
+                                           const int dag_eval_mode);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/blender/blenkernel/BKE_gpencil.h b/source/blender/blenkernel/BKE_gpencil.h
index 92e70b41e7b..b58317f4815 100644
--- a/source/blender/blenkernel/BKE_gpencil.h
+++ b/source/blender/blenkernel/BKE_gpencil.h
@@ -93,7 +93,7 @@ void BKE_gpencil_free_stroke(struct bGPDstroke *gps);
 bool BKE_gpencil_free_strokes(struct bGPDframe *gpf);
 void BKE_gpencil_free_frames(struct bGPDlayer *gpl);
 void BKE_gpencil_free_layers(struct ListBase *list);
-void BKE_gpencil_free(struct bGPdata *gpd, bool free_all);
+void BKE_gpencil_free_data(struct bGPdata *gpd, bool free_all);
 void BKE_gpencil_eval_delete(struct bGPdata *gpd_eval);
 void BKE_gpencil_free_layer_masks(struct bGPDlayer *gpl);
 void BKE_gpencil_tag(struct bGPdata *gpd);
diff --git a/source/blender/blenkernel/BKE_image.h b/source/blender/blenkernel/BKE_image.h
index 3cab1a6b755..b62ad3ad24a 100644
--- a/source/blender/blenkernel/BKE_image.h
+++ b/source/blender/blenkernel/BKE_image.h
@@ -56,7 +56,7 @@ void BKE_image_free_buffers(struct Image *image);
 void BKE_image_free_buffers_ex(struct Image *image, bool do_lock);
 void BKE_image_free_gputextures(struct Image *ima);
 /* call from library */
-void BKE_image_free(struct Image *image);
+void BKE_image_free_data(struct Image *image);
 
 typedef void(StampCallback)(void *data, const char *propname, char *propvalue, int len);
 
diff --git a/source/blender/blenkernel/BKE_key.h b/source/blender/blenkernel/BKE_key.h
index 70d65e02246..cb4fc607703 100644
--- a/source/blender/blenkernel/BKE_key.h
+++ b/source/blender/blenkernel/BKE_key.h
@@ -36,7 +36,7 @@ struct Object;
 extern "C" {
 #endif
 
-void BKE_key_free(struct Key *key);
+void BKE_key_free_data(struct Key *key);
 void BKE_key_free_nolib(struct Key *key);
 struct Key *BKE_key_add(struct Main *bmain, struct ID *id);
 void BKE_key_sort(struct Key *key);
diff --git a/source/blender/blenkernel/BKE_mesh.h b/source/blender/blenkernel/BKE_mesh.h
index 8000e57e08e..ae464a48e9e 100644
--- a/source/blender/blenkernel/BKE_mesh.h
+++ b/source/blender/blenkernel/BKE_mesh.h
@@ -95,7 +95,7 @@ void BKE_mesh_looptri_get_real_edges(const struct Mesh *mesh,
                                      const struct MLoopTri *looptri,
                                      int r_edges[3]);
 
-void BKE_mesh_free(struct Mesh *me);
+void BKE_mesh_free_data_for_undo(struct Mesh *me);
 void BKE_mesh_clear_geometry(struct Mesh *me);
 struct Mesh *BKE_mesh_add(struct Main *bmain, const char *name);
 void BKE_mesh_copy_parameters_for_eval(struct Mesh *me_dst, const struct Mesh *me_src);
diff --git a/source/blender/blenkernel/BKE_modifier.h b/source/blender/blenkernel/BKE_modifier.h
index 0b4e1191956..8be563e4c96 100644
--- a/source/blender/blenkernel/BKE_modifier.h
+++ b/source/blender/blenkernel/BKE_modifier.h
@@ -319,8 +319,10 @@ typedef struct ModifierTypeInfo {
    * changes.
    *
    * This function is optional (assumes false if not present).
+   *
+   * The dag_eval_mode should be of type eEvaluationMode.
    */
-  bool (*dependsOnTime)(struct ModifierData *md);
+  bool (*dependsOnTime)(struct Scene *scene, struct ModifierData *md, const int dag_eval_mode);
 
   /**
    * True when a deform modifier uses normals, the requiredDataMask
@@ -425,7 +427,7 @@ void BKE_modifier_copydata(struct ModifierData *md, struct ModifierData *target)
 void BKE_modifier_copydata_ex(struct ModifierData *md,
                               struct ModifierData *target,
                               const int flag);
-bool BKE_modifier_depends_ontime(struct ModifierData *md);
+bool BKE_modifier_depends_ontime(struct Scene *scene, struct ModifierData *md, int dag_eval_mode);
 bool BKE_modifier_supports_mapping(struct ModifierData *md);
 bool BKE_modifier_supports_cage(struct Scene *scene, struct ModifierData *md);
 bool BKE_modifier_couldbe_cage(struct Scene *scene, struct ModifierData *md);
diff --git a/source/blender/blenkernel/BKE_object.h b/source/blender/blenkernel/BKE_object.h
index 4724e6dfab6..a823602e341 100644
--- a/source/blender/blenkernel/BKE_object.h
+++ b/source/blender/blenkernel/BKE_object.h
@@ -401,7 +401,10 @@ void BKE_object_groups_clear(struct Main *bmain, struct Scene *scene, struct Obj
 
 struct KDTree_3d *BKE_object_as_kdtree(struct Object *ob, int *r_tot);
 
-bool BKE_object_modifier_use_time(struct Object *ob, struct ModifierData *md);
+bool BKE_object_modifier_use_time(struct Scene *scene,
+                                  struct Object *ob,
+                                  struct ModifierData *md,
+                                  int dag_eval_mode);
 
 bool BKE_object_modifier_update_subframe(struct Depsgraph *depsgraph,
                                          struct Scene *scene,
diff --git a/source/blender/blenkernel/BKE_scene.h b/source/blender/blenkernel/BKE_scene.h
index 6d58e165ea3..83ce5e72794 100644
--- a/source/blender/blenkernel/BKE_scene.h
+++ b/source/blender/blenkernel/BKE_scene.h
@@ -174,6 +174,10 @@ bool BKE_scene_uses_blender_eevee(const struct Scene *scene);
 bool BKE_scene_uses_blender_workbench(const struct Scene *scene);
 bool BKE_scene_uses_cycles(const struct Scene *scene);
 
+/* Return whether the Cycles experimental feature is enabled. It is invalid to call without first
+ * ensuring that Cycles is the active render engine (e.g. with BKE_scene_uses_cycles). */
+bool BKE_scene_uses_cycles_experimental_features(struct Scene *scene);
+
 void BKE_scene_copy_data_eevee(struct Scene *sce_dst, const struct Scene *sce_src);
 
 void BKE_scene_disable_color_management(struct Scene *scene);
diff --git a/source/blender/blenkernel/BKE_screen.h b/source/blender/blenkernel/BKE_screen.h
index 0b08bbfeff5..6f341a12b82 100644
--- a/source/blender/blenkernel/BKE_screen.h
+++ b/source/blender/blenkernel/BKE_screen.h
@@ -473,7 +473,7 @@ void BKE_screen_view3d_shading_init(struct View3DShading *shading);
 /* screen */
 void BKE_screen_foreach_id_screen_area(struct LibraryForeachIDData *data, struct ScrArea *area);
 
-void BKE_screen_free(struct bScreen *screen);
+void BKE_screen_free_data(struct bScreen *screen);
 void BKE_screen_area_map_free(struct ScrAreaMap *area_map) ATTR_NONNULL();
 
 struct ScrEdge *BKE_screen_find_edge(const struct bScreen *screen,
diff --git a/source/blender/blenkernel/intern/action.c b/source/blender/blenkernel/intern/action.c
index d55f023d209..981815f400a 100644
--- a/source/blender/blenkernel/intern/action.c
+++ b/source/blender/blenkernel/intern/action.c
@@ -186,22 +186,21 @@ static void action_foreach_id(ID *id, LibraryForeachIDData *data)
 static void action_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   bAction *act = (bAction *)id;
-  if (act->id.us > 0 || BLO_write_is_undo(writer)) {
-    BLO_write_id_struct(writer, bAction, id_address, &act->id);
-    BKE_id_blend_write(writer, &act->id);
 
-    BKE_fcurve_blend_write(writer, &act->curves);
+  BLO_write_id_struct(writer, bAction, id_address, &act->id);
+  BKE_id_blend_write(writer, &act->id);
 
-    LISTBASE_FOREACH (bActionGroup *, grp, &act->groups) {
-      BLO_write_struct(writer, bActionGroup, grp);
-    }
+  BKE_fcurve_blend_write(writer, &act->curves);
 
-    LISTBASE_FOREACH (TimeMarker *, marker, &act->markers) {
-      BLO_write_struct(writer, TimeMarker, marker);
-    }
+  LISTBASE_FOREACH (bActionGroup *, grp, &act->groups) {
+    BLO_write_struct(writer, bActionGroup, grp);
+  }
 
-    BKE_previewimg_blend_write(writer, act->preview);
+  LISTBASE_FOREACH (TimeMarker *, marker, &act->markers) {
+    BLO_write_struct(writer, TimeMarker, marker);
   }
+
+  BKE_previewimg_blend_write(writer, act->preview);
 }
 
 static void action_blend_read_data(BlendDataReader *reader, ID *id)
diff --git a/source/blender/blenkernel/intern/armature.c b/source/blender/blenkernel/intern/armature.c
index 1f02b084534..87320c88b1b 100644
--- a/source/blender/blenkernel/intern/armature.c
+++ b/source/blender/blenkernel/intern/armature.c
@@ -212,25 +212,24 @@ static void write_bone(BlendWriter *writer, Bone *bone)
 static void armature_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   bArmature *arm = (bArmature *)id;
-  if (arm->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* Clean up, important in undo case to reduce false detection of changed datablocks. */
-    arm->bonehash = NULL;
-    arm->edbo = NULL;
-    /* Must always be cleared (armatures don't have their own edit-data). */
-    arm->needs_flush_to_id = 0;
-    arm->act_edbone = NULL;
 
-    BLO_write_id_struct(writer, bArmature, id_address, &arm->id);
-    BKE_id_blend_write(writer, &arm->id);
+  /* Clean up, important in undo case to reduce false detection of changed datablocks. */
+  arm->bonehash = NULL;
+  arm->edbo = NULL;
+  /* Must always be cleared (armatures don't have their own edit-data). */
+  arm->needs_flush_to_id = 0;
+  arm->act_edbone = NULL;
 
-    if (arm->adt) {
-      BKE_animdata_blend_write(writer, arm->adt);
-    }
+  BLO_write_id_struct(writer, bArmature, id_address, &arm->id);
+  BKE_id_blend_write(writer, &arm->id);
 
-    /* Direct data */
-    LISTBASE_FOREACH (Bone *, bone, &arm->bonebase) {
-      write_bone(writer, bone);
-    }
+  if (arm->adt) {
+    BKE_animdata_blend_write(writer, arm->adt);
+  }
+
+  /* Direct data */
+  LISTBASE_FOREACH (Bone *, bone, &arm->bonebase) {
+    write_bone(writer, bone);
   }
 }
 
diff --git a/source/blender/blenkernel/intern/brush.c b/source/blender/blenkernel/intern/brush.c
index 3418e37642c..7b81187be21 100644
--- a/source/blender/blenkernel/intern/brush.c
+++ b/source/blender/blenkernel/intern/brush.c
@@ -202,48 +202,47 @@ static void brush_foreach_id(ID *id, LibraryForeachIDData *data)
 static void brush_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   Brush *brush = (Brush *)id;
-  if (brush->id.us > 0 || BLO_write_is_undo(writer)) {
-    BLO_write_id_struct(writer, Brush, id_address, &brush->id);
-    BKE_id_blend_write(writer, &brush->id);
 
-    if (brush->curve) {
-      BKE_curvemapping_blend_write(writer, brush->curve);
-    }
+  BLO_write_id_struct(writer, Brush, id_address, &brush->id);
+  BKE_id_blend_write(writer, &brush->id);
 
-    if (brush->gpencil_settings) {
-      BLO_write_struct(writer, BrushGpencilSettings, brush->gpencil_settings);
+  if (brush->curve) {
+    BKE_curvemapping_blend_write(writer, brush->curve);
+  }
 
-      if (brush->gpencil_settings->curve_sensitivity) {
-        BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_sensitivity);
-      }
-      if (brush->gpencil_settings->curve_strength) {
-        BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_strength);
-      }
-      if (brush->gpencil_settings->curve_jitter) {
-        BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_jitter);
-      }
-      if (brush->gpencil_settings->curve_rand_pressure) {
-        BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_pressure);
-      }
-      if (brush->gpencil_settings->curve_rand_strength) {
-        BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_strength);
-      }
-      if (brush->gpencil_settings->curve_rand_uv) {
-        BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_uv);
-      }
-      if (brush->gpencil_settings->curve_rand_hue) {
-        BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_hue);
-      }
-      if (brush->gpencil_settings->curve_rand_saturation) {
-        BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_saturation);
-      }
-      if (brush->gpencil_settings->curve_rand_value) {
-        BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_value);
-      }
+  if (brush->gpencil_settings) {
+    BLO_write_struct(writer, BrushGpencilSettings, brush->gpencil_settings);
+
+    if (brush->gpencil_settings->curve_sensitivity) {
+      BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_sensitivity);
     }
-    if (brush->gradient) {
-      BLO_write_struct(writer, ColorBand, brush->gradient);
+    if (brush->gpencil_settings->curve_strength) {
+      BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_strength);
     }
+    if (brush->gpencil_settings->curve_jitter) {
+      BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_jitter);
+    }
+    if (brush->gpencil_settings->curve_rand_pressure) {
+      BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_pressure);
+    }
+    if (brush->gpencil_settings->curve_rand_strength) {
+      BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_strength);
+    }
+    if (brush->gpencil_settings->curve_rand_uv) {
+      BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_uv);
+    }
+    if (brush->gpencil_settings->curve_rand_hue) {
+      BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_hue);
+    }
+    if (brush->gpencil_settings->curve_rand_saturation) {
+      BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_saturation);
+    }
+    if (brush->gpencil_settings->curve_rand_value) {
+      BKE_curvemapping_blend_write(writer, brush->gpencil_settings->curve_rand_value);
+    }
+  }
+  if (brush->gradient) {
+    BLO_write_struct(writer, ColorBand, brush->gradient);
   }
 }
 
diff --git a/source/blender/blenkernel/intern/cachefile.c b/source/blender/blenkernel/intern/cachefile.c
index 75180de94d8..4a60564b4a1 100644
--- a/source/blender/blenkernel/intern/cachefile.c
+++ b/source/blender/blenkernel/intern/cachefile.c
@@ -49,6 +49,8 @@
 
 #include "DEG_depsgraph_query.h"
 
+#include "RE_engine.h"
+
 #include "BLO_read_write.h"
 
 #ifdef WITH_ALEMBIC
@@ -95,19 +97,18 @@ static void cache_file_free_data(ID *id)
 static void cache_file_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   CacheFile *cache_file = (CacheFile *)id;
-  if (cache_file->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* Clean up, important in undo case to reduce false detection of changed datablocks. */
-    BLI_listbase_clear(&cache_file->object_paths);
-    cache_file->handle = NULL;
-    memset(cache_file->handle_filepath, 0, sizeof(cache_file->handle_filepath));
-    cache_file->handle_readers = NULL;
 
-    BLO_write_id_struct(writer, CacheFile, id_address, &cache_file->id);
-    BKE_id_blend_write(writer, &cache_file->id);
+  /* Clean up, important in undo case to reduce false detection of changed datablocks. */
+  BLI_listbase_clear(&cache_file->object_paths);
+  cache_file->handle = NULL;
+  memset(cache_file->handle_filepath, 0, sizeof(cache_file->handle_filepath));
+  cache_file->handle_readers = NULL;
 
-    if (cache_file->adt) {
-      BKE_animdata_blend_write(writer, cache_file->adt);
-    }
+  BLO_write_id_struct(writer, CacheFile, id_address, &cache_file->id);
+  BKE_id_blend_write(writer, &cache_file->id);
+
+  if (cache_file->adt) {
+    BKE_animdata_blend_write(writer, cache_file->adt);
   }
 }
 
@@ -409,3 +410,19 @@ float BKE_cachefile_time_offset(const CacheFile *cache_file, const float time, c
   const float frame = (cache_file->override_frame ? cache_file->frame : time);
   return cache_file->is_sequence ? frame : frame / fps - time_offset;
 }
+
+bool BKE_cache_file_uses_render_procedural(const CacheFile *cache_file,
+                                           Scene *scene,
+                                           const int dag_eval_mode)
+{
+  RenderEngineType *render_engine_type = RE_engines_find(scene->r.engine);
+
+  if (cache_file->type != CACHEFILE_TYPE_ALEMBIC ||
+      !RE_engine_supports_alembic_procedural(render_engine_type, scene)) {
+    return false;
+  }
+
+  /* The render time procedural is only enabled during viewport rendering. */
+  const bool is_final_render = (eEvaluationMode)dag_eval_mode == DAG_EVAL_RENDER;
+  return cache_file->use_render_procedural && !is_final_render;
+}
diff --git a/source/blender/blenkernel/intern/camera.c b/source/blender/blenkernel/intern/camera.c
index 5172b067eba..46b079fb42e 100644
--- a/source/blender/blenkernel/intern/camera.c
+++ b/source/blender/blenkernel/intern/camera.c
@@ -122,18 +122,17 @@ static void camera_foreach_id(ID *id, LibraryForeachIDData *data)
 static void camera_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   Camera *cam = (Camera *)id;
-  if (cam->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* write LibData */
-    BLO_write_id_struct(writer, Camera, id_address, &cam->id);
-    BKE_id_blend_write(writer, &cam->id);
 
-    if (cam->adt) {
-      BKE_animdata_blend_write(writer, cam->adt);
-    }
+  /* write LibData */
+  BLO_write_id_struct(writer, Camera, id_address, &cam->id);
+  BKE_id_blend_write(writer, &cam->id);
 
-    LISTBASE_FOREACH (CameraBGImage *, bgpic, &cam->bg_images) {
-      BLO_write_struct(writer, CameraBGImage, bgpic);
-    }
+  if (cam->adt) {
+    BKE_animdata_blend_write(writer, cam->adt);
+  }
+
+  LISTBASE_FOREACH (CameraBGImage *, bgpic, &cam->bg_images) {
+    BLO_write_struct(writer, CameraBGImage, bgpic);
   }
 }
 
diff --git a/source/blender/blenkernel/intern/cloth.c b/source/blender/blenkernel/intern/cloth.c
index f5ff936e18b..080a7c90c46 100644
--- a/source/blender/blenkernel/intern/cloth.c
+++ b/source/blender/blenkernel/intern/cloth.c
@@ -42,6 +42,7 @@
 #include "BKE_cloth.h"
 #include "BKE_effect.h"
 #include "BKE_global.h"
+#include "BKE_lib_id.h"
 #include "BKE_mesh.h"
 #include "BKE_mesh_runtime.h"
 #include "BKE_modifier.h"
@@ -1574,7 +1575,7 @@ static bool cloth_build_springs(ClothModifierData *clmd, Mesh *mesh)
           BLI_edgeset_free(existing_vert_pairs);
           free_bvhtree_from_mesh(&treedata);
           if (tmp_mesh) {
-            BKE_mesh_free(tmp_mesh);
+            BKE_id_free(NULL, &tmp_mesh->id);
           }
           return false;
         }
@@ -1583,7 +1584,7 @@ static bool cloth_build_springs(ClothModifierData *clmd, Mesh *mesh)
     BLI_edgeset_free(existing_vert_pairs);
     free_bvhtree_from_mesh(&treedata);
     if (tmp_mesh) {
-      BKE_mesh_free(tmp_mesh);
+      BKE_id_free(NULL, &tmp_mesh->id);
     }
     BLI_rng_free(rng);
   }
diff --git a/source/blender/blenkernel/intern/collection.c b/source/blender/blenkernel/intern/collection.c
index b62e33ff564..d36e9b67d00 100644
--- a/source/blender/blenkernel/intern/collection.c
+++ b/source/blender/blenkernel/intern/collection.c
@@ -214,20 +214,19 @@ void BKE_collection_blend_write_nolib(BlendWriter *writer, Collection *collectio
 static void collection_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   Collection *collection = (Collection *)id;
-  if (collection->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* Clean up, important in undo case to reduce false detection of changed data-blocks. */
-    collection->flag &= ~COLLECTION_HAS_OBJECT_CACHE;
-    collection->flag &= ~COLLECTION_HAS_OBJECT_CACHE_INSTANCED;
-    collection->tag = 0;
-    BLI_listbase_clear(&collection->object_cache);
-    BLI_listbase_clear(&collection->object_cache_instanced);
-    BLI_listbase_clear(&collection->parents);
 
-    /* write LibData */
-    BLO_write_id_struct(writer, Collection, id_address, &collection->id);
+  /* Clean up, important in undo case to reduce false detection of changed data-blocks. */
+  collection->flag &= ~COLLECTION_HAS_OBJECT_CACHE;
+  collection->flag &= ~COLLECTION_HAS_OBJECT_CACHE_INSTANCED;
+  collection->tag = 0;
+  BLI_listbase_clear(&collection->object_cache);
+  BLI_listbase_clear(&collection->object_cache_instanced);
+  BLI_listbase_clear(&collection->parents);
 
-    BKE_collection_blend_write_nolib(writer, collection);
-  }
+  /* write LibData */
+  BLO_write_id_struct(writer, Collection, id_address, &collection->id);
+
+  BKE_collection_blend_write_nolib(writer, collection);
 }
 
 #ifdef USE_COLLECTION_COMPAT_28
diff --git a/source/blender/blenkernel/intern/constraint.c b/source/blender/blenkernel/intern/constraint.c
index 4b26022039e..30aa22387d0 100644
--- a/source/blender/blenkernel/intern/constraint.c
+++ b/source/blender/blenkernel/intern/constraint.c
@@ -5430,6 +5430,11 @@ static void transformcache_evaluate(bConstraint *con, bConstraintOb *cob, ListBa
     return;
   }
 
+  /* Do not process data if using a render time procedural. */
+  if (BKE_cache_file_uses_render_procedural(cache_file, scene, DEG_get_mode(cob->depsgraph))) {
+    return;
+  }
+
   const float frame = DEG_get_ctime(cob->depsgraph);
   const float time = BKE_cachefile_time_offset(cache_file, frame, FPS);
 
diff --git a/source/blender/blenkernel/intern/curve.c b/source/blender/blenkernel/intern/curve.c
index db0ea71e233..397838e6904 100644
--- a/source/blender/blenkernel/intern/curve.c
+++ b/source/blender/blenkernel/intern/curve.c
@@ -146,51 +146,50 @@ static void curve_foreach_id(ID *id, LibraryForeachIDData *data)
 static void curve_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   Curve *cu = (Curve *)id;
-  if (cu->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* Clean up, important in undo case to reduce false detection of changed datablocks. */
-    cu->editnurb = NULL;
-    cu->editfont = NULL;
-    cu->batch_cache = NULL;
 
-    /* write LibData */
-    BLO_write_id_struct(writer, Curve, id_address, &cu->id);
-    BKE_id_blend_write(writer, &cu->id);
+  /* Clean up, important in undo case to reduce false detection of changed datablocks. */
+  cu->editnurb = NULL;
+  cu->editfont = NULL;
+  cu->batch_cache = NULL;
 
-    /* direct data */
-    BLO_write_pointer_array(writer, cu->totcol, cu->mat);
-    if (cu->adt) {
-      BKE_animdata_blend_write(writer, cu->adt);
-    }
+  /* write LibData */
+  BLO_write_id_struct(writer, Curve, id_address, &cu->id);
+  BKE_id_blend_write(writer, &cu->id);
+
+  /* direct data */
+  BLO_write_pointer_array(writer, cu->totcol, cu->mat);
+  if (cu->adt) {
+    BKE_animdata_blend_write(writer, cu->adt);
+  }
 
-    if (cu->vfont) {
-      BLO_write_raw(writer, cu->len + 1, cu->str);
-      BLO_write_struct_array(writer, CharInfo, cu->len_char32 + 1, cu->strinfo);
-      BLO_write_struct_array(writer, TextBox, cu->totbox, cu->tb);
+  if (cu->vfont) {
+    BLO_write_raw(writer, cu->len + 1, cu->str);
+    BLO_write_struct_array(writer, CharInfo, cu->len_char32 + 1, cu->strinfo);
+    BLO_write_struct_array(writer, TextBox, cu->totbox, cu->tb);
+  }
+  else {
+    /* is also the order of reading */
+    LISTBASE_FOREACH (Nurb *, nu, &cu->nurb) {
+      BLO_write_struct(writer, Nurb, nu);
     }
-    else {
-      /* is also the order of reading */
-      LISTBASE_FOREACH (Nurb *, nu, &cu->nurb) {
-        BLO_write_struct(writer, Nurb, nu);
+    LISTBASE_FOREACH (Nurb *, nu, &cu->nurb) {
+      if (nu->type == CU_BEZIER) {
+        BLO_write_struct_array(writer, BezTriple, nu->pntsu, nu->bezt);
       }
-      LISTBASE_FOREACH (Nurb *, nu, &cu->nurb) {
-        if (nu->type == CU_BEZIER) {
-          BLO_write_struct_array(writer, BezTriple, nu->pntsu, nu->bezt);
+      else {
+        BLO_write_struct_array(writer, BPoint, nu->pntsu * nu->pntsv, nu->bp);
+        if (nu->knotsu) {
+          BLO_write_float_array(writer, KNOTSU(nu), nu->knotsu);
         }
-        else {
-          BLO_write_struct_array(writer, BPoint, nu->pntsu * nu->pntsv, nu->bp);
-          if (nu->knotsu) {
-            BLO_write_float_array(writer, KNOTSU(nu), nu->knotsu);
-          }
-          if (nu->knotsv) {
-            BLO_write_float_array(writer, KNOTSV(nu), nu->knotsv);
-          }
+        if (nu->knotsv) {
+          BLO_write_float_array(writer, KNOTSV(nu), nu->knotsv);
         }
       }
     }
+  }
 
-    if (cu->bevel_profile != NULL) {
-      BKE_curveprofile_blend_write(writer, cu->bevel_profile);
-    }
+  if (cu->bevel_profile != NULL) {
+    BKE_curveprofile_blend_write(writer, cu->bevel_profile);
   }
 }
 
@@ -2331,17 +2330,21 @@ static void make_bevel_list_3D_minimum_twist(BevList *bl)
   bevp1 = bevp2 + (bl->nr - 1);
   bevp0 = bevp1 - 1;
 
-  nr = bl->nr;
-  while (nr--) {
+  /* The ordinal of the point being adjusted (bevp2). First point is 1. */
 
-    if (nr + 3 > bl->nr) { /* first time and second time, otherwise first point adjusts last */
-      vec_to_quat(bevp1->quat, bevp1->dir, 5, 1);
-    }
-    else {
-      minimum_twist_between_two_points(bevp1, bevp0);
-    }
+  /* First point is the reference, don't adjust.
+   * Skip this point in the following loop. */
+  if (bl->nr > 0) {
+    vec_to_quat(bevp2->quat, bevp2->dir, 5, 1);
 
-    bevp0 = bevp1;
+    bevp0 = bevp1; /* bevp0 is unused */
+    bevp1 = bevp2;
+    bevp2++;
+  }
+  for (nr = 1; nr < bl->nr; nr++) {
+    minimum_twist_between_two_points(bevp2, bevp1);
+
+    bevp0 = bevp1; /* bevp0 is unused */
     bevp1 = bevp2;
     bevp2++;
   }
diff --git a/source/blender/blenkernel/intern/font.c b/source/blender/blenkernel/intern/font.c
index 72add476bfe..c1765967238 100644
--- a/source/blender/blenkernel/intern/font.c
+++ b/source/blender/blenkernel/intern/font.c
@@ -126,23 +126,22 @@ static void vfont_blend_write(BlendWriter *writer, ID *id, const void *id_addres
 {
   VFont *vf = (VFont *)id;
   const bool is_undo = BLO_write_is_undo(writer);
-  if (vf->id.us > 0 || is_undo) {
-    /* Clean up, important in undo case to reduce false detection of changed datablocks. */
-    vf->data = NULL;
-    vf->temp_pf = NULL;
-
-    /* Do not store packed files in case this is a library override ID. */
-    if (ID_IS_OVERRIDE_LIBRARY(vf) && !is_undo) {
-      vf->packedfile = NULL;
-    }
 
-    /* write LibData */
-    BLO_write_id_struct(writer, VFont, id_address, &vf->id);
-    BKE_id_blend_write(writer, &vf->id);
+  /* Clean up, important in undo case to reduce false detection of changed datablocks. */
+  vf->data = NULL;
+  vf->temp_pf = NULL;
 
-    /* direct data */
-    BKE_packedfile_blend_write(writer, vf->packedfile);
+  /* Do not store packed files in case this is a library override ID. */
+  if (ID_IS_OVERRIDE_LIBRARY(vf) && !is_undo) {
+    vf->packedfile = NULL;
   }
+
+  /* write LibData */
+  BLO_write_id_struct(writer, VFont, id_address, &vf->id);
+  BKE_id_blend_write(writer, &vf->id);
+
+  /* direct data */
+  BKE_packedfile_blend_write(writer, vf->packedfile);
 }
 
 static void vfont_blend_read_data(BlendDataReader *reader, ID *id)
diff --git a/source/blender/blenkernel/intern/gpencil.c b/source/blender/blenkernel/intern/gpencil.c
index f566e18fb2f..9062fd2d39c 100644
--- a/source/blender/blenkernel/intern/gpencil.c
+++ b/source/blender/blenkernel/intern/gpencil.c
@@ -131,7 +131,7 @@ static void greasepencil_free_data(ID *id)
 {
   /* Really not ideal, but for now will do... In theory custom behaviors like not freeing cache
    * should be handled through specific API, and not be part of the generic one. */
-  BKE_gpencil_free((bGPdata *)id, true);
+  BKE_gpencil_free_data((bGPdata *)id, true);
 }
 
 static void greasepencil_foreach_id(ID *id, LibraryForeachIDData *data)
@@ -150,47 +150,46 @@ static void greasepencil_foreach_id(ID *id, LibraryForeachIDData *data)
 static void greasepencil_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   bGPdata *gpd = (bGPdata *)id;
-  if (gpd->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* Clean up, important in undo case to reduce false detection of changed data-blocks. */
-    /* XXX not sure why the whole run-time data is not cleared in reading code,
-     * for now mimicking it here. */
-    gpd->runtime.sbuffer = NULL;
-    gpd->runtime.sbuffer_used = 0;
-    gpd->runtime.sbuffer_size = 0;
-    gpd->runtime.tot_cp_points = 0;
 
-    /* write gpd data block to file */
-    BLO_write_id_struct(writer, bGPdata, id_address, &gpd->id);
-    BKE_id_blend_write(writer, &gpd->id);
+  /* Clean up, important in undo case to reduce false detection of changed data-blocks. */
+  /* XXX not sure why the whole run-time data is not cleared in reading code,
+   * for now mimicking it here. */
+  gpd->runtime.sbuffer = NULL;
+  gpd->runtime.sbuffer_used = 0;
+  gpd->runtime.sbuffer_size = 0;
+  gpd->runtime.tot_cp_points = 0;
 
-    if (gpd->adt) {
-      BKE_animdata_blend_write(writer, gpd->adt);
-    }
+  /* write gpd data block to file */
+  BLO_write_id_struct(writer, bGPdata, id_address, &gpd->id);
+  BKE_id_blend_write(writer, &gpd->id);
 
-    BKE_defbase_blend_write(writer, &gpd->vertex_group_names);
+  if (gpd->adt) {
+    BKE_animdata_blend_write(writer, gpd->adt);
+  }
 
-    BLO_write_pointer_array(writer, gpd->totcol, gpd->mat);
+  BKE_defbase_blend_write(writer, &gpd->vertex_group_names);
 
-    /* write grease-pencil layers to file */
-    BLO_write_struct_list(writer, bGPDlayer, &gpd->layers);
-    LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
-      /* Write mask list. */
-      BLO_write_struct_list(writer, bGPDlayer_Mask, &gpl->mask_layers);
-      /* write this layer's frames to file */
-      BLO_write_struct_list(writer, bGPDframe, &gpl->frames);
-      LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
-        /* write strokes */
-        BLO_write_struct_list(writer, bGPDstroke, &gpf->strokes);
-        LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
-          BLO_write_struct_array(writer, bGPDspoint, gps->totpoints, gps->points);
-          BLO_write_struct_array(writer, bGPDtriangle, gps->tot_triangles, gps->triangles);
-          BKE_defvert_blend_write(writer, gps->totpoints, gps->dvert);
-          if (gps->editcurve != NULL) {
-            bGPDcurve *gpc = gps->editcurve;
-            BLO_write_struct(writer, bGPDcurve, gpc);
-            BLO_write_struct_array(
-                writer, bGPDcurve_point, gpc->tot_curve_points, gpc->curve_points);
-          }
+  BLO_write_pointer_array(writer, gpd->totcol, gpd->mat);
+
+  /* write grease-pencil layers to file */
+  BLO_write_struct_list(writer, bGPDlayer, &gpd->layers);
+  LISTBASE_FOREACH (bGPDlayer *, gpl, &gpd->layers) {
+    /* Write mask list. */
+    BLO_write_struct_list(writer, bGPDlayer_Mask, &gpl->mask_layers);
+    /* write this layer's frames to file */
+    BLO_write_struct_list(writer, bGPDframe, &gpl->frames);
+    LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
+      /* write strokes */
+      BLO_write_struct_list(writer, bGPDstroke, &gpf->strokes);
+      LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
+        BLO_write_struct_array(writer, bGPDspoint, gps->totpoints, gps->points);
+        BLO_write_struct_array(writer, bGPDtriangle, gps->tot_triangles, gps->triangles);
+        BKE_defvert_blend_write(writer, gps->totpoints, gps->dvert);
+        if (gps->editcurve != NULL) {
+          bGPDcurve *gpc = gps->editcurve;
+          BLO_write_struct(writer, bGPDcurve, gpc);
+          BLO_write_struct_array(
+              writer, bGPDcurve_point, gpc->tot_curve_points, gpc->curve_points);
         }
       }
     }
@@ -496,7 +495,7 @@ void BKE_gpencil_free_layers(ListBase *list)
 }
 
 /** Free (or release) any data used by this grease pencil (does not free the gpencil itself). */
-void BKE_gpencil_free(bGPdata *gpd, bool free_all)
+void BKE_gpencil_free_data(bGPdata *gpd, bool free_all)
 {
   /* free layers */
   BKE_gpencil_free_layers(&gpd->layers);
@@ -519,7 +518,7 @@ void BKE_gpencil_free(bGPdata *gpd, bool free_all)
  */
 void BKE_gpencil_eval_delete(bGPdata *gpd_eval)
 {
-  BKE_gpencil_free(gpd_eval, true);
+  BKE_gpencil_free_data(gpd_eval, true);
   BKE_libblock_free_data(&gpd_eval->id, false);
   BLI_assert(!gpd_eval->id.py_instance); /* Or call #BKE_libblock_free_data_py. */
   MEM_freeN(gpd_eval);
diff --git a/source/blender/blenkernel/intern/hair.c b/source/blender/blenkernel/intern/hair.c
index 2894d6daf23..af7cc0acb57 100644
--- a/source/blender/blenkernel/intern/hair.c
+++ b/source/blender/blenkernel/intern/hair.c
@@ -114,32 +114,31 @@ static void hair_foreach_id(ID *id, LibraryForeachIDData *data)
 static void hair_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   Hair *hair = (Hair *)id;
-  if (hair->id.us > 0 || BLO_write_is_undo(writer)) {
-    CustomDataLayer *players = NULL, players_buff[CD_TEMP_CHUNK_SIZE];
-    CustomDataLayer *clayers = NULL, clayers_buff[CD_TEMP_CHUNK_SIZE];
-    CustomData_blend_write_prepare(&hair->pdata, &players, players_buff, ARRAY_SIZE(players_buff));
-    CustomData_blend_write_prepare(&hair->cdata, &clayers, clayers_buff, ARRAY_SIZE(clayers_buff));
-
-    /* Write LibData */
-    BLO_write_id_struct(writer, Hair, id_address, &hair->id);
-    BKE_id_blend_write(writer, &hair->id);
-
-    /* Direct data */
-    CustomData_blend_write(writer, &hair->pdata, players, hair->totpoint, CD_MASK_ALL, &hair->id);
-    CustomData_blend_write(writer, &hair->cdata, clayers, hair->totcurve, CD_MASK_ALL, &hair->id);
-
-    BLO_write_pointer_array(writer, hair->totcol, hair->mat);
-    if (hair->adt) {
-      BKE_animdata_blend_write(writer, hair->adt);
-    }
 
-    /* Remove temporary data. */
-    if (players && players != players_buff) {
-      MEM_freeN(players);
-    }
-    if (clayers && clayers != clayers_buff) {
-      MEM_freeN(clayers);
-    }
+  CustomDataLayer *players = NULL, players_buff[CD_TEMP_CHUNK_SIZE];
+  CustomDataLayer *clayers = NULL, clayers_buff[CD_TEMP_CHUNK_SIZE];
+  CustomData_blend_write_prepare(&hair->pdata, &players, players_buff, ARRAY_SIZE(players_buff));
+  CustomData_blend_write_prepare(&hair->cdata, &clayers, clayers_buff, ARRAY_SIZE(clayers_buff));
+
+  /* Write LibData */
+  BLO_write_id_struct(writer, Hair, id_address, &hair->id);
+  BKE_id_blend_write(writer, &hair->id);
+
+  /* Direct data */
+  CustomData_blend_write(writer, &hair->pdata, players, hair->totpoint, CD_MASK_ALL, &hair->id);
+  CustomData_blend_write(writer, &hair->cdata, clayers, hair->totcurve, CD_MASK_ALL, &hair->id);
+
+  BLO_write_pointer_array(writer, hair->totcol, hair->mat);
+  if (hair->adt) {
+    BKE_animdata_blend_write(writer, hair->adt);
+  }
+
+  /* Remove temporary data. */
+  if (players && players != players_buff) {
+    MEM_freeN(players);
+  }
+  if (clayers && clayers != clayers_buff) {
+    MEM_freeN(clayers);
   }
 }
 
diff --git a/source/blender/blenkernel/intern/image.c b/source/blender/blenkernel/intern/image.c
index d2ab54de697..d87290e1eb4 100644
--- a/source/blender/blenkernel/intern/image.c
+++ b/source/blender/blenkernel/intern/image.c
@@ -229,12 +229,26 @@ static void image_blend_write(BlendWriter *writer, ID *id, const void *id_addres
 {
   Image *ima = (Image *)id;
   const bool is_undo = BLO_write_is_undo(writer);
-  if (ima->id.us > 0 || is_undo) {
-    ImagePackedFile *imapf;
 
-    BLI_assert(ima->packedfile == NULL);
+  /* Clear all data that isn't read to reduce false detection of changed image during memfile undo.
+   */
+  ima->lastused = 0;
+  ima->cache = NULL;
+  ima->gpuflag = 0;
+  BLI_listbase_clear(&ima->anims);
+  BLI_listbase_clear(&ima->gpu_refresh_areas);
+  for (int i = 0; i < 3; i++) {
+    for (int j = 0; j < 2; j++) {
+      ima->gputexture[i][j] = NULL;
+    }
+  }
+
+  ImagePackedFile *imapf;
+
+  BLI_assert(ima->packedfile == NULL);
+  if (!is_undo) {
     /* Do not store packed files in case this is a library override ID. */
-    if (ID_IS_OVERRIDE_LIBRARY(ima) && !is_undo) {
+    if (ID_IS_OVERRIDE_LIBRARY(ima)) {
       BLI_listbase_clear(&ima->packedfiles);
     }
     else {
@@ -244,29 +258,29 @@ static void image_blend_write(BlendWriter *writer, ID *id, const void *id_addres
         ima->packedfile = imapf->packedfile;
       }
     }
+  }
 
-    /* write LibData */
-    BLO_write_id_struct(writer, Image, id_address, &ima->id);
-    BKE_id_blend_write(writer, &ima->id);
+  /* write LibData */
+  BLO_write_id_struct(writer, Image, id_address, &ima->id);
+  BKE_id_blend_write(writer, &ima->id);
 
-    for (imapf = ima->packedfiles.first; imapf; imapf = imapf->next) {
-      BLO_write_struct(writer, ImagePackedFile, imapf);
-      BKE_packedfile_blend_write(writer, imapf->packedfile);
-    }
+  for (imapf = ima->packedfiles.first; imapf; imapf = imapf->next) {
+    BLO_write_struct(writer, ImagePackedFile, imapf);
+    BKE_packedfile_blend_write(writer, imapf->packedfile);
+  }
 
-    BKE_previewimg_blend_write(writer, ima->preview);
+  BKE_previewimg_blend_write(writer, ima->preview);
 
-    LISTBASE_FOREACH (ImageView *, iv, &ima->views) {
-      BLO_write_struct(writer, ImageView, iv);
-    }
-    BLO_write_struct(writer, Stereo3dFormat, ima->stereo3d_format);
+  LISTBASE_FOREACH (ImageView *, iv, &ima->views) {
+    BLO_write_struct(writer, ImageView, iv);
+  }
+  BLO_write_struct(writer, Stereo3dFormat, ima->stereo3d_format);
 
-    BLO_write_struct_list(writer, ImageTile, &ima->tiles);
+  BLO_write_struct_list(writer, ImageTile, &ima->tiles);
 
-    ima->packedfile = NULL;
+  ima->packedfile = NULL;
 
-    BLO_write_struct_list(writer, RenderSlot, &ima->renderslots);
-  }
+  BLO_write_struct_list(writer, RenderSlot, &ima->renderslots);
 }
 
 static void image_blend_read_data(BlendDataReader *reader, ID *id)
@@ -300,6 +314,7 @@ static void image_blend_read_data(BlendDataReader *reader, ID *id)
   LISTBASE_FOREACH (ImageTile *, tile, &ima->tiles) {
     tile->ok = IMA_OK;
   }
+  ima->lastused = 0;
   ima->gpuflag = 0;
   BLI_listbase_clear(&ima->gpu_refresh_areas);
 }
@@ -519,7 +534,7 @@ void BKE_image_free_buffers(Image *ima)
 }
 
 /** Free (or release) any data used by this image (does not free the image itself). */
-void BKE_image_free(Image *ima)
+void BKE_image_free_data(Image *ima)
 {
   image_free_data(&ima->id);
 }
diff --git a/source/blender/blenkernel/intern/image_save.c b/source/blender/blenkernel/intern/image_save.c
index be86da05b57..f93ede517a9 100644
--- a/source/blender/blenkernel/intern/image_save.c
+++ b/source/blender/blenkernel/intern/image_save.c
@@ -409,7 +409,8 @@ bool BKE_image_save(
       BKE_reportf(reports,
                   RPT_ERROR,
                   "When saving a tiled image, the path '%s' must contain the UDIM tile number %d",
-                  opts->filepath, first_tile->tile_number);
+                  opts->filepath,
+                  first_tile->tile_number);
       return false;
     }
 
diff --git a/source/blender/blenkernel/intern/key.c b/source/blender/blenkernel/intern/key.c
index 724216bee6c..f79058dcf21 100644
--- a/source/blender/blenkernel/intern/key.c
+++ b/source/blender/blenkernel/intern/key.c
@@ -114,27 +114,26 @@ static void shapekey_blend_write(BlendWriter *writer, ID *id, const void *id_add
 {
   Key *key = (Key *)id;
   const bool is_undo = BLO_write_is_undo(writer);
-  if (key->id.us > 0 || is_undo) {
-    /* write LibData */
-    BLO_write_id_struct(writer, Key, id_address, &key->id);
-    BKE_id_blend_write(writer, &key->id);
-
-    if (key->adt) {
-      BKE_animdata_blend_write(writer, key->adt);
-    }
-
-    /* direct data */
-    LISTBASE_FOREACH (KeyBlock *, kb, &key->block) {
-      KeyBlock tmp_kb = *kb;
-      /* Do not store actual geometry data in case this is a library override ID. */
-      if (ID_IS_OVERRIDE_LIBRARY(key) && !is_undo) {
-        tmp_kb.totelem = 0;
-        tmp_kb.data = NULL;
-      }
-      BLO_write_struct_at_address(writer, KeyBlock, kb, &tmp_kb);
-      if (tmp_kb.data != NULL) {
-        BLO_write_raw(writer, tmp_kb.totelem * key->elemsize, tmp_kb.data);
-      }
+
+  /* write LibData */
+  BLO_write_id_struct(writer, Key, id_address, &key->id);
+  BKE_id_blend_write(writer, &key->id);
+
+  if (key->adt) {
+    BKE_animdata_blend_write(writer, key->adt);
+  }
+
+  /* direct data */
+  LISTBASE_FOREACH (KeyBlock *, kb, &key->block) {
+    KeyBlock tmp_kb = *kb;
+    /* Do not store actual geometry data in case this is a library override ID. */
+    if (ID_IS_OVERRIDE_LIBRARY(key) && !is_undo) {
+      tmp_kb.totelem = 0;
+      tmp_kb.data = NULL;
+    }
+    BLO_write_struct_at_address(writer, KeyBlock, kb, &tmp_kb);
+    if (tmp_kb.data != NULL) {
+      BLO_write_raw(writer, tmp_kb.totelem * key->elemsize, tmp_kb.data);
     }
   }
 }
@@ -246,7 +245,7 @@ typedef struct WeightsArrayCache {
 } WeightsArrayCache;
 
 /** Free (or release) any data used by this shapekey (does not free the key itself). */
-void BKE_key_free(Key *key)
+void BKE_key_free_data(Key *key)
 {
   shapekey_free_data(&key->id);
 }
diff --git a/source/blender/blenkernel/intern/lattice.c b/source/blender/blenkernel/intern/lattice.c
index 9875d776d33..e804f32e5a6 100644
--- a/source/blender/blenkernel/intern/lattice.c
+++ b/source/blender/blenkernel/intern/lattice.c
@@ -137,26 +137,25 @@ static void lattice_foreach_id(ID *id, LibraryForeachIDData *data)
 static void lattice_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   Lattice *lt = (Lattice *)id;
-  if (lt->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* Clean up, important in undo case to reduce false detection of changed datablocks. */
-    lt->editlatt = NULL;
-    lt->batch_cache = NULL;
-
-    /* write LibData */
-    BLO_write_id_struct(writer, Lattice, id_address, &lt->id);
-    BKE_id_blend_write(writer, &lt->id);
-
-    /* write animdata */
-    if (lt->adt) {
-      BKE_animdata_blend_write(writer, lt->adt);
-    }
 
-    /* direct data */
-    BLO_write_struct_array(writer, BPoint, lt->pntsu * lt->pntsv * lt->pntsw, lt->def);
+  /* Clean up, important in undo case to reduce false detection of changed datablocks. */
+  lt->editlatt = NULL;
+  lt->batch_cache = NULL;
+
+  /* write LibData */
+  BLO_write_id_struct(writer, Lattice, id_address, &lt->id);
+  BKE_id_blend_write(writer, &lt->id);
 
-    BKE_defbase_blend_write(writer, &lt->vertex_group_names);
-    BKE_defvert_blend_write(writer, lt->pntsu * lt->pntsv * lt->pntsw, lt->dvert);
+  /* write animdata */
+  if (lt->adt) {
+    BKE_animdata_blend_write(writer, lt->adt);
   }
+
+  /* direct data */
+  BLO_write_struct_array(writer, BPoint, lt->pntsu * lt->pntsv * lt->pntsw, lt->def);
+
+  BKE_defbase_blend_write(writer, &lt->vertex_group_names);
+  BKE_defvert_blend_write(writer, lt->pntsu * lt->pntsv * lt->pntsw, lt->dvert);
 }
 
 static void lattice_blend_read_data(BlendDataReader *reader, ID *id)
diff --git a/source/blender/blenkernel/intern/lib_query.c b/source/blender/blenkernel/intern/lib_query.c
index 977e53c8474..9400458376d 100644
--- a/source/blender/blenkernel/intern/lib_query.c
+++ b/source/blender/blenkernel/intern/lib_query.c
@@ -88,8 +88,8 @@ bool BKE_lib_query_foreachid_process(LibraryForeachIDData *data, ID **id_pp, int
 
     /* Update the callback flags with some extra information regarding overrides: all 'loopback',
      * 'internal', 'embedded' etc. ID pointers are never overridable. */
-    if (cb_flag & (IDWALK_CB_INTERNAL | IDWALK_CB_EMBEDDED | IDWALK_CB_LOOPBACK |
-                   IDWALK_CB_OVERRIDE_LIBRARY_REFERENCE)) {
+    if (cb_flag &
+        (IDWALK_CB_INTERNAL | IDWALK_CB_LOOPBACK | IDWALK_CB_OVERRIDE_LIBRARY_REFERENCE)) {
       cb_flag |= IDWALK_CB_OVERRIDE_LIBRARY_NOT_OVERRIDABLE;
     }
 
diff --git a/source/blender/blenkernel/intern/light.c b/source/blender/blenkernel/intern/light.c
index d91d80ac683..c2b71b85973 100644
--- a/source/blender/blenkernel/intern/light.c
+++ b/source/blender/blenkernel/intern/light.c
@@ -136,27 +136,26 @@ static void light_foreach_id(ID *id, LibraryForeachIDData *data)
 static void light_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   Light *la = (Light *)id;
-  if (la->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* write LibData */
-    BLO_write_id_struct(writer, Light, id_address, &la->id);
-    BKE_id_blend_write(writer, &la->id);
 
-    if (la->adt) {
-      BKE_animdata_blend_write(writer, la->adt);
-    }
+  /* write LibData */
+  BLO_write_id_struct(writer, Light, id_address, &la->id);
+  BKE_id_blend_write(writer, &la->id);
 
-    if (la->curfalloff) {
-      BKE_curvemapping_blend_write(writer, la->curfalloff);
-    }
+  if (la->adt) {
+    BKE_animdata_blend_write(writer, la->adt);
+  }
 
-    /* Node-tree is integral part of lights, no libdata. */
-    if (la->nodetree) {
-      BLO_write_struct(writer, bNodeTree, la->nodetree);
-      ntreeBlendWrite(writer, la->nodetree);
-    }
+  if (la->curfalloff) {
+    BKE_curvemapping_blend_write(writer, la->curfalloff);
+  }
 
-    BKE_previewimg_blend_write(writer, la->preview);
+  /* Node-tree is integral part of lights, no libdata. */
+  if (la->nodetree) {
+    BLO_write_struct(writer, bNodeTree, la->nodetree);
+    ntreeBlendWrite(writer, la->nodetree);
   }
+
+  BKE_previewimg_blend_write(writer, la->preview);
 }
 
 static void light_blend_read_data(BlendDataReader *reader, ID *id)
diff --git a/source/blender/blenkernel/intern/lightprobe.c b/source/blender/blenkernel/intern/lightprobe.c
index b09aed82921..15733af8ef0 100644
--- a/source/blender/blenkernel/intern/lightprobe.c
+++ b/source/blender/blenkernel/intern/lightprobe.c
@@ -60,14 +60,13 @@ static void lightprobe_foreach_id(ID *id, LibraryForeachIDData *data)
 static void lightprobe_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   LightProbe *prb = (LightProbe *)id;
-  if (prb->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* write LibData */
-    BLO_write_id_struct(writer, LightProbe, id_address, &prb->id);
-    BKE_id_blend_write(writer, &prb->id);
-
-    if (prb->adt) {
-      BKE_animdata_blend_write(writer, prb->adt);
-    }
+
+  /* write LibData */
+  BLO_write_id_struct(writer, LightProbe, id_address, &prb->id);
+  BKE_id_blend_write(writer, &prb->id);
+
+  if (prb->adt) {
+    BKE_animdata_blend_write(writer, prb->adt);
   }
 }
 
diff --git a/source/blender/blenkernel/intern/linestyle.c b/source/blender/blenkernel/intern/linestyle.c
index 26d9ab7a8c7..19030fca38b 100644
--- a/source/blender/blenkernel/intern/linestyle.c
+++ b/source/blender/blenkernel/intern/linestyle.c
@@ -457,28 +457,27 @@ static void write_linestyle_geometry_modifiers(BlendWriter *writer, ListBase *mo
 static void linestyle_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   FreestyleLineStyle *linestyle = (FreestyleLineStyle *)id;
-  if (linestyle->id.us > 0 || BLO_write_is_undo(writer)) {
-    BLO_write_id_struct(writer, FreestyleLineStyle, id_address, &linestyle->id);
-    BKE_id_blend_write(writer, &linestyle->id);
 
-    if (linestyle->adt) {
-      BKE_animdata_blend_write(writer, linestyle->adt);
-    }
+  BLO_write_id_struct(writer, FreestyleLineStyle, id_address, &linestyle->id);
+  BKE_id_blend_write(writer, &linestyle->id);
 
-    write_linestyle_color_modifiers(writer, &linestyle->color_modifiers);
-    write_linestyle_alpha_modifiers(writer, &linestyle->alpha_modifiers);
-    write_linestyle_thickness_modifiers(writer, &linestyle->thickness_modifiers);
-    write_linestyle_geometry_modifiers(writer, &linestyle->geometry_modifiers);
-    for (int a = 0; a < MAX_MTEX; a++) {
-      if (linestyle->mtex[a]) {
-        BLO_write_struct(writer, MTex, linestyle->mtex[a]);
-      }
-    }
-    if (linestyle->nodetree) {
-      BLO_write_struct(writer, bNodeTree, linestyle->nodetree);
-      ntreeBlendWrite(writer, linestyle->nodetree);
+  if (linestyle->adt) {
+    BKE_animdata_blend_write(writer, linestyle->adt);
+  }
+
+  write_linestyle_color_modifiers(writer, &linestyle->color_modifiers);
+  write_linestyle_alpha_modifiers(writer, &linestyle->alpha_modifiers);
+  write_linestyle_thickness_modifiers(writer, &linestyle->thickness_modifiers);
+  write_linestyle_geometry_modifiers(writer, &linestyle->geometry_modifiers);
+  for (int a = 0; a < MAX_MTEX; a++) {
+    if (linestyle->mtex[a]) {
+      BLO_write_struct(writer, MTex, linestyle->mtex[a]);
     }
   }
+  if (linestyle->nodetree) {
+    BLO_write_struct(writer, bNodeTree, linestyle->nodetree);
+    ntreeBlendWrite(writer, linestyle->nodetree);
+  }
 }
 
 static void direct_link_linestyle_color_modifier(BlendDataReader *reader,
diff --git a/source/blender/blenkernel/intern/mask.c b/source/blender/blenkernel/intern/mask.c
index f40d1db60ff..a93fcb6e8e0 100644
--- a/source/blender/blenkernel/intern/mask.c
+++ b/source/blender/blenkernel/intern/mask.c
@@ -101,48 +101,47 @@ static void mask_foreach_id(ID *id, LibraryForeachIDData *data)
 static void mask_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   Mask *mask = (Mask *)id;
-  if (mask->id.us > 0 || BLO_write_is_undo(writer)) {
-    MaskLayer *masklay;
 
-    BLO_write_id_struct(writer, Mask, id_address, &mask->id);
-    BKE_id_blend_write(writer, &mask->id);
+  MaskLayer *masklay;
 
-    if (mask->adt) {
-      BKE_animdata_blend_write(writer, mask->adt);
-    }
+  BLO_write_id_struct(writer, Mask, id_address, &mask->id);
+  BKE_id_blend_write(writer, &mask->id);
 
-    for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
-      MaskSpline *spline;
-      MaskLayerShape *masklay_shape;
+  if (mask->adt) {
+    BKE_animdata_blend_write(writer, mask->adt);
+  }
 
-      BLO_write_struct(writer, MaskLayer, masklay);
+  for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {
+    MaskSpline *spline;
+    MaskLayerShape *masklay_shape;
 
-      for (spline = masklay->splines.first; spline; spline = spline->next) {
-        int i;
+    BLO_write_struct(writer, MaskLayer, masklay);
 
-        void *points_deform = spline->points_deform;
-        spline->points_deform = NULL;
+    for (spline = masklay->splines.first; spline; spline = spline->next) {
+      int i;
 
-        BLO_write_struct(writer, MaskSpline, spline);
-        BLO_write_struct_array(writer, MaskSplinePoint, spline->tot_point, spline->points);
+      void *points_deform = spline->points_deform;
+      spline->points_deform = NULL;
 
-        spline->points_deform = points_deform;
+      BLO_write_struct(writer, MaskSpline, spline);
+      BLO_write_struct_array(writer, MaskSplinePoint, spline->tot_point, spline->points);
 
-        for (i = 0; i < spline->tot_point; i++) {
-          MaskSplinePoint *point = &spline->points[i];
+      spline->points_deform = points_deform;
 
-          if (point->tot_uw) {
-            BLO_write_struct_array(writer, MaskSplinePointUW, point->tot_uw, point->uw);
-          }
+      for (i = 0; i < spline->tot_point; i++) {
+        MaskSplinePoint *point = &spline->points[i];
+
+        if (point->tot_uw) {
+          BLO_write_struct_array(writer, MaskSplinePointUW, point->tot_uw, point->uw);
         }
       }
+    }
 
-      for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
-           masklay_shape = masklay_shape->next) {
-        BLO_write_struct(writer, MaskLayerShape, masklay_shape);
-        BLO_write_float_array(
-            writer, masklay_shape->tot_vert * MASK_OBJECT_SHAPE_ELEM_SIZE, masklay_shape->data);
-      }
+    for (masklay_shape = masklay->splines_shapes.first; masklay_shape;
+         masklay_shape = masklay_shape->next) {
+      BLO_write_struct(writer, MaskLayerShape, masklay_shape);
+      BLO_write_float_array(
+          writer, masklay_shape->tot_vert * MASK_OBJECT_SHAPE_ELEM_SIZE, masklay_shape->data);
     }
   }
 }
diff --git a/source/blender/blenkernel/intern/material.c b/source/blender/blenkernel/intern/material.c
index ca57038f1c4..13b5bca5638 100644
--- a/source/blender/blenkernel/intern/material.c
+++ b/source/blender/blenkernel/intern/material.c
@@ -179,31 +179,30 @@ static void material_foreach_id(ID *id, LibraryForeachIDData *data)
 static void material_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   Material *ma = (Material *)id;
-  if (ma->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* Clean up, important in undo case to reduce false detection of changed datablocks. */
-    ma->texpaintslot = NULL;
-    BLI_listbase_clear(&ma->gpumaterial);
 
-    /* write LibData */
-    BLO_write_id_struct(writer, Material, id_address, &ma->id);
-    BKE_id_blend_write(writer, &ma->id);
+  /* Clean up, important in undo case to reduce false detection of changed datablocks. */
+  ma->texpaintslot = NULL;
+  BLI_listbase_clear(&ma->gpumaterial);
 
-    if (ma->adt) {
-      BKE_animdata_blend_write(writer, ma->adt);
-    }
+  /* write LibData */
+  BLO_write_id_struct(writer, Material, id_address, &ma->id);
+  BKE_id_blend_write(writer, &ma->id);
 
-    /* nodetree is integral part of material, no libdata */
-    if (ma->nodetree) {
-      BLO_write_struct(writer, bNodeTree, ma->nodetree);
-      ntreeBlendWrite(writer, ma->nodetree);
-    }
+  if (ma->adt) {
+    BKE_animdata_blend_write(writer, ma->adt);
+  }
 
-    BKE_previewimg_blend_write(writer, ma->preview);
+  /* nodetree is integral part of material, no libdata */
+  if (ma->nodetree) {
+    BLO_write_struct(writer, bNodeTree, ma->nodetree);
+    ntreeBlendWrite(writer, ma->nodetree);
+  }
 
-    /* grease pencil settings */
-    if (ma->gp_style) {
-      BLO_write_struct(writer, MaterialGPencilStyle, ma->gp_style);
-    }
+  BKE_previewimg_blend_write(writer, ma->preview);
+
+  /* grease pencil settings */
+  if (ma->gp_style) {
+    BLO_write_struct(writer, MaterialGPencilStyle, ma->gp_style);
   }
 }
 
diff --git a/source/blender/blenkernel/intern/mball.c b/source/blender/blenkernel/intern/mball.c
index d6b189d484b..45cf0f17840 100644
--- a/source/blender/blenkernel/intern/mball.c
+++ b/source/blender/blenkernel/intern/mball.c
@@ -119,28 +119,27 @@ static void metaball_foreach_id(ID *id, LibraryForeachIDData *data)
 static void metaball_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   MetaBall *mb = (MetaBall *)id;
-  if (mb->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* Clean up, important in undo case to reduce false detection of changed datablocks. */
-    BLI_listbase_clear(&mb->disp);
-    mb->editelems = NULL;
-    /* Must always be cleared (meta's don't have their own edit-data). */
-    mb->needs_flush_to_id = 0;
-    mb->lastelem = NULL;
-    mb->batch_cache = NULL;
-
-    /* write LibData */
-    BLO_write_id_struct(writer, MetaBall, id_address, &mb->id);
-    BKE_id_blend_write(writer, &mb->id);
-
-    /* direct data */
-    BLO_write_pointer_array(writer, mb->totcol, mb->mat);
-    if (mb->adt) {
-      BKE_animdata_blend_write(writer, mb->adt);
-    }
 
-    LISTBASE_FOREACH (MetaElem *, ml, &mb->elems) {
-      BLO_write_struct(writer, MetaElem, ml);
-    }
+  /* Clean up, important in undo case to reduce false detection of changed datablocks. */
+  BLI_listbase_clear(&mb->disp);
+  mb->editelems = NULL;
+  /* Must always be cleared (meta's don't have their own edit-data). */
+  mb->needs_flush_to_id = 0;
+  mb->lastelem = NULL;
+  mb->batch_cache = NULL;
+
+  /* write LibData */
+  BLO_write_id_struct(writer, MetaBall, id_address, &mb->id);
+  BKE_id_blend_write(writer, &mb->id);
+
+  /* direct data */
+  BLO_write_pointer_array(writer, mb->totcol, mb->mat);
+  if (mb->adt) {
+    BKE_animdata_blend_write(writer, mb->adt);
+  }
+
+  LISTBASE_FOREACH (MetaElem *, ml, &mb->elems) {
+    BLO_write_struct(writer, MetaElem, ml);
   }
 }
 
diff --git a/source/blender/blenkernel/intern/mesh.c b/source/blender/blenkernel/intern/mesh.c
index e99670fc488..eb8e6aad736 100644
--- a/source/blender/blenkernel/intern/mesh.c
+++ b/source/blender/blenkernel/intern/mesh.c
@@ -179,95 +179,90 @@ static void mesh_blend_write(BlendWriter *writer, ID *id, const void *id_address
 {
   Mesh *mesh = (Mesh *)id;
   const bool is_undo = BLO_write_is_undo(writer);
-  if (mesh->id.us > 0 || is_undo) {
-    CustomDataLayer *vlayers = NULL, vlayers_buff[CD_TEMP_CHUNK_SIZE];
-    CustomDataLayer *elayers = NULL, elayers_buff[CD_TEMP_CHUNK_SIZE];
-    CustomDataLayer *flayers = NULL, flayers_buff[CD_TEMP_CHUNK_SIZE];
-    CustomDataLayer *llayers = NULL, llayers_buff[CD_TEMP_CHUNK_SIZE];
-    CustomDataLayer *players = NULL, players_buff[CD_TEMP_CHUNK_SIZE];
-
-    /* cache only - don't write */
-    mesh->mface = NULL;
-    mesh->totface = 0;
-    memset(&mesh->fdata, 0, sizeof(mesh->fdata));
-    memset(&mesh->runtime, 0, sizeof(mesh->runtime));
-    flayers = flayers_buff;
-
-    /* Do not store actual geometry data in case this is a library override ID. */
-    if (ID_IS_OVERRIDE_LIBRARY(mesh) && !is_undo) {
-      mesh->mvert = NULL;
-      mesh->totvert = 0;
-      memset(&mesh->vdata, 0, sizeof(mesh->vdata));
-      vlayers = vlayers_buff;
-
-      mesh->medge = NULL;
-      mesh->totedge = 0;
-      memset(&mesh->edata, 0, sizeof(mesh->edata));
-      elayers = elayers_buff;
-
-      mesh->mloop = NULL;
-      mesh->totloop = 0;
-      memset(&mesh->ldata, 0, sizeof(mesh->ldata));
-      llayers = llayers_buff;
-
-      mesh->mpoly = NULL;
-      mesh->totpoly = 0;
-      memset(&mesh->pdata, 0, sizeof(mesh->pdata));
-      players = players_buff;
-    }
-    else {
-      CustomData_blend_write_prepare(
-          &mesh->vdata, &vlayers, vlayers_buff, ARRAY_SIZE(vlayers_buff));
-      CustomData_blend_write_prepare(
-          &mesh->edata, &elayers, elayers_buff, ARRAY_SIZE(elayers_buff));
-      CustomData_blend_write_prepare(
-          &mesh->ldata, &llayers, llayers_buff, ARRAY_SIZE(llayers_buff));
-      CustomData_blend_write_prepare(
-          &mesh->pdata, &players, players_buff, ARRAY_SIZE(players_buff));
-    }
 
-    BLO_write_id_struct(writer, Mesh, id_address, &mesh->id);
-    BKE_id_blend_write(writer, &mesh->id);
+  CustomDataLayer *vlayers = NULL, vlayers_buff[CD_TEMP_CHUNK_SIZE];
+  CustomDataLayer *elayers = NULL, elayers_buff[CD_TEMP_CHUNK_SIZE];
+  CustomDataLayer *flayers = NULL, flayers_buff[CD_TEMP_CHUNK_SIZE];
+  CustomDataLayer *llayers = NULL, llayers_buff[CD_TEMP_CHUNK_SIZE];
+  CustomDataLayer *players = NULL, players_buff[CD_TEMP_CHUNK_SIZE];
 
-    /* direct data */
-    if (mesh->adt) {
-      BKE_animdata_blend_write(writer, mesh->adt);
-    }
+  /* cache only - don't write */
+  mesh->mface = NULL;
+  mesh->totface = 0;
+  memset(&mesh->fdata, 0, sizeof(mesh->fdata));
+  memset(&mesh->runtime, 0, sizeof(mesh->runtime));
+  flayers = flayers_buff;
+
+  /* Do not store actual geometry data in case this is a library override ID. */
+  if (ID_IS_OVERRIDE_LIBRARY(mesh) && !is_undo) {
+    mesh->mvert = NULL;
+    mesh->totvert = 0;
+    memset(&mesh->vdata, 0, sizeof(mesh->vdata));
+    vlayers = vlayers_buff;
+
+    mesh->medge = NULL;
+    mesh->totedge = 0;
+    memset(&mesh->edata, 0, sizeof(mesh->edata));
+    elayers = elayers_buff;
+
+    mesh->mloop = NULL;
+    mesh->totloop = 0;
+    memset(&mesh->ldata, 0, sizeof(mesh->ldata));
+    llayers = llayers_buff;
+
+    mesh->mpoly = NULL;
+    mesh->totpoly = 0;
+    memset(&mesh->pdata, 0, sizeof(mesh->pdata));
+    players = players_buff;
+  }
+  else {
+    CustomData_blend_write_prepare(&mesh->vdata, &vlayers, vlayers_buff, ARRAY_SIZE(vlayers_buff));
+    CustomData_blend_write_prepare(&mesh->edata, &elayers, elayers_buff, ARRAY_SIZE(elayers_buff));
+    CustomData_blend_write_prepare(&mesh->ldata, &llayers, llayers_buff, ARRAY_SIZE(llayers_buff));
+    CustomData_blend_write_prepare(&mesh->pdata, &players, players_buff, ARRAY_SIZE(players_buff));
+  }
+
+  BLO_write_id_struct(writer, Mesh, id_address, &mesh->id);
+  BKE_id_blend_write(writer, &mesh->id);
+
+  /* direct data */
+  if (mesh->adt) {
+    BKE_animdata_blend_write(writer, mesh->adt);
+  }
 
-    BKE_defbase_blend_write(writer, &mesh->vertex_group_names);
+  BKE_defbase_blend_write(writer, &mesh->vertex_group_names);
 
-    BLO_write_pointer_array(writer, mesh->totcol, mesh->mat);
-    BLO_write_raw(writer, sizeof(MSelect) * mesh->totselect, mesh->mselect);
+  BLO_write_pointer_array(writer, mesh->totcol, mesh->mat);
+  BLO_write_raw(writer, sizeof(MSelect) * mesh->totselect, mesh->mselect);
 
-    CustomData_blend_write(
-        writer, &mesh->vdata, vlayers, mesh->totvert, CD_MASK_MESH.vmask, &mesh->id);
-    CustomData_blend_write(
-        writer, &mesh->edata, elayers, mesh->totedge, CD_MASK_MESH.emask, &mesh->id);
-    /* fdata is really a dummy - written so slots align */
-    CustomData_blend_write(
-        writer, &mesh->fdata, flayers, mesh->totface, CD_MASK_MESH.fmask, &mesh->id);
-    CustomData_blend_write(
-        writer, &mesh->ldata, llayers, mesh->totloop, CD_MASK_MESH.lmask, &mesh->id);
-    CustomData_blend_write(
-        writer, &mesh->pdata, players, mesh->totpoly, CD_MASK_MESH.pmask, &mesh->id);
+  CustomData_blend_write(
+      writer, &mesh->vdata, vlayers, mesh->totvert, CD_MASK_MESH.vmask, &mesh->id);
+  CustomData_blend_write(
+      writer, &mesh->edata, elayers, mesh->totedge, CD_MASK_MESH.emask, &mesh->id);
+  /* fdata is really a dummy - written so slots align */
+  CustomData_blend_write(
+      writer, &mesh->fdata, flayers, mesh->totface, CD_MASK_MESH.fmask, &mesh->id);
+  CustomData_blend_write(
+      writer, &mesh->ldata, llayers, mesh->totloop, CD_MASK_MESH.lmask, &mesh->id);
+  CustomData_blend_write(
+      writer, &mesh->pdata, players, mesh->totpoly, CD_MASK_MESH.pmask, &mesh->id);
 
-    /* Free temporary data */
+  /* Free temporary data */
 
-/* Free custom-data layers, when not assigned a buffer value. */
+  /* Free custom-data layers, when not assigned a buffer value. */
 #define CD_LAYERS_FREE(id) \
   if (id && id != id##_buff) { \
     MEM_freeN(id); \
   } \
   ((void)0)
 
-    CD_LAYERS_FREE(vlayers);
-    CD_LAYERS_FREE(elayers);
-    // CD_LAYER_FREE(flayers); /* Never allocated. */
-    CD_LAYERS_FREE(llayers);
-    CD_LAYERS_FREE(players);
+  CD_LAYERS_FREE(vlayers);
+  CD_LAYERS_FREE(elayers);
+  // CD_LAYER_FREE(flayers); /* Never allocated. */
+  CD_LAYERS_FREE(llayers);
+  CD_LAYERS_FREE(players);
 
 #undef CD_LAYERS_FREE
-  }
 }
 
 static void mesh_blend_read_data(BlendDataReader *reader, ID *id)
@@ -866,8 +861,11 @@ bool BKE_mesh_has_custom_loop_normals(Mesh *me)
   return CustomData_has_layer(&me->ldata, CD_CUSTOMLOOPNORMAL);
 }
 
-/** Free (or release) any data used by this mesh (does not free the mesh itself). */
-void BKE_mesh_free(Mesh *me)
+/**
+ * Free (or release) any data used by this mesh (does not free the mesh itself).
+ * Only use for undo, in most cases `BKE_id_free(NULL, me)` should be used.
+ */
+void BKE_mesh_free_data_for_undo(Mesh *me)
 {
   mesh_free_data(&me->id);
 }
@@ -1083,7 +1081,7 @@ void BKE_mesh_eval_delete(struct Mesh *mesh_eval)
 {
   /* Evaluated mesh may point to edit mesh, but never owns it. */
   mesh_eval->edit_mesh = NULL;
-  BKE_mesh_free(mesh_eval);
+  mesh_free_data(&mesh_eval->id);
   BKE_libblock_free_data(&mesh_eval->id, false);
   MEM_freeN(mesh_eval);
 }
diff --git a/source/blender/blenkernel/intern/modifier.c b/source/blender/blenkernel/intern/modifier.c
index 2088c4268e6..821ca7b98b3 100644
--- a/source/blender/blenkernel/intern/modifier.c
+++ b/source/blender/blenkernel/intern/modifier.c
@@ -249,11 +249,11 @@ bool BKE_modifier_unique_name(ListBase *modifiers, ModifierData *md)
   return false;
 }
 
-bool BKE_modifier_depends_ontime(ModifierData *md)
+bool BKE_modifier_depends_ontime(Scene *scene, ModifierData *md, const int dag_eval_mode)
 {
   const ModifierTypeInfo *mti = BKE_modifier_get_info(md->type);
 
-  return mti->dependsOnTime && mti->dependsOnTime(md);
+  return mti->dependsOnTime && mti->dependsOnTime(scene, md, dag_eval_mode);
 }
 
 bool BKE_modifier_supports_mapping(ModifierData *md)
diff --git a/source/blender/blenkernel/intern/movieclip.c b/source/blender/blenkernel/intern/movieclip.c
index f32b0c434c1..e507252307b 100644
--- a/source/blender/blenkernel/intern/movieclip.c
+++ b/source/blender/blenkernel/intern/movieclip.c
@@ -206,36 +206,35 @@ static void write_movieReconstruction(BlendWriter *writer,
 static void movieclip_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   MovieClip *clip = (MovieClip *)id;
-  if (clip->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* Clean up, important in undo case to reduce false detection of changed datablocks. */
-    clip->anim = NULL;
-    clip->tracking_context = NULL;
-    clip->tracking.stats = NULL;
 
-    MovieTracking *tracking = &clip->tracking;
-    MovieTrackingObject *object;
+  /* Clean up, important in undo case to reduce false detection of changed datablocks. */
+  clip->anim = NULL;
+  clip->tracking_context = NULL;
+  clip->tracking.stats = NULL;
 
-    BLO_write_id_struct(writer, MovieClip, id_address, &clip->id);
-    BKE_id_blend_write(writer, &clip->id);
+  MovieTracking *tracking = &clip->tracking;
+  MovieTrackingObject *object;
 
-    if (clip->adt) {
-      BKE_animdata_blend_write(writer, clip->adt);
-    }
+  BLO_write_id_struct(writer, MovieClip, id_address, &clip->id);
+  BKE_id_blend_write(writer, &clip->id);
+
+  if (clip->adt) {
+    BKE_animdata_blend_write(writer, clip->adt);
+  }
 
-    write_movieTracks(writer, &tracking->tracks);
-    write_moviePlaneTracks(writer, &tracking->plane_tracks);
-    write_movieReconstruction(writer, &tracking->reconstruction);
+  write_movieTracks(writer, &tracking->tracks);
+  write_moviePlaneTracks(writer, &tracking->plane_tracks);
+  write_movieReconstruction(writer, &tracking->reconstruction);
 
-    object = tracking->objects.first;
-    while (object) {
-      BLO_write_struct(writer, MovieTrackingObject, object);
+  object = tracking->objects.first;
+  while (object) {
+    BLO_write_struct(writer, MovieTrackingObject, object);
 
-      write_movieTracks(writer, &object->tracks);
-      write_moviePlaneTracks(writer, &object->plane_tracks);
-      write_movieReconstruction(writer, &object->reconstruction);
+    write_movieTracks(writer, &object->tracks);
+    write_moviePlaneTracks(writer, &object->plane_tracks);
+    write_movieReconstruction(writer, &object->reconstruction);
 
-      object = object->next;
-    }
+    object = object->next;
   }
 }
 
diff --git a/source/blender/blenkernel/intern/node.cc b/source/blender/blenkernel/intern/node.cc
index b2d485b5720..151448e3038 100644
--- a/source/blender/blenkernel/intern/node.cc
+++ b/source/blender/blenkernel/intern/node.cc
@@ -606,19 +606,18 @@ void ntreeBlendWrite(BlendWriter *writer, bNodeTree *ntree)
 static void ntree_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   bNodeTree *ntree = (bNodeTree *)id;
-  if (ntree->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* Clean up, important in undo case to reduce false detection of changed datablocks. */
-    ntree->init = 0; /* to set callbacks and force setting types */
-    ntree->is_updating = false;
-    ntree->typeinfo = nullptr;
-    ntree->interface_type = nullptr;
-    ntree->progress = nullptr;
-    ntree->execdata = nullptr;
 
-    BLO_write_id_struct(writer, bNodeTree, id_address, &ntree->id);
+  /* Clean up, important in undo case to reduce false detection of changed datablocks. */
+  ntree->init = 0; /* to set callbacks and force setting types */
+  ntree->is_updating = false;
+  ntree->typeinfo = nullptr;
+  ntree->interface_type = nullptr;
+  ntree->progress = nullptr;
+  ntree->execdata = nullptr;
 
-    ntreeBlendWrite(writer, ntree);
-  }
+  BLO_write_id_struct(writer, bNodeTree, id_address, &ntree->id);
+
+  ntreeBlendWrite(writer, ntree);
 }
 
 static void direct_link_node_socket(BlendDataReader *reader, bNodeSocket *sock)
diff --git a/source/blender/blenkernel/intern/object.c b/source/blender/blenkernel/intern/object.c
index 23b9dca8371..1c08a46adc3 100644
--- a/source/blender/blenkernel/intern/object.c
+++ b/source/blender/blenkernel/intern/object.c
@@ -523,74 +523,72 @@ static void object_blend_write(BlendWriter *writer, ID *id, const void *id_addre
   Object *ob = (Object *)id;
 
   const bool is_undo = BLO_write_is_undo(writer);
-  if (ob->id.us > 0 || is_undo) {
-    /* Clean up, important in undo case to reduce false detection of changed data-blocks. */
-    BKE_object_runtime_reset(ob);
 
-    if (is_undo) {
-      /* For undo we stay in object mode during undo presses, so keep edit-mode disabled on save as
-       * well, can help reducing false detection of changed data-blocks. */
-      ob->mode &= ~OB_MODE_EDIT;
-    }
+  /* Clean up, important in undo case to reduce false detection of changed data-blocks. */
+  BKE_object_runtime_reset(ob);
+
+  if (is_undo) {
+    /* For undo we stay in object mode during undo presses, so keep edit-mode disabled on save as
+     * well, can help reducing false detection of changed data-blocks. */
+    ob->mode &= ~OB_MODE_EDIT;
+  }
 
-    /* write LibData */
-    BLO_write_id_struct(writer, Object, id_address, &ob->id);
-    BKE_id_blend_write(writer, &ob->id);
+  /* write LibData */
+  BLO_write_id_struct(writer, Object, id_address, &ob->id);
+  BKE_id_blend_write(writer, &ob->id);
 
-    if (ob->adt) {
-      BKE_animdata_blend_write(writer, ob->adt);
-    }
+  if (ob->adt) {
+    BKE_animdata_blend_write(writer, ob->adt);
+  }
 
-    /* direct data */
-    BLO_write_pointer_array(writer, ob->totcol, ob->mat);
-    BLO_write_raw(writer, sizeof(char) * ob->totcol, ob->matbits);
+  /* direct data */
+  BLO_write_pointer_array(writer, ob->totcol, ob->mat);
+  BLO_write_raw(writer, sizeof(char) * ob->totcol, ob->matbits);
 
-    bArmature *arm = NULL;
-    if (ob->type == OB_ARMATURE) {
-      arm = ob->data;
-      if (arm && ob->pose && arm->act_bone) {
-        BLI_strncpy(
-            ob->pose->proxy_act_bone, arm->act_bone->name, sizeof(ob->pose->proxy_act_bone));
-      }
+  bArmature *arm = NULL;
+  if (ob->type == OB_ARMATURE) {
+    arm = ob->data;
+    if (arm && ob->pose && arm->act_bone) {
+      BLI_strncpy(ob->pose->proxy_act_bone, arm->act_bone->name, sizeof(ob->pose->proxy_act_bone));
     }
+  }
 
-    BKE_pose_blend_write(writer, ob->pose, arm);
-    write_fmaps(writer, &ob->fmaps);
-    BKE_constraint_blend_write(writer, &ob->constraints);
-    animviz_motionpath_blend_write(writer, ob->mpath);
+  BKE_pose_blend_write(writer, ob->pose, arm);
+  write_fmaps(writer, &ob->fmaps);
+  BKE_constraint_blend_write(writer, &ob->constraints);
+  animviz_motionpath_blend_write(writer, ob->mpath);
 
-    BLO_write_struct(writer, PartDeflect, ob->pd);
-    if (ob->soft) {
-      /* Set deprecated pointers to prevent crashes of older Blenders */
-      ob->soft->pointcache = ob->soft->shared->pointcache;
-      ob->soft->ptcaches = ob->soft->shared->ptcaches;
-      BLO_write_struct(writer, SoftBody, ob->soft);
-      BLO_write_struct(writer, SoftBody_Shared, ob->soft->shared);
-      BKE_ptcache_blend_write(writer, &(ob->soft->shared->ptcaches));
-      BLO_write_struct(writer, EffectorWeights, ob->soft->effector_weights);
-    }
+  BLO_write_struct(writer, PartDeflect, ob->pd);
+  if (ob->soft) {
+    /* Set deprecated pointers to prevent crashes of older Blenders */
+    ob->soft->pointcache = ob->soft->shared->pointcache;
+    ob->soft->ptcaches = ob->soft->shared->ptcaches;
+    BLO_write_struct(writer, SoftBody, ob->soft);
+    BLO_write_struct(writer, SoftBody_Shared, ob->soft->shared);
+    BKE_ptcache_blend_write(writer, &(ob->soft->shared->ptcaches));
+    BLO_write_struct(writer, EffectorWeights, ob->soft->effector_weights);
+  }
 
-    if (ob->rigidbody_object) {
-      /* TODO: if any extra data is added to handle duplis, will need separate function then */
-      BLO_write_struct(writer, RigidBodyOb, ob->rigidbody_object);
-    }
-    if (ob->rigidbody_constraint) {
-      BLO_write_struct(writer, RigidBodyCon, ob->rigidbody_constraint);
-    }
+  if (ob->rigidbody_object) {
+    /* TODO: if any extra data is added to handle duplis, will need separate function then */
+    BLO_write_struct(writer, RigidBodyOb, ob->rigidbody_object);
+  }
+  if (ob->rigidbody_constraint) {
+    BLO_write_struct(writer, RigidBodyCon, ob->rigidbody_constraint);
+  }
 
-    if (ob->type == OB_EMPTY && ob->empty_drawtype == OB_EMPTY_IMAGE) {
-      BLO_write_struct(writer, ImageUser, ob->iuser);
-    }
+  if (ob->type == OB_EMPTY && ob->empty_drawtype == OB_EMPTY_IMAGE) {
+    BLO_write_struct(writer, ImageUser, ob->iuser);
+  }
 
-    BKE_particle_system_blend_write(writer, &ob->particlesystem);
-    BKE_modifier_blend_write(writer, &ob->modifiers);
-    BKE_gpencil_modifier_blend_write(writer, &ob->greasepencil_modifiers);
-    BKE_shaderfx_blend_write(writer, &ob->shader_fx);
+  BKE_particle_system_blend_write(writer, &ob->particlesystem);
+  BKE_modifier_blend_write(writer, &ob->modifiers);
+  BKE_gpencil_modifier_blend_write(writer, &ob->greasepencil_modifiers);
+  BKE_shaderfx_blend_write(writer, &ob->shader_fx);
 
-    BLO_write_struct_list(writer, LinkData, &ob->pc_ids);
+  BLO_write_struct_list(writer, LinkData, &ob->pc_ids);
 
-    BKE_previewimg_blend_write(writer, ob->preview);
-  }
+  BKE_previewimg_blend_write(writer, ob->preview);
 }
 
 /* XXX deprecated - old animation system */
@@ -5411,9 +5409,12 @@ KDTree_3d *BKE_object_as_kdtree(Object *ob, int *r_tot)
   return tree;
 }
 
-bool BKE_object_modifier_use_time(Object *ob, ModifierData *md)
+bool BKE_object_modifier_use_time(Scene *scene,
+                                  Object *ob,
+                                  ModifierData *md,
+                                  const int dag_eval_mode)
 {
-  if (BKE_modifier_depends_ontime(md)) {
+  if (BKE_modifier_depends_ontime(scene, md, dag_eval_mode)) {
     return true;
   }
 
diff --git a/source/blender/blenkernel/intern/paint.c b/source/blender/blenkernel/intern/paint.c
index a1fa6aae1ce..d6030941c6d 100644
--- a/source/blender/blenkernel/intern/paint.c
+++ b/source/blender/blenkernel/intern/paint.c
@@ -108,14 +108,13 @@ static void palette_free_data(ID *id)
 static void palette_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   Palette *palette = (Palette *)id;
-  if (palette->id.us > 0 || BLO_write_is_undo(writer)) {
-    PaletteColor *color;
-    BLO_write_id_struct(writer, Palette, id_address, &palette->id);
-    BKE_id_blend_write(writer, &palette->id);
 
-    for (color = palette->colors.first; color; color = color->next) {
-      BLO_write_struct(writer, PaletteColor, color);
-    }
+  PaletteColor *color;
+  BLO_write_id_struct(writer, Palette, id_address, &palette->id);
+  BKE_id_blend_write(writer, &palette->id);
+
+  for (color = palette->colors.first; color; color = color->next) {
+    BLO_write_struct(writer, PaletteColor, color);
   }
 }
 
@@ -187,12 +186,11 @@ static void paint_curve_free_data(ID *id)
 static void paint_curve_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   PaintCurve *pc = (PaintCurve *)id;
-  if (pc->id.us > 0 || BLO_write_is_undo(writer)) {
-    BLO_write_id_struct(writer, PaintCurve, id_address, &pc->id);
-    BKE_id_blend_write(writer, &pc->id);
 
-    BLO_write_struct_array(writer, PaintCurvePoint, pc->tot_points, pc->points);
-  }
+  BLO_write_id_struct(writer, PaintCurve, id_address, &pc->id);
+  BKE_id_blend_write(writer, &pc->id);
+
+  BLO_write_struct_array(writer, PaintCurvePoint, pc->tot_points, pc->points);
 }
 
 static void paint_curve_blend_read_data(BlendDataReader *reader, ID *id)
diff --git a/source/blender/blenkernel/intern/particle.c b/source/blender/blenkernel/intern/particle.c
index cc8a051eceb..29849c69b6f 100644
--- a/source/blender/blenkernel/intern/particle.c
+++ b/source/blender/blenkernel/intern/particle.c
@@ -255,60 +255,59 @@ static void write_boid_state(BlendWriter *writer, BoidState *state)
 static void particle_settings_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   ParticleSettings *part = (ParticleSettings *)id;
-  if (part->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* write LibData */
-    BLO_write_id_struct(writer, ParticleSettings, id_address, &part->id);
-    BKE_id_blend_write(writer, &part->id);
 
-    if (part->adt) {
-      BKE_animdata_blend_write(writer, part->adt);
-    }
-    BLO_write_struct(writer, PartDeflect, part->pd);
-    BLO_write_struct(writer, PartDeflect, part->pd2);
-    BLO_write_struct(writer, EffectorWeights, part->effector_weights);
+  /* write LibData */
+  BLO_write_id_struct(writer, ParticleSettings, id_address, &part->id);
+  BKE_id_blend_write(writer, &part->id);
 
-    if (part->clumpcurve) {
-      BKE_curvemapping_blend_write(writer, part->clumpcurve);
-    }
-    if (part->roughcurve) {
-      BKE_curvemapping_blend_write(writer, part->roughcurve);
-    }
-    if (part->twistcurve) {
-      BKE_curvemapping_blend_write(writer, part->twistcurve);
-    }
+  if (part->adt) {
+    BKE_animdata_blend_write(writer, part->adt);
+  }
+  BLO_write_struct(writer, PartDeflect, part->pd);
+  BLO_write_struct(writer, PartDeflect, part->pd2);
+  BLO_write_struct(writer, EffectorWeights, part->effector_weights);
 
-    LISTBASE_FOREACH (ParticleDupliWeight *, dw, &part->instance_weights) {
-      /* update indices, but only if dw->ob is set (can be NULL after loading e.g.) */
-      if (dw->ob != NULL) {
-        dw->index = 0;
-        if (part->instance_collection) { /* can be NULL if lining fails or set to None */
-          FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (part->instance_collection, object) {
-            if (object == dw->ob) {
-              break;
-            }
-            dw->index++;
+  if (part->clumpcurve) {
+    BKE_curvemapping_blend_write(writer, part->clumpcurve);
+  }
+  if (part->roughcurve) {
+    BKE_curvemapping_blend_write(writer, part->roughcurve);
+  }
+  if (part->twistcurve) {
+    BKE_curvemapping_blend_write(writer, part->twistcurve);
+  }
+
+  LISTBASE_FOREACH (ParticleDupliWeight *, dw, &part->instance_weights) {
+    /* update indices, but only if dw->ob is set (can be NULL after loading e.g.) */
+    if (dw->ob != NULL) {
+      dw->index = 0;
+      if (part->instance_collection) { /* can be NULL if lining fails or set to None */
+        FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (part->instance_collection, object) {
+          if (object == dw->ob) {
+            break;
           }
-          FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
+          dw->index++;
         }
+        FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
       }
-      BLO_write_struct(writer, ParticleDupliWeight, dw);
     }
+    BLO_write_struct(writer, ParticleDupliWeight, dw);
+  }
 
-    if (part->boids && part->phystype == PART_PHYS_BOIDS) {
-      BLO_write_struct(writer, BoidSettings, part->boids);
+  if (part->boids && part->phystype == PART_PHYS_BOIDS) {
+    BLO_write_struct(writer, BoidSettings, part->boids);
 
-      LISTBASE_FOREACH (BoidState *, state, &part->boids->states) {
-        write_boid_state(writer, state);
-      }
-    }
-    if (part->fluid && part->phystype == PART_PHYS_FLUID) {
-      BLO_write_struct(writer, SPHFluidSettings, part->fluid);
+    LISTBASE_FOREACH (BoidState *, state, &part->boids->states) {
+      write_boid_state(writer, state);
     }
+  }
+  if (part->fluid && part->phystype == PART_PHYS_FLUID) {
+    BLO_write_struct(writer, SPHFluidSettings, part->fluid);
+  }
 
-    for (int a = 0; a < MAX_MTEX; a++) {
-      if (part->mtex[a]) {
-        BLO_write_struct(writer, MTex, part->mtex[a]);
-      }
+  for (int a = 0; a < MAX_MTEX; a++) {
+    if (part->mtex[a]) {
+      BLO_write_struct(writer, MTex, part->mtex[a]);
     }
   }
 }
diff --git a/source/blender/blenkernel/intern/pointcloud.cc b/source/blender/blenkernel/intern/pointcloud.cc
index d9a7a376e2e..837a772607f 100644
--- a/source/blender/blenkernel/intern/pointcloud.cc
+++ b/source/blender/blenkernel/intern/pointcloud.cc
@@ -112,28 +112,27 @@ static void pointcloud_foreach_id(ID *id, LibraryForeachIDData *data)
 static void pointcloud_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   PointCloud *pointcloud = (PointCloud *)id;
-  if (pointcloud->id.us > 0 || BLO_write_is_undo(writer)) {
-    CustomDataLayer *players = nullptr, players_buff[CD_TEMP_CHUNK_SIZE];
-    CustomData_blend_write_prepare(
-        &pointcloud->pdata, &players, players_buff, ARRAY_SIZE(players_buff));
-
-    /* Write LibData */
-    BLO_write_id_struct(writer, PointCloud, id_address, &pointcloud->id);
-    BKE_id_blend_write(writer, &pointcloud->id);
-
-    /* Direct data */
-    CustomData_blend_write(
-        writer, &pointcloud->pdata, players, pointcloud->totpoint, CD_MASK_ALL, &pointcloud->id);
-
-    BLO_write_pointer_array(writer, pointcloud->totcol, pointcloud->mat);
-    if (pointcloud->adt) {
-      BKE_animdata_blend_write(writer, pointcloud->adt);
-    }
 
-    /* Remove temporary data. */
-    if (players && players != players_buff) {
-      MEM_freeN(players);
-    }
+  CustomDataLayer *players = nullptr, players_buff[CD_TEMP_CHUNK_SIZE];
+  CustomData_blend_write_prepare(
+      &pointcloud->pdata, &players, players_buff, ARRAY_SIZE(players_buff));
+
+  /* Write LibData */
+  BLO_write_id_struct(writer, PointCloud, id_address, &pointcloud->id);
+  BKE_id_blend_write(writer, &pointcloud->id);
+
+  /* Direct data */
+  CustomData_blend_write(
+      writer, &pointcloud->pdata, players, pointcloud->totpoint, CD_MASK_ALL, &pointcloud->id);
+
+  BLO_write_pointer_array(writer, pointcloud->totcol, pointcloud->mat);
+  if (pointcloud->adt) {
+    BKE_animdata_blend_write(writer, pointcloud->adt);
+  }
+
+  /* Remove temporary data. */
+  if (players && players != players_buff) {
+    MEM_freeN(players);
   }
 }
 
diff --git a/source/blender/blenkernel/intern/scene.c b/source/blender/blenkernel/intern/scene.c
index 5ecd9b7283e..3fe00adc4d5 100644
--- a/source/blender/blenkernel/intern/scene.c
+++ b/source/blender/blenkernel/intern/scene.c
@@ -109,6 +109,8 @@
 
 #include "RE_engine.h"
 
+#include "RNA_access.h"
+
 #include "SEQ_edit.h"
 #include "SEQ_iterator.h"
 #include "SEQ_modifier.h"
@@ -2938,6 +2940,22 @@ bool BKE_scene_uses_cycles(const Scene *scene)
   return STREQ(scene->r.engine, RE_engine_id_CYCLES);
 }
 
+/* This enumeration has to match the one defined in the Cycles addon. */
+typedef enum eCyclesFeatureSet {
+  CYCLES_FEATURES_SUPPORTED = 0,
+  CYCLES_FEATURES_EXPERIMENTAL = 1,
+} eCyclesFeatureSet;
+
+/* We cannot use const as RNA_id_pointer_create is not using a const ID. */
+bool BKE_scene_uses_cycles_experimental_features(Scene *scene)
+{
+  BLI_assert(BKE_scene_uses_cycles(scene));
+  PointerRNA scene_ptr;
+  RNA_id_pointer_create(&scene->id, &scene_ptr);
+  PointerRNA cycles_ptr = RNA_pointer_get(&scene_ptr, "cycles");
+  return RNA_enum_get(&cycles_ptr, "feature_set") == CYCLES_FEATURES_EXPERIMENTAL;
+}
+
 void BKE_scene_base_flag_to_objects(ViewLayer *view_layer)
 {
   Base *base = view_layer->object_bases.first;
diff --git a/source/blender/blenkernel/intern/screen.c b/source/blender/blenkernel/intern/screen.c
index e44c5a6b40e..065240bddbc 100644
--- a/source/blender/blenkernel/intern/screen.c
+++ b/source/blender/blenkernel/intern/screen.c
@@ -255,18 +255,16 @@ static void screen_foreach_id(ID *id, LibraryForeachIDData *data)
 static void screen_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   bScreen *screen = (bScreen *)id;
-  /* Screens are reference counted, only saved if used by a workspace. */
-  if (screen->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* write LibData */
-    /* in 2.50+ files, the file identifier for screens is patched, forward compatibility */
-    BLO_write_struct_at_address_with_filecode(writer, ID_SCRN, bScreen, id_address, screen);
-    BKE_id_blend_write(writer, &screen->id);
 
-    BKE_previewimg_blend_write(writer, screen->preview);
+  /* write LibData */
+  /* in 2.50+ files, the file identifier for screens is patched, forward compatibility */
+  BLO_write_struct_at_address_with_filecode(writer, ID_SCRN, bScreen, id_address, screen);
+  BKE_id_blend_write(writer, &screen->id);
 
-    /* direct data */
-    BKE_screen_area_map_blend_write(writer, AREAMAP_FROM_SCREEN(screen));
-  }
+  BKE_previewimg_blend_write(writer, screen->preview);
+
+  /* direct data */
+  BKE_screen_area_map_blend_write(writer, AREAMAP_FROM_SCREEN(screen));
 }
 
 /* Cannot use IDTypeInfo callback yet, because of the return value. */
@@ -730,7 +728,7 @@ void BKE_screen_area_map_free(ScrAreaMap *area_map)
 }
 
 /** Free (or release) any data used by this screen (does not free the screen itself). */
-void BKE_screen_free(bScreen *screen)
+void BKE_screen_free_data(bScreen *screen)
 {
   screen_free_data(&screen->id);
 }
diff --git a/source/blender/blenkernel/intern/simulation.cc b/source/blender/blenkernel/intern/simulation.cc
index 216563b860d..5aac29c19a7 100644
--- a/source/blender/blenkernel/intern/simulation.cc
+++ b/source/blender/blenkernel/intern/simulation.cc
@@ -114,19 +114,18 @@ static void simulation_foreach_id(ID *id, LibraryForeachIDData *data)
 static void simulation_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   Simulation *simulation = (Simulation *)id;
-  if (simulation->id.us > 0 || BLO_write_is_undo(writer)) {
-    BLO_write_id_struct(writer, Simulation, id_address, &simulation->id);
-    BKE_id_blend_write(writer, &simulation->id);
-
-    if (simulation->adt) {
-      BKE_animdata_blend_write(writer, simulation->adt);
-    }
-
-    /* nodetree is integral part of simulation, no libdata */
-    if (simulation->nodetree) {
-      BLO_write_struct(writer, bNodeTree, simulation->nodetree);
-      ntreeBlendWrite(writer, simulation->nodetree);
-    }
+
+  BLO_write_id_struct(writer, Simulation, id_address, &simulation->id);
+  BKE_id_blend_write(writer, &simulation->id);
+
+  if (simulation->adt) {
+    BKE_animdata_blend_write(writer, simulation->adt);
+  }
+
+  /* nodetree is integral part of simulation, no libdata */
+  if (simulation->nodetree) {
+    BLO_write_struct(writer, bNodeTree, simulation->nodetree);
+    ntreeBlendWrite(writer, simulation->nodetree);
   }
 }
 
diff --git a/source/blender/blenkernel/intern/sound.c b/source/blender/blenkernel/intern/sound.c
index 8730d2758e6..c61fa793367 100644
--- a/source/blender/blenkernel/intern/sound.c
+++ b/source/blender/blenkernel/intern/sound.c
@@ -137,24 +137,23 @@ static void sound_blend_write(BlendWriter *writer, ID *id, const void *id_addres
 {
   bSound *sound = (bSound *)id;
   const bool is_undo = BLO_write_is_undo(writer);
-  if (sound->id.us > 0 || is_undo) {
-    /* Clean up, important in undo case to reduce false detection of changed datablocks. */
-    sound->tags = 0;
-    sound->handle = NULL;
-    sound->playback_handle = NULL;
-    sound->spinlock = NULL;
 
-    /* Do not store packed files in case this is a library override ID. */
-    if (ID_IS_OVERRIDE_LIBRARY(sound) && !is_undo) {
-      sound->packedfile = NULL;
-    }
-
-    /* write LibData */
-    BLO_write_id_struct(writer, bSound, id_address, &sound->id);
-    BKE_id_blend_write(writer, &sound->id);
+  /* Clean up, important in undo case to reduce false detection of changed datablocks. */
+  sound->tags = 0;
+  sound->handle = NULL;
+  sound->playback_handle = NULL;
+  sound->spinlock = NULL;
 
-    BKE_packedfile_blend_write(writer, sound->packedfile);
+  /* Do not store packed files in case this is a library override ID. */
+  if (ID_IS_OVERRIDE_LIBRARY(sound) && !is_undo) {
+    sound->packedfile = NULL;
   }
+
+  /* write LibData */
+  BLO_write_id_struct(writer, bSound, id_address, &sound->id);
+  BKE_id_blend_write(writer, &sound->id);
+
+  BKE_packedfile_blend_write(writer, sound->packedfile);
 }
 
 static void sound_blend_read_data(BlendDataReader *reader, ID *id)
diff --git a/source/blender/blenkernel/intern/speaker.c b/source/blender/blenkernel/intern/speaker.c
index af9b2268879..4b10522c375 100644
--- a/source/blender/blenkernel/intern/speaker.c
+++ b/source/blender/blenkernel/intern/speaker.c
@@ -56,14 +56,13 @@ static void speaker_foreach_id(ID *id, LibraryForeachIDData *data)
 static void speaker_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   Speaker *spk = (Speaker *)id;
-  if (spk->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* write LibData */
-    BLO_write_id_struct(writer, Speaker, id_address, &spk->id);
-    BKE_id_blend_write(writer, &spk->id);
-
-    if (spk->adt) {
-      BKE_animdata_blend_write(writer, spk->adt);
-    }
+
+  /* write LibData */
+  BLO_write_id_struct(writer, Speaker, id_address, &spk->id);
+  BKE_id_blend_write(writer, &spk->id);
+
+  if (spk->adt) {
+    BKE_animdata_blend_write(writer, spk->adt);
   }
 }
 
diff --git a/source/blender/blenkernel/intern/text.c b/source/blender/blenkernel/intern/text.c
index 6048e823abb..275cf0d4c38 100644
--- a/source/blender/blenkernel/intern/text.c
+++ b/source/blender/blenkernel/intern/text.c
@@ -171,9 +171,6 @@ static void text_free_data(ID *id)
 
 static void text_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
-  if (id->us < 1 && !BLO_write_is_undo(writer)) {
-    return;
-  }
   Text *text = (Text *)id;
 
   /* NOTE: we are clearing local temp data here, *not* the flag in the actual 'real' ID. */
diff --git a/source/blender/blenkernel/intern/texture.c b/source/blender/blenkernel/intern/texture.c
index beb92495d16..228e6fffdf7 100644
--- a/source/blender/blenkernel/intern/texture.c
+++ b/source/blender/blenkernel/intern/texture.c
@@ -150,28 +150,27 @@ static void texture_foreach_id(ID *id, LibraryForeachIDData *data)
 static void texture_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   Tex *tex = (Tex *)id;
-  if (tex->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* write LibData */
-    BLO_write_id_struct(writer, Tex, id_address, &tex->id);
-    BKE_id_blend_write(writer, &tex->id);
 
-    if (tex->adt) {
-      BKE_animdata_blend_write(writer, tex->adt);
-    }
+  /* write LibData */
+  BLO_write_id_struct(writer, Tex, id_address, &tex->id);
+  BKE_id_blend_write(writer, &tex->id);
 
-    /* direct data */
-    if (tex->coba) {
-      BLO_write_struct(writer, ColorBand, tex->coba);
-    }
+  if (tex->adt) {
+    BKE_animdata_blend_write(writer, tex->adt);
+  }
 
-    /* nodetree is integral part of texture, no libdata */
-    if (tex->nodetree) {
-      BLO_write_struct(writer, bNodeTree, tex->nodetree);
-      ntreeBlendWrite(writer, tex->nodetree);
-    }
+  /* direct data */
+  if (tex->coba) {
+    BLO_write_struct(writer, ColorBand, tex->coba);
+  }
 
-    BKE_previewimg_blend_write(writer, tex->preview);
+  /* nodetree is integral part of texture, no libdata */
+  if (tex->nodetree) {
+    BLO_write_struct(writer, bNodeTree, tex->nodetree);
+    ntreeBlendWrite(writer, tex->nodetree);
   }
+
+  BKE_previewimg_blend_write(writer, tex->preview);
 }
 
 static void texture_blend_read_data(BlendDataReader *reader, ID *id)
diff --git a/source/blender/blenkernel/intern/volume.cc b/source/blender/blenkernel/intern/volume.cc
index b28d17df814..69452d6896f 100644
--- a/source/blender/blenkernel/intern/volume.cc
+++ b/source/blender/blenkernel/intern/volume.cc
@@ -578,27 +578,26 @@ static void volume_blend_write(BlendWriter *writer, ID *id, const void *id_addre
 {
   Volume *volume = (Volume *)id;
   const bool is_undo = BLO_write_is_undo(writer);
-  if (volume->id.us > 0 || is_undo) {
-    /* Clean up, important in undo case to reduce false detection of changed datablocks. */
-    volume->runtime.grids = nullptr;
 
-    /* Do not store packed files in case this is a library override ID. */
-    if (ID_IS_OVERRIDE_LIBRARY(volume) && !is_undo) {
-      volume->packedfile = nullptr;
-    }
+  /* Clean up, important in undo case to reduce false detection of changed datablocks. */
+  volume->runtime.grids = nullptr;
 
-    /* write LibData */
-    BLO_write_id_struct(writer, Volume, id_address, &volume->id);
-    BKE_id_blend_write(writer, &volume->id);
+  /* Do not store packed files in case this is a library override ID. */
+  if (ID_IS_OVERRIDE_LIBRARY(volume) && !is_undo) {
+    volume->packedfile = nullptr;
+  }
 
-    /* direct data */
-    BLO_write_pointer_array(writer, volume->totcol, volume->mat);
-    if (volume->adt) {
-      BKE_animdata_blend_write(writer, volume->adt);
-    }
+  /* write LibData */
+  BLO_write_id_struct(writer, Volume, id_address, &volume->id);
+  BKE_id_blend_write(writer, &volume->id);
 
-    BKE_packedfile_blend_write(writer, volume->packedfile);
+  /* direct data */
+  BLO_write_pointer_array(writer, volume->totcol, volume->mat);
+  if (volume->adt) {
+    BKE_animdata_blend_write(writer, volume->adt);
   }
+
+  BKE_packedfile_blend_write(writer, volume->packedfile);
 }
 
 static void volume_blend_read_data(BlendDataReader *reader, ID *id)
diff --git a/source/blender/blenkernel/intern/world.c b/source/blender/blenkernel/intern/world.c
index e889d8af1d5..4abe1ff0f20 100644
--- a/source/blender/blenkernel/intern/world.c
+++ b/source/blender/blenkernel/intern/world.c
@@ -138,26 +138,25 @@ static void world_foreach_id(ID *id, LibraryForeachIDData *data)
 static void world_blend_write(BlendWriter *writer, ID *id, const void *id_address)
 {
   World *wrld = (World *)id;
-  if (wrld->id.us > 0 || BLO_write_is_undo(writer)) {
-    /* Clean up, important in undo case to reduce false detection of changed datablocks. */
-    BLI_listbase_clear(&wrld->gpumaterial);
 
-    /* write LibData */
-    BLO_write_id_struct(writer, World, id_address, &wrld->id);
-    BKE_id_blend_write(writer, &wrld->id);
+  /* Clean up, important in undo case to reduce false detection of changed datablocks. */
+  BLI_listbase_clear(&wrld->gpumaterial);
 
-    if (wrld->adt) {
-      BKE_animdata_blend_write(writer, wrld->adt);
-    }
+  /* write LibData */
+  BLO_write_id_struct(writer, World, id_address, &wrld->id);
+  BKE_id_blend_write(writer, &wrld->id);
 
-    /* nodetree is integral part of world, no libdata */
-    if (wrld->nodetree) {
-      BLO_write_struct(writer, bNodeTree, wrld->nodetree);
-      ntreeBlendWrite(writer, wrld->nodetree);
-    }
+  if (wrld->adt) {
+    BKE_animdata_blend_write(writer, wrld->adt);
+  }
 
-    BKE_previewimg_blend_write(writer, wrld->preview);
+  /* nodetree is integral part of world, no libdata */
+  if (wrld->nodetree) {
+    BLO_write_struct(writer, bNodeTree, wrld->nodetree);
+    ntreeBlendWrite(writer, wrld->nodetree);
   }
+
+  BKE_previewimg_blend_write(writer, wrld->preview);
 }
 
 static void world_blend_read_data(BlendDataReader *reader, ID *id)
diff --git a/source/blender/blenlib/BLI_index_mask.hh b/source/blender/blenlib/BLI_index_mask.hh
index f04c0e9c80a..7a3169520ca 100644
--- a/source/blender/blenlib/BLI_index_mask.hh
+++ b/source/blender/blenlib/BLI_index_mask.hh
@@ -58,11 +58,7 @@ class IndexMask {
    */
   IndexMask(Span<int64_t> indices) : indices_(indices)
   {
-#ifdef DEBUG
-    for (int64_t i = 1; i < indices.size(); i++) {
-      BLI_assert(indices[i - 1] < indices[i]);
-    }
-#endif
+    BLI_assert(IndexMask::indices_are_valid_index_mask(indices));
   }
 
   /**
@@ -94,6 +90,22 @@ class IndexMask {
   {
   }
 
+  /** Checks that the indices are non-negative and in ascending order. */
+  static bool indices_are_valid_index_mask(Span<int64_t> indices)
+  {
+    if (!indices.is_empty()) {
+      if (indices.first() < 0) {
+        return false;
+      }
+    }
+    for (int64_t i = 1; i < indices.size(); i++) {
+      if (indices[i - 1] >= indices[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   operator Span<int64_t>() const
   {
     return indices_;
@@ -204,6 +216,11 @@ class IndexMask {
   {
     return indices_.size();
   }
+
+  bool is_empty() const
+  {
+    return indices_.is_empty();
+  }
 };
 
 }  // namespace blender
diff --git a/source/blender/blenloader/intern/versioning_300.c b/source/blender/blenloader/intern/versioning_300.c
index cac607ed152..eb01bfbfb9c 100644
--- a/source/blender/blenloader/intern/versioning_300.c
+++ b/source/blender/blenloader/intern/versioning_300.c
@@ -787,5 +787,23 @@ void blo_do_versions_300(FileData *fd, Library *UNUSED(lib), Main *bmain)
    */
   {
     /* Keep this block, even when empty. */
+
+    /* Add node storage for subdivision surface node. */
+    FOREACH_NODETREE_BEGIN (bmain, ntree, id) {
+      if (ntree->type == NTREE_GEOMETRY) {
+        LISTBASE_FOREACH (bNode *, node, &ntree->nodes) {
+          if (node->type == GEO_NODE_SUBDIVISION_SURFACE) {
+            if (node->storage == NULL) {
+              NodeGeometrySubdivisionSurface *data = MEM_callocN(
+                  sizeof(NodeGeometrySubdivisionSurface), __func__);
+              data->uv_smooth = SUBSURF_UV_SMOOTH_PRESERVE_BOUNDARIES;
+              data->boundary_smooth = SUBSURF_BOUNDARY_SMOOTH_ALL;
+              node->storage = data;
+            }
+          }
+        }
+      }
+    }
+    FOREACH_NODETREE_END;
   }
 }
diff --git a/source/blender/blenloader/intern/writefile.c b/source/blender/blenloader/intern/writefile.c
index 225548f3832..99246603e9a 100644
--- a/source/blender/blenloader/intern/writefile.c
+++ b/source/blender/blenloader/intern/writefile.c
@@ -982,6 +982,14 @@ static bool write_file_handle(Main *mainvar,
         BLI_assert(
             (id->tag & (LIB_TAG_NO_MAIN | LIB_TAG_NO_USER_REFCOUNT | LIB_TAG_NOT_ALLOCATED)) == 0);
 
+        /* We only write unused IDs in undo case.
+         * NOTE: All Scenes, WindowManagers and WorkSpaces should always be written to disk, so
+         * their usercount should never be NULL currently. */
+        if (id->us == 0 && !wd->use_memfile) {
+          BLI_assert(!ELEM(GS(id->name), ID_SCE, ID_WM, ID_WS));
+          continue;
+        }
+
         const bool do_override = !ELEM(override_storage, NULL, bmain) &&
                                  ID_IS_OVERRIDE_LIBRARY_REAL(id);
 
@@ -1015,12 +1023,23 @@ static bool write_file_handle(Main *mainvar,
 
         memcpy(id_buffer, id, idtype_struct_size);
 
+        /* Clear runtime data to reduce false detection of changed data in undo/redo context. */
         ((ID *)id_buffer)->tag = 0;
+        ((ID *)id_buffer)->us = 0;
+        ((ID *)id_buffer)->icon_id = 0;
         /* Those listbase data change every time we add/remove an ID, and also often when
          * renaming one (due to re-sorting). This avoids generating a lot of false 'is changed'
          * detections between undo steps. */
         ((ID *)id_buffer)->prev = NULL;
         ((ID *)id_buffer)->next = NULL;
+        /* Those runtime pointers should never be set during writing stage, but just in case clear
+         * them too. */
+        ((ID *)id_buffer)->orig_id = NULL;
+        ((ID *)id_buffer)->newid = NULL;
+        /* Even though in theory we could be able to preserve this python instance across undo even
+         * when we need to re-read the ID into its original address, this is currently cleared in
+         * #direct_link_id_common in `readfile.c` anyway, */
+        ((ID *)id_buffer)->py_instance = NULL;
 
         const IDTypeInfo *id_type = BKE_idtype_get_info_from_id(id);
         if (id_type->blend_write != NULL) {
diff --git a/source/blender/depsgraph/intern/builder/deg_builder_relations.cc b/source/blender/depsgraph/intern/builder/deg_builder_relations.cc
index 7da3d2e25f0..d88e9bc9c04 100644
--- a/source/blender/depsgraph/intern/builder/deg_builder_relations.cc
+++ b/source/blender/depsgraph/intern/builder/deg_builder_relations.cc
@@ -118,6 +118,7 @@
 #include "intern/node/deg_node_operation.h"
 #include "intern/node/deg_node_time.h"
 
+#include "intern/depsgraph.h"
 #include "intern/depsgraph_relation.h"
 #include "intern/depsgraph_type.h"
 
@@ -2095,7 +2096,7 @@ void DepsgraphRelationBuilder::build_object_data_geometry(Object *object)
         ctx.node = reinterpret_cast<::DepsNodeHandle *>(&handle);
         mti->updateDepsgraph(md, &ctx);
       }
-      if (BKE_object_modifier_use_time(object, md)) {
+      if (BKE_object_modifier_use_time(scene_, object, md, graph_->mode)) {
         TimeSourceKey time_src_key;
         add_relation(time_src_key, obdata_ubereval_key, "Time Source");
       }
diff --git a/source/blender/editors/gpencil/annotate_paint.c b/source/blender/editors/gpencil/annotate_paint.c
index 31ef094afa6..bf47704746b 100644
--- a/source/blender/editors/gpencil/annotate_paint.c
+++ b/source/blender/editors/gpencil/annotate_paint.c
@@ -836,10 +836,6 @@ static void annotation_stroke_newfrombuffer(tGPsdata *p)
 
   /* exit with error if no valid points from this stroke */
   if (totelem == 0) {
-    if (G.debug & G_DEBUG) {
-      printf("Error: No valid points in stroke buffer to convert (tot=%d)\n",
-             gpd->runtime.sbuffer_used);
-    }
     return;
   }
 
@@ -1263,9 +1259,6 @@ static bool annotation_session_initdata(bContext *C, tGPsdata *p)
   /* make sure the active view (at the starting time) is a 3d-view */
   if (curarea == NULL) {
     p->status = GP_STATUS_ERROR;
-    if (G.debug & G_DEBUG) {
-      printf("Error: No active view for painting\n");
-    }
     return 0;
   }
 
@@ -1294,11 +1287,6 @@ static bool annotation_session_initdata(bContext *C, tGPsdata *p)
 
       if (region->regiondata == NULL) {
         p->status = GP_STATUS_ERROR;
-        if (G.debug & G_DEBUG) {
-          printf(
-              "Error: 3D-View active region doesn't have any region data, so cannot be "
-              "drawable\n");
-        }
         return 0;
       }
       break;
@@ -1325,9 +1313,6 @@ static bool annotation_session_initdata(bContext *C, tGPsdata *p)
       /* check that gpencil data is allowed to be drawn */
       if (sseq->mainb == SEQ_DRAW_SEQUENCE) {
         p->status = GP_STATUS_ERROR;
-        if (G.debug & G_DEBUG) {
-          printf("Error: In active view (sequencer), active mode doesn't support Grease Pencil\n");
-        }
         return 0;
       }
       break;
@@ -1387,9 +1372,6 @@ static bool annotation_session_initdata(bContext *C, tGPsdata *p)
     /* unsupported views */
     default: {
       p->status = GP_STATUS_ERROR;
-      if (G.debug & G_DEBUG) {
-        printf("Error: Annotations are not supported in this editor\n");
-      }
       return 0;
     }
   }
@@ -1398,9 +1380,6 @@ static bool annotation_session_initdata(bContext *C, tGPsdata *p)
   gpd_ptr = ED_annotation_data_get_pointers(C, &p->ownerPtr);
   if ((gpd_ptr == NULL) || !ED_gpencil_data_owner_is_annotation(&p->ownerPtr)) {
     p->status = GP_STATUS_ERROR;
-    if (G.debug & G_DEBUG) {
-      printf("Error: Current context doesn't allow for any Annotation data\n");
-    }
     return 0;
   }
 
@@ -1507,7 +1486,6 @@ static void annotation_session_cleanup(tGPsdata *p)
 
   /* free stroke buffer */
   if (gpd->runtime.sbuffer) {
-    // printf("\t\tGP - free sbuffer\n");
     MEM_freeN(gpd->runtime.sbuffer);
     gpd->runtime.sbuffer = NULL;
   }
@@ -1545,9 +1523,6 @@ static void annotation_paint_initstroke(tGPsdata *p,
   }
   if (p->gpl->flag & GP_LAYER_LOCKED) {
     p->status = GP_STATUS_ERROR;
-    if (G.debug & G_DEBUG) {
-      printf("Error: Cannot paint on locked layer\n");
-    }
     return;
   }
 
@@ -1573,7 +1548,6 @@ static void annotation_paint_initstroke(tGPsdata *p,
 
     if (has_layer_to_erase == false) {
       p->status = GP_STATUS_CAPTURE;
-      // if (G.debug & G_DEBUG)
       printf("Error: Eraser will not be affecting anything (gpencil_paint_init)\n");
       return;
     }
@@ -1593,9 +1567,6 @@ static void annotation_paint_initstroke(tGPsdata *p,
 
     if (p->gpf == NULL) {
       p->status = GP_STATUS_ERROR;
-      if (G.debug & G_DEBUG) {
-        printf("Error: No frame created (gpencil_paint_init)\n");
-      }
       return;
     }
 
@@ -2063,9 +2034,6 @@ static void annotation_draw_apply(wmOperator *op, tGPsdata *p, Depsgraph *depsgr
       BKE_report(op->reports, RPT_ERROR, "Cannot paint stroke");
       p->status = GP_STATUS_ERROR;
 
-      if (G.debug & G_DEBUG) {
-        printf("Error: Grease-Pencil Paint - Add Point Invalid\n");
-      }
       return;
     }
 
@@ -2221,29 +2189,22 @@ static int annotation_draw_exec(bContext *C, wmOperator *op)
   tGPsdata *p = NULL;
   Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
 
-  // printf("GPencil - Starting Re-Drawing\n");
-
   /* try to initialize context data needed while drawing */
   if (!annotation_draw_init(C, op, NULL)) {
     if (op->customdata) {
       MEM_freeN(op->customdata);
     }
-    // printf("\tGP - no valid data\n");
     return OPERATOR_CANCELLED;
   }
 
   p = op->customdata;
 
-  // printf("\tGP - Start redrawing stroke\n");
-
   /* loop over the stroke RNA elements recorded (i.e. progress of mouse movement),
    * setting the relevant values in context at each step, then applying
    */
   RNA_BEGIN (op->ptr, itemptr, "stroke") {
     float mousef[2];
 
-    // printf("\t\tGP - stroke elem\n");
-
     /* get relevant data for this point from stroke */
     RNA_float_get_array(&itemptr, "mouse", mousef);
     p->mval[0] = (int)mousef[0];
@@ -2277,8 +2238,6 @@ static int annotation_draw_exec(bContext *C, wmOperator *op)
   }
   RNA_END;
 
-  // printf("\tGP - done\n");
-
   /* cleanup */
   annotation_draw_exit(C, op);
 
@@ -2301,18 +2260,11 @@ static int annotation_draw_invoke(bContext *C, wmOperator *op, const wmEvent *ev
     RNA_enum_set(op->ptr, "mode", GP_PAINTMODE_ERASER);
   }
 
-  if (G.debug & G_DEBUG) {
-    printf("GPencil - Starting Drawing\n");
-  }
-
   /* try to initialize context data needed while drawing */
   if (!annotation_draw_init(C, op, event)) {
     if (op->customdata) {
       MEM_freeN(op->customdata);
     }
-    if (G.debug & G_DEBUG) {
-      printf("\tGP - no valid data\n");
-    }
     return OPERATOR_CANCELLED;
   }
 
@@ -2361,7 +2313,6 @@ static int annotation_draw_invoke(bContext *C, wmOperator *op, const wmEvent *ev
   /* only start drawing immediately if we're allowed to do so... */
   if (RNA_boolean_get(op->ptr, "wait_for_input") == false) {
     /* hotkey invoked - start drawing */
-    // printf("\tGP - set first spot\n");
     p->status = GP_STATUS_PAINTING;
 
     /* handle the initial drawing - i.e. for just doing a simple dot */
@@ -2370,7 +2321,6 @@ static int annotation_draw_invoke(bContext *C, wmOperator *op, const wmEvent *ev
   }
   else {
     /* toolbar invoked - don't start drawing yet... */
-    // printf("\tGP - hotkey invoked... waiting for click-drag\n");
     op->flag |= OP_IS_MODAL_CURSOR_REGION;
   }
 
@@ -2399,8 +2349,6 @@ static tGPsdata *annotation_stroke_begin(bContext *C, wmOperator *op)
     p->status = GP_STATUS_ERROR;
   }
 
-  // printf("\t\tGP - start stroke\n");
-
   /* we may need to set up paint env again if we're resuming */
   /* XXX: watch it with the paintmode! in future,
    *      it'd be nice to allow changing paint-mode when in sketching-sessions */
@@ -2537,8 +2485,6 @@ static int annotation_draw_modal(bContext *C, wmOperator *op, const wmEvent *eve
     }
   }
 
-  // printf("\tGP - handle modal event...\n");
-
   /* Exit painting mode (and/or end current stroke)
    *
    * NOTE: cannot do RIGHTMOUSE (as is standard for canceling)
@@ -2547,7 +2493,6 @@ static int annotation_draw_modal(bContext *C, wmOperator *op, const wmEvent *eve
   if (event->val == KM_PRESS &&
       ELEM(event->type, EVT_RETKEY, EVT_PADENTER, EVT_ESCKEY, EVT_SPACEKEY, EVT_EKEY)) {
     /* exit() ends the current stroke before cleaning up */
-    // printf("\t\tGP - end of paint op + end of stroke\n");
     p->status = GP_STATUS_DONE;
     estate = OPERATOR_FINISHED;
   }
@@ -2571,7 +2516,6 @@ static int annotation_draw_modal(bContext *C, wmOperator *op, const wmEvent *eve
 
       if (sketch) {
         /* end stroke only, and then wait to resume painting soon */
-        // printf("\t\tGP - end stroke only\n");
         annotation_stroke_end(op);
 
         /* If eraser mode is on, turn it off after the stroke finishes
@@ -2602,7 +2546,6 @@ static int annotation_draw_modal(bContext *C, wmOperator *op, const wmEvent *eve
         WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL);
       }
       else {
-        // printf("\t\tGP - end of stroke + op\n");
         p->status = GP_STATUS_DONE;
         estate = OPERATOR_FINISHED;
       }
@@ -2619,18 +2562,6 @@ static int annotation_draw_modal(bContext *C, wmOperator *op, const wmEvent *eve
         ARegion *current_region = BKE_area_find_region_xy(
             p->area, RGN_TYPE_ANY, event->x, event->y);
 
-        if (G.debug & G_DEBUG) {
-          printf("found alternative region %p (old was %p) - at %d %d (area: %d %d -> %d %d)\n",
-                 current_region,
-                 p->region,
-                 event->x,
-                 event->y,
-                 p->area->totrct.xmin,
-                 p->area->totrct.ymin,
-                 p->area->totrct.xmax,
-                 p->area->totrct.ymax);
-        }
-
         if (current_region) {
           /* Assume that since we found the cursor in here, it is in bounds
            * and that this should be the region that we begin drawing in
@@ -2642,10 +2573,6 @@ static int annotation_draw_modal(bContext *C, wmOperator *op, const wmEvent *eve
           /* Out of bounds, or invalid in some other way */
           p->status = GP_STATUS_ERROR;
           estate = OPERATOR_CANCELLED;
-
-          if (G.debug & G_DEBUG) {
-            printf("%s: Region under cursor is out of bounds, so cannot be drawn on\n", __func__);
-          }
         }
       }
       else if (p->region) {
@@ -2657,10 +2584,6 @@ static int annotation_draw_modal(bContext *C, wmOperator *op, const wmEvent *eve
         /* No region */
         p->status = GP_STATUS_ERROR;
         estate = OPERATOR_CANCELLED;
-
-        if (G.debug & G_DEBUG) {
-          printf("%s: No active region found in GP Paint session data\n", __func__);
-        }
       }
 
       if (in_bounds) {
@@ -2719,7 +2642,6 @@ static int annotation_draw_modal(bContext *C, wmOperator *op, const wmEvent *eve
       }
       else {
         /* event handled, so just tag as running modal */
-        // printf("\t\t\t\tGP - add point handled!\n");
         estate = OPERATOR_RUNNING_MODAL;
       }
     }
@@ -2729,7 +2651,6 @@ static int annotation_draw_modal(bContext *C, wmOperator *op, const wmEvent *eve
       /* just resize the brush (local version)
        * TODO: fix the hardcoded size jumps (set to make a visible difference) and hardcoded keys
        */
-      // printf("\t\tGP - resize eraser\n");
       switch (event->type) {
         case WHEELDOWNMOUSE: /* larger */
         case EVT_PADPLUSKEY:
@@ -2787,12 +2708,6 @@ static int annotation_draw_modal(bContext *C, wmOperator *op, const wmEvent *eve
 
     case OPERATOR_RUNNING_MODAL | OPERATOR_PASS_THROUGH:
       /* event doesn't need to be handled */
-#if 0
-      printf("unhandled event -> %d (mmb? = %d | mmv? = %d)\n",
-             event->type,
-             event->type == MIDDLEMOUSE,
-             event->type == MOUSEMOVE);
-#endif
       break;
   }
 
diff --git a/source/blender/editors/gpencil/gpencil_convert.c b/source/blender/editors/gpencil/gpencil_convert.c
index a0a58abc02f..406a7ac77fc 100644
--- a/source/blender/editors/gpencil/gpencil_convert.c
+++ b/source/blender/editors/gpencil/gpencil_convert.c
@@ -389,9 +389,6 @@ static void gpencil_stroke_path_animation_preprocess_gaps(tGpTimingData *gtd,
 
   *r_tot_gaps_time = (float)(*nbr_gaps) * gtd->gap_duration;
   gtd->tot_time += *r_tot_gaps_time;
-  if (G.debug & G_DEBUG) {
-    printf("%f, %f, %f, %d\n", gtd->tot_time, delta_time, *r_tot_gaps_time, *nbr_gaps);
-  }
   if (gtd->gap_randomness > 0.0f) {
     BLI_rng_srandom(rng, gtd->seed);
   }
@@ -464,9 +461,6 @@ static void gpencil_stroke_path_animation_add_keyframes(ReportList *reports,
                                INSERTKEY_FAST);
         last_valid_time = cfra;
       }
-      else if (G.debug & G_DEBUG) {
-        printf("\t Skipping start point %d, too close from end point %d\n", i, end_stroke_idx);
-      }
     }
     else if (i == end_stroke_idx) {
       /* Always try to insert end point of a curve (should be safe enough, anyway...) */
@@ -546,13 +540,6 @@ static void gpencil_stroke_path_animation(bContext *C,
   act = ED_id_action_ensure(bmain, (ID *)cu);
   fcu = ED_action_fcurve_ensure(bmain, act, NULL, &ptr, "eval_time", 0);
 
-  if (G.debug & G_DEBUG) {
-    printf("%s: tot len: %f\t\ttot time: %f\n", __func__, gtd->tot_dist, gtd->tot_time);
-    for (int i = 0; i < gtd->num_points; i++) {
-      printf("\tpoint %d:\t\tlen: %f\t\ttime: %f\n", i, gtd->dists[i], gtd->times[i]);
-    }
-  }
-
   if (gtd->mode == GP_STROKECONVERT_TIMING_LINEAR) {
     float cfra;
 
@@ -610,10 +597,6 @@ static void gpencil_stroke_path_animation(bContext *C,
       time_range = (float)(gtd->end_frame - gtd->start_frame);
     }
 
-    if (G.debug & G_DEBUG) {
-      printf("GP Stroke Path Conversion: Starting keying!\n");
-    }
-
     gpencil_stroke_path_animation_add_keyframes(
         reports, ptr, prop, depsgraph, fcu, cu, gtd, rng, time_range, nbr_gaps, tot_gaps_time);
 
@@ -623,14 +606,6 @@ static void gpencil_stroke_path_animation(bContext *C,
   /* As we used INSERTKEY_FAST mode, we need to recompute all curve's handles now */
   calchandles_fcurve(fcu);
 
-  if (G.debug & G_DEBUG) {
-    printf("%s: \ntot len: %f\t\ttot time: %f\n", __func__, gtd->tot_dist, gtd->tot_time);
-    for (int i = 0; i < gtd->num_points; i++) {
-      printf("\tpoint %d:\t\tlen: %f\t\ttime: %f\n", i, gtd->dists[i], gtd->times[i]);
-    }
-    printf("\n\n");
-  }
-
   WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
 
   /* send updates */
diff --git a/source/blender/editors/gpencil/gpencil_paint.c b/source/blender/editors/gpencil/gpencil_paint.c
index 9e96c40b2db..d2dbf6ab2a6 100644
--- a/source/blender/editors/gpencil/gpencil_paint.c
+++ b/source/blender/editors/gpencil/gpencil_paint.c
@@ -976,10 +976,6 @@ static void gpencil_stroke_newfrombuffer(tGPsdata *p)
 
   /* exit with error if no valid points from this stroke */
   if (totelem == 0) {
-    if (G.debug & G_DEBUG) {
-      printf("Error: No valid points in stroke buffer to convert (tot=%d)\n",
-             gpd->runtime.sbuffer_used);
-    }
     return;
   }
 
@@ -1949,9 +1945,6 @@ static bool gpencil_session_initdata(bContext *C, wmOperator *op, tGPsdata *p)
   /* make sure the active view (at the starting time) is a 3d-view */
   if (curarea == NULL) {
     p->status = GP_STATUS_ERROR;
-    if (G.debug & G_DEBUG) {
-      printf("Error: No active view for painting\n");
-    }
     return 0;
   }
 
@@ -1980,11 +1973,6 @@ static bool gpencil_session_initdata(bContext *C, wmOperator *op, tGPsdata *p)
 
       if (region->regiondata == NULL) {
         p->status = GP_STATUS_ERROR;
-        if (G.debug & G_DEBUG) {
-          printf(
-              "Error: 3D-View active region doesn't have any region data, so cannot be "
-              "drawable\n");
-        }
         return 0;
       }
 
@@ -2010,9 +1998,6 @@ static bool gpencil_session_initdata(bContext *C, wmOperator *op, tGPsdata *p)
     /* unsupported views */
     default: {
       p->status = GP_STATUS_ERROR;
-      if (G.debug & G_DEBUG) {
-        printf("Error: Active view not appropriate for Grease Pencil drawing\n");
-      }
       return 0;
     }
   }
@@ -2021,9 +2006,6 @@ static bool gpencil_session_initdata(bContext *C, wmOperator *op, tGPsdata *p)
   gpd_ptr = ED_gpencil_data_get_pointers(C, &p->ownerPtr);
   if ((gpd_ptr == NULL) || ED_gpencil_data_owner_is_annotation(&p->ownerPtr)) {
     p->status = GP_STATUS_ERROR;
-    if (G.debug & G_DEBUG) {
-      printf("Error: Current context doesn't allow for any Grease Pencil data\n");
-    }
     return 0;
   }
 
@@ -2147,9 +2129,6 @@ static void gpencil_paint_initstroke(tGPsdata *p,
 
   if ((paintmode != GP_PAINTMODE_ERASER) && (p->gpl->flag & GP_LAYER_LOCKED)) {
     p->status = GP_STATUS_ERROR;
-    if (G.debug & G_DEBUG) {
-      printf("Error: Cannot paint on locked layer\n");
-    }
     return;
   }
 
@@ -2228,9 +2207,6 @@ static void gpencil_paint_initstroke(tGPsdata *p,
 
     if (p->gpf == NULL) {
       p->status = GP_STATUS_ERROR;
-      if (G.debug & G_DEBUG) {
-        printf("Error: No frame created (gpencil_paint_init)\n");
-      }
       if (!IS_AUTOKEY_ON(scene)) {
         BKE_report(p->reports, RPT_INFO, "No available frame for creating stroke");
       }
@@ -2824,9 +2800,6 @@ static void gpencil_draw_apply(bContext *C, wmOperator *op, tGPsdata *p, Depsgra
       BKE_report(op->reports, RPT_ERROR, "Cannot paint stroke");
       p->status = GP_STATUS_ERROR;
 
-      if (G.debug & G_DEBUG) {
-        printf("Error: Grease-Pencil Paint - Add Point Invalid\n");
-      }
       return;
     }
 
@@ -3198,10 +3171,6 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event
   Object *ob = CTX_data_active_object(C);
   bGPdata *gpd = (bGPdata *)ob->data;
 
-  if (G.debug & G_DEBUG) {
-    printf("GPencil - Starting Drawing\n");
-  }
-
   /* support for tablets eraser pen */
   if (gpencil_is_tablet_eraser_active(event)) {
     RNA_enum_set(op->ptr, "mode", GP_PAINTMODE_ERASER);
@@ -3239,9 +3208,6 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event
     if (op->customdata) {
       MEM_freeN(op->customdata);
     }
-    if (G.debug & G_DEBUG) {
-      printf("\tGP - no valid data\n");
-    }
     return OPERATOR_CANCELLED;
   }
 
@@ -3730,18 +3696,6 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
         ARegion *current_region = BKE_area_find_region_xy(
             p->area, RGN_TYPE_ANY, event->x, event->y);
 
-        if (G.debug & G_DEBUG) {
-          printf("found alternative region %p (old was %p) - at %d %d (area: %d %d -> %d %d)\n",
-                 current_region,
-                 p->region,
-                 event->x,
-                 event->y,
-                 p->area->totrct.xmin,
-                 p->area->totrct.ymin,
-                 p->area->totrct.xmax,
-                 p->area->totrct.ymax);
-        }
-
         if (current_region) {
           /* Assume that since we found the cursor in here, it is in bounds
            * and that this should be the region that we begin drawing in
@@ -3753,10 +3707,6 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
           /* Out of bounds, or invalid in some other way */
           p->status = GP_STATUS_ERROR;
           estate = OPERATOR_CANCELLED;
-
-          if (G.debug & G_DEBUG) {
-            printf("%s: Region under cursor is out of bounds, so cannot be drawn on\n", __func__);
-          }
         }
       }
       else if (p->region) {
@@ -3768,10 +3718,6 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event)
         /* No region */
         p->status = GP_STATUS_ERROR;
         estate = OPERATOR_CANCELLED;
-
-        if (G.debug & G_DEBUG) {
-          printf("%s: No active region found in GP Paint session data\n", __func__);
-        }
       }
 
       if (in_bounds) {
diff --git a/source/blender/editors/gpencil/gpencil_primitive.c b/source/blender/editors/gpencil/gpencil_primitive.c
index 7e6ff53de14..894fb83d70e 100644
--- a/source/blender/editors/gpencil/gpencil_primitive.c
+++ b/source/blender/editors/gpencil/gpencil_primitive.c
@@ -1830,11 +1830,6 @@ static int gpencil_primitive_modal(bContext *C, wmOperator *op, const wmEvent *e
       else if ((event->val == KM_RELEASE) && (tgpi->flag == IN_MOVE)) {
         tgpi->flag = IN_CURVE_EDIT;
       }
-      else {
-        if (G.debug & G_DEBUG) {
-          printf("GP Add Primitive Modal: LEFTMOUSE %d, Status = %d\n", event->val, tgpi->flag);
-        }
-      }
       break;
     }
     case EVT_SPACEKEY: /* confirm */
diff --git a/source/blender/editors/gpencil/gpencil_undo.c b/source/blender/editors/gpencil/gpencil_undo.c
index ede1d3eefaa..99b8b672327 100644
--- a/source/blender/editors/gpencil/gpencil_undo.c
+++ b/source/blender/editors/gpencil/gpencil_undo.c
@@ -125,7 +125,7 @@ static void gpencil_undo_free_node(bGPundonode *undo_node)
    */
   undo_node->gpd->adt = NULL;
 
-  BKE_gpencil_free(undo_node->gpd, false);
+  BKE_gpencil_free_data(undo_node->gpd, false);
   MEM_freeN(undo_node->gpd);
 }
 
@@ -133,8 +133,6 @@ void gpencil_undo_push(bGPdata *gpd)
 {
   bGPundonode *undo_node;
 
-  // printf("\t\tGP - undo push\n");
-
   if (cur_node) {
     /* Remove all undone nodes from stack. */
     undo_node = cur_node->next;
diff --git a/source/blender/editors/interface/interface_context_menu.c b/source/blender/editors/interface/interface_context_menu.c
index 8ace057891d..b953d88c896 100644
--- a/source/blender/editors/interface/interface_context_menu.c
+++ b/source/blender/editors/interface/interface_context_menu.c
@@ -373,13 +373,7 @@ static void ui_but_user_menu_add(bContext *C, uiBut *but, bUserMenu *um)
   BLI_assert(ui_but_is_user_menu_compatible(C, but));
 
   char drawstr[sizeof(but->drawstr)];
-  STRNCPY(drawstr, but->drawstr);
-  if (but->flag & UI_BUT_HAS_SEP_CHAR) {
-    char *sep = strrchr(drawstr, UI_SEP_CHAR);
-    if (sep) {
-      *sep = '\0';
-    }
-  }
+  ui_but_drawstr_without_sep_char(but, drawstr, sizeof(drawstr));
 
   MenuType *mt = NULL;
   if (but->optype) {
diff --git a/source/blender/editors/interface/interface_handlers.c b/source/blender/editors/interface/interface_handlers.c
index 6f2232fabe5..b8f324cba83 100644
--- a/source/blender/editors/interface/interface_handlers.c
+++ b/source/blender/editors/interface/interface_handlers.c
@@ -3086,11 +3086,6 @@ static void ui_textedit_set_cursor_pos(uiBut *but, uiHandleButtonData *data, con
 
   UI_fontstyle_set(&fstyle);
 
-  if (fstyle.kerning == 1) {
-    /* for BLF_width */
-    BLF_enable(fstyle.uifont_id, BLF_KERNING_DEFAULT);
-  }
-
   ui_but_text_password_hide(password_str, but, false);
 
   if (ELEM(but->type, UI_BTYPE_TEXT, UI_BTYPE_SEARCH_MENU)) {
@@ -3141,10 +3136,6 @@ static void ui_textedit_set_cursor_pos(uiBut *but, uiHandleButtonData *data, con
     but->pos = glyph_data[1] + but->ofs;
   }
 
-  if (fstyle.kerning == 1) {
-    BLF_disable(fstyle.uifont_id, BLF_KERNING_DEFAULT);
-  }
-
   ui_but_text_password_hide(password_str, but, true);
 }
 
diff --git a/source/blender/editors/interface/interface_intern.h b/source/blender/editors/interface/interface_intern.h
index 6b0b8e8df8f..d61104f094e 100644
--- a/source/blender/editors/interface/interface_intern.h
+++ b/source/blender/editors/interface/interface_intern.h
@@ -1177,6 +1177,8 @@ uiBut *ui_list_find_mouse_over_ex(const struct ARegion *region,
 
 bool ui_but_contains_password(const uiBut *but) ATTR_WARN_UNUSED_RESULT;
 
+size_t ui_but_drawstr_without_sep_char(const uiBut *but, char *str, size_t str_maxlen)
+    ATTR_NONNULL(1, 2);
 size_t ui_but_drawstr_len_without_sep_char(const uiBut *but);
 size_t ui_but_tip_len_only_first_line(const uiBut *but);
 
diff --git a/source/blender/editors/interface/interface_panel.c b/source/blender/editors/interface/interface_panel.c
index 97d01ac3763..a64797af24f 100644
--- a/source/blender/editors/interface/interface_panel.c
+++ b/source/blender/editors/interface/interface_panel.c
@@ -1447,10 +1447,6 @@ void UI_panel_category_draw_all(ARegion *region, const char *category_id_active)
 
   is_alpha = (region->overlap && (theme_col_back[3] != 255));
 
-  if (fstyle->kerning == 1) {
-    BLF_enable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
-  }
-
   BLF_enable(fontid, BLF_ROTATION);
   BLF_rotation(fontid, M_PI_2);
   // UI_fontstyle_set(&style->widget);
@@ -1620,10 +1616,6 @@ void UI_panel_category_draw_all(ARegion *region, const char *category_id_active)
   GPU_line_smooth(false);
 
   BLF_disable(fontid, BLF_ROTATION);
-
-  if (fstyle->kerning == 1) {
-    BLF_disable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
-  }
 }
 
 #undef TABS_PADDING_BETWEEN_FACTOR
diff --git a/source/blender/editors/interface/interface_query.c b/source/blender/editors/interface/interface_query.c
index 8534c95b6fd..09429bb6df5 100644
--- a/source/blender/editors/interface/interface_query.c
+++ b/source/blender/editors/interface/interface_query.c
@@ -23,6 +23,7 @@
 #include "BLI_listbase.h"
 #include "BLI_math.h"
 #include "BLI_rect.h"
+#include "BLI_string.h"
 #include "BLI_utildefines.h"
 
 #include "DNA_screen_types.h"
@@ -553,6 +554,12 @@ size_t ui_but_drawstr_len_without_sep_char(const uiBut *but)
   return strlen(but->drawstr);
 }
 
+size_t ui_but_drawstr_without_sep_char(const uiBut *but, char *str, size_t str_maxlen)
+{
+  size_t str_len_clip = ui_but_drawstr_len_without_sep_char(but);
+  return BLI_strncpy_rlen(str, but->drawstr, min_zz(str_len_clip + 1, str_maxlen));
+}
+
 size_t ui_but_tip_len_only_first_line(const uiBut *but)
 {
   if (but->tip == NULL) {
diff --git a/source/blender/editors/interface/interface_region_tooltip.c b/source/blender/editors/interface/interface_region_tooltip.c
index 10bc3760b42..a8f289702f8 100644
--- a/source/blender/editors/interface/interface_region_tooltip.c
+++ b/source/blender/editors/interface/interface_region_tooltip.c
@@ -1175,9 +1175,6 @@ static ARegion *ui_tooltip_create_with_data(bContext *C,
   data->wrap_width = min_ii(UI_TIP_MAXWIDTH * U.pixelsize / aspect, winx - (UI_TIP_PADDING * 2));
 
   font_flag |= BLF_WORD_WRAP;
-  if (data->fstyle.kerning == 1) {
-    font_flag |= BLF_KERNING_DEFAULT;
-  }
   BLF_enable(data->fstyle.uifont_id, font_flag);
   BLF_enable(blf_mono_font, font_flag);
   BLF_wordwrap(data->fstyle.uifont_id, data->wrap_width);
diff --git a/source/blender/editors/interface/interface_style.c b/source/blender/editors/interface/interface_style.c
index 88ab6a377d0..804156ba48c 100644
--- a/source/blender/editors/interface/interface_style.c
+++ b/source/blender/editors/interface/interface_style.c
@@ -83,7 +83,6 @@ static uiStyle *ui_style_new(ListBase *styles, const char *name, short uifont_id
 
   style->paneltitle.uifont_id = uifont_id;
   style->paneltitle.points = UI_DEFAULT_TITLE_POINTS;
-  style->paneltitle.kerning = 1;
   style->paneltitle.shadow = 3;
   style->paneltitle.shadx = 0;
   style->paneltitle.shady = -1;
@@ -92,7 +91,6 @@ static uiStyle *ui_style_new(ListBase *styles, const char *name, short uifont_id
 
   style->grouplabel.uifont_id = uifont_id;
   style->grouplabel.points = UI_DEFAULT_TITLE_POINTS;
-  style->grouplabel.kerning = 1;
   style->grouplabel.shadow = 3;
   style->grouplabel.shadx = 0;
   style->grouplabel.shady = -1;
@@ -101,7 +99,6 @@ static uiStyle *ui_style_new(ListBase *styles, const char *name, short uifont_id
 
   style->widgetlabel.uifont_id = uifont_id;
   style->widgetlabel.points = UI_DEFAULT_TEXT_POINTS;
-  style->widgetlabel.kerning = 1;
   style->widgetlabel.shadow = 3;
   style->widgetlabel.shadx = 0;
   style->widgetlabel.shady = -1;
@@ -110,7 +107,6 @@ static uiStyle *ui_style_new(ListBase *styles, const char *name, short uifont_id
 
   style->widget.uifont_id = uifont_id;
   style->widget.points = UI_DEFAULT_TEXT_POINTS;
-  style->widget.kerning = 1;
   style->widget.shadow = 1;
   style->widget.shady = -1;
   style->widget.shadowalpha = 0.5f;
@@ -164,9 +160,6 @@ void UI_fontstyle_draw_ex(const uiFontStyle *fs,
     BLF_shadow(fs->uifont_id, fs->shadow, shadow_color);
     BLF_shadow_offset(fs->uifont_id, fs->shadx, fs->shady);
   }
-  if (fs->kerning == 1) {
-    font_flag |= BLF_KERNING_DEFAULT;
-  }
   if (fs_params->word_wrap == 1) {
     font_flag |= BLF_WORD_WRAP;
   }
@@ -278,19 +271,12 @@ void UI_fontstyle_draw_rotated(const uiFontStyle *fs,
     BLF_shadow_offset(fs->uifont_id, fs->shadx, fs->shady);
   }
 
-  if (fs->kerning == 1) {
-    BLF_enable(fs->uifont_id, BLF_KERNING_DEFAULT);
-  }
-
   BLF_draw(fs->uifont_id, str, BLF_DRAW_STR_DUMMY_MAX);
   BLF_disable(fs->uifont_id, BLF_ROTATION);
   BLF_disable(fs->uifont_id, BLF_CLIPPING);
   if (fs->shadow) {
     BLF_disable(fs->uifont_id, BLF_SHADOW);
   }
-  if (fs->kerning == 1) {
-    BLF_disable(fs->uifont_id, BLF_KERNING_DEFAULT);
-  }
 }
 
 /**
@@ -302,18 +288,10 @@ void UI_fontstyle_draw_rotated(const uiFontStyle *fs,
 void UI_fontstyle_draw_simple(
     const uiFontStyle *fs, float x, float y, const char *str, const uchar col[4])
 {
-  if (fs->kerning == 1) {
-    BLF_enable(fs->uifont_id, BLF_KERNING_DEFAULT);
-  }
-
   UI_fontstyle_set(fs);
   BLF_position(fs->uifont_id, x, y, 0.0f);
   BLF_color4ubv(fs->uifont_id, col);
   BLF_draw(fs->uifont_id, str, BLF_DRAW_STR_DUMMY_MAX);
-
-  if (fs->kerning == 1) {
-    BLF_disable(fs->uifont_id, BLF_KERNING_DEFAULT);
-  }
 }
 
 /**
@@ -326,10 +304,6 @@ void UI_fontstyle_draw_simple_backdrop(const uiFontStyle *fs,
                                        const float col_fg[4],
                                        const float col_bg[4])
 {
-  if (fs->kerning == 1) {
-    BLF_enable(fs->uifont_id, BLF_KERNING_DEFAULT);
-  }
-
   UI_fontstyle_set(fs);
 
   {
@@ -357,10 +331,6 @@ void UI_fontstyle_draw_simple_backdrop(const uiFontStyle *fs,
   BLF_position(fs->uifont_id, x, y, 0.0f);
   BLF_color4fv(fs->uifont_id, col_fg);
   BLF_draw(fs->uifont_id, str, BLF_DRAW_STR_DUMMY_MAX);
-
-  if (fs->kerning == 1) {
-    BLF_disable(fs->uifont_id, BLF_KERNING_DEFAULT);
-  }
 }
 
 /* ************** helpers ************************ */
@@ -405,21 +375,8 @@ const uiStyle *UI_style_get_dpi(void)
 
 int UI_fontstyle_string_width(const uiFontStyle *fs, const char *str)
 {
-  int width;
-
-  if (fs->kerning == 1) {
-    /* for BLF_width */
-    BLF_enable(fs->uifont_id, BLF_KERNING_DEFAULT);
-  }
-
   UI_fontstyle_set(fs);
-  width = BLF_width(fs->uifont_id, str, BLF_DRAW_STR_DUMMY_MAX);
-
-  if (fs->kerning == 1) {
-    BLF_disable(fs->uifont_id, BLF_KERNING_DEFAULT);
-  }
-
-  return width;
+  return (int)BLF_width(fs->uifont_id, str, BLF_DRAW_STR_DUMMY_MAX);
 }
 
 int UI_fontstyle_height_max(const uiFontStyle *fs)
diff --git a/source/blender/editors/interface/interface_templates.c b/source/blender/editors/interface/interface_templates.c
index 47ff0c9fd3c..351b73c320b 100644
--- a/source/blender/editors/interface/interface_templates.c
+++ b/source/blender/editors/interface/interface_templates.c
@@ -84,6 +84,8 @@
 #include "ED_screen.h"
 #include "ED_undo.h"
 
+#include "RE_engine.h"
+
 #include "RNA_access.h"
 
 #include "WM_api.h"
@@ -6463,6 +6465,30 @@ void uiTemplateCacheFile(uiLayout *layout,
   row = uiLayoutRow(layout, false);
   uiItemR(row, &fileptr, "is_sequence", 0, NULL, ICON_NONE);
 
+  /* Only enable render procedural option if the active engine supports it. */
+  const struct RenderEngineType *engine_type = CTX_data_engine_type(C);
+
+  Scene *scene = CTX_data_scene(C);
+  const bool engine_supports_procedural = RE_engine_supports_alembic_procedural(engine_type,
+                                                                                scene);
+
+  if (!engine_supports_procedural) {
+    row = uiLayoutRow(layout, false);
+    /* For Cycles, verify that experimental features are enabled. */
+    if (BKE_scene_uses_cycles(scene) && !BKE_scene_uses_cycles_experimental_features(scene)) {
+      uiItemL(row,
+              "The Cycles Alembic Procedural is only available with the experimental feature set",
+              ICON_INFO);
+    }
+    else {
+      uiItemL(row, "The active render engine does not have an Alembic Procedural", ICON_INFO);
+    }
+  }
+
+  row = uiLayoutRow(layout, false);
+  uiLayoutSetActive(row, engine_supports_procedural);
+  uiItemR(row, &fileptr, "use_render_procedural", 0, NULL, ICON_NONE);
+
   row = uiLayoutRowWithHeading(layout, true, IFACE_("Override Frame"));
   sub = uiLayoutRow(row, true);
   uiLayoutSetPropDecorate(sub, false);
diff --git a/source/blender/editors/interface/interface_widgets.c b/source/blender/editors/interface/interface_widgets.c
index d3481c449ac..48f638dac33 100644
--- a/source/blender/editors/interface/interface_widgets.c
+++ b/source/blender/editors/interface/interface_widgets.c
@@ -1576,11 +1576,6 @@ float UI_text_clip_middle_ex(const uiFontStyle *fstyle,
   /* need to set this first */
   UI_fontstyle_set(fstyle);
 
-  if (fstyle->kerning == 1) {
-    /* for BLF_width */
-    BLF_enable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
-  }
-
   float strwidth = BLF_width(fstyle->uifont_id, str, max_len);
 
   if ((okwidth > 0.0f) && (strwidth > okwidth)) {
@@ -1674,10 +1669,6 @@ float UI_text_clip_middle_ex(const uiFontStyle *fstyle,
     strwidth = BLF_width(fstyle->uifont_id, str, max_len);
   }
 
-  if (fstyle->kerning == 1) {
-    BLF_disable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
-  }
-
   BLI_assert(strwidth <= okwidth);
 
   return strwidth;
@@ -1736,11 +1727,6 @@ static void ui_text_clip_cursor(const uiFontStyle *fstyle, uiBut *but, const rct
   /* need to set this first */
   UI_fontstyle_set(fstyle);
 
-  if (fstyle->kerning == 1) {
-    /* for BLF_width */
-    BLF_enable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
-  }
-
   /* define ofs dynamically */
   if (but->ofs > but->pos) {
     but->ofs = but->pos;
@@ -1785,10 +1771,6 @@ static void ui_text_clip_cursor(const uiFontStyle *fstyle, uiBut *but, const rct
       }
     }
   }
-
-  if (fstyle->kerning == 1) {
-    BLF_disable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
-  }
 }
 
 /**
@@ -1806,11 +1788,6 @@ static void ui_text_clip_right_label(const uiFontStyle *fstyle, uiBut *but, cons
   /* need to set this first */
   UI_fontstyle_set(fstyle);
 
-  if (fstyle->kerning == 1) {
-    /* for BLF_width */
-    BLF_enable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
-  }
-
   but->strwidth = BLF_width(fstyle->uifont_id, but->drawstr, sizeof(but->drawstr));
   but->ofs = 0;
 
@@ -1870,10 +1847,6 @@ static void ui_text_clip_right_label(const uiFontStyle *fstyle, uiBut *but, cons
     but->strwidth = strwidth;
     but->drawstr[drawstr_len] = 0;
   }
-
-  if (fstyle->kerning == 1) {
-    BLF_disable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
-  }
 }
 
 #ifdef WITH_INPUT_IME
@@ -1985,11 +1958,6 @@ static void widget_draw_text(const uiFontStyle *fstyle,
     align = UI_STYLE_TEXT_CENTER;
   }
 
-  if (fstyle->kerning == 1) {
-    /* for BLF_width */
-    BLF_enable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
-  }
-
   /* Special case: when we're entering text for multiple buttons,
    * don't draw the text for any of the multi-editing buttons */
   if (UNLIKELY(but->flag & UI_BUT_DRAG_MULTI)) {
@@ -2151,10 +2119,6 @@ static void widget_draw_text(const uiFontStyle *fstyle,
 #endif
   }
 
-  if (fstyle->kerning == 1) {
-    BLF_disable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
-  }
-
 #if 0
   ui_rasterpos_safe(x, y, but->aspect);
   transopts = ui_translate_buttons();
@@ -2232,10 +2196,6 @@ static void widget_draw_text(const uiFontStyle *fstyle,
         }
 
         if (ul_index != -1) {
-          if (fstyle->kerning == 1) {
-            BLF_enable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
-          }
-
           int ul_width = round_fl_to_int(BLF_width(fstyle->uifont_id, "_", 2));
 
           struct UnderlineData ul_data = {
@@ -2256,10 +2216,6 @@ static void widget_draw_text(const uiFontStyle *fstyle,
           BLF_position(fstyle->uifont_id, pos_x, pos_y, 0.0f);
           BLF_color4ubv(fstyle->uifont_id, wcol->text);
           BLF_draw(fstyle->uifont_id, "_", 2);
-
-          if (fstyle->kerning == 1) {
-            BLF_disable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
-          }
         }
       }
     }
@@ -5369,11 +5325,6 @@ void ui_draw_menu_item(const uiFontStyle *fstyle,
       /* need to set this first */
       UI_fontstyle_set(fstyle);
 
-      if (fstyle->kerning == 1) {
-        /* for BLF_width */
-        BLF_enable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
-      }
-
       if (separator_type == UI_MENU_ITEM_SEPARATOR_SHORTCUT) {
         /* Shrink rect to exclude the shortcut string. */
         rect->xmax -= BLF_width(fstyle->uifont_id, cpoin + 1, INT_MAX) + UI_DPI_ICON_SIZE;
@@ -5398,10 +5349,6 @@ void ui_draw_menu_item(const uiFontStyle *fstyle,
       else {
         BLI_assert_msg(0, "Unknwon menu item separator type");
       }
-
-      if (fstyle->kerning == 1) {
-        BLF_disable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
-      }
     }
   }
 
diff --git a/source/blender/editors/io/io_alembic.c b/source/blender/editors/io/io_alembic.c
index 12890552b1d..bbff37221e8 100644
--- a/source/blender/editors/io/io_alembic.c
+++ b/source/blender/editors/io/io_alembic.c
@@ -615,6 +615,7 @@ static void ui_alembic_import_settings(uiLayout *layout, PointerRNA *imfptr)
   uiItemR(col, imfptr, "set_frame_range", 0, NULL, ICON_NONE);
   uiItemR(col, imfptr, "is_sequence", 0, NULL, ICON_NONE);
   uiItemR(col, imfptr, "validate_meshes", 0, NULL, ICON_NONE);
+  uiItemR(col, imfptr, "always_add_cache_reader", 0, NULL, ICON_NONE);
 }
 
 static void wm_alembic_import_draw(bContext *UNUSED(C), wmOperator *op)
@@ -645,6 +646,7 @@ static int wm_alembic_import_exec(bContext *C, wmOperator *op)
   const bool is_sequence = RNA_boolean_get(op->ptr, "is_sequence");
   const bool set_frame_range = RNA_boolean_get(op->ptr, "set_frame_range");
   const bool validate_meshes = RNA_boolean_get(op->ptr, "validate_meshes");
+  const bool always_add_cache_reader = RNA_boolean_get(op->ptr, "always_add_cache_reader");
   const bool as_background_job = RNA_boolean_get(op->ptr, "as_background_job");
 
   int offset = 0;
@@ -672,6 +674,7 @@ static int wm_alembic_import_exec(bContext *C, wmOperator *op)
                        sequence_len,
                        offset,
                        validate_meshes,
+                       always_add_cache_reader,
                        as_background_job);
 
   return as_background_job || ok ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
@@ -722,6 +725,13 @@ void WM_OT_alembic_import(wmOperatorType *ot)
                   "Check imported mesh objects for invalid data (slow)");
 
   RNA_def_boolean(ot->srna,
+                  "always_add_cache_reader",
+                  false,
+                  "Always Add Cache Reader",
+                  "Add cache modifiers and constraints to imported objects even if they are not "
+                  "animated so that they can be updated when reloading the Alembic archive");
+
+  RNA_def_boolean(ot->srna,
                   "is_sequence",
                   false,
                   "Is Sequence",
diff --git a/source/blender/editors/mesh/editmesh_knife_project.c b/source/blender/editors/mesh/editmesh_knife_project.c
index 16661897e87..669a09b3fd3 100644
--- a/source/blender/editors/mesh/editmesh_knife_project.c
+++ b/source/blender/editors/mesh/editmesh_knife_project.c
@@ -33,6 +33,7 @@
 #include "BKE_customdata.h"
 #include "BKE_editmesh.h"
 #include "BKE_layer.h"
+#include "BKE_lib_id.h"
 #include "BKE_mesh.h"
 #include "BKE_mesh_runtime.h"
 #include "BKE_object.h"
@@ -115,7 +116,7 @@ static LinkNode *knifeproject_poly_from_object(const bContext *C,
     BKE_nurbList_free(&nurbslist);
 
     if (me_eval_needs_free) {
-      BKE_mesh_free((struct Mesh *)me_eval);
+      BKE_id_free(NULL, (ID *)me_eval);
     }
   }
 
diff --git a/source/blender/editors/mesh/editmesh_undo.c b/source/blender/editors/mesh/editmesh_undo.c
index fc9e1aa8b1a..f52cd94b8dc 100644
--- a/source/blender/editors/mesh/editmesh_undo.c
+++ b/source/blender/editors/mesh/editmesh_undo.c
@@ -755,11 +755,11 @@ static void undomesh_free_data(UndoMesh *um)
 #endif
 
   if (me->key) {
-    BKE_key_free(me->key);
+    BKE_key_free_data(me->key);
     MEM_freeN(me->key);
   }
 
-  BKE_mesh_free(me);
+  BKE_mesh_free_data_for_undo(me);
 }
 
 static Object *editmesh_object_from_context(bContext *C)
diff --git a/source/blender/editors/render/render_update.c b/source/blender/editors/render/render_update.c
index fb9d11feb63..6db148eb4e1 100644
--- a/source/blender/editors/render/render_update.c
+++ b/source/blender/editors/render/render_update.c
@@ -23,6 +23,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include "DNA_cachefile_types.h"
 #include "DNA_light_types.h"
 #include "DNA_material_types.h"
 #include "DNA_node_types.h"
@@ -204,6 +205,19 @@ void ED_render_engine_changed(Main *bmain, const bool update_scene_data)
       ntreeCompositUpdateRLayers(scene->nodetree);
     }
   }
+
+  /* Update CacheFiles to ensure that procedurals are properly taken into account. */
+  LISTBASE_FOREACH (CacheFile *, cachefile, &bmain->cachefiles) {
+    /* Only update cachefiles which are set to use a render procedural. We do not use
+     * BKE_cachefile_uses_render_procedural here as we need to update regardless of the current
+     * engine or its settings. */
+    if (cachefile->use_render_procedural) {
+      DEG_id_tag_update(&cachefile->id, ID_RECALC_COPY_ON_WRITE);
+      /* Rebuild relations so that modifiers are reconnected to or disconnected from the cachefile.
+       */
+      DEG_relations_tag_update(bmain);
+    }
+  }
 }
 
 void ED_render_view_layer_changed(Main *bmain, bScreen *screen)
diff --git a/source/blender/editors/screen/screen_edit.c b/source/blender/editors/screen/screen_edit.c
index 506b5a9859d..1c068fdd6e4 100644
--- a/source/blender/editors/screen/screen_edit.c
+++ b/source/blender/editors/screen/screen_edit.c
@@ -230,7 +230,7 @@ bScreen *screen_add(Main *bmain, const char *name, const rcti *rect)
 void screen_data_copy(bScreen *to, bScreen *from)
 {
   /* free contents of 'to', is from blenkernel screen.c */
-  BKE_screen_free(to);
+  BKE_screen_free_data(to);
 
   to->flag = from->flag;
 
diff --git a/source/blender/editors/space_action/action_draw.c b/source/blender/editors/space_action/action_draw.c
index 903754f4fb1..a3bdcd2adf5 100644
--- a/source/blender/editors/space_action/action_draw.c
+++ b/source/blender/editors/space_action/action_draw.c
@@ -144,12 +144,14 @@ void draw_channel_strips(bAnimContext *ac, SpaceAction *saction, ARegion *region
   uchar col1[4], col2[4];
   uchar col1a[4], col2a[4];
   uchar col1b[4], col2b[4];
+  uchar col_summary[4];
 
   const bool show_group_colors = U.animation_flag & USER_ANIM_SHOW_CHANNEL_GROUP_COLORS;
 
   /* get theme colors */
   UI_GetThemeColor4ubv(TH_SHADE2, col2);
   UI_GetThemeColor4ubv(TH_HILITE, col1);
+  UI_GetThemeColor4ubv(TH_ANIM_ACTIVE, col_summary);
 
   UI_GetThemeColor4ubv(TH_GROUP, col2a);
   UI_GetThemeColor4ubv(TH_GROUP_ACTIVE, col1a);
@@ -244,7 +246,10 @@ void draw_channel_strips(bAnimContext *ac, SpaceAction *saction, ARegion *region
         else if (ac->datatype == ANIMCONT_GPENCIL) {
           uchar *color;
           uchar gpl_col[4];
-          if ((show_group_colors) && (ale->type == ANIMTYPE_GPLAYER)) {
+          if (ale->type == ANIMTYPE_SUMMARY) {
+            color = col_summary;
+          }
+          else if ((show_group_colors) && (ale->type == ANIMTYPE_GPLAYER)) {
             bGPDlayer *gpl = (bGPDlayer *)ale->data;
             rgb_float_to_uchar(gpl_col, gpl->color);
             gpl_col[3] = col1[3];
@@ -265,7 +270,13 @@ void draw_channel_strips(bAnimContext *ac, SpaceAction *saction, ARegion *region
         else if (ac->datatype == ANIMCONT_MASK) {
           /* TODO: this is a copy of gpencil. */
           /* frames less than one get less saturated background */
-          uchar *color = sel ? col1 : col2;
+          uchar *color;
+          if (ale->type == ANIMTYPE_SUMMARY) {
+            color = col_summary;
+          }
+          else {
+            color = sel ? col1 : col2;
+          }
           immUniformColor4ubv(color);
           immRectf(pos, 0.0f, ymin, v2d->cur.xmin, ymax);
 
diff --git a/source/blender/editors/space_file/filesel.c b/source/blender/editors/space_file/filesel.c
index 72e7e0716db..4ab7014cf82 100644
--- a/source/blender/editors/space_file/filesel.c
+++ b/source/blender/editors/space_file/filesel.c
@@ -863,20 +863,8 @@ FileAttributeColumnType file_attribute_column_type_find_isect(const View2D *v2d,
 float file_string_width(const char *str)
 {
   const uiStyle *style = UI_style_get();
-  float width;
-
   UI_fontstyle_set(&style->widget);
-  if (style->widget.kerning == 1) { /* for BLF_width */
-    BLF_enable(style->widget.uifont_id, BLF_KERNING_DEFAULT);
-  }
-
-  width = BLF_width(style->widget.uifont_id, str, BLF_DRAW_STR_DUMMY_MAX);
-
-  if (style->widget.kerning == 1) {
-    BLF_disable(style->widget.uifont_id, BLF_KERNING_DEFAULT);
-  }
-
-  return width;
+  return BLF_width(style->widget.uifont_id, str, BLF_DRAW_STR_DUMMY_MAX);
 }
 
 float file_font_pointsize(void)
diff --git a/source/blender/editors/space_sequencer/space_sequencer.c b/source/blender/editors/space_sequencer/space_sequencer.c
index 00f3bf6ac72..2a6e49edfb6 100644
--- a/source/blender/editors/space_sequencer/space_sequencer.c
+++ b/source/blender/editors/space_sequencer/space_sequencer.c
@@ -194,7 +194,7 @@ static void sequencer_free(SpaceLink *sl)
   SpaceSeq *sseq = (SpaceSeq *)sl;
   SequencerScopes *scopes = &sseq->scopes;
 
-  /* XXX  if (sseq->gpd) BKE_gpencil_free(sseq->gpd); */
+  /* XXX  if (sseq->gpd) BKE_gpencil_free_data(sseq->gpd); */
 
   if (scopes->zebra_ibuf) {
     IMB_freeImBuf(scopes->zebra_ibuf);
diff --git a/source/blender/editors/space_view3d/view3d_select.c b/source/blender/editors/space_view3d/view3d_select.c
index 2ce5684e874..e3f97dd1c63 100644
--- a/source/blender/editors/space_view3d/view3d_select.c
+++ b/source/blender/editors/space_view3d/view3d_select.c
@@ -2521,6 +2521,7 @@ static bool ed_object_select_pick(bContext *C,
     }
     /* also prevent making it active on mouse selection */
     else if (BASE_SELECTABLE(v3d, basact)) {
+      const bool use_activate_selected_base = (oldbasact != basact) && (is_obedit == false);
       if (extend) {
         ED_object_base_select(basact, BA_SELECT);
       }
@@ -2529,7 +2530,8 @@ static bool ed_object_select_pick(bContext *C,
       }
       else if (toggle) {
         if (basact->flag & BASE_SELECTED) {
-          if (basact == oldbasact) {
+          /* Keep selected if the base is to be activated. */
+          if (use_activate_selected_base == false) {
             ED_object_base_select(basact, BA_DESELECT);
           }
         }
@@ -2545,7 +2547,7 @@ static bool ed_object_select_pick(bContext *C,
         }
       }
 
-      if ((oldbasact != basact) && (is_obedit == false)) {
+      if (use_activate_selected_base) {
         ED_object_base_activate(C, basact); /* adds notifier */
         if ((scene->toolsettings->object_flag & SCE_OBJECT_MODE_LOCK) == 0) {
           WM_toolsystem_update_from_context_view3d(C);
diff --git a/source/blender/editors/transform/CMakeLists.txt b/source/blender/editors/transform/CMakeLists.txt
index ad0a330f0f4..e9efed3cd61 100644
--- a/source/blender/editors/transform/CMakeLists.txt
+++ b/source/blender/editors/transform/CMakeLists.txt
@@ -101,6 +101,7 @@ set(SRC
   transform_ops.c
   transform_orientations.c
   transform_snap.c
+  transform_snap_animation.c
   transform_snap_object.c
   transform_snap_sequencer.c
 
diff --git a/source/blender/editors/transform/transform_convert.c b/source/blender/editors/transform/transform_convert.c
index 3f730956dd0..094ae080de0 100644
--- a/source/blender/editors/transform/transform_convert.c
+++ b/source/blender/editors/transform/transform_convert.c
@@ -1662,6 +1662,23 @@ void animrecord_check_state(TransInfo *t, struct Object *ob)
   }
 }
 
+void transform_convert_flush_handle2D(TransData *td, TransData2D *td2d, const float inv_unit_scale)
+{
+  /* If the handles are to be moved too
+   * (as side-effect of keyframes moving, to keep the general effect)
+   * offset them by the same amount so that the general angles are maintained
+   * (i.e. won't change while handles are free-to-roam and keyframes are snap-locked).
+   */
+  if ((td->flag & TD_MOVEHANDLE1) && td2d->h1) {
+    td2d->h1[0] = td2d->ih1[0] + td->loc[0] - td->iloc[0];
+    td2d->h1[1] = td2d->ih1[1] + (td->loc[1] - td->iloc[1]) * inv_unit_scale;
+  }
+  if ((td->flag & TD_MOVEHANDLE2) && td2d->h2) {
+    td2d->h2[0] = td2d->ih2[0] + td->loc[0] - td->iloc[0];
+    td2d->h2[1] = td2d->ih2[1] + (td->loc[1] - td->iloc[1]) * inv_unit_scale;
+  }
+}
+
 /* called for updating while transform acts, once per redraw */
 void recalcData(TransInfo *t)
 {
diff --git a/source/blender/editors/transform/transform_convert.h b/source/blender/editors/transform/transform_convert.h
index 55731bfa321..fa34e2555d6 100644
--- a/source/blender/editors/transform/transform_convert.h
+++ b/source/blender/editors/transform/transform_convert.h
@@ -43,6 +43,9 @@ void sort_trans_data_dist(TransInfo *t);
 void createTransData(struct bContext *C, TransInfo *t);
 bool clipUVTransform(TransInfo *t, float vec[2], const bool resize);
 void clipUVData(TransInfo *t);
+void transform_convert_flush_handle2D(TransData *td,
+                                      TransData2D *td2d,
+                                      const float inv_unit_scale);
 void recalcData(TransInfo *t);
 
 /* transform_convert_mesh.c */
diff --git a/source/blender/editors/transform/transform_convert_action.c b/source/blender/editors/transform/transform_convert_action.c
index cfa14e21d0d..8a3b254be5c 100644
--- a/source/blender/editors/transform/transform_convert_action.c
+++ b/source/blender/editors/transform/transform_convert_action.c
@@ -45,6 +45,8 @@
 #include "WM_types.h"
 
 #include "transform.h"
+#include "transform_snap.h"
+
 #include "transform_convert.h"
 
 /* helper struct for gp-frame transforms */
@@ -140,19 +142,37 @@ static int count_masklayer_frames(MaskLayer *masklay, char side, float cfra, boo
 }
 
 /* This function assigns the information to transdata */
-static void TimeToTransData(TransData *td, float *time, AnimData *adt, float ypos)
+static void TimeToTransData(
+    TransData *td, TransData2D *td2d, BezTriple *bezt, AnimData *adt, float ypos)
 {
-  /* memory is calloc'ed, so that should zero everything nicely for us */
+  float *time = bezt->vec[1];
+
+  /* Setup #TransData2D. */
+  td2d->loc[0] = *time;
+  td2d->loc2d = time;
+  td2d->h1 = bezt->vec[0];
+  td2d->h2 = bezt->vec[2];
+  copy_v2_v2(td2d->ih1, td2d->h1);
+  copy_v2_v2(td2d->ih2, td2d->h2);
+
+  /* Setup #TransData. */
+  td->loc = time; /* Usually #td2d->loc is used here. But this is for when the original location is
+                     not float[3]. */
   td->val = time;
-  td->ival = *(time);
-
+  td->ival = td->iloc[0] = *(time);
   td->center[0] = td->ival;
   td->center[1] = ypos;
 
-  /* store the AnimData where this keyframe exists as a keyframe of the
-   * active action as td->extra.
-   */
+  /* Store the AnimData where this keyframe exists as a keyframe of the
+   * active action as #td->extra. */
   td->extra = adt;
+
+  if (bezt->f2 & SELECT) {
+    td->flag |= TD_SELECTED;
+  }
+
+  /* Set flags to move handles as necessary. */
+  td->flag |= TD_MOVEHANDLE1 | TD_MOVEHANDLE2;
 }
 
 /* This function advances the address to which td points to, so it must return
@@ -185,19 +205,7 @@ static TransData *ActionFCurveToTransData(TransData *td,
                                                 * so can't use BEZT_ISSEL_ANY() macro */
       /* only add if on the right 'side' of the current frame */
       if (FrameOnMouseSide(side, bezt->vec[1][0], cfra)) {
-        TimeToTransData(td, bezt->vec[1], adt, ypos);
-
-        if (bezt->f2 & SELECT) {
-          td->flag |= TD_SELECTED;
-        }
-
-        /* Set flags to move handles as necessary. */
-        td->flag |= TD_MOVEHANDLE1 | TD_MOVEHANDLE2;
-        td2d->h1 = bezt->vec[0];
-        td2d->h2 = bezt->vec[2];
-
-        copy_v2_v2(td2d->ih1, td2d->h1);
-        copy_v2_v2(td2d->ih2, td2d->h2);
+        TimeToTransData(td, td2d, bezt, adt, ypos);
 
         td++;
         td2d++;
@@ -598,6 +606,19 @@ void recalcData_actedit(TransInfo *t)
     flushTransIntFrameActionData(t);
   }
 
+  /* Flush 2d vector. */
+  TransDataContainer *tc = TRANS_DATA_CONTAINER_FIRST_SINGLE(t);
+  const short autosnap = getAnimEdit_SnapMode(t);
+  TransData *td;
+  TransData2D *td2d;
+  int i = 0;
+  for (td = tc->data, td2d = tc->data_2d; i < tc->data_len; i++, td++, td2d++) {
+    if ((autosnap != SACTSNAP_OFF) && (t->state != TRANS_CANCEL) && !(td->flag & TD_NOTIMESNAP)) {
+      transform_snap_anim_flush_data(t, td, autosnap, td->loc);
+    }
+    transform_convert_flush_handle2D(td, td2d, 1.0f);
+  }
+
   if (ac.datatype != ANIMCONT_MASK) {
     /* Get animdata blocks visible in editor,
      * assuming that these will be the ones where things changed. */
diff --git a/source/blender/editors/transform/transform_convert_graph.c b/source/blender/editors/transform/transform_convert_graph.c
index a6cbbb299ac..d22277f9d91 100644
--- a/source/blender/editors/transform/transform_convert_graph.c
+++ b/source/blender/editors/transform/transform_convert_graph.c
@@ -40,7 +40,11 @@
 #include "UI_view2d.h"
 
 #include "transform.h"
+#include "transform_snap.h"
+
 #include "transform_convert.h"
+#include "transform_snap.h"
+
 #include "transform_mode.h"
 
 typedef struct TransDataGraph {
@@ -660,10 +664,9 @@ static void flushTransGraphData(TransInfo *t)
   TransData *td;
   TransData2D *td2d;
   TransDataGraph *tdg;
-  Scene *scene = t->scene;
-  double secf = FPS;
   int a;
 
+  const short autosnap = getAnimEdit_SnapMode(t);
   TransDataContainer *tc = TRANS_DATA_CONTAINER_FIRST_SINGLE(t);
 
   /* flush to 2d vector from internally used 3d vector */
@@ -679,22 +682,8 @@ static void flushTransGraphData(TransInfo *t)
      * - Only apply to keyframes (but never to handles).
      * - Don't do this when canceling, or else these changes won't go away.
      */
-    if ((t->state != TRANS_CANCEL) && (td->flag & TD_NOTIMESNAP) == 0) {
-      const short autosnap = getAnimEdit_SnapMode(t);
-      switch (autosnap) {
-        case SACTSNAP_FRAME: /* snap to nearest frame */
-          td2d->loc[0] = floor((double)td2d->loc[0] + 0.5);
-          break;
-
-        case SACTSNAP_SECOND: /* snap to nearest second */
-          td2d->loc[0] = floor(((double)td2d->loc[0] / secf) + 0.5) * secf;
-          break;
-
-        case SACTSNAP_MARKER: /* snap to nearest marker */
-          td2d->loc[0] = (float)ED_markers_find_nearest_marker_time(&t->scene->markers,
-                                                                    td2d->loc[0]);
-          break;
-      }
+    if ((autosnap != SACTSNAP_OFF) && (t->state != TRANS_CANCEL) && !(td->flag & TD_NOTIMESNAP)) {
+      transform_snap_anim_flush_data(t, td, autosnap, td->loc);
     }
 
     /* we need to unapply the nla-mapping from the time in some situations */
@@ -705,32 +694,6 @@ static void flushTransGraphData(TransInfo *t)
       td2d->loc2d[0] = td2d->loc[0];
     }
 
-    /** Time-stepping auto-snapping modes don't get applied for Graph Editor transforms,
-     * as these use the generic transform modes which don't account for this sort of thing.
-     * These ones aren't affected by NLA mapping, so we do this after the conversion...
-     *
-     * \note We also have to apply to td->loc,
-     * as that's what the handle-adjustment step below looks to,
-     * otherwise we get "swimming handles".
-     *
-     * \note We don't do this when canceling transforms, or else these changes don't go away.
-     */
-    if ((t->state != TRANS_CANCEL) && (td->flag & TD_NOTIMESNAP) == 0) {
-      const short autosnap = getAnimEdit_SnapMode(t);
-      switch (autosnap) {
-        case SACTSNAP_STEP: /* frame step */
-          td2d->loc2d[0] = floor((double)td2d->loc[0] + 0.5);
-          td->loc[0] = floor((double)td->loc[0] + 0.5);
-          break;
-
-        case SACTSNAP_TSTEP: /* second step */
-          /* XXX: the handle behavior in this case is still not quite right... */
-          td2d->loc[0] = floor(((double)td2d->loc[0] / secf) + 0.5) * secf;
-          td->loc[0] = floor(((double)td->loc[0] / secf) + 0.5) * secf;
-          break;
-      }
-    }
-
     /* if int-values only, truncate to integers */
     if (td->flag & TD_INTVALUES) {
       td2d->loc2d[1] = floorf(td2d->loc[1] * inv_unit_scale - tdg->offset + 0.5f);
@@ -739,15 +702,7 @@ static void flushTransGraphData(TransInfo *t)
       td2d->loc2d[1] = td2d->loc[1] * inv_unit_scale - tdg->offset;
     }
 
-    if ((td->flag & TD_MOVEHANDLE1) && td2d->h1) {
-      td2d->h1[0] = td2d->ih1[0] + td->loc[0] - td->iloc[0];
-      td2d->h1[1] = td2d->ih1[1] + (td->loc[1] - td->iloc[1]) * inv_unit_scale;
-    }
-
-    if ((td->flag & TD_MOVEHANDLE2) && td2d->h2) {
-      td2d->h2[0] = td2d->ih2[0] + td->loc[0] - td->iloc[0];
-      td2d->h2[1] = td2d->ih2[1] + (td->loc[1] - td->iloc[1]) * inv_unit_scale;
-    }
+    transform_convert_flush_handle2D(td, td2d, inv_unit_scale);
   }
 }
 
diff --git a/source/blender/editors/transform/transform_convert_nla.c b/source/blender/editors/transform/transform_convert_nla.c
index f96f2e93bbc..7e5b80c2453 100644
--- a/source/blender/editors/transform/transform_convert_nla.c
+++ b/source/blender/editors/transform/transform_convert_nla.c
@@ -41,7 +41,11 @@
 #include "RNA_access.h"
 
 #include "transform.h"
+#include "transform_snap.h"
+
 #include "transform_convert.h"
+#include "transform_snap.h"
+
 #include "transform_mode.h"
 
 /** Used for NLA transform (stored in #TransData.extra pointer). */
@@ -290,21 +294,30 @@ void createTransNlaData(bContext *C, TransInfo *t)
 void recalcData_nla(TransInfo *t)
 {
   SpaceNla *snla = (SpaceNla *)t->area->spacedata.first;
-  Scene *scene = t->scene;
-  double secf = FPS;
-  int i;
 
   TransDataContainer *tc = TRANS_DATA_CONTAINER_FIRST_SINGLE(t);
-  TransDataNla *tdn = tc->custom.type.data;
+
+  /* handle auto-snapping
+   * NOTE: only do this when transform is still running, or we can't restore
+   */
+  if (t->state != TRANS_CANCEL) {
+    const short autosnap = getAnimEdit_SnapMode(t);
+    if (autosnap != SACTSNAP_OFF) {
+      TransData *td = tc->data;
+      for (int i = 0; i < tc->data_len; i++, td++) {
+        transform_snap_anim_flush_data(t, td, autosnap, td->loc);
+      }
+    }
+  }
 
   /* For each strip we've got, perform some additional validation of the values
    * that got set before using RNA to set the value (which does some special
    * operations when setting these values to make sure that everything works ok).
    */
-  for (i = 0; i < tc->data_len; i++, tdn++) {
+  TransDataNla *tdn = tc->custom.type.data;
+  for (int i = 0; i < tc->data_len; i++, tdn++) {
     NlaStrip *strip = tdn->strip;
     PointerRNA strip_ptr;
-    short iter;
     int delta_y1, delta_y2;
 
     /* if this tdn has no handles, that means it is just a dummy that should be skipped */
@@ -368,8 +381,7 @@ void recalcData_nla(TransInfo *t)
       next = next->next;
     }
 
-    for (iter = 0; iter < 5; iter++) {
-
+    for (short iter = 0; iter < 5; iter++) {
       const bool pExceeded = (prev != NULL) && (tdn->h1[0] < prev->end);
       const bool nExceeded = (next != NULL) && (tdn->h2[0] > next->start);
 
@@ -408,51 +420,6 @@ void recalcData_nla(TransInfo *t)
       }
     }
 
-    /* handle auto-snapping
-     * NOTE: only do this when transform is still running, or we can't restore
-     */
-    if (t->state != TRANS_CANCEL) {
-      const short autosnap = getAnimEdit_SnapMode(t);
-      switch (autosnap) {
-        case SACTSNAP_FRAME: /* snap to nearest frame */
-        case SACTSNAP_STEP:  /* frame step - this is basically the same,
-                              * since we don't have any remapping going on */
-        {
-          tdn->h1[0] = floorf(tdn->h1[0] + 0.5f);
-          tdn->h2[0] = floorf(tdn->h2[0] + 0.5f);
-          break;
-        }
-
-        case SACTSNAP_SECOND: /* snap to nearest second */
-        case SACTSNAP_TSTEP:  /* second step - this is basically the same,
-                               * since we don't have any remapping going on */
-        {
-          /* This case behaves differently from the rest, since lengths of strips
-           * may not be multiples of a second. If we just naively resize adjust
-           * the handles, things may not work correctly. Instead, we only snap
-           * the first handle, and move the other to fit.
-           *
-           * FIXME: we do run into problems here when user attempts to negatively
-           *        scale the strip, as it then just compresses down and refuses
-           *        to expand out the other end.
-           */
-          float h1_new = (float)(floor(((double)tdn->h1[0] / secf) + 0.5) * secf);
-          float delta = h1_new - tdn->h1[0];
-
-          tdn->h1[0] = h1_new;
-          tdn->h2[0] += delta;
-          break;
-        }
-
-        case SACTSNAP_MARKER: /* snap to nearest marker */
-        {
-          tdn->h1[0] = (float)ED_markers_find_nearest_marker_time(&t->scene->markers, tdn->h1[0]);
-          tdn->h2[0] = (float)ED_markers_find_nearest_marker_time(&t->scene->markers, tdn->h2[0]);
-          break;
-        }
-      }
-    }
-
     /* Use RNA to write the values to ensure that constraints on these are obeyed
      * (e.g. for transition strips, the values are taken from the neighbors)
      *
diff --git a/source/blender/editors/transform/transform_mode.c b/source/blender/editors/transform/transform_mode.c
index 362ee179e7d..8df95222fa1 100644
--- a/source/blender/editors/transform/transform_mode.c
+++ b/source/blender/editors/transform/transform_mode.c
@@ -1068,102 +1068,6 @@ void ElementResize(const TransInfo *t,
 /** \} */
 
 /* -------------------------------------------------------------------- */
-/** \name Transform (Frame Utils)
- * \{ */
-
-/**
- * This function returns the snapping 'mode' for Animation Editors only.
- * We cannot use the standard snapping due to NLA-strip scaling complexities.
- *
- * TODO: these modifier checks should be key-mappable.
- */
-short getAnimEdit_SnapMode(TransInfo *t)
-{
-  short autosnap = SACTSNAP_OFF;
-
-  if (t->spacetype == SPACE_ACTION) {
-    SpaceAction *saction = (SpaceAction *)t->area->spacedata.first;
-
-    if (saction) {
-      autosnap = saction->autosnap;
-    }
-  }
-  else if (t->spacetype == SPACE_GRAPH) {
-    SpaceGraph *sipo = (SpaceGraph *)t->area->spacedata.first;
-
-    if (sipo) {
-      autosnap = sipo->autosnap;
-    }
-  }
-  else if (t->spacetype == SPACE_NLA) {
-    SpaceNla *snla = (SpaceNla *)t->area->spacedata.first;
-
-    if (snla) {
-      autosnap = snla->autosnap;
-    }
-  }
-  else {
-    autosnap = SACTSNAP_OFF;
-  }
-
-  /* toggle autosnap on/off
-   * - when toggling on, prefer nearest frame over 1.0 frame increments
-   */
-  if (t->modifiers & MOD_SNAP_INVERT) {
-    if (autosnap) {
-      autosnap = SACTSNAP_OFF;
-    }
-    else {
-      autosnap = SACTSNAP_FRAME;
-    }
-  }
-
-  return autosnap;
-}
-
-/* This function is used by Animation Editor specific transform functions to do
- * the Snap Keyframe to Nearest Frame/Marker
- */
-void doAnimEdit_SnapFrame(
-    TransInfo *t, TransData *td, TransData2D *td2d, AnimData *adt, short autosnap)
-{
-  if (autosnap != SACTSNAP_OFF) {
-    float val;
-
-    /* convert frame to nla-action time (if needed) */
-    if (adt && (t->spacetype != SPACE_SEQ)) {
-      val = BKE_nla_tweakedit_remap(adt, *(td->val), NLATIME_CONVERT_MAP);
-    }
-    else {
-      val = *(td->val);
-    }
-
-    snapFrameTransform(t, autosnap, true, val, &val);
-
-    /* convert frame out of nla-action time */
-    if (adt && (t->spacetype != SPACE_SEQ)) {
-      *(td->val) = BKE_nla_tweakedit_remap(adt, val, NLATIME_CONVERT_UNMAP);
-    }
-    else {
-      *(td->val) = val;
-    }
-  }
-
-  /* If the handles are to be moved too
-   * (as side-effect of keyframes moving, to keep the general effect)
-   * offset them by the same amount so that the general angles are maintained
-   * (i.e. won't change while handles are free-to-roam and keyframes are snap-locked).
-   */
-  if ((td->flag & TD_MOVEHANDLE1) && td2d->h1) {
-    td2d->h1[0] = td2d->ih1[0] + *td->val - td->ival;
-  }
-  if ((td->flag & TD_MOVEHANDLE2) && td2d->h2) {
-    td2d->h2[0] = td2d->ih2[0] + *td->val - td->ival;
-  }
-}
-/** \} */
-
-/* -------------------------------------------------------------------- */
 /** \name Transform Mode Initialization
  * \{ */
 
diff --git a/source/blender/editors/transform/transform_mode.h b/source/blender/editors/transform/transform_mode.h
index 027fb6b6982..d8601000ddb 100644
--- a/source/blender/editors/transform/transform_mode.h
+++ b/source/blender/editors/transform/transform_mode.h
@@ -63,9 +63,6 @@ void ElementResize(const TransInfo *t,
                    const TransDataContainer *tc,
                    TransData *td,
                    const float mat[3][3]);
-short getAnimEdit_SnapMode(TransInfo *t);
-void doAnimEdit_SnapFrame(
-    TransInfo *t, TransData *td, TransData2D *td2d, struct AnimData *adt, short autosnap);
 void transform_mode_init(TransInfo *t, struct wmOperator *op, const int mode);
 void transform_mode_default_modal_orientation_set(TransInfo *t, int type);
 
diff --git a/source/blender/editors/transform/transform_mode_timescale.c b/source/blender/editors/transform/transform_mode_timescale.c
index 98ffc0abbd4..50fd714727b 100644
--- a/source/blender/editors/transform/transform_mode_timescale.c
+++ b/source/blender/editors/transform/transform_mode_timescale.c
@@ -40,6 +40,8 @@
 
 #include "transform.h"
 #include "transform_convert.h"
+#include "transform_snap.h"
+
 #include "transform_mode.h"
 
 /* -------------------------------------------------------------------- */
@@ -63,7 +65,6 @@ static void headerTimeScale(TransInfo *t, char str[UI_MAX_DRAW_STR])
 static void applyTimeScaleValue(TransInfo *t, float value)
 {
   Scene *scene = t->scene;
-  const short autosnap = getAnimEdit_SnapMode(t);
 
   FOREACH_TRANS_DATA_CONTAINER (t, tc) {
     TransData *td = tc->data;
@@ -87,9 +88,6 @@ static void applyTimeScaleValue(TransInfo *t, float value)
 
       /* now, calculate the new value */
       *(td->val) = ((td->ival - startx) * fac) + startx;
-
-      /* apply nearest snapping */
-      doAnimEdit_SnapFrame(t, td, td2d, adt, autosnap);
     }
   }
 }
diff --git a/source/blender/editors/transform/transform_mode_timetranslate.c b/source/blender/editors/transform/transform_mode_timetranslate.c
index 01b9a08cf27..294040946bd 100644
--- a/source/blender/editors/transform/transform_mode_timetranslate.c
+++ b/source/blender/editors/transform/transform_mode_timetranslate.c
@@ -59,10 +59,18 @@ static void headerTimeTranslate(TransInfo *t, char str[UI_MAX_DRAW_STR])
   }
   else {
     const short autosnap = getAnimEdit_SnapMode(t);
-    float val = t->values_final[0];
+    float ival = TRANS_DATA_CONTAINER_FIRST_OK(t)->data->ival;
+    float val = ival + t->values_final[0];
 
-    float snap_val;
-    snapFrameTransform(t, autosnap, false, val, &snap_val);
+    float snap_val = val;
+    snapFrameTransform(t, autosnap, ival, val, &snap_val);
+
+    if (ELEM(autosnap, SACTSNAP_SECOND, SACTSNAP_TSTEP)) {
+      /* Convert to seconds. */
+      const Scene *scene = t->scene;
+      const double secf = FPS;
+      snap_val /= secf;
+    }
 
     if (autosnap == SACTSNAP_FRAME) {
       BLI_snprintf(&tvec[0], NUM_STR_REP_LEN, "%.2f (%.4f)", snap_val, val);
@@ -88,24 +96,11 @@ static void headerTimeTranslate(TransInfo *t, char str[UI_MAX_DRAW_STR])
 
 static void applyTimeTranslateValue(TransInfo *t, const float deltax)
 {
-  const short autosnap = getAnimEdit_SnapMode(t);
-
   FOREACH_TRANS_DATA_CONTAINER (t, tc) {
+    /* It doesn't matter whether we apply to t->data. */
     TransData *td = tc->data;
-    TransData2D *td2d = tc->data_2d;
-    /* It doesn't matter whether we apply to t->data or
-     * t->data2d, but t->data2d is more convenient. */
-    for (int i = 0; i < tc->data_len; i++, td++, td2d++) {
-      /* It is assumed that td->extra is a pointer to the AnimData,
-       * whose active action is where this keyframe comes from.
-       * (this is only valid when not in NLA)
-       * (also: masks and gpencil don't have animadata)
-       */
-      AnimData *adt = (t->spacetype != SPACE_NLA) ? td->extra : NULL;
-
-      /* apply nearest snapping */
-      *(td->val) = td->ival + deltax * td->factor;
-      doAnimEdit_SnapFrame(t, td, td2d, adt, autosnap);
+    for (int i = 0; i < tc->data_len; i++, td++) {
+      *(td->val) = td->loc[0] = td->ival + deltax * td->factor;
     }
   }
 }
diff --git a/source/blender/editors/transform/transform_mode_translate.c b/source/blender/editors/transform/transform_mode_translate.c
index 75744f26c15..e44e346d3e4 100644
--- a/source/blender/editors/transform/transform_mode_translate.c
+++ b/source/blender/editors/transform/transform_mode_translate.c
@@ -221,22 +221,30 @@ static void headerTranslation(TransInfo *t, const float vec[3], char str[UI_MAX_
   }
   else {
     float dvec[3];
+    copy_v3_v3(dvec, vec);
+    if (t->spacetype == SPACE_GRAPH) {
+      /* WORKAROUND:
+       * Special case where snapping is done in #recalData.
+       * Update the header based on the first element. */
+      const short autosnap = getAnimEdit_SnapMode(t);
+      float ival = TRANS_DATA_CONTAINER_FIRST_OK(t)->data->ival;
+      float val = ival + dvec[0];
+      snapFrameTransform(t, autosnap, ival, val, &dvec[0]);
+    }
+
     if (t->con.mode & CON_APPLY) {
       int i = 0;
       zero_v3(dvec);
       if (t->con.mode & CON_AXIS0) {
-        dvec[i++] = vec[0];
+        dvec[i++] = dvec[0];
       }
       if (t->con.mode & CON_AXIS1) {
-        dvec[i++] = vec[1];
+        dvec[i++] = dvec[1];
       }
       if (t->con.mode & CON_AXIS2) {
-        dvec[i++] = vec[2];
+        dvec[i++] = dvec[2];
       }
     }
-    else {
-      copy_v3_v3(dvec, vec);
-    }
 
     if (t->flag & T_2D_EDIT) {
       applyAspectRatio(t, dvec);
diff --git a/source/blender/editors/transform/transform_snap.c b/source/blender/editors/transform/transform_snap.c
index 656a1e5d9c7..05a20a14477 100644
--- a/source/blender/editors/transform/transform_snap.c
+++ b/source/blender/editors/transform/transform_snap.c
@@ -594,7 +594,7 @@ static void initSnappingMode(TransInfo *t)
   else if (t->spacetype == SPACE_SEQ) {
     t->tsnap.mode = SEQ_tool_settings_snap_mode_get(t->scene);
   }
-  else {
+  else if (ELEM(t->spacetype, SPACE_VIEW3D, SPACE_IMAGE) && !(t->options & CTX_CAMERA)) {
     /* force project off when not supported */
     if ((ts->snap_mode & SCE_SNAP_MODE_FACE) == 0) {
       t->tsnap.project = 0;
@@ -608,6 +608,14 @@ static void initSnappingMode(TransInfo *t)
       t->tsnap.mode |= SCE_SNAP_MODE_GRID;
     }
   }
+  else if (ELEM(t->spacetype, SPACE_GRAPH, SPACE_ACTION, SPACE_NLA)) {
+    /* No incremental snapping. */
+    t->tsnap.mode = 0;
+  }
+  else {
+    /* Fallback. */
+    t->tsnap.mode = SCE_SNAP_MODE_INCREMENT;
+  }
 
   if (ELEM(t->spacetype, SPACE_VIEW3D, SPACE_IMAGE) && !(t->options & CTX_CAMERA)) {
     /* Only 3D view or UV. */
@@ -654,10 +662,6 @@ static void initSnappingMode(TransInfo *t)
     setSnappingCallback(t);
     t->tsnap.modeSelect = SNAP_NOT_SELECTED;
   }
-  else {
-    /* Fallback. */
-    t->tsnap.mode = SCE_SNAP_MODE_INCREMENT;
-  }
 
   if (t->spacetype == SPACE_VIEW3D) {
     if (t->tsnap.object_context == NULL) {
@@ -1461,47 +1465,9 @@ bool snapNodesTransform(
 /** \} */
 
 /* -------------------------------------------------------------------- */
-/** \name snap Frames
+/** \name snap Grid
  * \{ */
 
-/* This function is used by Animation Editor specific transform functions to do
- * the Snap Keyframe to Nearest Frame/Marker
- */
-void snapFrameTransform(TransInfo *t,
-                        const eAnimEdit_AutoSnap autosnap,
-                        const bool is_frame_value,
-                        const float delta,
-                        float *r_val)
-{
-  double val = delta;
-  switch (autosnap) {
-    case SACTSNAP_STEP:
-    case SACTSNAP_FRAME:
-      val = floor(val + 0.5);
-      break;
-    case SACTSNAP_MARKER:
-      /* snap to nearest marker */
-      /* TODO: need some more careful checks for where data comes from. */
-      val = ED_markers_find_nearest_marker_time(&t->scene->markers, (float)val);
-      break;
-    case SACTSNAP_SECOND:
-    case SACTSNAP_TSTEP: {
-      /* second step */
-      const Scene *scene = t->scene;
-      const double secf = FPS;
-      val = floor((val / secf) + 0.5);
-      if (is_frame_value) {
-        val *= secf;
-      }
-      break;
-    }
-    case SACTSNAP_OFF: {
-      break;
-    }
-  }
-  *r_val = (float)val;
-}
-
 static void snap_grid_apply(
     TransInfo *t, const int max_index, const float grid_dist, const float loc[3], float r_out[3])
 {
diff --git a/source/blender/editors/transform/transform_snap.h b/source/blender/editors/transform/transform_snap.h
index 6dfaeab93e6..ed7f93304bc 100644
--- a/source/blender/editors/transform/transform_snap.h
+++ b/source/blender/editors/transform/transform_snap.h
@@ -45,12 +45,6 @@ bool snapNodesTransform(struct TransInfo *t,
                         float r_loc[2],
                         float *r_dist_px,
                         char *r_node_border);
-void snapFrameTransform(struct TransInfo *t,
-                        const eAnimEdit_AutoSnap autosnap,
-                        const bool is_frame_value,
-                        const float delta,
-                        /* return args */
-                        float *r_val);
 
 bool transformModeUseSnap(const TransInfo *t);
 
@@ -86,3 +80,15 @@ struct TransSeqSnapData *transform_snap_sequencer_data_alloc(const TransInfo *t)
 void transform_snap_sequencer_data_free(struct TransSeqSnapData *data);
 bool transform_snap_sequencer_calc(struct TransInfo *t);
 void transform_snap_sequencer_apply_translate(TransInfo *t, float *vec);
+
+/* transform_snap_animation.c */
+short getAnimEdit_SnapMode(TransInfo *t);
+void snapFrameTransform(TransInfo *t,
+                        const eAnimEdit_AutoSnap autosnap,
+                        const float val_initial,
+                        const float val_final,
+                        float *r_val_final);
+void transform_snap_anim_flush_data(TransInfo *t,
+                                    TransData *td,
+                                    const eAnimEdit_AutoSnap autosnap,
+                                    float *r_val_final);
diff --git a/source/blender/editors/transform/transform_snap_animation.c b/source/blender/editors/transform/transform_snap_animation.c
new file mode 100644
index 00000000000..be7fc65a6c2
--- /dev/null
+++ b/source/blender/editors/transform/transform_snap_animation.c
@@ -0,0 +1,159 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ */
+
+/** \file
+ * \ingroup edtransform
+ */
+
+#include "DNA_anim_types.h"
+
+#include "BLI_math.h"
+
+#include "BKE_context.h"
+#include "BKE_nla.h"
+
+#include "ED_markers.h"
+#include "ED_screen.h"
+
+#include "transform.h"
+#include "transform_snap.h"
+
+/* -------------------------------------------------------------------- */
+/** \name Snappint in Anim Editors
+ * \{ */
+
+/**
+ * This function returns the snapping 'mode' for Animation Editors only.
+ * We cannot use the standard snapping due to NLA-strip scaling complexities.
+ *
+ * TODO: these modifier checks should be key-mappable.
+ */
+short getAnimEdit_SnapMode(TransInfo *t)
+{
+  short autosnap = SACTSNAP_OFF;
+
+  if (t->spacetype == SPACE_ACTION) {
+    SpaceAction *saction = (SpaceAction *)t->area->spacedata.first;
+
+    if (saction) {
+      autosnap = saction->autosnap;
+    }
+  }
+  else if (t->spacetype == SPACE_GRAPH) {
+    SpaceGraph *sipo = (SpaceGraph *)t->area->spacedata.first;
+
+    if (sipo) {
+      autosnap = sipo->autosnap;
+    }
+  }
+  else if (t->spacetype == SPACE_NLA) {
+    SpaceNla *snla = (SpaceNla *)t->area->spacedata.first;
+
+    if (snla) {
+      autosnap = snla->autosnap;
+    }
+  }
+  else {
+    autosnap = SACTSNAP_OFF;
+  }
+
+  /* toggle autosnap on/off
+   * - when toggling on, prefer nearest frame over 1.0 frame increments
+   */
+  if (t->modifiers & MOD_SNAP_INVERT) {
+    if (autosnap) {
+      autosnap = SACTSNAP_OFF;
+    }
+    else {
+      autosnap = SACTSNAP_FRAME;
+    }
+  }
+
+  return autosnap;
+}
+
+void snapFrameTransform(TransInfo *t,
+                        const eAnimEdit_AutoSnap autosnap,
+                        const float val_initial,
+                        const float val_final,
+                        float *r_val_final)
+{
+  float deltax = val_final - val_initial;
+  switch (autosnap) {
+    case SACTSNAP_FRAME:
+      *r_val_final = floorf(val_final + 0.5f);
+      break;
+    case SACTSNAP_MARKER:
+      /* Snap to nearest marker. */
+      /* TODO: need some more careful checks for where data comes from. */
+      *r_val_final = (float)ED_markers_find_nearest_marker_time(&t->scene->markers, val_final);
+      break;
+    case SACTSNAP_SECOND:
+    case SACTSNAP_TSTEP: {
+      const Scene *scene = t->scene;
+      const double secf = FPS;
+      if (autosnap == SACTSNAP_SECOND) {
+        *r_val_final = floorf((val_final / secf) + 0.5) * secf;
+      }
+      else {
+        deltax = (float)(floor((deltax / secf) + 0.5) * secf);
+        *r_val_final = val_initial + deltax;
+      }
+      break;
+    }
+    case SACTSNAP_STEP:
+      deltax = floorf(deltax + 0.5f);
+      *r_val_final = val_initial + deltax;
+      break;
+    case SACTSNAP_OFF:
+      break;
+  }
+}
+
+/* This function is used by Animation Editor specific transform functions to do
+ * the Snap Keyframe to Nearest Frame/Marker
+ */
+void transform_snap_anim_flush_data(TransInfo *t,
+                                    TransData *td,
+                                    const eAnimEdit_AutoSnap autosnap,
+                                    float *r_val_final)
+{
+  BLI_assert(autosnap != SACTSNAP_OFF);
+
+  float val = td->loc[0];
+  float ival = td->iloc[0];
+  AnimData *adt = (!ELEM(t->spacetype, SPACE_NLA, SPACE_SEQ)) ? td->extra : NULL;
+
+  /* Convert frame to nla-action time (if needed) */
+  if (adt) {
+    val = BKE_nla_tweakedit_remap(adt, val, NLATIME_CONVERT_MAP);
+    ival = BKE_nla_tweakedit_remap(adt, ival, NLATIME_CONVERT_MAP);
+  }
+
+  snapFrameTransform(t, autosnap, ival, val, &val);
+
+  /* Convert frame out of nla-action time. */
+  if (adt) {
+    val = BKE_nla_tweakedit_remap(adt, val, NLATIME_CONVERT_UNMAP);
+  }
+
+  *r_val_final = val;
+}
+
+/** \} */
diff --git a/source/blender/functions/FN_generic_vector_array.hh b/source/blender/functions/FN_generic_vector_array.hh
index eeba0c9dba2..179e85671f8 100644
--- a/source/blender/functions/FN_generic_vector_array.hh
+++ b/source/blender/functions/FN_generic_vector_array.hh
@@ -82,6 +82,8 @@ class GVectorArray : NonCopyable, NonMovable {
   void extend(IndexMask mask, const GVVectorArray &values);
   void extend(IndexMask mask, const GVectorArray &values);
 
+  void clear(IndexMask mask);
+
   GMutableSpan operator[](int64_t index);
   GSpan operator[](int64_t index) const;
 
diff --git a/source/blender/functions/FN_multi_function_params.hh b/source/blender/functions/FN_multi_function_params.hh
index e292d11def7..a480287d578 100644
--- a/source/blender/functions/FN_multi_function_params.hh
+++ b/source/blender/functions/FN_multi_function_params.hh
@@ -54,6 +54,11 @@ class MFParamsBuilder {
 
   MFParamsBuilder(const class MultiFunction &fn, int64_t min_array_size);
 
+  template<typename T> void add_readonly_single_input_value(T value, StringRef expected_name = "")
+  {
+    T *value_ptr = &scope_.add_value<T>(std::move(value), __func__);
+    this->add_readonly_single_input(value_ptr, expected_name);
+  }
   template<typename T> void add_readonly_single_input(const T *value, StringRef expected_name = "")
   {
     this->add_readonly_single_input(scope_.construct<GVArray_For_SingleValueRef>(
@@ -83,6 +88,12 @@ class MFParamsBuilder {
     this->add_readonly_vector_input(
         scope_.construct<GVVectorArray_For_GVectorArray>(__func__, vector_array), expected_name);
   }
+  void add_readonly_vector_input(const GSpan single_vector, StringRef expected_name = "")
+  {
+    this->add_readonly_vector_input(
+        scope_.construct<GVVectorArray_For_SingleGSpan>(__func__, single_vector, min_array_size_),
+        expected_name);
+  }
   void add_readonly_vector_input(const GVVectorArray &ref, StringRef expected_name = "")
   {
     this->assert_current_param_type(MFParamType::ForVectorInput(ref.type()), expected_name);
diff --git a/source/blender/functions/intern/generic_vector_array.cc b/source/blender/functions/intern/generic_vector_array.cc
index 9556d24218e..ec95a283919 100644
--- a/source/blender/functions/intern/generic_vector_array.cc
+++ b/source/blender/functions/intern/generic_vector_array.cc
@@ -78,6 +78,15 @@ void GVectorArray::extend(IndexMask mask, const GVectorArray &values)
   this->extend(mask, virtual_values);
 }
 
+void GVectorArray::clear(IndexMask mask)
+{
+  for (const int64_t i : mask) {
+    Item &item = items_[i];
+    type_.destruct_n(item.start, item.length);
+    item.length = 0;
+  }
+}
+
 GMutableSpan GVectorArray::operator[](const int64_t index)
 {
   Item &item = items_[index];
diff --git a/source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c b/source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c
index f02b73e8430..99e3d59a57f 100644
--- a/source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c
+++ b/source/blender/gpencil_modifiers/intern/lineart/lineart_cpu.c
@@ -41,6 +41,7 @@
 #include "BKE_gpencil.h"
 #include "BKE_gpencil_geom.h"
 #include "BKE_gpencil_modifier.h"
+#include "BKE_lib_id.h"
 #include "BKE_material.h"
 #include "BKE_mesh.h"
 #include "BKE_object.h"
@@ -1691,8 +1692,7 @@ static void lineart_geometry_object_load(LineartObjectInfo *obi, LineartRenderBu
   }
 
   if (obi->free_use_mesh) {
-    BKE_mesh_free(obi->original_me);
-    MEM_freeN(obi->original_me);
+    BKE_id_free(NULL, &obi->original_me);
   }
 
   if (rb->remove_doubles) {
diff --git a/source/blender/io/alembic/ABC_alembic.h b/source/blender/io/alembic/ABC_alembic.h
index 0dbebb1e4c4..0a3a43bb21f 100644
--- a/source/blender/io/alembic/ABC_alembic.h
+++ b/source/blender/io/alembic/ABC_alembic.h
@@ -97,6 +97,7 @@ bool ABC_import(struct bContext *C,
                 int sequence_len,
                 int offset,
                 bool validate_meshes,
+                bool always_add_cache_reader,
                 bool as_background_job);
 
 struct CacheArchiveHandle *ABC_create_handle(struct Main *bmain,
diff --git a/source/blender/io/alembic/intern/abc_reader_curves.cc b/source/blender/io/alembic/intern/abc_reader_curves.cc
index 8d6605d6973..27ee35d1b39 100644
--- a/source/blender/io/alembic/intern/abc_reader_curves.cc
+++ b/source/blender/io/alembic/intern/abc_reader_curves.cc
@@ -112,7 +112,7 @@ void AbcCurveReader::readObjectData(Main *bmain, const Alembic::Abc::ISampleSele
 
   read_curve_sample(cu, m_curves_schema, sample_sel);
 
-  if (has_animations(m_curves_schema, m_settings)) {
+  if (m_settings->always_add_cache_reader || has_animations(m_curves_schema, m_settings)) {
     addCacheModifier();
   }
 }
diff --git a/source/blender/io/alembic/intern/abc_reader_mesh.cc b/source/blender/io/alembic/intern/abc_reader_mesh.cc
index c05df7f1ff5..77edd4908bd 100644
--- a/source/blender/io/alembic/intern/abc_reader_mesh.cc
+++ b/source/blender/io/alembic/intern/abc_reader_mesh.cc
@@ -578,7 +578,7 @@ void AbcMeshReader::readObjectData(Main *bmain, const Alembic::Abc::ISampleSelec
 
   readFaceSetsSample(bmain, mesh, sample_sel);
 
-  if (has_animations(m_schema, m_settings)) {
+  if (m_settings->always_add_cache_reader || has_animations(m_schema, m_settings)) {
     addCacheModifier();
   }
 }
@@ -928,7 +928,7 @@ void AbcSubDReader::readObjectData(Main *bmain, const Alembic::Abc::ISampleSelec
     BKE_mesh_validate(mesh, false, false);
   }
 
-  if (has_animations(m_schema, m_settings)) {
+  if (m_settings->always_add_cache_reader || has_animations(m_schema, m_settings)) {
     addCacheModifier();
   }
 }
diff --git a/source/blender/io/alembic/intern/abc_reader_object.cc b/source/blender/io/alembic/intern/abc_reader_object.cc
index d136d8c3e91..9a5ffd04bd1 100644
--- a/source/blender/io/alembic/intern/abc_reader_object.cc
+++ b/source/blender/io/alembic/intern/abc_reader_object.cc
@@ -197,7 +197,7 @@ void AbcObjectReader::setupObjectTransform(const float time)
   BKE_object_apply_mat4(m_object, transform_from_alembic, true, false);
   BKE_object_to_mat4(m_object, m_object->obmat);
 
-  if (!is_constant) {
+  if (!is_constant || m_settings->always_add_cache_reader) {
     bConstraint *con = BKE_constraint_add_for_object(
         m_object, nullptr, CONSTRAINT_TYPE_TRANSFORM_CACHE);
     bTransformCacheConstraint *data = static_cast<bTransformCacheConstraint *>(con->data);
diff --git a/source/blender/io/alembic/intern/abc_reader_object.h b/source/blender/io/alembic/intern/abc_reader_object.h
index dacdcf3f722..89590b26b61 100644
--- a/source/blender/io/alembic/intern/abc_reader_object.h
+++ b/source/blender/io/alembic/intern/abc_reader_object.h
@@ -51,6 +51,7 @@ struct ImportSettings {
   int read_flag;
 
   bool validate_meshes;
+  bool always_add_cache_reader;
 
   CacheFile *cache_file;
 
@@ -65,6 +66,7 @@ struct ImportSettings {
         sequence_offset(0),
         read_flag(0),
         validate_meshes(false),
+        always_add_cache_reader(false),
         cache_file(NULL)
   {
   }
diff --git a/source/blender/io/alembic/intern/abc_reader_points.cc b/source/blender/io/alembic/intern/abc_reader_points.cc
index f7dcba7a0de..3aeacbd14fe 100644
--- a/source/blender/io/alembic/intern/abc_reader_points.cc
+++ b/source/blender/io/alembic/intern/abc_reader_points.cc
@@ -95,7 +95,7 @@ void AbcPointsReader::readObjectData(Main *bmain, const Alembic::Abc::ISampleSel
   m_object = BKE_object_add_only_object(bmain, OB_MESH, m_object_name.c_str());
   m_object->data = mesh;
 
-  if (has_animations(m_schema, m_settings)) {
+  if (m_settings->always_add_cache_reader || has_animations(m_schema, m_settings)) {
     addCacheModifier();
   }
 }
diff --git a/source/blender/io/alembic/intern/alembic_capi.cc b/source/blender/io/alembic/intern/alembic_capi.cc
index b94b75b2216..deb945b767c 100644
--- a/source/blender/io/alembic/intern/alembic_capi.cc
+++ b/source/blender/io/alembic/intern/alembic_capi.cc
@@ -663,6 +663,7 @@ bool ABC_import(bContext *C,
                 int sequence_len,
                 int offset,
                 bool validate_meshes,
+                bool always_add_cache_reader,
                 bool as_background_job)
 {
   /* Using new here since MEM_* functions do not call constructor to properly initialize data. */
@@ -681,6 +682,7 @@ bool ABC_import(bContext *C,
   job->settings.sequence_len = sequence_len;
   job->settings.sequence_offset = offset;
   job->settings.validate_meshes = validate_meshes;
+  job->settings.always_add_cache_reader = always_add_cache_reader;
   job->error_code = ABC_NO_ERROR;
   job->was_cancelled = false;
   job->archive = nullptr;
diff --git a/source/blender/makesdna/DNA_cachefile_types.h b/source/blender/makesdna/DNA_cachefile_types.h
index b38c7827ea5..ae4ade49be1 100644
--- a/source/blender/makesdna/DNA_cachefile_types.h
+++ b/source/blender/makesdna/DNA_cachefile_types.h
@@ -87,14 +87,21 @@ typedef struct CacheFile {
   /** The frame offset to subtract. */
   float frame_offset;
 
+  char _pad[4];
+
   /** Animation flag. */
   short flag;
-  short draw_flag; /* UNUSED */
 
   /* eCacheFileType enum. */
   char type;
 
-  char _pad[2];
+  /** Do not load data from the cache file and display objects in the scene as boxes, Cycles will
+   * load objects directly from the CacheFile. Other render engines which can load Alembic data
+   * directly can take care of rendering it themselves.
+   */
+  char use_render_procedural;
+
+  char _pad1[7];
 
   char velocity_unit;
   /* Name of the velocity property in the archive. */
diff --git a/source/blender/makesdna/DNA_userdef_types.h b/source/blender/makesdna/DNA_userdef_types.h
index 28acf5413b8..27376432092 100644
--- a/source/blender/makesdna/DNA_userdef_types.h
+++ b/source/blender/makesdna/DNA_userdef_types.h
@@ -71,14 +71,13 @@ typedef struct uiFontStyle {
   short uifont_id;
   /** Actual size depends on 'global' dpi. */
   short points;
-  /** Unfitted or default kerning value. */
-  short kerning;
   /** Style hint. */
   short italic, bold;
   /** Value is amount of pixels blur. */
   short shadow;
   /** Shadow offset in pixels. */
   short shadx, shady;
+  char _pad0[2];
   /** Total alpha. */
   float shadowalpha;
   /** 1 value, typically white or black anyway. */
diff --git a/source/blender/makesrna/intern/rna_access_compare_override.c b/source/blender/makesrna/intern/rna_access_compare_override.c
index 3912c873fd0..2c552970c82 100644
--- a/source/blender/makesrna/intern/rna_access_compare_override.c
+++ b/source/blender/makesrna/intern/rna_access_compare_override.c
@@ -1096,6 +1096,7 @@ static void rna_property_override_check_resync(Main *bmain,
                                                PointerRNA *ptr_item_dst,
                                                PointerRNA *ptr_item_src)
 {
+  ID *id_owner = rna_property_override_property_real_id_owner(bmain, ptr_dst, NULL, NULL);
   ID *id_src = rna_property_override_property_real_id_owner(bmain, ptr_item_src, NULL, NULL);
   ID *id_dst = rna_property_override_property_real_id_owner(bmain, ptr_item_dst, NULL, NULL);
 
@@ -1109,9 +1110,18 @@ static void rna_property_override_check_resync(Main *bmain,
        * remapped to its new local override. In that case overrides and linked data
        * are always properly matching. */
       id_src != id_dst &&
-      /* If one of the pointers is NULL and not the other, or if linked reference ID
-       * of `id_src` is not `id_dst`,  we are in a non-matching case. */
-      (ELEM(NULL, id_src, id_dst) || id_src->override_library->reference != id_dst)) {
+      /* If one of the pointers is NULL and not the other, we are in a non-matching case. */
+      (ELEM(NULL, id_src, id_dst) ||
+       /* If `id_dst` is not from same lib as id_src, and linked reference ID of `id_src` is not
+        * `id_dst`, we are in a non-matching case. */
+       (id_dst->lib != id_src->lib && id_src->override_library->reference != id_dst) ||
+       /* If `id_dst` is from same lib as id_src, and is not same as `id_owner`, we are in a
+        * non-matching case.
+        *
+        * NOTE: Here we are testing if `id_owner` is referencing itself, in that case the new
+        * override copy generated by `BKE_lib_override_library_update` will already have its
+        * self-references updated to itself, instead of still pointing to its linked source. */
+       (id_dst->lib == id_src->lib && id_dst != id_owner))) {
     ptr_dst->owner_id->tag |= LIB_TAG_LIB_OVERRIDE_NEED_RESYNC;
     CLOG_INFO(&LOG, 3, "Local override %s detected as needing resync", ptr_dst->owner_id->name);
   }
diff --git a/source/blender/makesrna/intern/rna_cachefile.c b/source/blender/makesrna/intern/rna_cachefile.c
index b93f494072c..cb0a490417d 100644
--- a/source/blender/makesrna/intern/rna_cachefile.c
+++ b/source/blender/makesrna/intern/rna_cachefile.c
@@ -37,6 +37,7 @@
 #  include "BKE_cachefile.h"
 
 #  include "DEG_depsgraph.h"
+#  include "DEG_depsgraph_build.h"
 
 #  include "WM_api.h"
 #  include "WM_types.h"
@@ -53,6 +54,12 @@ static void rna_CacheFile_update(Main *UNUSED(bmain), Scene *UNUSED(scene), Poin
   WM_main_add_notifier(NC_OBJECT | ND_DRAW, NULL);
 }
 
+static void rna_CacheFile_dependency_update(Main *bmain, Scene *scene, PointerRNA *ptr)
+{
+  rna_CacheFile_update(bmain, scene, ptr);
+  DEG_relations_tag_update(bmain);
+}
+
 static void rna_CacheFile_object_paths_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 {
   CacheFile *cache_file = (CacheFile *)ptr->data;
@@ -105,6 +112,16 @@ static void rna_def_cachefile(BlenderRNA *brna)
       prop, "Sequence", "Whether the cache is separated in a series of files");
   RNA_def_property_update(prop, 0, "rna_CacheFile_update");
 
+  prop = RNA_def_property(srna, "use_render_procedural", PROP_BOOLEAN, PROP_NONE);
+  RNA_def_property_ui_text(
+      prop,
+      "Use Render Engine Procedural",
+      "Display boxes in the viewport as placeholders for the objects, Cycles will use a "
+      "procedural to load the objects during viewport rendering in experimental mode, "
+      "other render engines will also receive a placeholder and should take care of loading the "
+      "Alembic data themselves if possible");
+  RNA_def_property_update(prop, 0, "rna_CacheFile_dependency_update");
+
   /* ----------------- For Scene time ------------------- */
 
   prop = RNA_def_property(srna, "override_frame", PROP_BOOLEAN, PROP_NONE);
diff --git a/source/blender/makesrna/intern/rna_light.c b/source/blender/makesrna/intern/rna_light.c
index 0593db0dd56..8bec337885e 100644
--- a/source/blender/makesrna/intern/rna_light.c
+++ b/source/blender/makesrna/intern/rna_light.c
@@ -188,6 +188,7 @@ static void rna_def_light(BlenderRNA *brna)
   prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
   RNA_def_property_pointer_sdna(prop, NULL, "nodetree");
   RNA_def_property_clear_flag(prop, PROP_PTR_NO_OWNERSHIP);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Node Tree", "Node tree for node based lights");
 
   prop = RNA_def_property(srna, "use_nodes", PROP_BOOLEAN, PROP_NONE);
diff --git a/source/blender/makesrna/intern/rna_linestyle.c b/source/blender/makesrna/intern/rna_linestyle.c
index ca97f2c9a55..8cd1ac0d963 100644
--- a/source/blender/makesrna/intern/rna_linestyle.c
+++ b/source/blender/makesrna/intern/rna_linestyle.c
@@ -2189,6 +2189,7 @@ static void rna_def_linestyle(BlenderRNA *brna)
   prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
   RNA_def_property_pointer_sdna(prop, NULL, "nodetree");
   RNA_def_property_clear_flag(prop, PROP_PTR_NO_OWNERSHIP);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Node Tree", "Node tree for node-based shaders");
 
   prop = RNA_def_property(srna, "use_nodes", PROP_BOOLEAN, PROP_NONE);
diff --git a/source/blender/makesrna/intern/rna_material.c b/source/blender/makesrna/intern/rna_material.c
index d91c0bfaf29..144950235c8 100644
--- a/source/blender/makesrna/intern/rna_material.c
+++ b/source/blender/makesrna/intern/rna_material.c
@@ -849,8 +849,7 @@ void RNA_def_material(BlenderRNA *brna)
   prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
   RNA_def_property_pointer_sdna(prop, NULL, "nodetree");
   RNA_def_property_clear_flag(prop, PROP_PTR_NO_OWNERSHIP);
-  /* XXX: remove once overrides in material node trees are supported. */
-  RNA_def_property_override_flag(prop, PROPOVERRIDE_IGNORE);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Node Tree", "Node tree for node based materials");
 
   prop = RNA_def_property(srna, "use_nodes", PROP_BOOLEAN, PROP_NONE);
diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c
index 2521db3767e..ea780260be2 100644
--- a/source/blender/makesrna/intern/rna_nodetree.c
+++ b/source/blender/makesrna/intern/rna_nodetree.c
@@ -4761,6 +4761,7 @@ static void def_frame(StructRNA *srna)
   RNA_def_property_pointer_sdna(prop, NULL, "id");
   RNA_def_property_struct_type(prop, "Text");
   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Text", "");
   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
 
@@ -5768,6 +5769,7 @@ static void def_sh_tex_pointdensity(StructRNA *srna)
                                  NULL,
                                  NULL);
   RNA_def_property_flag(prop, PROP_EDITABLE);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
 
   prop = RNA_def_property(srna, "resolution", PROP_INT, PROP_NONE);
@@ -6187,6 +6189,7 @@ static void def_sh_tex_ies(StructRNA *srna)
   RNA_def_property_pointer_sdna(prop, NULL, "id");
   RNA_def_property_struct_type(prop, "Text");
   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "IES Text", "Internal IES file");
   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
 
@@ -6227,6 +6230,7 @@ static void def_sh_script(StructRNA *srna)
   RNA_def_property_pointer_sdna(prop, NULL, "id");
   RNA_def_property_struct_type(prop, "Text");
   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Script", "Internal shader script to define the shader");
   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_ShaderNodeScript_update");
 
@@ -7952,6 +7956,7 @@ static void def_cmp_movieclip(StructRNA *srna)
   RNA_def_property_pointer_sdna(prop, NULL, "id");
   RNA_def_property_struct_type(prop, "MovieClip");
   RNA_def_property_flag(prop, PROP_EDITABLE);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Movie Clip", "");
   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
 
@@ -7966,6 +7971,7 @@ static void def_cmp_stabilize2d(StructRNA *srna)
   RNA_def_property_pointer_sdna(prop, NULL, "id");
   RNA_def_property_struct_type(prop, "MovieClip");
   RNA_def_property_flag(prop, PROP_EDITABLE);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Movie Clip", "");
   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
 
@@ -7996,6 +8002,7 @@ static void def_cmp_moviedistortion(StructRNA *srna)
   RNA_def_property_pointer_sdna(prop, NULL, "id");
   RNA_def_property_struct_type(prop, "MovieClip");
   RNA_def_property_flag(prop, PROP_EDITABLE);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Movie Clip", "");
   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
 
@@ -8025,6 +8032,7 @@ static void def_cmp_mask(StructRNA *srna)
   RNA_def_property_pointer_sdna(prop, NULL, "id");
   RNA_def_property_struct_type(prop, "Mask");
   RNA_def_property_flag(prop, PROP_EDITABLE);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Mask", "");
 
   prop = RNA_def_property(srna, "use_feather", PROP_BOOLEAN, PROP_NONE);
@@ -8517,6 +8525,7 @@ static void def_cmp_keyingscreen(StructRNA *srna)
   RNA_def_property_pointer_sdna(prop, NULL, "id");
   RNA_def_property_struct_type(prop, "MovieClip");
   RNA_def_property_flag(prop, PROP_EDITABLE);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Movie Clip", "");
   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
 
@@ -8654,6 +8663,7 @@ static void def_cmp_trackpos(StructRNA *srna)
   RNA_def_property_pointer_sdna(prop, NULL, "id");
   RNA_def_property_struct_type(prop, "MovieClip");
   RNA_def_property_flag(prop, PROP_EDITABLE);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Movie Clip", "");
   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
 
@@ -8718,6 +8728,7 @@ static void def_cmp_planetrackdeform(StructRNA *srna)
   RNA_def_property_pointer_sdna(prop, NULL, "id");
   RNA_def_property_struct_type(prop, "MovieClip");
   RNA_def_property_flag(prop, PROP_EDITABLE);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Movie Clip", "");
   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
 
@@ -8848,6 +8859,7 @@ static void def_cmp_cryptomatte(StructRNA *srna)
       prop, "rna_NodeCryptomatte_scene_get", "rna_NodeCryptomatte_scene_set", NULL, NULL);
   RNA_def_property_struct_type(prop, "Scene");
   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Scene", "");
   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
 
@@ -8859,6 +8871,7 @@ static void def_cmp_cryptomatte(StructRNA *srna)
                                  "rna_NodeCryptomatte_image_poll");
   RNA_def_property_struct_type(prop, "Image");
   RNA_def_property_flag(prop, PROP_EDITABLE);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Image", "");
   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
 
@@ -8958,6 +8971,7 @@ static void def_tex_image(StructRNA *srna)
   RNA_def_property_pointer_sdna(prop, NULL, "id");
   RNA_def_property_struct_type(prop, "Image");
   RNA_def_property_flag(prop, PROP_EDITABLE);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Image", "");
   RNA_def_property_update(prop, NC_NODE | NA_EDITED, "rna_Node_update");
 
@@ -10996,6 +11010,7 @@ static void rna_def_node_socket_object(BlenderRNA *brna,
   RNA_def_property_update(
       prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT | PROP_CONTEXT_UPDATE);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
 
   /* socket interface */
   srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard");
@@ -11031,6 +11046,7 @@ static void rna_def_node_socket_image(BlenderRNA *brna,
   RNA_def_property_update(
       prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT | PROP_CONTEXT_UPDATE);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
 
   /* socket interface */
   srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard");
@@ -11081,6 +11097,7 @@ static void rna_def_node_socket_collection(BlenderRNA *brna,
   RNA_def_property_update(
       prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT | PROP_CONTEXT_UPDATE);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
 
   /* socket interface */
   srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard");
@@ -11116,6 +11133,7 @@ static void rna_def_node_socket_texture(BlenderRNA *brna,
   RNA_def_property_update(
       prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT | PROP_CONTEXT_UPDATE);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
 
   /* socket interface */
   srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard");
@@ -11153,6 +11171,7 @@ static void rna_def_node_socket_material(BlenderRNA *brna,
   RNA_def_property_update(
       prop, NC_NODE | NA_EDITED, "rna_NodeSocketStandard_value_and_relation_update");
   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT | PROP_CONTEXT_UPDATE);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
 
   /* socket interface */
   srna = RNA_def_struct(brna, interface_idname, "NodeSocketInterfaceStandard");
@@ -11538,12 +11557,14 @@ static void rna_def_node(BlenderRNA *brna)
   prop = RNA_def_property(srna, "inputs", PROP_COLLECTION, PROP_NONE);
   RNA_def_property_collection_sdna(prop, NULL, "inputs", NULL);
   RNA_def_property_struct_type(prop, "NodeSocket");
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Inputs", "");
   rna_def_node_sockets_api(brna, prop, SOCK_IN);
 
   prop = RNA_def_property(srna, "outputs", PROP_COLLECTION, PROP_NONE);
   RNA_def_property_collection_sdna(prop, NULL, "outputs", NULL);
   RNA_def_property_struct_type(prop, "NodeSocket");
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Outputs", "");
   rna_def_node_sockets_api(brna, prop, SOCK_OUT);
 
@@ -11990,6 +12011,7 @@ static void rna_def_nodetree(BlenderRNA *brna)
   prop = RNA_def_property(srna, "nodes", PROP_COLLECTION, PROP_NONE);
   RNA_def_property_collection_sdna(prop, NULL, "nodes", NULL);
   RNA_def_property_struct_type(prop, "Node");
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Nodes", "");
   rna_def_nodetree_nodes_api(brna, prop);
 
@@ -12007,6 +12029,7 @@ static void rna_def_nodetree(BlenderRNA *brna)
   RNA_def_property_pointer_funcs(
       prop, NULL, NULL, NULL, "rna_GPencil_datablocks_annotations_poll");
   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_REFCOUNT);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Grease Pencil Data", "Grease Pencil data-block");
   RNA_def_property_update(prop, NC_NODE, NULL);
 
diff --git a/source/blender/makesrna/intern/rna_render.c b/source/blender/makesrna/intern/rna_render.c
index 73924c45d52..4400d198b4a 100644
--- a/source/blender/makesrna/intern/rna_render.c
+++ b/source/blender/makesrna/intern/rna_render.c
@@ -896,6 +896,12 @@ static void rna_def_render_engine(BlenderRNA *brna)
   RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
   RNA_def_property_ui_text(prop, "Use Stereo Viewport", "Support rendering stereo 3D viewport");
 
+  prop = RNA_def_property(srna, "bl_use_alembic_procedural", PROP_BOOLEAN, PROP_NONE);
+  RNA_def_property_boolean_sdna(prop, NULL, "type->flag", RE_USE_ALEMBIC_PROCEDURAL);
+  RNA_def_property_flag(prop, PROP_REGISTER_OPTIONAL);
+  RNA_def_property_ui_text(
+      prop, "Use Alembic Procedural", "Support loading Alembic data at render time");
+
   RNA_define_verify_sdna(1);
 }
 
diff --git a/source/blender/makesrna/intern/rna_scene.c b/source/blender/makesrna/intern/rna_scene.c
index 7d7eec6f256..9d158761a21 100644
--- a/source/blender/makesrna/intern/rna_scene.c
+++ b/source/blender/makesrna/intern/rna_scene.c
@@ -616,6 +616,7 @@ const EnumPropertyItem rna_enum_transform_orientation_items[] = {
 #  include "BLI_string_utils.h"
 
 #  include "DNA_anim_types.h"
+#  include "DNA_cachefile_types.h"
 #  include "DNA_color_types.h"
 #  include "DNA_mesh_types.h"
 #  include "DNA_node_types.h"
@@ -1619,6 +1620,11 @@ static void rna_RenderSettings_engine_update(Main *bmain,
   ED_render_engine_changed(bmain, true);
 }
 
+static void rna_Scene_update_render_engine(Main *bmain)
+{
+  ED_render_engine_changed(bmain, true);
+}
+
 static bool rna_RenderSettings_multiple_engines_get(PointerRNA *UNUSED(ptr))
 {
   return (BLI_listbase_count(&R_engines) > 1);
@@ -7664,6 +7670,7 @@ void RNA_def_scene(BlenderRNA *brna)
   prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
   RNA_def_property_pointer_sdna(prop, NULL, "nodetree");
   RNA_def_property_clear_flag(prop, PROP_PTR_NO_OWNERSHIP);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Node Tree", "Compositing node tree");
 
   prop = RNA_def_property(srna, "use_nodes", PROP_BOOLEAN, PROP_NONE);
@@ -7835,6 +7842,10 @@ void RNA_def_scene(BlenderRNA *brna)
   RNA_def_property_update(prop, NC_SCENE, NULL);
   RNA_def_property_update(prop, NC_SCENE, "rna_Scene_volume_update");
 
+  func = RNA_def_function(srna, "update_render_engine", "rna_Scene_update_render_engine");
+  RNA_def_function_flag(func, FUNC_NO_SELF | FUNC_USE_MAIN);
+  RNA_def_function_ui_description(func, "Trigger a render engine update");
+
   /* Statistics */
   func = RNA_def_function(srna, "statistics", "rna_Scene_statistics_string_get");
   RNA_def_function_flag(func, FUNC_USE_MAIN | FUNC_USE_REPORTS);
@@ -7895,6 +7906,7 @@ void RNA_def_scene(BlenderRNA *brna)
   RNA_def_property_pointer_sdna(prop, NULL, "master_collection");
   RNA_def_property_struct_type(prop, "Collection");
   RNA_def_property_clear_flag(prop, PROP_PTR_NO_OWNERSHIP);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop,
                            "Collection",
                            "Scene root collection that owns all the objects and other collections "
diff --git a/source/blender/makesrna/intern/rna_simulation.c b/source/blender/makesrna/intern/rna_simulation.c
index cc9a4bec2e7..6f5041c9ed1 100644
--- a/source/blender/makesrna/intern/rna_simulation.c
+++ b/source/blender/makesrna/intern/rna_simulation.c
@@ -43,6 +43,7 @@ static void rna_def_simulation(BlenderRNA *brna)
   prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
   RNA_def_property_pointer_sdna(prop, NULL, "nodetree");
   RNA_def_property_clear_flag(prop, PROP_PTR_NO_OWNERSHIP);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Node Tree", "Node tree defining the simulation");
 
   /* common */
diff --git a/source/blender/makesrna/intern/rna_texture.c b/source/blender/makesrna/intern/rna_texture.c
index 128f1cb1e21..5a74cfa9964 100644
--- a/source/blender/makesrna/intern/rna_texture.c
+++ b/source/blender/makesrna/intern/rna_texture.c
@@ -1642,6 +1642,7 @@ static void rna_def_texture(BlenderRNA *brna)
   prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
   RNA_def_property_pointer_sdna(prop, NULL, "nodetree");
   RNA_def_property_clear_flag(prop, PROP_PTR_NO_OWNERSHIP);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Node Tree", "Node tree for node-based textures");
   RNA_def_property_update(prop, 0, "rna_Texture_nodes_update");
 
diff --git a/source/blender/makesrna/intern/rna_userdef.c b/source/blender/makesrna/intern/rna_userdef.c
index 483506d5733..73811924c23 100644
--- a/source/blender/makesrna/intern/rna_userdef.c
+++ b/source/blender/makesrna/intern/rna_userdef.c
@@ -1118,12 +1118,6 @@ static void rna_def_userdef_theme_ui_font_style(BlenderRNA *brna)
   StructRNA *srna;
   PropertyRNA *prop;
 
-  static const EnumPropertyItem font_kerning_style[] = {
-      {0, "UNFITTED", 0, "Unfitted", "Use scaled but un-grid-fitted kerning distances"},
-      {1, "FITTED", 0, "Fitted", "Use scaled and grid-fitted kerning distances"},
-      {0, NULL, 0, NULL, NULL},
-  };
-
   srna = RNA_def_struct(brna, "ThemeFontStyle", NULL);
   RNA_def_struct_sdna(srna, "uiFontStyle");
   RNA_def_struct_clear_flag(srna, STRUCT_UNDO);
@@ -1134,12 +1128,6 @@ static void rna_def_userdef_theme_ui_font_style(BlenderRNA *brna)
   RNA_def_property_ui_text(prop, "Points", "Font size in points");
   RNA_def_property_update(prop, 0, "rna_userdef_theme_update");
 
-  prop = RNA_def_property(srna, "font_kerning_style", PROP_ENUM, PROP_NONE);
-  RNA_def_property_enum_sdna(prop, NULL, "kerning");
-  RNA_def_property_enum_items(prop, font_kerning_style);
-  RNA_def_property_ui_text(prop, "Kerning Style", "Which style to use for font kerning");
-  RNA_def_property_update(prop, 0, "rna_userdef_theme_update");
-
   prop = RNA_def_property(srna, "shadow", PROP_INT, PROP_PIXEL);
   RNA_def_property_range(prop, 0, 5);
   RNA_def_property_ui_text(prop, "Shadow Size", "Shadow size (0, 3 and 5 supported)");
diff --git a/source/blender/makesrna/intern/rna_world.c b/source/blender/makesrna/intern/rna_world.c
index a66e3090548..826e6d21c36 100644
--- a/source/blender/makesrna/intern/rna_world.c
+++ b/source/blender/makesrna/intern/rna_world.c
@@ -237,6 +237,7 @@ void RNA_def_world(BlenderRNA *brna)
   prop = RNA_def_property(srna, "node_tree", PROP_POINTER, PROP_NONE);
   RNA_def_property_pointer_sdna(prop, NULL, "nodetree");
   RNA_def_property_clear_flag(prop, PROP_PTR_NO_OWNERSHIP);
+  RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
   RNA_def_property_ui_text(prop, "Node Tree", "Node tree for node based worlds");
 
   prop = RNA_def_property(srna, "use_nodes", PROP_BOOLEAN, PROP_NONE);
diff --git a/source/blender/modifiers/intern/MOD_build.c b/source/blender/modifiers/intern/MOD_build.c
index 52f21e3d3d0..a344a15b0c1 100644
--- a/source/blender/modifiers/intern/MOD_build.c
+++ b/source/blender/modifiers/intern/MOD_build.c
@@ -61,7 +61,9 @@ static void initData(ModifierData *md)
   MEMCPY_STRUCT_AFTER(bmd, DNA_struct_default_get(BuildModifierData), modifier);
 }
 
-static bool dependsOnTime(ModifierData *UNUSED(md))
+static bool dependsOnTime(struct Scene *UNUSED(scene),
+                          ModifierData *UNUSED(md),
+                          const int UNUSED(dag_eval_mode))
 {
   return true;
 }
diff --git a/source/blender/modifiers/intern/MOD_cloth.c b/source/blender/modifiers/intern/MOD_cloth.c
index 4487adcfdda..fa2f70e1a9c 100644
--- a/source/blender/modifiers/intern/MOD_cloth.c
+++ b/source/blender/modifiers/intern/MOD_cloth.c
@@ -220,7 +220,9 @@ static void copyData(const ModifierData *md, ModifierData *target, const int fla
   tclmd->solver_result = NULL;
 }
 
-static bool dependsOnTime(ModifierData *UNUSED(md))
+static bool dependsOnTime(struct Scene *UNUSED(scene),
+                          ModifierData *UNUSED(md),
+                          const int UNUSED(dag_eval_mode))
 {
   return true;
 }
diff --git a/source/blender/modifiers/intern/MOD_collision.c b/source/blender/modifiers/intern/MOD_collision.c
index 5dd57469914..e7d5fe056c5 100644
--- a/source/blender/modifiers/intern/MOD_collision.c
+++ b/source/blender/modifiers/intern/MOD_collision.c
@@ -95,7 +95,9 @@ static void freeData(ModifierData *md)
   }
 }
 
-static bool dependsOnTime(ModifierData *UNUSED(md))
+static bool dependsOnTime(struct Scene *UNUSED(scene),
+                          ModifierData *UNUSED(md),
+                          const int UNUSED(dag_eval_mode))
 {
   return true;
 }
diff --git a/source/blender/modifiers/intern/MOD_displace.c b/source/blender/modifiers/intern/MOD_displace.c
index a7ac9f618af..07da18f990d 100644
--- a/source/blender/modifiers/intern/MOD_displace.c
+++ b/source/blender/modifiers/intern/MOD_displace.c
@@ -95,7 +95,9 @@ static void requiredDataMask(Object *UNUSED(ob),
   }
 }
 
-static bool dependsOnTime(ModifierData *md)
+static bool dependsOnTime(struct Scene *UNUSED(scene),
+                          ModifierData *md,
+                          const int UNUSED(dag_eval_mode))
 {
   DisplaceModifierData *dmd = (DisplaceModifierData *)md;
 
diff --git a/source/blender/modifiers/intern/MOD_dynamicpaint.c b/source/blender/modifiers/intern/MOD_dynamicpaint.c
index 8b1d541d45d..77ae5c4b6f1 100644
--- a/source/blender/modifiers/intern/MOD_dynamicpaint.c
+++ b/source/blender/modifiers/intern/MOD_dynamicpaint.c
@@ -155,7 +155,9 @@ static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphConte
   }
 }
 
-static bool dependsOnTime(ModifierData *UNUSED(md))
+static bool dependsOnTime(struct Scene *UNUSED(scene),
+                          ModifierData *UNUSED(md),
+                          const int UNUSED(dag_eval_mode))
 {
   return true;
 }
diff --git a/source/blender/modifiers/intern/MOD_explode.c b/source/blender/modifiers/intern/MOD_explode.c
index bf197dca7e5..493b59b3a1a 100644
--- a/source/blender/modifiers/intern/MOD_explode.c
+++ b/source/blender/modifiers/intern/MOD_explode.c
@@ -86,7 +86,9 @@ static void copyData(const ModifierData *md, ModifierData *target, const int fla
 
   temd->facepa = NULL;
 }
-static bool dependsOnTime(ModifierData *UNUSED(md))
+static bool dependsOnTime(struct Scene *UNUSED(scene),
+                          ModifierData *UNUSED(md),
+                          const int UNUSED(dag_eval_mode))
 {
   return true;
 }
diff --git a/source/blender/modifiers/intern/MOD_fluid.c b/source/blender/modifiers/intern/MOD_fluid.c
index 36d2ab2a11a..a14d582063a 100644
--- a/source/blender/modifiers/intern/MOD_fluid.c
+++ b/source/blender/modifiers/intern/MOD_fluid.c
@@ -132,7 +132,9 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
 #endif /* WITH_FLUID */
 }
 
-static bool dependsOnTime(ModifierData *UNUSED(md))
+static bool dependsOnTime(struct Scene *UNUSED(scene),
+                          ModifierData *UNUSED(md),
+                          const int UNUSED(dag_eval_mode))
 {
   return true;
 }
diff --git a/source/blender/modifiers/intern/MOD_meshcache.c b/source/blender/modifiers/intern/MOD_meshcache.c
index e0507320628..6ef64ad8bc9 100644
--- a/source/blender/modifiers/intern/MOD_meshcache.c
+++ b/source/blender/modifiers/intern/MOD_meshcache.c
@@ -63,7 +63,9 @@ static void initData(ModifierData *md)
   MEMCPY_STRUCT_AFTER(mcmd, DNA_struct_default_get(MeshCacheModifierData), modifier);
 }
 
-static bool dependsOnTime(ModifierData *md)
+static bool dependsOnTime(struct Scene *UNUSED(scene),
+                          ModifierData *md,
+                          const int UNUSED(dag_eval_mode))
 {
   MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
   return (mcmd->play_mode == MOD_MESHCACHE_PLAY_CFEA);
diff --git a/source/blender/modifiers/intern/MOD_meshsequencecache.c b/source/blender/modifiers/intern/MOD_meshsequencecache.c
index 3e6081e0a18..259c1cb2417 100644
--- a/source/blender/modifiers/intern/MOD_meshsequencecache.c
+++ b/source/blender/modifiers/intern/MOD_meshsequencecache.c
@@ -20,6 +20,7 @@
 
 #include <string.h>
 
+#include "BLI_math_vector.h"
 #include "BLI_string.h"
 #include "BLI_utildefines.h"
 
@@ -39,6 +40,8 @@
 #include "BKE_cachefile.h"
 #include "BKE_context.h"
 #include "BKE_lib_query.h"
+#include "BKE_mesh.h"
+#include "BKE_object.h"
 #include "BKE_scene.h"
 #include "BKE_screen.h"
 
@@ -118,6 +121,44 @@ static bool isDisabled(const struct Scene *UNUSED(scene),
   return (mcmd->cache_file == NULL) || (mcmd->object_path[0] == '\0');
 }
 
+static Mesh *generate_bounding_box_mesh(Object *object, Mesh *org_mesh)
+{
+  BoundBox *bb = BKE_object_boundbox_get(object);
+  Mesh *result = BKE_mesh_new_nomain_from_template(org_mesh, 8, 0, 0, 24, 6);
+
+  MVert *mvert = result->mvert;
+  for (int i = 0; i < 8; ++i) {
+    copy_v3_v3(mvert[i].co, bb->vec[i]);
+  }
+
+  /* See DNA_object_types.h for the diagram showing the order of the vertices for a BoundBox. */
+  static unsigned int loops_v[6][4] = {
+      {0, 4, 5, 1},
+      {4, 7, 6, 5},
+      {7, 3, 2, 6},
+      {3, 0, 1, 2},
+      {1, 5, 6, 2},
+      {3, 7, 4, 0},
+  };
+
+  MLoop *mloop = result->mloop;
+  for (int i = 0; i < 6; ++i) {
+    for (int j = 0; j < 4; ++j, ++mloop) {
+      mloop->v = loops_v[i][j];
+    }
+  }
+
+  MPoly *mpoly = result->mpoly;
+  for (int i = 0; i < 6; ++i) {
+    mpoly[i].loopstart = i * 4;
+    mpoly[i].totloop = 4;
+  }
+
+  BKE_mesh_calc_edges(result, false, false);
+
+  return result;
+}
+
 static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh)
 {
 #if defined(WITH_USD) || defined(WITH_ALEMBIC)
@@ -143,6 +184,12 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
     }
   }
 
+  /* Do not process data if using a render procedural, return a box instead for displaying in the
+   * viewport. */
+  if (BKE_cache_file_uses_render_procedural(cache_file, scene, DEG_get_mode(ctx->depsgraph))) {
+    return generate_bounding_box_mesh(ctx->object, org_mesh);
+  }
+
   /* If this invocation is for the ORCO mesh, and the mesh hasn't changed topology, we
    * must return the mesh as-is instead of deforming it. */
   if (ctx->flag & MOD_APPLY_ORCO) {
@@ -223,18 +270,20 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
 
   return result ? result : mesh;
 #else
-  UNUSED_VARS(ctx, md);
+  UNUSED_VARS(ctx, md, generate_bounding_box_mesh);
   return mesh;
 #endif
 }
 
-static bool dependsOnTime(ModifierData *md)
+static bool dependsOnTime(Scene *scene, ModifierData *md, const int dag_eval_mode)
 {
 #if defined(WITH_USD) || defined(WITH_ALEMBIC)
   MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *)md;
-  return (mcmd->cache_file != NULL);
+  /* Do not evaluate animations if using the render engine procedural. */
+  return (mcmd->cache_file != NULL) &&
+         !BKE_cache_file_uses_render_procedural(mcmd->cache_file, scene, dag_eval_mode);
 #else
-  UNUSED_VARS(md);
+  UNUSED_VARS(scene, md, dag_eval_mode);
   return false;
 #endif
 }
diff --git a/source/blender/modifiers/intern/MOD_softbody.c b/source/blender/modifiers/intern/MOD_softbody.c
index d7d2f948955..4187f9087a0 100644
--- a/source/blender/modifiers/intern/MOD_softbody.c
+++ b/source/blender/modifiers/intern/MOD_softbody.c
@@ -62,7 +62,9 @@ static void deformVerts(ModifierData *UNUSED(md),
       ctx->depsgraph, scene, ctx->object, DEG_get_ctime(ctx->depsgraph), vertexCos, numVerts);
 }
 
-static bool dependsOnTime(ModifierData *UNUSED(md))
+static bool dependsOnTime(struct Scene *UNUSED(scene),
+                          ModifierData *UNUSED(md),
+                          const int UNUSED(dag_eval_mode))
 {
   return true;
 }
diff --git a/source/blender/modifiers/intern/MOD_surface.c b/source/blender/modifiers/intern/MOD_surface.c
index bfd4cd81803..3f2d0a06db8 100644
--- a/source/blender/modifiers/intern/MOD_surface.c
+++ b/source/blender/modifiers/intern/MOD_surface.c
@@ -98,7 +98,9 @@ static void freeData(ModifierData *md)
   }
 }
 
-static bool dependsOnTime(ModifierData *UNUSED(md))
+static bool dependsOnTime(struct Scene *UNUSED(scene),
+                          ModifierData *UNUSED(md),
+                          const int UNUSED(dag_eval_mode))
 {
   return true;
 }
diff --git a/source/blender/modifiers/intern/MOD_volume_displace.cc b/source/blender/modifiers/intern/MOD_volume_displace.cc
index af4b31d6bfc..fcf75040a9a 100644
--- a/source/blender/modifiers/intern/MOD_volume_displace.cc
+++ b/source/blender/modifiers/intern/MOD_volume_displace.cc
@@ -95,7 +95,9 @@ static void foreachTexLink(ModifierData *md, Object *ob, TexWalkFunc walk, void
   walk(userData, ob, md, "texture");
 }
 
-static bool dependsOnTime(ModifierData *md)
+static bool dependsOnTime(struct Scene *UNUSED(scene),
+                          ModifierData *md,
+                          const int UNUSED(dag_eval_mode))
 {
   VolumeDisplaceModifierData *vdmd = reinterpret_cast<VolumeDisplaceModifierData *>(md);
   if (vdmd->texture) {
diff --git a/source/blender/modifiers/intern/MOD_warp.c b/source/blender/modifiers/intern/MOD_warp.c
index 3bebc52c503..25e33b22bde 100644
--- a/source/blender/modifiers/intern/MOD_warp.c
+++ b/source/blender/modifiers/intern/MOD_warp.c
@@ -116,7 +116,9 @@ static void matrix_from_obj_pchan(float mat[4][4],
   }
 }
 
-static bool dependsOnTime(ModifierData *md)
+static bool dependsOnTime(struct Scene *UNUSED(scene),
+                          ModifierData *md,
+                          const int UNUSED(dag_eval_mode))
 {
   WarpModifierData *wmd = (WarpModifierData *)md;
 
diff --git a/source/blender/modifiers/intern/MOD_wave.c b/source/blender/modifiers/intern/MOD_wave.c
index cf4c195c66d..03f8e3a1dfb 100644
--- a/source/blender/modifiers/intern/MOD_wave.c
+++ b/source/blender/modifiers/intern/MOD_wave.c
@@ -70,7 +70,9 @@ static void initData(ModifierData *md)
   MEMCPY_STRUCT_AFTER(wmd, DNA_struct_default_get(WaveModifierData), modifier);
 }
 
-static bool dependsOnTime(ModifierData *UNUSED(md))
+static bool dependsOnTime(struct Scene *UNUSED(scene),
+                          ModifierData *UNUSED(md),
+                          const int UNUSED(dag_eval_mode))
 {
   return true;
 }
diff --git a/source/blender/modifiers/intern/MOD_weightvgedit.c b/source/blender/modifiers/intern/MOD_weightvgedit.c
index 093fa118ee0..a9d01c64ff1 100644
--- a/source/blender/modifiers/intern/MOD_weightvgedit.c
+++ b/source/blender/modifiers/intern/MOD_weightvgedit.c
@@ -112,7 +112,9 @@ static void requiredDataMask(Object *UNUSED(ob),
   /* No need to ask for CD_PREVIEW_MLOOPCOL... */
 }
 
-static bool dependsOnTime(ModifierData *md)
+static bool dependsOnTime(struct Scene *UNUSED(scene),
+                          ModifierData *md,
+                          const int UNUSED(dag_eval_mode))
 {
   WeightVGEditModifierData *wmd = (WeightVGEditModifierData *)md;
 
diff --git a/source/blender/modifiers/intern/MOD_weightvgmix.c b/source/blender/modifiers/intern/MOD_weightvgmix.c
index 7aae089fa18..b369b82ebb7 100644
--- a/source/blender/modifiers/intern/MOD_weightvgmix.c
+++ b/source/blender/modifiers/intern/MOD_weightvgmix.c
@@ -154,7 +154,9 @@ static void requiredDataMask(Object *UNUSED(ob),
   /* No need to ask for CD_PREVIEW_MLOOPCOL... */
 }
 
-static bool dependsOnTime(ModifierData *md)
+static bool dependsOnTime(struct Scene *UNUSED(scene),
+                          ModifierData *md,
+                          const int UNUSED(dag_eval_mode))
 {
   WeightVGMixModifierData *wmd = (WeightVGMixModifierData *)md;
 
diff --git a/source/blender/modifiers/intern/MOD_weightvgproximity.c b/source/blender/modifiers/intern/MOD_weightvgproximity.c
index 6e78774269a..7ee19e1c537 100644
--- a/source/blender/modifiers/intern/MOD_weightvgproximity.c
+++ b/source/blender/modifiers/intern/MOD_weightvgproximity.c
@@ -362,7 +362,9 @@ static void requiredDataMask(Object *UNUSED(ob),
   /* No need to ask for CD_PREVIEW_MLOOPCOL... */
 }
 
-static bool dependsOnTime(ModifierData *md)
+static bool dependsOnTime(struct Scene *UNUSED(scene),
+                          ModifierData *md,
+                          const int UNUSED(dag_eval_mode))
 {
   WeightVGProximityModifierData *wmd = (WeightVGProximityModifierData *)md;
 
diff --git a/source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc b/source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc
index e8dd36e528c..4f70252ae75 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_subdivision_surface.cc
@@ -40,6 +40,7 @@ static void geo_node_subdivision_surface_layout(uiLayout *layout,
                                                 PointerRNA *ptr)
 {
 #ifndef WITH_OPENSUBDIV
+  UNUSED_VARS(ptr);
   uiItemL(layout, IFACE_("Disabled, built without OpenSubdiv"), ICON_ERROR);
 #else
   uiLayoutSetPropSep(layout, true);
@@ -147,7 +148,5 @@ void register_node_type_geo_subdivision_surface()
                     "NodeGeometrySubdivisionSurface",
                     node_free_standard_storage,
                     node_copy_standard_storage);
-  node_type_socket_templates(
-      &ntype, geo_node_subdivision_surface_in, geo_node_subdivision_surface_out);
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/nodes/shader/nodes/node_shader_mixRgb.cc b/source/blender/nodes/shader/nodes/node_shader_mixRgb.cc
index 6baaa17f956..47011caeeb6 100644
--- a/source/blender/nodes/shader/nodes/node_shader_mixRgb.cc
+++ b/source/blender/nodes/shader/nodes/node_shader_mixRgb.cc
@@ -127,15 +127,71 @@ static int gpu_shader_mix_rgb(GPUMaterial *mat,
   return 0;
 }
 
+class MixRGBFunction : public blender::fn::MultiFunction {
+ private:
+  bool clamp_;
+  int type_;
+
+ public:
+  MixRGBFunction(bool clamp, int type) : clamp_(clamp), type_(type)
+  {
+    static blender::fn::MFSignature signature = create_signature();
+    this->set_signature(&signature);
+  }
+
+  static blender::fn::MFSignature create_signature()
+  {
+    blender::fn::MFSignatureBuilder signature{"MixRGB"};
+    signature.single_input<float>("Fac");
+    signature.single_input<blender::ColorGeometry4f>("Color1");
+    signature.single_input<blender::ColorGeometry4f>("Color2");
+    signature.single_output<blender::ColorGeometry4f>("Color");
+    return signature.build();
+  }
+
+  void call(blender::IndexMask mask,
+            blender::fn::MFParams params,
+            blender::fn::MFContext UNUSED(context)) const override
+  {
+    const blender::VArray<float> &fac = params.readonly_single_input<float>(0, "Fac");
+    const blender::VArray<blender::ColorGeometry4f> &col1 =
+        params.readonly_single_input<blender::ColorGeometry4f>(1, "Color1");
+    const blender::VArray<blender::ColorGeometry4f> &col2 =
+        params.readonly_single_input<blender::ColorGeometry4f>(2, "Color2");
+    blender::MutableSpan<blender::ColorGeometry4f> results =
+        params.uninitialized_single_output<blender::ColorGeometry4f>(3, "Color");
+
+    for (int64_t i : mask) {
+      results[i] = col1[i];
+      ramp_blend(type_, results[i], clamp_f(fac[i], 0.0f, 1.0f), col2[i]);
+    }
+
+    if (clamp_) {
+      for (int64_t i : mask) {
+        clamp_v3(results[i], 0.0f, 1.0f);
+      }
+    }
+  }
+};
+
+static void sh_node_mix_rgb_expand_in_mf_network(blender::nodes::NodeMFNetworkBuilder &builder)
+{
+  bNode &node = builder.bnode();
+  bool clamp = node.custom2 & SHD_MIXRGB_CLAMP;
+  int mix_type = node.custom1;
+  builder.construct_and_set_matching_fn<MixRGBFunction>(clamp, mix_type);
+}
+
 void register_node_type_sh_mix_rgb(void)
 {
   static bNodeType ntype;
 
-  sh_node_type_base(&ntype, SH_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, 0);
+  sh_fn_node_type_base(&ntype, SH_NODE_MIX_RGB, "Mix", NODE_CLASS_OP_COLOR, 0);
   node_type_socket_templates(&ntype, sh_node_mix_rgb_in, sh_node_mix_rgb_out);
   node_type_label(&ntype, node_blend_label);
   node_type_exec(&ntype, nullptr, nullptr, node_shader_exec_mix_rgb);
   node_type_gpu(&ntype, gpu_shader_mix_rgb);
+  ntype.expand_in_mf_network = sh_node_mix_rgb_expand_in_mf_network;
 
   nodeRegisterType(&ntype);
 }
diff --git a/source/blender/python/generic/blf_py_api.c b/source/blender/python/generic/blf_py_api.c
index 0ec66e22fa9..9e725730d40 100644
--- a/source/blender/python/generic/blf_py_api.c
+++ b/source/blender/python/generic/blf_py_api.c
@@ -493,7 +493,6 @@ PyObject *BPyInit_blf(void)
   PyModule_AddIntConstant(submodule, "ROTATION", BLF_ROTATION);
   PyModule_AddIntConstant(submodule, "CLIPPING", BLF_CLIPPING);
   PyModule_AddIntConstant(submodule, "SHADOW", BLF_SHADOW);
-  PyModule_AddIntConstant(submodule, "KERNING_DEFAULT", BLF_KERNING_DEFAULT);
   PyModule_AddIntConstant(submodule, "WORD_WRAP", BLF_WORD_WRAP);
   PyModule_AddIntConstant(submodule, "MONOCHROME", BLF_MONOCHROME);
 
diff --git a/source/blender/render/RE_engine.h b/source/blender/render/RE_engine.h
index 6b2861bbefd..dfc0d5d0e9f 100644
--- a/source/blender/render/RE_engine.h
+++ b/source/blender/render/RE_engine.h
@@ -66,6 +66,7 @@ extern "C" {
 #define RE_USE_GPU_CONTEXT 512
 #define RE_USE_CUSTOM_FREESTYLE 1024
 #define RE_USE_NO_IMAGE_SAVE 2048
+#define RE_USE_ALEMBIC_PROCEDURAL 4096
 
 /* RenderEngine.flag */
 #define RE_ENGINE_ANIMATION 1
@@ -235,6 +236,12 @@ void RE_engines_register(RenderEngineType *render_type);
 
 bool RE_engine_is_opengl(RenderEngineType *render_type);
 
+/**
+ * Return true if the RenderEngineType has native support for direct loading of Alembic data. For
+ * Cycles, this also checks that the experimental feature set is enabled.
+ */
+bool RE_engine_supports_alembic_procedural(const RenderEngineType *render_type, Scene *scene);
+
 RenderEngineType *RE_engines_find(const char *idname);
 
 rcti *RE_engine_get_current_tiles(struct Render *re, int *r_total_tiles, bool *r_needs_free);
diff --git a/source/blender/render/intern/engine.c b/source/blender/render/intern/engine.c
index 657cd1f606b..75b3f2db249 100644
--- a/source/blender/render/intern/engine.c
+++ b/source/blender/render/intern/engine.c
@@ -128,6 +128,19 @@ bool RE_engine_is_opengl(RenderEngineType *render_type)
   return (render_type->draw_engine != NULL) && DRW_engine_render_support(render_type->draw_engine);
 }
 
+bool RE_engine_supports_alembic_procedural(const RenderEngineType *render_type, Scene *scene)
+{
+  if ((render_type->flag & RE_USE_ALEMBIC_PROCEDURAL) == 0) {
+    return false;
+  }
+
+  if (BKE_scene_uses_cycles(scene) && !BKE_scene_uses_cycles_experimental_features(scene)) {
+    return false;
+  }
+
+  return true;
+}
+
 /* Create, Free */
 
 RenderEngine *RE_engine_create(RenderEngineType *type)
diff --git a/source/blender/sequencer/intern/strip_add.c b/source/blender/sequencer/intern/strip_add.c
index 7b383bcb330..9081c655d2f 100644
--- a/source/blender/sequencer/intern/strip_add.c
+++ b/source/blender/sequencer/intern/strip_add.c
@@ -99,7 +99,7 @@ void SEQ_add_load_data_init(SeqLoadData *load_data,
 
 static void seq_add_generic_update(Scene *scene, ListBase *seqbase, Sequence *seq)
 {
-  SEQ_sequence_base_unique_name_recursive(scene, seqbase, seq);
+  SEQ_sequence_base_unique_name_recursive(scene, &scene->ed->seqbase, seq);
   SEQ_time_update_sequence_bounds(scene, seq);
   SEQ_sort(seqbase);
   SEQ_relations_invalidate_cache_composite(scene, seq);
diff --git a/source/blender/windowmanager/intern/wm_draw.c b/source/blender/windowmanager/intern/wm_draw.c
index dcb918747f3..328950cf8f9 100644
--- a/source/blender/windowmanager/intern/wm_draw.c
+++ b/source/blender/windowmanager/intern/wm_draw.c
@@ -691,46 +691,48 @@ static void wm_draw_window_offscreen(bContext *C, wmWindow *win, bool stereo)
 
     /* Then do actual drawing of regions. */
     LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
-      if (region->visible && region->do_draw) {
-        CTX_wm_region_set(C, region);
-        bool use_viewport = WM_region_use_viewport(area, region);
-
-        GPU_debug_group_begin(use_viewport ? "Viewport" : "ARegion");
-
-        if (stereo && wm_draw_region_stereo_set(bmain, area, region, STEREO_LEFT_ID)) {
-          wm_draw_region_buffer_create(region, true, use_viewport);
-
-          for (int view = 0; view < 2; view++) {
-            eStereoViews sview;
-            if (view == 0) {
-              sview = STEREO_LEFT_ID;
-            }
-            else {
-              sview = STEREO_RIGHT_ID;
-              wm_draw_region_stereo_set(bmain, area, region, sview);
-            }
-
-            wm_draw_region_bind(region, view);
-            ED_region_do_draw(C, region);
-            wm_draw_region_unbind(region);
+      if (!region->visible || !region->do_draw) {
+        continue;
+      }
+
+      CTX_wm_region_set(C, region);
+      bool use_viewport = WM_region_use_viewport(area, region);
+
+      GPU_debug_group_begin(use_viewport ? "Viewport" : "ARegion");
+
+      if (stereo && wm_draw_region_stereo_set(bmain, area, region, STEREO_LEFT_ID)) {
+        wm_draw_region_buffer_create(region, true, use_viewport);
+
+        for (int view = 0; view < 2; view++) {
+          eStereoViews sview;
+          if (view == 0) {
+            sview = STEREO_LEFT_ID;
           }
-          if (use_viewport) {
-            GPUViewport *viewport = region->draw_buffer->viewport;
-            GPU_viewport_stereo_composite(viewport, win->stereo3d_format);
+          else {
+            sview = STEREO_RIGHT_ID;
+            wm_draw_region_stereo_set(bmain, area, region, sview);
           }
-        }
-        else {
-          wm_draw_region_buffer_create(region, false, use_viewport);
-          wm_draw_region_bind(region, 0);
+
+          wm_draw_region_bind(region, view);
           ED_region_do_draw(C, region);
           wm_draw_region_unbind(region);
         }
+        if (use_viewport) {
+          GPUViewport *viewport = region->draw_buffer->viewport;
+          GPU_viewport_stereo_composite(viewport, win->stereo3d_format);
+        }
+      }
+      else {
+        wm_draw_region_buffer_create(region, false, use_viewport);
+        wm_draw_region_bind(region, 0);
+        ED_region_do_draw(C, region);
+        wm_draw_region_unbind(region);
+      }
 
-        GPU_debug_group_end();
+      GPU_debug_group_end();
 
-        region->do_draw = false;
-        CTX_wm_region_set(C, NULL);
-      }
+      region->do_draw = false;
+      CTX_wm_region_set(C, NULL);
     }
 
     CTX_wm_area_set(C, NULL);
@@ -740,29 +742,30 @@ static void wm_draw_window_offscreen(bContext *C, wmWindow *win, bool stereo)
 
   /* Draw menus into their own framebuffer. */
   LISTBASE_FOREACH (ARegion *, region, &screen->regionbase) {
-    if (region->visible) {
-      CTX_wm_menu_set(C, region);
+    if (!region->visible) {
+      continue;
+    }
+    CTX_wm_menu_set(C, region);
 
-      GPU_debug_group_begin("Menu");
+    GPU_debug_group_begin("Menu");
 
-      if (region->type && region->type->layout) {
-        /* UI code reads the OpenGL state, but we have to refresh
-         * the UI layout beforehand in case the menu size changes. */
-        wmViewport(&region->winrct);
-        region->type->layout(C, region);
-      }
+    if (region->type && region->type->layout) {
+      /* UI code reads the OpenGL state, but we have to refresh
+       * the UI layout beforehand in case the menu size changes. */
+      wmViewport(&region->winrct);
+      region->type->layout(C, region);
+    }
 
-      wm_draw_region_buffer_create(region, false, false);
-      wm_draw_region_bind(region, 0);
-      GPU_clear_color(0.0f, 0.0f, 0.0f, 0.0f);
-      ED_region_do_draw(C, region);
-      wm_draw_region_unbind(region);
+    wm_draw_region_buffer_create(region, false, false);
+    wm_draw_region_bind(region, 0);
+    GPU_clear_color(0.0f, 0.0f, 0.0f, 0.0f);
+    ED_region_do_draw(C, region);
+    wm_draw_region_unbind(region);
 
-      GPU_debug_group_end();
+    GPU_debug_group_end();
 
-      region->do_draw = false;
-      CTX_wm_menu_set(C, NULL);
-    }
+    region->do_draw = false;
+    CTX_wm_menu_set(C, NULL);
   }
 }
 
@@ -786,8 +789,12 @@ static void wm_draw_window_onscreen(bContext *C, wmWindow *win, int view)
   /* Blit non-overlapping area regions. */
   ED_screen_areas_iter (win, screen, area) {
     LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
-      if (region->visible && region->overlap == false) {
-        /* Blit from offscreen buffer. */
+      if (!region->visible) {
+        continue;
+      }
+
+      if (region->overlap == false) {
+        /* Blit from off-screen buffer. */
         wm_draw_region_blit(region, view);
       }
     }
@@ -796,24 +803,25 @@ static void wm_draw_window_onscreen(bContext *C, wmWindow *win, int view)
   /* Draw overlays and paint cursors. */
   ED_screen_areas_iter (win, screen, area) {
     LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
-      if (region->visible) {
-        const bool do_paint_cursor = (wm->paintcursors.first && region == screen->active_region);
-        const bool do_draw_overlay = (region->type && region->type->draw_overlay);
-        if (!(do_paint_cursor || do_draw_overlay)) {
-          continue;
-        }
+      if (!region->visible) {
+        continue;
+      }
+      const bool do_paint_cursor = (wm->paintcursors.first && region == screen->active_region);
+      const bool do_draw_overlay = (region->type && region->type->draw_overlay);
+      if (!(do_paint_cursor || do_draw_overlay)) {
+        continue;
+      }
 
-        CTX_wm_area_set(C, area);
-        CTX_wm_region_set(C, region);
-        if (do_draw_overlay) {
-          wm_region_draw_overlay(C, area, region);
-        }
-        if (do_paint_cursor) {
-          wm_paintcursor_draw(C, area, region);
-        }
-        CTX_wm_region_set(C, NULL);
-        CTX_wm_area_set(C, NULL);
+      CTX_wm_area_set(C, area);
+      CTX_wm_region_set(C, region);
+      if (do_draw_overlay) {
+        wm_region_draw_overlay(C, area, region);
+      }
+      if (do_paint_cursor) {
+        wm_paintcursor_draw(C, area, region);
       }
+      CTX_wm_region_set(C, NULL);
+      CTX_wm_area_set(C, NULL);
     }
   }
   wmWindowViewport(win);
@@ -821,7 +829,10 @@ static void wm_draw_window_onscreen(bContext *C, wmWindow *win, int view)
   /* Blend in overlapping area regions */
   ED_screen_areas_iter (win, screen, area) {
     LISTBASE_FOREACH (ARegion *, region, &area->regionbase) {
-      if (region->visible && region->overlap) {
+      if (!region->visible) {
+        continue;
+      }
+      if (region->overlap) {
         wm_draw_region_blend(region, 0, true);
       }
     }
@@ -834,9 +845,10 @@ static void wm_draw_window_onscreen(bContext *C, wmWindow *win, int view)
 
   /* Blend in floating regions (menus). */
   LISTBASE_FOREACH (ARegion *, region, &screen->regionbase) {
-    if (region->visible) {
-      wm_draw_region_blend(region, 0, true);
+    if (!region->visible) {
+      continue;
     }
+    wm_draw_region_blend(region, 0, true);
   }
 
   /* always draw, not only when screen tagged */
diff --git a/source/blender/windowmanager/intern/wm_files_link.c b/source/blender/windowmanager/intern/wm_files_link.c
index cdcb6c5163f..606c9252ff9 100644
--- a/source/blender/windowmanager/intern/wm_files_link.c
+++ b/source/blender/windowmanager/intern/wm_files_link.c
@@ -30,6 +30,8 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "CLG_log.h"
+
 #include "MEM_guardedalloc.h"
 
 #include "DNA_ID.h"
@@ -76,6 +78,8 @@
 
 #include "wm_files.h"
 
+static CLG_LogRef LOG = {"wm.files_link"};
+
 /* -------------------------------------------------------------------- */
 /** \name Link/Append Operator
  * \{ */
@@ -315,7 +319,7 @@ static bool wm_link_append_item_poll(ReportList *reports,
   short idcode;
 
   if (!group || !name) {
-    printf("skipping %s\n", path);
+    CLOG_WARN(&LOG, "Skipping %s", path);
     return false;
   }
 
@@ -759,12 +763,12 @@ static void lib_relocate_do_remap(Main *bmain,
     BLI_assert(new_id);
   }
   if (new_id) {
-#ifdef PRINT_DEBUG
-    printf("before remap of %s, old_id users: %d, new_id users: %d\n",
-           old_id->name,
-           old_id->us,
-           new_id->us);
-#endif
+    CLOG_INFO(&LOG,
+              4,
+              "Before remap of %s, old_id users: %d, new_id users: %d",
+              old_id->name,
+              old_id->us,
+              new_id->us);
     BKE_libblock_remap_locked(bmain, old_id, new_id, remap_flags);
 
     if (old_id->flag & LIB_FAKEUSER) {
@@ -772,12 +776,12 @@ static void lib_relocate_do_remap(Main *bmain,
       id_fake_user_set(new_id);
     }
 
-#ifdef PRINT_DEBUG
-    printf("after remap of %s, old_id users: %d, new_id users: %d\n",
-           old_id->name,
-           old_id->us,
-           new_id->us);
-#endif
+    CLOG_INFO(&LOG,
+              4,
+              "After remap of %s, old_id users: %d, new_id users: %d",
+              old_id->name,
+              old_id->us,
+              new_id->us);
 
     /* In some cases, new_id might become direct link, remove parent of library in this case. */
     if (new_id->lib->parent && (new_id->tag & LIB_TAG_INDIRECT) == 0) {
@@ -875,9 +879,7 @@ static void lib_relocate_do(bContext *C,
         item = wm_link_append_data_item_add(lapp_data, id->name + 2, idcode, id);
         BLI_bitmap_set_all(item->libraries, true, lapp_data->num_libraries);
 
-#ifdef PRINT_DEBUG
-        printf("\tdatablock to seek for: %s\n", id->name);
-#endif
+        CLOG_INFO(&LOG, 4, "Datablock to seek for: %s", id->name);
       }
     }
   }
@@ -1117,9 +1119,7 @@ static int wm_lib_relocate_exec_do(bContext *C, wmOperator *op, bool do_reload)
     }
 
     if (BLI_path_cmp(lib->filepath_abs, path) == 0) {
-#ifdef PRINT_DEBUG
-      printf("We are supposed to reload '%s' lib (%d)...\n", lib->filepath, lib->id.us);
-#endif
+      CLOG_INFO(&LOG, 4, "We are supposed to reload '%s' lib (%d)", lib->filepath, lib->id.us);
 
       do_reload = true;
 
@@ -1129,9 +1129,8 @@ static int wm_lib_relocate_exec_do(bContext *C, wmOperator *op, bool do_reload)
     else {
       int totfiles = 0;
 
-#ifdef PRINT_DEBUG
-      printf("We are supposed to relocate '%s' lib to new '%s' one...\n", lib->filepath, libname);
-#endif
+      CLOG_INFO(
+          &LOG, 4, "We are supposed to relocate '%s' lib to new '%s' one", lib->filepath, libname);
 
       /* Check if something is indicated for relocate. */
       prop = RNA_struct_find_property(op->ptr, "files");
@@ -1157,17 +1156,13 @@ static int wm_lib_relocate_exec_do(bContext *C, wmOperator *op, bool do_reload)
             continue;
           }
 
-#ifdef PRINT_DEBUG
-          printf("\t candidate new lib to reload datablocks from: %s\n", path);
-#endif
+          CLOG_INFO(&LOG, 4, "\tCandidate new lib to reload datablocks from: %s", path);
           wm_link_append_data_library_add(lapp_data, path);
         }
         RNA_END;
       }
       else {
-#ifdef PRINT_DEBUG
-        printf("\t candidate new lib to reload datablocks from: %s\n", path);
-#endif
+        CLOG_INFO(&LOG, 4, "\tCandidate new lib to reload datablocks from: %s", path);
         wm_link_append_data_library_add(lapp_data, path);
       }
     }
diff --git a/source/blender/windowmanager/intern/wm_operators.c b/source/blender/windowmanager/intern/wm_operators.c
index 50db8e73844..b5a038757c2 100644
--- a/source/blender/windowmanager/intern/wm_operators.c
+++ b/source/blender/windowmanager/intern/wm_operators.c
@@ -3178,10 +3178,11 @@ static void redraw_timer_step(bContext *C,
     LISTBASE_FOREACH (ScrArea *, area_iter, &screen->areabase) {
       CTX_wm_area_set(C, area_iter);
       LISTBASE_FOREACH (ARegion *, region_iter, &area_iter->regionbase) {
-        if (region_iter->visible) {
-          CTX_wm_region_set(C, region_iter);
-          wm_draw_region_test(C, area_iter, region_iter);
+        if (!region_iter->visible) {
+          continue;
         }
+        CTX_wm_region_set(C, region_iter);
+        wm_draw_region_test(C, area_iter, region_iter);
       }
     }
 
diff --git a/tests/performance/api/environment.py b/tests/performance/api/environment.py
index 70fc15f251c..76c731b6118 100644
--- a/tests/performance/api/environment.py
+++ b/tests/performance/api/environment.py
@@ -47,7 +47,7 @@ class TestEnvironment:
         print(f'Init {self.base_dir}')
         self.base_dir.mkdir(parents=True, exist_ok=True)
 
-        if len(self.get_configs_names()) == 0:
+        if len(self.get_config_names()) == 0:
             config_dir = self.base_dir / 'default'
             print(f'Creating default configuration in {config_dir}')
             TestConfig.write_default_config(self, config_dir)