diff --git a/src/idl_gen_dart.cpp b/src/idl_gen_dart.cpp
index eec05a7..ff2c1a5 100644
--- a/src/idl_gen_dart.cpp
+++ b/src/idl_gen_dart.cpp
@@ -63,7 +63,7 @@
       code.clear();
       code = code + "// " + FlatBuffersGeneratedWarning() + "\n";
       code = code +
-             "// ignore_for_file: unused_import, unused_field, "
+             "// ignore_for_file: unused_import, unused_field, unused_element, "
              "unused_local_variable\n\n";
 
       if (!kv->first.empty()) { code += "library " + kv->first + ";\n\n"; }
@@ -154,10 +154,12 @@
 
   static std::string EscapeKeyword(const std::string &name) {
     for (size_t i = 0; i < sizeof(keywords) / sizeof(keywords[0]); i++) {
-      if (name == keywords[i]) { return MakeCamel(name + "_", false); }
+      if (name == keywords[i]) {
+        return ConvertCase(name + "_", Case::kLowerCamel);
+      }
     }
 
-    return MakeCamel(name, false);
+    return ConvertCase(name, Case::kLowerCamel);
   }
 
   void GenerateEnums(namespace_code_map *namespace_code) {
@@ -225,23 +227,34 @@
     GenDocComment(enum_def.doc_comment, &code, "");
 
     auto name = enum_def.is_union ? enum_def.name + "TypeId" : enum_def.name;
-    auto is_bit_flags = enum_def.attributes.Lookup("bit_flags");
+    const bool is_bit_flags =
+        enum_def.attributes.Lookup("bit_flags") != nullptr;
+    // The flatbuffer schema language allows bit flag enums to potentially have
+    // a default value of zero, even if it's not a valid enum value...
+    const bool permit_zero = is_bit_flags;
 
     code += "class " + name + " {\n";
     code += "  final int value;\n";
     code += "  const " + name + "._(this.value);\n\n";
     code += "  factory " + name + ".fromValue(int value) {\n";
-    code += "    if (value == null) value = 0;\n";
-
-    code += "    if (!values.containsKey(value)) {\n";
-    code +=
-        "      throw new StateError('Invalid value $value for bit flag enum ";
+    code += "    final result = values[value];\n";
+    code += "    if (result == null) {\n";
+    if (permit_zero) {
+      code += "      if (value == 0) {\n";
+      code += "        return " + name + "._(0);\n";
+      code += "      } else {\n";
+    }
+    code += "        throw StateError('Invalid value $value for bit flag enum ";
     code += name + "');\n";
+    if (permit_zero) { code += "      }\n"; }
     code += "    }\n";
 
-    code += "    return values[value];\n";
+    code += "    return result;\n";
     code += "  }\n\n";
 
+    code += "  static " + name + "? _createOrNull(int? value) => \n";
+    code += "      value == null ? null : " + name + ".fromValue(value);\n\n";
+
     // this is meaningless for bit_flags
     // however, note that unlike "regular" dart enums this enum can still have
     // holes.
@@ -263,19 +276,20 @@
         if (it != enum_def.Vals().begin()) { code += '\n'; }
         GenDocComment(ev.doc_comment, &code, "", "  ");
       }
-      code += "  static const " + name + " " + ev.name + " = ";
-      code += "const " + name + "._(" + enum_def.ToString(ev) + ");\n";
+      code += "  static const " + name + " " + ev.name + " = " + name + "._(" +
+              enum_def.ToString(ev) + ");\n";
     }
 
-    code += "  static const values = {";
+    code += "  static const Map<int, " + name + "> values = {\n";
     for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
       auto &ev = **it;
-      code += enum_def.ToString(ev) + ": " + ev.name + ",";
+      if (it != enum_def.Vals().begin()) code += ",\n";
+      code += "    " + enum_def.ToString(ev) + ": " + ev.name;
     }
     code += "};\n\n";
 
-    code += "  static const " + _kFb + ".Reader<" + name +
-            "> reader = const _" + name + "Reader();\n\n";
+    code += "  static const " + _kFb + ".Reader<" + name + "> reader = _" +
+            name + "Reader();\n\n";
     code += "  @override\n";
     code += "  String toString() {\n";
     code += "    return '" + name + "{value: $value}';\n";
@@ -298,7 +312,7 @@
     code += "  @override\n";
     code +=
         "  " + name + " read(" + _kFb + ".BufferContext bc, int offset) =>\n";
