diff --git a/.github/actions/compilers/entrypoint.sh b/.github/actions/compilers/entrypoint.sh
index 198ac0e1746da6..a83d90be91e161 100755
--- a/.github/actions/compilers/entrypoint.sh
+++ b/.github/actions/compilers/entrypoint.sh
@@ -70,14 +70,6 @@ fi
 
 pushd ${builddir}
 
-case "${INPUT_APPEND_CONFIGURE}" in
-*--with-shared-gc*)
-    export RUBY_GC_LIBRARY='librubygc.default.so'
-    mkdir -p /home/runner/shared-gc
-    grouped make shared-gc SHARED_GC=default
-    ;;
-esac
-
 grouped make showflags
 grouped make all
 grouped make test
diff --git a/NEWS.md b/NEWS.md
index 25e42db1a944eb..61e7bc790a5bfb 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -80,7 +80,7 @@ The following default gems are updated.
 * RubyGems 3.6.0.dev
 * bundler 2.6.0.dev
 * erb 4.0.4
-* fiddle 1.1.3.dev
+* fiddle 1.1.4.dev
 * io-console 0.7.2
 * irb 1.14.1
 * json 2.7.2
diff --git a/benchmark/data/citm_catalog.json b/benchmark/data/citm_catalog.json
index 245fdbbedf478e..149b2aa358839f 100644
--- a/benchmark/data/citm_catalog.json
+++ b/benchmark/data/citm_catalog.json
@@ -1406,7 +1406,7 @@
             "description": null,
             "id": 138586671,
             "logo": "/images/UE0AAAAACEKqLwAAAAlDSVRN",
-            "name": "Boris Godounov - M.Moussorgski (version de concert)",
+            "name": "Boris Godunov - M.Moussorgski (version de concert)",
             "subTopicIds": [
                 337184284,
                 337184298,
@@ -50466,4 +50466,4 @@
     "venueNames": {
         "PLEYEL_PLEYEL": "Salle Pleyel"
     }
-}
\ No newline at end of file
+}
diff --git a/bootstraptest/test_method.rb b/bootstraptest/test_method.rb
index af9443b8c6f5b8..f6f04541d6be09 100644
--- a/bootstraptest/test_method.rb
+++ b/bootstraptest/test_method.rb
@@ -1374,3 +1374,24 @@ def foo(...)
   foo(:foo, b: :ok)
   foo(*["foo"], b: :ok)
 }
+
+assert_equal 'ok', %q{
+  Thing = Struct.new(:value)
+
+  Obj = Thing.new("ok")
+
+  def delegate(...)
+    Obj.value(...)
+  end
+
+  def no_args
+    delegate
+  end
+
+  def splat_args(*args)
+    delegate(*args)
+  end
+
+  no_args
+  splat_args
+}
diff --git a/ext/fiddle/closure.c b/ext/fiddle/closure.c
index 7aa9407619c71b..d526d870e85e7f 100644
--- a/ext/fiddle/closure.c
+++ b/ext/fiddle/closure.c
@@ -61,7 +61,7 @@ const rb_data_type_t closure_data_type = {
         .dfree = dealloc,
         .dsize = closure_memsize
     },
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+    .flags = FIDDLE_DEFAULT_TYPED_DATA_FLAGS,
 };
 
 struct callback_args {
@@ -300,6 +300,7 @@ initialize_body(VALUE user_data)
         cl->argv[i] = rb_fiddle_int_to_ffi_type(NUM2INT(arg));
     }
     cl->argv[argc] = NULL;
+    OBJ_FREEZE_RAW(normalized_args);
 
     ret = rb_fiddle_type_ensure(ret);
     rb_iv_set(data->self, "@ctype", ret);
diff --git a/ext/fiddle/extconf.rb b/ext/fiddle/extconf.rb
index 6b0ea753fc373b..28999806579744 100644
--- a/ext/fiddle/extconf.rb
+++ b/ext/fiddle/extconf.rb
@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 require 'mkmf'
 
-if RUBY_ENGINE == "jruby"
+unless RUBY_ENGINE == "ruby"
   File.write('Makefile', dummy_makefile("").join)
   return
 end
@@ -223,6 +223,8 @@ def enable_debug_build_flag(flags)
   $LOCAL_LIBS.prepend("#{libffi.a} ").strip! # to exts.mk
   $INCFLAGS.gsub!(/-I#{libffi.dir}/, '-I$(LIBFFI_DIR)')
 end
+
+have_func("rb_str_to_interned_str")
 create_makefile 'fiddle' do |conf|
   if !libffi
     next conf << "LIBFFI_CLEAN = none\n"
diff --git a/ext/fiddle/fiddle.gemspec b/ext/fiddle/fiddle.gemspec
index 65de7a30af95fd..0092f5200337fa 100644
--- a/ext/fiddle/fiddle.gemspec
+++ b/ext/fiddle/fiddle.gemspec
@@ -38,11 +38,10 @@ Gem::Specification.new do |spec|
     "lib/fiddle.rb",
     "lib/fiddle/closure.rb",
     "lib/fiddle/cparser.rb",
+    "lib/fiddle/ffi_backend.rb",
     "lib/fiddle/function.rb",
     "lib/fiddle/import.rb",
-    "lib/fiddle/jruby.rb",
     "lib/fiddle/pack.rb",
-    "lib/fiddle/ruby.rb",
     "lib/fiddle/struct.rb",
     "lib/fiddle/types.rb",
     "lib/fiddle/value.rb",
diff --git a/ext/fiddle/fiddle.h b/ext/fiddle/fiddle.h
index 54391b95f57073..c0ab8a91ec2fa2 100644
--- a/ext/fiddle/fiddle.h
+++ b/ext/fiddle/fiddle.h
@@ -236,4 +236,14 @@ VALUE rb_fiddle_new_function(VALUE address, VALUE arg_types, VALUE ret_type);
 typedef void (*rb_fiddle_freefunc_t)(void*);
 VALUE rb_fiddle_ptr_new_wrap(void *ptr, long size, rb_fiddle_freefunc_t func, VALUE wrap0, VALUE wrap1);
 
+enum {
+    FIDDLE_DEFAULT_TYPED_DATA_FLAGS = (
+        RUBY_TYPED_FREE_IMMEDIATELY |
+        RUBY_TYPED_WB_PROTECTED |
+#ifdef RUBY_TYPED_FROZEN_SHAREABLE
+        RUBY_TYPED_FROZEN_SHAREABLE |
+#endif
+        0)
+};
+
 #endif
diff --git a/ext/fiddle/function.c b/ext/fiddle/function.c
index 73dfb129a54d3f..21a7ad6d2342d3 100644
--- a/ext/fiddle/function.c
+++ b/ext/fiddle/function.c
@@ -59,7 +59,7 @@ const rb_data_type_t function_data_type = {
         .dfree = deallocate,
         .dsize = function_memsize
     },
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+    .flags = FIDDLE_DEFAULT_TYPED_DATA_FLAGS,
 };
 
 static VALUE
