diff --git a/.github/composite/godot-itest/action.yml b/.github/composite/godot-itest/action.yml
index 8775c2a9f..347df15b5 100644
--- a/.github/composite/godot-itest/action.yml
+++ b/.github/composite/godot-itest/action.yml
@@ -142,7 +142,7 @@ runs:
           targetArgs="--target $TARGET"
         fi
         
-        cargo build -p itest ${{ inputs.rust-extra-args }} $targetArgs
+        cargo build -p itest --no-default-features ${{ inputs.rust-extra-args }} $targetArgs
         
         # Instead of modifying .gdextension, rename the output directory
         if [[ -n "$TARGET" ]]; then
diff --git a/.github/workflows/full-ci.yml b/.github/workflows/full-ci.yml
index d9ce9a14f..31979c50b 100644
--- a/.github/workflows/full-ci.yml
+++ b/.github/workflows/full-ci.yml
@@ -310,7 +310,7 @@ jobs:
             os: ubuntu-20.04
             artifact-name: linux-nightly
             godot-binary: godot.linuxbsd.editor.dev.x86_64
-            rust-extra-args: --features godot/__codegen-full
+            rust-extra-args: --features itest/codegen-full
             with-hot-reload: true
 
           # Combines now a lot of features, but should be OK. lazy-function-tables doesn't work with experimental-threads.
@@ -318,7 +318,7 @@ jobs:
             os: ubuntu-20.04
             artifact-name: linux-double-nightly
             godot-binary: godot.linuxbsd.editor.dev.double.x86_64
-            rust-extra-args: --features godot/api-custom,godot/double-precision,godot/__codegen-full,godot/lazy-function-tables
+            rust-extra-args: --features godot/api-custom,godot/double-precision,itest/codegen-full,godot/lazy-function-tables
 
           - name: linux-features-experimental
             os: ubuntu-20.04
diff --git a/.github/workflows/minimal-ci.yml b/.github/workflows/minimal-ci.yml
index 5d7b8e458..767f380eb 100644
--- a/.github/workflows/minimal-ci.yml
+++ b/.github/workflows/minimal-ci.yml
@@ -157,7 +157,7 @@ jobs:
             os: ubuntu-20.04
             artifact-name: linux-nightly
             godot-binary: godot.linuxbsd.editor.dev.x86_64
-            rust-extra-args: --features godot/__codegen-full
+            rust-extra-args: --features itest/codegen-full
             with-hot-reload: true
 
           - name: linux-features-experimental
diff --git a/check.sh b/check.sh
index 9c96f8f92..27585e1da 100755
--- a/check.sh
+++ b/check.sh
@@ -127,7 +127,7 @@ function cmd_fmt() {
 }
 
 function cmd_clippy() {
-    run cargo clippy --all-targets "${extraCargoArgs[@]}" -- \
+    run cargo clippy --all-targets "${extraCargoArgs[@]}" --features "itest/codegen-full" -- \
         -D clippy::suspicious \
         -D clippy::style \
         -D clippy::complexity \
@@ -139,7 +139,7 @@ function cmd_clippy() {
 }
 
 function cmd_klippy() {
-    run cargo clippy --fix --all-targets "${extraCargoArgs[@]}" -- \
+    run cargo clippy --fix --all-targets "${extraCargoArgs[@]}" --features "itest/codegen-full" -- \
         -D clippy::suspicious \
         -D clippy::style \
         -D clippy::complexity \
diff --git a/godot-codegen/src/generator/builtins.rs b/godot-codegen/src/generator/builtins.rs
index 4d393ea44..5006b2546 100644
--- a/godot-codegen/src/generator/builtins.rs
+++ b/godot-codegen/src/generator/builtins.rs
@@ -250,6 +250,7 @@ fn make_builtin_method_definition(
             receiver,
             varcall_invocation,
             ptrcall_invocation,
+            is_virtual_required: false,
         },
         safety_doc,
         &TokenStream::new(),
diff --git a/godot-codegen/src/generator/classes.rs b/godot-codegen/src/generator/classes.rs
index 63a53d669..fce892200 100644
--- a/godot-codegen/src/generator/classes.rs
+++ b/godot-codegen/src/generator/classes.rs
@@ -535,6 +535,7 @@ fn make_class_method_definition(
             receiver,
             varcall_invocation,
             ptrcall_invocation,
+            is_virtual_required: false,
         },
         None,
         cfg_attributes,
diff --git a/godot-codegen/src/generator/functions_common.rs b/godot-codegen/src/generator/functions_common.rs
index abc9dfb42..5ad33e3a1 100644
--- a/godot-codegen/src/generator/functions_common.rs
+++ b/godot-codegen/src/generator/functions_common.rs
@@ -37,6 +37,7 @@ pub struct FnCode {
     pub receiver: FnReceiver,
     pub varcall_invocation: TokenStream,
     pub ptrcall_invocation: TokenStream,
+    pub is_virtual_required: bool,
 }
 
 pub struct FnDefinition {
@@ -150,6 +151,11 @@ pub fn make_function_definition(
     };
 
     let return_decl = &sig.return_value().decl;
+    let fn_body = if code.is_virtual_required {
+        quote! { ; }
+    } else {
+        quote! { { unimplemented!() } }
+    };
 
     let receiver_param = &code.receiver.param;
     let primary_function = if sig.is_virtual() {
@@ -160,9 +166,7 @@ pub fn make_function_definition(
             #maybe_unsafe fn #primary_fn_name(
                 #receiver_param
                 #( #params, )*
-            ) #return_decl {
-                unimplemented!()
-            }
+            ) #return_decl #fn_body
         }
     } else if sig.is_vararg() {
         // Varargs (usually varcall, but not necessarily -- utilities use ptrcall)
diff --git a/godot-codegen/src/generator/utility_functions.rs b/godot-codegen/src/generator/utility_functions.rs
index 6e6dcab14..d778c0e23 100644
--- a/godot-codegen/src/generator/utility_functions.rs
+++ b/godot-codegen/src/generator/utility_functions.rs
@@ -70,6 +70,7 @@ pub(crate) fn make_utility_function_definition(function: &UtilityFunction) -> To
             receiver: FnReceiver::global_function(),
             varcall_invocation,
             ptrcall_invocation,
+            is_virtual_required: false,
         },
         None,
         &TokenStream::new(),