-    code += "      new " + name + ".fromValue(const " + _kFb + "." +
+    code += "      " + name + ".fromValue(const " + _kFb + "." +
             GenType(enum_def.underlying_type) + "Reader().read(bc, offset));\n";
     code += "}\n\n";
   }
@@ -327,30 +341,41 @@
 
   std::string GenReaderTypeName(const Type &type, Namespace *current_namespace,
                                 const FieldDef &def,
-                                bool parent_is_vector = false) {
+                                bool parent_is_vector = false, bool lazy = true,
+                                bool constConstruct = true) {
+    std::string prefix = (constConstruct ? "const " : "") + _kFb;
     if (type.base_type == BASE_TYPE_BOOL) {
-      return "const " + _kFb + ".BoolReader()";
+      return prefix + ".BoolReader()";
     } else if (IsVector(type)) {
-      return "const " + _kFb + ".ListReader<" +
+      if (!type.VectorType().enum_def) {
+        if (type.VectorType().base_type == BASE_TYPE_CHAR) {
+          return prefix + ".Int8ListReader(" + (lazy ? ")" : "lazy: false)");
+        }
+        if (type.VectorType().base_type == BASE_TYPE_UCHAR) {
+          return prefix + ".Uint8ListReader(" + (lazy ? ")" : "lazy: false)");
+        }
+      }
+      return prefix + ".ListReader<" +
              GenDartTypeName(type.VectorType(), current_namespace, def) + ">(" +
-             GenReaderTypeName(type.VectorType(), current_namespace, def,
-                               true) +
-             ")";
+             GenReaderTypeName(type.VectorType(), current_namespace, def, true,
+                               true, false) +
+             (lazy ? ")" : ", lazy: false)");
     } else if (IsString(type)) {
-      return "const " + _kFb + ".StringReader()";
+      return prefix + ".StringReader()";
     }
     if (IsScalar(type.base_type)) {
       if (type.enum_def && parent_is_vector) {
         return GenDartTypeName(type, current_namespace, def) + ".reader";
       }
-      return "const " + _kFb + "." + GenType(type) + "Reader()";
+      return prefix + "." + GenType(type) + "Reader()";
     } else {
       return GenDartTypeName(type, current_namespace, def) + ".reader";
     }
   }
 
   std::string GenDartTypeName(const Type &type, Namespace *current_namespace,
-                              const FieldDef &def, bool addBuilder = false) {
+                              const FieldDef &def,
+                              std::string struct_type_suffix = "") {
     if (type.enum_def) {
       if (type.enum_def->is_union && type.base_type != BASE_TYPE_UNION) {
         return type.enum_def->name + "TypeId";
@@ -375,18 +400,26 @@
       case BASE_TYPE_DOUBLE: return "double";
       case BASE_TYPE_STRING: return "String";
       case BASE_TYPE_STRUCT:
-        return MaybeWrapNamespace(
-            type.struct_def->name + (addBuilder ? "ObjectBuilder" : ""),
-            current_namespace, def);
+        return MaybeWrapNamespace(type.struct_def->name + struct_type_suffix,
+                                  current_namespace, def);
       case BASE_TYPE_VECTOR:
         return "List<" +
                GenDartTypeName(type.VectorType(), current_namespace, def,
-                               addBuilder) +
+                               struct_type_suffix) +
                ">";
       default: assert(0); return "dynamic";
     }
   }
 