@@ -153,6 +153,9 @@ initialize(int argc, VALUE argv[], VALUE self)
         rb_get_kwargs(kwargs, kw, 0, kw_max_, args);
         if (args[kw_name] != Qundef) {
             name = args[kw_name];
+#ifdef HAVE_RB_STR_TO_INTERNED_STR
+            name = rb_str_to_interned_str(name);
+#endif
         }
         if (args[kw_need_gvl] != Qundef) {
             need_gvl = args[kw_need_gvl];
diff --git a/ext/fiddle/handle.c b/ext/fiddle/handle.c
index 558d6d45516641..0d03133cabe755 100644
--- a/ext/fiddle/handle.c
+++ b/ext/fiddle/handle.c
@@ -56,7 +56,8 @@ static const rb_data_type_t fiddle_handle_data_type = {
         .dfree = fiddle_handle_free,
         .dsize = fiddle_handle_memsize
     },
-    .flags = RUBY_TYPED_WB_PROTECTED,
+    .flags = FIDDLE_DEFAULT_TYPED_DATA_FLAGS & ~RUBY_TYPED_FREE_IMMEDIATELY,
+    /* keeping while its symbols are referred. */
 };
 
 /*
diff --git a/ext/fiddle/lib/fiddle.rb b/ext/fiddle/lib/fiddle.rb
index b1c6cd08bf6c41..6718b012efee5b 100644
--- a/ext/fiddle/lib/fiddle.rb
+++ b/ext/fiddle/lib/fiddle.rb
@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
-require "fiddle/#{RUBY_ENGINE}"
+if RUBY_ENGINE == 'ruby'
+  require 'fiddle.so'
+else
+  require 'fiddle/ffi_backend'
+end
 require 'fiddle/closure'
 require 'fiddle/function'
 require 'fiddle/version'
diff --git a/ext/fiddle/lib/fiddle/jruby.rb b/ext/fiddle/lib/fiddle/ffi_backend.rb
similarity index 72%
rename from ext/fiddle/lib/fiddle/jruby.rb
rename to ext/fiddle/lib/fiddle/ffi_backend.rb
index 9ad61d4d9d1d5b..0c7c379777fad6 100644
--- a/ext/fiddle/lib/fiddle/jruby.rb
+++ b/ext/fiddle/lib/fiddle/ffi_backend.rb
@@ -1,4 +1,4 @@
-# This is part of JRuby's FFI-based fiddle implementation.
+# This is based on JRuby's FFI-based fiddle implementation.
 
 require 'ffi'
 
@@ -74,7 +74,7 @@ module Types
 
   WINDOWS = FFI::Platform.windows?
 
-  module JRuby
+  module FFIBackend
     FFITypes = {
         'c' => FFI::Type::INT8,
         'h' => FFI::Type::INT16,
@@ -104,16 +104,16 @@ module JRuby
         Types::VARIADIC => FFI::Type::Builtin::VARARGS,
     }
 
-    def self.__ffi_type__(dl_type)
-      if dl_type.is_a?(Symbol)
-        dl_type = Types.const_get(dl_type.to_s.upcase)
+    def self.to_ffi_type(fiddle_type)
+      if fiddle_type.is_a?(Symbol)
+        fiddle_type = Types.const_get(fiddle_type.to_s.upcase)
       end
-      if !dl_type.is_a?(Integer) && dl_type.respond_to?(:to_int)
-        dl_type = dl_type.to_int
+      if !fiddle_type.is_a?(Integer) && fiddle_type.respond_to?(:to_int)
+        fiddle_type = fiddle_type.to_int
       end
-      ffi_type = FFITypes[dl_type]
-      ffi_type = FFITypes[-dl_type] if ffi_type.nil? && dl_type.is_a?(Integer) && dl_type < 0
-      raise TypeError.new("cannot convert #{dl_type} to ffi") unless ffi_type
+      ffi_type = FFITypes[fiddle_type]
+      ffi_type = FFITypes[-fiddle_type] if ffi_type.nil? && fiddle_type.is_a?(Integer) && fiddle_type < 0
+      raise TypeError.new("cannot convert #{fiddle_type} to ffi") unless ffi_type
       ffi_type
     end
   end
@@ -133,8 +133,8 @@ def initialize(ptr, args, return_type, abi = DEFAULT, kwargs = nil)
       @ptr, @args, @return_type, @abi = ptr, args, return_type, abi
       raise TypeError.new "invalid argument types" unless args.is_a?(Array)
 
-      ffi_return_type = Fiddle::JRuby::__ffi_type__(@return_type)
-      ffi_args = @args.map { |t| Fiddle::JRuby.__ffi_type__(t) }
+      ffi_return_type = Fiddle::FFIBackend.to_ffi_type(@return_type)
+      ffi_args = @args.map { |t| Fiddle::FFIBackend.to_ffi_type(t) }
       pointer = FFI::Pointer.new(ptr.to_i)
       options = {convention: @abi}
       if ffi_args.last == FFI::Type::Builtin::VARARGS
@@ -149,14 +149,25 @@ def initialize(ptr, args, return_type, abi = DEFAULT, kwargs = nil)
       end
     end
 
-    def call(*args, &block);
+    def call(*args, &block)
       if @function.is_a?(FFI::VariadicInvoker)
         n_fixed_args = @args.size - 1
         n_fixed_args.step(args.size - 1, 2) do |i|
           if args[i] == :const_string || args[i] == Types::CONST_STRING
             args[i + 1] = String.try_convert(args[i + 1]) || args[i + 1]
           end
-          args[i] = Fiddle::JRuby.__ffi_type__(args[i])
+          args[i] = Fiddle::FFIBackend.to_ffi_type(args[i])
+        end
+      else
+        args.map! do |arg|
+          if arg.respond_to?(:to_ptr)
+            begin
+              arg = arg.to_ptr
+            end until arg.is_a?(FFI::Pointer) || !arg.respond_to?(:to_ptr)
+            arg
+          else
+            arg
+          end
         end
       end
       result = @function.call(*args, &block)
@@ -170,19 +181,21 @@ def initialize(ret, args, abi = Function::DEFAULT)
       raise TypeError.new "invalid argument types" unless args.is_a?(Array)
 
       @ctype, @args = ret, args
-      ffi_args = @args.map { |t| Fiddle::JRuby.__ffi_type__(t) }
+      ffi_args = @args.map { |t| Fiddle::FFIBackend.to_ffi_type(t) }
       if ffi_args.size == 1 && ffi_args[0] == FFI::Type::Builtin::VOID
         ffi_args = []
       end
-      @function = FFI::Function.new(
-        Fiddle::JRuby.__ffi_type__(@ctype),
-        ffi_args,
-        self,
-        :convention => abi
-      )
+      return_type = Fiddle::FFIBackend.to_ffi_type(@ctype)
+      raise "#{self.class} must implement #call" unless respond_to?(:call)
+      callable = method(:call)
+      @function = FFI::Function.new(return_type, ffi_args, callable, convention: abi)
       @freed = false
     end
 
+    def to_ptr
+      @function
+    end
+
     def to_i
       @function.to_i
     end
@@ -550,51 +563,51 @@ def cleared?
   RUBY_FREE = Fiddle::Pointer::LibC::FREE.address
   NULL = Fiddle::Pointer.new(0)
 
-  ALIGN_VOIDP       = Fiddle::JRuby::FFITypes[Types::VOIDP].alignment
-  ALIGN_CHAR        = Fiddle::JRuby::FFITypes[Types::CHAR].alignment
-  ALIGN_SHORT       = Fiddle::JRuby::FFITypes[Types::SHORT].alignment
-  ALIGN_INT         = Fiddle::JRuby::FFITypes[Types::INT].alignment
-  ALIGN_LONG        = Fiddle::JRuby::FFITypes[Types::LONG].alignment
-  ALIGN_LONG_LONG   = Fiddle::JRuby::FFITypes[Types::LONG_LONG].alignment
-  ALIGN_INT8_T      = Fiddle::JRuby::FFITypes[Types::INT8_T].alignment
-  ALIGN_INT16_T     = Fiddle::JRuby::FFITypes[Types::INT16_T].alignment
-  ALIGN_INT32_T     = Fiddle::JRuby::FFITypes[Types::INT32_T].alignment
-  ALIGN_INT64_T     = Fiddle::JRuby::FFITypes[Types::INT64_T].alignment
-  ALIGN_FLOAT       = Fiddle::JRuby::FFITypes[Types::FLOAT].alignment
-  ALIGN_DOUBLE      = Fiddle::JRuby::FFITypes[Types::DOUBLE].alignment
-  ALIGN_BOOL        = Fiddle::JRuby::FFITypes[Types::BOOL].alignment
-  ALIGN_SIZE_T      = Fiddle::JRuby::FFITypes[Types::SIZE_T].alignment
+  ALIGN_VOIDP       = Fiddle::FFIBackend::FFITypes[Types::VOIDP].alignment
+  ALIGN_CHAR        = Fiddle::FFIBackend::FFITypes[Types::CHAR].alignment
+  ALIGN_SHORT       = Fiddle::FFIBackend::FFITypes[Types::SHORT].alignment
+  ALIGN_INT         = Fiddle::FFIBackend::FFITypes[Types::INT].alignment
+  ALIGN_LONG        = Fiddle::FFIBackend::FFITypes[Types::LONG].alignment
+  ALIGN_LONG_LONG   = Fiddle::FFIBackend::FFITypes[Types::LONG_LONG].alignment
+  ALIGN_INT8_T      = Fiddle::FFIBackend::FFITypes[Types::INT8_T].alignment
+  ALIGN_INT16_T     = Fiddle::FFIBackend::FFITypes[Types::INT16_T].alignment
+  ALIGN_INT32_T     = Fiddle::FFIBackend::FFITypes[Types::INT32_T].alignment
+  ALIGN_INT64_T     = Fiddle::FFIBackend::FFITypes[Types::INT64_T].alignment
+  ALIGN_FLOAT       = Fiddle::FFIBackend::FFITypes[Types::FLOAT].alignment
+  ALIGN_DOUBLE      = Fiddle::FFIBackend::FFITypes[Types::DOUBLE].alignment
+  ALIGN_BOOL        = Fiddle::FFIBackend::FFITypes[Types::BOOL].alignment
+  ALIGN_SIZE_T      = Fiddle::FFIBackend::FFITypes[Types::SIZE_T].alignment
   ALIGN_SSIZE_T     = ALIGN_SIZE_T
-  ALIGN_PTRDIFF_T   = Fiddle::JRuby::FFITypes[Types::PTRDIFF_T].alignment
-  ALIGN_INTPTR_T    = Fiddle::JRuby::FFITypes[Types::INTPTR_T].alignment
-  ALIGN_UINTPTR_T   = Fiddle::JRuby::FFITypes[Types::UINTPTR_T].alignment
-
-  SIZEOF_VOIDP       = Fiddle::JRuby::FFITypes[Types::VOIDP].size
-  SIZEOF_CHAR        = Fiddle::JRuby::FFITypes[Types::CHAR].size
-  SIZEOF_UCHAR       = Fiddle::JRuby::FFITypes[Types::UCHAR].size
-  SIZEOF_SHORT       = Fiddle::JRuby::FFITypes[Types::SHORT].size
-  SIZEOF_USHORT      = Fiddle::JRuby::FFITypes[Types::USHORT].size
-  SIZEOF_INT         = Fiddle::JRuby::FFITypes[Types::INT].size
-  SIZEOF_UINT        = Fiddle::JRuby::FFITypes[Types::UINT].size
-  SIZEOF_LONG        = Fiddle::JRuby::FFITypes[Types::LONG].size
-  SIZEOF_ULONG       = Fiddle::JRuby::FFITypes[Types::ULONG].size
-  SIZEOF_LONG_LONG   = Fiddle::JRuby::FFITypes[Types::LONG_LONG].size
-  SIZEOF_ULONG_LONG  = Fiddle::JRuby::FFITypes[Types::ULONG_LONG].size
-  SIZEOF_INT8_T      = Fiddle::JRuby::FFITypes[Types::INT8_T].size
-  SIZEOF_UINT8_T     = Fiddle::JRuby::FFITypes[Types::UINT8_T].size
-  SIZEOF_INT16_T     = Fiddle::JRuby::FFITypes[Types::INT16_T].size
-  SIZEOF_UINT16_T    = Fiddle::JRuby::FFITypes[Types::UINT16_T].size
-  SIZEOF_INT32_T     = Fiddle::JRuby::FFITypes[Types::INT32_T].size
-  SIZEOF_UINT32_T    = Fiddle::JRuby::FFITypes[Types::UINT32_T].size
-  SIZEOF_INT64_T     = Fiddle::JRuby::FFITypes[Types::INT64_T].size
-  SIZEOF_UINT64_T    = Fiddle::JRuby::FFITypes[Types::UINT64_T].size
-  SIZEOF_FLOAT       = Fiddle::JRuby::FFITypes[Types::FLOAT].size
-  SIZEOF_DOUBLE      = Fiddle::JRuby::FFITypes[Types::DOUBLE].size
-  SIZEOF_BOOL        = Fiddle::JRuby::FFITypes[Types::BOOL].size
-  SIZEOF_SIZE_T      = Fiddle::JRuby::FFITypes[Types::SIZE_T].size
+  ALIGN_PTRDIFF_T   = Fiddle::FFIBackend::FFITypes[Types::PTRDIFF_T].alignment
+  ALIGN_INTPTR_T    = Fiddle::FFIBackend::FFITypes[Types::INTPTR_T].alignment
+  ALIGN_UINTPTR_T   = Fiddle::FFIBackend::FFITypes[Types::UINTPTR_T].alignment
+
+  SIZEOF_VOIDP       = Fiddle::FFIBackend::FFITypes[Types::VOIDP].size
+  SIZEOF_CHAR        = Fiddle::FFIBackend::FFITypes[Types::CHAR].size
+  SIZEOF_UCHAR       = Fiddle::FFIBackend::FFITypes[Types::UCHAR].size
+  SIZEOF_SHORT       = Fiddle::FFIBackend::FFITypes[Types::SHORT].size
+  SIZEOF_USHORT      = Fiddle::FFIBackend::FFITypes[Types::USHORT].size
+  SIZEOF_INT         = Fiddle::FFIBackend::FFITypes[Types::INT].size
+  SIZEOF_UINT        = Fiddle::FFIBackend::FFITypes[Types::UINT].size
+  SIZEOF_LONG        = Fiddle::FFIBackend::FFITypes[Types::LONG].size
+  SIZEOF_ULONG       = Fiddle::FFIBackend::FFITypes[Types::ULONG].size
+  SIZEOF_LONG_LONG   = Fiddle::FFIBackend::FFITypes[Types::LONG_LONG].size
+  SIZEOF_ULONG_LONG  = Fiddle::FFIBackend::FFITypes[Types::ULONG_LONG].size
+  SIZEOF_INT8_T      = Fiddle::FFIBackend::FFITypes[Types::INT8_T].size
+  SIZEOF_UINT8_T     = Fiddle::FFIBackend::FFITypes[Types::UINT8_T].size
+  SIZEOF_INT16_T     = Fiddle::FFIBackend::FFITypes[Types::INT16_T].size
+  SIZEOF_UINT16_T    = Fiddle::FFIBackend::FFITypes[Types::UINT16_T].size
+  SIZEOF_INT32_T     = Fiddle::FFIBackend::FFITypes[Types::INT32_T].size
+  SIZEOF_UINT32_T    = Fiddle::FFIBackend::FFITypes[Types::UINT32_T].size
+  SIZEOF_INT64_T     = Fiddle::FFIBackend::FFITypes[Types::INT64_T].size
+  SIZEOF_UINT64_T    = Fiddle::FFIBackend::FFITypes[Types::UINT64_T].size
+  SIZEOF_FLOAT       = Fiddle::FFIBackend::FFITypes[Types::FLOAT].size
+  SIZEOF_DOUBLE      = Fiddle::FFIBackend::FFITypes[Types::DOUBLE].size
+  SIZEOF_BOOL        = Fiddle::FFIBackend::FFITypes[Types::BOOL].size
+  SIZEOF_SIZE_T      = Fiddle::FFIBackend::FFITypes[Types::SIZE_T].size
   SIZEOF_SSIZE_T     = SIZEOF_SIZE_T
-  SIZEOF_PTRDIFF_T   = Fiddle::JRuby::FFITypes[Types::PTRDIFF_T].size
-  SIZEOF_INTPTR_T    = Fiddle::JRuby::FFITypes[Types::INTPTR_T].size
-  SIZEOF_UINTPTR_T   = Fiddle::JRuby::FFITypes[Types::UINTPTR_T].size
-  SIZEOF_CONST_STRING = Fiddle::JRuby::FFITypes[Types::VOIDP].size
+  SIZEOF_PTRDIFF_T   = Fiddle::FFIBackend::FFITypes[Types::PTRDIFF_T].size
+  SIZEOF_INTPTR_T    = Fiddle::FFIBackend::FFITypes[Types::INTPTR_T].size
+  SIZEOF_UINTPTR_T   = Fiddle::FFIBackend::FFITypes[Types::UINTPTR_T].size
+  SIZEOF_CONST_STRING = Fiddle::FFIBackend::FFITypes[Types::VOIDP].size
 end
diff --git a/ext/fiddle/lib/fiddle/ruby.rb b/ext/fiddle/lib/fiddle/ruby.rb
deleted file mode 100644
index ee5a9a937979c6..00000000000000
--- a/ext/fiddle/lib/fiddle/ruby.rb
+++ /dev/null
@@ -1 +0,0 @@
-require "fiddle.so"
diff --git a/ext/fiddle/lib/fiddle/version.rb b/ext/fiddle/lib/fiddle/version.rb
index 3444e24f926a2a..ad7a9655d393b0 100644
--- a/ext/fiddle/lib/fiddle/version.rb
+++ b/ext/fiddle/lib/fiddle/version.rb
@@ -1,3 +1,3 @@
 module Fiddle
-  VERSION = "1.1.3.dev"
+  VERSION = "1.1.4.dev"
 end
diff --git a/ext/fiddle/memory_view.c b/ext/fiddle/memory_view.c
index fa66fc2c7b26d1..5fd7b9b408fe25 100644
--- a/ext/fiddle/memory_view.c
+++ b/ext/fiddle/memory_view.c
@@ -64,8 +64,13 @@ fiddle_memview_memsize(const void *ptr)
 }
 
 static const rb_data_type_t fiddle_memview_data_type = {
-    "fiddle/memory_view",
-    {fiddle_memview_mark, fiddle_memview_free, fiddle_memview_memsize,},
+    .wrap_struct_name = "fiddle/memory_view",
+    .function = {
+        .dmark = fiddle_memview_mark,
+        .dfree = fiddle_memview_free,
+        .dsize = fiddle_memview_memsize,
+    },
+    .flags = FIDDLE_DEFAULT_TYPED_DATA_FLAGS,
 };
 
 static VALUE
diff --git a/ext/fiddle/pinned.c b/ext/fiddle/pinned.c
index 019a3020e2647e..94962b0ff6a9ed 100644
--- a/ext/fiddle/pinned.c
+++ b/ext/fiddle/pinned.c
@@ -24,9 +24,13 @@ pinned_memsize(const void *ptr)
 }
 
 static const rb_data_type_t pinned_data_type = {
-    "fiddle/pinned",
-    {pinned_mark, xfree, pinned_memsize, },
-    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+    .wrap_struct_name = "fiddle/pinned",
+    .function = {
+        .dmark = pinned_mark,
+        .dfree = RUBY_TYPED_DEFAULT_FREE,
+        .dsize = pinned_memsize,
+    },
+    .flags = FIDDLE_DEFAULT_TYPED_DATA_FLAGS,
 };
 
 static VALUE
diff --git a/ext/fiddle/pointer.c b/ext/fiddle/pointer.c
index 5c375fe9d2f08c..00bd76e9b2f107 100644
--- a/ext/fiddle/pointer.c
+++ b/ext/fiddle/pointer.c
@@ -94,7 +94,7 @@ static const rb_data_type_t fiddle_ptr_data_type = {
         .dfree = fiddle_ptr_free,
         .dsize = fiddle_ptr_memsize,
     },
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+    .flags = FIDDLE_DEFAULT_TYPED_DATA_FLAGS,
 };
 
 #ifdef HAVE_RUBY_MEMORY_VIEW_H
diff --git a/lib/rdoc/generator/darkfish.rb b/lib/rdoc/generator/darkfish.rb
index 96bb4fb66f39f0..5709fabf810206 100644
--- a/lib/rdoc/generator/darkfish.rb
+++ b/lib/rdoc/generator/darkfish.rb
@@ -780,4 +780,19 @@ def template_for file, page = true, klass = ERB
     template
   end
 
+  # Returns an excerpt of the content for usage in meta description tags
+  def excerpt(content)
+    text = content.is_a?(RDoc::Comment) ? content.text : content
+
+    # Match from a capital letter to the first period, discarding any links, so
+    # that we don't end up matching badges in the README
+    first_paragraph_match = text.match(/[A-Z][^\.:\/]+\./)
+    return text[0...150].gsub(/\n/, " ").squeeze(" ") unless first_paragraph_match
+
+    extracted_text = first_paragraph_match[0]
+    second_paragraph = first_paragraph_match.post_match.match(/[A-Z][^\.:\/]+\./)
+    extracted_text << " " << second_paragraph[0] if second_paragraph
+
+    extracted_text[0...150].gsub(/\n/, " ").squeeze(" ")
+  end
 end
diff --git a/lib/rdoc/generator/template/darkfish/_head.rhtml b/lib/rdoc/generator/template/darkfish/_head.rhtml
index 69649ad3b53736..9e6fb4f94ca90c 100644
--- a/lib/rdoc/generator/template/darkfish/_head.rhtml
+++ b/lib/rdoc/generator/template/darkfish/_head.rhtml
@@ -3,6 +3,28 @@
 
 <title><%= h @title %></title>
 
+<%- if defined?(klass) -%>
+  <meta name="keywords" content="ruby,<%= h "#{klass.type},#{klass.full_name}" %>">
+
+  <%- if klass.comment.empty? -%>
+    <meta name="description" content="Documentation for the <%= h "#{klass.full_name} #{klass.type}" %>">
+  <%- else -%>
+    <meta name="description" content="<%= h "#{klass.type} #{klass.full_name}: #{excerpt(klass.comment)}" %>">
+  <%- end -%>
+<%- elsif defined?(file) -%>
+  <meta name="keywords" content="ruby,documentation,<%= h file.page_name %>">
+  <meta name="description" content="<%= h "#{file.page_name}: #{excerpt(file.comment)}" %>">
+<%- elsif @title -%>
+  <meta name="keywords" content="ruby,documentation,<%= h @title %>">
+
+  <%- if @options.main_page and
+      main_page = @files.find { |f| f.full_name == @options.main_page } then %>
+    <meta name="description" content="<%= h "#{@title}: #{excerpt(main_page.comment)}" %>">
+  <%- else -%>
+    <meta name="description" content="Documentation for <%= h @title %>">
+  <%- end -%>
+<%- end -%>
+
 <script type="text/javascript">
   var rdoc_rel_prefix = "<%= h asset_rel_prefix %>/";
   var index_rel_prefix = "<%= h rel_prefix %>/";
diff --git a/lib/yaml/dbm.rb b/lib/yaml/dbm.rb
index e2508cd74b38c1..a3cbaeccf66256 100644
--- a/lib/yaml/dbm.rb
+++ b/lib/yaml/dbm.rb
@@ -1,6 +1,10 @@
 # frozen_string_literal: false
 require 'yaml'
-require 'dbm'
+
+begin
+  require 'dbm'
+rescue LoadError
+end
 
 module YAML
 
@@ -16,7 +20,6 @@ module YAML
 #
 # See the documentation for ::DBM and ::YAML for more information.
 class DBM < ::DBM
-    VERSION = "0.1" # :nodoc:
 
     # :call-seq:
     #   ydbm[key] -> value
@@ -56,7 +59,13 @@ def []=( key, val )
     def fetch( keystr, ifnone = nil )
         begin
             val = super( keystr )
-            return YAML.load( val ) if String === val
+            if String === val
+                if YAML.respond_to?(:safe_load)
+                    return YAML.safe_load( val )
+                else
+                    return YAML.load( val )
+                end
+            end
         rescue IndexError
         end
         if block_given?
@@ -102,7 +111,11 @@ def values_at( *keys )
     def delete( key )
         v = super( key )
         if String === v
-            v = YAML.load( v )
+            if YAML.respond_to?(:safe_load)
+                v = YAML.safe_load( v )
+            else
+                v = YAML.load( v )
+            end
         end
         v
     end
@@ -149,7 +162,7 @@ def each_pair # :yields: [key, value]
     #
     # Returns +self+.
     def each_value # :yields: value
-        super { |v| yield YAML.load( v ) }
+        super { |v| yield YAML.respond_to?(:safe_load) ? YAML.safe_load( v ) : YAML.load( v ) }
         self
     end
 
@@ -158,7 +171,7 @@ def each_value # :yields: value
     #
     # Returns an array of values from the database.
     def values
-        super.collect { |v| YAML.load( v ) }
+        super.collect { |v| YAML.respond_to?(:safe_load) ? YAML.safe_load( v ) : YAML.load( v ) }
     end
 
     # :call-seq:
@@ -204,7 +217,9 @@ def replace( hsh )
     # The order in which values are removed/returned is not guaranteed.
     def shift
         a = super
-        a[1] = YAML.load( a[1] ) if a
+        if a
+          a[1] = YAML.respond_to?(:safe_load) ? YAML.safe_load( a[1] ) : YAML.load( a[1] )
+        end
         a
     end
 
@@ -277,4 +292,4 @@ def to_hash
     alias :each :each_pair
 end
 
-end
+end if defined?(DBM)
diff --git a/lib/yaml/store.rb b/lib/yaml/store.rb
index f24e4ad332d7da..27c823b9f936f1 100644
--- a/lib/yaml/store.rb
+++ b/lib/yaml/store.rb
@@ -69,8 +69,16 @@ def dump(table)
   end
 
   def load(content)
-    table = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(content) : YAML.load(content)
-    if table == false
+    table =  if YAML.respond_to?(:safe_load)
+      if Psych::VERSION >= "3.1"
+        YAML.safe_load(content, permitted_classes: [Symbol])
+      else
+        YAML.safe_load(content, [Symbol])
+      end
+    else
+      YAML.load(content)
+    end
+    if table == false || table == nil
       {}
     else
       table
diff --git a/test/fiddle/helper.rb b/test/fiddle/helper.rb
index 9dfe381a201e17..457e02f59514a8 100644
--- a/test/fiddle/helper.rb
+++ b/test/fiddle/helper.rb
@@ -183,11 +183,20 @@ def teardown
       end
     end
 
+    def ffi_backend?
+      RUBY_ENGINE != 'ruby'
+    end
+
     def under_gc_stress
       stress, GC.stress = GC.stress, true
       yield
     ensure
       GC.stress = stress
     end
+
+    def assert_ractor_shareable(object)
+      Ractor.make_shareable(object)
+      assert_operator(Ractor, :shareable?, object)
+    end
   end
 end
diff --git a/test/fiddle/test_closure.rb b/test/fiddle/test_closure.rb
index 787a9b635a37a4..26cff8e516b319 100644
--- a/test/fiddle/test_closure.rb
+++ b/test/fiddle/test_closure.rb
@@ -58,9 +58,9 @@ def call thing
     end
 
     def test_const_string
-      if RUBY_ENGINE == "jruby"
+      if ffi_backend?
         omit("Closure with :const_string works but " +
-             "Function with :const_string doesn't work with JRuby")
+             "Function with :const_string doesn't work with FFI backend")
       end
 
       closure_class = Class.new(Closure) do
@@ -119,9 +119,14 @@ def test_memsize_ruby_dev_42480
       end
 
       require 'objspace'
+      closure_class = Class.new(Closure) do
+        def call
+          10
+        end
+      end
       n = 10000
       n.times do
-        Closure.create(:int, [:void]) do |closure|
+        closure_class.create(:int, [:void]) do |closure|
           ObjectSpace.memsize_of(closure)
         end
       end
@@ -152,5 +157,17 @@ def test_memsize_ruby_dev_42480
         end
       end
     end
+
+    def test_ractor_shareable
+      omit("Need Ractor") unless defined?(Ractor)
+      closure_class = Class.new(Closure) do
+        def call
+          0
+        end
+      end
+      closure_class.create(:int, [:void]) do |c|
+        assert_ractor_shareable(c)
+      end
+    end
   end
 end if defined?(Fiddle)
diff --git a/test/fiddle/test_fiddle.rb b/test/fiddle/test_fiddle.rb
index b247ae15cb9c84..28ae922171bb52 100644
--- a/test/fiddle/test_fiddle.rb
+++ b/test/fiddle/test_fiddle.rb
@@ -6,8 +6,8 @@
 
 class TestFiddle < Fiddle::TestCase
   def test_nil_true_etc
-    if RUBY_ENGINE == "jruby"
-      omit("Fiddle::Q* aren't supported with JRuby")
+    if ffi_backend?
+      omit("Fiddle::Q* aren't supported with FFI backend")
     end
 
     assert_equal Fiddle::Qtrue, Fiddle.dlwrap(true)
@@ -30,6 +30,10 @@ def test_dlopen_linker_script_input_linux
     if Dir.glob("/usr/lib/*/libncurses.so").empty?
       omit("libncurses.so is needed")
     end
