diff --git a/packages/nitrogen/src/syntax/kotlin/FbjniHybridObject.ts b/packages/nitrogen/src/syntax/kotlin/FbjniHybridObject.ts
index 6e0a40a0d..6140b1d10 100644
--- a/packages/nitrogen/src/syntax/kotlin/FbjniHybridObject.ts
+++ b/packages/nitrogen/src/syntax/kotlin/FbjniHybridObject.ts
@@ -51,7 +51,7 @@ export function createFbjniHybridObject(spec: HybridObjectSpec): SourceFile[] {
   const cppConstructorCalls = [`HybridObject(${name.HybridTSpec}::TAG)`]
   for (const base of spec.baseTypes) {
     const { JHybridTSpec } = getHybridObjectName(base.name)
-    cppConstructorCalls.push('HybridBase(jThis)')
+    cppConstructorCalls.push('HybridBase(javaPart)')
     cppImports.push({
       language: 'c++',
       name: `${JHybridTSpec}.hpp`,
@@ -87,17 +87,19 @@ namespace ${cxxNamespace} {
 ${spaces}          public virtual ${name.HybridTSpec} {
   public:
     static auto constexpr kJavaDescriptor = "L${jniClassDescriptor};";
-    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> javaPart);
     static void registerNatives();
 
   protected:
     // C++ constructor (called from Java via \`initHybrid()\`)
-    explicit ${name.JHybridTSpec}(jni::alias_ref<jhybridobject> jThis) :
-      ${indent(cppConstructorCalls.join(',\n'), '      ')},
-      _javaPart(jni::make_global(jThis)) {}
+    explicit ${name.JHybridTSpec}(jni::alias_ref<jhybridobject> javaPart);
 
   public:
-    virtual ~${name.JHybridTSpec}() {
+    // ${name.JHybridTSpec} cannot be default-constructed from C++.
+    ${name.JHybridTSpec}() = delete;
+
+  public:
+    ~${name.JHybridTSpec}() override {
       // Hermes GC can destroy JS objects on a non-JNI Thread.
       jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
     }
@@ -168,8 +170,22 @@ ${cppIncludes.join('\n')}
 
 namespace ${cxxNamespace} {
 
-  jni::local_ref<${name.JHybridTSpec}::jhybriddata> ${name.JHybridTSpec}::initHybrid(jni::alias_ref<jhybridobject> jThis) {
-    return makeCxxInstance(jThis);
+  ${name.JHybridTSpec}::${name.JHybridTSpec}(jni::alias_ref<jhybridobject> javaPart):
+    ${indent(cppConstructorCalls.join(',\n'), '    ')},
+    _javaPart(jni::make_global(javaPart)) {
+#ifdef NITRO_DEBUG
+    if (javaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Tried initializing a new C++ instance of \`${name.JHybridTSpec}\` from Java, "
+                                "but \`javaPart\` was null!");
+    } else if (!javaPart->isInstanceOf(${name.JHybridTSpec}::javaClassStatic())) [[unlikely]] {
+      throw std::runtime_error("Tried initializing a new C++ instance of \`${name.JHybridTSpec}\` from Java, "
+                                "but \`javaPart\` is not an instance of \`${name.HybridTSpec}\`!");
+    }
+#endif
+  }
+
+  jni::local_ref<${name.JHybridTSpec}::jhybriddata> ${name.JHybridTSpec}::initHybrid(jni::alias_ref<jhybridobject> javaPart) {
+    return makeCxxInstance(javaPart);
   }
 
   void ${name.JHybridTSpec}::registerNatives() {
diff --git a/packages/nitrogen/src/syntax/kotlin/KotlinHybridObject.ts b/packages/nitrogen/src/syntax/kotlin/KotlinHybridObject.ts
index e082f7eed..2e67f835f 100644
--- a/packages/nitrogen/src/syntax/kotlin/KotlinHybridObject.ts
+++ b/packages/nitrogen/src/syntax/kotlin/KotlinHybridObject.ts
@@ -56,22 +56,19 @@ import com.margelo.nitro.core.*
   "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
-abstract class ${name.HybridTSpec}: ${kotlinBase}() {
-  @DoNotStrip
-  private var mHybridData: HybridData = initHybrid()
-
-  init {
-    // Pass this \`HybridData\` through to it's base class,
-    // to represent inheritance to JHybridObject on C++ side
-    super.updateNative(mHybridData)
-  }
+abstract class ${name.HybridTSpec}: ${kotlinBase} {
+  /**
+   * Default-initialize this \`${name.HybridTSpec}\`.
+   * Use this constructor if \`${name.HybridTSpec}\` has no child-classes.
+   */
+  constructor(): super(initHybrid()) { }
 
   /**
-   * Call from a child class to initialize HybridData with a child.
+   * Initialize this \`${name.HybridTSpec}\` from a child-class
+   * with a custom \`HybridData\` being passed upwards.
+   * Use this constructor if \`${name.HybridTSpec}\` is being initialized from a child-class.
    */
-  override fun updateNative(hybridData: HybridData) {
-    mHybridData = hybridData
-  }
+  protected constructor(hybridData: HybridData): super(hybridData) { }
 
   // Properties
   ${indent(properties, '  ')}
@@ -79,10 +76,11 @@ abstract class ${name.HybridTSpec}: ${kotlinBase}() {
   // Methods
   ${indent(methods, '  ')}
 
-  private external fun initHybrid(): HybridData
-
   companion object {
     private const val TAG = "${name.HybridTSpec}"
+    @JvmStatic
+    private external fun initHybrid(): HybridData
+
     init {
       try {
         Log.i(TAG, "Loading ${cppLibName} C++ library...")
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridBaseSpec.cpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridBaseSpec.cpp
index c75ea3fdf..8dda0a890 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridBaseSpec.cpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridBaseSpec.cpp
@@ -13,8 +13,22 @@
 
 namespace margelo::nitro::image {
 
-  jni::local_ref<JHybridBaseSpec::jhybriddata> JHybridBaseSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
-    return makeCxxInstance(jThis);
+  JHybridBaseSpec::JHybridBaseSpec(jni::alias_ref<jhybridobject> javaPart):
+    HybridObject(HybridBaseSpec::TAG),
+    _javaPart(jni::make_global(javaPart)) {
+#ifdef NITRO_DEBUG
+    if (javaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Tried initializing a new C++ instance of `JHybridBaseSpec` from Java, "
+                                "but `javaPart` was null!");
+    } else if (!javaPart->isInstanceOf(JHybridBaseSpec::javaClassStatic())) [[unlikely]] {
+      throw std::runtime_error("Tried initializing a new C++ instance of `JHybridBaseSpec` from Java, "
+                                "but `javaPart` is not an instance of `HybridBaseSpec`!");
+    }
+#endif
+  }
+
+  jni::local_ref<JHybridBaseSpec::jhybriddata> JHybridBaseSpec::initHybrid(jni::alias_ref<jhybridobject> javaPart) {
+    return makeCxxInstance(javaPart);
   }
 
   void JHybridBaseSpec::registerNatives() {
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridBaseSpec.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridBaseSpec.hpp
index efd6246cd..d6b8d92c8 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridBaseSpec.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridBaseSpec.hpp
@@ -22,17 +22,19 @@ namespace margelo::nitro::image {
                          public virtual HybridBaseSpec {
   public:
     static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/HybridBaseSpec;";
-    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> javaPart);
     static void registerNatives();
 
   protected:
     // C++ constructor (called from Java via `initHybrid()`)
-    explicit JHybridBaseSpec(jni::alias_ref<jhybridobject> jThis) :
-      HybridObject(HybridBaseSpec::TAG),
-      _javaPart(jni::make_global(jThis)) {}
+    explicit JHybridBaseSpec(jni::alias_ref<jhybridobject> javaPart);
 
   public:
-    virtual ~JHybridBaseSpec() {
+    // JHybridBaseSpec cannot be default-constructed from C++.
+    JHybridBaseSpec() = delete;
+
+  public:
+    ~JHybridBaseSpec() override {
       // Hermes GC can destroy JS objects on a non-JNI Thread.
       jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
     }
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridChildSpec.cpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridChildSpec.cpp
index c8eba2ea4..f66b378f7 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridChildSpec.cpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridChildSpec.cpp
@@ -13,8 +13,23 @@
 
 namespace margelo::nitro::image {
 
-  jni::local_ref<JHybridChildSpec::jhybriddata> JHybridChildSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
-    return makeCxxInstance(jThis);
+  JHybridChildSpec::JHybridChildSpec(jni::alias_ref<jhybridobject> javaPart):
+    HybridObject(HybridChildSpec::TAG),
+    HybridBase(javaPart),
+    _javaPart(jni::make_global(javaPart)) {
+#ifdef NITRO_DEBUG
+    if (javaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Tried initializing a new C++ instance of `JHybridChildSpec` from Java, "
+                                "but `javaPart` was null!");
+    } else if (!javaPart->isInstanceOf(JHybridChildSpec::javaClassStatic())) [[unlikely]] {
+      throw std::runtime_error("Tried initializing a new C++ instance of `JHybridChildSpec` from Java, "
+                                "but `javaPart` is not an instance of `HybridChildSpec`!");
+    }
+#endif
+  }
+
+  jni::local_ref<JHybridChildSpec::jhybriddata> JHybridChildSpec::initHybrid(jni::alias_ref<jhybridobject> javaPart) {
+    return makeCxxInstance(javaPart);
   }
 
   void JHybridChildSpec::registerNatives() {
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridChildSpec.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridChildSpec.hpp
index de565a74e..ade5d85f1 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridChildSpec.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridChildSpec.hpp
@@ -23,18 +23,19 @@ namespace margelo::nitro::image {
                           public virtual HybridChildSpec {
   public:
     static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/HybridChildSpec;";
-    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> javaPart);
     static void registerNatives();
 
   protected:
     // C++ constructor (called from Java via `initHybrid()`)
-    explicit JHybridChildSpec(jni::alias_ref<jhybridobject> jThis) :
-      HybridObject(HybridChildSpec::TAG),
-      HybridBase(jThis),
-      _javaPart(jni::make_global(jThis)) {}
+    explicit JHybridChildSpec(jni::alias_ref<jhybridobject> javaPart);
 
   public:
-    virtual ~JHybridChildSpec() {
+    // JHybridChildSpec cannot be default-constructed from C++.
+    JHybridChildSpec() = delete;
+
+  public:
+    ~JHybridChildSpec() override {
       // Hermes GC can destroy JS objects on a non-JNI Thread.
       jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
     }
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridImageFactorySpec.cpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridImageFactorySpec.cpp
index 24eb6d62c..bfb1a8143 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridImageFactorySpec.cpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridImageFactorySpec.cpp
@@ -18,8 +18,22 @@ namespace margelo::nitro::image { class HybridImageSpec; }
 
 namespace margelo::nitro::image {
 
-  jni::local_ref<JHybridImageFactorySpec::jhybriddata> JHybridImageFactorySpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
-    return makeCxxInstance(jThis);
+  JHybridImageFactorySpec::JHybridImageFactorySpec(jni::alias_ref<jhybridobject> javaPart):
+    HybridObject(HybridImageFactorySpec::TAG),
+    _javaPart(jni::make_global(javaPart)) {
+#ifdef NITRO_DEBUG
+    if (javaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Tried initializing a new C++ instance of `JHybridImageFactorySpec` from Java, "
+                                "but `javaPart` was null!");
+    } else if (!javaPart->isInstanceOf(JHybridImageFactorySpec::javaClassStatic())) [[unlikely]] {
+      throw std::runtime_error("Tried initializing a new C++ instance of `JHybridImageFactorySpec` from Java, "
+                                "but `javaPart` is not an instance of `HybridImageFactorySpec`!");
+    }
+#endif
+  }
+
+  jni::local_ref<JHybridImageFactorySpec::jhybriddata> JHybridImageFactorySpec::initHybrid(jni::alias_ref<jhybridobject> javaPart) {
+    return makeCxxInstance(javaPart);
   }
 
   void JHybridImageFactorySpec::registerNatives() {
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridImageFactorySpec.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridImageFactorySpec.hpp
index 2e6f00a32..acc8369d3 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridImageFactorySpec.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridImageFactorySpec.hpp
@@ -22,17 +22,19 @@ namespace margelo::nitro::image {
                                  public virtual HybridImageFactorySpec {
   public:
     static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/HybridImageFactorySpec;";
-    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> javaPart);
     static void registerNatives();
 
   protected:
     // C++ constructor (called from Java via `initHybrid()`)
-    explicit JHybridImageFactorySpec(jni::alias_ref<jhybridobject> jThis) :
-      HybridObject(HybridImageFactorySpec::TAG),
-      _javaPart(jni::make_global(jThis)) {}
+    explicit JHybridImageFactorySpec(jni::alias_ref<jhybridobject> javaPart);
 
   public:
-    virtual ~JHybridImageFactorySpec() {
+    // JHybridImageFactorySpec cannot be default-constructed from C++.
+    JHybridImageFactorySpec() = delete;
+
+  public:
+    ~JHybridImageFactorySpec() override {
       // Hermes GC can destroy JS objects on a non-JNI Thread.
       jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
     }
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridImageSpec.cpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridImageSpec.cpp
index 72d8827f4..00291309e 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridImageSpec.cpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridImageSpec.cpp
@@ -26,8 +26,22 @@ namespace margelo::nitro::image { enum class ImageFormat; }
 
 namespace margelo::nitro::image {
 
-  jni::local_ref<JHybridImageSpec::jhybriddata> JHybridImageSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
-    return makeCxxInstance(jThis);
+  JHybridImageSpec::JHybridImageSpec(jni::alias_ref<jhybridobject> javaPart):
+    HybridObject(HybridImageSpec::TAG),
+    _javaPart(jni::make_global(javaPart)) {
+#ifdef NITRO_DEBUG
+    if (javaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Tried initializing a new C++ instance of `JHybridImageSpec` from Java, "
+                                "but `javaPart` was null!");
+    } else if (!javaPart->isInstanceOf(JHybridImageSpec::javaClassStatic())) [[unlikely]] {
+      throw std::runtime_error("Tried initializing a new C++ instance of `JHybridImageSpec` from Java, "
+                                "but `javaPart` is not an instance of `HybridImageSpec`!");
+    }
+#endif
+  }
+
+  jni::local_ref<JHybridImageSpec::jhybriddata> JHybridImageSpec::initHybrid(jni::alias_ref<jhybridobject> javaPart) {
+    return makeCxxInstance(javaPart);
   }
 
   void JHybridImageSpec::registerNatives() {
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridImageSpec.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridImageSpec.hpp
index 8a3242baf..99f0ef24a 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridImageSpec.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridImageSpec.hpp
@@ -22,17 +22,19 @@ namespace margelo::nitro::image {
                           public virtual HybridImageSpec {
   public:
     static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/HybridImageSpec;";
-    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> javaPart);
     static void registerNatives();
 
   protected:
     // C++ constructor (called from Java via `initHybrid()`)
-    explicit JHybridImageSpec(jni::alias_ref<jhybridobject> jThis) :
-      HybridObject(HybridImageSpec::TAG),
-      _javaPart(jni::make_global(jThis)) {}
+    explicit JHybridImageSpec(jni::alias_ref<jhybridobject> javaPart);
 
   public:
-    virtual ~JHybridImageSpec() {
+    // JHybridImageSpec cannot be default-constructed from C++.
+    JHybridImageSpec() = delete;
+
+  public:
+    ~JHybridImageSpec() override {
       // Hermes GC can destroy JS objects on a non-JNI Thread.
       jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
     }
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp
index 89b325faa..9d8928c3b 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp
@@ -72,8 +72,22 @@ namespace margelo::nitro::image { struct JsStyleStruct; }
 
 namespace margelo::nitro::image {
 
-  jni::local_ref<JHybridTestObjectSwiftKotlinSpec::jhybriddata> JHybridTestObjectSwiftKotlinSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
-    return makeCxxInstance(jThis);
+  JHybridTestObjectSwiftKotlinSpec::JHybridTestObjectSwiftKotlinSpec(jni::alias_ref<jhybridobject> javaPart):
+    HybridObject(HybridTestObjectSwiftKotlinSpec::TAG),
+    _javaPart(jni::make_global(javaPart)) {
+#ifdef NITRO_DEBUG
+    if (javaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Tried initializing a new C++ instance of `JHybridTestObjectSwiftKotlinSpec` from Java, "
+                                "but `javaPart` was null!");
+    } else if (!javaPart->isInstanceOf(JHybridTestObjectSwiftKotlinSpec::javaClassStatic())) [[unlikely]] {
+      throw std::runtime_error("Tried initializing a new C++ instance of `JHybridTestObjectSwiftKotlinSpec` from Java, "
+                                "but `javaPart` is not an instance of `HybridTestObjectSwiftKotlinSpec`!");
+    }
+#endif
+  }
+
+  jni::local_ref<JHybridTestObjectSwiftKotlinSpec::jhybriddata> JHybridTestObjectSwiftKotlinSpec::initHybrid(jni::alias_ref<jhybridobject> javaPart) {
+    return makeCxxInstance(javaPart);
   }
 
   void JHybridTestObjectSwiftKotlinSpec::registerNatives() {
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp
index 161a15dff..07c630ee4 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp
@@ -22,17 +22,19 @@ namespace margelo::nitro::image {
                                           public virtual HybridTestObjectSwiftKotlinSpec {
   public:
     static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec;";
-    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> javaPart);
     static void registerNatives();
 
   protected:
     // C++ constructor (called from Java via `initHybrid()`)
-    explicit JHybridTestObjectSwiftKotlinSpec(jni::alias_ref<jhybridobject> jThis) :
-      HybridObject(HybridTestObjectSwiftKotlinSpec::TAG),
-      _javaPart(jni::make_global(jThis)) {}
+    explicit JHybridTestObjectSwiftKotlinSpec(jni::alias_ref<jhybridobject> javaPart);
 
   public:
-    virtual ~JHybridTestObjectSwiftKotlinSpec() {
+    // JHybridTestObjectSwiftKotlinSpec cannot be default-constructed from C++.
+    JHybridTestObjectSwiftKotlinSpec() = delete;
+
+  public:
+    ~JHybridTestObjectSwiftKotlinSpec() override {
       // Hermes GC can destroy JS objects on a non-JNI Thread.
       jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
     }
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridBaseSpec.kt b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridBaseSpec.kt
index 15cf9bd72..2b20ba1f9 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridBaseSpec.kt
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridBaseSpec.kt
@@ -24,22 +24,19 @@ import com.margelo.nitro.core.*
   "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
-abstract class HybridBaseSpec: HybridObject() {
-  @DoNotStrip
-  private var mHybridData: HybridData = initHybrid()
-
-  init {
-    // Pass this `HybridData` through to it's base class,
-    // to represent inheritance to JHybridObject on C++ side
-    super.updateNative(mHybridData)
-  }
+abstract class HybridBaseSpec: HybridObject {
+  /**
+   * Default-initialize this `HybridBaseSpec`.
+   * Use this constructor if `HybridBaseSpec` has no child-classes.
+   */
+  constructor(): super(initHybrid()) { }
 
   /**
-   * Call from a child class to initialize HybridData with a child.
+   * Initialize this `HybridBaseSpec` from a child-class
+   * with a custom `HybridData` being passed upwards.
+   * Use this constructor if `HybridBaseSpec` is being initialized from a child-class.
    */
-  override fun updateNative(hybridData: HybridData) {
-    mHybridData = hybridData
-  }
+  protected constructor(hybridData: HybridData): super(hybridData) { }
 
   // Properties
   @get:DoNotStrip
@@ -49,10 +46,11 @@ abstract class HybridBaseSpec: HybridObject() {
   // Methods
   
 
-  private external fun initHybrid(): HybridData
-
   companion object {
     private const val TAG = "HybridBaseSpec"
+    @JvmStatic
+    private external fun initHybrid(): HybridData
+
     init {
       try {
         Log.i(TAG, "Loading NitroImage C++ library...")
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridChildSpec.kt b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridChildSpec.kt
index ee68eeac3..c186c249a 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridChildSpec.kt
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridChildSpec.kt
@@ -24,22 +24,19 @@ import com.margelo.nitro.core.*
   "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
-abstract class HybridChildSpec: HybridBaseSpec() {
-  @DoNotStrip
-  private var mHybridData: HybridData = initHybrid()
-
-  init {
-    // Pass this `HybridData` through to it's base class,
-    // to represent inheritance to JHybridObject on C++ side
-    super.updateNative(mHybridData)
-  }
+abstract class HybridChildSpec: HybridBaseSpec {
+  /**
+   * Default-initialize this `HybridChildSpec`.
+   * Use this constructor if `HybridChildSpec` has no child-classes.
+   */
+  constructor(): super(initHybrid()) { }
 
   /**
-   * Call from a child class to initialize HybridData with a child.
+   * Initialize this `HybridChildSpec` from a child-class
+   * with a custom `HybridData` being passed upwards.
+   * Use this constructor if `HybridChildSpec` is being initialized from a child-class.
    */
-  override fun updateNative(hybridData: HybridData) {
-    mHybridData = hybridData
-  }
+  protected constructor(hybridData: HybridData): super(hybridData) { }
 
   // Properties
   @get:DoNotStrip
@@ -49,10 +46,11 @@ abstract class HybridChildSpec: HybridBaseSpec() {
   // Methods
   
 
-  private external fun initHybrid(): HybridData
-
   companion object {
     private const val TAG = "HybridChildSpec"
+    @JvmStatic
+    private external fun initHybrid(): HybridData
+
     init {
       try {
         Log.i(TAG, "Loading NitroImage C++ library...")
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridImageFactorySpec.kt b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridImageFactorySpec.kt
index 89135dae1..403c49ff3 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridImageFactorySpec.kt
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridImageFactorySpec.kt
@@ -24,22 +24,19 @@ import com.margelo.nitro.core.*
   "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
-abstract class HybridImageFactorySpec: HybridObject() {
-  @DoNotStrip
-  private var mHybridData: HybridData = initHybrid()
-
-  init {
-    // Pass this `HybridData` through to it's base class,
-    // to represent inheritance to JHybridObject on C++ side
-    super.updateNative(mHybridData)
-  }
+abstract class HybridImageFactorySpec: HybridObject {
+  /**
+   * Default-initialize this `HybridImageFactorySpec`.
+   * Use this constructor if `HybridImageFactorySpec` has no child-classes.
+   */
+  constructor(): super(initHybrid()) { }
 
   /**
-   * Call from a child class to initialize HybridData with a child.
+   * Initialize this `HybridImageFactorySpec` from a child-class
+   * with a custom `HybridData` being passed upwards.
+   * Use this constructor if `HybridImageFactorySpec` is being initialized from a child-class.
    */
-  override fun updateNative(hybridData: HybridData) {
-    mHybridData = hybridData
-  }
+  protected constructor(hybridData: HybridData): super(hybridData) { }
 
   // Properties
   
@@ -61,10 +58,11 @@ abstract class HybridImageFactorySpec: HybridObject() {
   @Keep
   abstract fun bounceBack(image: HybridImageSpec): HybridImageSpec
 
-  private external fun initHybrid(): HybridData
-
   companion object {
     private const val TAG = "HybridImageFactorySpec"
+    @JvmStatic
+    private external fun initHybrid(): HybridData
+
     init {
       try {
         Log.i(TAG, "Loading NitroImage C++ library...")
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridImageSpec.kt b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridImageSpec.kt
index f4b7013e9..9e751b5ea 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridImageSpec.kt
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridImageSpec.kt
@@ -24,22 +24,19 @@ import com.margelo.nitro.core.*
   "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
-abstract class HybridImageSpec: HybridObject() {
-  @DoNotStrip
-  private var mHybridData: HybridData = initHybrid()
-
-  init {
-    // Pass this `HybridData` through to it's base class,
-    // to represent inheritance to JHybridObject on C++ side
-    super.updateNative(mHybridData)
-  }
+abstract class HybridImageSpec: HybridObject {
+  /**
+   * Default-initialize this `HybridImageSpec`.
+   * Use this constructor if `HybridImageSpec` has no child-classes.
+   */
+  constructor(): super(initHybrid()) { }
 
   /**
-   * Call from a child class to initialize HybridData with a child.
+   * Initialize this `HybridImageSpec` from a child-class
+   * with a custom `HybridData` being passed upwards.
+   * Use this constructor if `HybridImageSpec` is being initialized from a child-class.
    */
-  override fun updateNative(hybridData: HybridData) {
-    mHybridData = hybridData
-  }
+  protected constructor(hybridData: HybridData): super(hybridData) { }
 
   // Properties
   @get:DoNotStrip
@@ -70,10 +67,11 @@ abstract class HybridImageSpec: HybridObject() {
     return __result
   }
 
-  private external fun initHybrid(): HybridData
-
   companion object {
     private const val TAG = "HybridImageSpec"
+    @JvmStatic
+    private external fun initHybrid(): HybridData
+
     init {
       try {
         Log.i(TAG, "Loading NitroImage C++ library...")
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec.kt b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec.kt
index 8f1bd0b40..75cbecd96 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec.kt
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec.kt
@@ -24,22 +24,19 @@ import com.margelo.nitro.core.*
   "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
-abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() {
-  @DoNotStrip
-  private var mHybridData: HybridData = initHybrid()
-
-  init {
-    // Pass this `HybridData` through to it's base class,
-    // to represent inheritance to JHybridObject on C++ side
-    super.updateNative(mHybridData)
-  }
+abstract class HybridTestObjectSwiftKotlinSpec: HybridObject {
+  /**
+   * Default-initialize this `HybridTestObjectSwiftKotlinSpec`.
+   * Use this constructor if `HybridTestObjectSwiftKotlinSpec` has no child-classes.
+   */
+  constructor(): super(initHybrid()) { }
 
   /**
-   * Call from a child class to initialize HybridData with a child.
+   * Initialize this `HybridTestObjectSwiftKotlinSpec` from a child-class
+   * with a custom `HybridData` being passed upwards.
+   * Use this constructor if `HybridTestObjectSwiftKotlinSpec` is being initialized from a child-class.
    */
-  override fun updateNative(hybridData: HybridData) {
-    mHybridData = hybridData
-  }
+  protected constructor(hybridData: HybridData): super(hybridData) { }
 
   // Properties
   @get:DoNotStrip
@@ -384,10 +381,11 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() {
   @Keep
   abstract fun castBase(base: HybridBaseSpec): HybridChildSpec
 
-  private external fun initHybrid(): HybridData
-
   companion object {
     private const val TAG = "HybridTestObjectSwiftKotlinSpec"
+    @JvmStatic
+    private external fun initHybrid(): HybridData
+
     init {
       try {
         Log.i(TAG, "Loading NitroImage C++ library...")
diff --git a/packages/react-native-nitro-modules/android/src/main/java/com/margelo/nitro/core/HybridObject.kt b/packages/react-native-nitro-modules/android/src/main/java/com/margelo/nitro/core/HybridObject.kt
index a90518660..4214e0e52 100644
--- a/packages/react-native-nitro-modules/android/src/main/java/com/margelo/nitro/core/HybridObject.kt
+++ b/packages/react-native-nitro-modules/android/src/main/java/com/margelo/nitro/core/HybridObject.kt
@@ -9,7 +9,7 @@ import com.facebook.proguard.annotations.DoNotStrip
  */
 @Keep
 @DoNotStrip
-abstract class HybridObject: ExtendableHybridClass {
+open class HybridObject: ExtendableHybridClass {
     /**
      * Get the memory size of the Kotlin instance (plus any external heap allocations),
      * in bytes.
@@ -31,18 +31,13 @@ abstract class HybridObject: ExtendableHybridClass {
     open val memorySize: Long
         get() = 0L
 
-    /**
-     * Holds the native C++ instance.
-     * In `HybridObject`, the C++ instance is a sub-class of `JHybridObject`, such as one of it's specs.
-     * This is `null`, until `updateNative(..)` is called.
-     */
-    private var mHybridData: HybridData? = null
+    protected open var mHybridData: HybridData
 
-    /**
-     * Must be called in the constructor of a subclass of `HybridObject`, to initialize the C++
-     * `JHybridObject` with a subclass of it.
-     */
-    override fun updateNative(hybridData: HybridData) {
+    protected constructor(hybridData: HybridData) {
         mHybridData = hybridData
     }
+
+    override fun updateNative(hybridData: HybridData) {
+
+    }
 }