+  std::string GenDartTypeName(const Type &type, Namespace *current_namespace,
+                              const FieldDef &def, bool nullable,
+                              std::string struct_type_suffix) {
+    std::string typeName =
+        GenDartTypeName(type, current_namespace, def, struct_type_suffix);
+    if (nullable && typeName != "dynamic") typeName += "?";
+    return typeName;
+  }
+
   static const std::string MaybeWrapNamespace(const std::string &type_name,
                                               Namespace *current_ns,
                                               const FieldDef &field) {
@@ -432,15 +465,15 @@
     code += "  " + object_name + "._(this._bc, this._bcOffset);\n";
     if (!struct_def.fixed) {
       code += "  factory " + object_name + "(List<int> bytes) {\n";
-      code += "    " + _kFb + ".BufferContext rootRef = new " + _kFb +
-              ".BufferContext.fromBytes(bytes);\n";
+      code +=
+          "    final rootRef = " + _kFb + ".BufferContext.fromBytes(bytes);\n";
       code += "    return reader.read(rootRef, 0);\n";
       code += "  }\n";
     }
 
     code += "\n";
     code += "  static const " + _kFb + ".Reader<" + object_name +
-            "> reader = const " + reader_name + "();\n\n";
+            "> reader = " + reader_name + "();\n\n";
 
     code += "  final " + _kFb + ".BufferContext _bc;\n";
     code += "  final int _bcOffset;\n\n";
@@ -456,8 +489,23 @@
 
     GenImplementationGetters(struct_def, non_deprecated_fields, &code);
 
+    if (parser_.opts.generate_object_based_api) {
+      code +=
+          "\n" + GenStructObjectAPIUnpack(struct_def, non_deprecated_fields);
+
+      code += "\n  static int pack(fb.Builder fbBuilder, " + struct_def.name +
+              "T? object) {\n";
+      code += "    if (object == null) return 0;\n";
+      code += "    return object.pack(fbBuilder);\n";
+      code += "  }\n";
+    }
+
     code += "}\n\n";
 
+    if (parser_.opts.generate_object_based_api) {
+      code += GenStructObjectAPI(struct_def, non_deprecated_fields);
+    }
+
     GenReader(struct_def, &reader_name, &reader_code);
     GenBuilder(struct_def, non_deprecated_fields, &builder_name, &builder_code);
     GenObjectBuilder(struct_def, non_deprecated_fields, &object_builder_name,
@@ -469,6 +517,122 @@
     (*namespace_code)[object_namespace] += code;
   }
 
+  // Generate an accessor struct with constructor for a flatbuffers struct.
+  std::string GenStructObjectAPI(
+      const StructDef &struct_def,
+      const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields) {
+    std::string code;
+    GenDocComment(struct_def.doc_comment, &code, "");
+
+    std::string class_name = struct_def.name + "T";
+    code += "class " + class_name + " implements " + _kFb + ".Packable {\n";
+
+    std::string constructor_args;
+    for (auto it = non_deprecated_fields.begin();
+         it != non_deprecated_fields.end(); ++it) {
+      const FieldDef &field = *it->second;
+
+      std::string field_name = ConvertCase(field.name, Case::kLowerCamel);
+      std::string defaultValue = getDefaultValue(field.value);
+      std::string type_name =
+          GenDartTypeName(field.value.type, struct_def.defined_namespace, field,
+                          defaultValue.empty() && !struct_def.fixed, "T");
+
+      GenDocComment(field.doc_comment, &code, "", "  ");
+      code += "  " + type_name + " " + field_name + ";\n";
+
+      if (!constructor_args.empty()) constructor_args += ",\n";
+      constructor_args += "      ";
+      constructor_args += (struct_def.fixed ? "required " : "");
+      constructor_args += "this." + field_name;
+      if (!struct_def.fixed && !defaultValue.empty()) {
+        if (IsEnum(field.value.type)) {
+          auto &enum_def = *field.value.type.enum_def;
+          if (auto val = enum_def.FindByValue(defaultValue)) {
+            constructor_args += " = " + enum_def.name + "." + val->name;
+          } else {
+            constructor_args +=
+                " = const " + enum_def.name + "._(" + defaultValue + ")";
+          }
+        } else {
+          constructor_args += " = " + defaultValue;
+        }
+      }
+    }
+
+    if (!constructor_args.empty()) {
+      code += "\n  " + class_name + "({\n" + constructor_args + "});\n\n";
+    }
+
+    code += GenStructObjectAPIPack(struct_def, non_deprecated_fields);
+    code += "\n";
+    code += GenToString(class_name, non_deprecated_fields);
+
+    code += "}\n\n";
+    return code;
+  }
+
+  // Generate function `StructNameT unpack()`
+  std::string GenStructObjectAPIUnpack(
+      const StructDef &struct_def,
+      const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields) {
+    std::string constructor_args;
+    for (auto it = non_deprecated_fields.begin();
+         it != non_deprecated_fields.end(); ++it) {
+      const FieldDef &field = *it->second;
+
+      std::string field_name = ConvertCase(field.name, Case::kLowerCamel);
+      if (!constructor_args.empty()) constructor_args += ",\n";
+      constructor_args += "      " + field_name + ": ";
+
+      const Type &type = field.value.type;
+      std::string defaultValue = getDefaultValue(field.value);
+      bool isNullable = defaultValue.empty() && !struct_def.fixed;
+      std::string nullableValueAccessOperator = isNullable ? "?" : "";
+      if (type.base_type == BASE_TYPE_STRUCT) {
+        constructor_args +=
+            field_name + nullableValueAccessOperator + ".unpack()";
+      } else if (type.base_type == BASE_TYPE_VECTOR) {
+        if (type.VectorType().base_type == BASE_TYPE_STRUCT) {
+          constructor_args += field_name + nullableValueAccessOperator +
+                              ".map((e) => e.unpack()).toList()";
+        } else {
+          constructor_args +=
+              GenReaderTypeName(field.value.type, struct_def.defined_namespace,
+                                field, false, false);
+          constructor_args += ".vTableGet";
+          std::string offset = NumToString(field.value.offset);
+          constructor_args +=
+              isNullable
+                  ? "Nullable(_bc, _bcOffset, " + offset + ")"
+                  : "(_bc, _bcOffset, " + offset + ", " + defaultValue + ")";
+        }
+      } else {
+        constructor_args += field_name;
+      }
+    }
+
+    std::string class_name = struct_def.name + "T";
+    std::string code = "  " + class_name + " unpack() => " + class_name + "(";
+    if (!constructor_args.empty()) code += "\n" + constructor_args;
+    code += ");\n";
+    return code;
+  }
+
+  // Generate function `StructNameT pack()`
+  std::string GenStructObjectAPIPack(
+      const StructDef &struct_def,
+      const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields) {
+    std::string code;
+
+    code += "  @override\n";
+    code += "  int pack(fb.Builder fbBuilder) {\n";
+    code += GenObjectBuilderImplementation(struct_def, non_deprecated_fields,
+                                           false, true);
+    code += "  }\n";
+    return code;
+  }
+
   std::string NamespaceAliasFromUnionType(Namespace *root_namespace,
                                           const Type &type) {
     const std::vector<std::string> qualified_name_parts =
@@ -510,9 +674,12 @@
       auto pair = *it;
       auto &field = *pair.second;
 
-      std::string field_name = MakeCamel(field.name, false);
-      std::string type_name = GenDartTypeName(
-          field.value.type, struct_def.defined_namespace, field, false);
+      std::string field_name = ConvertCase(field.name, Case::kLowerCamel);
+      std::string defaultValue = getDefaultValue(field.value);
+      bool isNullable = defaultValue.empty() && !struct_def.fixed;
+      std::string type_name =
+          GenDartTypeName(field.value.type, struct_def.defined_namespace, field,
+                          isNullable, "");
 
       GenDocComment(field.doc_comment, &code, "", "  ");
 
@@ -528,8 +695,8 @@
           auto enum_name = NamespaceAliasFromUnionType(
               enum_def.defined_namespace, ev.union_type);
           code += "      case " + enum_def.ToString(ev) + ": return " +
-                  enum_name + ".reader.vTableGet(_bc, _bcOffset, " +
-                  NumToString(field.value.offset) + ", null);\n";
+                  enum_name + ".reader.vTableGetNullable(_bc, _bcOffset, " +
+                  NumToString(field.value.offset) + ");\n";
         }
         code += "      default: return null;\n";
         code += "    }\n";
@@ -538,10 +705,9 @@
         code += " => ";
         if (field.value.type.enum_def &&
             field.value.type.base_type != BASE_TYPE_VECTOR) {
-          code += "new " +
-                  GenDartTypeName(field.value.type,
+          code += GenDartTypeName(field.value.type,
                                   struct_def.defined_namespace, field) +
-                  ".fromValue(";
+                  (isNullable ? "._createOrNull(" : ".fromValue(");
         }
 
         code += GenReaderTypeName(field.value.type,
@@ -550,33 +716,13 @@
           code +=
               ".read(_bc, _bcOffset + " + NumToString(field.value.offset) + ")";
         } else {
-          code += ".vTableGet(_bc, _bcOffset, " +
-                  NumToString(field.value.offset) + ", ";
-          if (!field.value.constant.empty() && field.value.constant != "0") {
-            if (IsBool(field.value.type.base_type)) {
-              code += "true";
-            } else if (field.value.constant == "nan" ||
-                       field.value.constant == "+nan" ||
-                       field.value.constant == "-nan") {
-              code += "double.nan";
-            } else if (field.value.constant == "inf" ||
-                       field.value.constant == "+inf") {
-              code += "double.infinity";
-            } else if (field.value.constant == "-inf") {
-              code += "double.negativeInfinity";
-            } else {
-              code += field.value.constant;
-            }
+          code += ".vTableGet";
+          std::string offset = NumToString(field.value.offset);
+          if (isNullable) {
+            code += "Nullable(_bc, _bcOffset, " + offset + ")";
           } else {
-            if (IsBool(field.value.type.base_type)) {
-              code += "false";
-            } else if (IsScalar(field.value.type.base_type)) {
-              code += "0";
-            } else {
-              code += "null";
-            }
+            code += "(_bc, _bcOffset, " + offset + ", " + defaultValue + ")";
           }
-          code += ")";
         }
         if (field.value.type.enum_def &&
             field.value.type.base_type != BASE_TYPE_VECTOR) {
@@ -587,20 +733,50 @@
     }
 
     code += "\n";
+    code += GenToString(struct_def.name, non_deprecated_fields);
+  }
 
+  std::string GenToString(
+      const std::string &object_name,
+      const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields) {
+    std::string code;
     code += "  @override\n";
     code += "  String toString() {\n";
-    code += "    return '" + struct_def.name + "{";
+    code += "    return '" + object_name + "{";
     for (auto it = non_deprecated_fields.begin();
          it != non_deprecated_fields.end(); ++it) {
       auto pair = *it;
       auto &field = *pair.second;
-      code +=
-          MakeCamel(field.name, false) + ": $" + MakeCamel(field.name, false);
+      code += ConvertCase(field.name, Case::kLowerCamel) + ": $" +
+              ConvertCase(field.name, Case::kLowerCamel);
       if (it != non_deprecated_fields.end() - 1) { code += ", "; }
     }
     code += "}';\n";
     code += "  }\n";
+    return code;
+  }
+
+  std::string getDefaultValue(const Value &value) const {
+    if (!value.constant.empty() && value.constant != "0") {
+      if (IsBool(value.type.base_type)) {
+        return "true";
+      } else if (value.constant == "nan" || value.constant == "+nan" ||
+                 value.constant == "-nan") {
+        return "double.nan";
+      } else if (value.constant == "inf" || value.constant == "+inf") {
+        return "double.infinity";
+      } else if (value.constant == "-inf") {
+        return "double.negativeInfinity";
+      } else {
+        return value.constant;
+      }
+    } else if (IsBool(value.type.base_type)) {
+      return "false";
+    } else if (IsScalar(value.type.base_type) && !IsUnion(value.type)) {
+      return "0";
+    } else {
+      return "";
+    }
   }
 
   void GenReader(const StructDef &struct_def, std::string *reader_name_ptr,
@@ -624,7 +800,7 @@
     }
     code += "  @override\n";
     code += "  " + impl_name +
-            " createObject(fb.BufferContext bc, int offset) => \n    new " +
+            " createObject(fb.BufferContext bc, int offset) => \n    " +
             impl_name + "._(bc, offset);\n";
     code += "}\n\n";
   }
@@ -637,9 +813,7 @@
     auto &builder_name = *builder_name_ptr;
 
     code += "class " + builder_name + " {\n";
-    code += "  " + builder_name + "(this.fbBuilder) {\n";
-    code += "    assert(fbBuilder != null);\n";
-    code += "  }\n\n";
+    code += "  " + builder_name + "(this.fbBuilder);\n\n";
     code += "  final " + _kFb + ".Builder fbBuilder;\n\n";
 
     if (struct_def.fixed) {
@@ -688,7 +862,7 @@
       } else {
         code += "    fbBuilder.put" + GenType(field.value.type) + "(";
         code += field.name;
-        if (field.value.type.enum_def) { code += "?.value"; }
+        if (field.value.type.enum_def) { code += ".value"; }
         code += ");\n";
       }
     }