+    if ffi_backend?
+      omit("Fiddle::Handle#file_name doesn't exist in FFI backend")
+    end
+
     # libncurses.so uses INPUT() on Debian GNU/Linux
     # $ cat /usr/lib/x86_64-linux-gnu/libncurses.so
     # INPUT(libncurses.so.6 -ltinfo)
@@ -44,6 +48,10 @@ def test_dlopen_linker_script_input_linux
 
   def test_dlopen_linker_script_group_linux
     omit("This is only for Linux") unless RUBY_PLATFORM.match?("linux")
+    if ffi_backend?
+      omit("Fiddle::Handle#file_name doesn't exist in FFI backend")
+    end
+
     # libc.so uses GROUP() on Debian GNU/Linux
     # $ cat /usr/lib/x86_64-linux-gnu/libc.so
     # /* GNU ld script
diff --git a/test/fiddle/test_func.rb b/test/fiddle/test_func.rb
index 5d69cc5f11ad3d..ca503f92ad8c46 100644
--- a/test/fiddle/test_func.rb
+++ b/test/fiddle/test_func.rb
@@ -64,6 +64,10 @@ def test_strtod
     end
 
     def test_qsort1
+      if RUBY_ENGINE == "jruby"
+        omit("The untouched sanity check is broken on JRuby: https://github.com/jruby/jruby/issues/8365")
+      end
+
       closure_class = Class.new(Closure) do
         def call(x, y)
           Pointer.new(x)[0] <=> Pointer.new(y)[0]
