Remove generated .h files from repo

2026-06-13 08:14:31 +00:00 · 2025-12-22 05:42:15 +00:00
540 changed files with 32152 additions and 49567 deletions
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -42,7 +42,7 @@ jobs:
        chmod +x flatc
        ./flatc --version
    - name: upload build artifacts
-      uses: actions/upload-artifact@v7
+      uses: actions/upload-artifact@v4
      with:
        name: Linux flatc binary ${{ matrix.cxx }}
        path: flatc
@@ -170,7 +170,7 @@ jobs:
    - name: test
      run: Release\flattests.exe
    - name: upload build artifacts
-      uses: actions/upload-artifact@v7
+      uses: actions/upload-artifact@v4
      with:
        name: Windows flatc binary
        path: Release\flatc.exe
@@ -191,13 +191,14 @@ jobs:

  build-dotnet-windows:
    name: Build .NET Windows
-    runs-on: windows-2022
+    runs-on: windows-2022-64core
    strategy:
      matrix:
        configuration: [
          '',
          '-p:UnsafeByteBuffer=true',
-          '-p:EnableSpanT=true,UnsafeByteBuffer=true'
+          # Fails two tests currently.
+          #'-p:EnableSpanT=true,UnsafeByteBuffer=true'
          ]
    steps:
    - uses: actions/checkout@v6
@@ -208,7 +209,7 @@ jobs:
    - name: Build
      run: |
        cd tests\FlatBuffers.Test
-        dotnet new sln --force --name FlatBuffers.Test --format sln
+        dotnet new sln --force --name FlatBuffers.Test
        dotnet sln FlatBuffers.Test.sln add FlatBuffers.Test.csproj
        dotnet build -c Release ${{matrix.configuration}} FlatBuffers.Test.sln
    - name: Run net6.0
@@ -246,7 +247,7 @@ jobs:
        chmod +x Release/flatc
        Release/flatc --version
    - name: upload build artifacts
-      uses: actions/upload-artifact@v7
+      uses: actions/upload-artifact@v4
      with:
        name: Mac flatc binary Intel
        path: Release/flatc
@@ -289,7 +290,7 @@ jobs:
        chmod +x Release/flatc
        Release/flatc --version
    - name: upload build artifacts
-      uses: actions/upload-artifact@v7
+      uses: actions/upload-artifact@v4
      with:
        name: Mac flatc binary Universal
        path: Release/flatc
@@ -314,7 +315,7 @@ jobs:
   steps:
   - uses: actions/checkout@v6
   - name: set up Java
-     uses: actions/setup-java@v5
+     uses: actions/setup-java@v4
     with:
       distribution: temurin
       java-version: 17
@@ -373,7 +374,7 @@ jobs:
    - name: Run benchmarks
      run: ./flatbenchmark --benchmark_repetitions=5 --benchmark_display_aggregates_only=true --benchmark_out_format=console --benchmark_out=benchmarks/results_${{matrix.cxx}}
    - name: Upload benchmarks results
-      uses: actions/upload-artifact@v7
+      uses: actions/upload-artifact@v4
      with:
        name: Linux flatbenchmark results ${{matrix.cxx}}
        path: benchmarks/results_${{matrix.cxx}}
@@ -394,7 +395,7 @@ jobs:
    - name: Checkout
      uses: actions/checkout@v6
    - name: set up Java
-      uses: actions/setup-java@v5
+      uses: actions/setup-java@v4
      with:
        distribution: temurin
        java-version: 17
@@ -417,7 +418,7 @@ jobs:
    - name: Checkout
      uses: actions/checkout@v6
    - name: set up Java
-      uses: actions/setup-java@v5
+      uses: actions/setup-java@v4
      with:
        distribution: temurin
        java-version: 17
@@ -446,7 +447,7 @@ jobs:

  build-rust-windows:
    name: Build Rust Windows
-    runs-on: windows-2022
+    runs-on: windows-2022-64core
    steps:
    - uses: actions/checkout@v6
    - name: test
@@ -545,7 +546,7 @@ jobs:
      # FIXME: make test script not rely on flatc
      run: cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_INSTALL=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF . && make -j
    - name: pnpm
-      run: npm install -g pnpm
+      run: npm install -g pnpm esbuild
    - name: deps
      run: pnpm i
    - name: compile
@@ -591,16 +592,11 @@ jobs:
    runs-on: ubuntu-24.04
    steps:
      - uses: actions/checkout@v6
-      # Explicitly use 8.5.1 until we can update or https://github.com/actions/runner-images/issues/13564 is fixed.
-      - name: Set env
-        run: >
-          echo "USE_BAZEL_VERSION=8.5.1" >> $GITHUB_ENV
      - name: bazel build
        run: >
          bazel build
          //:flatc
          //:flatbuffers
-          //tests:flatbuffers_test
      - name: bazel test
        run: >
          bazel test
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -21,11 +21,11 @@ jobs:
        run: |
          git config user.name github-actions[bot]
          git config user.email 41898282+github-actions[bot]@users.noreply.github.com
-      - uses: actions/setup-python@v6
+      - uses: actions/setup-python@v5
        with:
          python-version: 3.x
      - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV 
-      - uses: actions/cache@v5
+      - uses: actions/cache@v4
        with:
          key: mkdocs-material-${{ env.cache_id }}
          path: .cache
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -27,7 +27,7 @@ jobs:
       language: c++
       fuzz-seconds: 60
   - name: Upload Crash
-     uses: actions/upload-artifact@v7
+     uses: actions/upload-artifact@v4
     if: failure() && steps.build.outcome == 'success'
     with:
       name: artifacts
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -13,7 +13,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
+      - uses: actions/setup-node@v3
        with:
          node-version: '20.x'
          registry-url: 'https://registry.npmjs.org'
@@ -30,7 +30,7 @@ jobs:
        working-directory: ./python
    steps:
      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
+      - uses: actions/setup-python@v4
        with:
          python-version: '3.10'

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -515,13 +515,13 @@ function(compile_schema SRC_FBS OPT SUFFIX OUT_GEN_FILE)
 endfunction()

 function(compile_schema_for_test SRC_FBS OPT)
-  compile_schema("${SRC_FBS}" "${OPT}" "_generated" GEN_FILE)
+  compile_schema("${SRC_FBS}" "${OPT}" ".fbs" GEN_FILE)
  target_sources(flattests PRIVATE ${GEN_FILE})
 endfunction()

-function(compile_schema_for_test_fbsh SRC_FBS OPT)
+function(compile_schema_for_test_17 SRC_FBS OPT)
  compile_schema("${SRC_FBS}" "${OPT}" ".fbs" GEN_FILE)
-  target_sources(flattests PRIVATE ${GEN_FILE})
+  target_sources(flattests_cpp17 PRIVATE ${GEN_FILE})
 endfunction()

 function(compile_schema_for_samples SRC_FBS OPT)
@@ -548,18 +548,26 @@ if(FLATBUFFERS_BUILD_TESTS)
  # The flattest target needs some generated files
  SET(FLATC_OPT_COMP --cpp --gen-compare --gen-mutable --gen-object-api --reflect-names)
  SET(FLATC_OPT_SCOPED_ENUMS ${FLATC_OPT_COMP};--scoped-enums)
+  SET(FLATC_OPT_NAKED_PTR ${FLATC_OPT_COMP} --cpp-ptr-type naked)

  compile_schema_for_test(tests/alignment_test.fbs "${FLATC_OPT_COMP}")
-  compile_schema_for_test_fbsh(tests/default_vectors_strings_test.fbs "${FLATC_OPT_COMP}")
+  compile_schema_for_test(tests/default_vectors_strings_test.fbs "${FLATC_OPT_COMP}")
+  compile_schema_for_test(tests/monster_extra.fbs "${FLATC_OPT_COMP}")
  compile_schema_for_test(tests/arrays_test.fbs "${FLATC_OPT_SCOPED_ENUMS}")
  compile_schema_for_test(tests/native_inline_table_test.fbs "${FLATC_OPT_COMP}")
  compile_schema_for_test(tests/native_type_test.fbs "${FLATC_OPT_COMP}")
+  compile_schema_for_test(tests/optional_scalars.fbs "${FLATC_OPT_COMP}")
  compile_schema_for_test(tests/key_field/key_field_sample.fbs "${FLATC_OPT_COMP}")
  compile_schema_for_test(tests/64bit/test_64bit.fbs "${FLATC_OPT_COMP};--bfbs-gen-embed")
  compile_schema_for_test(tests/64bit/evolution/v1.fbs "${FLATC_OPT_COMP}")
  compile_schema_for_test(tests/64bit/evolution/v2.fbs "${FLATC_OPT_COMP}")
  compile_schema_for_test(tests/union_underlying_type_test.fbs "${FLATC_OPT_SCOPED_ENUMS}")
-  compile_schema_for_test(tests/cross_namespace_pack_test.fbs "${FLATC_OPT_COMP}")
+  compile_schema_for_test(tests/evolution_test/evolution_v1.fbs "${FLATC_OPT_SCOPED_ENUMS}")
+  compile_schema_for_test(tests/evolution_test/evolution_v2.fbs "${FLATC_OPT_SCOPED_ENUMS}")
+  compile_schema_for_test(tests/vector_table_naked_ptr.fbs "${FLATC_OPT_NAKED_PTR}")
+  compile_schema_for_test(tests/namespace_test/namespace_test1.fbs "${FLATC_OPT_SCOPED_ENUMS}")
+  compile_schema_for_test(tests/namespace_test/namespace_test2.fbs "${FLATC_OPT_SCOPED_ENUMS}")
+  compile_schema_for_test(tests/union_vector/union_vector.fbs "${FLATC_OPT_COMP}")

  if(FLATBUFFERS_CODE_SANITIZE)
    add_fsanitize_to_target(flattests ${FLATBUFFERS_CODE_SANITIZE})
@@ -589,9 +597,19 @@ if(FLATBUFFERS_BUILD_TESTS)
  if(FLATBUFFERS_BUILD_CPP17)
    add_executable(flattests_cpp17 ${FlatBuffers_Tests_CPP17_SRCS})
    target_link_libraries(flattests_cpp17 PRIVATE $<BUILD_INTERFACE:ProjectConfig>)
-    target_include_directories(flattests_cpp17 PUBLIC src tests)
+    target_include_directories(flattests_cpp17 PUBLIC 
+      # Ideally everything is fully qualified from the root directories
+      ${CMAKE_CURRENT_SOURCE_DIR}
+      ${CMAKE_CURRENT_BINARY_DIR}
+      # TODO(derekbailey): update includes to fully qualify src/ and tests/
+      src 
+      tests 
+      ${CMAKE_CURRENT_BINARY_DIR}/tests 
+    )
    target_compile_features(flattests_cpp17 PRIVATE cxx_std_17) # requires cmake 3.8

+    compile_schema_for_test_17(tests/optional_scalars.fbs "${FLATC_OPT_COMP}")
+
    if(FLATBUFFERS_CODE_SANITIZE)
      add_fsanitize_to_target(flattests_cpp17 ${FLATBUFFERS_CODE_SANITIZE})
    endif()
--- a/MODULE.bazel
+++ b/MODULE.bazel
@@ -7,7 +7,7 @@ module(

 bazel_dep(
    name = "aspect_bazel_lib",
-    version = "2.14.0",
+    version = "2.11.0",
 )
 bazel_dep(
    name = "aspect_rules_esbuild",
@@ -23,16 +23,16 @@ bazel_dep(
 )
 bazel_dep(
    name = "grpc",
-    version = "1.76.0",
+    version = "1.70.1",
    repo_name = "com_github_grpc_grpc",
 )
 bazel_dep(
    name = "platforms",
-    version = "0.0.11",
+    version = "0.0.10",
 )
 bazel_dep(
    name = "rules_cc",
-    version = "0.1.1",
+    version = "0.0.16",
 )
 bazel_dep(
    name = "rules_go",
@@ -49,8 +49,7 @@ bazel_dep(
 )
 bazel_dep(
    name = "rules_swift",
-    version = "3.1.2",
-    max_compatibility_level = 3,
+    version = "2.1.1",
    repo_name = "build_bazel_rules_swift",
 )
 bazel_dep(
@@ -63,6 +62,9 @@ npm.npm_translate_lock(
    name = "flatbuffers_npm",
    npmrc = "//:.npmrc",
    pnpm_lock = "//ts:pnpm-lock.yaml",
+    # Override the Bazel package where pnpm-lock.yaml is located and link
+    # to the specified package instead.
+    root_package = "ts",
    verify_node_modules_ignored = "//:.bazelignore",
 )
 use_repo(npm, "flatbuffers_npm")
--- a/dart/lib/src/builder.dart
+++ b/dart/lib/src/builder.dart
@@ -5,7 +5,7 @@ import 'types.dart';

 /// The main builder class for creation of a FlexBuffer.
 class Builder {
-  ByteData _buffer;
+  final ByteData _buffer;
  List<_StackValue> _stack = [];
  List<_StackPointer> _stackPointers = [];
  int _offset = 0;
@@ -506,7 +506,6 @@ class Builder {
    if (prevSize < size) {
      final newBuf = ByteData(size);
      newBuf.buffer.asUint8List().setAll(0, _buffer.buffer.asUint8List());
-      _buffer = newBuf;
    }
    return newOffset;
  }
--- a/dart/test/flex_builder_test.dart
+++ b/dart/test/flex_builder_test.dart
@@ -318,21 +318,6 @@ void main() {
        1,
      ]);
    }
-    {
-      // Default buffer is 2048 bytes, add 2300 bytes of strings that force it
-      // to grow.
-      final s1 = 'A' * 1000;
-      final s2 = 'B' * 800;
-      final s3 = 'C' * 500;
-
-      var flx = Builder()
-        ..startVector()
-        ..addString(s1)
-        ..addString(s2)
-        ..addString(s3)
-        ..end();
-      expect(flx.finish().length, 2323);
-    }
  });

  test('build map', () {
--- a/docs/source/flatc.md
+++ b/docs/source/flatc.md
@@ -79,12 +79,11 @@ list of `FILES...`.
    `myschema.fbs` to JSON:

    ```sh
-    flatc --json myschema.fbs -- mydata.bin
+    flatc --json myschema.fbs mydata.bin
    ```

-    This will generate a `mydata.json` file. If there is no
-    [`file_identifier`](schema.md/#file-identification-and-extension) defined
-    for this schema, you will need to use the `--raw-binary` option.
+    This will generate a `mydata.json` file.
+

 ### Additional options

--- a/docs/source/languages/cpp.md
+++ b/docs/source/languages/cpp.md
@@ -57,7 +57,7 @@ a `char *` array, which you pass to `GetMonster()`.

 ```cpp
    #include "flatbuffers/flatbuffers.h"
-    #include "monster_test_generated.h"
+    #include "monster_test_generate.h"
    #include <iostream> // C++ header file for printing
    #include <fstream> // C++ header file for file access

--- a/docs/source/languages/rust.md
+++ b/docs/source/languages/rust.md
@@ -97,61 +97,6 @@ convenient accessors for all fields, e.g. `hp()`, `mana()`, etc:

 *Note: That we never stored a `mana` value, so it will return the default.*

-## Fallible API and Custom Allocators
-
-Every `FlatBufferBuilder` method that may allocate has a `try_*` counterpart
-(e.g. `try_create_string`, `try_push`, `try_finish`) that returns
-`Result<T, A::Error>` instead of panicking. This is useful when allocation
-failures must be handled gracefully: for example in `no_std` environments or
-with fixed-capacity buffers.
-
-The existing panicking methods are unchanged and remain the simplest option
-when using the default allocator.
-
-#### Custom allocators
-
-Implement the `Allocator` trait and pass it to `FlatBufferBuilder::new_in()`:
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.rs}
-    use flatbuffers::{Allocator, FlatBufferBuilder};
-
-    struct MyAllocator { /* ... */ }
-
-    unsafe impl Allocator for MyAllocator {
-        type Error = MyError;
-        fn grow_downwards(&mut self) -> Result<(), Self::Error> { /* ... */ }
-        fn len(&self) -> usize { /* ... */ }
-    }
-
-    let alloc = MyAllocator::new(/* ... */);
-    let mut builder = FlatBufferBuilder::new_in(alloc);
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-The built-in `DefaultAllocator` uses `Vec<u8>` and sets `Error = Infallible`,
-so the `try_*` methods on a default builder can never fail.
-
-#### Example: building a buffer with error propagation
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.rs}
-    fn build<A: flatbuffers::Allocator>(
-        builder: &mut FlatBufferBuilder<A>,
-    ) -> Result<(), A::Error> {
-        let name = builder.try_create_string("Orc")?;
-        let inventory = builder.try_create_vector(&[0u8, 1, 2, 3, 4])?;
-
-        let table_start = builder.start_table();
-        builder.try_push_slot_always(Monster::VT_NAME, name)?;
-        builder.try_push_slot_always(Monster::VT_INVENTORY, inventory)?;
-        builder.try_push_slot(Monster::VT_HP, 80i16, 100)?;
-        let root = builder.try_end_table(table_start)?;
-
-        builder.try_finish(root, None)?;
-        Ok(())
-    }
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-See the `FlatBufferBuilder` rustdoc for the full list of `try_*` methods.
-
 ## Direct memory access

 As you can see from the above examples, all elements in a buffer are
@@ -260,47 +205,6 @@ And example of usage, for the time being, can be found in
 - Safe getters in [SafeBuffer](https://docs.rs/flatbuffers-reflection/latest/flatbuffers_reflection/struct.SafeBuffer.html),
 which does verification when constructed so you can use it for any data source

-## Buffer pre allocation in a latency-sensitive context
-
-In latency-sensitive applications, dynamic memory allocations can introduce unpredictable latency spikes. The `FlatBufferBuilder` internally uses several `Vec`s that may reallocate during serialization:
-
- The backing buffer for the FlatBuffer data
- `field_locs` for tracking field locations within tables
- `written_vtable_revpos` for deduplicating vtables
- `strings_pool` for shared string interning
-
-To avoid allocations during serialization, you can preallocate all internal vectors upfront using the `with_internal_capacity` constructor:
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.rs}
-    // Preallocate: 1KB buffer, 8 field locations, 16 vtables, 32 shared strings
-    let mut builder = FlatBufferBuilder::with_internal_capacity(1024, 8, 16, 32);
-
-    // All subsequent operations will not allocate (if capacities are sufficient)
-    let name = builder.create_shared_string("MyMonster");
-    // ... build your FlatBuffer ...
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-There are three variants available:
-
- `with_internal_capacity(size, field_locs, vtables, strings)` - Creates a new builder with all capacities preallocated
- `from_vec_with_internal_capacity(buffer, field_locs, vtables, strings)` - Reuses an existing `Vec<u8>` as the backing buffer
- `new_in_with_internal_capacity(allocator, field_locs, vtables, strings)` - Uses a custom `Allocator` with preallocated internal vecs
-
-When combined with `reset()`, you can reuse the same builder across multiple serializations without any allocations after the initial setup:
-
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.rs}
-    let mut builder = FlatBufferBuilder::with_internal_capacity(1024, 8, 16, 32);
-
-    loop {
-        // Build a FlatBuffer (allocation-free if capacities are sufficient)
-        let data = build_message(&mut builder);
-        send(data);
-
-        // Reset for reuse - clears state but retains allocated capacity
-        builder.reset();
-    }
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 ## Useful tools created by others

 * [flatc-rust](https://github.com/frol/flatc-rust) - FlatBuffers compiler
--- a/docs/source/schema.md
+++ b/docs/source/schema.md
@@ -427,6 +427,9 @@ Current understood attributes:
  it won't be accessible anymore by newer code. Note that if you deprecate a
  field that was previous required, old code may fail to validate new data (when
  using the optional verifier).
+
+### `required`
+
 - `required` (on a non-scalar table field): this field must always be set. By
  default, fields do not need to be present in the binary. This is desirable, as
  it helps with forwards/backwards compatibility, and flexibility of data
--- a/docs/source/support.md
+++ b/docs/source/support.md
@@ -26,7 +26,7 @@ Simple mutation                | Yes    | Yes   | Yes      | Yes   | No     | No
 Reflection                     | Yes    | No    | No       | No    | No     | No    | No  | Basic  | No  | No      | No      | No     | No
 Buffer verifier                | Yes    | No    | No       | No    | No     | No    | No  | Yes    | No  | No      | No      | No     | Yes
 Native Object API              | Yes    | No    | Yes      | Yes   | Yes    | Yes   | Yes | No     | No  | Yes     | No      | No     | Yes
-Optional Scalars               | Yes    | Yes   | Yes      | Yes   | No     | Yes   | Yes | Yes    | No  | No      | Yes     | Yes    | Yes
+Optional Scalars               | Yes    | Yes   | Yes      | No    | No     | Yes   | Yes | Yes    | No  | No      | Yes     | Yes    | Yes
 Flexbuffers                    | Yes    | Yes   | ?        | ?     | ?      | ?     | ?   | ?      | ?   | ?       | ?       | Yes    | Yes
 Testing: basic                 | Yes    | Yes   | Yes      | Yes   | Yes    | Yes   | Yes | Yes    | ?   | Yes     | Yes     | Yes    | Yes
 Testing: fuzz                  | Yes    | No    | No       | Yes   | Yes    | No    | No  | No     | ?   | No      | No      | Yes    | No
--- a/docs/source/tutorial.md
+++ b/docs/source/tutorial.md
@@ -1134,8 +1134,12 @@ The Builder provides multiple ways to create `vectors`.
 === "Python"

    ```py
-    # Use the generated helper to create the weapons vector from offsets.
-    weapons = MyGame.Sample.Monster.CreateWeaponsVector(builder, [sword, axe])
+    # Create a FlatBuffer vector and prepend the weapons.
+    # Note: Since we prepend the data, prepend them in reverse order.
+    MyGame.Sample.Monster.StartWeaponsVector(builder, 2)
+    builder.PrependUOffsetTRelative(axe)
+    builder.PrependUOffsetTRelative(sword)
+    weapons = builder.EndVector()
    ```

 === "Rust"
@@ -1348,13 +1352,16 @@ bit more directly.
    ```py
    # Create a `vector` representing the inventory of the Orc. Each number
    # could correspond to an item that can be claimed after he is slain.
-    inv = MyGame.Sample.Monster.CreateInventoryVector(builder, range(0, 10))
+    # Note: Since we prepend the bytes, this loop iterates in reverse.
+    MyGame.Sample.Monster.StartInventoryVector(builder, 10)
+    for i in reversed(range(0, 10)):
+        builder.PrependByte(i)
+    inv = builder.EndVector()

-    path_points = [
-        MyGame.Sample.Vec3T(x=1.0, y=2.0, z=3.0),
-        MyGame.Sample.Vec3T(x=4.0, y=5.0, z=6.0),
-    ]
-    path = MyGame.Sample.Monster.CreatePathVector(builder, path_points)
+    MyGame.Sample.Monster.StartPathVector(builder, 2)
+    MyGame.Sample.Vec3.CreateVec3(builder, 1.0, 2.0, 3.0)
+    MyGame.Sample.Vec3.CreateVec3(builder, 4.0, 5.0, 6.0)
+    path = builder.EndVector()
    ```

 === "Rust"
--- a/goldens/py/flatbuffers/goldens/Universe.py
+++ b/goldens/py/flatbuffers/goldens/Universe.py
@@ -80,12 +80,6 @@ def UniverseStartGalaxiesVector(builder, numElems):
 def StartGalaxiesVector(builder, numElems):
    return UniverseStartGalaxiesVector(builder, numElems)

-def UniverseCreateGalaxiesVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateGalaxiesVector(builder, data):
-    UniverseCreateGalaxiesVector(builder, data)
-
 def UniverseEnd(builder):
    return builder.EndObject()

--- a/goldens/rust/basic_generated.rs
+++ b/goldens/rust/basic_generated.rs
@@ -2,321 +2,294 @@
 // @generated
 extern crate alloc;

+
 #[allow(unused_imports, dead_code)]
 pub mod flatbuffers {
-    extern crate alloc;

-    #[allow(unused_imports, dead_code)]
-    pub mod goldens {
-        extern crate alloc;
-
-        pub enum GalaxyOffset {}
-
-        #[derive(Copy, Clone, PartialEq)]
-        pub struct Galaxy<'a> {
-            pub _tab: ::flatbuffers::Table<'a>,
-        }
-
-        impl<'a> ::flatbuffers::Follow<'a> for Galaxy<'a> {
-            type Inner = Galaxy<'a>;
-
-            #[inline]
-            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-                Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
-            }
-        }
-
-        impl<'a> Galaxy<'a> {
-            pub const VT_NUM_STARS: ::flatbuffers::VOffsetT = 4;
-
-            #[inline]
-            pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-                Galaxy { _tab: table }
-            }
-
-            #[allow(unused_mut)]
-            pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
-                _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
-                args: &'args GalaxyArgs
-            ) -> ::flatbuffers::WIPOffset<Galaxy<'bldr>> {
-                let mut builder = GalaxyBuilder::new(_fbb);
-                builder.add_num_stars(args.num_stars);
-                builder.finish()
-            }
+#[allow(unused_imports, dead_code)]
+pub mod goldens {


-            #[inline]
-            pub fn num_stars(&self) -> i64 {
-                // Safety:
-                // Created from valid Table for this object
-                // which contains a valid value in this slot
-                unsafe { self._tab.get::<i64>(Galaxy::VT_NUM_STARS, Some(0)).unwrap()}
-            }
-        }
+pub enum GalaxyOffset {}
+#[derive(Copy, Clone, PartialEq)]

-        impl ::flatbuffers::Verifiable for Galaxy<'_> {
-            #[inline]
-            fn run_verifier(
-                v: &mut ::flatbuffers::Verifier, pos: usize
-            ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-                v.visit_table(pos)?
-                    .visit_field::<i64>("num_stars", Self::VT_NUM_STARS, false)?
-                    .finish();
-                Ok(())
-            }
-        }
+pub struct Galaxy<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}

-        pub struct GalaxyArgs {
-            pub num_stars: i64,
-        }
+impl<'a> ::flatbuffers::Follow<'a> for Galaxy<'a> {
+  type Inner = Galaxy<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}

-        impl<'a> Default for GalaxyArgs {
-            #[inline]
-            fn default() -> Self {
-                GalaxyArgs {
-                    num_stars: 0,
-                }
-            }
-        }
+impl<'a> Galaxy<'a> {
+  pub const VT_NUM_STARS: ::flatbuffers::VOffsetT = 4;

-        pub struct GalaxyBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
-            fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-            start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
-        }
-
-        impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GalaxyBuilder<'a, 'b, A> {
-            #[inline]
-            pub fn add_num_stars(&mut self, num_stars: i64) {
-                self.fbb_.push_slot::<i64>(Galaxy::VT_NUM_STARS, num_stars, 0);
-            }
-
-            #[inline]
-            pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GalaxyBuilder<'a, 'b, A> {
-                let start = _fbb.start_table();
-                GalaxyBuilder {
-                    fbb_: _fbb,
-                    start_: start,
-                }
-            }
-
-            #[inline]
-            pub fn finish(self) -> ::flatbuffers::WIPOffset<Galaxy<'a>> {
-                let o = self.fbb_.end_table(self.start_);
-                ::flatbuffers::WIPOffset::new(o.value())
-            }
-        }
-
-        impl ::core::fmt::Debug for Galaxy<'_> {
-            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-                let mut ds = f.debug_struct("Galaxy");
-                ds.field("num_stars", &self.num_stars());
-                ds.finish()
-            }
-        }
-
-        pub enum UniverseOffset {}
-
-        #[derive(Copy, Clone, PartialEq)]
-        pub struct Universe<'a> {
-            pub _tab: ::flatbuffers::Table<'a>,
-        }
-
-        impl<'a> ::flatbuffers::Follow<'a> for Universe<'a> {
-            type Inner = Universe<'a>;
-
-            #[inline]
-            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-                Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
-            }
-        }
-
-        impl<'a> Universe<'a> {
-            pub const VT_AGE: ::flatbuffers::VOffsetT = 4;
-            pub const VT_GALAXIES: ::flatbuffers::VOffsetT = 6;
-
-            #[inline]
-            pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-                Universe { _tab: table }
-            }
-
-            #[allow(unused_mut)]
-            pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
-                _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
-                args: &'args UniverseArgs<'args>
-            ) -> ::flatbuffers::WIPOffset<Universe<'bldr>> {
-                let mut builder = UniverseBuilder::new(_fbb);
-                builder.add_age(args.age);
-                if let Some(x) = args.galaxies { builder.add_galaxies(x); }
-                builder.finish()
-            }
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Galaxy { _tab: table }
+  }
+  #[allow(unused_mut)]
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
+    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
+    args: &'args GalaxyArgs
+  ) -> ::flatbuffers::WIPOffset<Galaxy<'bldr>> {
+    let mut builder = GalaxyBuilder::new(_fbb);
+    builder.add_num_stars(args.num_stars);
+    builder.finish()
+  }


-            #[inline]
-            pub fn age(&self) -> f64 {
-                // Safety:
-                // Created from valid Table for this object
-                // which contains a valid value in this slot
-                unsafe { self._tab.get::<f64>(Universe::VT_AGE, Some(0.0)).unwrap()}
-            }
+  #[inline]
+  pub fn num_stars(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(Galaxy::VT_NUM_STARS, Some(0)).unwrap()}
+  }
+}

-            #[inline]
-            pub fn galaxies(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy<'a>>>> {
-                // Safety:
-                // Created from valid Table for this object
-                // which contains a valid value in this slot
-                unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy>>>>(Universe::VT_GALAXIES, None)}
-            }
-        }
+impl ::flatbuffers::Verifiable for Galaxy<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<i64>("num_stars", Self::VT_NUM_STARS, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct GalaxyArgs {
+    pub num_stars: i64,
+}
+impl<'a> Default for GalaxyArgs {
+  #[inline]
+  fn default() -> Self {
+    GalaxyArgs {
+      num_stars: 0,
+    }
+  }
+}

-        impl ::flatbuffers::Verifiable for Universe<'_> {
-            #[inline]
-            fn run_verifier(
-                v: &mut ::flatbuffers::Verifier, pos: usize
-            ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-                v.visit_table(pos)?
-                    .visit_field::<f64>("age", Self::VT_AGE, false)?
-                    .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Galaxy>>>>("galaxies", Self::VT_GALAXIES, false)?
-                    .finish();
-                Ok(())
-            }
-        }
+pub struct GalaxyBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
+  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+}
+impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GalaxyBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_num_stars(&mut self, num_stars: i64) {
+    self.fbb_.push_slot::<i64>(Galaxy::VT_NUM_STARS, num_stars, 0);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GalaxyBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    GalaxyBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Galaxy<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}

-        pub struct UniverseArgs<'a> {
-            pub age: f64,
-            pub galaxies: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy<'a>>>>>,
-        }
+impl ::core::fmt::Debug for Galaxy<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Galaxy");
+      ds.field("num_stars", &self.num_stars());
+      ds.finish()
+  }
+}
+pub enum UniverseOffset {}
+#[derive(Copy, Clone, PartialEq)]

-        impl<'a> Default for UniverseArgs<'a> {
-            #[inline]
-            fn default() -> Self {
-                UniverseArgs {
-                    age: 0.0,
-                    galaxies: None,
-                }
-            }
-        }
+pub struct Universe<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}

-        pub struct UniverseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
-            fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-            start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
-        }
+impl<'a> ::flatbuffers::Follow<'a> for Universe<'a> {
+  type Inner = Universe<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}

-        impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UniverseBuilder<'a, 'b, A> {
-            #[inline]
-            pub fn add_age(&mut self, age: f64) {
-                self.fbb_.push_slot::<f64>(Universe::VT_AGE, age, 0.0);
-            }
+impl<'a> Universe<'a> {
+  pub const VT_AGE: ::flatbuffers::VOffsetT = 4;
+  pub const VT_GALAXIES: ::flatbuffers::VOffsetT = 6;

-            #[inline]
-            pub fn add_galaxies(&mut self, galaxies: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Galaxy<'b >>>>) {
-                self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Universe::VT_GALAXIES, galaxies);
-            }
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Universe { _tab: table }
+  }
+  #[allow(unused_mut)]
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
+    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
+    args: &'args UniverseArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<Universe<'bldr>> {
+    let mut builder = UniverseBuilder::new(_fbb);
+    builder.add_age(args.age);
+    if let Some(x) = args.galaxies { builder.add_galaxies(x); }
+    builder.finish()
+  }

-            #[inline]
-            pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> UniverseBuilder<'a, 'b, A> {
-                let start = _fbb.start_table();
-                UniverseBuilder {
-                    fbb_: _fbb,
-                    start_: start,
-                }
-            }

-            #[inline]
-            pub fn finish(self) -> ::flatbuffers::WIPOffset<Universe<'a>> {
-                let o = self.fbb_.end_table(self.start_);
-                ::flatbuffers::WIPOffset::new(o.value())
-            }
-        }
+  #[inline]
+  pub fn age(&self) -> f64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f64>(Universe::VT_AGE, Some(0.0)).unwrap()}
+  }
+  #[inline]
+  pub fn galaxies(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy<'a>>>> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy>>>>(Universe::VT_GALAXIES, None)}
+  }
+}

-        impl ::core::fmt::Debug for Universe<'_> {
-            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-                let mut ds = f.debug_struct("Universe");
-                ds.field("age", &self.age());
-                ds.field("galaxies", &self.galaxies());
-                ds.finish()
-            }
-        }
+impl ::flatbuffers::Verifiable for Universe<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<f64>("age", Self::VT_AGE, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Galaxy>>>>("galaxies", Self::VT_GALAXIES, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct UniverseArgs<'a> {
+    pub age: f64,
+    pub galaxies: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy<'a>>>>>,
+}
+impl<'a> Default for UniverseArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    UniverseArgs {
+      age: 0.0,
+      galaxies: None,
+    }
+  }
+}

-        /// Verifies that a buffer of bytes contains a `Universe`
-        /// and returns it.
-        /// Note that verification is still experimental and may not
-        /// catch every error, or be maximally performant. For the
-        /// previous, unchecked, behavior use
-        /// `root_as_universe_unchecked`.
-        #[inline]
-        pub fn root_as_universe(buf: &[u8]) -> Result<Universe<'_>, ::flatbuffers::InvalidFlatbuffer> {
-            ::flatbuffers::root::<Universe>(buf)
-        }
+pub struct UniverseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
+  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+}
+impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UniverseBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_age(&mut self, age: f64) {
+    self.fbb_.push_slot::<f64>(Universe::VT_AGE, age, 0.0);
+  }
+  #[inline]
+  pub fn add_galaxies(&mut self, galaxies: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Galaxy<'b >>>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Universe::VT_GALAXIES, galaxies);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> UniverseBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    UniverseBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Universe<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}

-        /// Verifies that a buffer of bytes contains a size prefixed
-        /// `Universe` and returns it.
-        /// Note that verification is still experimental and may not
-        /// catch every error, or be maximally performant. For the
-        /// previous, unchecked, behavior use
-        /// `size_prefixed_root_as_universe_unchecked`.
-        #[inline]
-        pub fn size_prefixed_root_as_universe(buf: &[u8]) -> Result<Universe<'_>, ::flatbuffers::InvalidFlatbuffer> {
-            ::flatbuffers::size_prefixed_root::<Universe>(buf)
-        }
+impl ::core::fmt::Debug for Universe<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Universe");
+      ds.field("age", &self.age());
+      ds.field("galaxies", &self.galaxies());
+      ds.finish()
+  }
+}
+#[inline]
+/// Verifies that a buffer of bytes contains a `Universe`
+/// and returns it.
+/// Note that verification is still experimental and may not
+/// catch every error, or be maximally performant. For the
+/// previous, unchecked, behavior use
+/// `root_as_universe_unchecked`.
+pub fn root_as_universe(buf: &[u8]) -> Result<Universe<'_>, ::flatbuffers::InvalidFlatbuffer> {
+  ::flatbuffers::root::<Universe>(buf)
+}
+#[inline]
+/// Verifies that a buffer of bytes contains a size prefixed
+/// `Universe` and returns it.
+/// Note that verification is still experimental and may not
+/// catch every error, or be maximally performant. For the
+/// previous, unchecked, behavior use
+/// `size_prefixed_root_as_universe_unchecked`.
+pub fn size_prefixed_root_as_universe(buf: &[u8]) -> Result<Universe<'_>, ::flatbuffers::InvalidFlatbuffer> {
+  ::flatbuffers::size_prefixed_root::<Universe>(buf)
+}
+#[inline]
+/// Verifies, with the given options, that a buffer of bytes
+/// contains a `Universe` and returns it.
+/// Note that verification is still experimental and may not
+/// catch every error, or be maximally performant. For the
+/// previous, unchecked, behavior use
+/// `root_as_universe_unchecked`.
+pub fn root_as_universe_with_opts<'b, 'o>(
+  opts: &'o ::flatbuffers::VerifierOptions,
+  buf: &'b [u8],
+) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
+  ::flatbuffers::root_with_opts::<Universe<'b>>(opts, buf)
+}
+#[inline]
+/// Verifies, with the given verifier options, that a buffer of
+/// bytes contains a size prefixed `Universe` and returns
+/// it. Note that verification is still experimental and may not
+/// catch every error, or be maximally performant. For the
+/// previous, unchecked, behavior use
+/// `root_as_universe_unchecked`.
+pub fn size_prefixed_root_as_universe_with_opts<'b, 'o>(
+  opts: &'o ::flatbuffers::VerifierOptions,
+  buf: &'b [u8],
+) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
+  ::flatbuffers::size_prefixed_root_with_opts::<Universe<'b>>(opts, buf)
+}
+#[inline]
+/// Assumes, without verification, that a buffer of bytes contains a Universe and returns it.
+/// # Safety
+/// Callers must trust the given bytes do indeed contain a valid `Universe`.
+pub unsafe fn root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {
+  unsafe { ::flatbuffers::root_unchecked::<Universe>(buf) }
+}
+#[inline]
+/// Assumes, without verification, that a buffer of bytes contains a size prefixed Universe and returns it.
+/// # Safety
+/// Callers must trust the given bytes do indeed contain a valid size prefixed `Universe`.
+pub unsafe fn size_prefixed_root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {
+  unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Universe>(buf) }
+}
+#[inline]
+pub fn finish_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
+    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    root: ::flatbuffers::WIPOffset<Universe<'a>>) {
+  fbb.finish(root, None);
+}

-        /// Verifies, with the given options, that a buffer of bytes
-        /// contains a `Universe` and returns it.
-        /// Note that verification is still experimental and may not
-        /// catch every error, or be maximally performant. For the
-        /// previous, unchecked, behavior use
-        /// `root_as_universe_unchecked`.
-        #[inline]
-        pub fn root_as_universe_with_opts<'b, 'o>(
-            opts: &'o ::flatbuffers::VerifierOptions,
-            buf: &'b [u8],
-        ) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
-            ::flatbuffers::root_with_opts::<Universe<'b>>(opts, buf)
-        }
+#[inline]
+pub fn finish_size_prefixed_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset<Universe<'a>>) {
+  fbb.finish_size_prefixed(root, None);
+}
+}  // pub mod goldens
+}  // pub mod flatbuffers

-        /// Verifies, with the given verifier options, that a buffer of
-        /// bytes contains a size prefixed `Universe` and returns
-        /// it. Note that verification is still experimental and may not
-        /// catch every error, or be maximally performant. For the
-        /// previous, unchecked, behavior use
-        /// `root_as_universe_unchecked`.
-        #[inline]
-        pub fn size_prefixed_root_as_universe_with_opts<'b, 'o>(
-            opts: &'o ::flatbuffers::VerifierOptions,
-            buf: &'b [u8],
-        ) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
-            ::flatbuffers::size_prefixed_root_with_opts::<Universe<'b>>(opts, buf)
-        }
-
-        /// Assumes, without verification, that a buffer of bytes contains a Universe and returns it.
-        /// # Safety
-        /// Callers must trust the given bytes do indeed contain a valid `Universe`.
-        #[inline]
-        pub unsafe fn root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {
-            unsafe { ::flatbuffers::root_unchecked::<Universe>(buf) }
-        }
-
-        /// Assumes, without verification, that a buffer of bytes contains a size prefixed Universe and returns it.
-        /// # Safety
-        /// Callers must trust the given bytes do indeed contain a valid size prefixed `Universe`.
-        #[inline]
-        pub unsafe fn size_prefixed_root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {
-            unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Universe>(buf) }
-        }
-
-        #[inline]
-        pub fn finish_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
-            fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-            root: ::flatbuffers::WIPOffset<Universe<'a>>
-        ) {
-            fbb.finish(root, None);
-        }
-
-        #[inline]
-        pub fn finish_size_prefixed_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
-            fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-            root: ::flatbuffers::WIPOffset<Universe<'a>>
-        ) {
-            fbb.finish_size_prefixed(root, None);
-        }
-    } // pub mod goldens
-} // pub mod flatbuffers
--- a/goldens/ts/flatbuffers/goldens/universe.ts
+++ b/goldens/ts/flatbuffers/goldens/universe.ts
@@ -4,7 +4,7 @@

 import * as flatbuffers from 'flatbuffers';

-import { Galaxy } from './galaxy.js';
+import { Galaxy } from '../../flatbuffers/goldens/galaxy.js';


 export class Universe {
--- a/grpc/examples/swift/Greeter/Sources/Model/greeter_generated.swift
+++ b/grpc/examples/swift/Greeter/Sources/Model/greeter_generated.swift
@@ -17,14 +17,16 @@ public struct models_HelloReply: FlatBufferTable, FlatbuffersVectorInitializable
  private init(_ t: Table) { _accessor = t }
  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }

-  private struct VT {
-    static let message: VOffset = 4
+  private enum VTOFFSET: VOffset {
+    case message = 4
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
  }

-  public var message: String? { let o = _accessor.offset(VT.message); return o == 0 ? nil : _accessor.string(at: o) }
-  public var messageSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.message) }
+  public var message: String? { let o = _accessor.offset(VTOFFSET.message.v); return o == 0 ? nil : _accessor.string(at: o) }
+  public var messageSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.message.v) }
  public static func startHelloReply(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
-  public static func add(message: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: message, at: VT.message) }
+  public static func add(message: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: message, at: VTOFFSET.message.p) }
  public static func endHelloReply(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
  public static func createHelloReply(
    _ fbb: inout FlatBufferBuilder,
@@ -37,16 +39,16 @@ public struct models_HelloReply: FlatBufferTable, FlatbuffersVectorInitializable

  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
    var _v = try verifier.visitTable(at: position)
-    try _v.visit(field: VT.message, fieldName: "message", required: false, type: ForwardOffset<String>.self)
+    try _v.visit(field: VTOFFSET.message.p, fieldName: "message", required: false, type: ForwardOffset<String>.self)
    _v.finish()
  }
 }

 extension models_HelloReply: Encodable {
+
  enum CodingKeys: String, CodingKey {
    case message = "message"
  }
-
  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    try container.encodeIfPresent(message, forKey: .message)
@@ -62,14 +64,16 @@ public struct models_HelloRequest: FlatBufferTable, FlatbuffersVectorInitializab
  private init(_ t: Table) { _accessor = t }
  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }

-  private struct VT {
-    static let name: VOffset = 4
+  private enum VTOFFSET: VOffset {
+    case name = 4
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
  }

-  public var name: String? { let o = _accessor.offset(VT.name); return o == 0 ? nil : _accessor.string(at: o) }
-  public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.name) }
+  public var name: String? { let o = _accessor.offset(VTOFFSET.name.v); return o == 0 ? nil : _accessor.string(at: o) }
+  public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.name.v) }
  public static func startHelloRequest(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
-  public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VT.name) }
+  public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VTOFFSET.name.p) }
  public static func endHelloRequest(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
  public static func createHelloRequest(
    _ fbb: inout FlatBufferBuilder,
@@ -82,16 +86,16 @@ public struct models_HelloRequest: FlatBufferTable, FlatbuffersVectorInitializab

  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
    var _v = try verifier.visitTable(at: position)
-    try _v.visit(field: VT.name, fieldName: "name", required: false, type: ForwardOffset<String>.self)
+    try _v.visit(field: VTOFFSET.name.p, fieldName: "name", required: false, type: ForwardOffset<String>.self)
    _v.finish()
  }
 }

 extension models_HelloRequest: Encodable {
+
  enum CodingKeys: String, CodingKey {
    case name = "name"
  }
-
  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    try container.encodeIfPresent(name, forKey: .name)
--- a/grpc/examples/ts/greeter/src/models.ts
+++ b/grpc/examples/ts/greeter/src/models.ts
@@ -2,5 +2,5 @@

 /* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */

-export {HelloReply} from './models/hello-reply.js';
-export {HelloRequest} from './models/hello-request.js';
+export { HelloReply } from './models/hello-reply.js';
+export { HelloRequest } from './models/hello-request.js';
--- a/grpc/examples/ts/greeter/src/models/hello-reply.ts
+++ b/grpc/examples/ts/greeter/src/models/hello-reply.ts
@@ -8,7 +8,7 @@ import * as flatbuffers from 'flatbuffers';

 export class HelloReply {
  bb: flatbuffers.ByteBuffer|null = null;
-  bb_pos: number = 0;
+  bb_pos = 0;
  __init(i:number, bb:flatbuffers.ByteBuffer):HelloReply {
  this.bb_pos = i;
  this.bb = bb;
@@ -31,11 +31,11 @@ message(optionalEncoding?:any):string|Uint8Array|null {
  return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
 }

-static startHelloReply(builder:flatbuffers.Builder):void {
+static startHelloReply(builder:flatbuffers.Builder) {
  builder.startObject(1);
 }

-static addMessage(builder:flatbuffers.Builder, messageOffset:flatbuffers.Offset):void {
+static addMessage(builder:flatbuffers.Builder, messageOffset:flatbuffers.Offset) {
  builder.addFieldOffset(0, messageOffset, 0);
 }

--- a/grpc/examples/ts/greeter/src/models/hello-request.ts
+++ b/grpc/examples/ts/greeter/src/models/hello-request.ts
@@ -8,7 +8,7 @@ import * as flatbuffers from 'flatbuffers';

 export class HelloRequest {
  bb: flatbuffers.ByteBuffer|null = null;
-  bb_pos: number = 0;
+  bb_pos = 0;
  __init(i:number, bb:flatbuffers.ByteBuffer):HelloRequest {
  this.bb_pos = i;
  this.bb = bb;
@@ -31,11 +31,11 @@ name(optionalEncoding?:any):string|Uint8Array|null {
  return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
 }

-static startHelloRequest(builder:flatbuffers.Builder):void {
+static startHelloRequest(builder:flatbuffers.Builder) {
  builder.startObject(1);
 }

-static addName(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset):void {
+static addName(builder:flatbuffers.Builder, nameOffset:flatbuffers.Offset) {
  builder.addFieldOffset(0, nameOffset, 0);
 }

--- a/grpc/src/compiler/python_generator.cc
+++ b/grpc/src/compiler/python_generator.cc
@@ -172,7 +172,6 @@ class StubGenerator : public BaseGenerator {
       << "  def __init__(self, channel: grpc.Channel) -> None: ...\n";

    for (const RPCCall* method : service->calls.vec) {
-      imports->Import("typing");
      std::string request = "bytes";
      std::string response = "bytes";

@@ -184,22 +183,14 @@ class StubGenerator : public BaseGenerator {
        imports->Import(ModuleFor(method->response), response);
      }

-      ss << "  def " << method->name << "(\n";
-      ss << "      self,\n";
+      ss << "  def " << method->name << "(self, ";
      if (ClientStreaming(method)) {
-        ss << "      request_iterator: typing.Iterator[" << request << "]\n";
+        imports->Import("typing");
+        ss << "request_iterator: typing.Iterator[" << request << "]";
      } else {
-        ss << "      request: " << request << ",\n";
+        ss << "request: " << request;
      }
-
-      ss << "      timeout: float | None = None,\n";
-      // https://github.com/python/typeshed/blob/ccf9411fb1f5bee2a8e3d278889de17a08f7bbe3/stubs/grpcio/grpc/__init__.pyi#L37
-      ss << "      metadata: typing.Sequence[tuple[str, typing.Union[str, bytes]]] | None = None,\n";
-      ss << "      credentials: grpc.CallCredentials | None = None,\n";
-      ss << "      wait_for_ready: bool | None = None,\n";
-      ss << "      compression: grpc.Compression | None = None\n";
-
-      ss << "  ) -> ";
+      ss << ") -> ";
      if (ServerStreaming(method)) {
        imports->Import("typing");
        ss << "typing.Iterator[" << response << "]";
--- a/include/codegen/namer.h
+++ b/include/codegen/namer.h
@@ -91,14 +91,6 @@ class Namer {
    std::string keyword_prefix;
    // Suffix used to escape keywords. It is usually "_".
    std::string keyword_suffix;
-    // The casing used for keywords when escaping. For most languages, keywords
-    // are case sensitive. PHP is an instance where some keywords are case
-    // insensitive.
-    enum class KeywordsCasing {
-      CaseSensitive,
-      CaseInsensitive,
-    };
-    KeywordsCasing keywords_casing;

    // Files.

@@ -212,16 +204,8 @@ class Namer {
    return result;
  }

-  virtual std::string NormalizeKeywordCase(const std::string& name) const {
-    if (config_.keywords_casing == Config::KeywordsCasing::CaseInsensitive) {
-      return ConvertCase(name, Case::kAllLower);
-    } else {
-      return name;
-    }
-  }
-
  virtual std::string EscapeKeyword(const std::string& name) const {
-    if (keywords_.find(NormalizeKeywordCase(name)) == keywords_.end()) {
+    if (keywords_.find(name) == keywords_.end()) {
      return name;
    } else {
      return config_.keyword_prefix + name + config_.keyword_suffix;
--- a/include/codegen/python.h
+++ b/include/codegen/python.h
@@ -26,7 +26,6 @@ static const Namer::Config kConfig = {
    /*object_suffix=*/"T",
    /*keyword_prefix=*/"",
    /*keyword_suffix=*/"_",
-    /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
    /*filenames=*/Case::kKeep,
    /*directories=*/Case::kKeep,
    /*output_path=*/"",
@@ -50,7 +49,6 @@ static const Namer::Config kStubConfig = {
    /*object_suffix=*/"T",
    /*keyword_prefix=*/"",
    /*keyword_suffix=*/"_",
-    /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
    /*filenames=*/Case::kKeep,
    /*directories=*/Case::kKeep,
    /*output_path=*/"",
--- a/include/flatbuffers/flatbuffers.h
+++ b/include/flatbuffers/flatbuffers.h
@@ -260,15 +260,15 @@ inline const char* flatbuffers_version_string() {
    inline FLATBUFFERS_CONSTEXPR_CPP11 E operator ~ (E lhs){\
        return E(~T(lhs));\
    }\
-    inline FLATBUFFERS_CONSTEXPR_CPP14 E operator |= (E &lhs, E rhs){\
+    inline FLATBUFFERS_CONSTEXPR_CPP11 E operator |= (E &lhs, E rhs){\
        lhs = lhs | rhs;\
        return lhs;\
    }\
-    inline FLATBUFFERS_CONSTEXPR_CPP14 E operator &= (E &lhs, E rhs){\
+    inline FLATBUFFERS_CONSTEXPR_CPP11 E operator &= (E &lhs, E rhs){\
        lhs = lhs & rhs;\
        return lhs;\
    }\
-    inline FLATBUFFERS_CONSTEXPR_CPP14 E operator ^= (E &lhs, E rhs){\
+    inline FLATBUFFERS_CONSTEXPR_CPP11 E operator ^= (E &lhs, E rhs){\
        lhs = lhs ^ rhs;\
        return lhs;\
    }\
--- a/include/flatbuffers/flexbuffers.h
+++ b/include/flatbuffers/flexbuffers.h
@@ -1207,20 +1207,11 @@ class Builder FLATBUFFERS_FINAL_CLASS {
    String(str);
  }

-  size_t AlignedBlob(const void* data, size_t len, BitWidth alignment) {
-    // The requested alignment must not be smaller than the one required to
-    // store the length.
-    return CreateAlignedBlob(data, len, 0, FBT_BLOB,
-                             std::max(alignment, WidthU(len)));
-  }
-  size_t AlignedBlob(const std::vector<uint8_t>& v, BitWidth alignment) {
-    return AlignedBlob(v.data(), v.size(), alignment);
-  }
  size_t Blob(const void* data, size_t len) {
    return CreateBlob(data, len, 0, FBT_BLOB);
  }
  size_t Blob(const std::vector<uint8_t>& v) {
-    return Blob(v.data(), v.size());
+    return CreateBlob(v.data(), v.size(), 0, FBT_BLOB);
  }

  void Blob(const char* key, const void* data, size_t len) {
@@ -1702,16 +1693,11 @@ class Builder FLATBUFFERS_FINAL_CLASS {

  size_t CreateBlob(const void* data, size_t len, size_t trailing, Type type) {
    auto bit_width = WidthU(len);
-    return CreateAlignedBlob(data, len, trailing, type, bit_width);
-  }
-
-  size_t CreateAlignedBlob(const void* data, size_t len, size_t trailing,
-                           Type type, BitWidth alignment) {
-    auto byte_width = Align(alignment);
+    auto byte_width = Align(bit_width);
    Write<uint64_t>(len, byte_width);
    auto sloc = buf_.size();
    WriteBytes(data, len + trailing);
-    stack_.push_back(Value(static_cast<uint64_t>(sloc), type, alignment));
+    stack_.push_back(Value(static_cast<uint64_t>(sloc), type, bit_width));
    return sloc;
  }

--- a/include/flatbuffers/idl.h
+++ b/include/flatbuffers/idl.h
@@ -223,7 +223,7 @@ struct Type {
  uint16_t fixed_length;  // only set if t == BASE_TYPE_ARRAY
 };

-// Represents a parsed scalar value, its type, and field offset.
+// Represents a parsed scalar value, it's type, and field offset.
 struct Value {
  Value()
      : constant("0"),
@@ -395,20 +395,13 @@ struct FieldDef : public Definition {
 };

 struct StructDef : public Definition {
-  enum class CycleStatus {
-    NotChecked,
-    InProgress,
-    Checked,
-  };
-
  StructDef()
      : fixed(false),
        predecl(true),
        sortbysize(true),
        has_key(false),
        minalign(1),
-        bytesize(0),
-        cycle_status{CycleStatus::NotChecked} {}
+        bytesize(0) {}

  void PadLastField(size_t min_align) {
    auto padding = PaddingBytes(bytesize, min_align);
@@ -430,8 +423,6 @@ struct StructDef : public Definition {
  size_t minalign;  // What the whole object needs to be aligned to.
  size_t bytesize;  // Size if fixed.

-  CycleStatus cycle_status;  // used for determining if we have circular references
-
  flatbuffers::unique_ptr<std::string> original_location;
  std::vector<voffset_t> reserved_ids;
 };
@@ -743,7 +734,6 @@ struct IDLOptions {
  bool python_gen_numpy;

  bool ts_omit_entrypoint;
-  bool ts_undefined_for_optionals;
  ProtoIdGapAction proto_id_gap_action;

  // Possible options for the more general generator below.
@@ -870,7 +860,6 @@ struct IDLOptions {
        python_typing(false),
        python_gen_numpy(true),
        ts_omit_entrypoint(false),
-        ts_undefined_for_optionals(false),
        proto_id_gap_action(ProtoIdGapAction::WARNING),
        mini_reflect(IDLOptions::kNone),
        require_explicit_ids(false),
@@ -1110,8 +1099,6 @@ class Parser : public ParserState {
  // others includes.
  std::vector<IncludedFile> GetIncludedFiles() const;

-  bool HasCircularStructDependency();
-
 private:
  class ParseDepthGuard;

--- a/include/flatbuffers/reflection.h
+++ b/include/flatbuffers/reflection.h
@@ -30,52 +30,50 @@ namespace flatbuffers {

 // ------------------------- GETTERS -------------------------

-constexpr bool IsScalar(reflection::BaseType t) {
+inline bool IsScalar(reflection::BaseType t) {
  return t >= reflection::UType && t <= reflection::Double;
 }
-constexpr bool IsInteger(reflection::BaseType t) {
+inline bool IsInteger(reflection::BaseType t) {
  return t >= reflection::UType && t <= reflection::ULong;
 }
-constexpr bool IsFloat(reflection::BaseType t) {
+inline bool IsFloat(reflection::BaseType t) {
  return t == reflection::Float || t == reflection::Double;
 }
-constexpr bool IsLong(reflection::BaseType t) {
+inline bool IsLong(reflection::BaseType t) {
  return t == reflection::Long || t == reflection::ULong;
 }

-// This needs to correspond to the BaseType enum.
-constexpr size_t kBaseTypeSize[] = {
-    0,  // None
-    1,  // UType
-    1,  // Bool
-    1,  // Byte
-    1,  // UByte
-    2,  // Short
-    2,  // UShort
-    4,  // Int
-    4,  // UInt
-    8,  // Long
-    8,  // ULong
-    4,  // Float
-    8,  // Double
-    4,  // String
-    4,  // Vector
-    4,  // Obj
-    4,  // Union
-    0,  // Array. Only used in structs. 0 was chosen to prevent out-of-bounds
-        // errors.
-    8,  // Vector64
-
-    0  // MaxBaseType. This must be kept the last entry in this array.
-};
-static_assert(sizeof(kBaseTypeSize) / sizeof(size_t) ==
-                  reflection::MaxBaseType + 1,
-              "Size of sizes[] array does not match the count of BaseType "
-              "enum values.");
-
 // Size of a basic type, don't use with structs.
-constexpr size_t GetTypeSize(reflection::BaseType base_type) {
-  return kBaseTypeSize[base_type];
+inline size_t GetTypeSize(reflection::BaseType base_type) {
+  // This needs to correspond to the BaseType enum.
+  static size_t sizes[] = {
+      0,  // None
+      1,  // UType
+      1,  // Bool
+      1,  // Byte
+      1,  // UByte
+      2,  // Short
+      2,  // UShort
+      4,  // Int
+      4,  // UInt
+      8,  // Long
+      8,  // ULong
+      4,  // Float
+      8,  // Double
+      4,  // String
+      4,  // Vector
+      4,  // Obj
+      4,  // Union
+      0,  // Array. Only used in structs. 0 was chosen to prevent out-of-bounds
+          // errors.
+      8,  // Vector64
+
+      0  // MaxBaseType. This must be kept the last entry in this array.
+  };
+  static_assert(sizeof(sizes) / sizeof(size_t) == reflection::MaxBaseType + 1,
+                "Size of sizes[] array does not match the count of BaseType "
+                "enum values.");
+  return sizes[base_type];
 }

 // Same as above, but now correctly returns the size of a struct if
@@ -422,7 +420,7 @@ pointer_inside_vector<T, U> piv(T* ptr, std::vector<U>& vec) {
  return pointer_inside_vector<T, U>(ptr, vec);
 }

-constexpr const char* UnionTypeFieldSuffix() { return "_type"; }
+inline const char* UnionTypeFieldSuffix() { return "_type"; }

 // Helper to figure out the actual table type a union refers to.
 inline const reflection::Object& GetUnionType(
--- a/kotlin/flatbuffers-kotlin/src/nativeMain/kotlin/com/google/flatbuffers/kotlin/ByteArray.kt
+++ b/kotlin/flatbuffers-kotlin/src/nativeMain/kotlin/com/google/flatbuffers/kotlin/ByteArray.kt
@@ -14,12 +14,9 @@
 * limitations under the License.
 */
@file:Suppress("NOTHING_TO_INLINE")
-@file:OptIn(ExperimentalNativeApi::class)

 package com.google.flatbuffers.kotlin

-import kotlin.experimental.ExperimentalNativeApi
-
 /**
 * This implementation assumes that of native macOSX64 the byte order of the implementation is
 * Little Endian.
--- a/lua/flatbuffers/builder.lua
+++ b/lua/flatbuffers/builder.lua
@@ -296,62 +296,25 @@ function mt:Slot(slotnum)
    self.currentVTable[slotnum + 1] = self:Offset()
 end

-local function finish(self, rootTable, sizePrefix, fileIdentifier)
+local function finish(self, rootTable, sizePrefix)
    UOffsetT:EnforceNumber(rootTable)
-    local hasFid = fileIdentifier ~= nil
-    if hasFid then
-        assert(#fileIdentifier == 4, "File identifier must be exactly 4 bytes")
-    end
-
-    local fid_byte_count = (hasFid and 4 or 0)
-
-    -- alignment:
-    -- root offset (4)
-    -- optional file id (4)
-    -- optional size prefix (4)
-    self:Prep(
-        self.minalign,
-        (sizePrefix and 4 or 0) +
-        4 +
-        fid_byte_count
-    )
-
-    -- root offset (points past file identifier if present)
-    self:PrependUOffsetTRelative(rootTable + fid_byte_count)
-
-    -- file identifier
-    if hasFid then
-        for i = 4, 1, -1 do
-            self:PrependByte(string.byte(fileIdentifier, i))
-        end
-    end
-
-    -- size prefix
+    self:Prep(self.minalign, sizePrefix and 8 or 4)
+    self:PrependUOffsetTRelative(rootTable)
    if sizePrefix then
        local size = self.bytes.size - self.head
        Int32:EnforceNumber(size)
        self:PrependInt32(size)
    end
-
    self.finished = true
    return self.head
 end

-
 function mt:Finish(rootTable)
-    return finish(self, rootTable, false, nil)
+    return finish(self, rootTable, false)
 end

 function mt:FinishSizePrefixed(rootTable)
-    return finish(self, rootTable, true, nil)
-end
-
-function mt:FinishWithIdentifier(rootTable, fileIdentifier)
-    return finish(self, rootTable, false, fileIdentifier)
-end
-
-function mt:FinishSizePrefixedWithIdentifier(rootTable, fileIdentifier)
-    return finish(self, rootTable, true, fileIdentifier)
+    return finish(self, rootTable, true)
 end

 function mt:Prepend(flags, off)
--- a/net/FlatBuffers/FlatBufferBuilder.cs
+++ b/net/FlatBuffers/FlatBufferBuilder.cs
@@ -438,7 +438,8 @@ namespace Google.FlatBuffers
            if (off > Offset)
                throw new ArgumentException();

-            off = Offset - off + sizeof(int);
+            if (off != 0)
+                off = Offset - off + sizeof(int);
            PutInt(off);
        }

--- a/net/FlatBuffers/Table.cs
+++ b/net/FlatBuffers/Table.cs
@@ -65,7 +65,11 @@ namespace Google.FlatBuffers
        // Create a .NET String from UTF-8 data stored inside the flatbuffer.
        public string __string(int offset)
        {
-            offset += bb.GetInt(offset);
+            int stringOffset = bb.GetInt(offset);
+            if (stringOffset == 0)
+                return null;
+
+            offset += stringOffset;
            var len = bb.GetInt(offset);
            var startPos = offset + sizeof(int);
            return bb.GetStringUTF8(startPos, len);
@@ -146,7 +150,7 @@ namespace Google.FlatBuffers

            var pos = this.__vector(o);
            var len = this.__vector_len(o);
-            return bb.ToArray<T>(pos, len * ByteBuffer.SizeOf<T>());
+            return bb.ToArray<T>(pos, len);
        }

        // Initialize any Table-derived type to point to the union at the given offset.
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -33,12 +33,6 @@ importers:
        specifier: ^8.34.1
        version: 8.34.1(eslint@9.29.0)(typescript@5.8.3)

-  tests/ts:
-    dependencies:
-      flatbuffers:
-        specifier: workspace:*
-        version: link:../..
-
 packages:

  '@esbuild/aix-ppc64@0.25.5':
@@ -349,8 +343,8 @@ packages:
    engines: {node: '>=0.4.0'}
    hasBin: true

-  ajv@6.14.0:
-    resolution: {integrity: sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==}
+  ajv@6.12.6:
+    resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}

  ansi-styles@4.3.0:
    resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
@@ -489,8 +483,8 @@ packages:
    resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==}
    engines: {node: '>=16'}

-  flatted@3.4.2:
-    resolution: {integrity: sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==}
+  flatted@3.3.1:
+    resolution: {integrity: sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==}

  glob-parent@5.1.2:
    resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
@@ -577,11 +571,11 @@ packages:
    resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
    engines: {node: '>=8.6'}

-  minimatch@3.1.5:
-    resolution: {integrity: sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==}
+  minimatch@3.1.2:
+    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}

-  minimatch@9.0.9:
-    resolution: {integrity: sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==}
+  minimatch@9.0.5:
+    resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==}
    engines: {node: '>=16 || 14 >=14.17'}

  ms@2.1.3:
@@ -799,7 +793,7 @@ snapshots:
    dependencies:
      '@eslint/object-schema': 2.1.6
      debug: 4.3.7
-      minimatch: 3.1.5
+      minimatch: 3.1.2
    transitivePeerDependencies:
      - supports-color

@@ -815,14 +809,14 @@ snapshots:

  '@eslint/eslintrc@3.3.1':
    dependencies:
-      ajv: 6.14.0
+      ajv: 6.12.6
      debug: 4.3.7
      espree: 10.4.0
      globals: 14.0.0
      ignore: 5.3.2
      import-fresh: 3.3.0
      js-yaml: 4.1.1
-      minimatch: 3.1.5
+      minimatch: 3.1.2
      strip-json-comments: 3.1.1
    transitivePeerDependencies:
      - supports-color
@@ -938,7 +932,7 @@ snapshots:
      debug: 4.3.7
      fast-glob: 3.3.2
      is-glob: 4.0.3
-      minimatch: 9.0.9
+      minimatch: 9.0.5
      semver: 7.6.3
      ts-api-utils: 2.1.0(typescript@5.8.3)
      typescript: 5.8.3
@@ -967,7 +961,7 @@ snapshots:

  acorn@8.15.0: {}

-  ajv@6.14.0:
+  ajv@6.12.6:
    dependencies:
      fast-deep-equal: 3.1.3
      fast-json-stable-stringify: 2.1.0
@@ -1076,7 +1070,7 @@ snapshots:
      '@humanwhocodes/retry': 0.4.3
      '@types/estree': 1.0.8
      '@types/json-schema': 7.0.15
-      ajv: 6.14.0
+      ajv: 6.12.6
      chalk: 4.1.2
      cross-spawn: 7.0.6
      debug: 4.3.7
@@ -1095,7 +1089,7 @@ snapshots:
      is-glob: 4.0.3
      json-stable-stringify-without-jsonify: 1.0.1
      lodash.merge: 4.6.2
-      minimatch: 3.1.5
+      minimatch: 3.1.2
      natural-compare: 1.4.0
      optionator: 0.9.4
    transitivePeerDependencies:
@@ -1152,10 +1146,10 @@ snapshots:

  flat-cache@4.0.1:
    dependencies:
-      flatted: 3.4.2
+      flatted: 3.3.1
      keyv: 4.5.4

-  flatted@3.4.2: {}
+  flatted@3.3.1: {}

  glob-parent@5.1.2:
    dependencies:
@@ -1224,11 +1218,11 @@ snapshots:
      braces: 3.0.3
      picomatch: 2.3.1

-  minimatch@3.1.5:
+  minimatch@3.1.2:
    dependencies:
      brace-expansion: 1.1.12

-  minimatch@9.0.9:
+  minimatch@9.0.5:
    dependencies:
      brace-expansion: 2.0.2

--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -1,2 +0,0 @@
-packages:
-  - tests/ts
--- a/python/flatbuffers/builder.py
+++ b/python/flatbuffers/builder.py
@@ -422,6 +422,7 @@ class Builder(object):
    off2 = self.Offset() - off + N.UOffsetTFlags.bytewidth
    self.PlaceUOffsetT(off2)

+  ## @cond FLATBUFFERS_INTERNAL
  def StartVector(self, elemSize, numElems, alignment):
    """StartVector initializes bookkeeping for writing a new vector.

@@ -437,6 +438,8 @@ class Builder(object):
    self.Prep(alignment, elemSize * numElems)  # In case alignment > int.
    return self.Offset()

+  ## @endcond
+
  def EndVector(self, numElems=None):
    """EndVector writes data necessary to finish vector construction."""

@@ -553,21 +556,6 @@ class Builder(object):
    self.vectorNumElems = x.size
    return self.EndVector()

-  def CreateVectorOfTables(self, offsets):
-    """CreateVectorOfTables writes a vector of offsets such as tables or strings.
-
-    Args:
-      offsets: Iterable of offsets returned from previous builder operations.
-               Each element should be an integer compatible with UOffsetT.
-    """
-
-    offsets = list(offsets)
-    self.StartVector(N.UOffsetTFlags.bytewidth, len(offsets),
-                     N.UOffsetTFlags.bytewidth)
-    for off in reversed(offsets):
-      self.PrependUOffsetTRelative(off)
-    return self.EndVector()
-
  ## @cond FLATBUFFERS_INTERNAL
  def assertNested(self):
    """Check that we are in the process of building an object."""
--- a/python/flatbuffers/reflection/Enum.py
+++ b/python/flatbuffers/reflection/Enum.py
@@ -155,12 +155,6 @@ def EnumStartValuesVector(builder, numElems):
 def StartValuesVector(builder, numElems):
    return EnumStartValuesVector(builder, numElems)

-def EnumCreateValuesVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateValuesVector(builder, data):
-    return EnumCreateValuesVector(builder, data)
-
 def EnumAddIsUnion(builder, isUnion):
    builder.PrependBoolSlot(2, isUnion, 0)

@@ -185,12 +179,6 @@ def EnumStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
    return EnumStartAttributesVector(builder, numElems)

-def EnumCreateAttributesVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateAttributesVector(builder, data):
-    return EnumCreateAttributesVector(builder, data)
-
 def EnumAddDocumentation(builder, documentation):
    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)

@@ -203,12 +191,6 @@ def EnumStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
    return EnumStartDocumentationVector(builder, numElems)

-def EnumCreateDocumentationVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateDocumentationVector(builder, data):
-    return EnumCreateDocumentationVector(builder, data)
-
 def EnumAddDeclarationFile(builder, declarationFile):
    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)

--- a/python/flatbuffers/reflection/EnumVal.py
+++ b/python/flatbuffers/reflection/EnumVal.py
@@ -134,12 +134,6 @@ def EnumValStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
    return EnumValStartDocumentationVector(builder, numElems)

-def EnumValCreateDocumentationVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateDocumentationVector(builder, data):
-    return EnumValCreateDocumentationVector(builder, data)
-
 def EnumValAddAttributes(builder, attributes):
    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)

@@ -152,12 +146,6 @@ def EnumValStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
    return EnumValStartAttributesVector(builder, numElems)

-def EnumValCreateAttributesVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateAttributesVector(builder, data):
-    return EnumValCreateAttributesVector(builder, data)
-
 def EnumValEnd(builder):
    return builder.EndObject()

--- a/python/flatbuffers/reflection/Field.py
+++ b/python/flatbuffers/reflection/Field.py
@@ -235,12 +235,6 @@ def FieldStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
    return FieldStartAttributesVector(builder, numElems)

-def FieldCreateAttributesVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateAttributesVector(builder, data):
-    return FieldCreateAttributesVector(builder, data)
-
 def FieldAddDocumentation(builder, documentation):
    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)

@@ -253,12 +247,6 @@ def FieldStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
    return FieldStartDocumentationVector(builder, numElems)

-def FieldCreateDocumentationVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateDocumentationVector(builder, data):
-    return FieldCreateDocumentationVector(builder, data)
-
 def FieldAddOptional(builder, optional):
    builder.PrependBoolSlot(11, optional, 0)

--- a/python/flatbuffers/reflection/Object.py
+++ b/python/flatbuffers/reflection/Object.py
@@ -158,12 +158,6 @@ def ObjectStartFieldsVector(builder, numElems):
 def StartFieldsVector(builder, numElems):
    return ObjectStartFieldsVector(builder, numElems)

-def ObjectCreateFieldsVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateFieldsVector(builder, data):
-    return ObjectCreateFieldsVector(builder, data)
-
 def ObjectAddIsStruct(builder, isStruct):
    builder.PrependBoolSlot(2, isStruct, 0)

@@ -194,12 +188,6 @@ def ObjectStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
    return ObjectStartAttributesVector(builder, numElems)

-def ObjectCreateAttributesVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateAttributesVector(builder, data):
-    return ObjectCreateAttributesVector(builder, data)
-
 def ObjectAddDocumentation(builder, documentation):
    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)

@@ -212,12 +200,6 @@ def ObjectStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
    return ObjectStartDocumentationVector(builder, numElems)

-def ObjectCreateDocumentationVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateDocumentationVector(builder, data):
-    return ObjectCreateDocumentationVector(builder, data)
-
 def ObjectAddDeclarationFile(builder, declarationFile):
    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)

--- a/python/flatbuffers/reflection/RPCCall.py
+++ b/python/flatbuffers/reflection/RPCCall.py
@@ -138,12 +138,6 @@ def RPCCallStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
    return RPCCallStartAttributesVector(builder, numElems)

-def RPCCallCreateAttributesVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateAttributesVector(builder, data):
-    return RPCCallCreateAttributesVector(builder, data)
-
 def RPCCallAddDocumentation(builder, documentation):
    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)

@@ -156,12 +150,6 @@ def RPCCallStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
    return RPCCallStartDocumentationVector(builder, numElems)

-def RPCCallCreateDocumentationVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateDocumentationVector(builder, data):
-    return RPCCallCreateDocumentationVector(builder, data)
-
 def RPCCallEnd(builder):
    return builder.EndObject()

--- a/python/flatbuffers/reflection/Schema.py
+++ b/python/flatbuffers/reflection/Schema.py
@@ -180,12 +180,6 @@ def SchemaStartObjectsVector(builder, numElems):
 def StartObjectsVector(builder, numElems):
    return SchemaStartObjectsVector(builder, numElems)

-def SchemaCreateObjectsVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateObjectsVector(builder, data):
-    return SchemaCreateObjectsVector(builder, data)
-
 def SchemaAddEnums(builder, enums):
    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(enums), 0)

@@ -198,12 +192,6 @@ def SchemaStartEnumsVector(builder, numElems):
 def StartEnumsVector(builder, numElems):
    return SchemaStartEnumsVector(builder, numElems)

-def SchemaCreateEnumsVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateEnumsVector(builder, data):
-    return SchemaCreateEnumsVector(builder, data)
-
 def SchemaAddFileIdent(builder, fileIdent):
    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(fileIdent), 0)

@@ -234,12 +222,6 @@ def SchemaStartServicesVector(builder, numElems):
 def StartServicesVector(builder, numElems):
    return SchemaStartServicesVector(builder, numElems)

-def SchemaCreateServicesVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateServicesVector(builder, data):
-    return SchemaCreateServicesVector(builder, data)
-
 def SchemaAddAdvancedFeatures(builder, advancedFeatures):
    builder.PrependUint64Slot(6, advancedFeatures, 0)

@@ -258,12 +240,6 @@ def SchemaStartFbsFilesVector(builder, numElems):
 def StartFbsFilesVector(builder, numElems):
    return SchemaStartFbsFilesVector(builder, numElems)

-def SchemaCreateFbsFilesVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateFbsFilesVector(builder, data):
-    return SchemaCreateFbsFilesVector(builder, data)
-
 def SchemaEnd(builder):
    return builder.EndObject()

--- a/python/flatbuffers/reflection/SchemaFile.py
+++ b/python/flatbuffers/reflection/SchemaFile.py
@@ -84,12 +84,6 @@ def SchemaFileStartIncludedFilenamesVector(builder, numElems):
 def StartIncludedFilenamesVector(builder, numElems):
    return SchemaFileStartIncludedFilenamesVector(builder, numElems)

-def SchemaFileCreateIncludedFilenamesVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateIncludedFilenamesVector(builder, data):
-    return SchemaFileCreateIncludedFilenamesVector(builder, data)
-
 def SchemaFileEnd(builder):
    return builder.EndObject()

--- a/python/flatbuffers/reflection/Service.py
+++ b/python/flatbuffers/reflection/Service.py
@@ -137,12 +137,6 @@ def ServiceStartCallsVector(builder, numElems):
 def StartCallsVector(builder, numElems):
    return ServiceStartCallsVector(builder, numElems)

-def ServiceCreateCallsVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateCallsVector(builder, data):
-    return ServiceCreateCallsVector(builder, data)
-
 def ServiceAddAttributes(builder, attributes):
    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)

@@ -155,12 +149,6 @@ def ServiceStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
    return ServiceStartAttributesVector(builder, numElems)

-def ServiceCreateAttributesVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateAttributesVector(builder, data):
-    return ServiceCreateAttributesVector(builder, data)
-
 def ServiceAddDocumentation(builder, documentation):
    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)

@@ -173,12 +161,6 @@ def ServiceStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
    return ServiceStartDocumentationVector(builder, numElems)

-def ServiceCreateDocumentationVector(builder, data):
-    return builder.CreateVectorOfTables(data)
-
-def CreateDocumentationVector(builder, data):
-    return ServiceCreateDocumentationVector(builder, data)
-
 def ServiceAddDeclarationFile(builder, declarationFile):
    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)

--- a/python/setup.cfg
+++ b/python/setup.cfg
@@ -1,2 +1,6 @@
+[bdist_wheel]
+universal=1
+
 [metadata]
-license_files = LICENSE
+license_files =
+   ../LICENSE
--- a/python/setup.py
+++ b/python/setup.py
@@ -12,54 +12,35 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.

-from pathlib import Path
-import shutil
-
 from setuptools import setup

-
-_THIS_DIR = Path(__file__).resolve().parent
-_ROOT_LICENSE = _THIS_DIR.parent / 'LICENSE'
-_LOCAL_LICENSE = _THIS_DIR / 'LICENSE'
-
-
-def _stage_license_file():
-    if _LOCAL_LICENSE.exists() or not _ROOT_LICENSE.exists():
-        return False
-    shutil.copyfile(_ROOT_LICENSE, _LOCAL_LICENSE)
-    return True
-
-_remove_staged_license = _stage_license_file()
-
-try:
-    setup(
-        name='flatbuffers',
-        version='25.12.19',
-        license='Apache 2.0',
-        author='Derek Bailey',
-        author_email='derekbailey@google.com',
-        url='https://google.github.io/flatbuffers/',
-        long_description=(
-            'Python runtime library for use with the '
-            '`Flatbuffers <https://google.github.io/flatbuffers/>`_ '
-            'serialization format.'
-        ),
-        packages=['flatbuffers'],
-        include_package_data=True,
-        requires=[],
-        description='The FlatBuffers serialization format for Python',
-        classifiers=[
-            'Intended Audience :: Developers',
-            'Operating System :: OS Independent',
-            'Programming Language :: Python',
-            'Programming Language :: Python :: 3',
-            'Topic :: Software Development :: Libraries :: Python Modules',
-        ],
-        project_urls={
-            'Documentation': 'https://google.github.io/flatbuffers/',
-            'Source': 'https://github.com/google/flatbuffers',
-        },
-    )
-finally:
-    if _remove_staged_license and _LOCAL_LICENSE.exists():
-        _LOCAL_LICENSE.unlink()
+setup(
+    name='flatbuffers',
+    version='25.12.19',
+    license='Apache 2.0',
+    author='Derek Bailey',
+    author_email='derekbailey@google.com',
+    url='https://google.github.io/flatbuffers/',
+    long_description=(
+        'Python runtime library for use with the '
+        '`Flatbuffers <https://google.github.io/flatbuffers/>`_ '
+        'serialization format.'
+    ),
+    packages=['flatbuffers'],
+    include_package_data=True,
+    requires=[],
+    description='The FlatBuffers serialization format for Python',
+    classifiers=[
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: Apache Software License',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python',
+        'Programming Language :: Python :: 2',
+        'Programming Language :: Python :: 3',
+        'Topic :: Software Development :: Libraries :: Python Modules',
+    ],
+    project_urls={
+        'Documentation': 'https://google.github.io/flatbuffers/',
+        'Source': 'https://github.com/google/flatbuffers',
+    },
+)
--- a/rust/flatbuffers/src/builder.rs
+++ b/rust/flatbuffers/src/builder.rs
@@ -24,9 +24,6 @@ use core::marker::PhantomData;
 use core::ops::{Add, AddAssign, Deref, DerefMut, Index, IndexMut, Sub, SubAssign};
 use core::ptr::write_bytes;

-#[cfg(feature = "std")]
-use std::collections::HashMap;
-
 use crate::endian_scalar::emplace_scalar;
 use crate::primitives::*;
 use crate::push::{Push, PushAlignment};
@@ -142,9 +139,6 @@ pub struct FlatBufferBuilder<'fbb, A: Allocator = DefaultAllocator> {

    min_align: usize,
    force_defaults: bool,
-    #[cfg(feature = "std")]
-    strings_pool: HashMap<String, WIPOffset<&'fbb str>>,
-    #[cfg(not(feature = "std"))]
    strings_pool: Vec<WIPOffset<&'fbb str>>,

    _phantom: PhantomData<&'fbb ()>,
@@ -166,60 +160,6 @@ impl<'fbb> FlatBufferBuilder<'fbb, DefaultAllocator> {
    pub fn with_capacity(size: usize) -> Self {
        Self::from_vec(vec![0; size])
    }
-    /// Create a FlatBufferBuilder that is ready for writing, with a
-    /// ready-to-use capacity of the provided size and preallocated internal vecs.
-    ///
-    /// The maximum valid value for `size` is `FLATBUFFERS_MAX_BUFFER_SIZE`.
-    ///
-    /// # Arguments
-    ///
-    /// * `size` - The initial capacity of the backing buffer in bytes.
-    /// * `field_locs_capacity` - Preallocated capacity for the field locations vec.
-    /// * `written_vtable_revpos_capacity` - Preallocated capacity for the written vtable reverse positions vec.
-    /// * `strings_pool_capacity` - Preallocated capacity for the shared strings pool vec.
-    pub fn with_internal_capacity(
-        size: usize,
-        field_locs_capacity: usize,
-        written_vtable_revpos_capacity: usize,
-        strings_pool_capacity: usize,
-    ) -> Self {
-        Self::from_vec_with_internal_capacity(
-            vec![0; size],
-            field_locs_capacity,
-            written_vtable_revpos_capacity,
-            strings_pool_capacity,
-        )
-    }
-    /// Create a FlatBufferBuilder that is ready for writing, reusing
-    /// an existing vector and preallocated internal vecs.
-    ///
-    /// # Arguments
-    ///
-    /// * `buffer` - An existing `Vec<u8>` to reuse as the backing buffer.
-    /// * `field_locs_capacity` - Preallocated capacity for the field locations vec.
-    /// * `written_vtable_revpos_capacity` - Preallocated capacity for the written vtable reverse positions vec.
-    /// * `strings_pool_capacity` - Preallocated capacity for the shared strings pool vec.
-    pub fn from_vec_with_internal_capacity(
-        buffer: Vec<u8>,
-        field_locs_capacity: usize,
-        written_vtable_revpos_capacity: usize,
-        strings_pool_capacity: usize,
-    ) -> Self {
-        // we need to check the size here because we create the backing buffer
-        // directly, bypassing the typical way of using grow_allocator:
-        assert!(
-            buffer.len() <= FLATBUFFERS_MAX_BUFFER_SIZE,
-            "cannot initialize buffer bigger than 2 gigabytes"
-        );
-        let allocator = DefaultAllocator::from_vec(buffer);
-        Self::new_in_with_internal_capacity(
-            allocator,
-            field_locs_capacity,
-            written_vtable_revpos_capacity,
-            strings_pool_capacity,
-        )
-    }
-
    /// Create a FlatBufferBuilder that is ready for writing, reusing
    /// an existing vector.
    pub fn from_vec(buffer: Vec<u8>) -> Self {
@@ -257,52 +197,12 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {

            min_align: 0,
            force_defaults: false,
-            #[cfg(feature = "std")]
-            strings_pool: HashMap::new(),
-            #[cfg(not(feature = "std"))]
            strings_pool: Vec::new(),

            _phantom: PhantomData,
        }
    }

-    /// Create a [`FlatBufferBuilder`] that is ready for writing with a custom [`Allocator`]
-    /// and preallocated internal vecs.
-    ///
-    /// # Arguments
-    ///
-    /// * `allocator` - A custom [`Allocator`] to use as the backing buffer.
-    /// * `field_locs_capacity` - Preallocated capacity for the field locations vec.
-    /// * `written_vtable_revpos_capacity` - Preallocated capacity for the written vtable reverse positions vec.
-    /// * `strings_pool_capacity` - Preallocated capacity for the shared strings pool vec.
-    pub fn new_in_with_internal_capacity(
-        allocator: A,
-        field_locs_capacity: usize,
-        written_vtable_revpos_capacity: usize,
-        strings_pool_capacity: usize,
-    ) -> Self {
-        let head = ReverseIndex::end();
-        FlatBufferBuilder {
-            allocator,
-            head,
-
-            field_locs: Vec::with_capacity(field_locs_capacity),
-            written_vtable_revpos: Vec::with_capacity(written_vtable_revpos_capacity),
-
-            nested: false,
-            finished: false,
-
-            min_align: 0,
-            force_defaults: false,
-            #[cfg(feature = "std")]
-            strings_pool: HashMap::with_capacity(strings_pool_capacity),
-            #[cfg(not(feature = "std"))]
-            strings_pool: Vec::with_capacity(strings_pool_capacity),
-
-            _phantom: PhantomData,
-        }
-    }
-
    /// Destroy the [`FlatBufferBuilder`], returning its [`Allocator`] and the index
    /// into it that represents the start of valid data.
    pub fn collapse_in(self) -> (A, usize) {
@@ -323,9 +223,7 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
    /// new object.
    pub fn reset(&mut self) {
        // memset only the part of the buffer that could be dirty:
-        self.allocator[self.head.range_to_end()]
-            .iter_mut()
-            .for_each(|x| *x = 0);
+        self.allocator[self.head.range_to_end()].iter_mut().for_each(|x| *x = 0);

        self.head = ReverseIndex::end();
        self.written_vtable_revpos.clear();
@@ -337,43 +235,22 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
        self.strings_pool.clear();
    }

-    /// Fallible version of [`push`](Self::push).
-    #[inline]
-    pub fn try_push<P: Push>(&mut self, x: P) -> Result<WIPOffset<P::Output>, A::Error> {
-        let sz = P::size();
-        self.align(sz, P::alignment())?;
-        self.make_space(sz)?;
-        {
-            let (dst, rest) = self.allocator[self.head.range_to_end()].split_at_mut(sz);
-            // Safety:
-            // Called make_space above
-            unsafe { x.push(dst, rest.len()) };
-        }
-        Ok(WIPOffset::new(self.used_space() as UOffsetT))
-    }
-
    /// Push a Push'able value onto the front of the in-progress data.
    ///
    /// This function uses traits to provide a unified API for writing
    /// scalars, tables, vectors, and WIPOffsets.
    #[inline]
    pub fn push<P: Push>(&mut self, x: P) -> WIPOffset<P::Output> {
-        self.try_push(x).expect("Flatbuffer allocation failure")
-    }
-
-    /// Fallible version of [`push_slot`](Self::push_slot).
-    #[inline]
-    pub fn try_push_slot<X: Push + PartialEq>(
-        &mut self,
-        slotoff: VOffsetT,
-        x: X,
-        default: X,
-    ) -> Result<(), A::Error> {
-        self.assert_nested("push_slot");
-        if x != default || self.force_defaults {
-            self.try_push_slot_always(slotoff, x)?;
+        let sz = P::size();
+        self.align(sz, P::alignment());
+        self.make_space(sz);
+        {
+            let (dst, rest) = self.allocator[self.head.range_to_end()].split_at_mut(sz);
+            // Safety:
+            // Called make_space above
+            unsafe { x.push(dst, rest.len()) };
        }
-        Ok(())
+        WIPOffset::new(self.used_space() as UOffsetT)
    }

    /// Push a Push'able value onto the front of the in-progress data, and
@@ -381,29 +258,19 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
    /// the default, then this is a no-op.
    #[inline]
    pub fn push_slot<X: Push + PartialEq>(&mut self, slotoff: VOffsetT, x: X, default: X) {
-        self.try_push_slot(slotoff, x, default)
-            .expect("Flatbuffer allocation failure")
-    }
-
-    /// Fallible version of [`push_slot_always`](Self::push_slot_always).
-    #[inline]
-    pub fn try_push_slot_always<X: Push>(
-        &mut self,
-        slotoff: VOffsetT,
-        x: X,
-    ) -> Result<(), A::Error> {
-        self.assert_nested("push_slot_always");
-        let off = self.try_push(x)?;
-        self.track_field(slotoff, off.value());
-        Ok(())
+        self.assert_nested("push_slot");
+        if x != default || self.force_defaults {
+            self.push_slot_always(slotoff, x);
+        }
    }

    /// Push a Push'able value onto the front of the in-progress data, and
    /// store a reference to it in the in-progress vtable.
    #[inline]
    pub fn push_slot_always<X: Push>(&mut self, slotoff: VOffsetT, x: X) {
-        self.try_push_slot_always(slotoff, x)
-            .expect("Flatbuffer allocation failure")
+        self.assert_nested("push_slot_always");
+        let off = self.push(x);
+        self.track_field(slotoff, off.value());
    }

    /// Retrieve the number of vtables that have been serialized into the
@@ -428,22 +295,6 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
        WIPOffset::new(self.used_space() as UOffsetT)
    }

-    /// Fallible version of [`end_table`](Self::end_table).
-    #[inline]
-    pub fn try_end_table(
-        &mut self,
-        off: WIPOffset<TableUnfinishedWIPOffset>,
-    ) -> Result<WIPOffset<TableFinishedWIPOffset>, A::Error> {
-        self.assert_nested("end_table");
-
-        let o = self.write_vtable(off)?;
-
-        self.nested = false;
-        self.field_locs.clear();
-
-        Ok(WIPOffset::new(o.value()))
-    }
-
    /// End a Table write.
    ///
    /// Asserts that the builder is in a nested state.
@@ -452,19 +303,14 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
        &mut self,
        off: WIPOffset<TableUnfinishedWIPOffset>,
    ) -> WIPOffset<TableFinishedWIPOffset> {
-        self.try_end_table(off)
-            .expect("Flatbuffer allocation failure")
-    }
+        self.assert_nested("end_table");

-    /// Fallible version of [`start_vector`](Self::start_vector).
-    #[inline]
-    pub fn try_start_vector<T: Push>(&mut self, num_items: usize) -> Result<(), A::Error> {
-        self.assert_not_nested(
-            "start_vector can not be called when a table or vector is under construction",
-        );
-        self.align(num_items * T::size(), T::alignment().max_of(SIZE_UOFFSET))?;
-        self.nested = true;
-        Ok(())
+        let o = self.write_vtable(off);
+
+        self.nested = false;
+        self.field_locs.clear();
+
+        WIPOffset::new(o.value())
    }

    /// Start a Vector write.
@@ -476,20 +322,11 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
    /// function will want to use `push` to add values.
    #[inline]
    pub fn start_vector<T: Push>(&mut self, num_items: usize) {
-        self.try_start_vector::<T>(num_items)
-            .expect("Flatbuffer allocation failure")
-    }
-
-    /// Fallible version of [`end_vector`](Self::end_vector).
-    #[inline]
-    pub fn try_end_vector<T: Push>(
-        &mut self,
-        num_elems: usize,
-    ) -> Result<WIPOffset<Vector<'fbb, T>>, A::Error> {
-        self.assert_nested("end_vector");
-        let o = self.try_push::<UOffsetT>(num_elems as UOffsetT)?;
-        self.nested = false;
-        Ok(WIPOffset::new(o.value()))
+        self.assert_not_nested(
+            "start_vector can not be called when a table or vector is under construction",
+        );
+        self.nested = true;
+        self.align(num_items * T::size(), T::alignment().max_of(SIZE_UOFFSET));
    }

    /// End a Vector write.
@@ -500,54 +337,14 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
    /// Asserts that the builder is in a nested state.
    #[inline]
    pub fn end_vector<T: Push>(&mut self, num_elems: usize) -> WIPOffset<Vector<'fbb, T>> {
-        self.try_end_vector::<T>(num_elems)
-            .expect("Flatbuffer allocation failure")
+        self.assert_nested("end_vector");
+        self.nested = false;
+        let o = self.push::<UOffsetT>(num_elems as UOffsetT);
+        WIPOffset::new(o.value())
    }

-    /// Fallible version of [`create_shared_string`](Self::create_shared_string).
-    ///
-    /// Uses a HashMap to track previously written strings, providing O(1)
-    /// amortized lookup and insertion.
-    #[cfg(feature = "std")]
-    #[inline]
-    pub fn try_create_shared_string<'a: 'b, 'b>(
-        &'a mut self,
-        s: &'b str,
-    ) -> Result<WIPOffset<&'fbb str>, A::Error> {
-        self.assert_not_nested(
-            "create_shared_string can not be called when a table or vector is under construction",
-        );
-
-        if let Some(&offset) = self.strings_pool.get(s) {
-            return Ok(offset);
-        }
-
-        let address = WIPOffset::new(self.try_create_byte_string(s.as_bytes())?.value());
-        self.strings_pool.insert(s.to_owned(), address);
-        Ok(address)
-    }
-
-    /// Create a utf8 string, and de-duplicate if already created.
-    ///
-    /// Uses a HashMap to track previously written strings, providing O(1)
-    /// amortized lookup and insertion.
-    #[cfg(feature = "std")]
    #[inline]
    pub fn create_shared_string<'a: 'b, 'b>(&'a mut self, s: &'b str) -> WIPOffset<&'fbb str> {
-        self.try_create_shared_string(s)
-            .expect("Flatbuffer allocation failure")
-    }
-
-    /// Fallible version of [`create_shared_string`](Self::create_shared_string).
-    ///
-    /// Uses a sorted Vec with binary search to track previously written
-    /// strings when in `no_std` mode.
-    #[cfg(not(feature = "std"))]
-    #[inline]
-    pub fn try_create_shared_string<'a: 'b, 'b>(
-        &'a mut self,
-        s: &'b str,
-    ) -> Result<WIPOffset<&'fbb str>, A::Error> {
        self.assert_not_nested(
            "create_shared_string can not be called when a table or vector is under construction",
        );
@@ -558,95 +355,68 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {

        let found = self.strings_pool.binary_search_by(|offset| {
            let ptr = offset.value() as usize;
+            // Gets The pointer to the size of the string
            let str_memory = &buf[buf.len() - ptr..];
-            let size = u32::from_le_bytes([
-                str_memory[0],
-                str_memory[1],
-                str_memory[2],
-                str_memory[3],
-            ]) as usize;
-            let stored = &str_memory[4..4 + size];
-            stored.cmp(s.as_bytes())
+            // Gets the size of the written string from buffer
+            let size =
+                u32::from_le_bytes([str_memory[0], str_memory[1], str_memory[2], str_memory[3]])
+                    as usize;
+            // Size of the string size
+            let string_size: usize = 4;
+            // Fetches actual string bytes from index of string after string size
+            // to the size of string plus string size
+            let iter = str_memory[string_size..size + string_size].iter();
+            // Compares bytes of fetched string and current writable string
+            iter.cloned().cmp(s.bytes())
        });

        match found {
-            Ok(index) => Ok(self.strings_pool[index]),
+            Ok(index) => self.strings_pool[index],
            Err(index) => {
-                let address =
-                    WIPOffset::new(self.try_create_byte_string(s.as_bytes())?.value());
+                let address = WIPOffset::new(self.create_byte_string(s.as_bytes()).value());
                self.strings_pool.insert(index, address);
-                Ok(address)
+                address
            }
        }
    }

-    /// Create a utf8 string, and de-duplicate if already created.
-    ///
-    /// Uses a sorted Vec with binary search to track previously written
-    /// strings when in `no_std` mode.
-    #[cfg(not(feature = "std"))]
-    #[inline]
-    pub fn create_shared_string<'a: 'b, 'b>(&'a mut self, s: &'b str) -> WIPOffset<&'fbb str> {
-        self.try_create_shared_string(s)
-            .expect("Flatbuffer allocation failure")
-    }
-
-    /// Fallible version of [`create_string`](Self::create_string).
-    #[inline]
-    pub fn try_create_string<'a: 'b, 'b>(
-        &'a mut self,
-        s: &'b str,
-    ) -> Result<WIPOffset<&'fbb str>, A::Error> {
-        self.assert_not_nested(
-            "create_string can not be called when a table or vector is under construction",
-        );
-        Ok(WIPOffset::new(
-            self.try_create_byte_string(s.as_bytes())?.value(),
-        ))
-    }
-
    /// Create a utf8 string.
    ///
    /// The wire format represents this as a zero-terminated byte vector.
    #[inline]
    pub fn create_string<'a: 'b, 'b>(&'a mut self, s: &'b str) -> WIPOffset<&'fbb str> {
-        self.try_create_string(s)
-            .expect("Flatbuffer allocation failure")
-    }
-
-    /// Fallible version of [`create_byte_string`](Self::create_byte_string).
-    #[inline]
-    pub fn try_create_byte_string(
-        &mut self,
-        data: &[u8],
-    ) -> Result<WIPOffset<&'fbb [u8]>, A::Error> {
        self.assert_not_nested(
-            "create_byte_string can not be called when a table or vector is under construction",
+            "create_string can not be called when a table or vector is under construction",
        );
-        self.align(data.len() + 1, PushAlignment::new(SIZE_UOFFSET))?;
-        self.try_push(0u8)?;
-        self.push_bytes_unprefixed(data)?;
-        self.try_push(data.len() as UOffsetT)?;
-        Ok(WIPOffset::new(self.used_space() as UOffsetT))
+        WIPOffset::new(self.create_byte_string(s.as_bytes()).value())
    }

    /// Create a zero-terminated byte vector.
    #[inline]
    pub fn create_byte_string(&mut self, data: &[u8]) -> WIPOffset<&'fbb [u8]> {
-        self.try_create_byte_string(data)
-            .expect("Flatbuffer allocation failure")
+        self.assert_not_nested(
+            "create_byte_string can not be called when a table or vector is under construction",
+        );
+        self.align(data.len() + 1, PushAlignment::new(SIZE_UOFFSET));
+        self.push(0u8);
+        self.push_bytes_unprefixed(data);
+        self.push(data.len() as UOffsetT);
+        WIPOffset::new(self.used_space() as UOffsetT)
    }

-    /// Fallible version of [`create_vector`](Self::create_vector).
+    /// Create a vector of Push-able objects.
+    ///
+    /// Speed-sensitive users may wish to reduce memory usage by creating the
+    /// vector manually: use `start_vector`, `push`, and `end_vector`.
    #[inline]
-    pub fn try_create_vector<'a: 'b, 'b, T: Push + 'b>(
+    pub fn create_vector<'a: 'b, 'b, T: Push + 'b>(
        &'a mut self,
        items: &'b [T],
-    ) -> Result<WIPOffset<Vector<'fbb, T::Output>>, A::Error> {
+    ) -> WIPOffset<Vector<'fbb, T::Output>> {
        let elem_size = T::size();
        let slice_size = items.len() * elem_size;
-        self.align(slice_size, T::alignment().max_of(SIZE_UOFFSET))?;
-        self.ensure_capacity(slice_size + UOffsetT::size())?;
+        self.align(slice_size, T::alignment().max_of(SIZE_UOFFSET));
+        self.ensure_capacity(slice_size + UOffsetT::size());

        self.head -= slice_size;
        let mut written_len = self.head.distance_to_end();
@@ -660,38 +430,7 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
            unsafe { item.push(out, written_len) };
        }

-        Ok(WIPOffset::new(
-            self.try_push::<UOffsetT>(items.len() as UOffsetT)?.value(),
-        ))
-    }
-
-    /// Create a vector of Push-able objects.
-    ///
-    /// Speed-sensitive users may wish to reduce memory usage by creating the
-    /// vector manually: use `start_vector`, `push`, and `end_vector`.
-    #[inline]
-    pub fn create_vector<'a: 'b, 'b, T: Push + 'b>(
-        &'a mut self,
-        items: &'b [T],
-    ) -> WIPOffset<Vector<'fbb, T::Output>> {
-        self.try_create_vector(items)
-            .expect("Flatbuffer allocation failure")
-    }
-
-    /// Fallible version of [`create_vector_from_iter`](Self::create_vector_from_iter).
-    #[inline]
-    pub fn try_create_vector_from_iter<T: Push>(
-        &mut self,
-        items: impl ExactSizeIterator<Item = T> + DoubleEndedIterator,
-    ) -> Result<WIPOffset<Vector<'fbb, T::Output>>, A::Error> {
-        let elem_size = T::size();
-        self.align(items.len() * elem_size, T::alignment().max_of(SIZE_UOFFSET))?;
-        let mut actual = 0;
-        for item in items.rev() {
-            self.try_push(item)?;
-            actual += 1;
-        }
-        Ok(WIPOffset::new(self.try_push::<UOffsetT>(actual)?.value()))
+        WIPOffset::new(self.push::<UOffsetT>(items.len() as UOffsetT).value())
    }

    /// Create a vector of Push-able objects.
@@ -703,8 +442,14 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
        &mut self,
        items: impl ExactSizeIterator<Item = T> + DoubleEndedIterator,
    ) -> WIPOffset<Vector<'fbb, T::Output>> {
-        self.try_create_vector_from_iter(items)
-            .expect("Flatbuffer allocation failure")
+        let elem_size = T::size();
+        self.align(items.len() * elem_size, T::alignment().max_of(SIZE_UOFFSET));
+        let mut actual = 0;
+        for item in items.rev() {
+            self.push(item);
+            actual += 1;
+        }
+        WIPOffset::new(self.push::<UOffsetT>(actual).value())
    }

    /// Set whether default values are stored.
@@ -767,34 +512,13 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
        assert!(o != 0, "missing required field {}", assert_msg_name);
    }

-    /// Fallible version of [`finish_size_prefixed`](Self::finish_size_prefixed).
-    #[inline]
-    pub fn try_finish_size_prefixed<T>(
-        &mut self,
-        root: WIPOffset<T>,
-        file_identifier: Option<&str>,
-    ) -> Result<(), A::Error> {
-        self.finish_with_opts(root, file_identifier, true)
-    }
-
    /// Finalize the FlatBuffer by: aligning it, pushing an optional file
    /// identifier on to it, pushing a size prefix on to it, and marking the
    /// internal state of the FlatBufferBuilder as `finished`. Afterwards,
    /// users can call `finished_data` to get the resulting data.
    #[inline]
    pub fn finish_size_prefixed<T>(&mut self, root: WIPOffset<T>, file_identifier: Option<&str>) {
-        self.try_finish_size_prefixed(root, file_identifier)
-            .expect("Flatbuffer allocation failure")
-    }
-
-    /// Fallible version of [`finish`](Self::finish).
-    #[inline]
-    pub fn try_finish<T>(
-        &mut self,
-        root: WIPOffset<T>,
-        file_identifier: Option<&str>,
-    ) -> Result<(), A::Error> {
-        self.finish_with_opts(root, file_identifier, false)
+        self.finish_with_opts(root, file_identifier, true);
    }

    /// Finalize the FlatBuffer by: aligning it, pushing an optional file
@@ -803,14 +527,7 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
    /// `finished_data` to get the resulting data.
    #[inline]
    pub fn finish<T>(&mut self, root: WIPOffset<T>, file_identifier: Option<&str>) {
-        self.try_finish(root, file_identifier)
-            .expect("Flatbuffer allocation failure")
-    }
-
-    /// Fallible version of [`finish_minimal`](Self::finish_minimal).
-    #[inline]
-    pub fn try_finish_minimal<T>(&mut self, root: WIPOffset<T>) -> Result<(), A::Error> {
-        self.finish_with_opts(root, None, false)
+        self.finish_with_opts(root, file_identifier, false);
    }

    /// Finalize the FlatBuffer by: aligning it and marking the internal state
@@ -818,8 +535,7 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
    /// `finished_data` to get the resulting data.
    #[inline]
    pub fn finish_minimal<T>(&mut self, root: WIPOffset<T>) {
-        self.try_finish_minimal(root)
-            .expect("Flatbuffer allocation failure")
+        self.finish_with_opts(root, None, false);
    }

    #[inline]
@@ -837,13 +553,13 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
    fn write_vtable(
        &mut self,
        table_tail_revloc: WIPOffset<TableUnfinishedWIPOffset>,
-    ) -> Result<WIPOffset<VTableWIPOffset>, A::Error> {
+    ) -> WIPOffset<VTableWIPOffset> {
        self.assert_nested("write_vtable");

        // Write the vtable offset, which is the start of any Table.
        // We fill its value later.
        let object_revloc_to_vtable: WIPOffset<VTableWIPOffset> =
-            WIPOffset::new(self.try_push::<UOffsetT>(0xF0F0_F0F0)?.value());
+            WIPOffset::new(self.push::<UOffsetT>(0xF0F0_F0F0).value());

        // Layout of the data this function will create when a new vtable is
        // needed.
@@ -886,7 +602,7 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {

        // fill the WIP vtable with zeros:
        let vtable_byte_len = get_vtable_byte_len(&self.field_locs);
-        self.make_space(vtable_byte_len)?;
+        self.make_space(vtable_byte_len);

        // compute the length of the table (not vtable!) in bytes:
        let table_object_size = object_revloc_to_vtable.value() - table_tail_revloc.value();
@@ -895,8 +611,6 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
        // Write the VTable (we may delete it afterwards, if it is a duplicate):
        let vt_start_pos = self.head;
        let vt_end_pos = self.head + vtable_byte_len;
-        // Zero out the vtable space - make_space only reserves but doesn't initialize
-        self.allocator[vt_start_pos.range_to(vt_end_pos)].fill(0);
        {
            // write the vtable header:
            let vtfw =
@@ -911,15 +625,13 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
            }
        }
        let new_vt_bytes = &self.allocator[vt_start_pos.range_to(vt_end_pos)];
-        let found = self
-            .written_vtable_revpos
-            .binary_search_by(|old_vtable_revpos: &UOffsetT| {
-                let old_vtable_pos = self.allocator.len() - *old_vtable_revpos as usize;
-                // Safety:
-                // Already written vtables are valid by construction
-                let old_vtable = unsafe { VTable::init(&self.allocator, old_vtable_pos) };
-                new_vt_bytes.cmp(old_vtable.as_bytes())
-            });
+        let found = self.written_vtable_revpos.binary_search_by(|old_vtable_revpos: &UOffsetT| {
+            let old_vtable_pos = self.allocator.len() - *old_vtable_revpos as usize;
+            // Safety:
+            // Already written vtables are valid by construction
+            let old_vtable = unsafe { VTable::init(&self.allocator, old_vtable_pos) };
+            new_vt_bytes.cmp(old_vtable.as_bytes())
+        });
        let final_vtable_revpos = match found {
            Ok(i) => {
                // The new vtable is a duplicate so clear it.
@@ -957,18 +669,17 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {

        self.field_locs.clear();

-        Ok(object_revloc_to_vtable)
+        object_revloc_to_vtable
    }

    // Only call this when you know it is safe to double the size of the buffer.
    #[inline]
-    fn grow_allocator(&mut self) -> Result<(), A::Error> {
+    fn grow_allocator(&mut self) {
        let starting_active_size = self.used_space();
-        self.allocator.grow_downwards()?;
+        self.allocator.grow_downwards().expect("Flatbuffer allocation failure");

        let ending_active_size = self.used_space();
        debug_assert_eq!(starting_active_size, ending_active_size);
-        Ok(())
    }

    // with or without a size prefix changes how we load the data, so finish*
@@ -978,7 +689,7 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
        root: WIPOffset<T>,
        file_identifier: Option<&str>,
        size_prefixed: bool,
-    ) -> Result<(), A::Error> {
+    ) {
        self.assert_not_finished("buffer cannot be finished when it is already finished");
        self.assert_not_nested(
            "buffer cannot be finished when a table or vector is under construction",
@@ -991,40 +702,34 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
            // for the size prefix:
            let b = if size_prefixed { SIZE_UOFFSET } else { 0 };
            // for the file identifier (a string that is not zero-terminated):
-            let c = if file_identifier.is_some() {
-                FILE_IDENTIFIER_LENGTH
-            } else {
-                0
-            };
+            let c = if file_identifier.is_some() { FILE_IDENTIFIER_LENGTH } else { 0 };
            a + b + c
        };

        {
            let ma = PushAlignment::new(self.min_align);
-            self.align(to_align, ma)?;
+            self.align(to_align, ma);
        }

        if let Some(ident) = file_identifier {
            debug_assert_eq!(ident.len(), FILE_IDENTIFIER_LENGTH);
-            self.push_bytes_unprefixed(ident.as_bytes())?;
+            self.push_bytes_unprefixed(ident.as_bytes());
        }

-        self.try_push(root)?;
+        self.push(root);

        if size_prefixed {
            let sz = self.used_space() as UOffsetT;
-            self.try_push::<UOffsetT>(sz)?;
+            self.push::<UOffsetT>(sz);
        }
        self.finished = true;
-        Ok(())
    }

    #[inline]
-    fn align(&mut self, len: usize, alignment: PushAlignment) -> Result<(), A::Error> {
+    fn align(&mut self, len: usize, alignment: PushAlignment) {
        self.track_min_align(alignment.value());
        let s = self.used_space() as usize;
-        self.make_space(padding_bytes(s + len, alignment.value()))?;
-        Ok(())
+        self.make_space(padding_bytes(s + len, alignment.value()));
    }

    #[inline]
@@ -1033,34 +738,31 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
    }

    #[inline]
-    fn push_bytes_unprefixed(&mut self, x: &[u8]) -> Result<UOffsetT, A::Error> {
-        let n = self.make_space(x.len())?;
+    fn push_bytes_unprefixed(&mut self, x: &[u8]) -> UOffsetT {
+        let n = self.make_space(x.len());
        self.allocator[n.range_to(n + x.len())].copy_from_slice(x);

-        Ok(n.to_forward_index(&self.allocator) as UOffsetT)
+        n.to_forward_index(&self.allocator) as UOffsetT
    }

    #[inline]
-    fn make_space(&mut self, want: usize) -> Result<ReverseIndex, A::Error> {
-        self.ensure_capacity(want)?;
+    fn make_space(&mut self, want: usize) -> ReverseIndex {
+        self.ensure_capacity(want);
        self.head -= want;
-        Ok(self.head)
+        self.head
    }

    #[inline]
-    fn ensure_capacity(&mut self, want: usize) -> Result<usize, A::Error> {
+    fn ensure_capacity(&mut self, want: usize) -> usize {
        if self.unused_ready_space() >= want {
-            return Ok(want);
+            return want;
        }
-        assert!(
-            want <= FLATBUFFERS_MAX_BUFFER_SIZE,
-            "cannot grow buffer beyond 2 gigabytes"
-        );
+        assert!(want <= FLATBUFFERS_MAX_BUFFER_SIZE, "cannot grow buffer beyond 2 gigabytes");

        while self.unused_ready_space() < want {
-            self.grow_allocator()?;
+            self.grow_allocator();
        }
-        Ok(want)
+        want
    }
    #[inline]
    fn unused_ready_space(&self) -> usize {
@@ -1227,33 +929,6 @@ impl<T> IndexMut<ReverseIndexRange> for [T] {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use core::sync::atomic::{AtomicUsize, Ordering};
-    use std::alloc::{GlobalAlloc, Layout, System};
-
-    static ALLOC_COUNT: AtomicUsize = AtomicUsize::new(0);
-
-    struct CountingAllocator;
-
-    unsafe impl GlobalAlloc for CountingAllocator {
-        unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-            ALLOC_COUNT.fetch_add(1, Ordering::Relaxed);
-            unsafe { System.alloc(layout) }
-        }
-        unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-            unsafe { System.dealloc(ptr, layout) }
-        }
-    }
-
-    #[global_allocator]
-    static GLOBAL: CountingAllocator = CountingAllocator;
-
-    fn reset_alloc_count() {
-        ALLOC_COUNT.store(0, Ordering::Relaxed);
-    }
-
-    fn alloc_count() -> usize {
-        ALLOC_COUNT.load(Ordering::Relaxed)
-    }

    #[test]
    fn reverse_index_test() {
@@ -1263,150 +938,4 @@ mod tests {
        assert_eq!(&buf[idx.range_to(idx + 1)], &[4]);
        assert_eq!(idx.to_forward_index(&buf), 4);
    }
-
-    #[test]
-    fn with_internal_capacity_preallocates_vecs() {
-        let mut builder = FlatBufferBuilder::with_internal_capacity(64, 8, 16, 32);
-
-        assert!(builder.allocator.len() >= 64);
-        assert!(builder.field_locs.capacity() >= 8);
-        assert!(builder.written_vtable_revpos.capacity() >= 16);
-        assert!(builder.strings_pool.capacity() >= 32);
-
-        assert!(builder.field_locs.is_empty());
-        assert!(builder.written_vtable_revpos.is_empty());
-        assert!(builder.strings_pool.is_empty());
-
-        // Reset the allocation counter after builder construction
-        reset_alloc_count();
-
-        // Add a shared string and verify it lands in the pool
-        let s1 = builder.create_shared_string("hello");
-        assert_eq!(builder.strings_pool.len(), 1);
-
-        // Adding the same string again should reuse the pooled entry
-        let s2 = builder.create_shared_string("hello");
-        assert_eq!(builder.strings_pool.len(), 1);
-        assert_eq!(s1.value(), s2.value());
-
-        // A different string should add a new entry
-        let _s3 = builder.create_shared_string("world");
-        assert_eq!(builder.strings_pool.len(), 2);
-
-        // With sufficient preallocated capacity, no additional allocations
-        // should have occurred for the internal vecs during the operations above
-        let allocs = alloc_count();
-        assert_eq!(
-            allocs, 0,
-            "expected 0 allocations after builder construction, got {}",
-            allocs
-        );
-    }
-
-    /// A test allocator that fails after a specified number of grow operations.
-    struct FailingAllocator {
-        inner: DefaultAllocator,
-        grows_remaining: usize,
-    }
-
-    #[derive(Debug, Clone, PartialEq, Eq)]
-    struct AllocationError;
-
-    impl core::fmt::Display for AllocationError {
-        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-            write!(f, "allocation failed")
-        }
-    }
-
-    impl FailingAllocator {
-        fn new(initial_size: usize, max_grows: usize) -> Self {
-            Self {
-                inner: DefaultAllocator::from_vec(vec![0u8; initial_size]),
-                grows_remaining: max_grows,
-            }
-        }
-    }
-
-    impl Deref for FailingAllocator {
-        type Target = [u8];
-        fn deref(&self) -> &Self::Target {
-            &self.inner
-        }
-    }
-
-    impl DerefMut for FailingAllocator {
-        fn deref_mut(&mut self) -> &mut Self::Target {
-            &mut self.inner
-        }
-    }
-
-    unsafe impl Allocator for FailingAllocator {
-        type Error = AllocationError;
-
-        fn grow_downwards(&mut self) -> Result<(), Self::Error> {
-            if self.grows_remaining == 0 {
-                return Err(AllocationError);
-            }
-            self.grows_remaining -= 1;
-            // DefaultAllocator returns Infallible, so unwrap is safe
-            self.inner.grow_downwards().unwrap();
-            Ok(())
-        }
-
-        fn len(&self) -> usize {
-            self.inner.len()
-        }
-    }
-
-    #[test]
-    fn try_push_propagates_allocation_error() {
-        let allocator = FailingAllocator::new(1, 0);
-        let mut builder = FlatBufferBuilder::new_in(allocator);
-
-        let result = builder.try_push::<u64>(0x1234567890ABCDEF);
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn try_create_string_propagates_allocation_error() {
-        let allocator = FailingAllocator::new(1, 0);
-        let mut builder = FlatBufferBuilder::new_in(allocator);
-
-        let result = builder.try_create_string("hello world");
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn try_create_vector_propagates_allocation_error() {
-        let allocator = FailingAllocator::new(1, 0);
-        let mut builder = FlatBufferBuilder::new_in(allocator);
-
-        let result = builder.try_create_vector(&[1u32, 2, 3, 4, 5]);
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn try_methods_succeed_with_sufficient_capacity() {
-        let allocator = FailingAllocator::new(1, 10);
-        let mut builder = FlatBufferBuilder::new_in(allocator);
-
-        let result = builder.try_create_string("hello");
-        assert!(result.is_ok());
-
-        let result = builder.try_create_vector(&[1u32, 2, 3]);
-        assert!(result.is_ok());
-    }
-
-    #[test]
-    fn try_finish_propagates_allocation_error() {
-        let allocator = FailingAllocator::new(1, 3);
-        let mut builder = FlatBufferBuilder::new_in(allocator);
-
-        let start = builder.start_table();
-        let table = builder
-            .try_end_table(start)
-            .expect("end_table should succeed with 3 grows");
-        let result = builder.try_finish_minimal(table);
-        assert!(result.is_err(), "finish should fail after grows exhausted");
-    }
 }
--- a/rust/flatbuffers/src/vector.rs
+++ b/rust/flatbuffers/src/vector.rs
@@ -107,20 +107,6 @@ impl<'a, T: Follow<'a> + 'a> Vector<'a, T> {
        key: K,
        f: fn(&<T as Follow<'a>>::Inner, &K) -> Ordering,
    ) -> Option<T::Inner> {
-        self.lookup_index_by_key(key, f).map(|idx| self.get(idx))
-    }
-
-    /// Binary search by key, returning the index of the matching element.
-    ///
-    /// This is similar to `lookup_by_key`, but returns the index of the found
-    /// element rather than the element itself. This is useful when you need
-    /// to reference elements by their position in the vector.
-    #[inline(always)]
-    pub fn lookup_index_by_key<K: Ord>(
-        &self,
-        key: K,
-        f: fn(&<T as Follow<'a>>::Inner, &K) -> Ordering,
-    ) -> Option<usize> {
        if self.is_empty() {
            return None;
        }
@@ -132,7 +118,7 @@ impl<'a, T: Follow<'a> + 'a> Vector<'a, T> {
            let mid = (left + right) / 2;
            let value = self.get(mid);
            match f(&value, &key) {
-                Ordering::Equal => return Some(mid),
+                Ordering::Equal => return Some(value),
                Ordering::Less => left = mid + 1,
                Ordering::Greater => {
                    if mid == 0 {
--- a/rust/flatbuffers/src/verifier.rs
+++ b/rust/flatbuffers/src/verifier.rs
@@ -492,8 +492,8 @@ impl<'ver, 'opts, 'buf> TableVerifier<'ver, 'opts, 'buf> {
                Ok(self)
            }
            _ => InvalidFlatbuffer::new_inconsistent_union(
-                val_field_name.into(),
                key_field_name.into(),
+                val_field_name.into(),
            ),
        }
    }
--- a/rust/flexbuffers/src/builder/ser.rs
+++ b/rust/flexbuffers/src/builder/ser.rs
@@ -421,9 +421,6 @@ impl<'a> Serializer for MapKeySerializer<'a> {
    type SerializeStruct = Impossible<(), Error>;
    type SerializeStructVariant = Impossible<(), Error>;

-    fn is_human_readable(&self) -> bool {
-        self.0.is_human_readable()
-    }
    fn serialize_bool(self, _value: bool) -> Result<(), Error> {
        key_must_be_a_string()
    }
--- a/rust/reflection/src/reflection_verifier.rs
+++ b/rust/reflection/src/reflection_verifier.rs
@@ -397,8 +397,8 @@ fn verify_union<'a, 'b, 'c>(
        }
    } else {
        return InvalidFlatbuffer::new_inconsistent_union(
-            field.name().to_string(),
            format!("{}_type", field.name()),
+            field.name().to_string(),
        )?;
    }

--- a/samples/monster_generated.h
+++ b/samples/monster_generated.h
@@ -643,7 +643,7 @@ inline ::flatbuffers::Offset<Monster> Monster::Pack(::flatbuffers::FlatBufferBui
  auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
  auto _inventory = _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0;
  auto _color = _o->color;
-  auto _weapons = _o->weapons.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Sample::Weapon>> (_o->weapons.size(), [](size_t i, _VectorArgs *__va) { return MyGame::Sample::CreateWeapon(*__va->__fbb, __va->__o->weapons[i].get(), __va->__rehasher); }, &_va ) : 0;
+  auto _weapons = _o->weapons.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Sample::Weapon>> (_o->weapons.size(), [](size_t i, _VectorArgs *__va) { return CreateWeapon(*__va->__fbb, __va->__o->weapons[i].get(), __va->__rehasher); }, &_va ) : 0;
  auto _equipped_type = _o->equipped.type;
  auto _equipped = _o->equipped.Pack(_fbb);
  auto _path = _o->path.size() ? _fbb.CreateVectorOfStructs(_o->path) : 0;
--- a/samples/monster_generated.swift
+++ b/samples/monster_generated.swift
@@ -113,12 +113,12 @@ public struct MyGame_Sample_Vec3: NativeStruct, FlatbuffersVectorInitializable,
 }

 extension MyGame_Sample_Vec3: Encodable {
+
  enum CodingKeys: String, CodingKey {
    case x = "x"
    case y = "y"
    case z = "z"
  }
-
  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    if x != 0.0 {
@@ -170,49 +170,51 @@ public struct MyGame_Sample_Monster: FlatBufferTable, FlatbuffersVectorInitializ
  private init(_ t: Table) { _accessor = t }
  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }

-  private struct VT {
-    static let pos: VOffset = 4
-    static let mana: VOffset = 6
-    static let hp: VOffset = 8
-    static let name: VOffset = 10
-    static let inventory: VOffset = 14
-    static let color: VOffset = 16
-    static let weapons: VOffset = 18
-    static let equippedType: VOffset = 20
-    static let equipped: VOffset = 22
-    static let path: VOffset = 24
+  private enum VTOFFSET: VOffset {
+    case pos = 4
+    case mana = 6
+    case hp = 8
+    case name = 10
+    case inventory = 14
+    case color = 16
+    case weapons = 18
+    case equippedType = 20
+    case equipped = 22
+    case path = 24
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
  }

-  public var pos: MyGame_Sample_Vec3? { let o = _accessor.offset(VT.pos); return o == 0 ? nil : _accessor.readBuffer(of: MyGame_Sample_Vec3.self, at: o) }
-  public var mutablePos: MyGame_Sample_Vec3_Mutable? { let o = _accessor.offset(VT.pos); return o == 0 ? nil : MyGame_Sample_Vec3_Mutable(_accessor.bb, o: o + _accessor.position) }
-  public var mana: Int16 { let o = _accessor.offset(VT.mana); return o == 0 ? 150 : _accessor.readBuffer(of: Int16.self, at: o) }
-  @discardableResult public func mutate(mana: Int16) -> Bool {let o = _accessor.offset(VT.mana);  return _accessor.mutate(mana, index: o) }
-  public var hp: Int16 { let o = _accessor.offset(VT.hp); return o == 0 ? 100 : _accessor.readBuffer(of: Int16.self, at: o) }
-  @discardableResult public func mutate(hp: Int16) -> Bool {let o = _accessor.offset(VT.hp);  return _accessor.mutate(hp, index: o) }
-  public var name: String? { let o = _accessor.offset(VT.name); return o == 0 ? nil : _accessor.string(at: o) }
-  public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.name) }
-  public var inventory: FlatbufferVector<UInt8> { return _accessor.vector(at: VT.inventory, byteSize: 1) }
-  public func mutate(inventory: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VT.inventory); return _accessor.directMutate(inventory, index: _accessor.vector(at: o) + index * 1) }
-  public func withUnsafePointerToInventory<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.inventory, body: body) }
-  public var color: MyGame_Sample_Color { let o = _accessor.offset(VT.color); return o == 0 ? .blue : MyGame_Sample_Color(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .blue }
-  @discardableResult public func mutate(color: MyGame_Sample_Color) -> Bool {let o = _accessor.offset(VT.color);  return _accessor.mutate(color.rawValue, index: o) }
-  public var weapons: FlatbufferVector<MyGame_Sample_Weapon> { return _accessor.vector(at: VT.weapons, byteSize: 4) }
-  public var equippedType: MyGame_Sample_Equipment { let o = _accessor.offset(VT.equippedType); return o == 0 ? .none_ : MyGame_Sample_Equipment(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
-  public func equipped<T: FlatbuffersInitializable>(type: T.Type) -> T? { let o = _accessor.offset(VT.equipped); return o == 0 ? nil : _accessor.union(o) }
-  public var path: FlatbufferVector<MyGame_Sample_Vec3> { return _accessor.vector(at: VT.path, byteSize: 12) }
-  public var mutablePath: FlatbufferVector<MyGame_Sample_Vec3_Mutable> { return _accessor.vector(at: VT.path, byteSize: 12) }
-  public func withUnsafePointerToPath<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.path, body: body) }
+  public var pos: MyGame_Sample_Vec3? { let o = _accessor.offset(VTOFFSET.pos.v); return o == 0 ? nil : _accessor.readBuffer(of: MyGame_Sample_Vec3.self, at: o) }
+  public var mutablePos: MyGame_Sample_Vec3_Mutable? { let o = _accessor.offset(VTOFFSET.pos.v); return o == 0 ? nil : MyGame_Sample_Vec3_Mutable(_accessor.bb, o: o + _accessor.position) }
+  public var mana: Int16 { let o = _accessor.offset(VTOFFSET.mana.v); return o == 0 ? 150 : _accessor.readBuffer(of: Int16.self, at: o) }
+  @discardableResult public func mutate(mana: Int16) -> Bool {let o = _accessor.offset(VTOFFSET.mana.v);  return _accessor.mutate(mana, index: o) }
+  public var hp: Int16 { let o = _accessor.offset(VTOFFSET.hp.v); return o == 0 ? 100 : _accessor.readBuffer(of: Int16.self, at: o) }
+  @discardableResult public func mutate(hp: Int16) -> Bool {let o = _accessor.offset(VTOFFSET.hp.v);  return _accessor.mutate(hp, index: o) }
+  public var name: String? { let o = _accessor.offset(VTOFFSET.name.v); return o == 0 ? nil : _accessor.string(at: o) }
+  public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.name.v) }
+  public var inventory: FlatbufferVector<UInt8> { return _accessor.vector(at: VTOFFSET.inventory.v, byteSize: 1) }
+  public func mutate(inventory: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.inventory.v); return _accessor.directMutate(inventory, index: _accessor.vector(at: o) + index * 1) }
+  public func withUnsafePointerToInventory<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.inventory.v, body: body) }
+  public var color: MyGame_Sample_Color { let o = _accessor.offset(VTOFFSET.color.v); return o == 0 ? .blue : MyGame_Sample_Color(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .blue }
+  @discardableResult public func mutate(color: MyGame_Sample_Color) -> Bool {let o = _accessor.offset(VTOFFSET.color.v);  return _accessor.mutate(color.rawValue, index: o) }
+  public var weapons: FlatbufferVector<MyGame_Sample_Weapon> { return _accessor.vector(at: VTOFFSET.weapons.v, byteSize: 4) }
+  public var equippedType: MyGame_Sample_Equipment { let o = _accessor.offset(VTOFFSET.equippedType.v); return o == 0 ? .none_ : MyGame_Sample_Equipment(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
+  public func equipped<T: FlatbuffersInitializable>(type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.equipped.v); return o == 0 ? nil : _accessor.union(o) }
+  public var path: FlatbufferVector<MyGame_Sample_Vec3> { return _accessor.vector(at: VTOFFSET.path.v, byteSize: 12) }
+  public var mutablePath: FlatbufferVector<MyGame_Sample_Vec3_Mutable> { return _accessor.vector(at: VTOFFSET.path.v, byteSize: 12) }
+  public func withUnsafePointerToPath<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.path.v, body: body) }
  public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 11) }
-  public static func add(pos: MyGame_Sample_Vec3?, _ fbb: inout FlatBufferBuilder) { guard let pos = pos else { return }; fbb.create(struct: pos, position: VT.pos) }
-  public static func add(mana: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mana, def: 150, at: VT.mana) }
-  public static func add(hp: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: hp, def: 100, at: VT.hp) }
-  public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VT.name) }
-  public static func addVectorOf(inventory: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: inventory, at: VT.inventory) }
-  public static func add(color: MyGame_Sample_Color, _ fbb: inout FlatBufferBuilder) { fbb.add(element: color.rawValue, def: 2, at: VT.color) }
-  public static func addVectorOf(weapons: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: weapons, at: VT.weapons) }
-  public static func add(equippedType: MyGame_Sample_Equipment, _ fbb: inout FlatBufferBuilder) { fbb.add(element: equippedType.rawValue, def: 0, at: VT.equippedType) }
-  public static func add(equipped: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: equipped, at: VT.equipped) }
-  public static func addVectorOf(path: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: path, at: VT.path) }
+  public static func add(pos: MyGame_Sample_Vec3?, _ fbb: inout FlatBufferBuilder) { guard let pos = pos else { return }; fbb.create(struct: pos, position: VTOFFSET.pos.p) }
+  public static func add(mana: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mana, def: 150, at: VTOFFSET.mana.p) }
+  public static func add(hp: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: hp, def: 100, at: VTOFFSET.hp.p) }
+  public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VTOFFSET.name.p) }
+  public static func addVectorOf(inventory: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: inventory, at: VTOFFSET.inventory.p) }
+  public static func add(color: MyGame_Sample_Color, _ fbb: inout FlatBufferBuilder) { fbb.add(element: color.rawValue, def: 2, at: VTOFFSET.color.p) }
+  public static func addVectorOf(weapons: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: weapons, at: VTOFFSET.weapons.p) }
+  public static func add(equippedType: MyGame_Sample_Equipment, _ fbb: inout FlatBufferBuilder) { fbb.add(element: equippedType.rawValue, def: 0, at: VTOFFSET.equippedType.p) }
+  public static func add(equipped: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: equipped, at: VTOFFSET.equipped.p) }
+  public static func addVectorOf(path: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: path, at: VTOFFSET.path.p) }
  public static func startVectorOfPath(_ size: Int, in builder: inout FlatBufferBuilder) {
    builder.startVector(size * MemoryLayout<MyGame_Sample_Vec3>.size, elementSize: MemoryLayout<MyGame_Sample_Vec3>.alignment)
  }
@@ -291,14 +293,14 @@ public struct MyGame_Sample_Monster: FlatBufferTable, FlatbuffersVectorInitializ

  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
    var _v = try verifier.visitTable(at: position)
-    try _v.visit(field: VT.pos, fieldName: "pos", required: false, type: MyGame_Sample_Vec3.self)
-    try _v.visit(field: VT.mana, fieldName: "mana", required: false, type: Int16.self)
-    try _v.visit(field: VT.hp, fieldName: "hp", required: false, type: Int16.self)
-    try _v.visit(field: VT.name, fieldName: "name", required: false, type: ForwardOffset<String>.self)
-    try _v.visit(field: VT.inventory, fieldName: "inventory", required: false, type: ForwardOffset<Vector<UInt8, UInt8>>.self)
-    try _v.visit(field: VT.color, fieldName: "color", required: false, type: MyGame_Sample_Color.self)
-    try _v.visit(field: VT.weapons, fieldName: "weapons", required: false, type: ForwardOffset<Vector<ForwardOffset<MyGame_Sample_Weapon>, MyGame_Sample_Weapon>>.self)
-    try _v.visit(unionKey: VT.equippedType, unionField: VT.equipped, unionKeyName: "equippedType", fieldName: "equipped", required: false, completion: { (verifier, key: MyGame_Sample_Equipment, pos) in
+    try _v.visit(field: VTOFFSET.pos.p, fieldName: "pos", required: false, type: MyGame_Sample_Vec3.self)
+    try _v.visit(field: VTOFFSET.mana.p, fieldName: "mana", required: false, type: Int16.self)
+    try _v.visit(field: VTOFFSET.hp.p, fieldName: "hp", required: false, type: Int16.self)
+    try _v.visit(field: VTOFFSET.name.p, fieldName: "name", required: false, type: ForwardOffset<String>.self)
+    try _v.visit(field: VTOFFSET.inventory.p, fieldName: "inventory", required: false, type: ForwardOffset<Vector<UInt8, UInt8>>.self)
+    try _v.visit(field: VTOFFSET.color.p, fieldName: "color", required: false, type: MyGame_Sample_Color.self)
+    try _v.visit(field: VTOFFSET.weapons.p, fieldName: "weapons", required: false, type: ForwardOffset<Vector<ForwardOffset<MyGame_Sample_Weapon>, MyGame_Sample_Weapon>>.self)
+    try _v.visit(unionKey: VTOFFSET.equippedType.p, unionField: VTOFFSET.equipped.p, unionKeyName: "equippedType", fieldName: "equipped", required: false, completion: { (verifier, key: MyGame_Sample_Equipment, pos) in
      switch key {
      case .none_:
        break // NOTE - SWIFT doesnt support none
@@ -306,12 +308,13 @@ public struct MyGame_Sample_Monster: FlatBufferTable, FlatbuffersVectorInitializ
        try ForwardOffset<MyGame_Sample_Weapon>.verify(&verifier, at: pos, of: MyGame_Sample_Weapon.self)
      }
    })
-    try _v.visit(field: VT.path, fieldName: "path", required: false, type: ForwardOffset<Vector<MyGame_Sample_Vec3, MyGame_Sample_Vec3>>.self)
+    try _v.visit(field: VTOFFSET.path.p, fieldName: "path", required: false, type: ForwardOffset<Vector<MyGame_Sample_Vec3, MyGame_Sample_Vec3>>.self)
    _v.finish()
  }
 }

 extension MyGame_Sample_Monster: Encodable {
+
  enum CodingKeys: String, CodingKey {
    case pos = "pos"
    case mana = "mana"
@@ -324,7 +327,6 @@ extension MyGame_Sample_Monster: Encodable {
    case equipped = "equipped"
    case path = "path"
  }
-
  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    try container.encodeIfPresent(pos, forKey: .pos)
@@ -409,18 +411,20 @@ public struct MyGame_Sample_Weapon: FlatBufferTable, FlatbuffersVectorInitializa
  private init(_ t: Table) { _accessor = t }
  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }

-  private struct VT {
-    static let name: VOffset = 4
-    static let damage: VOffset = 6
+  private enum VTOFFSET: VOffset {
+    case name = 4
+    case damage = 6
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
  }

-  public var name: String? { let o = _accessor.offset(VT.name); return o == 0 ? nil : _accessor.string(at: o) }
-  public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.name) }
-  public var damage: Int16 { let o = _accessor.offset(VT.damage); return o == 0 ? 0 : _accessor.readBuffer(of: Int16.self, at: o) }
-  @discardableResult public func mutate(damage: Int16) -> Bool {let o = _accessor.offset(VT.damage);  return _accessor.mutate(damage, index: o) }
+  public var name: String? { let o = _accessor.offset(VTOFFSET.name.v); return o == 0 ? nil : _accessor.string(at: o) }
+  public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.name.v) }
+  public var damage: Int16 { let o = _accessor.offset(VTOFFSET.damage.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int16.self, at: o) }
+  @discardableResult public func mutate(damage: Int16) -> Bool {let o = _accessor.offset(VTOFFSET.damage.v);  return _accessor.mutate(damage, index: o) }
  public static func startWeapon(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 2) }
-  public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VT.name) }
-  public static func add(damage: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: damage, def: 0, at: VT.damage) }
+  public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VTOFFSET.name.p) }
+  public static func add(damage: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: damage, def: 0, at: VTOFFSET.damage.p) }
  public static func endWeapon(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
  public static func createWeapon(
    _ fbb: inout FlatBufferBuilder,
@@ -457,18 +461,18 @@ public struct MyGame_Sample_Weapon: FlatBufferTable, FlatbuffersVectorInitializa

  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
    var _v = try verifier.visitTable(at: position)
-    try _v.visit(field: VT.name, fieldName: "name", required: false, type: ForwardOffset<String>.self)
-    try _v.visit(field: VT.damage, fieldName: "damage", required: false, type: Int16.self)
+    try _v.visit(field: VTOFFSET.name.p, fieldName: "name", required: false, type: ForwardOffset<String>.self)
+    try _v.visit(field: VTOFFSET.damage.p, fieldName: "damage", required: false, type: Int16.self)
    _v.finish()
  }
 }

 extension MyGame_Sample_Weapon: Encodable {
+
  enum CodingKeys: String, CodingKey {
    case name = "name"
    case damage = "damage"
  }
-
  public func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    try container.encodeIfPresent(name, forKey: .name)
--- a/samples/rust_generated/mod.rs
+++ b/samples/rust_generated/mod.rs
@@ -1,18 +1,18 @@
 // Automatically generated by the Flatbuffers compiler. Do not modify.
 // @generated
 pub mod my_game {
+  use super::*;
+  pub mod sample {
    use super::*;
-    pub mod sample {
-        use super::*;
-        mod color_generated;
-        pub use self::color_generated::*;
-        mod equipment_generated;
-        pub use self::equipment_generated::*;
-        mod vec_3_generated;
-        pub use self::vec_3_generated::*;
-        mod monster_generated;
-        pub use self::monster_generated::*;
-        mod weapon_generated;
-        pub use self::weapon_generated::*;
-    } // sample
+    mod color_generated;
+    pub use self::color_generated::*;
+    mod equipment_generated;
+    pub use self::equipment_generated::*;
+    mod vec_3_generated;
+    pub use self::vec_3_generated::*;
+    mod monster_generated;
+    pub use self::monster_generated::*;
+    mod weapon_generated;
+    pub use self::weapon_generated::*;
+  } // sample
 } // my_game
--- a/samples/rust_generated/my_game/sample/color_generated.rs
+++ b/samples/rust_generated/my_game/sample/color_generated.rs
@@ -2,73 +2,64 @@
 // @generated
 extern crate alloc;
 use super::*;
-
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MIN_COLOR: i8 = 0;
-
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MAX_COLOR: i8 = 2;
-
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 #[allow(non_camel_case_types)]
 pub const ENUM_VALUES_COLOR: [Color; 3] = [
-    Color::Red,
-    Color::Green,
-    Color::Blue,
+  Color::Red,
+  Color::Green,
+  Color::Blue,
 ];

 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct Color(pub i8);
-
 #[allow(non_upper_case_globals)]
 impl Color {
-    pub const Red: Self = Self(0);
-    pub const Green: Self = Self(1);
-    pub const Blue: Self = Self(2);
+  pub const Red: Self = Self(0);
+  pub const Green: Self = Self(1);
+  pub const Blue: Self = Self(2);

-    pub const ENUM_MIN: i8 = 0;
-    pub const ENUM_MAX: i8 = 2;
-    pub const ENUM_VALUES: &'static [Self] = &[
-        Self::Red,
-        Self::Green,
-        Self::Blue,
-    ];
-
-    /// Returns the variant's name or "" if unknown.
-    pub fn variant_name(self) -> Option<&'static str> {
-        match self {
-            Self::Red => Some("Red"),
-            Self::Green => Some("Green"),
-            Self::Blue => Some("Blue"),
-            _ => None,
-        }
+  pub const ENUM_MIN: i8 = 0;
+  pub const ENUM_MAX: i8 = 2;
+  pub const ENUM_VALUES: &'static [Self] = &[
+    Self::Red,
+    Self::Green,
+    Self::Blue,
+  ];
+  /// Returns the variant's name or "" if unknown.
+  pub fn variant_name(self) -> Option<&'static str> {
+    match self {
+      Self::Red => Some("Red"),
+      Self::Green => Some("Green"),
+      Self::Blue => Some("Blue"),
+      _ => None,
    }
+  }
 }
-
 impl ::core::fmt::Debug for Color {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        if let Some(name) = self.variant_name() {
-            f.write_str(name)
-        } else {
-            f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
-        }
+  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    if let Some(name) = self.variant_name() {
+      f.write_str(name)
+    } else {
+      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
    }
+  }
 }
-
 impl<'a> ::flatbuffers::Follow<'a> for Color {
-    type Inner = Self;
-
-    #[inline]
-    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { ::flatbuffers::read_scalar_at::<i8>(buf, loc) };
-        Self(b)
-    }
+  type Inner = Self;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    let b = unsafe { ::flatbuffers::read_scalar_at::<i8>(buf, loc) };
+    Self(b)
+  }
 }

 impl ::flatbuffers::Push for Color {
    type Output = Color;
-
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        unsafe { ::flatbuffers::emplace_scalar::<i8>(dst, self.0) };
@@ -76,28 +67,26 @@ impl ::flatbuffers::Push for Color {
 }

 impl ::flatbuffers::EndianScalar for Color {
-    type Scalar = i8;
-
-    #[inline]
-    fn to_little_endian(self) -> i8 {
-        self.0.to_le()
-    }
-
-    #[inline]
-    #[allow(clippy::wrong_self_convention)]
-    fn from_little_endian(v: i8) -> Self {
-        let b = i8::from_le(v);
-        Self(b)
-    }
+  type Scalar = i8;
+  #[inline]
+  fn to_little_endian(self) -> i8 {
+    self.0.to_le()
+  }
+  #[inline]
+  #[allow(clippy::wrong_self_convention)]
+  fn from_little_endian(v: i8) -> Self {
+    let b = i8::from_le(v);
+    Self(b)
+  }
 }

 impl<'a> ::flatbuffers::Verifiable for Color {
-    #[inline]
-    fn run_verifier(
-        v: &mut ::flatbuffers::Verifier, pos: usize
-    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-        i8::run_verifier(v, pos)
-    }
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    i8::run_verifier(v, pos)
+  }
 }

 impl ::flatbuffers::SimpleToVerifyInSlice for Color {}
--- a/samples/rust_generated/my_game/sample/equipment_generated.rs
+++ b/samples/rust_generated/my_game/sample/equipment_generated.rs
@@ -2,69 +2,60 @@
 // @generated
 extern crate alloc;
 use super::*;
-
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MIN_EQUIPMENT: u8 = 0;
-
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MAX_EQUIPMENT: u8 = 1;
-
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 #[allow(non_camel_case_types)]
 pub const ENUM_VALUES_EQUIPMENT: [Equipment; 2] = [
-    Equipment::NONE,
-    Equipment::Weapon,
+  Equipment::NONE,
+  Equipment::Weapon,
 ];

 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct Equipment(pub u8);
-
 #[allow(non_upper_case_globals)]
 impl Equipment {
-    pub const NONE: Self = Self(0);
-    pub const Weapon: Self = Self(1);
+  pub const NONE: Self = Self(0);
+  pub const Weapon: Self = Self(1);

-    pub const ENUM_MIN: u8 = 0;
-    pub const ENUM_MAX: u8 = 1;
-    pub const ENUM_VALUES: &'static [Self] = &[
-        Self::NONE,
-        Self::Weapon,
-    ];
-
-    /// Returns the variant's name or "" if unknown.
-    pub fn variant_name(self) -> Option<&'static str> {
-        match self {
-            Self::NONE => Some("NONE"),
-            Self::Weapon => Some("Weapon"),
-            _ => None,
-        }
+  pub const ENUM_MIN: u8 = 0;
+  pub const ENUM_MAX: u8 = 1;
+  pub const ENUM_VALUES: &'static [Self] = &[
+    Self::NONE,
+    Self::Weapon,
+  ];
+  /// Returns the variant's name or "" if unknown.
+  pub fn variant_name(self) -> Option<&'static str> {
+    match self {
+      Self::NONE => Some("NONE"),
+      Self::Weapon => Some("Weapon"),
+      _ => None,
    }
+  }
 }
-
 impl ::core::fmt::Debug for Equipment {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        if let Some(name) = self.variant_name() {
-            f.write_str(name)
-        } else {
-            f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
-        }
+  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    if let Some(name) = self.variant_name() {
+      f.write_str(name)
+    } else {
+      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
    }
+  }
 }
-
 impl<'a> ::flatbuffers::Follow<'a> for Equipment {
-    type Inner = Self;
-
-    #[inline]
-    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
-        Self(b)
-    }
+  type Inner = Self;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
+    Self(b)
+  }
 }

 impl ::flatbuffers::Push for Equipment {
    type Output = Equipment;
-
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
@@ -72,85 +63,75 @@ impl ::flatbuffers::Push for Equipment {
 }

 impl ::flatbuffers::EndianScalar for Equipment {
-    type Scalar = u8;
-
-    #[inline]
-    fn to_little_endian(self) -> u8 {
-        self.0.to_le()
-    }
-
-    #[inline]
-    #[allow(clippy::wrong_self_convention)]
-    fn from_little_endian(v: u8) -> Self {
-        let b = u8::from_le(v);
-        Self(b)
-    }
+  type Scalar = u8;
+  #[inline]
+  fn to_little_endian(self) -> u8 {
+    self.0.to_le()
+  }
+  #[inline]
+  #[allow(clippy::wrong_self_convention)]
+  fn from_little_endian(v: u8) -> Self {
+    let b = u8::from_le(v);
+    Self(b)
+  }
 }

 impl<'a> ::flatbuffers::Verifiable for Equipment {
-    #[inline]
-    fn run_verifier(
-        v: &mut ::flatbuffers::Verifier, pos: usize
-    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-        u8::run_verifier(v, pos)
-    }
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    u8::run_verifier(v, pos)
+  }
 }

 impl ::flatbuffers::SimpleToVerifyInSlice for Equipment {}
-
 pub struct EquipmentUnionTableOffset {}

 #[allow(clippy::upper_case_acronyms)]
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub enum EquipmentT {
-    NONE,
-    Weapon(alloc::boxed::Box<WeaponT>),
+  NONE,
+  Weapon(alloc::boxed::Box<WeaponT>),
 }
-
 impl Default for EquipmentT {
-    fn default() -> Self {
-        Self::NONE
-    }
+  fn default() -> Self {
+    Self::NONE
+  }
 }
-
 impl EquipmentT {
-    pub fn equipment_type(&self) -> Equipment {
-        match self {
-            Self::NONE => Equipment::NONE,
-            Self::Weapon(_) => Equipment::Weapon,
-        }
+  pub fn equipment_type(&self) -> Equipment {
+    match self {
+      Self::NONE => Equipment::NONE,
+      Self::Weapon(_) => Equipment::Weapon,
    }
-
-    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> {
-        match self {
-            Self::NONE => None,
-            Self::Weapon(v) => Some(v.pack(fbb).as_union_value()),
-        }
+  }
+  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> {
+    match self {
+      Self::NONE => None,
+      Self::Weapon(v) => Some(v.pack(fbb).as_union_value()),
    }
-
-    /// If the union variant matches, return the owned WeaponT, setting the union to NONE.
-    pub fn take_weapon(&mut self) -> Option<alloc::boxed::Box<WeaponT>> {
-        if let Self::Weapon(_) = self {
-            let v = ::core::mem::replace(self, Self::NONE);
-            if let Self::Weapon(w) = v {
-                Some(w)
-            } else {
-                unreachable!()
-            }
-        } else {
-            None
-        }
-    }
-
-    /// If the union variant matches, return a reference to the WeaponT.
-    pub fn as_weapon(&self) -> Option<&WeaponT> {
-        if let Self::Weapon(v) = self { Some(v.as_ref()) } else { None }
-    }
-
-    /// If the union variant matches, return a mutable reference to the WeaponT.
-    pub fn as_weapon_mut(&mut self) -> Option<&mut WeaponT> {
-        if let Self::Weapon(v) = self { Some(v.as_mut()) } else { None }
+  }
+  /// If the union variant matches, return the owned WeaponT, setting the union to NONE.
+  pub fn take_weapon(&mut self) -> Option<alloc::boxed::Box<WeaponT>> {
+    if let Self::Weapon(_) = self {
+      let v = ::core::mem::replace(self, Self::NONE);
+      if let Self::Weapon(w) = v {
+        Some(w)
+      } else {
+        unreachable!()
+      }
+    } else {
+      None
    }
+  }
+  /// If the union variant matches, return a reference to the WeaponT.
+  pub fn as_weapon(&self) -> Option<&WeaponT> {
+    if let Self::Weapon(v) = self { Some(v.as_ref()) } else { None }
+  }
+  /// If the union variant matches, return a mutable reference to the WeaponT.
+  pub fn as_weapon_mut(&mut self) -> Option<&mut WeaponT> {
+    if let Self::Weapon(v) = self { Some(v.as_mut()) } else { None }
+  }
 }
-
--- a/samples/rust_generated/my_game/sample/monster_generated.rs
+++ b/samples/rust_generated/my_game/sample/monster_generated.rs
@@ -2,225 +2,212 @@
 // @generated
 extern crate alloc;
 use super::*;
-
 pub enum MonsterOffset {}
-
 #[derive(Copy, Clone, PartialEq)]
+
 pub struct Monster<'a> {
-    pub _tab: ::flatbuffers::Table<'a>,
+  pub _tab: ::flatbuffers::Table<'a>,
 }

 impl<'a> ::flatbuffers::Follow<'a> for Monster<'a> {
-    type Inner = Monster<'a>;
-
-    #[inline]
-    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
-    }
+  type Inner = Monster<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
 }

 impl<'a> Monster<'a> {
-    pub const VT_POS: ::flatbuffers::VOffsetT = 4;
-    pub const VT_MANA: ::flatbuffers::VOffsetT = 6;
-    pub const VT_HP: ::flatbuffers::VOffsetT = 8;
-    pub const VT_NAME: ::flatbuffers::VOffsetT = 10;
-    pub const VT_INVENTORY: ::flatbuffers::VOffsetT = 14;
-    pub const VT_COLOR: ::flatbuffers::VOffsetT = 16;
-    pub const VT_WEAPONS: ::flatbuffers::VOffsetT = 18;
-    pub const VT_EQUIPPED_TYPE: ::flatbuffers::VOffsetT = 20;
-    pub const VT_EQUIPPED: ::flatbuffers::VOffsetT = 22;
-    pub const VT_PATH: ::flatbuffers::VOffsetT = 24;
+  pub const VT_POS: ::flatbuffers::VOffsetT = 4;
+  pub const VT_MANA: ::flatbuffers::VOffsetT = 6;
+  pub const VT_HP: ::flatbuffers::VOffsetT = 8;
+  pub const VT_NAME: ::flatbuffers::VOffsetT = 10;
+  pub const VT_INVENTORY: ::flatbuffers::VOffsetT = 14;
+  pub const VT_COLOR: ::flatbuffers::VOffsetT = 16;
+  pub const VT_WEAPONS: ::flatbuffers::VOffsetT = 18;
+  pub const VT_EQUIPPED_TYPE: ::flatbuffers::VOffsetT = 20;
+  pub const VT_EQUIPPED: ::flatbuffers::VOffsetT = 22;
+  pub const VT_PATH: ::flatbuffers::VOffsetT = 24;

-    pub const fn get_fully_qualified_name() -> &'static str {
-        "MyGame.Sample.Monster"
-    }
+  pub const fn get_fully_qualified_name() -> &'static str {
+    "MyGame.Sample.Monster"
+  }

-    #[inline]
-    pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-        Monster { _tab: table }
-    }
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Monster { _tab: table }
+  }
+  #[allow(unused_mut)]
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
+    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
+    args: &'args MonsterArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<Monster<'bldr>> {
+    let mut builder = MonsterBuilder::new(_fbb);
+    if let Some(x) = args.path { builder.add_path(x); }
+    if let Some(x) = args.equipped { builder.add_equipped(x); }
+    if let Some(x) = args.weapons { builder.add_weapons(x); }
+    if let Some(x) = args.inventory { builder.add_inventory(x); }
+    if let Some(x) = args.name { builder.add_name(x); }
+    if let Some(x) = args.pos { builder.add_pos(x); }
+    builder.add_hp(args.hp);
+    builder.add_mana(args.mana);
+    builder.add_equipped_type(args.equipped_type);
+    builder.add_color(args.color);
+    builder.finish()
+  }

-    #[allow(unused_mut)]
-    pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
-        _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
-        args: &'args MonsterArgs<'args>
-    ) -> ::flatbuffers::WIPOffset<Monster<'bldr>> {
-        let mut builder = MonsterBuilder::new(_fbb);
-        if let Some(x) = args.path { builder.add_path(x); }
-        if let Some(x) = args.equipped { builder.add_equipped(x); }
-        if let Some(x) = args.weapons { builder.add_weapons(x); }
-        if let Some(x) = args.inventory { builder.add_inventory(x); }
-        if let Some(x) = args.name { builder.add_name(x); }
-        if let Some(x) = args.pos { builder.add_pos(x); }
-        builder.add_hp(args.hp);
-        builder.add_mana(args.mana);
-        builder.add_equipped_type(args.equipped_type);
-        builder.add_color(args.color);
-        builder.finish()
+  pub fn unpack(&self) -> MonsterT {
+    let pos = self.pos().map(|x| {
+      x.unpack()
+    });
+    let mana = self.mana();
+    let hp = self.hp();
+    let name = self.name().map(|x| {
+      alloc::string::ToString::to_string(x)
+    });
+    let inventory = self.inventory().map(|x| {
+      x.into_iter().collect()
+    });
+    let color = self.color();
+    let weapons = self.weapons().map(|x| {
+      x.iter().map(|t| t.unpack()).collect()
+    });
+    let equipped = match self.equipped_type() {
+      Equipment::NONE => EquipmentT::NONE,
+      Equipment::Weapon => EquipmentT::Weapon(alloc::boxed::Box::new(
+        self.equipped_as_weapon()
+            .expect("Invalid union table, expected `Equipment::Weapon`.")
+            .unpack()
+      )),
+      _ => EquipmentT::NONE,
+    };
+    let path = self.path().map(|x| {
+      x.iter().map(|t| t.unpack()).collect()
+    });
+    MonsterT {
+      pos,
+      mana,
+      hp,
+      name,
+      inventory,
+      color,
+      weapons,
+      equipped,
+      path,
    }
+  }

-    pub fn unpack(&self) -> MonsterT {
-        let pos = self.pos().map(|x| {
-            x.unpack()
-        });
-        let mana = self.mana();
-        let hp = self.hp();
-        let name = self.name().map(|x| {
-            alloc::string::ToString::to_string(x)
-        });
-        let inventory = self.inventory().map(|x| {
-            x.into_iter().collect()
-        });
-        let color = self.color();
-        let weapons = self.weapons().map(|x| {
-            x.iter().map(|t| t.unpack()).collect()
-        });
-        let equipped = match self.equipped_type() {
-            Equipment::NONE => EquipmentT::NONE,
-            Equipment::Weapon => EquipmentT::Weapon(alloc::boxed::Box::new(
-                self.equipped_as_weapon()
-                    .expect("Invalid union table, expected `Equipment::Weapon`.")
-                    .unpack()
-            )),
-            _ => EquipmentT::NONE,
-        };
-        let path = self.path().map(|x| {
-            x.iter().map(|t| t.unpack()).collect()
-        });
-        MonsterT {
-            pos,
-            mana,
-            hp,
-            name,
-            inventory,
-            color,
-            weapons,
-            equipped,
-            path,
-        }
+  #[inline]
+  pub fn pos(&self) -> Option<&'a Vec3> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<Vec3>(Monster::VT_POS, None)}
+  }
+  #[inline]
+  pub fn mana(&self) -> i16 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i16>(Monster::VT_MANA, Some(150)).unwrap()}
+  }
+  #[inline]
+  pub fn hp(&self) -> i16 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i16>(Monster::VT_HP, Some(100)).unwrap()}
+  }
+  #[inline]
+  pub fn name(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Monster::VT_NAME, None)}
+  }
+  #[inline]
+  pub fn inventory(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_INVENTORY, None)}
+  }
+  #[inline]
+  pub fn color(&self) -> Color {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<Color>(Monster::VT_COLOR, Some(Color::Blue)).unwrap()}
+  }
+  #[inline]
+  pub fn weapons(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Weapon<'a>>>> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Weapon>>>>(Monster::VT_WEAPONS, None)}
+  }
+  #[inline]
+  pub fn equipped_type(&self) -> Equipment {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<Equipment>(Monster::VT_EQUIPPED_TYPE, Some(Equipment::NONE)).unwrap()}
+  }
+  #[inline]
+  pub fn equipped(&self) -> Option<::flatbuffers::Table<'a>> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_EQUIPPED, None)}
+  }
+  #[inline]
+  pub fn path(&self) -> Option<::flatbuffers::Vector<'a, Vec3>> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Vec3>>>(Monster::VT_PATH, None)}
+  }
+  #[inline]
+  #[allow(non_snake_case)]
+  pub fn equipped_as_weapon(&self) -> Option<Weapon<'a>> {
+    if self.equipped_type() == Equipment::Weapon {
+      self.equipped().map(|t| {
+       // Safety:
+       // Created from a valid Table for this object
+       // Which contains a valid union in this slot
+       unsafe { Weapon::init_from_table(t) }
+     })
+    } else {
+      None
    }
+  }

-    #[inline]
-    pub fn pos(&self) -> Option<&'a Vec3> {
-        // Safety:
-        // Created from valid Table for this object
-        // which contains a valid value in this slot
-        unsafe { self._tab.get::<Vec3>(Monster::VT_POS, None)}
-    }
-
-    #[inline]
-    pub fn mana(&self) -> i16 {
-        // Safety:
-        // Created from valid Table for this object
-        // which contains a valid value in this slot
-        unsafe { self._tab.get::<i16>(Monster::VT_MANA, Some(150)).unwrap()}
-    }
-
-    #[inline]
-    pub fn hp(&self) -> i16 {
-        // Safety:
-        // Created from valid Table for this object
-        // which contains a valid value in this slot
-        unsafe { self._tab.get::<i16>(Monster::VT_HP, Some(100)).unwrap()}
-    }
-
-    #[inline]
-    pub fn name(&self) -> Option<&'a str> {
-        // Safety:
-        // Created from valid Table for this object
-        // which contains a valid value in this slot
-        unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Monster::VT_NAME, None)}
-    }
-
-    #[inline]
-    pub fn inventory(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
-        // Safety:
-        // Created from valid Table for this object
-        // which contains a valid value in this slot
-        unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_INVENTORY, None)}
-    }
-
-    #[inline]
-    pub fn color(&self) -> Color {
-        // Safety:
-        // Created from valid Table for this object
-        // which contains a valid value in this slot
-        unsafe { self._tab.get::<Color>(Monster::VT_COLOR, Some(Color::Blue)).unwrap()}
-    }
-
-    #[inline]
-    pub fn weapons(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Weapon<'a>>>> {
-        // Safety:
-        // Created from valid Table for this object
-        // which contains a valid value in this slot
-        unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Weapon>>>>(Monster::VT_WEAPONS, None)}
-    }
-
-    #[inline]
-    pub fn equipped_type(&self) -> Equipment {
-        // Safety:
-        // Created from valid Table for this object
-        // which contains a valid value in this slot
-        unsafe { self._tab.get::<Equipment>(Monster::VT_EQUIPPED_TYPE, Some(Equipment::NONE)).unwrap()}
-    }
-
-    #[inline]
-    pub fn equipped(&self) -> Option<::flatbuffers::Table<'a>> {
-        // Safety:
-        // Created from valid Table for this object
-        // which contains a valid value in this slot
-        unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_EQUIPPED, None)}
-    }
-
-    #[inline]
-    pub fn path(&self) -> Option<::flatbuffers::Vector<'a, Vec3>> {
-        // Safety:
-        // Created from valid Table for this object
-        // which contains a valid value in this slot
-        unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Vec3>>>(Monster::VT_PATH, None)}
-    }
-
-    #[inline]
-    #[allow(non_snake_case)]
-    pub fn equipped_as_weapon(&self) -> Option<Weapon<'a>> {
-        if self.equipped_type() == Equipment::Weapon {
-            self.equipped().map(|t| {
-                // Safety:
-                // Created from a valid Table for this object
-                // Which contains a valid union in this slot
-                unsafe { Weapon::init_from_table(t) }
-            })
-        } else {
-            None
-        }
-    }
 }

 impl ::flatbuffers::Verifiable for Monster<'_> {
-    #[inline]
-    fn run_verifier(
-        v: &mut ::flatbuffers::Verifier, pos: usize
-    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-        v.visit_table(pos)?
-            .visit_field::<Vec3>("pos", Self::VT_POS, false)?
-            .visit_field::<i16>("mana", Self::VT_MANA, false)?
-            .visit_field::<i16>("hp", Self::VT_HP, false)?
-            .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
-            .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("inventory", Self::VT_INVENTORY, false)?
-            .visit_field::<Color>("color", Self::VT_COLOR, false)?
-            .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Weapon>>>>("weapons", Self::VT_WEAPONS, false)?
-            .visit_union::<Equipment, _>("equipped_type", Self::VT_EQUIPPED_TYPE, "equipped", Self::VT_EQUIPPED, false, |key, v, pos| {
-                match key {
-                    Equipment::Weapon => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<Weapon>>("Equipment::Weapon", pos),
-                    _ => Ok(()),
-                }
-            })?
-            .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Vec3>>>("path", Self::VT_PATH, false)?
-            .finish();
-        Ok(())
-    }
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<Vec3>("pos", Self::VT_POS, false)?
+     .visit_field::<i16>("mana", Self::VT_MANA, false)?
+     .visit_field::<i16>("hp", Self::VT_HP, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("inventory", Self::VT_INVENTORY, false)?
+     .visit_field::<Color>("color", Self::VT_COLOR, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<Weapon>>>>("weapons", Self::VT_WEAPONS, false)?
+     .visit_union::<Equipment, _>("equipped_type", Self::VT_EQUIPPED_TYPE, "equipped", Self::VT_EQUIPPED, false, |key, v, pos| {
+        match key {
+          Equipment::Weapon => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<Weapon>>("Equipment::Weapon", pos),
+          _ => Ok(()),
+        }
+     })?
+     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, Vec3>>>("path", Self::VT_PATH, false)?
+     .finish();
+    Ok(())
+  }
 }
-
 pub struct MonsterArgs<'a> {
    pub pos: Option<&'a Vec3>,
    pub mana: i16,
@@ -233,273 +220,246 @@ pub struct MonsterArgs<'a> {
    pub equipped: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
    pub path: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, Vec3>>>,
 }
-
 impl<'a> Default for MonsterArgs<'a> {
-    #[inline]
-    fn default() -> Self {
-        MonsterArgs {
-            pos: None,
-            mana: 150,
-            hp: 100,
-            name: None,
-            inventory: None,
-            color: Color::Blue,
-            weapons: None,
-            equipped_type: Equipment::NONE,
-            equipped: None,
-            path: None,
-        }
+  #[inline]
+  fn default() -> Self {
+    MonsterArgs {
+      pos: None,
+      mana: 150,
+      hp: 100,
+      name: None,
+      inventory: None,
+      color: Color::Blue,
+      weapons: None,
+      equipped_type: Equipment::NONE,
+      equipped: None,
+      path: None,
    }
+  }
 }

 pub struct MonsterBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
-    fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-    start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
-
 impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> MonsterBuilder<'a, 'b, A> {
-    #[inline]
-    pub fn add_pos(&mut self, pos: &Vec3) {
-        self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos);
-    }
-
-    #[inline]
-    pub fn add_mana(&mut self, mana: i16) {
-        self.fbb_.push_slot::<i16>(Monster::VT_MANA, mana, 150);
-    }
-
-    #[inline]
-    pub fn add_hp(&mut self, hp: i16) {
-        self.fbb_.push_slot::<i16>(Monster::VT_HP, hp, 100);
-    }
-
-    #[inline]
-    pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
-        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_NAME, name);
-    }
-
-    #[inline]
-    pub fn add_inventory(&mut self, inventory: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) {
-        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_INVENTORY, inventory);
-    }
-
-    #[inline]
-    pub fn add_color(&mut self, color: Color) {
-        self.fbb_.push_slot::<Color>(Monster::VT_COLOR, color, Color::Blue);
-    }
-
-    #[inline]
-    pub fn add_weapons(&mut self, weapons: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Weapon<'b >>>>) {
-        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_WEAPONS, weapons);
-    }
-
-    #[inline]
-    pub fn add_equipped_type(&mut self, equipped_type: Equipment) {
-        self.fbb_.push_slot::<Equipment>(Monster::VT_EQUIPPED_TYPE, equipped_type, Equipment::NONE);
-    }
-
-    #[inline]
-    pub fn add_equipped(&mut self, equipped: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
-        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_EQUIPPED, equipped);
-    }
-
-    #[inline]
-    pub fn add_path(&mut self, path: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Vec3>>) {
-        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_PATH, path);
-    }
-
-    #[inline]
-    pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> {
-        let start = _fbb.start_table();
-        MonsterBuilder {
-            fbb_: _fbb,
-            start_: start,
-        }
-    }
-
-    #[inline]
-    pub fn finish(self) -> ::flatbuffers::WIPOffset<Monster<'a>> {
-        let o = self.fbb_.end_table(self.start_);
-        ::flatbuffers::WIPOffset::new(o.value())
+  #[inline]
+  pub fn add_pos(&mut self, pos: &Vec3) {
+    self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos);
+  }
+  #[inline]
+  pub fn add_mana(&mut self, mana: i16) {
+    self.fbb_.push_slot::<i16>(Monster::VT_MANA, mana, 150);
+  }
+  #[inline]
+  pub fn add_hp(&mut self, hp: i16) {
+    self.fbb_.push_slot::<i16>(Monster::VT_HP, hp, 100);
+  }
+  #[inline]
+  pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_NAME, name);
+  }
+  #[inline]
+  pub fn add_inventory(&mut self, inventory: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_INVENTORY, inventory);
+  }
+  #[inline]
+  pub fn add_color(&mut self, color: Color) {
+    self.fbb_.push_slot::<Color>(Monster::VT_COLOR, color, Color::Blue);
+  }
+  #[inline]
+  pub fn add_weapons(&mut self, weapons: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Weapon<'b >>>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_WEAPONS, weapons);
+  }
+  #[inline]
+  pub fn add_equipped_type(&mut self, equipped_type: Equipment) {
+    self.fbb_.push_slot::<Equipment>(Monster::VT_EQUIPPED_TYPE, equipped_type, Equipment::NONE);
+  }
+  #[inline]
+  pub fn add_equipped(&mut self, equipped: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_EQUIPPED, equipped);
+  }
+  #[inline]
+  pub fn add_path(&mut self, path: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Vec3>>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_PATH, path);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    MonsterBuilder {
+      fbb_: _fbb,
+      start_: start,
    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Monster<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
 }

 impl ::core::fmt::Debug for Monster<'_> {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-        let mut ds = f.debug_struct("Monster");
-        ds.field("pos", &self.pos());
-        ds.field("mana", &self.mana());
-        ds.field("hp", &self.hp());
-        ds.field("name", &self.name());
-        ds.field("inventory", &self.inventory());
-        ds.field("color", &self.color());
-        ds.field("weapons", &self.weapons());
-        ds.field("equipped_type", &self.equipped_type());
-        match self.equipped_type() {
-            Equipment::Weapon => {
-                if let Some(x) = self.equipped_as_weapon() {
-                    ds.field("equipped", &x)
-                } else {
-                    ds.field("equipped", &"InvalidFlatbuffer: Union discriminant does not match value.")
-                }
-            },
-            _ => {
-                let x: Option<()> = None;
-                ds.field("equipped", &x)
-            },
-        };
-        ds.field("path", &self.path());
-        ds.finish()
-    }
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Monster");
+      ds.field("pos", &self.pos());
+      ds.field("mana", &self.mana());
+      ds.field("hp", &self.hp());
+      ds.field("name", &self.name());
+      ds.field("inventory", &self.inventory());
+      ds.field("color", &self.color());
+      ds.field("weapons", &self.weapons());
+      ds.field("equipped_type", &self.equipped_type());
+      match self.equipped_type() {
+        Equipment::Weapon => {
+          if let Some(x) = self.equipped_as_weapon() {
+            ds.field("equipped", &x)
+          } else {
+            ds.field("equipped", &"InvalidFlatbuffer: Union discriminant does not match value.")
+          }
+        },
+        _ => {
+          let x: Option<()> = None;
+          ds.field("equipped", &x)
+        },
+      };
+      ds.field("path", &self.path());
+      ds.finish()
+  }
 }
-
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub struct MonsterT {
-    pub pos: Option<Vec3T>,
-    pub mana: i16,
-    pub hp: i16,
-    pub name: Option<alloc::string::String>,
-    pub inventory: Option<alloc::vec::Vec<u8>>,
-    pub color: Color,
-    pub weapons: Option<alloc::vec::Vec<WeaponT>>,
-    pub equipped: EquipmentT,
-    pub path: Option<alloc::vec::Vec<Vec3T>>,
+  pub pos: Option<Vec3T>,
+  pub mana: i16,
+  pub hp: i16,
+  pub name: Option<alloc::string::String>,
+  pub inventory: Option<alloc::vec::Vec<u8>>,
+  pub color: Color,
+  pub weapons: Option<alloc::vec::Vec<WeaponT>>,
+  pub equipped: EquipmentT,
+  pub path: Option<alloc::vec::Vec<Vec3T>>,
 }
-
 impl Default for MonsterT {
-    fn default() -> Self {
-        Self {
-            pos: None,
-            mana: 150,
-            hp: 100,
-            name: None,
-            inventory: None,
-            color: Color::Blue,
-            weapons: None,
-            equipped: EquipmentT::NONE,
-            path: None,
-        }
+  fn default() -> Self {
+    Self {
+      pos: None,
+      mana: 150,
+      hp: 100,
+      name: None,
+      inventory: None,
+      color: Color::Blue,
+      weapons: None,
+      equipped: EquipmentT::NONE,
+      path: None,
    }
+  }
 }
-
 impl MonsterT {
-    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
-        &self,
-        _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
-    ) -> ::flatbuffers::WIPOffset<Monster<'b>> {
-        let pos_tmp = self.pos.as_ref().map(|x| x.pack());
-        let pos = pos_tmp.as_ref();
-        let mana = self.mana;
-        let hp = self.hp;
-        let name = self.name.as_ref().map(|x|{
-            _fbb.create_string(x)
-        });
-        let inventory = self.inventory.as_ref().map(|x|{
-            _fbb.create_vector(x)
-        });
-        let color = self.color;
-        let weapons = self.weapons.as_ref().map(|x|{
-            let w: alloc::vec::Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w)
-        });
-        let equipped_type = self.equipped.equipment_type();
-        let equipped = self.equipped.pack(_fbb);
-        let path = self.path.as_ref().map(|x|{
-            let w: alloc::vec::Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w)
-        });
-        Monster::create(_fbb, &MonsterArgs{
-            pos,
-            mana,
-            hp,
-            name,
-            inventory,
-            color,
-            weapons,
-            equipped_type,
-            equipped,
-            path,
-        })
-    }
+  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+    &self,
+    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+  ) -> ::flatbuffers::WIPOffset<Monster<'b>> {
+    let pos_tmp = self.pos.as_ref().map(|x| x.pack());
+    let pos = pos_tmp.as_ref();
+    let mana = self.mana;
+    let hp = self.hp;
+    let name = self.name.as_ref().map(|x|{
+      _fbb.create_string(x)
+    });
+    let inventory = self.inventory.as_ref().map(|x|{
+      _fbb.create_vector(x)
+    });
+    let color = self.color;
+    let weapons = self.weapons.as_ref().map(|x|{
+      let w: alloc::vec::Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w)
+    });
+    let equipped_type = self.equipped.equipment_type();
+    let equipped = self.equipped.pack(_fbb);
+    let path = self.path.as_ref().map(|x|{
+      let w: alloc::vec::Vec<_> = x.iter().map(|t| t.pack()).collect();_fbb.create_vector(&w)
+    });
+    Monster::create(_fbb, &MonsterArgs{
+      pos,
+      mana,
+      hp,
+      name,
+      inventory,
+      color,
+      weapons,
+      equipped_type,
+      equipped,
+      path,
+    })
+  }
 }
-
+#[inline]
 /// Verifies that a buffer of bytes contains a `Monster`
 /// and returns it.
 /// Note that verification is still experimental and may not
 /// catch every error, or be maximally performant. For the
 /// previous, unchecked, behavior use
 /// `root_as_monster_unchecked`.
-#[inline]
 pub fn root_as_monster(buf: &[u8]) -> Result<Monster<'_>, ::flatbuffers::InvalidFlatbuffer> {
-    ::flatbuffers::root::<Monster>(buf)
+  ::flatbuffers::root::<Monster>(buf)
 }
-
+#[inline]
 /// Verifies that a buffer of bytes contains a size prefixed
 /// `Monster` and returns it.
 /// Note that verification is still experimental and may not
 /// catch every error, or be maximally performant. For the
 /// previous, unchecked, behavior use
 /// `size_prefixed_root_as_monster_unchecked`.
-#[inline]
 pub fn size_prefixed_root_as_monster(buf: &[u8]) -> Result<Monster<'_>, ::flatbuffers::InvalidFlatbuffer> {
-    ::flatbuffers::size_prefixed_root::<Monster>(buf)
+  ::flatbuffers::size_prefixed_root::<Monster>(buf)
 }
-
+#[inline]
 /// Verifies, with the given options, that a buffer of bytes
 /// contains a `Monster` and returns it.
 /// Note that verification is still experimental and may not
 /// catch every error, or be maximally performant. For the
 /// previous, unchecked, behavior use
 /// `root_as_monster_unchecked`.
-#[inline]
 pub fn root_as_monster_with_opts<'b, 'o>(
-    opts: &'o ::flatbuffers::VerifierOptions,
-    buf: &'b [u8],
+  opts: &'o ::flatbuffers::VerifierOptions,
+  buf: &'b [u8],
 ) -> Result<Monster<'b>, ::flatbuffers::InvalidFlatbuffer> {
-    ::flatbuffers::root_with_opts::<Monster<'b>>(opts, buf)
+  ::flatbuffers::root_with_opts::<Monster<'b>>(opts, buf)
 }
-
+#[inline]
 /// Verifies, with the given verifier options, that a buffer of
 /// bytes contains a size prefixed `Monster` and returns
 /// it. Note that verification is still experimental and may not
 /// catch every error, or be maximally performant. For the
 /// previous, unchecked, behavior use
 /// `root_as_monster_unchecked`.
-#[inline]
 pub fn size_prefixed_root_as_monster_with_opts<'b, 'o>(
-    opts: &'o ::flatbuffers::VerifierOptions,
-    buf: &'b [u8],
+  opts: &'o ::flatbuffers::VerifierOptions,
+  buf: &'b [u8],
 ) -> Result<Monster<'b>, ::flatbuffers::InvalidFlatbuffer> {
-    ::flatbuffers::size_prefixed_root_with_opts::<Monster<'b>>(opts, buf)
+  ::flatbuffers::size_prefixed_root_with_opts::<Monster<'b>>(opts, buf)
 }
-
+#[inline]
 /// Assumes, without verification, that a buffer of bytes contains a Monster and returns it.
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid `Monster`.
-#[inline]
 pub unsafe fn root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> {
-    unsafe { ::flatbuffers::root_unchecked::<Monster>(buf) }
+  unsafe { ::flatbuffers::root_unchecked::<Monster>(buf) }
 }
-
+#[inline]
 /// Assumes, without verification, that a buffer of bytes contains a size prefixed Monster and returns it.
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid size prefixed `Monster`.
-#[inline]
 pub unsafe fn size_prefixed_root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> {
-    unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Monster>(buf) }
+  unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Monster>(buf) }
 }
-
 #[inline]
 pub fn finish_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-    root: ::flatbuffers::WIPOffset<Monster<'a>>
-) {
-    fbb.finish(root, None);
+    root: ::flatbuffers::WIPOffset<Monster<'a>>) {
+  fbb.finish(root, None);
 }

 #[inline]
-pub fn finish_size_prefixed_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
-    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-    root: ::flatbuffers::WIPOffset<Monster<'a>>
-) {
-    fbb.finish_size_prefixed(root, None);
+pub fn finish_size_prefixed_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset<Monster<'a>>) {
+  fbb.finish_size_prefixed(root, None);
 }
--- a/samples/rust_generated/my_game/sample/vec_3_generated.rs
+++ b/samples/rust_generated/my_game/sample/vec_3_generated.rs
@@ -2,57 +2,47 @@
 // @generated
 extern crate alloc;
 use super::*;
-
 // struct Vec3, aligned to 4
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq)]
 pub struct Vec3(pub [u8; 12]);
-
-impl Default for Vec3 {
-    fn default() -> Self {
-        Self([0; 12])
-    }
+impl Default for Vec3 { 
+  fn default() -> Self { 
+    Self([0; 12])
+  }
 }
-
 impl ::core::fmt::Debug for Vec3 {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        f.debug_struct("Vec3")
-            .field("x", &self.x())
-            .field("y", &self.y())
-            .field("z", &self.z())
-            .finish()
-    }
+  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    f.debug_struct("Vec3")
+      .field("x", &self.x())
+      .field("y", &self.y())
+      .field("z", &self.z())
+      .finish()
+  }
 }

 impl ::flatbuffers::SimpleToVerifyInSlice for Vec3 {}
-
 impl<'a> ::flatbuffers::Follow<'a> for Vec3 {
-    type Inner = &'a Vec3;
-
-    #[inline]
-    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        unsafe { <&'a Vec3>::follow(buf, loc) }
-    }
+  type Inner = &'a Vec3;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe { <&'a Vec3>::follow(buf, loc) }
+  }
 }
-
 impl<'a> ::flatbuffers::Follow<'a> for &'a Vec3 {
-    type Inner = &'a Vec3;
-
-    #[inline]
-    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        unsafe { ::flatbuffers::follow_cast_ref::<Vec3>(buf, loc) }
-    }
+  type Inner = &'a Vec3;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe { ::flatbuffers::follow_cast_ref::<Vec3>(buf, loc) }
+  }
 }
-
 impl<'b> ::flatbuffers::Push for Vec3 {
    type Output = Vec3;
-
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        let src = unsafe { ::core::slice::from_raw_parts(self as *const Vec3 as *const u8, <Self as ::flatbuffers::Push>::size()) };
        dst.copy_from_slice(src);
    }
-
    #[inline]
    fn alignment() -> ::flatbuffers::PushAlignment {
        ::flatbuffers::PushAlignment::new(4)
@@ -60,150 +50,141 @@ impl<'b> ::flatbuffers::Push for Vec3 {
 }

 impl<'a> ::flatbuffers::Verifiable for Vec3 {
-    #[inline]
-    fn run_verifier(
-        v: &mut ::flatbuffers::Verifier, pos: usize
-    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-        v.in_buffer::<Self>(pos)
-    }
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.in_buffer::<Self>(pos)
+  }
 }

 impl<'a> Vec3 {
-    #[allow(clippy::too_many_arguments)]
-    pub fn new(
-        x: f32,
-        y: f32,
-        z: f32,
-    ) -> Self {
-        let mut s = Self([0; 12]);
-        s.set_x(x);
-        s.set_y(y);
-        s.set_z(z);
-        s
-    }
+  #[allow(clippy::too_many_arguments)]
+  pub fn new(
+    x: f32,
+    y: f32,
+    z: f32,
+  ) -> Self {
+    let mut s = Self([0; 12]);
+    s.set_x(x);
+    s.set_y(y);
+    s.set_z(z);
+    s
+  }

-    pub const fn get_fully_qualified_name() -> &'static str {
-        "MyGame.Sample.Vec3"
-    }
+  pub const fn get_fully_qualified_name() -> &'static str {
+    "MyGame.Sample.Vec3"
+  }

-    pub fn x(&self) -> f32 {
-        let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
-        // Safety:
-        // Created from a valid Table for this object
-        // Which contains a valid value in this slot
-        ::flatbuffers::EndianScalar::from_little_endian(unsafe {
-            ::core::ptr::copy_nonoverlapping(
-                self.0[0..].as_ptr(),
-                mem.as_mut_ptr() as *mut u8,
-                ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
-            );
-            mem.assume_init()
-        })
-    }
+  pub fn x(&self) -> f32 {
+    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid value in this slot
+    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
+      ::core::ptr::copy_nonoverlapping(
+        self.0[0..].as_ptr(),
+        mem.as_mut_ptr() as *mut u8,
+        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
+      );
+      mem.assume_init()
+    })
+  }

-    pub fn set_x(&mut self, x: f32) {
-        let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
-        // Safety:
-        // Created from a valid Table for this object
-        // Which contains a valid value in this slot
-        unsafe {
-            ::core::ptr::copy_nonoverlapping(
-                &x_le as *const _ as *const u8,
-                self.0[0..].as_mut_ptr(),
-                ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
-            );
-        }
+  pub fn set_x(&mut self, x: f32) {
+    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid value in this slot
+    unsafe {
+      ::core::ptr::copy_nonoverlapping(
+        &x_le as *const _ as *const u8,
+        self.0[0..].as_mut_ptr(),
+        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
+      );
    }
+  }

-    pub fn y(&self) -> f32 {
-        let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
-        // Safety:
-        // Created from a valid Table for this object
-        // Which contains a valid value in this slot
-        ::flatbuffers::EndianScalar::from_little_endian(unsafe {
-            ::core::ptr::copy_nonoverlapping(
-                self.0[4..].as_ptr(),
-                mem.as_mut_ptr() as *mut u8,
-                ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
-            );
-            mem.assume_init()
-        })
-    }
+  pub fn y(&self) -> f32 {
+    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid value in this slot
+    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
+      ::core::ptr::copy_nonoverlapping(
+        self.0[4..].as_ptr(),
+        mem.as_mut_ptr() as *mut u8,
+        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
+      );
+      mem.assume_init()
+    })
+  }

-    pub fn set_y(&mut self, x: f32) {
-        let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
-        // Safety:
-        // Created from a valid Table for this object
-        // Which contains a valid value in this slot
-        unsafe {
-            ::core::ptr::copy_nonoverlapping(
-                &x_le as *const _ as *const u8,
-                self.0[4..].as_mut_ptr(),
-                ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
-            );
-        }
+  pub fn set_y(&mut self, x: f32) {
+    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid value in this slot
+    unsafe {
+      ::core::ptr::copy_nonoverlapping(
+        &x_le as *const _ as *const u8,
+        self.0[4..].as_mut_ptr(),
+        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
+      );
    }
+  }

-    pub fn z(&self) -> f32 {
-        let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
-        // Safety:
-        // Created from a valid Table for this object
-        // Which contains a valid value in this slot
-        ::flatbuffers::EndianScalar::from_little_endian(unsafe {
-            ::core::ptr::copy_nonoverlapping(
-                self.0[8..].as_ptr(),
-                mem.as_mut_ptr() as *mut u8,
-                ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
-            );
-            mem.assume_init()
-        })
-    }
+  pub fn z(&self) -> f32 {
+    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid value in this slot
+    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
+      ::core::ptr::copy_nonoverlapping(
+        self.0[8..].as_ptr(),
+        mem.as_mut_ptr() as *mut u8,
+        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
+      );
+      mem.assume_init()
+    })
+  }

-    pub fn set_z(&mut self, x: f32) {
-        let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
-        // Safety:
-        // Created from a valid Table for this object
-        // Which contains a valid value in this slot
-        unsafe {
-            ::core::ptr::copy_nonoverlapping(
-                &x_le as *const _ as *const u8,
-                self.0[8..].as_mut_ptr(),
-                ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
-            );
-        }
+  pub fn set_z(&mut self, x: f32) {
+    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid value in this slot
+    unsafe {
+      ::core::ptr::copy_nonoverlapping(
+        &x_le as *const _ as *const u8,
+        self.0[8..].as_mut_ptr(),
+        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
+      );
    }
+  }

-    pub fn unpack(&self) -> Vec3T {
-        Vec3T {
-            x: self.x(),
-            y: self.y(),
-            z: self.z(),
-        }
+  pub fn unpack(&self) -> Vec3T {
+    Vec3T {
+      x: self.x(),
+      y: self.y(),
+      z: self.z(),
    }
+  }
 }

-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Default)]
 pub struct Vec3T {
-    pub x: f32,
-    pub y: f32,
-    pub z: f32,
+  pub x: f32,
+  pub y: f32,
+  pub z: f32,
 }
-impl Default for Vec3T {
-    fn default() -> Self {
-        Self {
-            x: 0.0,
-            y: 0.0,
-            z: 0.0,
-        }
-    }
+impl Vec3T {
+  pub fn pack(&self) -> Vec3 {
+    Vec3::new(
+      self.x,
+      self.y,
+      self.z,
+    )
+  }
 }

-impl Vec3T {
-    pub fn pack(&self) -> Vec3 {
-        Vec3::new(
-            self.x,
-            self.y,
-            self.z,
-        )
-    }
-}
--- a/samples/rust_generated/my_game/sample/weapon_generated.rs
+++ b/samples/rust_generated/my_game/sample/weapon_generated.rs
@@ -2,172 +2,159 @@
 // @generated
 extern crate alloc;
 use super::*;
-
 pub enum WeaponOffset {}
-
 #[derive(Copy, Clone, PartialEq)]
+
 pub struct Weapon<'a> {
-    pub _tab: ::flatbuffers::Table<'a>,
+  pub _tab: ::flatbuffers::Table<'a>,
 }

 impl<'a> ::flatbuffers::Follow<'a> for Weapon<'a> {
-    type Inner = Weapon<'a>;
-
-    #[inline]
-    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
-    }
+  type Inner = Weapon<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
 }

 impl<'a> Weapon<'a> {
-    pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
-    pub const VT_DAMAGE: ::flatbuffers::VOffsetT = 6;
+  pub const VT_NAME: ::flatbuffers::VOffsetT = 4;
+  pub const VT_DAMAGE: ::flatbuffers::VOffsetT = 6;

-    pub const fn get_fully_qualified_name() -> &'static str {
-        "MyGame.Sample.Weapon"
-    }
+  pub const fn get_fully_qualified_name() -> &'static str {
+    "MyGame.Sample.Weapon"
+  }

-    #[inline]
-    pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
-        Weapon { _tab: table }
-    }
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Weapon { _tab: table }
+  }
+  #[allow(unused_mut)]
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
+    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
+    args: &'args WeaponArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<Weapon<'bldr>> {
+    let mut builder = WeaponBuilder::new(_fbb);
+    if let Some(x) = args.name { builder.add_name(x); }
+    builder.add_damage(args.damage);
+    builder.finish()
+  }

-    #[allow(unused_mut)]
-    pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
-        _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
-        args: &'args WeaponArgs<'args>
-    ) -> ::flatbuffers::WIPOffset<Weapon<'bldr>> {
-        let mut builder = WeaponBuilder::new(_fbb);
-        if let Some(x) = args.name { builder.add_name(x); }
-        builder.add_damage(args.damage);
-        builder.finish()
+  pub fn unpack(&self) -> WeaponT {
+    let name = self.name().map(|x| {
+      alloc::string::ToString::to_string(x)
+    });
+    let damage = self.damage();
+    WeaponT {
+      name,
+      damage,
    }
+  }

-    pub fn unpack(&self) -> WeaponT {
-        let name = self.name().map(|x| {
-            alloc::string::ToString::to_string(x)
-        });
-        let damage = self.damage();
-        WeaponT {
-            name,
-            damage,
-        }
-    }
-
-    #[inline]
-    pub fn name(&self) -> Option<&'a str> {
-        // Safety:
-        // Created from valid Table for this object
-        // which contains a valid value in this slot
-        unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Weapon::VT_NAME, None)}
-    }
-
-    #[inline]
-    pub fn damage(&self) -> i16 {
-        // Safety:
-        // Created from valid Table for this object
-        // which contains a valid value in this slot
-        unsafe { self._tab.get::<i16>(Weapon::VT_DAMAGE, Some(0)).unwrap()}
-    }
+  #[inline]
+  pub fn name(&self) -> Option<&'a str> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Weapon::VT_NAME, None)}
+  }
+  #[inline]
+  pub fn damage(&self) -> i16 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i16>(Weapon::VT_DAMAGE, Some(0)).unwrap()}
+  }
 }

 impl ::flatbuffers::Verifiable for Weapon<'_> {
-    #[inline]
-    fn run_verifier(
-        v: &mut ::flatbuffers::Verifier, pos: usize
-    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
-        v.visit_table(pos)?
-            .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
-            .visit_field::<i16>("damage", Self::VT_DAMAGE, false)?
-            .finish();
-        Ok(())
-    }
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
+     .visit_field::<i16>("damage", Self::VT_DAMAGE, false)?
+     .finish();
+    Ok(())
+  }
 }
-
 pub struct WeaponArgs<'a> {
    pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
    pub damage: i16,
 }
-
 impl<'a> Default for WeaponArgs<'a> {
-    #[inline]
-    fn default() -> Self {
-        WeaponArgs {
-            name: None,
-            damage: 0,
-        }
+  #[inline]
+  fn default() -> Self {
+    WeaponArgs {
+      name: None,
+      damage: 0,
    }
+  }
 }

 pub struct WeaponBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
-    fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-    start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
-
 impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> WeaponBuilder<'a, 'b, A> {
-    #[inline]
-    pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
-        self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Weapon::VT_NAME, name);
-    }
-
-    #[inline]
-    pub fn add_damage(&mut self, damage: i16) {
-        self.fbb_.push_slot::<i16>(Weapon::VT_DAMAGE, damage, 0);
-    }
-
-    #[inline]
-    pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> WeaponBuilder<'a, 'b, A> {
-        let start = _fbb.start_table();
-        WeaponBuilder {
-            fbb_: _fbb,
-            start_: start,
-        }
-    }
-
-    #[inline]
-    pub fn finish(self) -> ::flatbuffers::WIPOffset<Weapon<'a>> {
-        let o = self.fbb_.end_table(self.start_);
-        ::flatbuffers::WIPOffset::new(o.value())
+  #[inline]
+  pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Weapon::VT_NAME, name);
+  }
+  #[inline]
+  pub fn add_damage(&mut self, damage: i16) {
+    self.fbb_.push_slot::<i16>(Weapon::VT_DAMAGE, damage, 0);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> WeaponBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    WeaponBuilder {
+      fbb_: _fbb,
+      start_: start,
    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Weapon<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
 }

 impl ::core::fmt::Debug for Weapon<'_> {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-        let mut ds = f.debug_struct("Weapon");
-        ds.field("name", &self.name());
-        ds.field("damage", &self.damage());
-        ds.finish()
-    }
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Weapon");
+      ds.field("name", &self.name());
+      ds.field("damage", &self.damage());
+      ds.finish()
+  }
 }
-
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub struct WeaponT {
-    pub name: Option<alloc::string::String>,
-    pub damage: i16,
+  pub name: Option<alloc::string::String>,
+  pub damage: i16,
 }
-
 impl Default for WeaponT {
-    fn default() -> Self {
-        Self {
-            name: None,
-            damage: 0,
-        }
+  fn default() -> Self {
+    Self {
+      name: None,
+      damage: 0,
    }
+  }
 }
-
 impl WeaponT {
-    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
-        &self,
-        _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
-    ) -> ::flatbuffers::WIPOffset<Weapon<'b>> {
-        let name = self.name.as_ref().map(|x|{
-            _fbb.create_string(x)
-        });
-        let damage = self.damage;
-        Weapon::create(_fbb, &WeaponArgs{
-            name,
-            damage,
-        })
-    }
+  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+    &self,
+    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+  ) -> ::flatbuffers::WIPOffset<Weapon<'b>> {
+    let name = self.name.as_ref().map(|x|{
+      _fbb.create_string(x)
+    });
+    let damage = self.damage;
+    Weapon::create(_fbb, &WeaponArgs{
+      name,
+      damage,
+    })
+  }
 }
--- a/scripts/check_generate_code.py
+++ b/scripts/check_generate_code.py
@@ -33,11 +33,11 @@ result = subprocess.run(
 if result.returncode != 0:
  print(
      "\n"
-      "ERROR: **********************************************************\n"
-      "ERROR: * The following differences were found after building.   *\n"
-      "ERROR: * Perhaps there is a difference in the flags for the.    *\n"
-      "ERROR: * CMakeLists.txt vs the scripts/generate_code.py script? *\n"
-      "ERROR: **********************************************************\n"
+      "ERROR: *********************************************************\n"
+      "ERROR: * The following differences were found after building.  *\n"
+      "ERROR: * Perhaps there is a difference in the flags for the.   *\n"
+      "ERROR: * CMakeLists.txt vs the script/generate_code.py script? *\n"
+      "ERROR: *********************************************************\n"
  )
  subprocess.run(["git", "diff", "--binary", "--exit-code"], cwd=root_path)
  sys.exit(result.returncode)
@@ -55,11 +55,11 @@ result = subprocess.run(
 if result.returncode != 0:
  print(
      "\n"
-      "ERROR: *********************************************************\n"
-      "ERROR: * The following differences were found after running    *\n"
-      "ERROR: * the scripts/generate_code.py script. Maybe you forgot *\n"
-      "ERROR: * to run it after making changes in a generator?        *\n"
-      "ERROR: *********************************************************\n"
+      "ERROR: ********************************************************\n"
+      "ERROR: * The following differences were found after running   *\n"
+      "ERROR: * the script/generate_code.py script. Maybe you forgot *\n"
+      "ERROR: * to run it after making changes in a generator?       *\n"
+      "ERROR: ********************************************************\n"
  )
  subprocess.run(["git", "diff", "--binary", "--exit-code"], cwd=root_path)
  sys.exit(result.returncode)
--- a/scripts/generate_code.py
+++ b/scripts/generate_code.py
@@ -85,11 +85,6 @@ RUST_OPTS = BASE_OPTS + [
    "--gen-name-strings",
    "--rust-module-root-file",
 ]
-RUST_STANDALONE_OPTS = BASE_OPTS + [
-    "--rust",
-    "--gen-all",
-    "--gen-name-strings",
-]
 RUST_SERIALIZE_OPTS = BASE_OPTS + [
    "--rust",
    "--gen-all",
@@ -245,12 +240,6 @@ flatc(
    ],
 )

-flatc(
-    BASE_OPTS + CPP_OPTS + ["--cpp-ptr-type", "naked"],
-    prefix="vector_table_naked_ptr",
-    schema="vector_table_naked_ptr.fbs",
-)
-
 flatc(
    BASE_OPTS + CPP_OPTS + CS_OPTS + JAVA_OPTS + KOTLIN_OPTS + PHP_OPTS,
    prefix="union_vector",
@@ -293,12 +282,6 @@ flatc(
    schema="include_test/include_test1.fbs",
 )

-flatc(
-    RUST_STANDALONE_OPTS,
-    include="include_test",
-    schema="include_test/include_test1.fbs",
-)
-
 flatc(
    RUST_OPTS,
    prefix="include_test2",
@@ -306,12 +289,6 @@ flatc(
    schema="include_test/sub/include_test2.fbs",
 )

-flatc(
-    RUST_STANDALONE_OPTS,
-    include="include_test",
-    schema="include_test/sub/include_test2.fbs",
-)
-
 flatc(
    BINARY_OPTS + ["--bfbs-filenames", str(tests_path)],
    include="include_test",
@@ -379,7 +356,13 @@ flatc(
 )

 flatc(
-    ["--cpp", "--gen-compare", "--gen-mutable", "--gen-object-api", "--reflect-names"],
+    [
+        "--cpp",
+        "--gen-compare",
+        "--gen-mutable",
+        "--gen-object-api",
+        "--reflect-names",
+    ],
    schema="native_type_test.fbs",
 )

@@ -394,11 +377,6 @@ flatc(
    schema="native_inline_table_test.fbs",
 )

-flatc(
-    ["--cpp", "--gen-compare", "--gen-mutable", "--gen-object-api", "--reflect-names"],
-    schema="cross_namespace_pack_test.fbs",
-)
-
 flatc(
    RUST_OPTS,
    prefix="arrays_test",
@@ -422,11 +400,6 @@ flatc(
    schema="nested_union_test.fbs",
 )

-flatc(
-    ["--python", "--gen-object-api"],
-    schema="union_name_test.fbs",
-)
-
 flatc(
    NO_INCL_OPTS + CPP_OPTS,
    schema="default_vectors_strings_test.fbs",
@@ -527,13 +500,6 @@ flatc(
    cwd=swift_code_gen,
 )

-flatc(
-    SWIFT_OPTS_CODE_GEN + BASE_OPTS,
-    schema="empty_vtable.fbs",
-    cwd=swift_code_gen,
-    prefix="../../Tests/Flatbuffers/",
-)
-
 # Swift Wasm Tests
 swift_Wasm_prefix = "swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests"
 flatc(
--- a/src/bfbs_gen_lua.cpp
+++ b/src/bfbs_gen_lua.cpp
@@ -61,7 +61,6 @@ Namer::Config LuaDefaultConfig() {
          /*object_suffix=*/"",
          /*keyword_prefix=*/"",
          /*keyword_suffix=*/"_",
-          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
          /*filenames=*/Case::kKeep,
          /*directories=*/Case::kKeep,
          /*output_path=*/"",
@@ -195,13 +194,6 @@ class LuaBfbsGenerator : public BaseBfbsGenerator {
      code += "\n";

      if (object == root_object) {
-        // emit file identifier if present
-        const auto ident = schema_->file_ident();
-        if (ident && ident->size() == 4) {
-          code += "local FileIdentifier = \"" + ident->str() + "\"\n";
-          code += "\n";
-        }
-
        code += "function " + object_name + ".GetRootAs" + object_name +
                "(buf, offset)\n";
        code += "  if type(buf) == \"string\" then\n";
@@ -462,34 +454,6 @@ class LuaBfbsGenerator : public BaseBfbsGenerator {
        code += "  return builder:EndObject()\n";
        code += "end\n";
        code += "\n";
-
-        if (object == root_object) {
-          code += "function " + object_name + ".Finish" + object_name +
-                  "Buffer(builder, offset)\n";
-          // emit file identifier if present
-          const auto ident = schema_->file_ident();
-          if (ident && ident->size() == 4) {
-            code += "  builder:FinishWithIdentifier(offset, FileIdentifier)\n";
-          } else {
-            code += "  builder:Finish(offset)\n";
-          }
-          code += "end\n";
-          code += "\n";
-
-          // size prefixed option
-          code += "function " + object_name + ".FinishSizePrefixed" +
-                  object_name + "Buffer(builder, offset)\n";
-          // emit file identifier if present
-          if (ident && ident->size() == 4) {
-            code +=
-                "  builder:FinishSizePrefixedWithIdentifier(offset, "
-                "FileIdentifier)\n";
-          } else {
-            code += "  builder:FinishSizePrefixed(offset)\n";
-          }
-          code += "end\n";
-          code += "\n";
-        }
      }

      EmitCodeBlock(code, object_name, ns, object->declaration_file()->str());
--- a/src/bfbs_gen_nim.cpp
+++ b/src/bfbs_gen_nim.cpp
@@ -70,7 +70,6 @@ Namer::Config NimDefaultConfig() {
          /*object_suffix=*/"T",
          /*keyword_prefix=*/"",
          /*keyword_suffix=*/"_",
-          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
          /*filenames=*/Case::kKeep,
          /*directories=*/Case::kKeep,
          /*output_path=*/"",
--- a/src/binary_annotator.cpp
+++ b/src/binary_annotator.cpp
@@ -126,7 +126,9 @@ static BinarySection GenerateMissingSection(const uint64_t offset,
 std::map<uint64_t, BinarySection> BinaryAnnotator::Annotate() {
  if (bfbs_ != nullptr && bfbs_length_ != 0) {
    flatbuffers::Verifier verifier(bfbs_, static_cast<size_t>(bfbs_length_));
-    if (!reflection::VerifySchemaBuffer(verifier)) {
+    if ((is_size_prefixed_ &&
+         !reflection::VerifySizePrefixedSchemaBuffer(verifier)) ||
+        !reflection::VerifySchemaBuffer(verifier)) {
      return {};
    }
  }
--- a/src/flatc.cpp
+++ b/src/flatc.cpp
@@ -265,9 +265,6 @@ const static FlatCOption flatc_options[] = {
    {"", "python-gen-numpy", "", "Whether to generate numpy helpers."},
    {"", "ts-omit-entrypoint", "",
     "Omit emission of namespace entrypoint file"},
-    {"", "ts-undefined-for-optionals", "",
-     "Whether to generate undefined values instead of null values for missing "
-     "optional keys"},
    {"", "file-names-only", "",
     "Print out generated file names without writing to the files"},
    {"", "grpc-filename-suffix", "SUFFIX",
@@ -713,8 +710,6 @@ FlatCOptions FlatCompiler::ParseFromCommandLineArguments(int argc,
        opts.python_gen_numpy = false;
      } else if (arg == "--ts-omit-entrypoint") {
        opts.ts_omit_entrypoint = true;
-      } else if (arg == "--ts-undefined-for-optionals") {
-        opts.ts_undefined_for_optionals = true;
      } else if (arg == "--annotate-sparse-vectors") {
        options.annotate_include_vector_contents = false;
      } else if (arg == "--annotate") {
@@ -927,9 +922,6 @@ std::unique_ptr<Parser> FlatCompiler::GenerateCode(const FlatCOptions& options,
        auto err = parser->ConformTo(conform_parser);
        if (!err.empty()) Error("schemas don\'t conform: " + err, false);
      }
-      if (parser->HasCircularStructDependency()) {
-        Error("schema has circular struct dependencies: " + filename, false);
-      }
      if (options.schema_binary || opts.binary_schema_gen_embed) {
        parser->Serialize();
      }
--- a/src/idl_gen_cpp.cpp
+++ b/src/idl_gen_cpp.cpp
@@ -2779,17 +2779,15 @@ class CppGenerator : public BaseGenerator {
        get_call += ">(" + offset_str + ");";
        code_ += get_call;
      } else if (IsString(type) && field.value.constant != "0") {
-        std::string escaped;
-        flatbuffers::EscapeString(field.value.constant.c_str(),
-                                  field.value.constant.length(), &escaped,
-                                  true, false);
+        // TODO: Add logic to always convert the string to a valid C++ string
+        // literal by handling string escapes.
        code_ += "    auto* ptr = {{FIELD_VALUE}};";
        code_ += "    if (ptr) return ptr;";
        code_ += "    static const struct { uint32_t len; const char s[" +
                 NumToString(field.value.constant.length() + 1) +
                 "]; } bfbs_string = { " +
-                 NumToString(field.value.constant.length()) + ", " +
-                 escaped + " };";
+                 NumToString(field.value.constant.length()) + ", \"" +
+                 field.value.constant + "\" };";
        code_ +=
            "    return reinterpret_cast<const ::flatbuffers::String "
            " *>(&bfbs_string);";
@@ -3419,15 +3417,11 @@ class CppGenerator : public BaseGenerator {
            code_.SetValue("CREATE_STRING", "CreateSharedString");
          }
          if (field->value.constant != "0") {
-            std::string escaped;
-            flatbuffers::EscapeString(field->value.constant.c_str(),
-                                      field->value.constant.length(), &escaped,
-                                      true, false);
            code_ +=
                "  auto {{FIELD_NAME}}__ = {{FIELD_NAME}} ? "
                "_fbb.{{CREATE_STRING}}({{FIELD_NAME}}) : "
-                "_fbb.{{CREATE_STRING}}(" +
-                escaped + ");";
+                "_fbb.{{CREATE_STRING}}(\"" +
+                field->value.constant + "\");";
          } else {
            code_ +=
                "  auto {{FIELD_NAME}}__ = {{FIELD_NAME}} ? "
@@ -3831,9 +3825,7 @@ class CppGenerator : public BaseGenerator {
              code += WrapInNameSpace(*vector_type.struct_def) + ">> ";
              code += "(" + value + ".size(), ";
              code += "[](size_t i, _VectorArgs *__va) { ";
-              code += "return " +
-                      WrapInNameSpace(vector_type.struct_def->defined_namespace,
-                                      "Create" + vector_type.struct_def->name);
+              code += "return Create" + vector_type.struct_def->name;
              code += "(*__va->__fbb, ";
              if (field.native_inline) {
                code += "&(__va->_" + value + "[i])";
@@ -3946,10 +3938,8 @@ class CppGenerator : public BaseGenerator {
          }
        } else {
          // _o->field ? CreateT(_fbb, _o->field.get(), _rehasher);
-          const auto& nested_struct = *field.value.type.struct_def;
-          code += value + " ? " +
-                  WrapInNameSpace(nested_struct.defined_namespace,
-                                  "Create" + nested_struct.name);
+          const std::string& type = field.value.type.struct_def->name;
+          code += value + " ? Create" + type;
          code += "(_fbb, " + value;
          if (!field.native_inline) code += GenPtrGet(field);
          code += ", _rehasher) : 0";
--- a/src/idl_gen_csharp.cpp
+++ b/src/idl_gen_csharp.cpp
@@ -1243,58 +1243,6 @@ class CSharpGenerator : public BaseGenerator {
        }
        code += " }\n";
      }
-      
-      // Generate Length property and ByteBuffer accessor for arrays in structs.
-      if (IsArray(field.value.type) && struct_def.fixed &&
-          IsScalar(field.value.type.VectorType().base_type)) {
-        auto camel_name = Name(field);
-        if (camel_name == struct_def.name) { camel_name += "_"; }
-        
-        // Generate Length constant
-        code += "  public const int " + camel_name;
-        code += "Length = ";
-        code += NumToString(field.value.type.fixed_length);
-        code += ";\n";
-        
-        // Generate GetBytes methods for scalar arrays (similar to vector pattern)
-        code += "#if ENABLE_SPAN_T\n";
-        code += "  public Span<" + GenTypeBasic(field.value.type.VectorType()) +
-                "> Get";
-        code += camel_name;
-        code += "Bytes() { return ";
-        
-        // For byte arrays, we can return the span directly
-        if (field.value.type.VectorType().base_type == BASE_TYPE_UCHAR) {
-          code += "__p.bb.ToSpan(__p.bb_pos + ";
-          code += NumToString(field.value.offset);
-          code += ", ";
-          code += NumToString(field.value.type.fixed_length *
-                             SizeOf(field.value.type.VectorType().base_type));
-          code += ")";
-        } else {
-          // For other types, we need to cast the byte span
-          code += "System.Runtime.InteropServices.MemoryMarshal.Cast<byte, " +
-                  GenTypeBasic(field.value.type.VectorType()) + ">(__p.bb.ToSpan(__p.bb_pos + ";
-          code += NumToString(field.value.offset);
-          code += ", ";
-          code += NumToString(field.value.type.fixed_length *
-                             SizeOf(field.value.type.VectorType().base_type));
-          code += "))";
-        }
-        code += "; }\n";
-        code += "#else\n";
-        code += "  public ArraySegment<byte>? Get";
-        code += camel_name;
-        code += "Bytes() { return ";
-        code += "__p.bb.ToArraySegment(__p.bb_pos + ";
-        code += NumToString(field.value.offset);
-        code += ", ";
-        code += NumToString(field.value.type.fixed_length *
-                           SizeOf(field.value.type.VectorType().base_type));
-        code += ");}\n";
-        code += "#endif\n";
-      }
-      
      // generate object accessors if is nested_flatbuffer
      if (field.nested_flatbuffer) {
        auto nested_type_name = NamespacedName(*field.nested_flatbuffer);
--- a/src/idl_gen_dart.cpp
+++ b/src/idl_gen_dart.cpp
@@ -48,7 +48,6 @@ static Namer::Config DartDefaultConfig() {
          /*object_suffix=*/"T",
          /*keyword_prefix=*/"$",
          /*keyword_suffix=*/"",
-          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
          /*filenames=*/Case::kKeep,
          /*directories=*/Case::kKeep,
          /*output_path=*/"",
--- a/src/idl_gen_fbs.cpp
+++ b/src/idl_gen_fbs.cpp
@@ -368,17 +368,7 @@ static std::string GenerateFBS(const Parser& parser,
      if (field.value.type.base_type != BASE_TYPE_UTYPE) {
        GenComment(field.doc_comment, &schema, nullptr, "  ");
        schema += "  " + field.name + ":" + GenType(field.value.type);
-        if (field.value.constant != "0") {
-          if (IsString(field.value.type)) {
-            std::string escaped;
-            flatbuffers::EscapeString(field.value.constant.c_str(),
-                                      field.value.constant.length(), &escaped,
-                                      true, false);
-            schema += " = " + escaped;
-          } else {
-            schema += " = " + field.value.constant;
-          }
-        }
+        if (field.value.constant != "0") schema += " = " + field.value.constant;
        std::vector<std::string> attributes;
        if (field.IsRequired()) attributes.push_back("required");
        if (field.key) attributes.push_back("key");
--- a/src/idl_gen_go.cpp
+++ b/src/idl_gen_go.cpp
@@ -75,7 +75,6 @@ static Namer::Config GoDefaultConfig() {
          /*object_suffix=*/"T",
          /*keyword_prefix=*/"",
          /*keyword_suffix=*/"_",
-          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
          /*filenames=*/Case::kKeep,
          /*directories=*/Case::kKeep,
          /*output_path=*/"",
--- a/src/idl_gen_java.cpp
+++ b/src/idl_gen_java.cpp
@@ -46,7 +46,6 @@ static Namer::Config JavaDefaultConfig() {
      /*object_suffix=*/"T",
      /*keyword_prefix=*/"",
      /*keyword_suffix=*/"_",
-      /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
      /*filenames=*/Case::kKeep,
      /*directories=*/Case::kKeep,
      /*output_path=*/"",
--- a/src/idl_gen_kotlin.cpp
+++ b/src/idl_gen_kotlin.cpp
@@ -64,7 +64,6 @@ static Namer::Config KotlinDefaultConfig() {
          /*object_suffix=*/"T",
          /*keyword_prefix=*/"",
          /*keyword_suffix=*/"_",
-          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
          /*filenames=*/Case::kKeep,
          /*directories=*/Case::kKeep,
          /*output_path=*/"",
--- a/src/idl_gen_kotlin_kmp.cpp
+++ b/src/idl_gen_kotlin_kmp.cpp
@@ -62,7 +62,6 @@ static Namer::Config KotlinDefaultConfig() {
          /*object_suffix=*/"T",
          /*keyword_prefix=*/"",
          /*keyword_suffix=*/"E",
-          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
          /*filenames=*/Case::kUpperCamel,
          /*directories=*/Case::kLowerCamel,
          /*output_path=*/"",
--- a/src/idl_gen_python.cpp
+++ b/src/idl_gen_python.cpp
@@ -593,18 +593,6 @@ class PythonStubGenerator {
                    "bytes) -> uoffset: ...\n";
          }
        }
-
-        stub << "def ";
-        if (!parser_.opts.python_no_type_prefix_suffix) stub << type;
-        stub << "Create" << namer_.Method(*field)
-             << "Vector(builder: flatbuffers.Builder, data: typing.Iterable["
-                "typing.Any]) -> uoffset: ...\n";
-        if (!parser_.opts.one_file &&
-            !parser_.opts.python_no_type_prefix_suffix) {
-          stub << "def Create" << namer_.Method(*field)
-               << "Vector(builder: flatbuffers.Builder, data: "
-                  "typing.Iterable[typing.Any]) -> uoffset: ...\n";
-        }
      }
    }

@@ -1479,59 +1467,6 @@ class PythonGenerator : public BaseGenerator {
    }
  }

-  void BuildVectorCreationHelper(const StructDef& struct_def,
-                                 const FieldDef& field, std::string* code_ptr,
-                                 ImportMap& imports) const {
-    auto& code = *code_ptr;
-    const auto vector_type = field.value.type.VectorType();
-    const bool is_struct_vector = IsStruct(vector_type);
-    const bool is_scalar_vector =
-        IsScalar(vector_type.base_type) || vector_type.enum_def != nullptr;
-    const std::string struct_type = namer_.Type(struct_def);
-    const std::string field_method = namer_.Method(field);
-    const std::string helper_name =
-        parser_.opts.python_no_type_prefix_suffix
-            ? "Create" + field_method + "Vector"
-            : struct_type + "Create" + field_method + "Vector";
-
-    if (parser_.opts.python_typing) {
-      imports.insert(ImportMapEntry{"typing", "Iterable"});
-      code += "def " + helper_name +
-              "(builder: flatbuffers.Builder, data: Iterable[Any]) -> int:\n";
-    } else {
-      code += "def " + helper_name + "(builder, data):\n";
-    }
-
-    if (is_scalar_vector || is_struct_vector) {
-      auto alignment = InlineAlignment(vector_type);
-      auto elem_size = InlineSize(vector_type);
-      code += Indent + "data = list(data)\n";
-      code += Indent + "builder.StartVector(" + NumToString(elem_size) +
-              ", len(data), " + NumToString(alignment) + ")\n";
-      code += Indent + "for item in reversed(data):\n";
-      if (is_struct_vector) {
-        code += Indent + Indent + "item.Pack(builder)\n";
-      } else {
-        code += Indent + Indent + "builder.Prepend" +
-                namer_.Method(GenTypeBasic(vector_type)) + "(item)\n";
-      }
-      code += Indent + "return builder.EndVector()\n\n";
-    } else {
-      code += Indent + "return builder.CreateVectorOfTables(data)\n\n";
-    }
-
-    if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) {
-      if (parser_.opts.python_typing) {
-        code += "def Create" + field_method +
-                "Vector(builder: flatbuffers.Builder, data: Iterable[Any]) "
-                "-> int:\n";
-      } else {
-        code += "def Create" + field_method + "Vector(builder, data):\n";
-      }
-      code += Indent + "return " + helper_name + "(builder, data)\n\n";
-    }
-  }
-
  // Set the value of one of the members of a table's vector and fills in the
  // elements from a bytearray. This is for simplifying the use of nested
  // flatbuffers.
@@ -1682,8 +1617,8 @@ class PythonGenerator : public BaseGenerator {
  }

  // Generate table constructors, conditioned on its members' types.
-  void GenTableBuilders(const StructDef& struct_def, std::string* code_ptr,
-                        ImportMap& imports) const {
+  void GenTableBuilders(const StructDef& struct_def,
+                        std::string* code_ptr) const {
    GetStartOfTable(struct_def, code_ptr);

    for (auto it = struct_def.fields.vec.begin();
@@ -1695,7 +1630,6 @@ class PythonGenerator : public BaseGenerator {
      BuildFieldOfTable(struct_def, field, offset, code_ptr);
      if (IsVector(field.value.type)) {
        BuildVectorOfTable(struct_def, field, code_ptr);
-        BuildVectorCreationHelper(struct_def, field, code_ptr, imports);
        BuildVectorOfTableFromBytes(struct_def, field, code_ptr);
      }
    }
@@ -1762,7 +1696,7 @@ class PythonGenerator : public BaseGenerator {
      GenStructBuilder(struct_def, code_ptr);
    } else {
      // Creates a set of functions that allow table construction.
-      GenTableBuilders(struct_def, code_ptr, imports);
+      GenTableBuilders(struct_def, code_ptr);
    }
  }

@@ -2095,12 +2029,12 @@ class PythonGenerator : public BaseGenerator {
    const auto field_method = namer_.Method(field);
    const auto struct_var = namer_.Variable(struct_def);
    const EnumDef& enum_def = *field.value.type.enum_def;
-    auto union_fn = namer_.Function(enum_def);
+    auto union_type = namer_.Type(enum_def);

    if (parser_.opts.include_dependence_headers) {
-      union_fn = namer_.NamespacedType(enum_def) + "." + union_fn;
+      union_type = namer_.NamespacedType(enum_def) + "." + union_type;
    }
-    code += GenIndents(2) + "self." + field_field + " = " + union_fn +
+    code += GenIndents(2) + "self." + field_field + " = " + union_type +
            "Creator(" + "self." + field_field + "Type, " + struct_var + "." +
            field_method + "())";
  }
@@ -2471,7 +2405,7 @@ class PythonGenerator : public BaseGenerator {
    } else {
      GenPackForScalarVectorFieldHelper(struct_def, field, code_prefix_ptr, 3);
      code_prefix += "(self." + field_field + "[i])";
-      code_prefix += GenIndents(3) + field_field + " = builder.EndVector()";
+      code_prefix += GenIndents(4) + field_field + " = builder.EndVector()";
    }
  }

--- a/src/idl_gen_rust.cpp
+++ b/src/idl_gen_rust.cpp
--- a/src/idl_gen_swift.cpp
+++ b/src/idl_gen_swift.cpp
@@ -47,7 +47,6 @@ static Namer::Config SwiftDefaultConfig() {
          /*object_suffix=*/"T",
          /*keyword_prefix=*/"",
          /*keyword_suffix=*/"_",
-          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
          /*filenames=*/Case::kKeep,
          /*directories=*/Case::kKeep,
          /*output_path=*/"",
@@ -164,7 +163,7 @@ class SwiftGenerator : public BaseGenerator {
  bool generate() {
    code_.Clear();
    code_.SetValue("ACCESS", "_accessor");
-    code_.SetValue("TABLEOFFSET", "VT");
+    code_.SetValue("TABLEOFFSET", "VTOFFSET");
    code_ += "// " + std::string(FlatBuffersGeneratedWarning());
    code_ += "// swiftlint:disable all";
    code_ += "// swiftformat:disable all\n";
@@ -282,16 +281,9 @@ class SwiftGenerator : public BaseGenerator {
            NumToString(field.value.type.VectorType().fixed_length);
        code_.SetValue("FIXEDLENGTH", fixed_length);

-        std::string vector_base_type;
-        if (IsStruct(field.value.type.VectorType())) {
-          vector_base_type = type + "()";
-        } else if (IsBool(field.value.type.VectorType().base_type)) {
-          vector_base_type = "false";
-        } else if (IsFloat(field.value.type.VectorType().base_type)) {
-          vector_base_type = "0.0";
-        } else {
-          vector_base_type = SwiftConstant(field);
-        }
+        const auto vector_base_type = IsStruct(field.value.type.VectorType())
+                                          ? (type + "()")
+                                          : SwiftConstant(field);
        code_ += "private var _{{FIELDVAR}}: InlineArray<{{FIXEDLENGTH}}, " +
                 valueType + ">";

@@ -525,7 +517,7 @@ class SwiftGenerator : public BaseGenerator {
  void GenTableAccessors(const StructDef& struct_def) {
    // Generate field id constants.
    if (struct_def.fields.vec.size() > 0) {
-      code_ += "private struct {{TABLEOFFSET}} {";
+      code_ += "private enum {{TABLEOFFSET}}: VOffset {";
      Indent();
      for (auto it = struct_def.fields.vec.begin();
           it != struct_def.fields.vec.end(); ++it) {
@@ -535,8 +527,10 @@ class SwiftGenerator : public BaseGenerator {
        }
        code_.SetValue("OFFSET_NAME", namer_.Variable(field));
        code_.SetValue("OFFSET_VALUE", NumToString(field.value.offset));
-        code_ += "static let {{OFFSET_NAME}}: VOffset = {{OFFSET_VALUE}}";
+        code_ += "case {{OFFSET_NAME}} = {{OFFSET_VALUE}}";
      }
+      code_ += "var v: Int32 { Int32(self.rawValue) }";
+      code_ += "var p: VOffset { self.rawValue }";
      Outdent();
      code_ += "}";
      code_ += "";
@@ -625,8 +619,7 @@ class SwiftGenerator : public BaseGenerator {
    if (should_generate_create) {
      code_ += "{{ACCESS_TYPE}} static func create{{SHORT_STRUCTNAME}}(";
      Indent();
-      code_ += "_ fbb: inout FlatBufferBuilder\\";
-      if (create_func_header.empty() == false) code_ += ",";
+      code_ += "_ fbb: inout FlatBufferBuilder,";
      for (auto it = create_func_header.begin(); it < create_func_header.end();
           ++it) {
        code_ += *it + "\\";
@@ -705,7 +698,7 @@ class SwiftGenerator : public BaseGenerator {
      code_ += field.IsOptional() ? (optional_enum + "\\")
                                  : (is_enum + ", def: {{CONSTANT}}\\");

-      code_ += ", at: {{TABLEOFFSET}}.{{OFFSET}}) }";
+      code_ += ", at: {{TABLEOFFSET}}.{{OFFSET}}.p) }";

      const auto default_value =
          IsEnum(field.value.type)
@@ -725,7 +718,7 @@ class SwiftGenerator : public BaseGenerator {
      code_ +=
          "{{VALUETYPE}}" + builder_string + "fbb.add(element: {{FIELDVAR}},\\";
      code_ += field.IsOptional() ? "\\" : " def: {{CONSTANT}},";
-      code_ += " at: {{TABLEOFFSET}}.{{OFFSET}}) }";
+      code_ += " at: {{TABLEOFFSET}}.{{OFFSET}}.p) }";
      create_func_header.push_back(
          field_var + ": " + nullable_type + " = " +
          (field.IsOptional() ? "nil" : default_value));
@@ -736,7 +729,7 @@ class SwiftGenerator : public BaseGenerator {
      const auto create_struct =
          "guard let {{FIELDVAR}} = {{FIELDVAR}} else { return };"
          " fbb.create(struct: {{FIELDVAR}}, position: "
-          "{{TABLEOFFSET}}.{{OFFSET}}) }";
+          "{{TABLEOFFSET}}.{{OFFSET}}.p) }";
      code_ += type + "?" + builder_string + create_struct;
      /// Optional hard coded since structs are always optional
      create_func_header.push_back(field_var + ": " + type +
@@ -753,9 +746,8 @@ class SwiftGenerator : public BaseGenerator {
                                 (field.IsRequired() ? "" : " = Offset()"));
    const auto reader_type =
        IsStruct(field.value.type) && field.value.type.struct_def->fixed
-            ? "structOffset: {{TABLEOFFSET}}.{{OFFSET}}) }"
-            : "offset: {{FIELDVAR}}, at: {{TABLEOFFSET}}.{{OFFSET}}) "
-              "}";
+            ? "structOffset: {{TABLEOFFSET}}.{{OFFSET}}.p) }"
+            : "offset: {{FIELDVAR}}, at: {{TABLEOFFSET}}.{{OFFSET}}.p) }";
    code_ += "Offset" + builder_string + "fbb.add(" + reader_type;

    const auto vectortype = field.value.type.VectorType();
@@ -859,10 +851,7 @@ class SwiftGenerator : public BaseGenerator {
        break;

      case BASE_TYPE_STRING: {
-        const auto sc = SwiftConstant(field);
-        std::string default_string;
-        flatbuffers::EscapeString(sc.c_str(), sc.length(), &default_string,
-                                  true, false);
+        const auto default_string = "\"" + SwiftConstant(field) + "\"";
        code_.SetValue("VALUETYPE", GenType(field.value.type));
        code_.SetValue("CONSTANT", field.IsDefault() ? default_string : "nil");
        code_ += GenReaderMainBody(is_required) + GenOffset() +
@@ -870,7 +859,7 @@ class SwiftGenerator : public BaseGenerator {
        code_ += "{{ACCESS_TYPE}} var {{FIELDVAR}}SegmentArray: [UInt8]" +
                 is_required +
                 " { return "
-                 "{{ACCESS}}.getVector(at: {{TABLEOFFSET}}.{{OFFSET}}) }";
+                 "{{ACCESS}}.getVector(at: {{TABLEOFFSET}}.{{OFFSET}}.v) }";
        break;
      }
      case BASE_TYPE_ARRAY:
@@ -904,7 +893,7 @@ class SwiftGenerator : public BaseGenerator {
      code_ +=
          "{{ACCESS_TYPE}} var {{FIELDVAR}}: "
          "FlatbufferVector<{{VALUETYPE}}> "
-          "{ return {{ACCESS}}.vector(at: {{TABLEOFFSET}}.{{OFFSET}}, "
+          "{ return {{ACCESS}}.vector(at: {{TABLEOFFSET}}.{{OFFSET}}.v, "
          "byteSize: {{SIZE}}) }";
    }

@@ -921,7 +910,7 @@ class SwiftGenerator : public BaseGenerator {
      code_ +=
          "{{ACCESS_TYPE}} var {{FIELDVAR}}: "
          "FlatbufferVector<{{VALUETYPE}}_Mutable> "
-          "{ return {{ACCESS}}.vector(at: {{TABLEOFFSET}}.{{OFFSET}}, "
+          "{ return {{ACCESS}}.vector(at: {{TABLEOFFSET}}.{{OFFSET}}.v, "
          "byteSize: {{SIZE}}) }";
      GenUnsafeBufferPointer(field);
      return;
@@ -930,8 +919,7 @@ class SwiftGenerator : public BaseGenerator {
    if (vectortype.base_type == BASE_TYPE_UNION) {
      code_ +=
          "{{ACCESS_TYPE}} var {{FIELDVAR}}: UnionFlatbufferVector "
-          "{ return {{ACCESS}}.unionVector(at: "
-          "{{TABLEOFFSET}}.{{OFFSET}}, "
+          "{ return {{ACCESS}}.unionVector(at: {{TABLEOFFSET}}.{{OFFSET}}.v, "
          "byteSize: {{SIZE}}) }";
      code_ +=
          "{{ACCESS_TYPE}} func {{FIELDVAR}}<T: FlatbuffersInitializable>(at "
@@ -965,21 +953,24 @@ class SwiftGenerator : public BaseGenerator {
        "{{ACCESS_TYPE}} func {{functionName}}<T>(_ body: "
        "(UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return "
        "try "
-        "{{ACCESS}}.withUnsafePointerToSlice(at: "
-        "{{TABLEOFFSET}}.{{OFFSET}}, "
+        "{{ACCESS}}.withUnsafePointerToSlice(at: {{TABLEOFFSET}}.{{OFFSET}}.v, "
        "body: body) }";
  }

-  std::vector<std::string> GenerateCodingKeys(const StructDef& struct_def) {
-    std::vector<std::string> coding_keys;
+  void GenerateCodingKeys(const StructDef& struct_def) {
+    code_ += "enum CodingKeys: String, CodingKey {";
+    Indent();
    for (auto it = struct_def.fields.vec.begin();
         it != struct_def.fields.vec.end(); ++it) {
      const auto& field = **it;
      if (field.deprecated) continue;
-      coding_keys.push_back("case " + namer_.Variable(field) + " = \"" +
-                            field.name + "\"");
+
+      code_.SetValue("RAWVALUENAME", field.name);
+      code_.SetValue("FIELDVAR", namer_.Variable(field));
+      code_ += "case {{FIELDVAR}} = \"{{RAWVALUENAME}}\"";
    }
-    return coding_keys;
+    Outdent();
+    code_ += "}";
  }

  void GenerateEncoderUnionBody(const FieldDef& field) {
@@ -1101,31 +1092,14 @@ class SwiftGenerator : public BaseGenerator {
    GenOSVersionChecks();
    code_ += "extension {{STRUCTNAME}}: Encodable {";
    Indent();
-    auto coding_keys = GenerateCodingKeys(struct_def);
-
-    if (coding_keys.empty() == false) {
-      code_ += "enum CodingKeys: String, CodingKey {";
-      Indent();
-      for (auto it = coding_keys.begin(); it != coding_keys.end(); ++it) {
-        const auto& field = *it;
-        code_ += field;
-      }
-      Outdent();
-      code_ += "}";
-
-      code_ += "";
-    }
+    code_ += "";
+    if (struct_def.fields.vec.empty() == false) GenerateCodingKeys(struct_def);

    code_ += "{{ACCESS_TYPE}} func encode(to encoder: Encoder) throws {";
-
-    if (coding_keys.empty() == false) {
-      Indent();
-      GenerateEncoderBody(struct_def);
-      Outdent();
-    }
-
+    Indent();
+    if (struct_def.fields.vec.empty() == false) GenerateEncoderBody(struct_def);
+    Outdent();
    code_ += "}";
-
    Outdent();
    code_ += "}";
    code_ += "";
@@ -1155,7 +1129,7 @@ class SwiftGenerator : public BaseGenerator {
      }

      code_ +=
-          "try _v.visit(field: {{TABLEOFFSET}}.{{OFFSET}}, fieldName: "
+          "try _v.visit(field: {{TABLEOFFSET}}.{{OFFSET}}.p, fieldName: "
          "\"{{FIELDVAR}}\", required: {{ISREQUIRED}}, type: "
          "{{VALUETYPE}}.self)";
    }
@@ -1175,9 +1149,8 @@ class SwiftGenerator : public BaseGenerator {
    code_.SetValue("VALUETYPE", namer_.NamespacedType(union_def));
    code_.SetValue("FUNCTION_NAME", is_vector ? "visitUnionVector" : "visit");
    code_ +=
-        "try _v.{{FUNCTION_NAME}}(unionKey: "
-        "{{TABLEOFFSET}}.{{OFFSET}}Type, "
-        "unionField: {{TABLEOFFSET}}.{{OFFSET}}, unionKeyName: "
+        "try _v.{{FUNCTION_NAME}}(unionKey: {{TABLEOFFSET}}.{{OFFSET}}Type.p, "
+        "unionField: {{TABLEOFFSET}}.{{OFFSET}}.p, unionKeyName: "
        "\"{{FIELDVAR}}Type\", fieldName: \"{{FIELDVAR}}\", required: "
        "{{ISREQUIRED}}, completion: { (verifier, key: {{VALUETYPE}}, pos) in";
    Indent();
@@ -1652,23 +1625,15 @@ class SwiftGenerator : public BaseGenerator {
        buffer_constructor.push_back(field_var + " = _t." + field_field);

        if (field.IsRequired()) {
-          std::string default_value;
-          if (field.IsDefault()) {
-            const auto sc = SwiftConstant(field);
-            flatbuffers::EscapeString(sc.c_str(), sc.length(), &default_value,
-                                      true, false);
-          } else {
-            default_value = "\"\"";
-          }
-          base_constructor.push_back(field_var + " = " + default_value);
+          std::string default_value =
+              field.IsDefault() ? SwiftConstant(field) : "";
+          base_constructor.push_back(field_var + " = \"" + default_value +
+                                     "\"");
          break;
        }
        if (field.IsDefault() && !field.IsRequired()) {
-          const auto sc = SwiftConstant(field);
-          std::string value;
-          flatbuffers::EscapeString(sc.c_str(), sc.length(), &value,
-                                    true, false);
-          base_constructor.push_back(field_var + " = " + value);
+          std::string value = field.IsDefault() ? SwiftConstant(field) : "nil";
+          base_constructor.push_back(field_var + " = \"" + value + "\"");
        }
        break;
      }
@@ -1927,7 +1892,7 @@ class SwiftGenerator : public BaseGenerator {
  }

  std::string GenOffset() {
-    return "let o = {{ACCESS}}.offset({{TABLEOFFSET}}.{{OFFSET}}); ";
+    return "let o = {{ACCESS}}.offset({{TABLEOFFSET}}.{{OFFSET}}.v); ";
  }

  std::string GenReaderMainBody(const std::string& optional = "") {
@@ -1997,7 +1962,7 @@ class SwiftGenerator : public BaseGenerator {
  std::string GenType(const Type& type,
                      const bool should_consider_suffix = false) const {
    return IsScalar(type.base_type) ? GenTypeBasic(type)
-           : IsArray(type)          ? GenType(type.VectorType())
+           : IsArray(type) ? GenType(type.VectorType())
                           : GenTypePointer(type, should_consider_suffix);
  }

--- a/src/idl_gen_ts.cpp
+++ b/src/idl_gen_ts.cpp
@@ -67,7 +67,6 @@ Namer::Config TypeScriptDefaultConfig() {
          /*object_suffix=*/"T",
          /*keyword_prefix=*/"",
          /*keyword_suffix=*/"_",
-          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
          /*filenames=*/Case::kDasher,
          /*directories=*/Case::kDasher,
          /*output_path=*/"",
@@ -87,7 +86,6 @@ std::set<std::string> TypescriptKeywords() {
      "throw",     "true",     "try",       "typeof",     "var",        "void",
      "while",     "with",     "as",        "implements", "interface",  "let",
      "package",   "private",  "protected", "public",     "static",     "yield",
-      "undefined"  // Used with --ts-undefined-for-optionals
  };
 }

@@ -112,9 +110,7 @@ class TsGenerator : public BaseGenerator {
              const std::string& file_name)
      : BaseGenerator(parser, path, file_name, "", "_", "ts"),
        namer_(WithFlagOptions(TypeScriptDefaultConfig(), parser.opts, path),
-               TypescriptKeywords()),
-        null_keyword_(parser_.opts.ts_undefined_for_optionals ? "undefined"
-                                                              : "null") {}
+               TypescriptKeywords()) {}

  bool generate() {
    generateEnums();
@@ -218,8 +214,6 @@ class TsGenerator : public BaseGenerator {

  std::map<std::string, NsDefinition> ns_defs_;

-  std::string null_keyword_;
-
  // Generate code for all enums.
  void generateEnums() {
    for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
@@ -296,11 +290,11 @@ class TsGenerator : public BaseGenerator {
        auto fully_qualified_type_name =
            it.second.ns->GetFullyQualifiedName(type_name);
        auto is_struct = parser_.structs_.Lookup(fully_qualified_type_name);
-        code += "export {" + type_name;
+        code += "export { " + type_name;
        if (parser_.opts.generate_object_based_api && is_struct) {
          code += ", " + type_name + parser_.opts.object_suffix;
        }
-        code += "} from '";
+        code += " } from '";
        std::string import_extension =
            parser_.opts.ts_no_import_ext ? "" : ".js";
        code += base_name_rel + import_extension + "';\n";
@@ -324,10 +318,9 @@ class TsGenerator : public BaseGenerator {
        export_counter++;
      }

-      if (export_counter > 0) {
+      if (export_counter > 0)
        parser_.opts.file_saver->SaveFile(it.second.filepath.c_str(), code,
                                          false);
-      }
    }
  }

@@ -474,7 +467,7 @@ class TsGenerator : public BaseGenerator {

  std::string GenDefaultValue(const FieldDef& field, import_set& imports) {
    if (field.IsScalarOptional()) {
-      return null_keyword_;
+      return "null";
    }

    const auto& value = field.value;
@@ -522,23 +515,10 @@ class TsGenerator : public BaseGenerator {
      case BASE_TYPE_BOOL:
        return value.constant == "0" ? "false" : "true";

-      case BASE_TYPE_STRING: {
-        // NOTE: Strings without a default value are parsed as "0" by
-        // the parser, so therefore we have to treat "0" as a null-signifying
-        // value.
-        if (value.constant == "0" || value.constant == "null") {
-          return "null";
-        } else {
-          std::string escaped;
-          flatbuffers::EscapeString(value.constant.c_str(),
-                                    value.constant.length(), &escaped,
-                                    true, false);
-          return escaped;
-        }
-      }
+      case BASE_TYPE_STRING:
      case BASE_TYPE_UNION:
      case BASE_TYPE_STRUCT: {
-        return null_keyword_;
+        return "null";
      }

      case BASE_TYPE_ARRAY:
@@ -574,16 +554,16 @@ class TsGenerator : public BaseGenerator {
        } else {
          name = AddImport(imports, owner, *type.struct_def).name;
        }
-        return allowNull ? (name + "|" + null_keyword_) : name;
+        return allowNull ? (name + "|null") : name;
      }
    }

    switch (type.base_type) {
      case BASE_TYPE_BOOL:
-        return allowNull ? ("boolean|" + null_keyword_) : "boolean";
+        return allowNull ? "boolean|null" : "boolean";
      case BASE_TYPE_LONG:
      case BASE_TYPE_ULONG:
-        return allowNull ? ("bigint|" + null_keyword_) : "bigint";
+        return allowNull ? "bigint|null" : "bigint";
      case BASE_TYPE_ARRAY: {
        std::string name;
        if (type.element == BASE_TYPE_LONG || type.element == BASE_TYPE_ULONG) {
@@ -598,16 +578,16 @@ class TsGenerator : public BaseGenerator {
          }
        }

-        return name + (allowNull ? ("|" + null_keyword_) : "");
+        return name + (allowNull ? "|null" : "");
      }
      default:
        if (IsScalar(type.base_type)) {
          if (type.enum_def) {
            const auto enum_name =
                AddImport(imports, owner, *type.enum_def).name;
-            return allowNull ? (enum_name + "|" + null_keyword_) : enum_name;
+            return allowNull ? (enum_name + "|null") : enum_name;
          }
-          return allowNull ? ("number|" + null_keyword_) : "number";
+          return allowNull ? "number|null" : "number";
        }
        return "flatbuffers.Offset";
    }
@@ -661,8 +641,7 @@ class TsGenerator : public BaseGenerator {
  }

  void GenStructArgs(import_set& imports, const StructDef& struct_def,
-                     const Definition& owner, std::string* arguments,
-                     const std::string& nameprefix) {
+                     std::string* arguments, const std::string& nameprefix) {
    for (auto it = struct_def.fields.vec.begin();
         it != struct_def.fields.vec.end(); ++it) {
      auto& field = **it;
@@ -670,11 +649,11 @@ class TsGenerator : public BaseGenerator {
        // Generate arguments for a struct inside a struct. To ensure names
        // don't clash, and to make it obvious these arguments are constructing
        // a nested struct, prefix the name with the field name.
-        GenStructArgs(imports, *field.value.type.struct_def, owner, arguments,
+        GenStructArgs(imports, *field.value.type.struct_def, arguments,
                      nameprefix + field.name + "_");
      } else {
        *arguments += ", " + nameprefix + field.name + ": " +
-                      GenTypeName(imports, owner, field.value.type, true,
+                      GenTypeName(imports, field, field.value.type, true,
                                  field.IsOptional());
      }
    }
@@ -818,7 +797,7 @@ class TsGenerator : public BaseGenerator {

      code += "static finish" + (size_prefixed ? sizePrefixed : "") +
              GetPrefixedName(struct_def) + "Buffer";
-      code += "(builder:flatbuffers.Builder, offset:flatbuffers.Offset):void {\n";
+      code += "(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {\n";
      code += "  builder.finish(offset";
      if (!parser_.file_identifier_.empty()) {
        code += ", '" + parser_.file_identifier_ + "'";
@@ -936,48 +915,6 @@ class TsGenerator : public BaseGenerator {
    return symbols_expression;
  }

-  std::vector<std::string> PathComponents(const std::string& path) const {
-    std::vector<std::string> components;
-    size_t start = 0;
-    while (start < path.size()) {
-      auto end = path.find(kPathSeparator, start);
-      if (end == std::string::npos) end = path.size();
-      if (end > start) {
-        components.emplace_back(path.substr(start, end - start));
-      }
-      if (end == path.size()) break;
-      start = end + 1;
-    }
-    return components;
-  }
-
-  std::string RelativeDirectory(const std::vector<std::string>& from,
-                                const std::vector<std::string>& to) const {
-    size_t common = 0;
-    while (common < from.size() && common < to.size() &&
-           from[common] == to[common]) {
-      ++common;
-    }
-
-    std::string rel;
-    const size_t ups = from.size() - common;
-    if (ups == 0) {
-      rel = ".";
-    } else {
-      for (size_t i = 0; i < ups; ++i) {
-        if (!rel.empty()) rel += kPathSeparator;
-        rel += "..";
-      }
-    }
-
-    for (size_t i = common; i < to.size(); ++i) {
-      if (!rel.empty()) rel += kPathSeparator;
-      rel += to[i];
-    }
-
-    return rel;
-  }
-
  template <typename DefinitionT>
  ImportDefinition AddImport(import_set& imports, const Definition& dependent,
                             const DefinitionT& dependency) {
@@ -1005,32 +942,26 @@ class TsGenerator : public BaseGenerator {
    const std::string symbols_expression = GenSymbolExpression(
        dependency, has_name_clash, import_name, name, object_name);

-    const Namespace* dependent_ns = dependent.defined_namespace
-                                        ? dependent.defined_namespace
-                                        : parser_.empty_namespace_;
-    const Namespace* dependency_ns = dependency.defined_namespace
-                                         ? dependency.defined_namespace
-                                         : parser_.empty_namespace_;
+    std::string bare_file_path;
+    std::string rel_file_path;
+    if (dependent.defined_namespace) {
+      const auto& dep_comps = dependent.defined_namespace->components;
+      for (size_t i = 0; i < dep_comps.size(); i++) {
+        rel_file_path += i == 0 ? ".." : (kPathSeparator + std::string(".."));
+      }
+      if (dep_comps.size() == 0) {
+        rel_file_path += ".";
+      }
+    } else {
+      rel_file_path += "..";
+    }

-    const std::string dependent_dirs =
-        namer_.Directories(*dependent_ns, SkipDir::OutputPath);
-    const std::string dependency_dirs =
-        namer_.Directories(*dependency_ns, SkipDir::OutputPath);
-
-    const auto dependent_components = PathComponents(dependent_dirs);
-    const auto dependency_components = PathComponents(dependency_dirs);
-
-    std::string rel_dir =
-        RelativeDirectory(dependent_components, dependency_components);
-    if (rel_dir.empty()) rel_dir = ".";
-    if (!rel_dir.empty()) rel_dir += kPathSeparator;
-
-    std::string rel_file_path =
-        rel_dir + namer_.File(dependency, SkipFile::SuffixAndExtension);
-
-    std::string bare_file_path =
-        kPathSeparator + dependency_dirs +
+    bare_file_path +=
+        kPathSeparator +
+        namer_.Directories(dependency.defined_namespace->components,
+                           SkipDir::OutputPath) +
        namer_.File(dependency, SkipFile::SuffixAndExtension);
+    rel_file_path += bare_file_path;

    ImportDefinition import;
    import.name = name;
@@ -1040,7 +971,7 @@ class TsGenerator : public BaseGenerator {
    std::string import_extension = parser_.opts.ts_no_import_ext ? "" : ".js";
    import.import_statement = "import { " + symbols_expression + " } from '" +
                              rel_file_path + import_extension + "';";
-    import.export_statement = "export {" + symbols_expression + "} from '." +
+    import.export_statement = "export { " + symbols_expression + " } from '." +
                              bare_file_path + import_extension + "';";
    import.dependency = &dependency;
    import.dependent = &dependent;
@@ -1108,8 +1039,7 @@ class TsGenerator : public BaseGenerator {
      const auto& enum_def = *union_type.enum_def;

      const auto valid_union_type = GenUnionTypeTS(enum_def, imports);
-      const auto valid_union_type_with_null =
-          valid_union_type + "|" + null_keyword_;
+      const auto valid_union_type_with_null = valid_union_type + "|null";

      auto ret = "\n\nexport function " + GenUnionConvFuncName(enum_def) +
                 "(\n  type: " + GetTypeName(enum_def) +
@@ -1121,7 +1051,7 @@ class TsGenerator : public BaseGenerator {

      const auto union_enum_loop = [&](const std::string& accessor_str) {
        ret += "  switch(" + enum_type + "[type]) {\n";
-        ret += "    case 'NONE': return " + null_keyword_ + "; \n";
+        ret += "    case 'NONE': return null; \n";

        for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end();
             ++it) {
@@ -1145,7 +1075,7 @@ class TsGenerator : public BaseGenerator {
          ret += "\n";
        }

-        ret += "    default: return " + null_keyword_ + ";\n";
+        ret += "    default: return null;\n";
        ret += "  }\n";
      };

@@ -1190,8 +1120,7 @@ class TsGenerator : public BaseGenerator {
        ret += "      const temp = " + conversion_function + "(this." +
               namer_.Method(field_name, "Type") + "(), " +
               field_binded_method + ");\n";
-        ret += "      if(temp === " + null_keyword_ + ") { return " +
-               null_keyword_ + "; }\n";
+        ret += "      if(temp === null) { return null; }\n";
        ret += union_has_string
                   ? "      if(typeof temp === 'string') { return temp; }\n"
                   : "";
@@ -1211,12 +1140,12 @@ class TsGenerator : public BaseGenerator {
               "++targetEnumIndex) {\n";
        ret += "      const targetEnum = this." +
               namer_.Method(field_name, "Type") + "(targetEnumIndex);\n";
-        ret += "      if(targetEnum === " + null_keyword_ + " || " + enum_type +
+        ret += "      if(targetEnum === null || " + enum_type +
               "[targetEnum!] === 'NONE') { "
               "continue; }\n\n";
        ret += "      const temp = " + conversion_function + "(targetEnum, " +
               field_binded_method + ", targetEnumIndex);\n";
-        ret += "      if(temp === " + null_keyword_ + ") { continue; }\n";
+        ret += "      if(temp === null) { continue; }\n";
        ret += union_has_string ? "      if(typeof temp === 'string') { "
                                  "ret.push(temp); continue; }\n"
                                : "";
@@ -1233,12 +1162,11 @@ class TsGenerator : public BaseGenerator {
    return "";
  }

-  std::string GenNullCheckConditional(const std::string& nullCheckVar,
-                                      const std::string& trueVal,
-                                      const std::string& falseVal = "") {
-    std::string false_val = falseVal.empty() ? null_keyword_ : falseVal;
-    return "(" + nullCheckVar + " !== " + null_keyword_ + " ? " + trueVal +
-           " : " + false_val + ")";
+  static std::string GenNullCheckConditional(
+      const std::string& nullCheckVar, const std::string& trueVal,
+      const std::string& falseVal = "null") {
+    return "(" + nullCheckVar + " !== null ? " + trueVal + " : " + falseVal +
+           ")";
  }

  std::string GenStructMemberValueTS(const StructDef& struct_def,
@@ -1347,9 +1275,10 @@ class TsGenerator : public BaseGenerator {
      // Emit a scalar field
      const auto is_string = IsString(field.value.type);
      if (IsScalar(field.value.type.base_type) || is_string) {
-        field_type +=
-            GenTypeName(imports, field, field.value.type, false,
-                        !HasDefaultValue(field) || HasNullDefault(field));
+        const auto has_null_default = is_string || HasNullDefault(field);
+
+        field_type += GenTypeName(imports, field, field.value.type, false,
+                                  has_null_default);
        field_val = "this." + namer_.Method(field) + "()";

        if (field.value.type.base_type != BASE_TYPE_STRING) {
@@ -1371,8 +1300,8 @@ class TsGenerator : public BaseGenerator {

            const std::string field_accessor =
                "this." + namer_.Method(field) + "()";
-            field_val = GenNullCheckConditional(
-                field_accessor, field_accessor + "!.unpack()", null_keyword_);
+            field_val = GenNullCheckConditional(field_accessor,
+                                                field_accessor + "!.unpack()");
            auto packing = GenNullCheckConditional(
                "this." + field_field,
                "this." + field_field + "!.pack(builder)", "0");
@@ -1580,8 +1509,8 @@ class TsGenerator : public BaseGenerator {
            break;
        }

-        // length 0 vector is simply empty instead of null/undefined.
-        field_type += is_vector ? "" : ("|" + null_keyword_);
+        // length 0 vector is simply empty instead of null
+        field_type += is_vector ? "" : "|null";
      }

      if (!field_offset_decl.empty()) {
@@ -1610,7 +1539,7 @@ class TsGenerator : public BaseGenerator {
        } else {
          if (field.IsScalarOptional()) {
            pack_func_create_call +=
-                "  if (" + field_offset_val + " !== " + null_keyword_ + ")\n  ";
+                "  if (" + field_offset_val + " !== null)\n  ";
          }
          pack_func_create_call += "  " + struct_name + "." +
                                   namer_.Method("add", field) + "(builder, " +
@@ -1695,15 +1624,13 @@ class TsGenerator : public BaseGenerator {
    GenDocComment(struct_def.doc_comment, code_ptr);
    code += "export class ";
    code += object_name;
-    if (parser.opts.generate_object_based_api) {
+    if (parser.opts.generate_object_based_api)
      code += " implements flatbuffers.IUnpackableObject<" + object_api_name +
              "> {\n";
-    } else {
+    else
      code += " {\n";
-    }
-    code += "  bb: flatbuffers.ByteBuffer|" + null_keyword_ + " = " +
-            null_keyword_ + ";\n";
-    code += "  bb_pos: number = 0;\n";
+    code += "  bb: flatbuffers.ByteBuffer|null = null;\n";
+    code += "  bb_pos = 0;\n";

    // Generate the __init method that sets the field in a pre-existing
    // accessor object. This is to allow object reuse.
@@ -1743,22 +1670,21 @@ class TsGenerator : public BaseGenerator {
        offset_prefix = "  const offset = " + GenBBAccess() +
                        ".__offset(this.bb_pos, " +
                        NumToString(field.value.offset) + ");\n";
-        offset_prefix += "  return ";
+        offset_prefix += "  return offset ? ";
      }

      // Emit a scalar field
      const auto is_string = IsString(field.value.type);
      if (IsScalar(field.value.type.base_type) || is_string) {
-        const auto has_null_default =
-            !field.IsRequired() && !HasDefaultValue(field);
+        const auto has_null_default = is_string || HasNullDefault(field);

        GenDocComment(field.doc_comment, code_ptr);
        std::string prefix = namer_.Method(field) + "(";
        if (is_string) {
-          code += prefix + "):" + (has_null_default ? "string|" + null_keyword_ : "string") + "\n";
+          code += prefix + "):string|null\n";
          code +=
              prefix + "optionalEncoding:flatbuffers.Encoding" + "):" +
-              GenTypeName(imports, struct_def, field.value.type, false, has_null_default) +
+              GenTypeName(imports, struct_def, field.value.type, false, true) +
              "\n";
          code += prefix + "optionalEncoding?:any";
        } else {
@@ -1787,16 +1713,9 @@ class TsGenerator : public BaseGenerator {
          if (is_string) {
            index += ", optionalEncoding";
          }
-          if (field.IsRequired()) {
-            code +=
-                offset_prefix + GenGetter(field.value.type, "(" + index + ")");
-            ;
-          } else {
-            code += offset_prefix + "offset ? " +
-                    GenGetter(field.value.type, "(" + index + ")");
-          }
-          if (field.value.type.base_type != BASE_TYPE_ARRAY &&
-              !field.IsRequired()) {
+          code +=
+              offset_prefix + GenGetter(field.value.type, "(" + index + ")");
+          if (field.value.type.base_type != BASE_TYPE_ARRAY) {
            code += " : " + GenDefaultValue(field, imports);
          }
          code += ";\n";
@@ -1812,8 +1731,7 @@ class TsGenerator : public BaseGenerator {
                    .name;
            GenDocComment(field.doc_comment, code_ptr);
            code += namer_.Method(field);
-            code +=
-                "(obj?:" + type + "):" + type + "|" + null_keyword_ + " {\n";
+            code += "(obj?:" + type + "):" + type + "|null {\n";

            if (struct_def.fixed) {
              code += "  return (obj || " + GenerateNewExpression(type);
@@ -1821,12 +1739,12 @@ class TsGenerator : public BaseGenerator {
              code +=
                  MaybeAdd(field.value.offset) + ", " + GenBBAccess() + ");\n";
            } else {
-              code += offset_prefix + "offset ? (obj || " +
-                      GenerateNewExpression(type) + ").__init(";
+              code += offset_prefix + "(obj || " + GenerateNewExpression(type) +
+                      ").__init(";
              code += field.value.type.struct_def->fixed
                          ? "this.bb_pos + offset"
                          : GenBBAccess() + ".__indirect(this.bb_pos + offset)";
-              code += ", " + GenBBAccess() + ") : " + null_keyword_ + ";\n";
+              code += ", " + GenBBAccess() + ") : null;\n";
            }

            break;
@@ -1879,7 +1797,7 @@ class TsGenerator : public BaseGenerator {
            } else {
              code += prefix;
            }
-            code += "):" + vectortypename + "|" + null_keyword_ + " {\n";
+            code += "):" + vectortypename + "|null {\n";

            if (vectortype.base_type == BASE_TYPE_STRUCT) {
              code += offset_prefix + "(obj || " +
@@ -1919,7 +1837,7 @@ class TsGenerator : public BaseGenerator {
                    code += " : 0";
                  }
                } else {
-                  code += ": " + null_keyword_;
+                  code += ": null";
                }
                break;
              }
@@ -1977,10 +1895,10 @@ class TsGenerator : public BaseGenerator {
            } else {
              code += prefix;
            }
-            code += "):" + vectortypename + "|" + null_keyword_ + " {\n";
+            code += "):" + vectortypename + "|null {\n";

            if (vectortype.base_type == BASE_TYPE_STRUCT) {
-              code += offset_prefix + "offset ? (obj || " +
+              code += offset_prefix + "(obj || " +
                      GenerateNewExpression(vectortypename);
              code += ").__init(";
              code += vectortype.struct_def->fixed
@@ -1993,8 +1911,7 @@ class TsGenerator : public BaseGenerator {
              } else if (IsString(vectortype)) {
                index += ", optionalEncoding";
              }
-              code += offset_prefix + "offset ? " +
-                      GenGetter(vectortype, "(" + index + ")");
+              code += offset_prefix + GenGetter(vectortype, "(" + index + ")");
            }
            code += " : ";
            if (field.value.type.element == BASE_TYPE_BOOL) {
@@ -2004,12 +1921,12 @@ class TsGenerator : public BaseGenerator {
              code += "BigInt(0)";
            } else if (IsScalar(field.value.type.element)) {
              if (field.value.type.enum_def) {
-                code += null_keyword_;
+                code += "null";
              } else {
                code += "0";
              }
            } else {
-              code += null_keyword_;
+              code += "null";
            }
            code += ";\n";
            break;
@@ -2022,13 +1939,13 @@ class TsGenerator : public BaseGenerator {
            const auto& union_enum = *(field.value.type.enum_def);
            const auto union_type = GenUnionGenericTypeTS(union_enum);
            code += "<T extends flatbuffers.Table>(obj:" + union_type +
-                    "):" + union_type + "|" + null_keyword_ +
-                    " "
+                    "):" + union_type +
+                    "|null "
                    "{\n";

-            code += offset_prefix + "offset ? " +
+            code += offset_prefix +
                    GenGetter(field.value.type, "(obj, this.bb_pos + offset)") +
-                    " : " + null_keyword_ + ";\n";
+                    " : null;\n";
            break;
          }
          default:
@@ -2079,7 +1996,7 @@ class TsGenerator : public BaseGenerator {
        // Emit a length helper
        GenDocComment(code_ptr);
        code += namer_.Method(field, "Length");
-        code += "():number {\n" + offset_prefix + "offset ? ";
+        code += "():number {\n" + offset_prefix;

        code +=
            GenBBAccess() + ".__vector_len(this.bb_pos + offset) : 0;\n}\n\n";
@@ -2090,30 +2007,14 @@ class TsGenerator : public BaseGenerator {
          GenDocComment(code_ptr);

          code += namer_.Method(field, "Array");
+          code +=
+              "():" + GenType(vectorType) + "Array|null {\n" + offset_prefix;

-          std::string return_type =
-              (field.IsRequired() || HasDefaultValue(field))
-                  ? "Array"
-                  : ("Array|" + null_keyword_);
-          if (field.IsRequired()) {
-            code += "():" + GenType(vectorType) + return_type + " {\n" +
-                    offset_prefix + "new " + GenType(vectorType) + "Array(" +
-                    GenBBAccess() + ".bytes().buffer, " + GenBBAccess() +
-                    ".bytes().byteOffset + " + GenBBAccess() +
-                    ".__vector(this.bb_pos + offset), " + GenBBAccess() +
-                    ".__vector_len(this.bb_pos + offset));\n}\n\n";
-          } else {
-            std::string value = HasDefaultValue(field)
-                                    ? "new " + GenType(vectorType) + "Array()"
-                                    : "null";
-            code += "():" + GenType(vectorType) + return_type + " {\n" +
-                    offset_prefix + "offset ? new " + GenType(vectorType) +
-                    "Array(" + GenBBAccess() + ".bytes().buffer, " +
-                    GenBBAccess() + ".bytes().byteOffset + " + GenBBAccess() +
-                    ".__vector(this.bb_pos + offset), " + GenBBAccess() +
-                    ".__vector_len(this.bb_pos + offset)) : " + value +
-                    ";\n}\n\n";
-          }
+          code += "new " + GenType(vectorType) + "Array(" + GenBBAccess() +
+                  ".bytes().buffer, " + GenBBAccess() +
+                  ".bytes().byteOffset + " + GenBBAccess() +
+                  ".__vector(this.bb_pos + offset), " + GenBBAccess() +
+                  ".__vector_len(this.bb_pos + offset)) : null;\n}\n\n";
        }
      }
    }
@@ -2142,7 +2043,7 @@ class TsGenerator : public BaseGenerator {
    // Emit a factory constructor
    if (struct_def.fixed) {
      std::string arguments;
-      GenStructArgs(imports, struct_def, struct_def, &arguments, "");
+      GenStructArgs(imports, struct_def, &arguments, "");
      GenDocComment(code_ptr);

      code += "static create" + GetPrefixedName(struct_def) +
@@ -2156,7 +2057,7 @@ class TsGenerator : public BaseGenerator {
      GenDocComment(code_ptr);

      code += "static start" + GetPrefixedName(struct_def) +
-              "(builder:flatbuffers.Builder):void {\n";
+              "(builder:flatbuffers.Builder) {\n";

      code += "  builder.startObject(" +
              NumToString(struct_def.fields.vec.size()) + ");\n";
@@ -2173,7 +2074,7 @@ class TsGenerator : public BaseGenerator {
        GenDocComment(code_ptr);
        code += "static " + namer_.Method("add", field);
        code += "(builder:flatbuffers.Builder, " + argname + ":" +
-                GetArgType(imports, struct_def, field, false) + "):void {\n";
+                GetArgType(imports, struct_def, field, false) + ") {\n";
        code += "  builder.addField" + GenWriteMethod(field.value.type) + "(";
        code += NumToString(it - struct_def.fields.vec.begin()) + ", ";
        if (field.value.type.base_type == BASE_TYPE_BOOL) {
@@ -2183,7 +2084,7 @@ class TsGenerator : public BaseGenerator {
        if (!IsScalar(field.value.type.base_type)) {
          code += "0";
        } else if (HasNullDefault(field)) {
-          code += null_keyword_;
+          code += "null";
        } else {
          if (field.value.type.base_type == BASE_TYPE_BOOL) {
            code += "+";
@@ -2245,7 +2146,7 @@ class TsGenerator : public BaseGenerator {

          code += "static ";
          code += namer_.Method("start", field, "Vector");
-          code += "(builder:flatbuffers.Builder, numElems:number):void {\n";
+          code += "(builder:flatbuffers.Builder, numElems:number) {\n";
          code += "  builder.startVector(" + NumToString(elem_size);
          code += ", numElems, " + NumToString(alignment) + ");\n";
          code += "}\n\n";
@@ -2300,7 +2201,7 @@ class TsGenerator : public BaseGenerator {
          const auto arg_name = GetArgName(field);

          if (field.IsScalarOptional()) {
-            code += "  if (" + arg_name + " !== " + null_keyword_ + ")\n  ";
+            code += "  if (" + arg_name + " !== null)\n  ";
          }

          code += "  " + methodPrefix + "." + namer_.Method("add", field) + "(";
@@ -2340,38 +2241,10 @@ class TsGenerator : public BaseGenerator {
    }
  }

-  bool HasNullDefault(const FieldDef& field) {
+  static bool HasNullDefault(const FieldDef& field) {
    return field.IsOptional() && field.value.constant == "null";
  }

-  static bool HasDefaultValue(const FieldDef& field) {
-    switch (field.value.type.base_type) {
-      // These types can't have defaults
-      case BASE_TYPE_UNION:
-      case BASE_TYPE_STRUCT: {
-        return false;
-      }
-
-      // Arrays always have a default (empty array)
-      case BASE_TYPE_ARRAY:
-        return true;
-
-      // The only supported default for vectors is []
-      case BASE_TYPE_VECTOR:
-        return field.value.constant == "[]";
-
-      // Even strings are presumed to be null-default if the default value is
-      // "0", this is intended behavior.
-      case BASE_TYPE_STRING: {
-        return field.value.constant != "0" && field.value.constant != "null";
-      }
-
-      default: {
-        return field.value.constant != "null";
-      }
-    }
-  }
-
  std::string GetArgType(import_set& imports, const Definition& owner,
                         const FieldDef& field, bool allowNull) {
    return GenTypeName(imports, owner, field.value.type, true,
--- a/src/idl_parser.cpp
+++ b/src/idl_parser.cpp
@@ -2755,42 +2755,6 @@ std::vector<IncludedFile> Parser::GetIncludedFiles() const {
  return {it->second.cbegin(), it->second.cend()};
 }

-bool Parser::HasCircularStructDependency() {
-  std::function<bool(StructDef*)> visit =
-      [&](StructDef* struct_def) {
-        // Only consider fixed structs and structs we have yet to check
-        if (!struct_def->fixed || struct_def->cycle_status == StructDef::CycleStatus::Checked) {
-          return false;
-        }
-
-        if (struct_def->cycle_status == StructDef::CycleStatus::InProgress) {
-          // cycle found
-          return true;
-        }
-
-        struct_def->cycle_status = StructDef::CycleStatus::InProgress;
-
-        for (const auto& field : struct_def->fields.vec) {
-          if (field->value.type.base_type == BASE_TYPE_STRUCT) {
-            if (visit(field->value.type.struct_def)) {
-              return true;  // Cycle detected in recursion.
-            }
-          }
-        }
-
-        struct_def->cycle_status = StructDef::CycleStatus::Checked;
-        return false;  // No cycle detected.
-      };
-
-  for (const auto& struct_def : structs_.vec) {
-    if (visit(struct_def)) {
-      return true;  // Cycle detected.
-    }
-  }
-
-  return false;  // No cycle detected.
-}
-
 bool Parser::SupportsOptionalScalars(const flatbuffers::IDLOptions& opts) {
  static FLATBUFFERS_CONSTEXPR unsigned long supported_langs =
      IDLOptions::kRust | IDLOptions::kSwift | IDLOptions::kLobster |
@@ -2809,8 +2773,7 @@ bool Parser::SupportsOptionalScalars() const {
 bool Parser::SupportsDefaultVectorsAndStrings() const {
  static FLATBUFFERS_CONSTEXPR unsigned long supported_langs =
      IDLOptions::kRust | IDLOptions::kSwift | IDLOptions::kNim |
-      IDLOptions::kCpp | IDLOptions::kBinary | IDLOptions::kJson |
-      IDLOptions::kTs;
+      IDLOptions::kCpp | IDLOptions::kBinary | IDLOptions::kJson;
  return !(opts.lang_to_generate & ~supported_langs);
 }

@@ -3172,10 +3135,8 @@ CheckedError Parser::ParseProtoFields(StructDef* struct_def, bool isextend,
            return Error("Protobuf has non positive number in reserved ids");

          if (range) {
-            for (uint32_t id = static_cast<uint32_t>(from) + 1;
-                 id <= static_cast<uint32_t>(attribute); id++) {
-              struct_def->reserved_ids.push_back(static_cast<voffset_t>(id));
-            }
+            for (voffset_t id = from + 1; id <= attribute; id++)
+              struct_def->reserved_ids.push_back(id);

            range = false;
          } else {
@@ -4132,15 +4093,7 @@ bool StructDef::Deserialize(Parser& parser, const reflection::Object* object) {
  sortbysize = attributes.Lookup("original_order") == nullptr && !fixed;
  const auto& of = *(object->fields());
  auto indexes = std::vector<uoffset_t>(of.size());
-  for (uoffset_t i = 0; i < of.size(); i++) {
-  uint16_t field_id = of.Get(i)->id();
-  if (field_id >= of.size()) {
-    parser.error_ = "Field ID " + std::to_string(field_id) + 
-                    " exceeds field count " + std::to_string(of.size());
-    return false;
-  }
-  indexes[field_id] = i;
-}
+  for (uoffset_t i = 0; i < of.size(); i++) indexes[of.Get(i)->id()] = i;
  size_t tmp_struct_size = 0;
  for (size_t i = 0; i < indexes.size(); i++) {
    auto field = of.Get(indexes[i]);
--- a/src/reflection.cpp
+++ b/src/reflection.cpp
@@ -389,7 +389,7 @@ void ForAllFields(const reflection::Object* object, bool reverse,

  for (size_t i = 0; i < field_to_id_map.size(); ++i) {
    func(object->fields()->Get(
-        field_to_id_map[reverse ? field_to_id_map.size() - (i + 1) : i]));
+        field_to_id_map[reverse ? field_to_id_map.size() - i + 1 : i]));
  }
 }

@@ -641,10 +641,7 @@ const uint8_t* AddFlatBuffer(std::vector<uint8_t>& flatbuf,
                             const uint8_t* newbuf, size_t newlen) {
  // Align to sizeof(uoffset_t) past sizeof(largest_scalar_t) since we're
  // going to chop off the root offset.
-  if (!newbuf || newlen < sizeof(uoffset_t)) return nullptr;
  FLATBUFFERS_ASSERT(newlen >= sizeof(uoffset_t));
-  auto root = ReadScalar<uoffset_t>(newbuf);
-  if (root < sizeof(uoffset_t) || root >= newlen) return nullptr;
  while ((flatbuf.size() & (sizeof(uoffset_t) - 1)) ||
         !(flatbuf.size() & (sizeof(largest_scalar_t) - 1))) {
    flatbuf.push_back(0);
@@ -652,7 +649,7 @@ const uint8_t* AddFlatBuffer(std::vector<uint8_t>& flatbuf,
  auto insertion_point = static_cast<uoffset_t>(flatbuf.size());
  // Insert the entire FlatBuffer minus the root pointer.
  flatbuf.insert(flatbuf.end(), newbuf + sizeof(uoffset_t), newbuf + newlen);
-  auto root_offset = root - sizeof(uoffset_t);
+  auto root_offset = ReadScalar<uoffset_t>(newbuf) - sizeof(uoffset_t);
  return flatbuf.data() + insertion_point + root_offset;
 }

--- a/swift/Sources/FlatBuffers/Table.swift
+++ b/swift/Sources/FlatBuffers/Table.swift
@@ -49,7 +49,7 @@ public struct Table {
  /// the vtable
  /// - Parameter o: current offset
  /// - Returns: offset of field within buffer
-  public func offset(_ o: VOffset) -> Int32 {
+  public func offset(_ o: Int32) -> Int32 {
    let vtable = position &- bb.read(def: Int32.self, position: Int(position))
    return o
      < bb
@@ -57,7 +57,7 @@ public struct Table {
      ? Int32(
        bb.read(
          def: Int16.self,
-          position: Int(vtable &+ Int32(o)))) : 0
+          position: Int(vtable &+ o))) : 0
  }

  /// Gets the indirect offset of the current stored object
@@ -106,13 +106,13 @@ public struct Table {
  /// This should only be used by `Scalars`
  /// - Parameter off: Readable offset
  /// - Returns: Returns a vector of type [T]
-  public func getVector<T>(at off: VOffset) -> [T]? {
+  public func getVector<T>(at off: Int32) -> [T]? {
    let o = offset(off)
    guard o != 0 else { return nil }
    return bb.readSlice(index: Int(vector(at: o)), count: Int(vector(count: o)))
  }

-  public func vector<T>(at off: VOffset, byteSize: Int) -> FlatbufferVector<T> {
+  public func vector<T>(at off: Int32, byteSize: Int) -> FlatbufferVector<T> {
    let off = offset(off)
    return FlatbufferVector(
      bb: bb,
@@ -122,7 +122,7 @@ public struct Table {
  }

  public func unionVector(
-    at off: VOffset,
+    at off: Int32,
    byteSize: Int) -> UnionFlatbufferVector
  {
    let off = offset(off)
@@ -146,7 +146,7 @@ public struct Table {
  /// - Returns: Returns a pointer to the underlying data
  @inline(__always)
  public func withUnsafePointerToSlice<T>(
-    at off: VOffset,
+    at off: Int32,
    body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T?
  {
    let o = offset(off)
--- a/swift/Sources/FlexBuffers/Reader/Reference.swift
+++ b/swift/Sources/FlexBuffers/Reader/Reference.swift
@@ -14,7 +14,6 @@
 * limitations under the License.
 */

-import Common
 import Foundation

 enum FlexBuffersErrors: Error {
@@ -24,10 +23,6 @@ enum FlexBuffersErrors: Error {

@inline(__always)
 public func getRoot(buffer: ByteBuffer) throws -> Reference? {
-  assert(
-    isLitteEndian,
-    "Swift FlexBuffers currently only supports little-endian systems")
-
  let end = buffer.count
  if buffer.count < 3 {
    throw FlexBuffersErrors.sizeOfBufferIsTooSmall
--- a/swift/Sources/FlexBuffers/Writer/FlexBuffersWriter.swift
+++ b/swift/Sources/FlexBuffers/Writer/FlexBuffersWriter.swift
@@ -37,15 +37,12 @@ public struct FlexBuffersWriter {
  private var hasDuplicatedKeys = false
  private var minBitWidth: BitWidth = .w8
  private var _bb: _InternalByteBuffer
-  private var stack: Stack = Stack()
+  private var stack: [Value] = []
  private var keyPool: [Int: UInt] = [:]
  private var stringPool: [Int: UInt] = [:]
  private var flags: BuilderFlag

  public init(initialSize: Int = 1024, flags: BuilderFlag = .shareKeys) {
-    assert(
-      isLitteEndian,
-      "Swift FlexBuffers currently only supports little-endian systems")
    _bb = _InternalByteBuffer(initialSize: initialSize)
    self.flags = flags
  }
@@ -151,7 +148,7 @@ public struct FlexBuffersWriter {
      typed: typed,
      fixed: fixed,
      keys: nil)
-    stack.popLast(start)
+    stack = Array(stack[..<start])
    stack.append(vec)
    return vec.u
  }
@@ -220,7 +217,7 @@ public struct FlexBuffersWriter {
      typed: false,
      fixed: false,
      keys: keys)
-    stack.popLast(start)
+    stack = Array(stack[..<start])
    stack.append(vec)
    return numericCast(vec.u)
  }
@@ -724,7 +721,7 @@ public struct FlexBuffersWriter {
        assert(
          vectorType == stack[i].type,
          """
-          If you get this assert you are writing a typed vector
+          If you get this assert you are writing a typed vector 
          with elements that are not all the same type
          """)
      }
@@ -760,7 +757,7 @@ public struct FlexBuffersWriter {
    }

    if !fixed {
-      write(value: UInt64(count), byteWidth: byteWidth)
+      write(value: count, byteWidth: byteWidth)
    }

    let vloc = _bb.writerIndex
@@ -833,14 +830,13 @@ public struct FlexBuffersWriter {
      let key, value: Value
    }

-    stack.withUnsafeMutableBytes(start: start) { buffer in
+    stack[start...].withUnsafeMutableBytes { buffer in
      var ptr = buffer.assumingMemoryBound(to: TwoValue.self)
      ptr.sort { a, b in
        let aMem = _bb.memory.advanced(by: numericCast(a.key.u))
          .assumingMemoryBound(to: CChar.self)
        let bMem = _bb.memory.advanced(by: numericCast(b.key.u))
          .assumingMemoryBound(to: CChar.self)
-
        let comp = strcmp(aMem, bMem)
        if (comp == 0) && a != b { hasDuplicatedKeys = true }
        return comp < 0
@@ -901,129 +897,3 @@ extension FlexBuffersWriter {
    return endMap(start: start)
  }
 }
-
-fileprivate struct Stack: RandomAccessCollection {
-  typealias Element = Value
-  typealias Index = Int
-
-  private final class Storage {
-    var memory: UnsafeMutableRawPointer
-
-    init(capacity: Int, alignment: Int) {
-      memory = .allocate(byteCount: capacity, alignment: alignment)
-      memset(memory, 0, capacity)
-    }
-
-    deinit {
-      memory.deallocate()
-    }
-  }
-
-  private static let initialCapacity = 10 &* MemoryLayout<Value>.stride
-  private let storage: Storage
-  private var capacity: Int
-  private(set) var count: Int
-
-  var startIndex: Int {
-    0
-  }
-
-  var endIndex: Int {
-    count
-  }
-
-  init() {
-    count = 0
-    capacity = Self.initialCapacity
-
-    storage = Storage(
-      capacity: capacity,
-      alignment: MemoryLayout<Value>.alignment)
-  }
-
-  @inline(__always)
-  subscript(position: Int) -> Value {
-    get {
-      storage.memory.advanced(by: position &* MemoryLayout<Value>.stride)
-        .assumingMemoryBound(to: Value.self).pointee
-    }
-    set {
-      storage.memory.advanced(by: position &* MemoryLayout<Value>.stride)
-        .assumingMemoryBound(to: Value.self).pointee = newValue
-    }
-  }
-
-  @inline(__always)
-  mutating func popLast(_ val: Int) {
-    count = if val < 0 {
-      0
-    } else {
-      val
-    }
-  }
-
-  mutating func append(_ value: Value) {
-    let writePosition = count &* MemoryLayout<Value>.stride
-    if writePosition >= capacity {
-      reallocate(writePosition: writePosition)
-    }
-
-    storage.memory.advanced(by: writePosition).storeBytes(
-      of: value,
-      as: Value.self)
-    count += 1
-  }
-
-  mutating func removeAll(keepingCapacity keepCapacity: Bool = false) {
-    count = 0
-    if !keepCapacity {
-      capacity = Self.initialCapacity
-      storage.memory = UnsafeMutableRawPointer.allocate(
-        byteCount: capacity,
-        alignment: MemoryLayout<Value>.alignment)
-    }
-    memset(storage.memory, 0, capacity)
-  }
-
-  @discardableResult
-  mutating func withUnsafeMutableBytes<R>(
-    start: Int,
-    _ body: (UnsafeMutableRawBufferPointer) throws -> R) rethrows -> R
-  {
-    let startingPosition = start &* MemoryLayout<Value>.stride
-    let pointer = storage.memory.advanced(by: startingPosition)
-    return try body(UnsafeMutableRawBufferPointer(
-      start: pointer,
-      count: (count &* MemoryLayout<Value>.stride) &- startingPosition))
-  }
-
-  @discardableResult
-  mutating func withUnsafeMutableBytes<R>(
-    _ body: (UnsafeMutableRawBufferPointer) throws
-      -> R) rethrows -> R
-  {
-    return try body(UnsafeMutableRawBufferPointer(
-      start: storage.memory,
-      count: count &* MemoryLayout<Value>.stride))
-  }
-
-  mutating private func reallocate(writePosition: Int) {
-    while capacity <= writePosition {
-      capacity = capacity << 1
-    }
-
-    /// solution take from Apple-NIO
-    capacity = capacity.convertToPowerofTwo
-
-    let newData = UnsafeMutableRawPointer.allocate(
-      byteCount: capacity,
-      alignment: MemoryLayout<Value>.alignment)
-    memset(newData, 0, capacity)
-    memcpy(
-      newData,
-      storage.memory,
-      writePosition)
-    storage.memory.deallocate()
-    storage.memory = newData
-  }
-}
--- a/swift/Sources/FlexBuffers/_InternalByteBuffer.swift
+++ b/swift/Sources/FlexBuffers/_InternalByteBuffer.swift
@@ -60,7 +60,7 @@ struct _InternalByteBuffer {
      let newData = UnsafeMutableRawPointer.allocate(
        byteCount: capacity,
        alignment: alignment)
-      memset(newData, 0, capacity)
+      memset(newData, 0, capacity &- writerSize)
      memcpy(
        newData,
        memory,
--- a/tests/64bit/BUILD.bazel
+++ b/tests/64bit/BUILD.bazel
@@ -0,0 +1,30 @@
+load("@rules_cc//cc:defs.bzl", "cc_library")
+load("//:build_defs.bzl", "flatbuffer_cc_library")
+
+package(default_visibility = ["//visibility:public"])
+
+cc_library(
+    name = "offset64_test",
+    testonly = 1,
+    srcs = ["offset64_test.cpp"],
+    hdrs = ["offset64_test.h"],
+    deps = [
+        ":test_64bit_cc_fbs",
+        "//tests:test_assert",
+        "//tests/64bit/evolution:v1_cc_fbs",
+        "//tests/64bit/evolution:v2_cc_fbs",
+    ],
+)
+
+flatbuffer_cc_library(
+    name = "test_64bit_cc_fbs",
+    srcs = ["test_64bit.fbs"],
+    filename_suffix = ".fbs",
+    flatc_args = [
+        "--gen-compare",
+        "--gen-mutable",
+        "--gen-object-api",
+        "--reflect-names",
+        "--filename-suffix .fbs",
+    ],
+)
--- a/tests/64bit/evolution/BUILD.bazel
+++ b/tests/64bit/evolution/BUILD.bazel
@@ -0,0 +1,29 @@
+load("//:build_defs.bzl", "flatbuffer_cc_library")
+
+package(default_visibility = ["//visibility:public"])
+
+flatbuffer_cc_library(
+    name = "v1_cc_fbs",
+    srcs = ["v1.fbs"],
+    filename_suffix = ".fbs",
+    flatc_args = [
+        "--gen-compare",
+        "--gen-mutable",
+        "--gen-object-api",
+        "--reflect-names",
+        "--filename-suffix .fbs",
+    ],
+)
+
+flatbuffer_cc_library(
+    name = "v2_cc_fbs",
+    srcs = ["v2.fbs"],
+    filename_suffix = ".fbs",
+    flatc_args = [
+        "--gen-compare",
+        "--gen-mutable",
+        "--gen-object-api",
+        "--reflect-names",
+        "--filename-suffix .fbs",
+    ],
+)
--- a/tests/64bit/evolution/v1_generated.h
+++ b/tests/64bit/evolution/v1_generated.h
@@ -1,222 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-
-#ifndef FLATBUFFERS_GENERATED_V1_V1_H_
-#define FLATBUFFERS_GENERATED_V1_V1_H_
-
-#include "flatbuffers/flatbuffers.h"
-
-// Ensure the included flatbuffers.h is the same version as when this file was
-// generated, otherwise it may not be compatible.
-static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
-              FLATBUFFERS_VERSION_MINOR == 12 &&
-              FLATBUFFERS_VERSION_REVISION == 19,
-             "Non-compatible flatbuffers version included");
-
-namespace v1 {
-
-struct RootTable;
-struct RootTableBuilder;
-struct RootTableT;
-
-bool operator==(const RootTableT &lhs, const RootTableT &rhs);
-bool operator!=(const RootTableT &lhs, const RootTableT &rhs);
-
-inline const ::flatbuffers::TypeTable *RootTableTypeTable();
-
-struct RootTableT : public ::flatbuffers::NativeTable {
-  typedef RootTable TableType;
-  float a = 0.0f;
-  std::vector<uint8_t> b{};
-};
-
-struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef RootTableT NativeTableType;
-  typedef RootTableBuilder Builder;
-  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
-    return RootTableTypeTable();
-  }
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_A = 4,
-    VT_B = 6
-  };
-  float a() const {
-    return GetField<float>(VT_A, 0.0f);
-  }
-  bool mutate_a(float _a = 0.0f) {
-    return SetField<float>(VT_A, _a, 0.0f);
-  }
-  const ::flatbuffers::Vector<uint8_t> *b() const {
-    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_B);
-  }
-  ::flatbuffers::Vector<uint8_t> *mutable_b() {
-    return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_B);
-  }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyField<float>(verifier, VT_A, 4) &&
-           VerifyOffset(verifier, VT_B) &&
-           verifier.VerifyVector(b()) &&
-           verifier.EndTable();
-  }
-  RootTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
-  void UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
-  static ::flatbuffers::Offset<RootTable> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
-};
-
-struct RootTableBuilder {
-  typedef RootTable Table;
-  ::flatbuffers::FlatBufferBuilder &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_a(float a) {
-    fbb_.AddElement<float>(RootTable::VT_A, a, 0.0f);
-  }
-  void add_b(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> b) {
-    fbb_.AddOffset(RootTable::VT_B, b);
-  }
-  explicit RootTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<RootTable> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<RootTable>(end);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<RootTable> CreateRootTable(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    float a = 0.0f,
-    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> b = 0) {
-  RootTableBuilder builder_(_fbb);
-  builder_.add_b(b);
-  builder_.add_a(a);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<RootTable> CreateRootTableDirect(
-    ::flatbuffers::FlatBufferBuilder &_fbb,
-    float a = 0.0f,
-    const std::vector<uint8_t> *b = nullptr) {
-  auto b__ = b ? _fbb.CreateVector<uint8_t>(*b) : 0;
-  return v1::CreateRootTable(
-      _fbb,
-      a,
-      b__);
-}
-
-::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
-
-
-inline bool operator==(const RootTableT &lhs, const RootTableT &rhs) {
-  return
-      (lhs.a == rhs.a) &&
-      (lhs.b == rhs.b);
-}
-
-inline bool operator!=(const RootTableT &lhs, const RootTableT &rhs) {
-    return !(lhs == rhs);
-}
-
-
-inline RootTableT *RootTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
-  auto _o = std::unique_ptr<RootTableT>(new RootTableT());
-  UnPackTo(_o.get(), _resolver);
-  return _o.release();
-}
-
-inline void RootTable::UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
-  (void)_o;
-  (void)_resolver;
-  { auto _e = a(); _o->a = _e; }
-  { auto _e = b(); if (_e) { _o->b.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->b.begin()); } }
-}
-
-inline ::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
-  return RootTable::Pack(_fbb, _o, _rehasher);
-}
-
-inline ::flatbuffers::Offset<RootTable> RootTable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
-  (void)_rehasher;
-  (void)_o;
-  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const RootTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
-  auto _a = _o->a;
-  auto _b = _o->b.size() ? _fbb.CreateVector(_o->b) : 0;
-  return v1::CreateRootTable(
-      _fbb,
-      _a,
-      _b);
-}
-
-inline const ::flatbuffers::TypeTable *RootTableTypeTable() {
-  static const ::flatbuffers::TypeCode type_codes[] = {
-    { ::flatbuffers::ET_FLOAT, 0, -1 },
-    { ::flatbuffers::ET_UCHAR, 1, -1 }
-  };
-  static const char * const names[] = {
-    "a",
-    "b"
-  };
-  static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
-  };
-  return &tt;
-}
-
-inline const v1::RootTable *GetRootTable(const void *buf) {
-  return ::flatbuffers::GetRoot<v1::RootTable>(buf);
-}
-
-inline const v1::RootTable *GetSizePrefixedRootTable(const void *buf) {
-  return ::flatbuffers::GetSizePrefixedRoot<v1::RootTable>(buf);
-}
-
-inline RootTable *GetMutableRootTable(void *buf) {
-  return ::flatbuffers::GetMutableRoot<RootTable>(buf);
-}
-
-inline v1::RootTable *GetMutableSizePrefixedRootTable(void *buf) {
-  return ::flatbuffers::GetMutableSizePrefixedRoot<v1::RootTable>(buf);
-}
-
-template <bool B = false>
-inline bool VerifyRootTableBuffer(
-    ::flatbuffers::VerifierTemplate<B> &verifier) {
-  return verifier.template VerifyBuffer<v1::RootTable>(nullptr);
-}
-
-template <bool B = false>
-inline bool VerifySizePrefixedRootTableBuffer(
-    ::flatbuffers::VerifierTemplate<B> &verifier) {
-  return verifier.template VerifySizePrefixedBuffer<v1::RootTable>(nullptr);
-}
-
-inline void FinishRootTableBuffer(
-    ::flatbuffers::FlatBufferBuilder &fbb,
-    ::flatbuffers::Offset<v1::RootTable> root) {
-  fbb.Finish(root);
-}
-
-inline void FinishSizePrefixedRootTableBuffer(
-    ::flatbuffers::FlatBufferBuilder &fbb,
-    ::flatbuffers::Offset<v1::RootTable> root) {
-  fbb.FinishSizePrefixed(root);
-}
-
-inline std::unique_ptr<v1::RootTableT> UnPackRootTable(
-    const void *buf,
-    const ::flatbuffers::resolver_function_t *res = nullptr) {
-  return std::unique_ptr<v1::RootTableT>(GetRootTable(buf)->UnPack(res));
-}
-
-inline std::unique_ptr<v1::RootTableT> UnPackSizePrefixedRootTable(
-    const void *buf,
-    const ::flatbuffers::resolver_function_t *res = nullptr) {
-  return std::unique_ptr<v1::RootTableT>(GetSizePrefixedRootTable(buf)->UnPack(res));
-}
-
-}  // namespace v1
-
-#endif  // FLATBUFFERS_GENERATED_V1_V1_H_
--- a/tests/64bit/evolution/v2_generated.h
+++ b/tests/64bit/evolution/v2_generated.h
@@ -1,246 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-
-#ifndef FLATBUFFERS_GENERATED_V2_V2_H_
-#define FLATBUFFERS_GENERATED_V2_V2_H_
-
-#include "flatbuffers/flatbuffers.h"
-
-// Ensure the included flatbuffers.h is the same version as when this file was
-// generated, otherwise it may not be compatible.
-static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
-              FLATBUFFERS_VERSION_MINOR == 12 &&
-              FLATBUFFERS_VERSION_REVISION == 19,
-             "Non-compatible flatbuffers version included");
-
-namespace v2 {
-
-struct RootTable;
-struct RootTableBuilder;
-struct RootTableT;
-
-bool operator==(const RootTableT &lhs, const RootTableT &rhs);
-bool operator!=(const RootTableT &lhs, const RootTableT &rhs);
-
-inline const ::flatbuffers::TypeTable *RootTableTypeTable();
-
-struct RootTableT : public ::flatbuffers::NativeTable {
-  typedef RootTable TableType;
-  float a = 0.0f;
-  std::vector<uint8_t> b{};
-  std::vector<uint8_t> big_vector{};
-};
-
-struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef RootTableT NativeTableType;
-  typedef RootTableBuilder Builder;
-  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
-    return RootTableTypeTable();
-  }
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_A = 4,
-    VT_B = 6,
-    VT_BIG_VECTOR = 8
-  };
-  float a() const {
-    return GetField<float>(VT_A, 0.0f);
-  }
-  bool mutate_a(float _a = 0.0f) {
-    return SetField<float>(VT_A, _a, 0.0f);
-  }
-  const ::flatbuffers::Vector<uint8_t> *b() const {
-    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_B);
-  }
-  ::flatbuffers::Vector<uint8_t> *mutable_b() {
-    return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_B);
-  }
-  const ::flatbuffers::Vector64<uint8_t> *big_vector() const {
-    return GetPointer64<const ::flatbuffers::Vector64<uint8_t> *>(VT_BIG_VECTOR);
-  }
-  ::flatbuffers::Vector64<uint8_t> *mutable_big_vector() {
-    return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_BIG_VECTOR);
-  }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyField<float>(verifier, VT_A, 4) &&
-           VerifyOffset(verifier, VT_B) &&
-           verifier.VerifyVector(b()) &&
-           VerifyOffset64(verifier, VT_BIG_VECTOR) &&
-           verifier.VerifyVector(big_vector()) &&
-           verifier.EndTable();
-  }
-  RootTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
-  void UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
-  static ::flatbuffers::Offset<RootTable> Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
-};
-
-struct RootTableBuilder {
-  typedef RootTable Table;
-  ::flatbuffers::FlatBufferBuilder64 &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_a(float a) {
-    fbb_.AddElement<float>(RootTable::VT_A, a, 0.0f);
-  }
-  void add_b(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> b) {
-    fbb_.AddOffset(RootTable::VT_B, b);
-  }
-  void add_big_vector(::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_vector) {
-    fbb_.AddOffset(RootTable::VT_BIG_VECTOR, big_vector);
-  }
-  explicit RootTableBuilder(::flatbuffers::FlatBufferBuilder64 &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<RootTable> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<RootTable>(end);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<RootTable> CreateRootTable(
-    ::flatbuffers::FlatBufferBuilder64 &_fbb,
-    float a = 0.0f,
-    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> b = 0,
-    ::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_vector = 0) {
-  RootTableBuilder builder_(_fbb);
-  builder_.add_big_vector(big_vector);
-  builder_.add_b(b);
-  builder_.add_a(a);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<RootTable> CreateRootTableDirect(
-    ::flatbuffers::FlatBufferBuilder64 &_fbb,
-    float a = 0.0f,
-    const std::vector<uint8_t> *b = nullptr,
-    const std::vector<uint8_t> *big_vector = nullptr) {
-  auto big_vector__ = big_vector ? _fbb.CreateVector64(*big_vector) : 0;
-  auto b__ = b ? _fbb.CreateVector<uint8_t>(*b) : 0;
-  return v2::CreateRootTable(
-      _fbb,
-      a,
-      b__,
-      big_vector__);
-}
-
-::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
-
-
-inline bool operator==(const RootTableT &lhs, const RootTableT &rhs) {
-  return
-      (lhs.a == rhs.a) &&
-      (lhs.b == rhs.b) &&
-      (lhs.big_vector == rhs.big_vector);
-}
-
-inline bool operator!=(const RootTableT &lhs, const RootTableT &rhs) {
-    return !(lhs == rhs);
-}
-
-
-inline RootTableT *RootTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
-  auto _o = std::unique_ptr<RootTableT>(new RootTableT());
-  UnPackTo(_o.get(), _resolver);
-  return _o.release();
-}
-
-inline void RootTable::UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
-  (void)_o;
-  (void)_resolver;
-  { auto _e = a(); _o->a = _e; }
-  { auto _e = b(); if (_e) { _o->b.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->b.begin()); } }
-  { auto _e = big_vector(); if (_e) { _o->big_vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->big_vector.begin()); } }
-}
-
-inline ::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
-  return RootTable::Pack(_fbb, _o, _rehasher);
-}
-
-inline ::flatbuffers::Offset<RootTable> RootTable::Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
-  (void)_rehasher;
-  (void)_o;
-  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder64 *__fbb; const RootTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
-  auto _a = _o->a;
-  auto _b = _o->b.size() ? _fbb.CreateVector(_o->b) : 0;
-  auto _big_vector = _o->big_vector.size() ? _fbb.CreateVector64(_o->big_vector) : 0;
-  return v2::CreateRootTable(
-      _fbb,
-      _a,
-      _b,
-      _big_vector);
-}
-
-inline const ::flatbuffers::TypeTable *RootTableTypeTable() {
-  static const ::flatbuffers::TypeCode type_codes[] = {
-    { ::flatbuffers::ET_FLOAT, 0, -1 },
-    { ::flatbuffers::ET_UCHAR, 1, -1 },
-    { ::flatbuffers::ET_UCHAR, 1, -1 }
-  };
-  static const char * const names[] = {
-    "a",
-    "b",
-    "big_vector"
-  };
-  static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names
-  };
-  return &tt;
-}
-
-inline const v2::RootTable *GetRootTable(const void *buf) {
-  return ::flatbuffers::GetRoot<v2::RootTable>(buf);
-}
-
-inline const v2::RootTable *GetSizePrefixedRootTable(const void *buf) {
-  return ::flatbuffers::GetSizePrefixedRoot<v2::RootTable,::flatbuffers::uoffset64_t>(buf);
-}
-
-inline RootTable *GetMutableRootTable(void *buf) {
-  return ::flatbuffers::GetMutableRoot<RootTable>(buf);
-}
-
-inline v2::RootTable *GetMutableSizePrefixedRootTable(void *buf) {
-  return ::flatbuffers::GetMutableSizePrefixedRoot<v2::RootTable,::flatbuffers::uoffset64_t>(buf);
-}
-
-template <bool B = false>
-inline bool VerifyRootTableBuffer(
-    ::flatbuffers::VerifierTemplate<B> &verifier) {
-  return verifier.template VerifyBuffer<v2::RootTable>(nullptr);
-}
-
-template <bool B = false>
-inline bool VerifySizePrefixedRootTableBuffer(
-    ::flatbuffers::VerifierTemplate<B> &verifier) {
-  return verifier.template VerifySizePrefixedBuffer<v2::RootTable,::flatbuffers::uoffset64_t>(nullptr);
-}
-
-inline void FinishRootTableBuffer(
-    ::flatbuffers::FlatBufferBuilder64 &fbb,
-    ::flatbuffers::Offset<v2::RootTable> root) {
-  fbb.Finish(root);
-}
-
-inline void FinishSizePrefixedRootTableBuffer(
-    ::flatbuffers::FlatBufferBuilder64 &fbb,
-    ::flatbuffers::Offset<v2::RootTable> root) {
-  fbb.FinishSizePrefixed(root);
-}
-
-inline std::unique_ptr<v2::RootTableT> UnPackRootTable(
-    const void *buf,
-    const ::flatbuffers::resolver_function_t *res = nullptr) {
-  return std::unique_ptr<v2::RootTableT>(GetRootTable(buf)->UnPack(res));
-}
-
-inline std::unique_ptr<v2::RootTableT> UnPackSizePrefixedRootTable(
-    const void *buf,
-    const ::flatbuffers::resolver_function_t *res = nullptr) {
-  return std::unique_ptr<v2::RootTableT>(GetSizePrefixedRootTable(buf)->UnPack(res));
-}
-
-}  // namespace v2
-
-#endif  // FLATBUFFERS_GENERATED_V2_V2_H_
--- a/tests/64bit/offset64_test.cpp
+++ b/tests/64bit/offset64_test.cpp
@@ -11,9 +11,9 @@
 #include "flatbuffers/buffer.h"
 #include "flatbuffers/flatbuffer_builder.h"
 #include "flatbuffers/flatbuffers.h"
-#include "tests/64bit/evolution/v1_generated.h"
-#include "tests/64bit/evolution/v2_generated.h"
-#include "tests/64bit/test_64bit_generated.h"
+#include "tests/64bit/evolution/v1.fbs.h"
+#include "tests/64bit/evolution/v2.fbs.h"
+#include "tests/64bit/test_64bit.fbs.h"
 #include "tests/test_assert.h"

 namespace flatbuffers {
--- a/tests/64bit/test_64bit_generated.h
+++ b/tests/64bit/test_64bit_generated.h
@@ -1,683 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-
-#ifndef FLATBUFFERS_GENERATED_TEST64BIT_H_
-#define FLATBUFFERS_GENERATED_TEST64BIT_H_
-
-#include "flatbuffers/flatbuffers.h"
-
-// Ensure the included flatbuffers.h is the same version as when this file was
-// generated, otherwise it may not be compatible.
-static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
-              FLATBUFFERS_VERSION_MINOR == 12 &&
-              FLATBUFFERS_VERSION_REVISION == 19,
-             "Non-compatible flatbuffers version included");
-
-// For access to the binary schema that produced this file.
-#include "test_64bit_bfbs_generated.h"
-
-struct LeafStruct;
-
-struct WrapperTable;
-struct WrapperTableBuilder;
-struct WrapperTableT;
-
-struct RootTable;
-struct RootTableBuilder;
-struct RootTableT;
-
-bool operator==(const LeafStruct &lhs, const LeafStruct &rhs);
-bool operator!=(const LeafStruct &lhs, const LeafStruct &rhs);
-bool operator==(const WrapperTableT &lhs, const WrapperTableT &rhs);
-bool operator!=(const WrapperTableT &lhs, const WrapperTableT &rhs);
-bool operator==(const RootTableT &lhs, const RootTableT &rhs);
-bool operator!=(const RootTableT &lhs, const RootTableT &rhs);
-
-inline const ::flatbuffers::TypeTable *LeafStructTypeTable();
-
-inline const ::flatbuffers::TypeTable *WrapperTableTypeTable();
-
-inline const ::flatbuffers::TypeTable *RootTableTypeTable();
-
-FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) LeafStruct FLATBUFFERS_FINAL_CLASS {
- private:
-  int32_t a_;
-  int32_t padding0__;
-  double b_;
-
- public:
-  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
-    return LeafStructTypeTable();
-  }
-  LeafStruct()
-      : a_(0),
-        padding0__(0),
-        b_(0) {
-    (void)padding0__;
-  }
-  LeafStruct(int32_t _a, double _b)
-      : a_(::flatbuffers::EndianScalar(_a)),
-        padding0__(0),
-        b_(::flatbuffers::EndianScalar(_b)) {
-    (void)padding0__;
-  }
-  int32_t a() const {
-    return ::flatbuffers::EndianScalar(a_);
-  }
-  void mutate_a(int32_t _a) {
-    ::flatbuffers::WriteScalar(&a_, _a);
-  }
-  double b() const {
-    return ::flatbuffers::EndianScalar(b_);
-  }
-  void mutate_b(double _b) {
-    ::flatbuffers::WriteScalar(&b_, _b);
-  }
-};
-FLATBUFFERS_STRUCT_END(LeafStruct, 16);
-
-inline bool operator==(const LeafStruct &lhs, const LeafStruct &rhs) {
-  return
-      (lhs.a() == rhs.a()) &&
-      (lhs.b() == rhs.b());
-}
-
-inline bool operator!=(const LeafStruct &lhs, const LeafStruct &rhs) {
-    return !(lhs == rhs);
-}
-
-
-struct WrapperTableT : public ::flatbuffers::NativeTable {
-  typedef WrapperTable TableType;
-  std::vector<int8_t> vector{};
-};
-
-struct WrapperTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef WrapperTableT NativeTableType;
-  typedef WrapperTableBuilder Builder;
-  typedef RootTableBinarySchema BinarySchema;
-  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
-    return WrapperTableTypeTable();
-  }
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_VECTOR = 4
-  };
-  const ::flatbuffers::Vector<int8_t> *vector() const {
-    return GetPointer64<const ::flatbuffers::Vector<int8_t> *>(VT_VECTOR);
-  }
-  ::flatbuffers::Vector<int8_t> *mutable_vector() {
-    return GetPointer64<::flatbuffers::Vector<int8_t> *>(VT_VECTOR);
-  }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffset64(verifier, VT_VECTOR) &&
-           verifier.VerifyVector(vector()) &&
-           verifier.EndTable();
-  }
-  WrapperTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
-  void UnPackTo(WrapperTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
-  static ::flatbuffers::Offset<WrapperTable> Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const WrapperTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
-};
-
-struct WrapperTableBuilder {
-  typedef WrapperTable Table;
-  ::flatbuffers::FlatBufferBuilder64 &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_vector(::flatbuffers::Offset64<::flatbuffers::Vector<int8_t>> vector) {
-    fbb_.AddOffset(WrapperTable::VT_VECTOR, vector);
-  }
-  explicit WrapperTableBuilder(::flatbuffers::FlatBufferBuilder64 &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<WrapperTable> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<WrapperTable>(end);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<WrapperTable> CreateWrapperTable(
-    ::flatbuffers::FlatBufferBuilder64 &_fbb,
-    ::flatbuffers::Offset64<::flatbuffers::Vector<int8_t>> vector = 0) {
-  WrapperTableBuilder builder_(_fbb);
-  builder_.add_vector(vector);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<WrapperTable> CreateWrapperTableDirect(
-    ::flatbuffers::FlatBufferBuilder64 &_fbb,
-    const std::vector<int8_t> *vector = nullptr) {
-  auto vector__ = vector ? _fbb.CreateVector64<::flatbuffers::Vector>(*vector) : 0;
-  return CreateWrapperTable(
-      _fbb,
-      vector__);
-}
-
-::flatbuffers::Offset<WrapperTable> CreateWrapperTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const WrapperTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
-
-struct RootTableT : public ::flatbuffers::NativeTable {
-  typedef RootTable TableType;
-  std::vector<uint8_t> far_vector{};
-  int32_t a = 0;
-  std::string far_string{};
-  std::vector<uint8_t> big_bool_vector{};
-  std::vector<uint8_t> big_vector{};
-  std::string near_string{};
-  std::vector<uint8_t> nested_root{};
-  std::vector<LeafStruct> far_struct_vector{};
-  std::vector<LeafStruct> big_struct_vector{};
-  std::vector<std::unique_ptr<WrapperTableT>> many_vectors{};
-  std::vector<uint8_t> forced_aligned_vector{};
-  RootTableT() = default;
-  RootTableT(const RootTableT &o);
-  RootTableT(RootTableT&&) FLATBUFFERS_NOEXCEPT = default;
-  RootTableT &operator=(RootTableT o) FLATBUFFERS_NOEXCEPT;
-};
-
-struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
-  typedef RootTableT NativeTableType;
-  typedef RootTableBuilder Builder;
-  typedef RootTableBinarySchema BinarySchema;
-  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
-    return RootTableTypeTable();
-  }
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
-    VT_FAR_VECTOR = 4,
-    VT_A = 6,
-    VT_FAR_STRING = 8,
-    VT_BIG_BOOL_VECTOR = 10,
-    VT_BIG_VECTOR = 12,
-    VT_NEAR_STRING = 14,
-    VT_NESTED_ROOT = 16,
-    VT_FAR_STRUCT_VECTOR = 18,
-    VT_BIG_STRUCT_VECTOR = 20,
-    VT_MANY_VECTORS = 22,
-    VT_FORCED_ALIGNED_VECTOR = 24
-  };
-  const ::flatbuffers::Vector<uint8_t> *far_vector() const {
-    return GetPointer64<const ::flatbuffers::Vector<uint8_t> *>(VT_FAR_VECTOR);
-  }
-  ::flatbuffers::Vector<uint8_t> *mutable_far_vector() {
-    return GetPointer64<::flatbuffers::Vector<uint8_t> *>(VT_FAR_VECTOR);
-  }
-  int32_t a() const {
-    return GetField<int32_t>(VT_A, 0);
-  }
-  bool mutate_a(int32_t _a = 0) {
-    return SetField<int32_t>(VT_A, _a, 0);
-  }
-  const ::flatbuffers::String *far_string() const {
-    return GetPointer64<const ::flatbuffers::String *>(VT_FAR_STRING);
-  }
-  ::flatbuffers::String *mutable_far_string() {
-    return GetPointer64<::flatbuffers::String *>(VT_FAR_STRING);
-  }
-  const ::flatbuffers::Vector64<uint8_t> *big_bool_vector() const {
-    return GetPointer64<const ::flatbuffers::Vector64<uint8_t> *>(VT_BIG_BOOL_VECTOR);
-  }
-  ::flatbuffers::Vector64<uint8_t> *mutable_big_bool_vector() {
-    return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_BIG_BOOL_VECTOR);
-  }
-  const ::flatbuffers::Vector64<uint8_t> *big_vector() const {
-    return GetPointer64<const ::flatbuffers::Vector64<uint8_t> *>(VT_BIG_VECTOR);
-  }
-  ::flatbuffers::Vector64<uint8_t> *mutable_big_vector() {
-    return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_BIG_VECTOR);
-  }
-  const ::flatbuffers::String *near_string() const {
-    return GetPointer<const ::flatbuffers::String *>(VT_NEAR_STRING);
-  }
-  ::flatbuffers::String *mutable_near_string() {
-    return GetPointer<::flatbuffers::String *>(VT_NEAR_STRING);
-  }
-  const ::flatbuffers::Vector64<uint8_t> *nested_root() const {
-    return GetPointer64<const ::flatbuffers::Vector64<uint8_t> *>(VT_NESTED_ROOT);
-  }
-  ::flatbuffers::Vector64<uint8_t> *mutable_nested_root() {
-    return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_NESTED_ROOT);
-  }
-  const RootTable *nested_root_nested_root() const {
-    const auto _f = nested_root();
-    return _f ? ::flatbuffers::GetRoot<RootTable>(_f->Data())
-              : nullptr;
-  }
-  const ::flatbuffers::Vector<const LeafStruct *> *far_struct_vector() const {
-    return GetPointer64<const ::flatbuffers::Vector<const LeafStruct *> *>(VT_FAR_STRUCT_VECTOR);
-  }
-  ::flatbuffers::Vector<const LeafStruct *> *mutable_far_struct_vector() {
-    return GetPointer64<::flatbuffers::Vector<const LeafStruct *> *>(VT_FAR_STRUCT_VECTOR);
-  }
-  const ::flatbuffers::Vector64<const LeafStruct *> *big_struct_vector() const {
-    return GetPointer64<const ::flatbuffers::Vector64<const LeafStruct *> *>(VT_BIG_STRUCT_VECTOR);
-  }
-  ::flatbuffers::Vector64<const LeafStruct *> *mutable_big_struct_vector() {
-    return GetPointer64<::flatbuffers::Vector64<const LeafStruct *> *>(VT_BIG_STRUCT_VECTOR);
-  }
-  const ::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>> *many_vectors() const {
-    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>> *>(VT_MANY_VECTORS);
-  }
-  ::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>> *mutable_many_vectors() {
-    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>> *>(VT_MANY_VECTORS);
-  }
-  const ::flatbuffers::Vector64<uint8_t> *forced_aligned_vector() const {
-    return GetPointer64<const ::flatbuffers::Vector64<uint8_t> *>(VT_FORCED_ALIGNED_VECTOR);
-  }
-  ::flatbuffers::Vector64<uint8_t> *mutable_forced_aligned_vector() {
-    return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_FORCED_ALIGNED_VECTOR);
-  }
-  template <bool B = false>
-  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
-    return VerifyTableStart(verifier) &&
-           VerifyOffset64(verifier, VT_FAR_VECTOR) &&
-           verifier.VerifyVector(far_vector()) &&
-           VerifyField<int32_t>(verifier, VT_A, 4) &&
-           VerifyOffset64(verifier, VT_FAR_STRING) &&
-           verifier.VerifyString(far_string()) &&
-           VerifyOffset64(verifier, VT_BIG_BOOL_VECTOR) &&
-           verifier.VerifyVector(big_bool_vector()) &&
-           VerifyOffset64(verifier, VT_BIG_VECTOR) &&
-           verifier.VerifyVector(big_vector()) &&
-           VerifyOffset(verifier, VT_NEAR_STRING) &&
-           verifier.VerifyString(near_string()) &&
-           VerifyOffset64(verifier, VT_NESTED_ROOT) &&
-           verifier.VerifyVector(nested_root()) &&
-           verifier.template VerifyNestedFlatBuffer<RootTable>(nested_root(), nullptr) &&
-           VerifyOffset64(verifier, VT_FAR_STRUCT_VECTOR) &&
-           verifier.VerifyVector(far_struct_vector()) &&
-           VerifyOffset64(verifier, VT_BIG_STRUCT_VECTOR) &&
-           verifier.VerifyVector(big_struct_vector()) &&
-           VerifyOffset(verifier, VT_MANY_VECTORS) &&
-           verifier.VerifyVector(many_vectors()) &&
-           verifier.VerifyVectorOfTables(many_vectors()) &&
-           VerifyOffset64(verifier, VT_FORCED_ALIGNED_VECTOR) &&
-           verifier.VerifyVector(forced_aligned_vector()) &&
-           verifier.EndTable();
-  }
-  RootTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
-  void UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
-  static ::flatbuffers::Offset<RootTable> Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
-};
-
-struct RootTableBuilder {
-  typedef RootTable Table;
-  ::flatbuffers::FlatBufferBuilder64 &fbb_;
-  ::flatbuffers::uoffset_t start_;
-  void add_far_vector(::flatbuffers::Offset64<::flatbuffers::Vector<uint8_t>> far_vector) {
-    fbb_.AddOffset(RootTable::VT_FAR_VECTOR, far_vector);
-  }
-  void add_a(int32_t a) {
-    fbb_.AddElement<int32_t>(RootTable::VT_A, a, 0);
-  }
-  void add_far_string(::flatbuffers::Offset64<::flatbuffers::String> far_string) {
-    fbb_.AddOffset(RootTable::VT_FAR_STRING, far_string);
-  }
-  void add_big_bool_vector(::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_bool_vector) {
-    fbb_.AddOffset(RootTable::VT_BIG_BOOL_VECTOR, big_bool_vector);
-  }
-  void add_big_vector(::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_vector) {
-    fbb_.AddOffset(RootTable::VT_BIG_VECTOR, big_vector);
-  }
-  void add_near_string(::flatbuffers::Offset<::flatbuffers::String> near_string) {
-    fbb_.AddOffset(RootTable::VT_NEAR_STRING, near_string);
-  }
-  void add_nested_root(::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> nested_root) {
-    fbb_.AddOffset(RootTable::VT_NESTED_ROOT, nested_root);
-  }
-  void add_far_struct_vector(::flatbuffers::Offset64<::flatbuffers::Vector<const LeafStruct *>> far_struct_vector) {
-    fbb_.AddOffset(RootTable::VT_FAR_STRUCT_VECTOR, far_struct_vector);
-  }
-  void add_big_struct_vector(::flatbuffers::Offset64<::flatbuffers::Vector64<const LeafStruct *>> big_struct_vector) {
-    fbb_.AddOffset(RootTable::VT_BIG_STRUCT_VECTOR, big_struct_vector);
-  }
-  void add_many_vectors(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>>> many_vectors) {
-    fbb_.AddOffset(RootTable::VT_MANY_VECTORS, many_vectors);
-  }
-  void add_forced_aligned_vector(::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> forced_aligned_vector) {
-    fbb_.AddOffset(RootTable::VT_FORCED_ALIGNED_VECTOR, forced_aligned_vector);
-  }
-  explicit RootTableBuilder(::flatbuffers::FlatBufferBuilder64 &_fbb)
-        : fbb_(_fbb) {
-    start_ = fbb_.StartTable();
-  }
-  ::flatbuffers::Offset<RootTable> Finish() {
-    const auto end = fbb_.EndTable(start_);
-    auto o = ::flatbuffers::Offset<RootTable>(end);
-    return o;
-  }
-};
-
-inline ::flatbuffers::Offset<RootTable> CreateRootTable(
-    ::flatbuffers::FlatBufferBuilder64 &_fbb,
-    ::flatbuffers::Offset64<::flatbuffers::Vector<uint8_t>> far_vector = 0,
-    int32_t a = 0,
-    ::flatbuffers::Offset64<::flatbuffers::String> far_string = 0,
-    ::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_bool_vector = 0,
-    ::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_vector = 0,
-    ::flatbuffers::Offset<::flatbuffers::String> near_string = 0,
-    ::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> nested_root = 0,
-    ::flatbuffers::Offset64<::flatbuffers::Vector<const LeafStruct *>> far_struct_vector = 0,
-    ::flatbuffers::Offset64<::flatbuffers::Vector64<const LeafStruct *>> big_struct_vector = 0,
-    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>>> many_vectors = 0,
-    ::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> forced_aligned_vector = 0) {
-  RootTableBuilder builder_(_fbb);
-  builder_.add_forced_aligned_vector(forced_aligned_vector);
-  builder_.add_big_struct_vector(big_struct_vector);
-  builder_.add_nested_root(nested_root);
-  builder_.add_big_vector(big_vector);
-  builder_.add_big_bool_vector(big_bool_vector);
-  builder_.add_many_vectors(many_vectors);
-  builder_.add_far_struct_vector(far_struct_vector);
-  builder_.add_near_string(near_string);
-  builder_.add_far_string(far_string);
-  builder_.add_a(a);
-  builder_.add_far_vector(far_vector);
-  return builder_.Finish();
-}
-
-inline ::flatbuffers::Offset<RootTable> CreateRootTableDirect(
-    ::flatbuffers::FlatBufferBuilder64 &_fbb,
-    const std::vector<uint8_t> *far_vector = nullptr,
-    int32_t a = 0,
-    const char *far_string = nullptr,
-    const std::vector<uint8_t> *big_bool_vector = nullptr,
-    const std::vector<uint8_t> *big_vector = nullptr,
-    const char *near_string = nullptr,
-    const std::vector<uint8_t> *nested_root = nullptr,
-    const std::vector<LeafStruct> *far_struct_vector = nullptr,
-    const std::vector<LeafStruct> *big_struct_vector = nullptr,
-    const std::vector<::flatbuffers::Offset<WrapperTable>> *many_vectors = nullptr,
-    const std::vector<uint8_t> *forced_aligned_vector = nullptr) {
-  auto far_vector__ = far_vector ? _fbb.CreateVector64<::flatbuffers::Vector>(*far_vector) : 0;
-  auto far_string__ = far_string ? _fbb.CreateString<::flatbuffers::Offset64>(far_string) : 0;
-  auto big_bool_vector__ = big_bool_vector ? _fbb.CreateVector64(*big_bool_vector) : 0;
-  auto big_vector__ = big_vector ? _fbb.CreateVector64(*big_vector) : 0;
-  auto nested_root__ = nested_root ? _fbb.CreateVector64(*nested_root) : 0;
-  auto far_struct_vector__ = far_struct_vector ? _fbb.CreateVectorOfStructs64<::flatbuffers::Vector>(*far_struct_vector) : 0;
-  auto big_struct_vector__ = big_struct_vector ? _fbb.CreateVectorOfStructs64(*big_struct_vector) : 0;
-  if (forced_aligned_vector) { _fbb.ForceVectorAlignment64(forced_aligned_vector->size(), sizeof(uint8_t), 32); }
-  auto forced_aligned_vector__ = forced_aligned_vector ? _fbb.CreateVector64(*forced_aligned_vector) : 0;
-  auto near_string__ = near_string ? _fbb.CreateString(near_string) : 0;
-  auto many_vectors__ = many_vectors ? _fbb.CreateVector<::flatbuffers::Offset<WrapperTable>>(*many_vectors) : 0;
-  return CreateRootTable(
-      _fbb,
-      far_vector__,
-      a,
-      far_string__,
-      big_bool_vector__,
-      big_vector__,
-      near_string__,
-      nested_root__,
-      far_struct_vector__,
-      big_struct_vector__,
-      many_vectors__,
-      forced_aligned_vector__);
-}
-
-::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
-
-
-inline bool operator==(const WrapperTableT &lhs, const WrapperTableT &rhs) {
-  return
-      (lhs.vector == rhs.vector);
-}
-
-inline bool operator!=(const WrapperTableT &lhs, const WrapperTableT &rhs) {
-    return !(lhs == rhs);
-}
-
-
-inline WrapperTableT *WrapperTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
-  auto _o = std::unique_ptr<WrapperTableT>(new WrapperTableT());
-  UnPackTo(_o.get(), _resolver);
-  return _o.release();
-}
-
-inline void WrapperTable::UnPackTo(WrapperTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
-  (void)_o;
-  (void)_resolver;
-  { auto _e = vector(); if (_e) { _o->vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->vector.begin()); } }
-}
-
-inline ::flatbuffers::Offset<WrapperTable> CreateWrapperTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const WrapperTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
-  return WrapperTable::Pack(_fbb, _o, _rehasher);
-}
-
-inline ::flatbuffers::Offset<WrapperTable> WrapperTable::Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const WrapperTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
-  (void)_rehasher;
-  (void)_o;
-  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder64 *__fbb; const WrapperTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
-  auto _vector = _o->vector.size() ? _fbb.CreateVector64<::flatbuffers::Vector>(_o->vector) : 0;
-  return CreateWrapperTable(
-      _fbb,
-      _vector);
-}
-
-
-inline bool operator==(const RootTableT &lhs, const RootTableT &rhs) {
-  return
-      (lhs.far_vector == rhs.far_vector) &&
-      (lhs.a == rhs.a) &&
-      (lhs.far_string == rhs.far_string) &&
-      (lhs.big_bool_vector == rhs.big_bool_vector) &&
-      (lhs.big_vector == rhs.big_vector) &&
-      (lhs.near_string == rhs.near_string) &&
-      (lhs.nested_root == rhs.nested_root) &&
-      (lhs.far_struct_vector == rhs.far_struct_vector) &&
-      (lhs.big_struct_vector == rhs.big_struct_vector) &&
-      (lhs.many_vectors.size() == rhs.many_vectors.size() && std::equal(lhs.many_vectors.cbegin(), lhs.many_vectors.cend(), rhs.many_vectors.cbegin(), [](std::unique_ptr<WrapperTableT> const &a, std::unique_ptr<WrapperTableT> const &b) { return (a == b) || (a && b && *a == *b); })) &&
-      (lhs.forced_aligned_vector == rhs.forced_aligned_vector);
-}
-
-inline bool operator!=(const RootTableT &lhs, const RootTableT &rhs) {
-    return !(lhs == rhs);
-}
-
-
-inline RootTableT::RootTableT(const RootTableT &o)
-      : far_vector(o.far_vector),
-        a(o.a),
-        far_string(o.far_string),
-        big_bool_vector(o.big_bool_vector),
-        big_vector(o.big_vector),
-        near_string(o.near_string),
-        nested_root(o.nested_root),
-        far_struct_vector(o.far_struct_vector),
-        big_struct_vector(o.big_struct_vector),
-        forced_aligned_vector(o.forced_aligned_vector) {
-  many_vectors.reserve(o.many_vectors.size());
-  for (const auto &many_vectors_ : o.many_vectors) { many_vectors.emplace_back((many_vectors_) ? new WrapperTableT(*many_vectors_) : nullptr); }
-}
-
-inline RootTableT &RootTableT::operator=(RootTableT o) FLATBUFFERS_NOEXCEPT {
-  std::swap(far_vector, o.far_vector);
-  std::swap(a, o.a);
-  std::swap(far_string, o.far_string);
-  std::swap(big_bool_vector, o.big_bool_vector);
-  std::swap(big_vector, o.big_vector);
-  std::swap(near_string, o.near_string);
-  std::swap(nested_root, o.nested_root);
-  std::swap(far_struct_vector, o.far_struct_vector);
-  std::swap(big_struct_vector, o.big_struct_vector);
-  std::swap(many_vectors, o.many_vectors);
-  std::swap(forced_aligned_vector, o.forced_aligned_vector);
-  return *this;
-}
-
-inline RootTableT *RootTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
-  auto _o = std::unique_ptr<RootTableT>(new RootTableT());
-  UnPackTo(_o.get(), _resolver);
-  return _o.release();
-}
-
-inline void RootTable::UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
-  (void)_o;
-  (void)_resolver;
-  { auto _e = far_vector(); if (_e) { _o->far_vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->far_vector.begin()); } }
-  { auto _e = a(); _o->a = _e; }
-  { auto _e = far_string(); if (_e) _o->far_string = _e->str(); }
-  { auto _e = big_bool_vector(); if (_e) { _o->big_bool_vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->big_bool_vector.begin()); } }
-  { auto _e = big_vector(); if (_e) { _o->big_vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->big_vector.begin()); } }
-  { auto _e = near_string(); if (_e) _o->near_string = _e->str(); }
-  { auto _e = nested_root(); if (_e) { _o->nested_root.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->nested_root.begin()); } }
-  { auto _e = far_struct_vector(); if (_e) { _o->far_struct_vector.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->far_struct_vector[_i] = *_e->Get(_i); } } else { _o->far_struct_vector.resize(0); } }
-  { auto _e = big_struct_vector(); if (_e) { _o->big_struct_vector.resize(_e->size()); for (::flatbuffers::uoffset64_t _i = 0; _i < _e->size(); _i++) { _o->big_struct_vector[_i] = *_e->Get(_i); } } else { _o->big_struct_vector.resize(0); } }
-  { auto _e = many_vectors(); if (_e) { _o->many_vectors.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->many_vectors[_i]) { _e->Get(_i)->UnPackTo(_o->many_vectors[_i].get(), _resolver); } else { _o->many_vectors[_i] = std::unique_ptr<WrapperTableT>(_e->Get(_i)->UnPack(_resolver)); } } } else { _o->many_vectors.resize(0); } }
-  { auto _e = forced_aligned_vector(); if (_e) { _o->forced_aligned_vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->forced_aligned_vector.begin()); } }
-}
-
-inline ::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
-  return RootTable::Pack(_fbb, _o, _rehasher);
-}
-
-inline ::flatbuffers::Offset<RootTable> RootTable::Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
-  (void)_rehasher;
-  (void)_o;
-  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder64 *__fbb; const RootTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
-  auto _far_vector = _o->far_vector.size() ? _fbb.CreateVector64<::flatbuffers::Vector>(_o->far_vector) : 0;
-  auto _a = _o->a;
-  auto _far_string = _o->far_string.empty() ? 0 : _fbb.CreateString<::flatbuffers::Offset64>(_o->far_string);
-  auto _big_bool_vector = _o->big_bool_vector.size() ? _fbb.CreateVector64(_o->big_bool_vector) : 0;
-  auto _big_vector = _o->big_vector.size() ? _fbb.CreateVector64(_o->big_vector) : 0;
-  auto _near_string = _o->near_string.empty() ? 0 : _fbb.CreateString(_o->near_string);
-  auto _nested_root = _o->nested_root.size() ? _fbb.CreateVector64(_o->nested_root) : 0;
-  auto _far_struct_vector = _o->far_struct_vector.size() ? _fbb.CreateVectorOfStructs64<::flatbuffers::Vector>(_o->far_struct_vector) : 0;
-  auto _big_struct_vector = _o->big_struct_vector.size() ? _fbb.CreateVectorOfStructs64(_o->big_struct_vector) : 0;
-  auto _many_vectors = _o->many_vectors.size() ? _fbb.CreateVector<::flatbuffers::Offset<WrapperTable>> (_o->many_vectors.size(), [](size_t i, _VectorArgs *__va) { return CreateWrapperTable(*__va->__fbb, __va->__o->many_vectors[i].get(), __va->__rehasher); }, &_va ) : 0;
-  _fbb.ForceVectorAlignment64(_o->forced_aligned_vector.size(), sizeof(uint8_t), 32);
-  auto _forced_aligned_vector = _o->forced_aligned_vector.size() ? _fbb.CreateVector64(_o->forced_aligned_vector) : 0;
-  return CreateRootTable(
-      _fbb,
-      _far_vector,
-      _a,
-      _far_string,
-      _big_bool_vector,
-      _big_vector,
-      _near_string,
-      _nested_root,
-      _far_struct_vector,
-      _big_struct_vector,
-      _many_vectors,
-      _forced_aligned_vector);
-}
-
-inline const ::flatbuffers::TypeTable *LeafStructTypeTable() {
-  static const ::flatbuffers::TypeCode type_codes[] = {
-    { ::flatbuffers::ET_INT, 0, -1 },
-    { ::flatbuffers::ET_DOUBLE, 0, -1 }
-  };
-  static const int64_t values[] = { 0, 8, 16 };
-  static const char * const names[] = {
-    "a",
-    "b"
-  };
-  static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names
-  };
-  return &tt;
-}
-
-inline const ::flatbuffers::TypeTable *WrapperTableTypeTable() {
-  static const ::flatbuffers::TypeCode type_codes[] = {
-    { ::flatbuffers::ET_CHAR, 1, -1 }
-  };
-  static const char * const names[] = {
-    "vector"
-  };
-  static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
-  };
-  return &tt;
-}
-
-inline const ::flatbuffers::TypeTable *RootTableTypeTable() {
-  static const ::flatbuffers::TypeCode type_codes[] = {
-    { ::flatbuffers::ET_UCHAR, 1, -1 },
-    { ::flatbuffers::ET_INT, 0, -1 },
-    { ::flatbuffers::ET_STRING, 0, -1 },
-    { ::flatbuffers::ET_UCHAR, 1, -1 },
-    { ::flatbuffers::ET_UCHAR, 1, -1 },
-    { ::flatbuffers::ET_STRING, 0, -1 },
-    { ::flatbuffers::ET_UCHAR, 1, -1 },
-    { ::flatbuffers::ET_SEQUENCE, 1, 0 },
-    { ::flatbuffers::ET_SEQUENCE, 1, 0 },
-    { ::flatbuffers::ET_SEQUENCE, 1, 1 },
-    { ::flatbuffers::ET_UCHAR, 1, -1 }
-  };
-  static const ::flatbuffers::TypeFunction type_refs[] = {
-    LeafStructTypeTable,
-    WrapperTableTypeTable
-  };
-  static const char * const names[] = {
-    "far_vector",
-    "a",
-    "far_string",
-    "big_bool_vector",
-    "big_vector",
-    "near_string",
-    "nested_root",
-    "far_struct_vector",
-    "big_struct_vector",
-    "many_vectors",
-    "forced_aligned_vector"
-  };
-  static const ::flatbuffers::TypeTable tt = {
-    ::flatbuffers::ST_TABLE, 11, type_codes, type_refs, nullptr, nullptr, names
-  };
-  return &tt;
-}
-
-inline const RootTable *GetRootTable(const void *buf) {
-  return ::flatbuffers::GetRoot<RootTable>(buf);
-}
-
-inline const RootTable *GetSizePrefixedRootTable(const void *buf) {
-  return ::flatbuffers::GetSizePrefixedRoot<RootTable,::flatbuffers::uoffset64_t>(buf);
-}
-
-inline RootTable *GetMutableRootTable(void *buf) {
-  return ::flatbuffers::GetMutableRoot<RootTable>(buf);
-}
-
-inline RootTable *GetMutableSizePrefixedRootTable(void *buf) {
-  return ::flatbuffers::GetMutableSizePrefixedRoot<RootTable,::flatbuffers::uoffset64_t>(buf);
-}
-
-template <bool B = false>
-inline bool VerifyRootTableBuffer(
-    ::flatbuffers::VerifierTemplate<B> &verifier) {
-  return verifier.template VerifyBuffer<RootTable>(nullptr);
-}
-
-template <bool B = false>
-inline bool VerifySizePrefixedRootTableBuffer(
-    ::flatbuffers::VerifierTemplate<B> &verifier) {
-  return verifier.template VerifySizePrefixedBuffer<RootTable,::flatbuffers::uoffset64_t>(nullptr);
-}
-
-inline void FinishRootTableBuffer(
-    ::flatbuffers::FlatBufferBuilder64 &fbb,
-    ::flatbuffers::Offset<RootTable> root) {
-  fbb.Finish(root);
-}
-
-inline void FinishSizePrefixedRootTableBuffer(
-    ::flatbuffers::FlatBufferBuilder64 &fbb,
-    ::flatbuffers::Offset<RootTable> root) {
-  fbb.FinishSizePrefixed(root);
-}
-
-inline std::unique_ptr<RootTableT> UnPackRootTable(
-    const void *buf,
-    const ::flatbuffers::resolver_function_t *res = nullptr) {
-  return std::unique_ptr<RootTableT>(GetRootTable(buf)->UnPack(res));
-}
-
-inline std::unique_ptr<RootTableT> UnPackSizePrefixedRootTable(
-    const void *buf,
-    const ::flatbuffers::resolver_function_t *res = nullptr) {
-  return std::unique_ptr<RootTableT>(GetSizePrefixedRootTable(buf)->UnPack(res));
-}
-
-#endif  // FLATBUFFERS_GENERATED_TEST64BIT_H_
--- a/tests/BUILD.bazel
+++ b/tests/BUILD.bazel
@@ -24,21 +24,12 @@ cc_test(
    name = "flatbuffers_test",
    testonly = 1,
    srcs = [
-        "64bit/evolution/v1_generated.h",
-        "64bit/evolution/v2_generated.h",
-        "64bit/offset64_test.cpp",
-        "64bit/offset64_test.h",
-        "64bit/test_64bit_bfbs_generated.h",
-        "64bit/test_64bit_generated.h",
        "alignment_test.cpp",
        "alignment_test.h",
-        "alignment_test_generated.h",
        "default_vectors_strings_test.cpp",
        "default_vectors_strings_test.h",
        "evolution_test.cpp",
        "evolution_test.h",
-        "evolution_test/evolution_v1_generated.h",
-        "evolution_test/evolution_v2_generated.h",
        "flexbuffers_test.cpp",
        "flexbuffers_test.h",
        "fuzz_test.cpp",
@@ -46,19 +37,13 @@ cc_test(
        "is_quiet_nan.h",
        "json_test.cpp",
        "json_test.h",
-        "key_field/key_field_sample_generated.h",
        "key_field_test.cpp",
        "key_field_test.h",
        "monster_test.cpp",
        "monster_test.h",
        "monster_test_bfbs_generated.h",
-        "cross_namespace_pack_test_generated.h",
-        "namespace_test/namespace_test1_generated.h",
-        "namespace_test/namespace_test2_generated.h",
-        "native_inline_table_test_generated.h",
        "native_type_test_impl.cpp",
        "native_type_test_impl.h",
-        "optional_scalars_generated.h",
        "optional_scalars_test.cpp",
        "optional_scalars_test.h",
        "parser_test.cpp",
@@ -72,13 +57,10 @@ cc_test(
        "test_assert.h",
        "test_builder.cpp",
        "test_builder.h",
-        "union_underlying_type_test_generated.h",
-        "union_vector/union_vector_generated.h",
        "util_test.cpp",
        "util_test.h",
-        "vector_table_naked_ptr/vector_table_naked_ptr_generated.h",
-        "vector_table_naked_ptr_test.h",
        "vector_table_naked_ptr_test.cpp",
+        "vector_table_naked_ptr_test.h",
    ],
    copts = [
        "-DFLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE",
@@ -88,13 +70,8 @@ cc_test(
        ":arrays_test.bfbs",
        ":arrays_test.fbs",
        ":arrays_test.golden",
-        ":evolution_test/evolution_v1.fbs",
-        ":evolution_test/evolution_v1.json",
-        ":evolution_test/evolution_v2.fbs",
-        ":evolution_test/evolution_v2.json",
        ":include_test/include_test1.fbs",
        ":include_test/sub/include_test2.fbs",
-        ":key_field/key_field_sample.fbs",
        ":monster_extra.fbs",
        ":monster_test.bfbs",
        ":monster_test.fbs",
@@ -105,7 +82,6 @@ cc_test(
        ":name_clash_test/invalid_test2.fbs",
        ":name_clash_test/valid_test1.fbs",
        ":name_clash_test/valid_test2.fbs",
-        ":native_type_test.fbs",
        ":optional_scalars.fbs",
        ":optional_scalars.json",
        ":optional_scalars_defaults.json",
@@ -127,8 +103,8 @@ cc_test(
        ":prototest/twice-id.proto",
        ":prototest/use-reserved-id.proto",
        ":unicode_test.json",
-        ":union_vector/union_vector.fbs",
-        ":union_vector/union_vector.json",
+        "//tests/evolution_test:test_data",
+        "//tests/union_vector:test_data",
    ],
    includes = [
        "",
@@ -137,13 +113,21 @@ cc_test(
    deps = [
        ":alignment_test_cc_fbs",
        ":arrays_test_cc_fbs",
-        ":cross_namespace_pack_test_cc_fbs",
        ":default_vectors_strings_test_cc_fbs",
        ":monster_extra_cc_fbs",
        ":monster_test_cc_fbs",
+        ":native_inline_table_test_cc_fbs",
        ":native_type_test_cc_fbs",
+        ":optional_scalars_cc_fbs",
+        ":union_underlying_type_test_cc_fbs",
+        ":vector_table_naked_ptr_cc_fbs",
        "//:flatbuffers",
        "//src:generate_fbs",
+        "//tests/64bit:offset64_test",
+        "//tests/evolution_test:evolution_v1_cc_fbs",
+        "//tests/evolution_test:evolution_v2_cc_fbs",
+        "//tests/key_field:key_field_sample_cc_fbs",
+        "//tests/union_vector:union_vector_cc_fbs",
    ],
 )

@@ -153,7 +137,10 @@ cc_library(
    name = "test_assert",
    srcs = ["test_assert.cpp"],
    hdrs = ["test_assert.h"],
-    visibility = ["//grpc/tests:__subpackages__"],
+    visibility = [
+        "//grpc/tests:__subpackages__",
+        "//tests:__subpackages__",
+    ],
    deps = ["//:flatbuffers"],
 )

@@ -247,11 +234,20 @@ cc_library(
 flatbuffer_cc_library(
    name = "monster_extra_cc_fbs",
    srcs = ["monster_extra.fbs"],
+    filename_suffix = ".fbs",
+    flatc_args = [
+        "--gen-compare",
+        "--gen-mutable",
+        "--gen-object-api",
+        "--reflect-names",
+        "--filename-suffix .fbs",
+    ],
 )

 flatbuffer_cc_library(
    name = "arrays_test_cc_fbs",
    srcs = ["arrays_test.fbs"],
+    filename_suffix = ".fbs",
    flatc_args = [
        "--gen-object-api",
        "--gen-compare",
@@ -260,38 +256,26 @@ flatbuffer_cc_library(
        "--reflect-names",
        "--cpp-ptr-type flatbuffers::unique_ptr",
        "--scoped-enums",
-    ],
-)
-
-flatbuffer_cc_library(
-    name = "cross_namespace_pack_test_cc_fbs",
-    srcs = ["cross_namespace_pack_test.fbs"],
-    flatc_args = [
-        "--gen-object-api",
-        "--gen-mutable",
-        "--gen-compare",
-        "--reflect-names",
+        "--filename-suffix .fbs",
    ],
 )

 flatbuffer_cc_library(
    name = "native_type_test_cc_fbs",
    srcs = ["native_type_test.fbs"],
+    filename_suffix = ".fbs",
    flatc_args = [
        "--gen-object-api",
        "--gen-mutable",
        "--cpp-ptr-type flatbuffers::unique_ptr",
+        "--filename-suffix .fbs",
    ],
 )

 flatbuffer_cc_library(
    name = "alignment_test_cc_fbs",
    srcs = ["alignment_test.fbs"],
-)
-
-flatbuffer_cc_library(
-    name = "default_vectors_strings_test_cc_fbs",
-    srcs = ["default_vectors_strings_test.fbs"],
+    filename_suffix = ".fbs",
    flatc_args = [
        "--gen-compare",
        "--gen-mutable",
@@ -299,5 +283,71 @@ flatbuffer_cc_library(
        "--reflect-names",
        "--filename-suffix .fbs",
    ],
-    filename_suffix = ".fbs"
+)
+
+flatbuffer_cc_library(
+    name = "default_vectors_strings_test_cc_fbs",
+    srcs = ["default_vectors_strings_test.fbs"],
+    filename_suffix = ".fbs",
+    flatc_args = [
+        "--gen-compare",
+        "--gen-mutable",
+        "--gen-object-api",
+        "--reflect-names",
+        "--filename-suffix .fbs",
+    ],
+)
+
+flatbuffer_cc_library(
+    name = "native_inline_table_test_cc_fbs",
+    srcs = ["native_inline_table_test.fbs"],
+    filename_suffix = ".fbs",
+    flatc_args = [
+        "--gen-compare",
+        "--gen-mutable",
+        "--gen-object-api",
+        "--reflect-names",
+        "--filename-suffix .fbs",
+    ],
+)
+
+flatbuffer_cc_library(
+    name = "optional_scalars_cc_fbs",
+    srcs = ["optional_scalars.fbs"],
+    filename_suffix = ".fbs",
+    flatc_args = [
+        "--gen-compare",
+        "--gen-mutable",
+        "--gen-object-api",
+        "--reflect-names",
+        "--filename-suffix .fbs",
+    ],
+)
+
+flatbuffer_cc_library(
+    name = "union_underlying_type_test_cc_fbs",
+    srcs = ["union_underlying_type_test.fbs"],
+    filename_suffix = ".fbs",
+    flatc_args = [
+        "--gen-compare",
+        "--gen-mutable",
+        "--gen-object-api",
+        "--reflect-names",
+        "--filename-suffix .fbs",
+        "--scoped-enums",
+    ],
+)
+
+flatbuffer_cc_library(
+    name = "vector_table_naked_ptr_cc_fbs",
+    srcs = ["vector_table_naked_ptr.fbs"],
+    filename_suffix = ".fbs",
+    flatc_args = [
+        "--gen-compare",
+        "--gen-mutable",
+        "--gen-object-api",
+        "--reflect-names",
+        "--filename-suffix .fbs",
+        "--cpp-ptr-type naked",
+    ],
 )
--- a/tests/FlatBuffers.Test/FlatBuffers.Test.csproj
+++ b/tests/FlatBuffers.Test/FlatBuffers.Test.csproj
@@ -106,9 +106,6 @@
    <Compile Include="..\MyGame\Example\NestedStruct.cs">
      <Link>MyGame\Example\NestedStruct.cs</Link>
    </Compile>
-    <Compile Include="..\MyGame\Example\LargeArrayStruct.cs">
-      <Link>MyGame\Example\LargeArrayStruct.cs</Link>
-    </Compile>
    <Compile Include="..\MyGame\Example\LongEnum.cs">
      <Link>MyGame\Example\LongEnum.cs</Link>
    </Compile>
--- a/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs
+++ b/tests/FlatBuffers.Test/FlatBuffersExampleTests.cs
@@ -1,4 +1,4 @@
-/*
+/*
 * Copyright 2014 Google Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
@@ -90,9 +90,6 @@ namespace Google.FlatBuffers.Test
            fbb.AddOffset(test1.Value);
            var testArrayOfString = fbb.EndVector();

-            var longsVector = Monster.CreateVectorOfLongsVector(fbb, new long[] { 1, 100, 10000, 1000000, 100000000 });
-            var doublesVector = Monster.CreateVectorOfDoublesVector(fbb, new double[] { -1.7976931348623157e+308, 0, 1.7976931348623157e+308 });
-
            Monster.StartMonster(fbb);
            Monster.AddPos(fbb, Vec3.CreateVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0,
                                                     Color.Green, (short)5, (sbyte)6));
@@ -105,8 +102,6 @@ namespace Google.FlatBuffers.Test
            Monster.AddTestarrayofstring(fbb, testArrayOfString);
            Monster.AddTestbool(fbb, true);
            Monster.AddTestarrayoftables(fbb, sortMons);
-            Monster.AddVectorOfLongs(fbb, longsVector);
-            Monster.AddVectorOfDoubles(fbb, doublesVector);
            var mon = Monster.EndMonster(fbb);

            if (sizePrefix)
@@ -290,13 +285,6 @@ namespace Google.FlatBuffers.Test
                Assert.IsTrue(monster.GetTestarrayofboolsBytes().HasValue);
            }
            #endif
-
-            var longArray = monster.GetVectorOfLongsArray();
-            Assert.AreEqual(5, longArray.Length);
-            Assert.AreEqual(100, longArray[1]);
-
-            var doublesArray = monster.GetVectorOfDoublesArray();
-            Assert.AreEqual(3, doublesArray.Length);
        }

        [FlatBuffersTestMethod]
--- a/tests/FlatBuffers.Test/FlatBuffersFixedLengthArrayTests.cs
+++ b/tests/FlatBuffers.Test/FlatBuffersFixedLengthArrayTests.cs
@@ -1,249 +0,0 @@
-/*
- * Copyright 2025 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-using System;
-using System.Linq;
-using MyGame.Example;
-
-namespace Google.FlatBuffers.Test
-{
-    [FlatBuffersTestClass]
-    public class FlatBuffersFixedLengthArrayTests
-    {
-        [FlatBuffersTestMethod]
-        public void FixedLengthArray_LengthConstantsMatchSchema_ReturnTrue()
-        {
-            const int nestedALength = NestedStruct.ALength;
-            const int nestedCLength = NestedStruct.CLength;
-            const int nestedDLength = NestedStruct.DLength;
-            const int arrayBLength = ArrayStruct.BLength;
-            const int arrayFLength = ArrayStruct.FLength;
-
-            Assert.AreEqual(2, nestedALength);
-            Assert.AreEqual(2, nestedCLength);
-            Assert.AreEqual(2, nestedDLength);
-            Assert.AreEqual(15, arrayBLength);
-            Assert.AreEqual(2, arrayFLength);
-        }
-
-#if ENABLE_SPAN_T
-        [FlatBuffersTestMethod]
-        public void FixedLengthArray_GetBytesSpanLengthIsCorrect_ReturnTrue()
-        {
-            var builder = new FlatBufferBuilder(1024);
-            var ints = new int[] { 1, 2 };
-            var enumB = TestEnum.A;
-            var enums = new TestEnum[] { TestEnum.B, TestEnum.C };
-            var longs = new long[] { 10L, 20L };
-            
-            var structOffset = NestedStruct.CreateNestedStruct(builder, ints, enumB, enums, longs);
-            builder.Finish(structOffset.Value);
-            
-            var bb = builder.DataBuffer;
-            var nestedStruct = new NestedStruct();
-            nestedStruct.__assign(bb.Length - builder.Offset, bb);
-
-            Span<int> intSpan = nestedStruct.GetABytes();
-            Span<TestEnum> enumSpan = nestedStruct.GetCBytes();
-            Span<long> longSpan = nestedStruct.GetDBytes();
-
-            Assert.AreEqual(intSpan.Length, NestedStruct.ALength);
-            Assert.AreEqual(enumSpan.Length, NestedStruct.CLength);
-            Assert.AreEqual(longSpan.Length, NestedStruct.DLength);          
-        }
-#endif
-
-#if !ENABLE_SPAN_T
-        [FlatBuffersTestMethod]
-        public void FixedLengthArray_GetBytesArraySegmentLengthIsCorrect_ReturnTrue()
-        {
-            var builder = new FlatBufferBuilder(1024);
-            var ints = new int[] { 1, 2 };
-            var enumB = TestEnum.A;
-            var enums = new TestEnum[] { TestEnum.B, TestEnum.C };
-            var longs = new long[] { 10L, 20L };
-
-            var structOffset = NestedStruct.CreateNestedStruct(builder, ints, enumB, enums, longs);
-            builder.Finish(structOffset.Value);
-
-            var buffer = builder.DataBuffer;
-            var nestedStruct = new NestedStruct();
-            nestedStruct.__assign(buffer.Length - builder.Offset, buffer);
-
-            Assert.IsTrue(nestedStruct.GetABytes().HasValue);
-            Assert.IsTrue(nestedStruct.GetCBytes().HasValue);
-            Assert.IsTrue(nestedStruct.GetDBytes().HasValue);
-
-            ArraySegment<byte> intSegment = nestedStruct.GetABytes().Value;
-            ArraySegment<byte> enumSegment = nestedStruct.GetCBytes().Value;
-            ArraySegment<byte> longSegment = nestedStruct.GetDBytes().Value;
-
-            Assert.AreEqual(intSegment.Count, NestedStruct.ALength * sizeof(int));
-            Assert.AreEqual(enumSegment.Count, NestedStruct.CLength * sizeof(sbyte));
-            Assert.AreEqual(longSegment.Count, NestedStruct.DLength * sizeof(long));
-        }
-#endif
-
-#if ENABLE_SPAN_T
-        [FlatBuffersTestMethod]
-        public void FixedLengthArray_GetBytesSpanEquality_ReturnTrue()
-        {
-            var builder = new FlatBufferBuilder(1024);
-
-            var floatA = 3.14f;
-            var intArray = Enumerable.Range(1, 15).ToArray();
-            var byteC = (sbyte)42;
-            var intE = 999;
-            var longArray = new long[] { 5000L, 6000L };
-
-            var nestedInts = new int[2, 2] { { 10, 20 }, { 30, 40 } };
-            var nestedEnumB = new TestEnum[] { TestEnum.A, TestEnum.B };
-            var nestedEnums = new TestEnum[2, 2] { { TestEnum.A, TestEnum.B }, { TestEnum.C, TestEnum.A } };
-            var nestedLongs = new long[2, 2] { { 100L, 200L }, { 300L, 400L } };
-
-            var structOffset = ArrayStruct.CreateArrayStruct(builder, floatA, intArray, byteC,
-                nestedInts, nestedEnumB, nestedEnums, nestedLongs, intE, longArray);
-
-            ArrayTable.StartArrayTable(builder);
-            ArrayTable.AddA(builder, structOffset);
-            var rootTable = ArrayTable.EndArrayTable(builder);
-            builder.Finish(rootTable.Value);
-
-            var finishedBytes = builder.SizedByteArray();
-            ByteBuffer bb = new ByteBuffer(finishedBytes);
-            ArrayTable arrayTable = ArrayTable.GetRootAsArrayTable(bb);
-            ArrayStruct arrayStruct = arrayTable.A.Value;
-
-            Assert.AreEqual(byteC, arrayStruct.C);
-            Assert.AreEqual(intE, arrayStruct.E);
-
-            Assert.IsTrue(arrayStruct.GetBBytes().SequenceEqual(intArray));
-            Assert.IsTrue(arrayStruct.GetFBytes().SequenceEqual(longArray));
-            
-            // Test nested struct arrays
-            for (int i = 0; i < 2; i++)
-            {
-                var nestedStruct = arrayStruct.D(i);
-                
-                var nestedIntSpan = nestedStruct.GetABytes();
-                var expectedNestedInts = new int[] { nestedInts[i, 0], nestedInts[i, 1] };
-                Assert.IsTrue(nestedIntSpan.SequenceEqual(expectedNestedInts));
-                
-                Assert.AreEqual(nestedEnumB[i], nestedStruct.B);
-                
-                var nestedEnumSpan = nestedStruct.GetCBytes();
-                var expectedNestedEnums = new TestEnum[] { nestedEnums[i, 0], nestedEnums[i, 1] };
-                Assert.IsTrue(nestedEnumSpan.SequenceEqual(expectedNestedEnums));
-                
-                var nestedLongSpan = nestedStruct.GetDBytes();
-                var expectedNestedLongs = new long[] { nestedLongs[i, 0], nestedLongs[i, 1] };
-                Assert.IsTrue(nestedLongSpan.SequenceEqual(expectedNestedLongs));
-            }
-        }
-#endif  
-
-#if !ENABLE_SPAN_T
-        [FlatBuffersTestMethod] 
-        public void FixedLengthArray_GetBytesArraySegmentEquality_ReturnTrue()
-        {
-            var builder = new FlatBufferBuilder(1024);
-            
-            var floatA = 3.14f;
-            var intArray = Enumerable.Range(1, 15).ToArray();
-            var byteC = (sbyte)42;
-            var intE = 999;
-            var longArray = new long[] { 5000L, 6000L };
-            
-            var nestedInts = new int[2, 2] { { 10, 20 }, { 30, 40 } };
-            var nestedEnumB = new TestEnum[] { TestEnum.A, TestEnum.B };
-            var nestedEnums = new TestEnum[2, 2] { { TestEnum.A, TestEnum.B }, { TestEnum.C, TestEnum.A } };
-            var nestedLongs = new long[2, 2] { { 100L, 200L }, { 300L, 400L } };
-            
-            var structOffset = ArrayStruct.CreateArrayStruct(builder, floatA, intArray, byteC, 
-                nestedInts, nestedEnumB, nestedEnums, nestedLongs, intE, longArray);
-
-            ArrayTable.StartArrayTable(builder);
-            ArrayTable.AddA(builder, structOffset);
-            var rootTable = ArrayTable.EndArrayTable(builder);
-            builder.Finish(rootTable.Value);
-
-            var finishedBytes = builder.SizedByteArray();
-            ByteBuffer bb = new ByteBuffer(finishedBytes);
-            ArrayTable arrayTable = ArrayTable.GetRootAsArrayTable(bb);
-            ArrayStruct arrayStruct = arrayTable.A.Value;
-
-            // Test that we can read basic scalars correctly
-            Assert.AreEqual(byteC, arrayStruct.C);
-            Assert.AreEqual(intE, arrayStruct.E);
-            
-            Assert.IsTrue(arrayStruct.GetBBytes().HasValue);
-            var intSegment = arrayStruct.GetBBytes().Value;
-            for (int i = 0, offset = 0; i < intArray.Length; i++, offset += sizeof(int))
-            {
-                var segmentValue = BitConverter.ToInt32(intSegment.Array,
-                    intSegment.Offset + offset);
-                Assert.AreEqual(intArray[i], segmentValue);
-            }
-            
-            Assert.IsTrue(arrayStruct.GetFBytes().HasValue);
-            var longSegment = arrayStruct.GetFBytes().Value;
-            for (int i = 0, offset = 0; i < longArray.Length; i++, offset += sizeof(long))
-            {
-                var segmentValue = BitConverter.ToInt64(longSegment.Array,
-                    longSegment.Offset + offset);
-                Assert.AreEqual(longArray[i], segmentValue);
-            }
-            
-            // Test nested struct arrays
-            for (int i = 0; i < 2; i++)
-            {
-                var nestedStruct = arrayStruct.D(i);
-                
-                Assert.IsTrue(nestedStruct.GetABytes().HasValue);
-                var nestedIntSegment = nestedStruct.GetABytes().Value;
-                var expectedNestedInts = new int[] { nestedInts[i, 0], nestedInts[i, 1] };
-                for (int ii = 0, offset = 0; ii < NestedStruct.ALength; ii++, offset += sizeof(int))
-                {
-                    var segmentValue = BitConverter.ToInt32(nestedIntSegment.Array,
-                        nestedIntSegment.Offset + offset);
-                    Assert.AreEqual(expectedNestedInts[ii], segmentValue);
-                }
-
-                Assert.AreEqual(nestedEnumB[i], nestedStruct.B);
-                
-                Assert.IsTrue(nestedStruct.GetCBytes().HasValue);
-                var nestedEnumSegment = nestedStruct.GetCBytes().Value;
-                var expectedNestedEnums = new TestEnum[] { nestedEnums[i, 0], nestedEnums[i, 1] };
-                for (int ii = 0, offset = 0; ii < NestedStruct.CLength; ii++, offset += sizeof(sbyte))
-                {
-                    var segmentValue = (TestEnum)nestedEnumSegment.Array[nestedEnumSegment.Offset + offset];
-                    Assert.AreEqual(expectedNestedEnums[ii], segmentValue);
-                }
-                
-                Assert.IsTrue(nestedStruct.GetDBytes().HasValue);
-                var nestedLongSegment = nestedStruct.GetDBytes().Value;
-                var expectedNestedLongs = new long[] { nestedLongs[i, 0], nestedLongs[i, 1] };
-                for (int ii = 0, offset = 0; ii < NestedStruct.DLength; ii++, offset += sizeof(long))
-                {
-                    var segmentValue = BitConverter.ToInt64(nestedLongSegment.Array,
-                        nestedLongSegment.Offset + offset);
-                    Assert.AreEqual(expectedNestedLongs[ii], segmentValue);
-                }
-            }
-        }
-#endif
-    }
-}
--- a/tests/MyGame/Example/ArrayStruct.cs
+++ b/tests/MyGame/Example/ArrayStruct.cs
@@ -19,12 +19,6 @@ public struct ArrayStruct : IFlatbufferObject
  public float A { get { return __p.bb.GetFloat(__p.bb_pos + 0); } }
  public void MutateA(float a) { __p.bb.PutFloat(__p.bb_pos + 0, a); }
  public int B(int j) { return __p.bb.GetInt(__p.bb_pos + 4 + j * 4); }
-  public const int BLength = 15;
-#if ENABLE_SPAN_T
-  public Span<int> GetBBytes() { return System.Runtime.InteropServices.MemoryMarshal.Cast<byte, int>(__p.bb.ToSpan(__p.bb_pos + 4, 60)); }
-#else
-  public ArraySegment<byte>? GetBBytes() { return __p.bb.ToArraySegment(__p.bb_pos + 4, 60);}
-#endif
  public void MutateB(int j, int b) { __p.bb.PutInt(__p.bb_pos + 4 + j * 4, b); }
  public sbyte C { get { return __p.bb.GetSbyte(__p.bb_pos + 64); } }
  public void MutateC(sbyte c) { __p.bb.PutSbyte(__p.bb_pos + 64, c); }
@@ -32,12 +26,6 @@ public struct ArrayStruct : IFlatbufferObject
  public int E { get { return __p.bb.GetInt(__p.bb_pos + 136); } }
  public void MutateE(int e) { __p.bb.PutInt(__p.bb_pos + 136, e); }
  public long F(int j) { return __p.bb.GetLong(__p.bb_pos + 144 + j * 8); }
-  public const int FLength = 2;
-#if ENABLE_SPAN_T
-  public Span<long> GetFBytes() { return System.Runtime.InteropServices.MemoryMarshal.Cast<byte, long>(__p.bb.ToSpan(__p.bb_pos + 144, 16)); }
-#else
-  public ArraySegment<byte>? GetFBytes() { return __p.bb.ToArraySegment(__p.bb_pos + 144, 16);}
-#endif
  public void MutateF(int j, long f) { __p.bb.PutLong(__p.bb_pos + 144 + j * 8, f); }

  public static Offset<MyGame.Example.ArrayStruct> CreateArrayStruct(FlatBufferBuilder builder, float A, int[] B, sbyte C, int[,] d_A, MyGame.Example.TestEnum[] d_B, MyGame.Example.TestEnum[,] d_C, long[,] d_D, int E, long[] F) {
--- a/tests/MyGame/Example/LargeArrayStruct.cs
+++ b/tests/MyGame/Example/LargeArrayStruct.cs
@@ -1,150 +0,0 @@
-// <auto-generated>
-//  automatically generated by the FlatBuffers compiler, do not modify
-// </auto-generated>
-
-namespace MyGame.Example
-{
-
-using global::System;
-using global::System.Collections.Generic;
-using global::Google.FlatBuffers;
-
-public struct LargeArrayStruct : IFlatbufferObject
-{
-  private Struct __p;
-  public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public void __init(int _i, ByteBuffer _bb) { __p = new Struct(_i, _bb); }
-  public LargeArrayStruct __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
-
-  public byte D(int j) { return __p.bb.Get(__p.bb_pos + 0 + j * 1); }
-  public const int DLength = 64;
-#if ENABLE_SPAN_T
-  public Span<byte> GetDBytes() { return __p.bb.ToSpan(__p.bb_pos + 0, 64); }
-#else
-  public ArraySegment<byte>? GetDBytes() { return __p.bb.ToArraySegment(__p.bb_pos + 0, 64);}
-#endif
-  public void MutateD(int j, byte d) { __p.bb.Put(__p.bb_pos + 0 + j * 1, d); }
-  public float E(int j) { return __p.bb.GetFloat(__p.bb_pos + 64 + j * 4); }
-  public const int ELength = 64;
-#if ENABLE_SPAN_T
-  public Span<float> GetEBytes() { return System.Runtime.InteropServices.MemoryMarshal.Cast<byte, float>(__p.bb.ToSpan(__p.bb_pos + 64, 256)); }
-#else
-  public ArraySegment<byte>? GetEBytes() { return __p.bb.ToArraySegment(__p.bb_pos + 64, 256);}
-#endif
-  public void MutateE(int j, float e) { __p.bb.PutFloat(__p.bb_pos + 64 + j * 4, e); }
-  public bool F(int j) { return 0!=__p.bb.Get(__p.bb_pos + 320 + j * 1); }
-  public const int FLength = 64;
-#if ENABLE_SPAN_T
-  public Span<bool> GetFBytes() { return System.Runtime.InteropServices.MemoryMarshal.Cast<byte, bool>(__p.bb.ToSpan(__p.bb_pos + 320, 64)); }
-#else
-  public ArraySegment<byte>? GetFBytes() { return __p.bb.ToArraySegment(__p.bb_pos + 320, 64);}
-#endif
-  public void MutateF(int j, bool f) { __p.bb.Put(__p.bb_pos + 320 + j * 1, (byte)(f ? 1 : 0)); }
-  public MyGame.Example.NestedStruct G(int j) { return (new MyGame.Example.NestedStruct()).__assign(__p.bb_pos + 384 + j * 32, __p.bb); }
-  public MyGame.Example.TestEnum H(int j) { return (MyGame.Example.TestEnum)__p.bb.GetSbyte(__p.bb_pos + 2432 + j * 1); }
-  public const int HLength = 64;
-#if ENABLE_SPAN_T
-  public Span<MyGame.Example.TestEnum> GetHBytes() { return System.Runtime.InteropServices.MemoryMarshal.Cast<byte, MyGame.Example.TestEnum>(__p.bb.ToSpan(__p.bb_pos + 2432, 64)); }
-#else
-  public ArraySegment<byte>? GetHBytes() { return __p.bb.ToArraySegment(__p.bb_pos + 2432, 64);}
-#endif
-  public void MutateH(int j, MyGame.Example.TestEnum h) { __p.bb.PutSbyte(__p.bb_pos + 2432 + j * 1, (sbyte)h); }
-
-  public static Offset<MyGame.Example.LargeArrayStruct> CreateLargeArrayStruct(FlatBufferBuilder builder, byte[] D, float[] E, bool[] F, int[,] g_A, MyGame.Example.TestEnum[] g_B, MyGame.Example.TestEnum[,] g_C, long[,] g_D, MyGame.Example.TestEnum[] H) {
-    builder.Prep(8, 2496);
-    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
-      builder.PutSbyte((sbyte)H[_idx0-1]);
-    }
-    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
-      builder.Prep(8, 32);
-      for (int _idx1 = 2; _idx1 > 0; _idx1--) {
-        builder.PutLong(g_D[_idx0-1,_idx1-1]);
-      }
-      builder.Pad(5);
-      for (int _idx1 = 2; _idx1 > 0; _idx1--) {
-        builder.PutSbyte((sbyte)g_C[_idx0-1,_idx1-1]);
-      }
-      builder.PutSbyte((sbyte)g_B[_idx0-1]);
-      for (int _idx1 = 2; _idx1 > 0; _idx1--) {
-        builder.PutInt(g_A[_idx0-1,_idx1-1]);
-      }
-    }
-    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
-      builder.PutBool(F[_idx0-1]);
-    }
-    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
-      builder.PutFloat(E[_idx0-1]);
-    }
-    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
-      builder.PutByte(D[_idx0-1]);
-    }
-    return new Offset<MyGame.Example.LargeArrayStruct>(builder.Offset);
-  }
-  public LargeArrayStructT UnPack() {
-    var _o = new LargeArrayStructT();
-    this.UnPackTo(_o);
-    return _o;
-  }
-  public void UnPackTo(LargeArrayStructT _o) {
-    _o.D = new byte[64];
-    for (var _j = 0; _j < 64; ++_j) { _o.D[_j] = this.D(_j); }
-    _o.E = new float[64];
-    for (var _j = 0; _j < 64; ++_j) { _o.E[_j] = this.E(_j); }
-    _o.F = new bool[64];
-    for (var _j = 0; _j < 64; ++_j) { _o.F[_j] = this.F(_j); }
-    _o.G = new MyGame.Example.NestedStructT[64];
-    for (var _j = 0; _j < 64; ++_j) { _o.G[_j] = this.G(_j).UnPack(); }
-    _o.H = new MyGame.Example.TestEnum[64];
-    for (var _j = 0; _j < 64; ++_j) { _o.H[_j] = this.H(_j); }
-  }
-  public static Offset<MyGame.Example.LargeArrayStruct> Pack(FlatBufferBuilder builder, LargeArrayStructT _o) {
-    if (_o == null) return default(Offset<MyGame.Example.LargeArrayStruct>);
-    var _d = _o.D;
-    var _e = _o.E;
-    var _f = _o.F;
-    var _g_a = new int[64,2];
-    for (var idx0 = 0; idx0 < 64; ++idx0) {for (var idx1 = 0; idx1 < 2; ++idx1) {_g_a[idx0,idx1] = _o.G[idx0].A[idx1];}}
-    var _g_b = new MyGame.Example.TestEnum[64];
-    for (var idx0 = 0; idx0 < 64; ++idx0) {_g_b[idx0] = _o.G[idx0].B;}
-    var _g_c = new MyGame.Example.TestEnum[64,2];
-    for (var idx0 = 0; idx0 < 64; ++idx0) {for (var idx1 = 0; idx1 < 2; ++idx1) {_g_c[idx0,idx1] = _o.G[idx0].C[idx1];}}
-    var _g_d = new long[64,2];
-    for (var idx0 = 0; idx0 < 64; ++idx0) {for (var idx1 = 0; idx1 < 2; ++idx1) {_g_d[idx0,idx1] = _o.G[idx0].D[idx1];}}
-    var _h = _o.H;
-    return CreateLargeArrayStruct(
-      builder,
-      _d,
-      _e,
-      _f,
-      _g_a,
-      _g_b,
-      _g_c,
-      _g_d,
-      _h);
-  }
-}
-
-public class LargeArrayStructT
-{
-  [Newtonsoft.Json.JsonProperty("d")]
-  public byte[] D { get; set; }
-  [Newtonsoft.Json.JsonProperty("e")]
-  public float[] E { get; set; }
-  [Newtonsoft.Json.JsonProperty("f")]
-  public bool[] F { get; set; }
-  [Newtonsoft.Json.JsonProperty("g")]
-  public MyGame.Example.NestedStructT[] G { get; set; }
-  [Newtonsoft.Json.JsonProperty("h")]
-  public MyGame.Example.TestEnum[] H { get; set; }
-
-  public LargeArrayStructT() {
-    this.D = new byte[64];
-    this.E = new float[64];
-    this.F = new bool[64];
-    this.G = new MyGame.Example.NestedStructT[64];
-    this.H = new MyGame.Example.TestEnum[64];
-  }
-}
-
-
-}
--- a/tests/MyGame/Example/LargeArrayStruct.java
+++ b/tests/MyGame/Example/LargeArrayStruct.java
@@ -1,117 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-package MyGame.Example;
-
-import com.google.flatbuffers.BaseVector;
-import com.google.flatbuffers.BooleanVector;
-import com.google.flatbuffers.ByteVector;
-import com.google.flatbuffers.Constants;
-import com.google.flatbuffers.DoubleVector;
-import com.google.flatbuffers.FlatBufferBuilder;
-import com.google.flatbuffers.FloatVector;
-import com.google.flatbuffers.IntVector;
-import com.google.flatbuffers.LongVector;
-import com.google.flatbuffers.ShortVector;
-import com.google.flatbuffers.StringVector;
-import com.google.flatbuffers.Struct;
-import com.google.flatbuffers.UnionVector;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-
-@SuppressWarnings("unused")
-public final class LargeArrayStruct extends Struct {
-  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
-  public LargeArrayStruct __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
-
-  public int d(int j) { return bb.get(bb_pos + 0 + j * 1); }
-  public void mutateD(int j, int d) { bb.put(bb_pos + 0 + j * 1, (byte) d); }
-  public float e(int j) { return bb.getFloat(bb_pos + 64 + j * 4); }
-  public void mutateE(int j, float e) { bb.putFloat(bb_pos + 64 + j * 4, e); }
-  public boolean f(int j) { return 0!=bb.get(bb_pos + 320 + j * 1); }
-  public void mutateF(int j, boolean f) { bb.put(bb_pos + 320 + j * 1, (byte)(f ? 1 : 0)); }
-  public MyGame.Example.NestedStruct g(int j) { return g(new MyGame.Example.NestedStruct(), j); }
-  public MyGame.Example.NestedStruct g(MyGame.Example.NestedStruct obj, int j) { return obj.__assign(bb_pos + 384 + j * 32, bb); }
-  public byte h(int j) { return bb.get(bb_pos + 2432 + j * 1); }
-  public void mutateH(int j, byte h) { bb.put(bb_pos + 2432 + j * 1, h); }
-
-  public static int createLargeArrayStruct(FlatBufferBuilder builder, int[] d, float[] e, boolean[] f, int[][] g_a, byte[] g_b, byte[][] g_c, long[][] g_d, byte[] h) {
-    builder.prep(8, 2496);
-    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
-      builder.putByte(h[_idx0-1]);
-    }
-    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
-      builder.prep(8, 32);
-      for (int _idx1 = 2; _idx1 > 0; _idx1--) {
-        builder.putLong(g_d[_idx0-1][_idx1-1]);
-      }
-      builder.pad(5);
-      for (int _idx1 = 2; _idx1 > 0; _idx1--) {
-        builder.putByte(g_c[_idx0-1][_idx1-1]);
-      }
-      builder.putByte(g_b[_idx0-1]);
-      for (int _idx1 = 2; _idx1 > 0; _idx1--) {
-        builder.putInt(g_a[_idx0-1][_idx1-1]);
-      }
-    }
-    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
-      builder.putBoolean(f[_idx0-1]);
-    }
-    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
-      builder.putFloat(e[_idx0-1]);
-    }
-    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
-      builder.putByte((byte) d[_idx0-1]);
-    }
-    return builder.offset();
-  }
-
-  public static final class Vector extends BaseVector {
-    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
-
-    public LargeArrayStruct get(int j) { return get(new LargeArrayStruct(), j); }
-    public LargeArrayStruct get(LargeArrayStruct obj, int j) {  return obj.__assign(__element(j), bb); }
-  }
-  public LargeArrayStructT unpack() {
-    LargeArrayStructT _o = new LargeArrayStructT();
-    unpackTo(_o);
-    return _o;
-  }
-  public void unpackTo(LargeArrayStructT _o) {
-    int[] _oD = _o.getD();
-    for (int _j = 0; _j < 64; ++_j) { _oD[_j] = d(_j); }
-    float[] _oE = _o.getE();
-    for (int _j = 0; _j < 64; ++_j) { _oE[_j] = e(_j); }
-    boolean[] _oF = _o.getF();
-    for (int _j = 0; _j < 64; ++_j) { _oF[_j] = f(_j); }
-    MyGame.Example.NestedStructT[] _oG = _o.getG();
-    for (int _j = 0; _j < 64; ++_j) { _oG[_j] = g(_j).unpack(); }
-    byte[] _oH = _o.getH();
-    for (int _j = 0; _j < 64; ++_j) { _oH[_j] = h(_j); }
-  }
-  public static int pack(FlatBufferBuilder builder, LargeArrayStructT _o) {
-    if (_o == null) return 0;
-    int[] _d = _o.getD();
-    float[] _e = _o.getE();
-    boolean[] _f = _o.getF();
-    int[][] _g_a = new int[64][2];
-    for (int idx0 = 0; idx0 < 64; ++idx0) {for (int idx1 = 0; idx1 < 2; ++idx1) {_g_a[idx0][idx1] = _o.getG()[idx0].getA()[idx1];}}
-    byte[] _g_b = new byte[64];
-    for (int idx0 = 0; idx0 < 64; ++idx0) {_g_b[idx0] = _o.getG()[idx0].getB();}
-    byte[][] _g_c = new byte[64][2];
-    for (int idx0 = 0; idx0 < 64; ++idx0) {for (int idx1 = 0; idx1 < 2; ++idx1) {_g_c[idx0][idx1] = _o.getG()[idx0].getC()[idx1];}}
-    long[][] _g_d = new long[64][2];
-    for (int idx0 = 0; idx0 < 64; ++idx0) {for (int idx1 = 0; idx1 < 2; ++idx1) {_g_d[idx0][idx1] = _o.getG()[idx0].getD()[idx1];}}
-    byte[] _h = _o.getH();
-    return createLargeArrayStruct(
-      builder,
-      _d,
-      _e,
-      _f,
-      _g_a,
-      _g_b,
-      _g_c,
-      _g_d,
-      _h);
-  }
-}
-
--- a/tests/MyGame/Example/LargeArrayStruct.py
+++ b/tests/MyGame/Example/LargeArrayStruct.py
@@ -1,226 +0,0 @@
-# automatically generated by the FlatBuffers compiler, do not modify
-
-# namespace: Example
-
-import flatbuffers
-from flatbuffers.compat import import_numpy
-from typing import Any
-from MyGame.Example.NestedStruct import NestedStruct
-np = import_numpy()
-
-class LargeArrayStruct(object):
-    __slots__ = ['_tab']
-
-    @classmethod
-    def SizeOf(cls) -> int:
-        return 2496
-
-    # LargeArrayStruct
-    def Init(self, buf: bytes, pos: int):
-        self._tab = flatbuffers.table.Table(buf, pos)
-
-    # LargeArrayStruct
-    def D(self, j = None):
-        if j is None:
-            return [self._tab.Get(flatbuffers.number_types.Uint8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0 + i * 1)) for i in range(self.DLength())]
-        elif j >= 0 and j < self.DLength():
-            return self._tab.Get(flatbuffers.number_types.Uint8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0 + j * 1))
-        else:
-            return None
-
-    # LargeArrayStruct
-    def DAsNumpy(self):
-        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Uint8Flags, self._tab.Pos + 0, self.DLength())
-
-    # LargeArrayStruct
-    def DLength(self) -> int:
-        return 64
-
-    # LargeArrayStruct
-    def DIsNone(self) -> bool:
-        return False
-
-    # LargeArrayStruct
-    def E(self, j = None):
-        if j is None:
-            return [self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(64 + i * 4)) for i in range(self.ELength())]
-        elif j >= 0 and j < self.ELength():
-            return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(64 + j * 4))
-        else:
-            return None
-
-    # LargeArrayStruct
-    def EAsNumpy(self):
-        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Float32Flags, self._tab.Pos + 64, self.ELength())
-
-    # LargeArrayStruct
-    def ELength(self) -> int:
-        return 64
-
-    # LargeArrayStruct
-    def EIsNone(self) -> bool:
-        return False
-
-    # LargeArrayStruct
-    def F(self, j = None):
-        if j is None:
-            return [self._tab.Get(flatbuffers.number_types.BoolFlags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(320 + i * 1)) for i in range(self.FLength())]
-        elif j >= 0 and j < self.FLength():
-            return self._tab.Get(flatbuffers.number_types.BoolFlags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(320 + j * 1))
-        else:
-            return None
-
-    # LargeArrayStruct
-    def FAsNumpy(self):
-        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.BoolFlags, self._tab.Pos + 320, self.FLength())
-
-    # LargeArrayStruct
-    def FLength(self) -> int:
-        return 64
-
-    # LargeArrayStruct
-    def FIsNone(self) -> bool:
-        return False
-
-    # LargeArrayStruct
-    def G(self, i: int) -> NestedStruct:
-        obj = NestedStruct()
-        obj.Init(self._tab.Bytes, self._tab.Pos + 384 + i * 32)
-        return obj
-
-    # LargeArrayStruct
-    def GLength(self) -> int:
-        return 64
-
-    # LargeArrayStruct
-    def GIsNone(self) -> bool:
-        return False
-
-    # LargeArrayStruct
-    def H(self, j = None):
-        if j is None:
-            return [self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(2432 + i * 1)) for i in range(self.HLength())]
-        elif j >= 0 and j < self.HLength():
-            return self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(2432 + j * 1))
-        else:
-            return None
-
-    # LargeArrayStruct
-    def HAsNumpy(self):
-        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int8Flags, self._tab.Pos + 2432, self.HLength())
-
-    # LargeArrayStruct
-    def HLength(self) -> int:
-        return 64
-
-    # LargeArrayStruct
-    def HIsNone(self) -> bool:
-        return False
-
-
-def CreateLargeArrayStruct(builder, d, e, f, g_a, g_b, g_c, g_d, h):
-    builder.Prep(8, 2496)
-    for _idx0 in range(64 , 0, -1):
-        builder.PrependInt8(h[_idx0-1])
-    for _idx0 in range(64 , 0, -1):
-        builder.Prep(8, 32)
-        for _idx1 in range(2 , 0, -1):
-            builder.PrependInt64(g_d[_idx0-1][_idx1-1])
-        builder.Pad(5)
-        for _idx1 in range(2 , 0, -1):
-            builder.PrependInt8(g_c[_idx0-1][_idx1-1])
-        builder.PrependInt8(g_b[_idx0-1])
-        for _idx1 in range(2 , 0, -1):
-            builder.PrependInt32(g_a[_idx0-1][_idx1-1])
-    for _idx0 in range(64 , 0, -1):
-        builder.PrependBool(f[_idx0-1])
-    for _idx0 in range(64 , 0, -1):
-        builder.PrependFloat32(e[_idx0-1])
-    for _idx0 in range(64 , 0, -1):
-        builder.PrependUint8(d[_idx0-1])
-    return builder.Offset()
-
-import MyGame.Example.NestedStruct
-try:
-    from typing import List
-except:
-    pass
-
-class LargeArrayStructT(object):
-
-    # LargeArrayStructT
-    def __init__(
-        self,
-        d = None,
-        e = None,
-        f = None,
-        g = None,
-        h = None,
-    ):
-        self.d = d  # type: Optional[List[int]]
-        self.e = e  # type: Optional[List[float]]
-        self.f = f  # type: Optional[List[bool]]
-        self.g = g  # type: Optional[List[MyGame.Example.NestedStruct.NestedStructT]]
-        self.h = h  # type: Optional[List[int]]
-
-    @classmethod
-    def InitFromBuf(cls, buf, pos):
-        largeArrayStruct = LargeArrayStruct()
-        largeArrayStruct.Init(buf, pos)
-        return cls.InitFromObj(largeArrayStruct)
-
-    @classmethod
-    def InitFromPackedBuf(cls, buf, pos=0):
-        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
-        return cls.InitFromBuf(buf, pos+n)
-
-    @classmethod
-    def InitFromObj(cls, largeArrayStruct):
-        x = LargeArrayStructT()
-        x._UnPack(largeArrayStruct)
-        return x
-
-    # LargeArrayStructT
-    def _UnPack(self, largeArrayStruct):
-        if largeArrayStruct is None:
-            return
-        if not largeArrayStruct.DIsNone():
-            if np is None:
-                self.d = []
-                for i in range(largeArrayStruct.DLength()):
-                    self.d.append(largeArrayStruct.D(i))
-            else:
-                self.d = largeArrayStruct.DAsNumpy()
-        if not largeArrayStruct.EIsNone():
-            if np is None:
-                self.e = []
-                for i in range(largeArrayStruct.ELength()):
-                    self.e.append(largeArrayStruct.E(i))
-            else:
-                self.e = largeArrayStruct.EAsNumpy()
-        if not largeArrayStruct.FIsNone():
-            if np is None:
-                self.f = []
-                for i in range(largeArrayStruct.FLength()):
-                    self.f.append(largeArrayStruct.F(i))
-            else:
-                self.f = largeArrayStruct.FAsNumpy()
-        if not largeArrayStruct.GIsNone():
-            self.g = []
-            for i in range(largeArrayStruct.GLength()):
-                if largeArrayStruct.G(i) is None:
-                    self.g.append(None)
-                else:
-                    nestedStruct_ = MyGame.Example.NestedStruct.NestedStructT.InitFromObj(largeArrayStruct.G(i))
-                    self.g.append(nestedStruct_)
-        if not largeArrayStruct.HIsNone():
-            if np is None:
-                self.h = []
-                for i in range(largeArrayStruct.HLength()):
-                    self.h.append(largeArrayStruct.H(i))
-            else:
-                self.h = largeArrayStruct.HAsNumpy()
-
-    # LargeArrayStructT
-    def Pack(self, builder):
-        return CreateLargeArrayStruct(builder, self.d, self.e, self.f, self.g.a, self.g.b, self.g.c, self.g.d, self.h)
--- a/tests/MyGame/Example/LargeArrayStruct.pyi
+++ b/tests/MyGame/Example/LargeArrayStruct.pyi
@@ -1,60 +0,0 @@
-from __future__ import annotations
-
-import flatbuffers
-import numpy as np
-
-import typing
-from MyGame.Example.NestedStruct import NestedStruct, NestedStructT
-from MyGame.Example.TestEnum import TestEnum
-
-uoffset: typing.TypeAlias = flatbuffers.number_types.UOffsetTFlags.py_type
-
-class LargeArrayStruct(object):
-  @classmethod
-  def SizeOf(cls) -> int: ...
-
-  def Init(self, buf: bytes, pos: int) -> None: ...
-  def D(self, i: int) -> typing.List[int]: ...
-  def DAsNumpy(self) -> np.ndarray: ...
-  def DLength(self) -> int: ...
-  def DIsNone(self) -> bool: ...
-  def E(self, i: int) -> typing.List[float]: ...
-  def EAsNumpy(self) -> np.ndarray: ...
-  def ELength(self) -> int: ...
-  def EIsNone(self) -> bool: ...
-  def F(self, i: int) -> typing.List[bool]: ...
-  def FAsNumpy(self) -> np.ndarray: ...
-  def FLength(self) -> int: ...
-  def FIsNone(self) -> bool: ...
-  def G(self, i: int) -> NestedStruct | None: ...
-  def GLength(self) -> int: ...
-  def GIsNone(self) -> bool: ...
-  def H(self, i: int) -> typing.Literal[TestEnum.A, TestEnum.B, TestEnum.C]: ...
-  def HAsNumpy(self) -> np.ndarray: ...
-  def HLength(self) -> int: ...
-  def HIsNone(self) -> bool: ...
-class LargeArrayStructT(object):
-  d: typing.List[int]
-  e: typing.List[float]
-  f: typing.List[bool]
-  g: typing.List[NestedStructT]
-  h: typing.List[typing.Literal[TestEnum.A, TestEnum.B, TestEnum.C]]
-  def __init__(
-    self,
-    d: typing.List[int] | None = ...,
-    e: typing.List[float] | None = ...,
-    f: typing.List[bool] | None = ...,
-    g: typing.List['NestedStructT'] | None = ...,
-    h: typing.List[typing.Literal[TestEnum.A, TestEnum.B, TestEnum.C]] | None = ...,
-  ) -> None: ...
-  @classmethod
-  def InitFromBuf(cls, buf: bytes, pos: int) -> LargeArrayStructT: ...
-  @classmethod
-  def InitFromPackedBuf(cls, buf: bytes, pos: int = 0) -> LargeArrayStructT: ...
-  @classmethod
-  def InitFromObj(cls, largeArrayStruct: LargeArrayStruct) -> LargeArrayStructT: ...
-  def _UnPack(self, largeArrayStruct: LargeArrayStruct) -> None: ...
-  def Pack(self, builder: flatbuffers.Builder) -> None: ...
-
-def CreateLargeArrayStruct(builder: flatbuffers.Builder, d: int, e: float, f: bool, g_a: int, g_b: typing.Literal[TestEnum.A, TestEnum.B, TestEnum.C], g_c: typing.Literal[TestEnum.A, TestEnum.B, TestEnum.C], g_d: int, h: typing.Literal[TestEnum.A, TestEnum.B, TestEnum.C]) -> uoffset: ...
-
--- a/tests/MyGame/Example/LargeArrayStructT.java
+++ b/tests/MyGame/Example/LargeArrayStructT.java
@@ -1,57 +0,0 @@
-// automatically generated by the FlatBuffers compiler, do not modify
-
-package MyGame.Example;
-
-import com.google.flatbuffers.BaseVector;
-import com.google.flatbuffers.BooleanVector;
-import com.google.flatbuffers.ByteVector;
-import com.google.flatbuffers.Constants;
-import com.google.flatbuffers.DoubleVector;
-import com.google.flatbuffers.FlatBufferBuilder;
-import com.google.flatbuffers.FloatVector;
-import com.google.flatbuffers.IntVector;
-import com.google.flatbuffers.LongVector;
-import com.google.flatbuffers.ShortVector;
-import com.google.flatbuffers.StringVector;
-import com.google.flatbuffers.Struct;
-import com.google.flatbuffers.UnionVector;
-import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-
-public class LargeArrayStructT {
-  private int[] d;
-  private float[] e;
-  private boolean[] f;
-  private MyGame.Example.NestedStructT[] g;
-  private byte[] h;
-
-  public int[] getD() { return d; }
-
-  public void setD(int[] d) { if (d != null && d.length == 64) this.d = d; }
-
-  public float[] getE() { return e; }
-
-  public void setE(float[] e) { if (e != null && e.length == 64) this.e = e; }
-
-  public boolean[] getF() { return f; }
-
-  public void setF(boolean[] f) { if (f != null && f.length == 64) this.f = f; }
-
-  public MyGame.Example.NestedStructT[] getG() { return g; }
-
-  public void setG(MyGame.Example.NestedStructT[] g) { if (g != null && g.length == 64) this.g = g; }
-
-  public byte[] getH() { return h; }
-
-  public void setH(byte[] h) { if (h != null && h.length == 64) this.h = h; }
-
-
-  public LargeArrayStructT() {
-    this.d = new int[64];
-    this.e = new float[64];
-    this.f = new boolean[64];
-    this.g = new MyGame.Example.NestedStructT[64];
-    this.h = new byte[64];
-  }
-}
-
--- a/tests/MyGame/Example/Monster.lua
+++ b/tests/MyGame/Example/Monster.lua
@@ -28,8 +28,6 @@ function Monster.New()
  return o
 end

-local FileIdentifier = "MONS"
-
 function Monster.GetRootAsMonster(buf, offset)
  if type(buf) == "string" then
    buf = flatbuffers.binaryArray.New(buf)
@@ -1101,12 +1099,4 @@ function Monster.End(builder)
  return builder:EndObject()
 end

-function Monster.FinishMonsterBuffer(builder, offset)
-  builder:FinishWithIdentifier(offset, FileIdentifier)
-end
-
-function Monster.FinishSizePrefixedMonsterBuffer(builder, offset)
-  builder:FinishSizePrefixedWithIdentifier(offset, FileIdentifier)
-end
-
 return Monster
--- a/Show More
+++ b/Show More