@@ -703,7 +877,8 @@
     auto &code = *code_ptr;
 
     code += "  void begin() {\n";
-    code += "    fbBuilder.startTable();\n";
+    code += "    fbBuilder.startTable(" +
+            NumToString(struct_def.fields.vec.size()) + ");\n";
     code += "  }\n\n";
 
     for (auto it = non_deprecated_fields.begin();
@@ -713,21 +888,23 @@
       auto offset = pair.first;
 
       if (IsScalar(field.value.type.base_type)) {
-        code += "  int add" + MakeCamel(field.name) + "(";
+        code += "  int add" + ConvertCase(field.name, Case::kUpperCamel) + "(";
         code += GenDartTypeName(field.value.type, struct_def.defined_namespace,
                                 field);
-        code += " " + MakeCamel(field.name, false) + ") {\n";
+        code += "? " + ConvertCase(field.name, Case::kLowerCamel) + ") {\n";
         code += "    fbBuilder.add" + GenType(field.value.type) + "(" +
                 NumToString(offset) + ", ";
-        code += MakeCamel(field.name, false);
+        code += ConvertCase(field.name, Case::kLowerCamel);
         if (field.value.type.enum_def) { code += "?.value"; }
         code += ");\n";
       } else if (IsStruct(field.value.type)) {
-        code += "  int add" + MakeCamel(field.name) + "(int offset) {\n";
+        code += "  int add" + ConvertCase(field.name, Case::kUpperCamel) +
+                "(int offset) {\n";
         code +=
             "    fbBuilder.addStruct(" + NumToString(offset) + ", offset);\n";
       } else {
-        code += "  int add" + MakeCamel(field.name) + "Offset(int offset) {\n";
+        code += "  int add" + ConvertCase(field.name, Case::kUpperCamel) +
+                "Offset(int? offset) {\n";
         code +=
             "    fbBuilder.addOffset(" + NumToString(offset) + ", offset);\n";
       }
@@ -756,8 +933,8 @@
 
       code += "  final " +
               GenDartTypeName(field.value.type, struct_def.defined_namespace,
-                              field, true) +
-              " _" + MakeCamel(field.name, false) + ";\n";
+                              field, !struct_def.fixed, "ObjectBuilder") +
+              " _" + ConvertCase(field.name, Case::kLowerCamel) + ";\n";
     }
     code += "\n";
     code += "  " + builder_name + "(";