@@ -74,27 +78,32 @@ def call(x, y)
         qsort = Function.new(@libc['qsort'],
                              [TYPE_VOIDP, TYPE_SIZE_T, TYPE_SIZE_T, TYPE_VOIDP],
                              TYPE_VOID)
-        buff = "9341"
+        untouched = "9341"
+        buff = +"9341"
         qsort.call(buff, buff.size, 1, callback)
         assert_equal("1349", buff)
 
         bug4929 = '[ruby-core:37395]'
-        buff = "9341"
+        buff = +"9341"
         under_gc_stress do
           qsort.call(buff, buff.size, 1, callback)
         end
         assert_equal("1349", buff, bug4929)
+
+        # Ensure the test didn't mutate String literals
+        assert_equal("93" + "41", untouched)
       end
     ensure
       # We can't use ObjectSpace with JRuby.
-      return if RUBY_ENGINE == "jruby"
-      # Ensure freeing all closures.
-      # See https://github.com/ruby/fiddle/issues/102#issuecomment-1241763091 .
-      not_freed_closures = []
-      ObjectSpace.each_object(Fiddle::Closure) do |closure|
-        not_freed_closures << closure unless closure.freed?
+      unless RUBY_ENGINE == "jruby"
+        # Ensure freeing all closures.
+        # See https://github.com/ruby/fiddle/issues/102#issuecomment-1241763091 .
+        not_freed_closures = []
+        ObjectSpace.each_object(Fiddle::Closure) do |closure|
+          not_freed_closures << closure unless closure.freed?
+        end
+        assert_equal([], not_freed_closures)
       end