diff --git a/godot-codegen/src/generator/virtual_traits.rs b/godot-codegen/src/generator/virtual_traits.rs
index e98844059..82c470e30 100644
--- a/godot-codegen/src/generator/virtual_traits.rs
+++ b/godot-codegen/src/generator/virtual_traits.rs
@@ -154,6 +154,7 @@ fn make_virtual_method(method: &ClassMethod) -> Option<TokenStream> {
             // make_return() requests following args, but they are not used for virtual methods. We can provide empty streams.
             varcall_invocation: TokenStream::new(),
             ptrcall_invocation: TokenStream::new(),
+            is_virtual_required: method.is_virtual_required(),
         },
         None,
         &TokenStream::new(),
diff --git a/godot-codegen/src/models/domain.rs b/godot-codegen/src/models/domain.rs
index 51918de85..101b83637 100644
--- a/godot-codegen/src/models/domain.rs
+++ b/godot-codegen/src/models/domain.rs
@@ -280,6 +280,7 @@ pub struct FunctionCommon {
     pub return_value: FnReturn,
     pub is_vararg: bool,
     pub is_private: bool,
+    pub is_virtual_required: bool,
     pub direction: FnDirection,
 }
 
@@ -314,6 +315,10 @@ pub trait Function: fmt::Display {
     fn direction(&self) -> FnDirection {
         self.common().direction
     }
+
+    fn is_virtual_required(&self) -> bool {
+        self.common().is_virtual_required
+    }
 }
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/godot-codegen/src/models/domain_mapping.rs b/godot-codegen/src/models/domain_mapping.rs
index b4160394a..9e3869c26 100644
--- a/godot-codegen/src/models/domain_mapping.rs
+++ b/godot-codegen/src/models/domain_mapping.rs
@@ -358,6 +358,7 @@ impl BuiltinMethod {
                 return_value: FnReturn::new(&return_value, ctx),
                 is_vararg: method.is_vararg,
                 is_private: special_cases::is_method_private(builtin_name, &method.name),
+                is_virtual_required: false,
                 direction: FnDirection::Outbound {
                     hash: method.hash.expect("hash absent for builtin method"),
                 },
@@ -463,6 +464,10 @@ impl ClassMethod {
                 return_value: FnReturn::new(&method.return_value, ctx),
                 is_vararg: method.is_vararg,
                 is_private,
+                is_virtual_required: special_cases::is_virtual_method_required(
+                    &class_name.rust_ty.to_string(),
+                    rust_method_name,
+                ),
                 direction,
             },
             qualifier,
@@ -511,6 +516,7 @@ impl UtilityFunction {
                 return_value: FnReturn::new(&return_value, ctx),
                 is_vararg: function.is_vararg,
                 is_private: false,
+                is_virtual_required: false,
                 direction: FnDirection::Outbound {
                     hash: function.hash,
                 },
diff --git a/godot-codegen/src/special_cases/special_cases.rs b/godot-codegen/src/special_cases/special_cases.rs
index 98756e3ac..55f48f47d 100644
--- a/godot-codegen/src/special_cases/special_cases.rs
+++ b/godot-codegen/src/special_cases/special_cases.rs
@@ -336,6 +336,190 @@ pub fn get_interface_extra_docs(trait_name: &str) -> Option<&'static str> {
     }
 }
 