@@ -769,10 +946,11 @@
         auto pair = *it;
         auto &field = *pair.second;
 
-        code += "    " +
+        code += "    ";
+        code += (struct_def.fixed ? "required " : "") +
                 GenDartTypeName(field.value.type, struct_def.defined_namespace,
-                                field, true) +
-                " " + MakeCamel(field.name, false) + ",\n";
+                                field, !struct_def.fixed, "ObjectBuilder") +
+                " " + ConvertCase(field.name, Case::kLowerCamel) + ",\n";
       }
       code += "  })\n";
       code += "      : ";
@@ -781,8 +959,8 @@
         auto pair = *it;
         auto &field = *pair.second;
 
-        code += "_" + MakeCamel(field.name, false) + " = " +
-                MakeCamel(field.name, false);
+        code += "_" + ConvertCase(field.name, Case::kLowerCamel) + " = " +
+                ConvertCase(field.name, Case::kLowerCamel);
         if (it == non_deprecated_fields.end() - 1) {
           code += ";\n\n";
         } else {
@@ -795,75 +973,102 @@
 
     code += "  /// Finish building, and store into the [fbBuilder].\n";
     code += "  @override\n";
-    code += "  int finish(\n";
-    code += "    " + _kFb + ".Builder fbBuilder) {\n";
-    code += "    assert(fbBuilder != null);\n";
-
-    for (auto it = non_deprecated_fields.begin();
-         it != non_deprecated_fields.end(); ++it) {
-      auto pair = *it;
-      auto &field = *pair.second;
-
-      if (IsScalar(field.value.type.base_type) || IsStruct(field.value.type))
-        continue;
-
-      code += "    final int " + MakeCamel(field.name, false) + "Offset";
-      if (IsVector(field.value.type)) {
-        code +=
-            " = _" + MakeCamel(field.name, false) + "?.isNotEmpty == true\n";
-        code += "        ? fbBuilder.writeList";
-        switch (field.value.type.VectorType().base_type) {
-          case BASE_TYPE_STRING:
-            code += "(_" + MakeCamel(field.name, false) +
-                    ".map((b) => fbBuilder.writeString(b)).toList())";
-            break;
-          case BASE_TYPE_STRUCT:
-            if (field.value.type.struct_def->fixed) {
-              code += "OfStructs(_" + MakeCamel(field.name, false) + ")";
-            } else {
-              code += "(_" + MakeCamel(field.name, false) +
-                      ".map((b) => b.getOrCreateOffset(fbBuilder)).toList())";
-            }
-            break;
-          default:
-            code += GenType(field.value.type.VectorType()) + "(_" +
-                    MakeCamel(field.name, false);
-            if (field.value.type.enum_def) { code += ".map((f) => f.value)"; }
-            code += ")";
-        }
-        code += "\n        : null;\n";
-      } else if (IsString(field.value.type)) {
-        code += " = fbBuilder.writeString(_" + MakeCamel(field.name, false) +
-                ");\n";
-      } else {
-        code += " = _" + MakeCamel(field.name, false) +
-                "?.getOrCreateOffset(fbBuilder);\n";
-      }
-    }
-
-    code += "\n";
-    if (struct_def.fixed) {
-      StructObjectBuilderBody(non_deprecated_fields, code_ptr);
-    } else {
-      TableObjectBuilderBody(non_deprecated_fields, code_ptr);
-    }
+    code += "  int finish(" + _kFb + ".Builder fbBuilder) {\n";
+    code += GenObjectBuilderImplementation(struct_def, non_deprecated_fields);
     code += "  }\n\n";
 
     code += "  /// Convenience method to serialize to byte list.\n";
     code += "  @override\n";
-    code += "  Uint8List toBytes([String fileIdentifier]) {\n";
-    code += "    " + _kFb + ".Builder fbBuilder = new ";
-    code += _kFb + ".Builder();\n";
-    code += "    int offset = finish(fbBuilder);\n";
-    code += "    return fbBuilder.finish(offset, fileIdentifier);\n";
+    code += "  Uint8List toBytes([String? fileIdentifier]) {\n";
+    code += "    final fbBuilder = " + _kFb +
+            ".Builder(deduplicateTables: false);\n";
+    code += "    fbBuilder.finish(finish(fbBuilder), fileIdentifier);\n";
+    code += "    return fbBuilder.buffer;\n";
     code += "  }\n";
     code += "}\n";
   }
 