-      assert_equal([], not_freed_closures)
     end
 
     def test_snprintf
diff --git a/test/fiddle/test_function.rb b/test/fiddle/test_function.rb
index b6ae8c14bcb514..6ec40bee06cd58 100644
--- a/test/fiddle/test_function.rb
+++ b/test/fiddle/test_function.rb
@@ -41,6 +41,9 @@ def test_need_gvl?
       if RUBY_ENGINE == "jruby"
         omit("rb_str_dup() doesn't exist in JRuby")
       end
+      if RUBY_ENGINE == "truffleruby"
+        omit("rb_str_dup() doesn't work with TruffleRuby")
+      end
 
       libruby = Fiddle.dlopen(nil)
       rb_str_dup = Function.new(libruby['rb_str_dup'],
@@ -109,8 +112,8 @@ def call one
     end
 
     def test_last_error
-      if RUBY_ENGINE == "jruby"
-        omit("Fiddle.last_error doesn't work with JRuby")
+      if ffi_backend?
+        omit("Fiddle.last_error doesn't work with FFI backend")
       end
 
       func = Function.new(@libc['strcpy'], [TYPE_VOIDP, TYPE_VOIDP], TYPE_VOIDP)
@@ -219,6 +222,9 @@ def test_no_memory_leak
       if RUBY_ENGINE == "jruby"
         omit("rb_obj_frozen_p() doesn't exist in JRuby")
       end
+      if RUBY_ENGINE == "truffleruby"
+        omit("memory leak detection is fragile with TruffleRuby")
+      end
 
       if respond_to?(:assert_nothing_leaked_memory)
         rb_obj_frozen_p_symbol = Fiddle.dlopen(nil)["rb_obj_frozen_p"]
@@ -253,6 +259,11 @@ def test_no_memory_leak
       end
     end
 
+    def test_ractor_shareable
+      omit("Need Ractor") unless defined?(Ractor)
+      assert_ractor_shareable(Function.new(@libm['sin'], [TYPE_DOUBLE], TYPE_DOUBLE))
+    end
+
     private
 
     def perror(m)
diff --git a/test/fiddle/test_handle.rb b/test/fiddle/test_handle.rb
index c952a7ef17f80c..e0ad17a9cb41fc 100644
--- a/test/fiddle/test_handle.rb
+++ b/test/fiddle/test_handle.rb
@@ -9,8 +9,8 @@ class TestHandle < TestCase
     include Fiddle
 
     def test_to_i
-      if RUBY_ENGINE == "jruby"
-        omit("Fiddle::Handle#to_i is unavailable with JRuby")
+      if ffi_backend?
+        omit("Fiddle::Handle#to_i is unavailable with FFI backend")
       end
 
       handle = Fiddle::Handle.new(LIBC_SO)
@@ -18,8 +18,8 @@ def test_to_i
     end
 
     def test_to_ptr
-      if RUBY_ENGINE == "jruby"
-        omit("Fiddle::Handle#to_i is unavailable with JRuby")
+      if ffi_backend?
+        omit("Fiddle::Handle#to_i is unavailable with FFI backend")
       end
 
       handle = Fiddle::Handle.new(LIBC_SO)
@@ -34,8 +34,8 @@ def test_static_sym_unknown
     end
 
     def test_static_sym
-      if RUBY_ENGINE == "jruby"
-        omit("We can't assume static symbols with JRuby")
+      if ffi_backend?
+        omit("We can't assume static symbols with FFI backend")
       end
 
       begin
@@ -133,8 +133,8 @@ def test_disable_close
     end
 
     def test_file_name
-      if RUBY_ENGINE == "jruby"
-        omit("Fiddle::Handle#file_name doesn't exist in JRuby")
+      if ffi_backend?
+        omit("Fiddle::Handle#file_name doesn't exist in FFI backend")
       end
 
       file_name = Handle.new(LIBC_SO).file_name
@@ -155,8 +155,8 @@ def test_file_name
     end
 
     def test_NEXT
-      if RUBY_ENGINE == "jruby"
-        omit("Fiddle::Handle::NEXT doesn't exist in JRuby")
+      if ffi_backend?
+        omit("Fiddle::Handle::NEXT doesn't exist in FFI backend")
       end
 
       begin
@@ -226,5 +226,10 @@ def test_fallback_to_ansi
         assert_equal(ansi, k["GetFileAttributes"], "should fallback to ANSI version")
       end
     end
+
+    def test_ractor_shareable
+      omit("Need Ractor") unless defined?(Ractor)
+      assert_ractor_shareable(Fiddle::Handle.new(LIBC_SO))
+    end
   end
 end if defined?(Fiddle)
diff --git a/test/fiddle/test_import.rb b/test/fiddle/test_import.rb
index 26190325ecdfeb..79b65d97f52386 100644
--- a/test/fiddle/test_import.rb
+++ b/test/fiddle/test_import.rb
@@ -154,8 +154,8 @@ def test_unsigned_result()
     end
 
     def test_io()
-      if RUBY_ENGINE == "jruby"
-        omit("BUILD_RUBY_PLATFORM doesn't exist in JRuby")
+      if ffi_backend?
+        omit("BUILD_RUBY_PLATFORM doesn't exist in FFI backend")
       end
 
       if( RUBY_PLATFORM != BUILD_RUBY_PLATFORM ) || !defined?(LIBC.fprintf)
diff --git a/test/fiddle/test_memory_view.rb b/test/fiddle/test_memory_view.rb
index d44c42d2394528..da00d66c91b2b4 100644
--- a/test/fiddle/test_memory_view.rb
+++ b/test/fiddle/test_memory_view.rb
@@ -159,5 +159,17 @@ def test_to_s
         mview.release
       end
     end
+
+    def test_ractor_shareable
+      omit("Need Ractor") unless defined?(Ractor)
+      ptr = Pointer["hello world"]
+      mview = MemoryView.new(ptr)
+      begin
+        assert_ractor_shareable(mview)
+        assert_predicate(ptr, :frozen?)
+      ensure
+        mview.release
+      end
+    end
   end
 end
diff --git a/test/fiddle/test_pinned.rb b/test/fiddle/test_pinned.rb
index f0d375b1cc5895..ad132579b00a05 100644
--- a/test/fiddle/test_pinned.rb
+++ b/test/fiddle/test_pinned.rb
@@ -23,6 +23,12 @@ def test_clear
       end
       assert_match "called on", ex.message
     end
+
+    def test_ractor_shareable
+      omit("Need Ractor") unless defined?(Ractor)
+      obj = Object.new
+      assert_ractor_shareable(Pinned.new(obj))
+      assert_predicate(obj, :frozen?)
+    end
   end
 end
-
diff --git a/test/fiddle/test_pointer.rb b/test/fiddle/test_pointer.rb
index f17c8338f5e6cc..d46fb662bafadb 100644
--- a/test/fiddle/test_pointer.rb
+++ b/test/fiddle/test_pointer.rb
@@ -11,8 +11,8 @@ def dlwrap arg
     end
 
     def test_can_read_write_memory
-      if RUBY_ENGINE == "jruby"
-        omit("Fiddle::Pointer.{read,write} don't exist in JRuby")
+      if ffi_backend?
+        omit("Fiddle::Pointer.{read,write} don't exist in FFI backend")
       end
 
       # Allocate some memory
@@ -113,8 +113,8 @@ def test_plus
     end
 
     def test_inspect
-      if RUBY_ENGINE == "jruby"
-        omit("Fiddle::Pointer#inspect is incompatible on JRuby")
+      if ffi_backend?
+        omit("Fiddle::Pointer#inspect is incompatible with FFI backend")
       end
 
       ptr = Pointer.new(0)
@@ -132,8 +132,8 @@ def test_to_ptr_string
     end
 
     def test_to_ptr_io
-      if RUBY_ENGINE == "jruby"
-        omit("Fiddle::Pointer.to_ptr(IO) isn't supported with JRuby")
+      if ffi_backend?
+        omit("Fiddle::Pointer.to_ptr(IO) isn't supported with FFI backend")
       end
 
       Pointer.malloc(10, Fiddle::RUBY_FREE) do |buf|
@@ -183,8 +183,8 @@ def test_cmp
     end
 
     def test_ref_ptr
-      if RUBY_ENGINE == "jruby"
-        omit("Fiddle.dlwrap([]) isn't supported with JRuby")
+      if ffi_backend?
+        omit("Fiddle.dlwrap([]) isn't supported with FFI backend")
       end
 
       ary = [0,1,2,4,5]
@@ -195,8 +195,8 @@ def test_ref_ptr
     end
 
     def test_to_value
-      if RUBY_ENGINE == "jruby"
-        omit("Fiddle.dlwrap([]) isn't supported with JRuby")
+      if ffi_backend?
+        omit("Fiddle.dlwrap([]) isn't supported with FFI backend")
       end
 
       ary = [0,1,2,4,5]
@@ -305,5 +305,13 @@ def test_null_pointer
       assert_raise(DLError) {nullpo[0]}
       assert_raise(DLError) {nullpo[0] = 1}
     end
+
+    def test_ractor_shareable
+      omit("Need Ractor") unless defined?(Ractor)
+      assert_ractor_shareable(Fiddle::NULL)
+      ary = [0, 1, 2, 4, 5]
+      addr = Pointer.new(dlwrap(ary))
+      assert_ractor_shareable(addr)
+    end
   end
 end if defined?(Fiddle)
diff --git a/test/json/json_generator_test.rb b/test/json/json_generator_test.rb
index fd70b02699a4ab..2436fa0627d841 100755
--- a/test/json/json_generator_test.rb
+++ b/test/json/json_generator_test.rb
@@ -446,6 +446,15 @@ def test_invalid_encoding_string
   end
 
   if defined?(JSON::Ext::Generator) and RUBY_PLATFORM != "java"
+    def test_valid_utf8_in_different_encoding
+      utf8_string = "€™"
+      wrong_encoding_string = utf8_string.b
+      # This behavior is historical. Not necessary desirable. We should deprecated it.
+      # The pure and java version of the gem already don't behave this way.
+      assert_equal utf8_string.to_json, wrong_encoding_string.to_json
+      assert_equal JSON.dump(utf8_string), JSON.dump(wrong_encoding_string)
+    end
+
     def test_string_ext_included_calls_super
       included = false
 
diff --git a/test/json/ractor_test.rb b/test/json/ractor_test.rb
index ba9bf7a7f6d8a7..36196ed23db7d7 100644
--- a/test/json/ractor_test.rb
+++ b/test/json/ractor_test.rb
@@ -9,7 +9,7 @@
 
 class JSONInRactorTest < Test::Unit::TestCase
   def test_generate
-    assert_separately([], "#{<<~"begin;"}\n#{<<~'end;'}")
+    assert_separately([], "#{<<~"begin;"}\n#{<<~'end;'}", ignore_stderr: true)
     begin;
       $VERBOSE = nil
       require "json"
diff --git a/test/json/test_helper.rb b/test/json/test_helper.rb
index 446c020e8fbf03..4955a02c9dde31 100644
--- a/test/json/test_helper.rb
+++ b/test/json/test_helper.rb
@@ -1,12 +1,12 @@
 case ENV['JSON']
 when 'pure'
-  $:.unshift File.join(__dir__, '../lib')
+  $:.unshift File.join(__dir__, '../../lib')
   require 'json/pure'
 when 'ext'
-  $:.unshift File.join(__dir__, '../ext'), File.join(__dir__, '../lib')
+  $:.unshift File.join(__dir__, '../../ext'), File.join(__dir__, '../../lib')
   require 'json/ext'
 else
-  $:.unshift File.join(__dir__, '../ext'), File.join(__dir__, '../lib')
+  $:.unshift File.join(__dir__, '../../ext'), File.join(__dir__, '../../lib')
   require 'json'
 end
 
@@ -15,3 +15,8 @@
   require 'byebug'
 rescue LoadError
 end
+
+unless defined?(Test::Unit::CoreAssertions)
+  require "core_assertions"
+  Test::Unit::TestCase.include Test::Unit::CoreAssertions
+end
diff --git a/test/rdoc/test_rdoc_generator_darkfish.rb b/test/rdoc/test_rdoc_generator_darkfish.rb
index 899e697de649ac..f6c0a1e1cf18aa 100644
--- a/test/rdoc/test_rdoc_generator_darkfish.rb
+++ b/test/rdoc/test_rdoc_generator_darkfish.rb
@@ -322,6 +322,51 @@ def test_title_escape
     assert_main_title(File.binread('index.html'), title)
   end
 
+  def test_meta_tags_for_index
+    @options.title = "My awesome Ruby project"
+    @g.generate
+
+    content = File.binread("index.html")
+
+    assert_include(content, '<meta name="keywords" content="ruby,documentation,My awesome Ruby project">')
+    assert_include(content, '<meta name="description" content="Documentation for My awesome Ruby project">')
+  end
+
+  def test_meta_tags_for_classes
+    top_level = @store.add_file("file.rb")
+    top_level.add_class(@klass.class, @klass.name)
+    inner = @klass.add_class(RDoc::NormalClass, "Inner")
+    inner.add_comment("This is a normal class. It is fully documented.", top_level)
+
+    @g.generate
+
+    content = File.binread("Klass/Inner.html")
+    assert_include(content, '<meta name="keywords" content="ruby,class,Klass::Inner">')
+    assert_include(
+      content,
+      '<meta name="description" content="class Klass::Inner: This is a normal class. It is fully documented.">',
+    )
+  end
+
+  def test_meta_tags_for_pages
+    top_level = @store.add_file("CONTRIBUTING.rdoc", parser: RDoc::Parser::Simple)
+    top_level.comment = <<~RDOC
+      = Contributing
+
+      Here are the instructions for contributing. Begin by installing Ruby.
+    RDOC
+
+    @g.generate
+
+    content = File.binread("CONTRIBUTING_rdoc.html")
+    assert_include(content, '<meta name="keywords" content="ruby,documentation,CONTRIBUTING">')
+    assert_include(
+      content,
+      "<meta name=\"description\" content=\"CONTRIBUTING: Contributing Here are the instructions for contributing." \
+      " Begin by installing Ruby.\">",
+    )
+  end
+
   ##
   # Asserts that +filename+ has a link count greater than 1 if hard links to
   # @tmpdir are supported.
diff --git a/test/ruby/test_yjit.rb b/test/ruby/test_yjit.rb
index c91d6312560ec6..5f0a5035b0a4fc 100644
--- a/test/ruby/test_yjit.rb
+++ b/test/ruby/test_yjit.rb
@@ -1150,6 +1150,8 @@ def test_code_gc_with_many_iseqs
   end
 
   def test_code_gc_with_auto_compact
+    omit "compaction is not supported on this platform" unless GC.respond_to?(:compact)
+
     assert_compiles((code_gc_helpers + <<~'RUBY'), exits: :any, result: :ok, mem_size: 1, code_gc: true)
       # Test ISEQ moves in the middle of code GC
       GC.auto_compact = true
@@ -1278,6 +1280,8 @@ def foo(_, a, b, c)
   end
 
   def test_gc_compact_cyclic_branch
+    omit "compaction is not supported on this platform" unless GC.respond_to?(:compact)
+
     assert_compiles(<<~'RUBY', result: 2)
       def foo
         i = 0
diff --git a/test/yaml/test_dbm.rb b/test/yaml/test_dbm.rb
new file mode 100644
index 00000000000000..cf50256298174c
--- /dev/null
+++ b/test/yaml/test_dbm.rb
@@ -0,0 +1,46 @@
+require "test/unit"
+require "yaml/dbm"
+
+class TestYAMLDBM < Test::Unit::TestCase
+  def setup
+    @dbm = YAML::DBM.new("test")
+  end
+
+  def teardown
+    @dbm.close
+    File.unlink("test.db")
+  end
+
+  def test_fetch
+    @dbm["key"] = "value"
+    assert_equal "value", @dbm["key"]
+    assert_equal "value", @dbm.fetch("key")
+  end
+
+  def test_delete
+    @dbm["key"] = "value"
+    assert_equal "value", @dbm.delete("key")
+    assert_nil @dbm["key"]
+  end
+
+  def test_each_value
+    @dbm["key1"] = "value1"
+    @dbm["key2"] = "value2"
+    @dbm.each_value do |value|
+      assert_match(/value[12]/, value)
+    end
+  end
+
+  def test_values
+    @dbm["key1"] = "value1"
+    @dbm["key2"] = "value2"
+    @dbm.values.each do |value|
+      assert_match(/value[12]/, value)
+    end
+  end
+
+  def test_shift
+    @dbm["key"] = "value"
+    assert_equal ["key", "value"], @dbm.shift
+  end
+end if defined?(YAML::DBM)
diff --git a/tool/sync_default_gems.rb b/tool/sync_default_gems.rb
index a7ad331c999894..9fca49ad170d2d 100755
--- a/tool/sync_default_gems.rb
+++ b/tool/sync_default_gems.rb
@@ -192,7 +192,7 @@ def sync_default_gems(gem)
     when "json"
       rm_rf(%w[ext/json test/json])
       cp_r("#{upstream}/ext/json/ext", "ext/json")
-      cp_r("#{upstream}/tests", "test/json")
+      cp_r("#{upstream}/test/json", "test/json")
       rm_rf("test/json/lib")
       cp_r("#{upstream}/lib", "ext/json")
       cp_r("#{upstream}/json.gemspec", "ext/json")
diff --git a/vm_args.c b/vm_args.c
index 0ecdc31a316d21..28f685d7dd53bd 100644
--- a/vm_args.c
+++ b/vm_args.c
@@ -1177,7 +1177,7 @@ vm_caller_setup_fwd_args(const rb_execution_context_t *ec, rb_control_frame_t *r
 
     *adjusted_ci = VM_CI_ON_STACK(
             site_mid,
-            (caller_flag | (site_flag & (VM_CALL_FCALL | VM_CALL_FORWARDING))),
+            ((caller_flag & ~VM_CALL_ARGS_SIMPLE) | (site_flag & (VM_CALL_FCALL | VM_CALL_FORWARDING))),
             site_argc + caller_argc,
             kw
             );