+pub fn is_virtual_method_required(class_name: &str, method: &str) -> bool {
+    match (class_name, method) {
+        ("ScriptLanguageExtension", _) => method != "get_doc_comment_delimiters",
+
+        ("ScriptExtension", "editor_can_reload_from_file")
+        | ("ScriptExtension", "can_instantiate")
+        | ("ScriptExtension", "get_base_script")
+        | ("ScriptExtension", "get_global_name")
+        | ("ScriptExtension", "inherits_script")
+        | ("ScriptExtension", "get_instance_base_type")
+        | ("ScriptExtension", "instance_create")
+        | ("ScriptExtension", "placeholder_instance_create")
+        | ("ScriptExtension", "instance_has")
+        | ("ScriptExtension", "has_source_code")
+        | ("ScriptExtension", "get_source_code")
+        | ("ScriptExtension", "set_source_code")
+        | ("ScriptExtension", "reload")
+        | ("ScriptExtension", "get_documentation")
+        | ("ScriptExtension", "has_method")
+        | ("ScriptExtension", "has_static_method")
+        | ("ScriptExtension", "get_method_info")
+        | ("ScriptExtension", "is_tool")
+        | ("ScriptExtension", "is_valid")
+        | ("ScriptExtension", "get_language")
+        | ("ScriptExtension", "has_script_signal")
+        | ("ScriptExtension", "get_script_signal_list")
+        | ("ScriptExtension", "has_property_default_value")
+        | ("ScriptExtension", "get_property_default_value")
+        | ("ScriptExtension", "update_exports")
+        | ("ScriptExtension", "get_script_method_list")
+        | ("ScriptExtension", "get_script_property_list")
+        | ("ScriptExtension", "get_member_line")
+        | ("ScriptExtension", "get_constants")
+        | ("ScriptExtension", "get_members")
+        | ("ScriptExtension", "is_placeholder_fallback_enabled")
+        | ("ScriptExtension", "get_rpc_config")
+        | ("EditorExportPlugin", "customize_resource")
+        | ("EditorExportPlugin", "customize_scene")
+        | ("EditorExportPlugin", "get_customization_configuration_hash")
+        | ("EditorExportPlugin", "get_name")
+        | ("EditorVcsInterface", _)
+        | ("MovieWriter", _)
+        | ("TextServerExtension", "has_feature")
+        | ("TextServerExtension", "get_name")
+        | ("TextServerExtension", "get_features")
+        | ("TextServerExtension", "free_rid")
+        | ("TextServerExtension", "has")
+        | ("TextServerExtension", "create_font")
+        | ("TextServerExtension", "font_set_fixed_size")
+        | ("TextServerExtension", "font_get_fixed_size")
+        | ("TextServerExtension", "font_set_fixed_size_scale_mode")
+        | ("TextServerExtension", "font_get_fixed_size_scale_mode")
+        | ("TextServerExtension", "font_get_size_cache_list")
+        | ("TextServerExtension", "font_clear_size_cache")
+        | ("TextServerExtension", "font_remove_size_cache")
+        | ("TextServerExtension", "font_set_ascent")
+        | ("TextServerExtension", "font_get_ascent")
+        | ("TextServerExtension", "font_set_descent")
+        | ("TextServerExtension", "font_get_descent")
+        | ("TextServerExtension", "font_set_underline_position")
+        | ("TextServerExtension", "font_get_underline_position")
+        | ("TextServerExtension", "font_set_underline_thickness")
+        | ("TextServerExtension", "font_get_underline_thickness")
+        | ("TextServerExtension", "font_set_scale")
+        | ("TextServerExtension", "font_get_scale")
+        | ("TextServerExtension", "font_get_texture_count")
+        | ("TextServerExtension", "font_clear_textures")
+        | ("TextServerExtension", "font_remove_texture")
+        | ("TextServerExtension", "font_set_texture_image")
+        | ("TextServerExtension", "font_get_texture_image")
+        | ("TextServerExtension", "font_get_glyph_list")
+        | ("TextServerExtension", "font_clear_glyphs")
+        | ("TextServerExtension", "font_remove_glyph")
+        | ("TextServerExtension", "font_get_glyph_advance")
+        | ("TextServerExtension", "font_set_glyph_advance")
+        | ("TextServerExtension", "font_get_glyph_offset")
+        | ("TextServerExtension", "font_set_glyph_offset")
+        | ("TextServerExtension", "font_get_glyph_size")
+        | ("TextServerExtension", "font_set_glyph_size")
+        | ("TextServerExtension", "font_get_glyph_uv_rect")
+        | ("TextServerExtension", "font_set_glyph_uv_rect")
+        | ("TextServerExtension", "font_get_glyph_texture_idx")
+        | ("TextServerExtension", "font_set_glyph_texture_idx")
+        | ("TextServerExtension", "font_get_glyph_texture_rid")
+        | ("TextServerExtension", "font_get_glyph_texture_size")
+        | ("TextServerExtension", "font_get_glyph_index")
+        | ("TextServerExtension", "font_get_char_from_glyph_index")
+        | ("TextServerExtension", "font_has_char")
+        | ("TextServerExtension", "font_get_supported_chars")
+        | ("TextServerExtension", "font_draw_glyph")
+        | ("TextServerExtension", "font_draw_glyph_outline")
+        | ("TextServerExtension", "create_shaped_text")
+        | ("TextServerExtension", "shaped_text_clear")
+        | ("TextServerExtension", "shaped_text_add_string")
+        | ("TextServerExtension", "shaped_text_add_object")
+        | ("TextServerExtension", "shaped_text_resize_object")
+        | ("TextServerExtension", "shaped_get_span_count")
+        | ("TextServerExtension", "shaped_get_span_meta")
+        | ("TextServerExtension", "shaped_set_span_update_font")
+        | ("TextServerExtension", "shaped_text_substr")
+        | ("TextServerExtension", "shaped_text_get_parent")
+        | ("TextServerExtension", "shaped_text_shape")
+        | ("TextServerExtension", "shaped_text_is_ready")
+        | ("TextServerExtension", "shaped_text_get_glyphs")
+        | ("TextServerExtension", "shaped_text_sort_logical")
+        | ("TextServerExtension", "shaped_text_get_glyph_count")
+        | ("TextServerExtension", "shaped_text_get_range")
+        | ("TextServerExtension", "shaped_text_get_trim_pos")
+        | ("TextServerExtension", "shaped_text_get_ellipsis_pos")
+        | ("TextServerExtension", "shaped_text_get_ellipsis_glyphs")
+        | ("TextServerExtension", "shaped_text_get_ellipsis_glyph_count")
+        | ("TextServerExtension", "shaped_text_get_objects")
+        | ("TextServerExtension", "shaped_text_get_object_rect")
+        | ("TextServerExtension", "shaped_text_get_object_range")
+        | ("TextServerExtension", "shaped_text_get_object_glyph")
+        | ("TextServerExtension", "shaped_text_get_size")
+        | ("TextServerExtension", "shaped_text_get_ascent")
+        | ("TextServerExtension", "shaped_text_get_descent")
+        | ("TextServerExtension", "shaped_text_get_width")
+        | ("TextServerExtension", "shaped_text_get_underline_position")
+        | ("TextServerExtension", "shaped_text_get_underline_thickness")
+        | ("AudioStreamPlayback", "mix")
+        | ("AudioStreamPlaybackResampled", "mix_resampled")
+        | ("AudioStreamPlaybackResampled", "get_stream_sampling_rate")
+        | ("AudioEffectInstance", "process")
+        | ("AudioEffect", "instantiate")
+        | ("PhysicsDirectBodyState2DExtension", _)
+        | ("PhysicsDirectBodyState3DExtension", _)
+        | ("PhysicsDirectSpaceState2DExtension", _)
+        | ("PhysicsDirectSpaceState3DExtension", _)
+        | ("PhysicsServer3DExtension", _)
+        | ("PhysicsServer2DExtension", _)
+        | ("EditorScript", "run")
+        | ("VideoStreamPlayback", "update")
+        | ("EditorFileSystemImportFormatSupportQuery", _)
+        | ("Mesh", _)
+        | ("Texture2D", "get_width")
+        | ("Texture2D", "get_height")
+        | ("Texture3D", _)
+        | ("TextureLayered", _)
+        | ("StyleBox", "draw")
+        | ("Material", "get_shader_rid")
+        | ("Material", "get_shader_mode")
+        | ("PacketPeerExtension", "get_available_packet_count")
+        | ("PacketPeerExtension", "get_max_packet_size")
+        | ("StreamPeerExtension", "get_available_bytes")
+        | ("WebRtcDataChannelExtension", "poll")
+        | ("WebRtcDataChannelExtension", "close")
+        | ("WebRtcDataChannelExtension", "set_write_mode")
+        | ("WebRtcDataChannelExtension", "get_write_mode")
+        | ("WebRtcDataChannelExtension", "was_string_packet")
+        | ("WebRtcDataChannelExtension", "get_ready_state")
+        | ("WebRtcDataChannelExtension", "get_label")
+        | ("WebRtcDataChannelExtension", "is_ordered")
+        | ("WebRtcDataChannelExtension", "get_id")
+        | ("WebRtcDataChannelExtension", "get_max_packet_life_time")
+        | ("WebRtcDataChannelExtension", "get_max_retransmits")
+        | ("WebRtcDataChannelExtension", "get_protocol")
+        | ("WebRtcDataChannelExtension", "is_negotiated")
+        | ("WebRtcDataChannelExtension", "get_buffered_amount")
+        | ("WebRtcDataChannelExtension", "get_available_packet_count")
+        | ("WebRtcDataChannelExtension", "get_max_packet_size")
+        | ("WebRtcPeerConnectionExtension", _)
+        | ("MultiplayerPeerExtension", "get_available_packet_count")
+        | ("MultiplayerPeerExtension", "get_max_packet_size")
+        | ("MultiplayerPeerExtension", "set_transfer_channel")
+        | ("MultiplayerPeerExtension", "get_transfer_channel")
+        | ("MultiplayerPeerExtension", "set_transfer_mode")
+        | ("MultiplayerPeerExtension", "get_transfer_mode")
+        | ("MultiplayerPeerExtension", "set_target_peer")
+        | ("MultiplayerPeerExtension", "get_packet_peer")
+        | ("MultiplayerPeerExtension", "get_packet_mode")
+        | ("MultiplayerPeerExtension", "get_packet_channel")
+        | ("MultiplayerPeerExtension", "is_server")
+        | ("MultiplayerPeerExtension", "poll")
+        | ("MultiplayerPeerExtension", "close")
+        | ("MultiplayerPeerExtension", "disconnect_peer")
+        | ("MultiplayerPeerExtension", "get_unique_id")
+        | ("MultiplayerPeerExtension", "get_connection_status") => true,
+
+        (_, _) => false,
+    }
+}
+
 #[rustfmt::skip]
 pub fn is_class_level_server(class_name: &str) -> bool {
     // Unclear on if some of these classes should be registered earlier than `Scene`:
diff --git a/godot-core/src/obj/script.rs b/godot-core/src/obj/script.rs
index d1ec14319..7e85f2844 100644
--- a/godot-core/src/obj/script.rs
+++ b/godot-core/src/obj/script.rs
@@ -84,6 +84,37 @@ use self::bounded_ptr_list::BoundedPtrList;
 ///         // through create_script_instance().
 ///         create_script_instance(script_instance)
 ///     }
+///   # fn can_instantiate(&self) -> bool { unreachable!() }
+///   # fn editor_can_reload_from_file(&mut self) -> bool { unreachable!() }
+///   # fn get_base_script(&self) -> Option<Gd<Script>> { unreachable!() }
+///   # fn get_global_name(&self) -> StringName { unreachable!() }
+///   # fn inherits_script(&self, _script: Gd<Script>) -> bool { unreachable!() }
+///   # fn get_instance_base_type(&self) -> StringName { unreachable!() }
+///   # unsafe fn placeholder_instance_create(&self, _for_object: Gd<Object>) -> *mut c_void { unreachable!() }
+///   # fn instance_has(&self, _object: Gd<Object>) -> bool { unreachable!() }
+///   # fn has_source_code(&self) -> bool { unreachable!() }
+///   # fn get_source_code(&self) -> GString { unreachable!() }
+///   # fn set_source_code(&mut self, _code: GString) { unreachable!() }
+///   # fn reload(&mut self, _keep_state: bool) -> Error { unreachable!() }
+///   # fn get_documentation(&self) -> Array<Dictionary> { unreachable!() }
+///   # fn has_method(&self, _method: StringName) -> bool { unreachable!() }
+///   # fn has_static_method(&self, _method: StringName) -> bool { unreachable!() }
+///   # fn get_method_info(&self, _method: StringName) -> Dictionary { unreachable!() }
+///   # fn is_tool(&self) -> bool { unreachable!() }
+///   # fn is_valid(&self) -> bool { unreachable!() }
+///   # fn get_language(&self) -> Option<Gd<ScriptLanguage>> { unreachable!() }
+///   # fn has_script_signal(&self, _signall: StringName) -> bool { unreachable!() }
+///   # fn get_script_signal_list(&self) -> Array<Dictionary> { unreachable!() }
+///   # fn has_property_default_value(&self, _property: StringName) -> bool { unreachable!() }
+///   # fn get_property_default_value(&self, _property: StringName) -> Variant { unreachable!() }
+///   # fn update_exports(&mut self) { unreachable!() }
+///   # fn get_script_method_list(&self) -> Array<Dictionary> { unreachable!() }
+///   # fn get_script_property_list(&self) -> Array<Dictionary> { unreachable!() }
+///   # fn get_member_line(&self, _member: StringName) -> i32 { unreachable!() }
+///   # fn get_constants(&self) -> godot::prelude::Dictionary { unreachable!() }
+///   # fn get_members(&self) -> godot::prelude::Array<StringName> { unreachable!() }
+///   # fn is_placeholder_fallback_enabled(&self) -> bool { unreachable!() }
+///   # fn get_rpc_config(&self) -> Variant { unreachable!() }
 /// }
 /// ```
 pub trait ScriptInstance: Sized {
diff --git a/itest/rust/Cargo.toml b/itest/rust/Cargo.toml
index b7a3d90f4..34ed60d3d 100644
--- a/itest/rust/Cargo.toml
+++ b/itest/rust/Cargo.toml
@@ -10,8 +10,9 @@ publish = false
 crate-type = ["cdylib"]
 
 [features]
-default = []
-codegen-full-experimental = ["godot/__codegen-full", "godot/experimental-godot-api"]
+default = ["codegen-full"]
+codegen-full = ["godot/__codegen-full"]
+codegen-full-experimental = ["codegen-full", "godot/experimental-godot-api"]
 experimental-threads = ["godot/experimental-threads"]
 register-docs = ["godot/register-docs"] # TODO remove as soon as constant_test.rs checks bitfields with #[constant] proc-macro
 serde = ["dep:serde", "dep:serde_json", "godot/serde"]
diff --git a/itest/rust/src/builtin_tests/script/script_instance_tests.rs b/itest/rust/src/builtin_tests/script/script_instance_tests.rs
index 8061fad9d..cbb5f35a5 100644
--- a/itest/rust/src/builtin_tests/script/script_instance_tests.rs
+++ b/itest/rust/src/builtin_tests/script/script_instance_tests.rs
@@ -7,9 +7,9 @@
 
 use std::ffi::c_void;
 
-use godot::builtin::{GString, StringName, Variant, VariantType};
+use godot::builtin::{Array, Dictionary, GString, StringName, Variant, VariantType};
 use godot::classes::{IScriptExtension, Object, Script, ScriptExtension, ScriptLanguage};
-use godot::global::MethodFlags;
+use godot::global::{Error, MethodFlags};
 use godot::meta::{ClassName, FromGodot, MethodInfo, PropertyInfo, ToGodot};
 use godot::obj::script::{create_script_instance, ScriptInstance, SiMut};
 use godot::obj::{Base, Gd, WithBaseField};
@@ -22,6 +22,7 @@ struct TestScript {
     base: Base<ScriptExtension>,
 }
 
+#[rustfmt::skip]
 #[godot_api]
 impl IScriptExtension for TestScript {
     fn can_instantiate(&self) -> bool {
@@ -31,6 +32,38 @@ impl IScriptExtension for TestScript {
     unsafe fn instance_create(&self, for_object: Gd<Object>) -> *mut c_void {
         create_script_instance(TestScriptInstance::new(self.to_gd().upcast()), for_object)
     }
+
+    fn editor_can_reload_from_file(&mut self) -> bool { unreachable!() }
+    fn get_base_script(&self) -> Option<Gd<Script>> { unreachable!() }
+    fn get_global_name(&self) -> StringName { unreachable!() }
+    fn inherits_script(&self, _script: Gd<Script>) -> bool { unreachable!() }
+    fn get_instance_base_type(&self) -> StringName { unreachable!() }
+    unsafe fn placeholder_instance_create(&self, _for_object: Gd<Object>) -> *mut c_void { unreachable!() }
+    fn instance_has(&self, _object: Gd<Object>) -> bool { unreachable!() }
+    fn has_source_code(&self) -> bool { unreachable!() }
+    fn get_source_code(&self) -> GString { unreachable!() }
+    fn set_source_code(&mut self, _code: GString) { unreachable!() }
+    fn reload(&mut self, _keep_state: bool) -> Error { unreachable!() }
+    fn get_documentation(&self) -> Array<Dictionary> { unreachable!() }
+    fn has_method(&self, _method: StringName) -> bool { unreachable!() }
+    #[cfg(since_api = "4.2")]
+    fn has_static_method(&self, _method: StringName) -> bool { unreachable!() }
+    fn get_method_info(&self, _method: StringName) -> Dictionary { unreachable!() }
+    fn is_tool(&self) -> bool { unreachable!() }
+    fn is_valid(&self) -> bool { unreachable!() }
+    fn get_language(&self) -> Option<Gd<ScriptLanguage>> { unreachable!() }
+    fn has_script_signal(&self, _signall: StringName) -> bool { unreachable!() }
+    fn get_script_signal_list(&self) -> Array<Dictionary> { unreachable!() }
+    fn has_property_default_value(&self, _property: StringName) -> bool { unreachable!() }
+    fn get_property_default_value(&self, _property: StringName) -> Variant { unreachable!() }
+    fn update_exports(&mut self) { unreachable!() }
+    fn get_script_method_list(&self) -> Array<Dictionary> { unreachable!() }
+    fn get_script_property_list(&self) -> Array<Dictionary> { unreachable!() }
+    fn get_member_line(&self, _member: StringName) -> i32 { unreachable!() }
+    fn get_constants(&self) -> godot::prelude::Dictionary { unreachable!() }
+    fn get_members(&self) -> godot::prelude::Array<StringName> { unreachable!() }
+    fn is_placeholder_fallback_enabled(&self) -> bool { unreachable!() }
+    fn get_rpc_config(&self) -> Variant { unreachable!() }
 }
 
 struct TestScriptInstance {
diff --git a/itest/rust/src/engine_tests/mod.rs b/itest/rust/src/engine_tests/mod.rs
index acaac3d98..f991a0e93 100644
--- a/itest/rust/src/engine_tests/mod.rs
+++ b/itest/rust/src/engine_tests/mod.rs
@@ -8,6 +8,8 @@
 mod codegen_enums_test;
 mod codegen_test;
 mod gfile_test;
+#[cfg(all(feature = "experimental-threads", feature = "codegen-full"))]
+mod native_audio_structures_test;
 mod native_structures_test;
 mod node_test;
 mod save_load_test;
diff --git a/itest/rust/src/engine_tests/native_audio_structures_test.rs b/itest/rust/src/engine_tests/native_audio_structures_test.rs
new file mode 100644
index 000000000..bcf29e6a0
--- /dev/null
+++ b/itest/rust/src/engine_tests/native_audio_structures_test.rs
@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) godot-rust; Bromeon and contributors.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+use std::thread;
+use std::time::Duration;
+
+use godot::builtin::Vector2;
+use godot::classes::native::AudioFrame;
+use godot::classes::{
+    AudioEffect, AudioEffectInstance, AudioServer, AudioStreamGenerator,
+    AudioStreamGeneratorPlayback, AudioStreamPlayer, Engine, IAudioEffect, IAudioEffectInstance,
+    SceneTree,
+};
+use godot::global::godot_print;
+use godot::obj::{Base, Gd, NewAlloc, NewGd};
+use godot::register::{godot_api, GodotClass};
+
+use crate::framework::itest;
+
+#[derive(GodotClass)]
+#[class(base = AudioEffect, init)]
+struct AudioEffectReceiver {
+    base: Base<AudioEffect>,
+}
+
+#[godot_api]
+impl IAudioEffect for AudioEffectReceiver {
+    fn instantiate(&mut self) -> Option<Gd<AudioEffectInstance>> {
+        Some(AudioEffectReceiverInstance::new_gd().upcast())
+    }
+}
+
+#[derive(GodotClass)]
+#[class(base = AudioEffectInstance, init)]
+struct AudioEffectReceiverInstance {
+    was_called: bool,
+    base: Base<AudioEffectInstance>,
+}
+
+#[godot_api]
+impl IAudioEffectInstance for AudioEffectReceiverInstance {
+    unsafe fn process(
+        &mut self,
+        _src_buffer: *const std::ffi::c_void,
+        dst_buffer: *mut AudioFrame,
+        _frame_count: i32,
+    ) {
+        (*dst_buffer).left = 15.0;
+        (*dst_buffer).right = -12.0;
+        self.was_called = true;
+    }
+}
+
+#[derive(GodotClass)]
+#[class(base = AudioEffect, init)]
+struct AudioEffectAsserter {
+    base: Base<AudioEffect>,
+}
+
+#[godot_api]
+impl IAudioEffect for AudioEffectAsserter {
+    fn instantiate(&mut self) -> Option<Gd<AudioEffectInstance>> {
+        Some(AudioEffectAsserterInstance::new_gd().upcast())
+    }
+}
+
+#[derive(GodotClass)]
+#[class(base = AudioEffectInstance, init)]
+struct AudioEffectAsserterInstance {
+    was_called: bool,
+    base: Base<AudioEffectInstance>,
+}
+
+#[godot_api]
+impl IAudioEffectInstance for AudioEffectAsserterInstance {
+    unsafe fn process(
+        &mut self,
+        src_buffer: *const std::ffi::c_void,
+        _dst_buffer: *mut AudioFrame,
+        _frame_count: i32,
+    ) {
+        let src = src_buffer as *const AudioFrame;
+
+        assert_eq!((*src).left, 15.0);
+        assert_eq!((*src).right, -12.0);
+
+        self.was_called = true;
+    }
+}
+
+#[itest]
+fn native_audio_structure_out_parameter() {
+    // create two audio effects: one that writes to the out parameter and one that reads the incomming parameter.
+    let receiver = AudioEffectReceiver::new_gd();
+    let asserter = AudioEffectAsserter::new_gd();
+
+    let mut audio_server = AudioServer::singleton();
+
+    // add both effects to the audio bus so they get called during audio processing.
+    audio_server.add_bus_effect(0, receiver.clone().upcast::<AudioEffect>());
+    audio_server.add_bus_effect(0, asserter.clone().upcast::<AudioEffect>());
+
+    let generator = AudioStreamGenerator::new_gd();
+    let mut player = AudioStreamPlayer::new_alloc();
+
+    let tree = Engine::singleton()
+        .get_main_loop()
+        .unwrap()
+        .cast::<SceneTree>();
+
+    tree.get_root().unwrap().add_child(player.clone());
+
+    player.set_stream(generator);
+    // start playback so we can push audio frames through the audio pipeline.
+    player.play();
+
+    let mut playback = player
+        .get_stream_playback()
+        .unwrap()
+        .cast::<AudioStreamGeneratorPlayback>();
+
+    let length = playback.get_frames_available();
+    godot_print!("can push {} frames", length);
+
+    if length == 0 {
+        panic!("must be able to push at least one frame!");
+    }
+
+    // create dummy audio frame
+    playback.push_frame(Vector2::ONE);
+    thread::sleep(Duration::from_secs(1));
+
+    // verify that both audio effects were called.
+    let receiver_instance = AudioServer::singleton()
+        .get_bus_effect_instance(0, 0)
+        .unwrap()
+        .cast::<AudioEffectReceiverInstance>();
+    let asserter_instance = AudioServer::singleton()
+        .get_bus_effect_instance(0, 1)
+        .unwrap()
+        .cast::<AudioEffectAsserterInstance>();
+
+    assert!(receiver_instance.bind().was_called);
+    assert!(asserter_instance.bind().was_called);
+
+    player.get_parent().unwrap().remove_child(player.clone());
+    player.free();
+}
diff --git a/itest/rust/src/engine_tests/native_structures_test.rs b/itest/rust/src/engine_tests/native_structures_test.rs
index 1b9e5d84f..a56587890 100644
--- a/itest/rust/src/engine_tests/native_structures_test.rs
+++ b/itest/rust/src/engine_tests/native_structures_test.rs
@@ -7,22 +7,56 @@
 
 use crate::framework::itest;
 
-use godot::builtin::{Rect2, Rid, Variant};
+use godot::builtin::{Dictionary, Rect2, Rid};
 use godot::classes::native::{
     AudioFrame, CaretInfo, Glyph, ObjectId, PhysicsServer2DExtensionShapeResult,
 };
 use godot::classes::text_server::Direction;
-use godot::classes::{ITextServerExtension, Node3D, RefCounted, TextServer, TextServerExtension};
+use godot::classes::{IRefCounted, Node3D, RefCounted};
+use godot::meta::ToGodot;
 use godot::obj::{Base, NewAlloc, NewGd};
 use godot::register::{godot_api, GodotClass};
 
-use std::cell::Cell;
-
-#[derive(GodotClass)]
-#[class(base=TextServerExtension)]
-pub struct TestTextServer {
+#[derive(GodotClass, Debug)]
+#[class(base = RefCounted)]
+struct NativeStructTests {
     glyphs: [Glyph; 2],
-    cell: Cell<Option<(Rid, i64)>>,
+}
+
+#[godot_api]
+impl IRefCounted for NativeStructTests {
+    fn init(_base: Base<Self::Base>) -> Self {
+        Self {
+            glyphs: [sample_glyph(99), sample_glyph(700)],
+        }
+    }
+}
+
+#[godot_api]
+impl NativeStructTests {
+    #[func]
+    fn pass_native_struct(&self, caret_info: *const CaretInfo) -> Dictionary {
+        let CaretInfo {
+            leading_caret,
+            trailing_caret,
+            leading_direction,
+            trailing_direction,
+        } = unsafe { &*caret_info };
+
+        let mut result = Dictionary::new();
+
+        result.set("leading_caret", *leading_caret);
+        result.set("trailing_caret", *trailing_caret);
+        result.set("leading_direction", *leading_direction);
+        result.set("trailing_direction", *trailing_direction);
+
+        result
+    }
+
+    #[func]
+    fn native_struct_array_ret(&self) -> *const Glyph {
+        self.glyphs.as_ptr()
+    }
 }
 
 // Simple function to make these up with one field differing.
@@ -42,36 +76,6 @@ fn sample_glyph(start: i32) -> Glyph {
     }
 }
 
-#[godot_api]
-impl ITextServerExtension for TestTextServer {
-    fn init(_base: Base<TextServerExtension>) -> Self {
-        TestTextServer {
-            glyphs: [sample_glyph(99), sample_glyph(700)],
-            cell: Cell::new(None),
-        }
-    }
-
-    unsafe fn shaped_text_get_carets(&self, shaped: Rid, position: i64, caret: *mut CaretInfo) {
-        // Record the arguments we were called with.
-        self.cell.set(Some((shaped, position)));
-        // Now put something in the out param.
-        *caret = CaretInfo {
-            leading_caret: Rect2::from_components(0.0, 0.0, 0.0, 0.0),
-            trailing_caret: Rect2::from_components(1.0, 1.0, 1.0, 1.0),
-            leading_direction: Direction::AUTO,
-            trailing_direction: Direction::LTR,
-        };
-    }
-
-    fn shaped_text_get_glyph_count(&self, _shaped: Rid) -> i64 {
-        self.glyphs.len() as i64
-    }
-
-    unsafe fn shaped_text_get_glyphs(&self, _shaped: Rid) -> *const Glyph {
-        self.glyphs.as_ptr()
-    }
-}
-
 #[itest]
 fn native_structure_codegen() {
     // Test construction of a few simple types.
@@ -95,52 +99,49 @@ fn native_structure_codegen() {
 }
 
 #[itest]
-fn native_structure_out_parameter() {
-    // Instantiate a TextServerExtension and then have Godot call a
-    // function which uses an 'out' pointer parameter.
-    let mut ext = TestTextServer::new_gd();
-    let result = ext
-        .clone()
-        .upcast::<TextServer>()
-        .shaped_text_get_carets(Rid::new(100), 200);
-
-    // Check that we called the virtual function.
-    let cell = ext.bind_mut().cell.take();
-    assert_eq!(cell, Some((Rid::new(100), 200)));
-
-    // Check the result dictionary (Godot made it out of our 'out'
-    // param).
+fn native_structure_parameter() {
+    let caret = CaretInfo {
+        leading_caret: Rect2::from_components(0.0, 0.0, 0.0, 0.0),
+        trailing_caret: Rect2::from_components(1.0, 1.0, 1.0, 1.0),
+        leading_direction: Direction::AUTO,
+        trailing_direction: Direction::LTR,
+    };
+
+    let ptr: *const _ = &caret;
+    let mut object = NativeStructTests::new_gd();
+    let result: Dictionary = object
+        .call("pass_native_struct".into(), &[ptr.to_variant()])
+        .to();
+
     assert_eq!(
-        result.get("leading_rect"),
-        Some(Variant::from(Rect2::from_components(0.0, 0.0, 0.0, 0.0)))
+        result.get("leading_caret").unwrap().to::<Rect2>(),
+        caret.leading_caret
     );
     assert_eq!(
-        result.get("trailing_rect"),
-        Some(Variant::from(Rect2::from_components(1.0, 1.0, 1.0, 1.0)))
+        result.get("trailing_caret").unwrap().to::<Rect2>(),
+        caret.trailing_caret
     );
     assert_eq!(
-        result.get("leading_direction"),
-        Some(Variant::from(Direction::AUTO))
+        result.get("leading_direction").unwrap().to::<Direction>(),
+        caret.leading_direction
     );
     assert_eq!(
-        result.get("trailing_direction"),
-        Some(Variant::from(Direction::LTR))
+        result.get("trailing_direction").unwrap().to::<Direction>(),
+        caret.trailing_direction
     );
 }
 
 #[itest]
 fn native_structure_pointer_to_array_parameter() {
-    // Instantiate a TextServerExtension.
-    let ext = TestTextServer::new_gd();
-    let result = ext
-        .clone()
-        .upcast::<TextServer>()
-        .shaped_text_get_glyphs(Rid::new(100));
+    // Instantiate a custom class.
+    let mut object = NativeStructTests::new_gd();
+    let result_ptr: *const Glyph = object.call("native_struct_array_ret".into(), &[]).to();
+    let result = unsafe { std::slice::from_raw_parts(result_ptr, 2) };
 
     // Check the result array.
     assert_eq!(result.len(), 2);
-    assert_eq!(result.at(0).get("start"), Some(Variant::from(99)));
-    assert_eq!(result.at(1).get("start"), Some(Variant::from(700)));
+    assert_eq!(result.first().unwrap().start, 99);
+    assert_eq!(result.get(1).unwrap().start, 700);
 }
 
 #[itest]
diff --git a/itest/rust/src/object_tests/virtual_methods_test.rs b/itest/rust/src/object_tests/virtual_methods_test.rs
index b0e78eceb..0f0bba42a 100644
--- a/itest/rust/src/object_tests/virtual_methods_test.rs
+++ b/itest/rust/src/object_tests/virtual_methods_test.rs
@@ -16,6 +16,8 @@ use godot::builtin::{
 };
 use godot::classes::notify::NodeNotification;
 use godot::classes::resource_loader::CacheMode;
+#[cfg(feature = "codegen-full")]
+use godot::classes::Material;
 use godot::classes::{
     BoxMesh, INode, INode2D, IPrimitiveMesh, IRefCounted, IResourceFormatLoader, IRigidBody2D,
     InputEvent, InputEventAction, Node, Node2D, PrimitiveMesh, RefCounted, ResourceFormatLoader,
@@ -121,6 +123,7 @@ struct VirtualReturnTest {
     base: Base<PrimitiveMesh>,
 }
 
+#[rustfmt::skip]
 #[godot_api]
 impl IPrimitiveMesh for VirtualReturnTest {
     fn create_mesh_array(&self) -> VariantArray {
@@ -140,6 +143,23 @@ impl IPrimitiveMesh for VirtualReturnTest {
             PackedInt32Array::from_iter([0]),
         ]
     }
+
+    fn get_surface_count(&self) -> i32 { unreachable!() }
+    fn surface_get_array_len(&self, _index: i32) -> i32 { unreachable!() }
+    fn surface_get_array_index_len(&self, _index: i32) -> i32 { unreachable!() }
+    fn surface_get_arrays(&self, _index: i32) -> VariantArray { unreachable!() }
+    fn surface_get_blend_shape_arrays(&self, _index: i32) -> godot::prelude::Array<VariantArray> { unreachable!() }
+    fn surface_get_lods(&self, _index: i32) -> godot::prelude::Dictionary { unreachable!() }
+    fn surface_get_format(&self, _index: i32) -> u32 { unreachable!() }
+    fn surface_get_primitive_type(&self, _index: i32) -> u32 { unreachable!() }
+    #[cfg(feature = "codegen-full")]
+    fn surface_set_material(&mut self, _index: i32, _material: Gd<Material>) { unreachable!() }
+    #[cfg(feature = "codegen-full")]
+    fn surface_get_material(&self, _index: i32) -> Option<Gd<Material>> { unreachable!() }
+    fn get_blend_shape_count(&self) -> i32 { unreachable!() }
+    fn get_blend_shape_name(&self, _index: i32) -> StringName { unreachable!() }
+    fn set_blend_shape_name(&mut self, _index: i32, _namee: StringName) { unreachable!() }
+    fn get_aabb(&self) -> godot::prelude::Aabb { unreachable!() }
 }
 
 #[derive(GodotClass, Debug)]
diff --git a/itest/rust/src/register_tests/keyword_parameters_test.rs b/itest/rust/src/register_tests/keyword_parameters_test.rs
index 5ef272604..60f69c1f9 100644
--- a/itest/rust/src/register_tests/keyword_parameters_test.rs
+++ b/itest/rust/src/register_tests/keyword_parameters_test.rs
@@ -6,7 +6,8 @@
  */
 
 use godot::builtin::{GString, PackedStringArray};
-use godot::classes::IEditorExportPlugin;
+use godot::classes::{IEditorExportPlugin, Node, Resource};
+use godot::obj::Gd;
 use godot::register::{godot_api, GodotClass};
 
 #[derive(GodotClass)]
@@ -14,8 +15,14 @@ use godot::register::{godot_api, GodotClass};
 struct KeywordParameterEditorExportPlugin;
 
 #[godot_api]
+#[rustfmt::skip]
 impl IEditorExportPlugin for KeywordParameterEditorExportPlugin {
     // This test requires that the second non-self parameter on `export_file`
     // remain named `_type`.
     fn export_file(&mut self, _path: GString, _type: GString, _features: PackedStringArray) {}
+
+    fn customize_resource(&mut self, _resource: Gd<Resource>, _path: GString) -> Option<Gd<Resource>> { unreachable!() }
+    fn customize_scene(&mut self, _scene: Gd<Node>, _path: GString) -> Option<Gd<Node>> { unreachable!() }
+    fn get_customization_configuration_hash(&self) -> u64 { unreachable!() }
+    fn get_name(&self) -> GString { unreachable!() }
 }