-  void StructObjectBuilderBody(
-      std::vector<std::pair<int, FieldDef *>> non_deprecated_fields,
-      std::string *code_ptr, bool prependUnderscore = true) {
-    auto &code = *code_ptr;
+  std::string GenObjectBuilderImplementation(
+      const StructDef &struct_def,
+      const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields,
+      bool prependUnderscore = true, bool pack = false) {
+    std::string code;
+    for (auto it = non_deprecated_fields.begin();
+         it != non_deprecated_fields.end(); ++it) {
+      const FieldDef &field = *it->second;
+
+      if (IsScalar(field.value.type.base_type) || IsStruct(field.value.type))
+        continue;
+
+      std::string offset_name =
+          ConvertCase(field.name, Case::kLowerCamel) + "Offset";
+      std::string field_name = (prependUnderscore ? "_" : "") +
+                               ConvertCase(field.name, Case::kLowerCamel);
+
+      // custom handling for fixed-sized struct in pack()
+      if (pack && IsVector(field.value.type) &&
+          field.value.type.VectorType().base_type == BASE_TYPE_STRUCT &&
+          field.value.type.struct_def->fixed) {
+        code += "    int? " + offset_name + ";\n";
+        code += "    if (" + field_name + " != null) {\n";
+        code +=
+            "      for (var e in " + field_name + "!) { e.pack(fbBuilder); }\n";
+        code += "      " + ConvertCase(field.name, Case::kLowerCamel) +
+                "Offset = fbBuilder.endStructVector(" + field_name +
+                "!.length);\n";
+        code += "    }\n";
+        continue;
+      }
+
+      code += "    final int? " + offset_name;
+      if (IsVector(field.value.type)) {
+        code += " = " + field_name + " == null ? null\n";
+        code += "        : fbBuilder.writeList";
+        switch (field.value.type.VectorType().base_type) {
+          case BASE_TYPE_STRING:
+            code +=
+                "(" + field_name + "!.map(fbBuilder.writeString).toList());\n";
+            break;
+          case BASE_TYPE_STRUCT:
+            if (field.value.type.struct_def->fixed) {
+              code += "OfStructs(" + field_name + "!);\n";
+            } else {
+              code += "(" + field_name + "!.map((b) => b." +
+                      (pack ? "pack" : "getOrCreateOffset") +
+                      "(fbBuilder)).toList());\n";
+            }
+            break;
+          default:
+            code +=
+                GenType(field.value.type.VectorType()) + "(" + field_name + "!";
+            if (field.value.type.enum_def) {
+              code += ".map((f) => f.value).toList()";
+            }
+            code += ");\n";
+        }
+      } else if (IsString(field.value.type)) {
+        code += " = " + field_name + " == null ? null\n";
+        code += "        : fbBuilder.writeString(" + field_name + "!);\n";
+      } else {
+        code += " = " + field_name + "?." +
+                (pack ? "pack" : "getOrCreateOffset") + "(fbBuilder);\n";
+      }
+    }
+
+    if (struct_def.fixed) {
+      code += StructObjectBuilderBody(non_deprecated_fields, prependUnderscore,
+                                      pack);
+    } else {
+      code += TableObjectBuilderBody(struct_def, non_deprecated_fields,
+                                     prependUnderscore, pack);
+    }
+    return code;
+  }
+
+  std::string StructObjectBuilderBody(
+      const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields,
+      bool prependUnderscore = true, bool pack = false) {
+    std::string code;
 
     for (auto it = non_deprecated_fields.rbegin();
          it != non_deprecated_fields.rend(); ++it) {
@@ -877,24 +1082,27 @@
       if (IsStruct(field.value.type)) {
         code += "    ";
         if (prependUnderscore) { code += "_"; }
-        code += field.name + ".finish(fbBuilder);\n";
+        code += field.name + (pack ? ".pack" : ".finish") + "(fbBuilder);\n";
       } else {
         code += "    fbBuilder.put" + GenType(field.value.type) + "(";
         if (prependUnderscore) { code += "_"; }
         code += field.name;
-        if (field.value.type.enum_def) { code += "?.value"; }
+        if (field.value.type.enum_def) { code += ".value"; }
         code += ");\n";
       }
     }
 
     code += "    return fbBuilder.offset;\n";
+    return code;
   }
 
-  void TableObjectBuilderBody(
-      std::vector<std::pair<int, FieldDef *>> non_deprecated_fields,
-      std::string *code_ptr, bool prependUnderscore = true) {
-    std::string &code = *code_ptr;
-    code += "    fbBuilder.startTable();\n";
+  std::string TableObjectBuilderBody(
+      const StructDef &struct_def,
+      const std::vector<std::pair<int, FieldDef *>> &non_deprecated_fields,
+      bool prependUnderscore = true, bool pack = false) {
+    std::string code;
+    code += "    fbBuilder.startTable(" +
+            NumToString(struct_def.fields.vec.size()) + ");\n";
 
     for (auto it = non_deprecated_fields.begin();
          it != non_deprecated_fields.end(); ++it) {
@@ -902,29 +1110,29 @@
       auto &field = *pair.second;
       auto offset = pair.first;
 
+      std::string field_name = (prependUnderscore ? "_" : "") +
+                               ConvertCase(field.name, Case::kLowerCamel);
+
       if (IsScalar(field.value.type.base_type)) {
         code += "    fbBuilder.add" + GenType(field.value.type) + "(" +
-                NumToString(offset) + ", ";
-        if (prependUnderscore) { code += "_"; }
-        code += MakeCamel(field.name, false);
-        if (field.value.type.enum_def) { code += "?.value"; }
+                NumToString(offset) + ", " + field_name;
+        if (field.value.type.enum_def) {
+          bool isNullable = getDefaultValue(field.value).empty();
+          code += (isNullable || !pack) ? "?.value" : ".value";
+        }
         code += ");\n";
       } else if (IsStruct(field.value.type)) {
-        code += "    if (";
-        if (prependUnderscore) { code += "_"; }
-        code += MakeCamel(field.name, false) + " != null) {\n";
-        code += "      fbBuilder.addStruct(" + NumToString(offset) + ", ";
-        code += "_" + MakeCamel(field.name, false) + ".finish(fbBuilder));\n";
+        code += "    if (" + field_name + " != null) {\n";
+        code += "      fbBuilder.addStruct(" + NumToString(offset) + ", " +
+                field_name + (pack ? "!.pack" : "!.finish") + "(fbBuilder));\n";
         code += "    }\n";
       } else {
-        code +=
-            "    if (" + MakeCamel(field.name, false) + "Offset != null) {\n";
-        code += "      fbBuilder.addOffset(" + NumToString(offset) + ", " +
-                MakeCamel(field.name, false) + "Offset);\n";
-        code += "    }\n";
+        code += "    fbBuilder.addOffset(" + NumToString(offset) + ", " +
+                ConvertCase(field.name, Case::kLowerCamel) + "Offset);\n";
       }
     }
     code += "    return fbBuilder.endTable();\n";
+    return code;
   }
 };
 }  // namespace dart
@@ -937,8 +1145,6 @@
 
 std::string DartMakeRule(const Parser &parser, const std::string &path,
                          const std::string &file_name) {
-  assert(parser.opts.lang <= IDLOptions::kMAX);
-
   auto filebase =
       flatbuffers::StripPath(flatbuffers::StripExtension(file_name));
   dart::DartGenerator generator(parser, path, file_name);