FlatBuffers Version v24.3.6

2024-03-07 07:21:58 +00:00
1137 changed files with 47097 additions and 68447 deletions
--- a/.bazelci/presubmit.yml
+++ b/.bazelci/presubmit.yml
@@ -1,16 +1,25 @@
 ---
 buildifier: latest
-matrix:
-  bazel:
-    - 7.x
-    - 8.x
-tasks:
-  verify_ubuntu2004:
-    platform: ubuntu2004
-    bazel: ${{ bazel }}
+bazel: 6.4.0
+platforms:
+  ubuntu1804:
    environment:
      CC: clang
-      SWIFT_VERSION: "5.9"
+      SWIFT_VERSION: "5.5.3"
+      SWIFT_HOME: "$HOME/swift-$SWIFT_VERSION"
+      PATH: "$PATH:$SWIFT_HOME/usr/bin"
+    shell_commands:
+      - "echo --- Downloading and extracting Swift $SWIFT_VERSION to $SWIFT_HOME"
+      - "mkdir $SWIFT_HOME"
+      - "curl https://download.swift.org/swift-${SWIFT_VERSION}-release/ubuntu1804/swift-${SWIFT_VERSION}-RELEASE/swift-${SWIFT_VERSION}-RELEASE-ubuntu18.04.tar.gz | tar xvz --strip-components=1 -C $SWIFT_HOME"
+    build_targets:
+    - "//..."
+    test_targets:
+    - "//..."
+  ubuntu2004:
+    environment:
+      CC: clang
+      SWIFT_VERSION: "5.5.3"
      SWIFT_HOME: "$HOME/swift-$SWIFT_VERSION"
      PATH: "$PATH:$SWIFT_HOME/usr/bin"
    shell_commands:
@@ -21,40 +30,8 @@ tasks:
    - "//..."
    test_targets:
    - "//..."
-  verify_ubuntu2204:
-    platform: ubuntu2204
-    bazel: ${{ bazel }}
-    environment:
-      CC: clang
-      SWIFT_VERSION: "5.9"
-      SWIFT_HOME: "$HOME/swift-$SWIFT_VERSION"
-      PATH: "$PATH:$SWIFT_HOME/usr/bin"
-    shell_commands:
-      - "echo --- Downloading and extracting Swift $SWIFT_VERSION to $SWIFT_HOME"
-      - "mkdir $SWIFT_HOME"
-      - "curl https://download.swift.org/swift-${SWIFT_VERSION}-release/ubuntu2204/swift-${SWIFT_VERSION}-RELEASE/swift-${SWIFT_VERSION}-RELEASE-ubuntu22.04.tar.gz | tar xvz --strip-components=1 -C $SWIFT_HOME"
+  macos:
    build_targets:
    - "//..."
    test_targets:
    - "//..."
-  test_module_cpp:
-    platform: ubuntu2204
-    bazel: ${{ bazel }}
-    working_directory: tests/bazel_repository_test_dir
-    build_targets:
-    - "//..."
-  test_module_ts:
-    platform: ubuntu2204
-    bazel: ${{ bazel }}
-    working_directory: tests/ts/bazel_repository_test_dir
-    test_targets:
-    - "//..."
-  verify_macos:
-    platform: macos
-    bazel: ${{ bazel }}
-    xcode_version: "15.2"
-    build_targets:
-    - "//:flatbuffers"
-    - "//:flatc"
-    test_targets:
-    - "//tests:flatbuffers_test"
--- a/.bazelignore
+++ b/.bazelignore
@@ -1,5 +1 @@
-ts/node_modules
-
-# Test workspaces
-tests/bazel_repository_test_dir
-tests/ts/bazel_repository_test_dir
+node_modules
--- a/.bazelrc
+++ b/.bazelrc
@@ -1,18 +1,4 @@
 # We cannot use "common" here because the "version" command doesn't support
 # --deleted_packages. We need to specify it for both build and query instead.
-build --deleted_packages=tests/bazel_repository_test_dir,tests/ts/bazel_repository_test_dir
-query --deleted_packages=tests/bazel_repository_test_dir,tests/ts/bazel_repository_test_dir
-# Point tools such as coursier (used in rules_jvm_external) to Bazel's internal JDK
-# suggested in https://github.com/bazelbuild/rules_jvm_external/issues/445
-common --repo_env=JAVA_HOME=../bazel_tools/jdk
-common --action_env=JAVA_HOME=../bazel_tools/jdk
-# Workaround "Error: need --enable_runfiles on Windows for to support rules_js"
-common:windows --enable_runfiles
-# Swift is not required on Windows
-common:windows --deleted_packages=swift
-# Ignore warnings in external dependencies
-build --per_file_copt=external/.*@-Wno-everything --host_per_file_copt=external/.*@-Wno-everything
-# Honor the setting of `skipLibCheck` in the tsconfig.json file.
-common --@aspect_rules_ts//ts:skipLibCheck=honor_tsconfig
-# Use "tsc" as the transpiler when ts_project has no `transpiler` set.
-common --@aspect_rules_ts//ts:default_to_tsc_transpiler
+build --deleted_packages=tests/ts/bazel_repository_test_dir
+query --deleted_packages=tests/ts/bazel_repository_test_dir
--- a/.clang-format
+++ b/.clang-format
@@ -1,5 +1,13 @@
 ---
 Language: Cpp
 BasedOnStyle: Google
+DerivePointerAlignment: false
+PointerAlignment: Right
+IndentPPDirectives: AfterHash
+Cpp11BracedListStyle: false
+AlwaysBreakTemplateDeclarations: false
+AllowShortCaseLabelsOnASingleLine: true
+SpaceAfterTemplateKeyword: false
+AllowShortBlocksOnASingleLine: true
 ...

--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -0,0 +1,13 @@
+/* eslint-env node */
+
+module.exports = {
+    root: true,
+    parser: '@typescript-eslint/parser',
+    plugins: [
+        '@typescript-eslint',
+    ],
+    extends: [
+        'eslint:recommended',
+        'plugin:@typescript-eslint/recommended',
+    ]
+};
--- a/.github/ISSUE_TEMPLATE/404-doc.md
+++ b/.github/ISSUE_TEMPLATE/404-doc.md
@@ -1,11 +0,0 @@
---
-name: 404 Doc
-about: To fix broken documentation links
-title: "[Doc 404]"
-labels: documentation
-assignees: dbaileychess
-
---
-
-Target URL:
-[Optional] Source Site:
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -12,9 +12,6 @@ on:
  pull_request:
    branches:
      - master
-  schedule:
-    # Run daily at 4:45 A.M. to catch dependencies that break us.
-    - cron: '45 4 * * *'

 jobs:
  build-linux:
@@ -24,10 +21,10 @@ jobs:
      digests-gcc: ${{ steps.hash-gcc.outputs.hashes }}
      digests-clang: ${{ steps.hash-clang.outputs.hashes }}
    name: Build Linux
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04-64core
    strategy:
      matrix:
-        cxx: [g++-13, clang++-18]
+        cxx: [g++-13, clang++-15]
      fail-fast: false
    steps:
    - uses: actions/checkout@v3
@@ -42,7 +39,7 @@ jobs:
        chmod +x flatc
        ./flatc --version
    - name: upload build artifacts
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v1
      with:
        name: Linux flatc binary ${{ matrix.cxx }}
        path: flatc
@@ -56,7 +53,7 @@ jobs:
      with:
        files: Linux.flatc.binary.${{ matrix.cxx }}.zip
    - name: Generate SLSA subjects - clang
-      if: matrix.cxx == 'clang++-18' && startsWith(github.ref, 'refs/tags/')
+      if: matrix.cxx == 'clang++-15' && startsWith(github.ref, 'refs/tags/')
      id: hash-clang
      run: echo "hashes=$(sha256sum Linux.flatc.binary.${{ matrix.cxx }}.zip | base64 -w0)" >> $GITHUB_OUTPUT
    - name: Generate SLSA subjects - gcc
@@ -66,11 +63,11 @@ jobs:

  build-linux-no-file-tests:
    name: Build Linux with -DFLATBUFFERS_NO_FILE_TESTS
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04-64core
    steps:
    - uses: actions/checkout@v3
    - name: cmake
-      run: CXX=clang++-18 cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON -DFLATBUFFERS_CXX_FLAGS="-DFLATBUFFERS_NO_FILE_TESTS" .
+      run: CXX=clang++-15 cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON -DFLATBUFFERS_CXX_FLAGS="-DFLATBUFFERS_NO_FILE_TESTS" .
    - name: build
      run: make -j
    - name: test
@@ -78,7 +75,7 @@ jobs:

  build-linux-out-of-source:
    name: Build Linux with out-of-source build location
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04-64core
    steps:
    - uses: actions/checkout@v3
    - name: make build directory
@@ -86,7 +83,7 @@ jobs:
    - name: cmake
      working-directory: build
      run: >
-        CXX=clang++-18 cmake .. -G "Unix Makefiles" -DFLATBUFFERS_STRICT_MODE=ON
+        CXX=clang++-15 cmake .. -G "Unix Makefiles" -DFLATBUFFERS_STRICT_MODE=ON
        -DFLATBUFFERS_BUILD_CPP17=ON -DFLATBUFFERS_CPP_STD=17
    - name: build
      working-directory: build
@@ -100,15 +97,15 @@ jobs:

  build-linux-cpp-std:
    name: Build Linux C++
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04-64core
    strategy:
      fail-fast: false
      matrix:
        std: [11, 14, 17, 20, 23]
-        cxx: [g++-13, clang++-18]
+        cxx: [g++-13, clang++-15]
        exclude:
          # Clang++15 10.3.0 stdlibc++ doesn't fully support std 23
-          - cxx: clang++-18
+          - cxx: clang++-15
            std: 23

    steps:
@@ -129,7 +126,7 @@ jobs:

  build-cpp-std:
    name: Build Windows C++
-    runs-on: windows-2022
+    runs-on: windows-2019
    strategy:
      matrix:
        std: [11, 14, 17, 20, 23]
@@ -140,7 +137,7 @@ jobs:
      uses: microsoft/setup-msbuild@v1.1
    - name: cmake
      run: >
-        cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release
+        cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_BUILD_TYPE=Release
        -DFLATBUFFERS_STRICT_MODE=ON
        -DFLATBUFFERS_CPP_STD=${{ matrix.std }}
        -DFLATBUFFERS_BUILD_CPP17=${{ matrix.std >= 17 && 'On' || 'Off'}}
@@ -157,20 +154,20 @@ jobs:
      contents: write
    outputs:
      digests: ${{ steps.hash.outputs.hashes }}
-    name: Build Windows 2022
-    runs-on: windows-2022
+    name: Build Windows 2019
+    runs-on: windows-2019
    steps:
    - uses: actions/checkout@v3
    - name: Add msbuild to PATH
      uses: microsoft/setup-msbuild@v1.1
    - name: cmake
-      run: cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_CPP17=ON -DFLATBUFFERS_STRICT_MODE=ON .
+      run: cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_CPP17=ON -DFLATBUFFERS_STRICT_MODE=ON .
    - name: build
      run: msbuild.exe FlatBuffers.sln /p:Configuration=Release /p:Platform=x64
    - name: test
      run: Release\flattests.exe
    - name: upload build artifacts
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v1
      with:
        name: Windows flatc binary
        path: Release\flatc.exe
@@ -203,7 +200,7 @@ jobs:
    steps:
    - uses: actions/checkout@v3
    - name: Setup .NET Core SDK
-      uses: actions/setup-dotnet@v4.2.0
+      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: '8.0.x'
    - name: Build
@@ -211,16 +208,11 @@ jobs:
        cd tests\FlatBuffers.Test
        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
+        dotnet build -c Release ${{matrix.configuration}} -o out FlatBuffers.Test.sln
+    - name: Run
      run: |
-        cd tests\FlatBuffers.Test\bin\Release\net6.0
-        dir
-        .\FlatBuffers.Test.exe
-    - name: Run net8.0
-      run: |
-        cd tests\FlatBuffers.Test\bin\Release\net8.0
-        .\FlatBuffers.Test.exe
+        cd tests\FlatBuffers.Test
+        out\FlatBuffers.Test.exe

  build-mac-intel:
    permissions:
@@ -228,11 +220,11 @@ jobs:
    outputs:
      digests: ${{ steps.hash.outputs.hashes }}
    name: Build Mac (for Intel)
-    runs-on: macos-latest-large
+    runs-on: macos-latest
    steps:
    - uses: actions/checkout@v3
    - name: cmake
-      run: cmake -G "Xcode" -DCMAKE_OSX_ARCHITECTURES="x86_64" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON .
+      run: cmake -G "Xcode" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON .
    - name: build
      run: xcodebuild -toolchain clang -configuration Release -target flattests
    - name: check that the binary is x86_64
@@ -247,9 +239,9 @@ jobs:
        chmod +x Release/flatc
        Release/flatc --version
    - name: upload build artifacts
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v1
      with:
-        name: Mac flatc binary Intel
+        name: Mac flatc binary
        path: Release/flatc
    # Below if only for release.
    - name: Zip file
@@ -290,9 +282,9 @@ jobs:
        chmod +x Release/flatc
        Release/flatc --version
    - name: upload build artifacts
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v1
      with:
-        name: Mac flatc binary Universal
+        name: Mac flatc binary
        path: Release/flatc
    # Below if only for release.
    - name: Zip file
@@ -310,17 +302,14 @@ jobs:

  build-android:
   name: Build Android (on Linux)
-   if: false #disabled due to continual failure
-   runs-on: ubuntu-24.04
+   runs-on: ubuntu-22.04-64core
   steps:
   - uses: actions/checkout@v3
   - name: set up Java
-     uses: actions/setup-java@v4
+     uses: actions/setup-java@v3
     with:
-       distribution: temurin
-       java-version: 17
-   - name: set up Gradle
-     uses: gradle/actions/setup-gradle@v4
+       distribution: 'temurin'
+       java-version: '11'
   - name: set up flatc
     run: |
       cmake -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF -DFLATBUFFERS_STRICT_MODE=ON .
@@ -332,10 +321,10 @@ jobs:

  build-generator:
    name: Check Generated Code
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04-64core
    strategy:
      matrix:
-        cxx: [g++-13, clang++-18]
+        cxx: [g++-13, clang++-15]
    steps:
    - uses: actions/checkout@v3
    - name: cmake
@@ -347,13 +336,13 @@ jobs:

  build-generator-windows:
    name: Check Generated Code on Windows
-    runs-on: windows-2022
+    runs-on: windows-2019
    steps:
    - uses: actions/checkout@v3
    - name: Add msbuild to PATH
      uses: microsoft/setup-msbuild@v1.1
    - name: cmake
-      run: cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_CPP17=ON -DFLATBUFFERS_STRICT_MODE=ON .
+      run: cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_CPP17=ON -DFLATBUFFERS_STRICT_MODE=ON .
    - name: build
      run: msbuild.exe FlatBuffers.sln /p:Configuration=Release /p:Platform=x64
    - name: Generate
@@ -363,7 +352,7 @@ jobs:

  build-benchmarks:
    name: Build Benchmarks (on Linux)
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04-64core
    strategy:
      matrix:
        cxx: [g++-13]
@@ -374,14 +363,14 @@ 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@v4
+      uses: actions/upload-artifact@v1
      with:
        name: Linux flatbenchmark results ${{matrix.cxx}}
        path: benchmarks/results_${{matrix.cxx}}

  build-java:
    name: Build Java
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04-64core
    steps:
    - uses: actions/checkout@v3
    - name: test
@@ -390,24 +379,15 @@ jobs:

  build-kotlin-macos:
    name: Build Kotlin MacOS
-    runs-on: macos-13
+    runs-on: macos-latest
    steps:
    - name: Checkout
      uses: actions/checkout@v3
-      # Force Xcode 14.3 since Xcode 15 doesnt support older versions of
-      # kotlin. For Xcode 15, kotlin should be bumpped to 1.9.10
-      # https://stackoverflow.com/a/77150623
-      # For now, run with macos-13 which has this 14.3 installed:
-      # https://github.com/actions/runner-images/blob/main/images/macos/macos-13-Readme.md#xcode
-    - name: Set up Xcode version
-      run: sudo xcode-select -s /Applications/Xcode_14.3.app/Contents/Developer
-    - name: set up Java
-      uses: actions/setup-java@v4
+    - uses: gradle/wrapper-validation-action@v1.0.5
+    - uses: actions/setup-java@v3
      with:
-        distribution: temurin
-        java-version: 17
-    - name: set up Gradle
-      uses: gradle/actions/setup-gradle@v4
+        distribution: 'temurin'
+        java-version: '11'
    - name: Build flatc
      run: |
       cmake -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF .
@@ -419,18 +399,15 @@ jobs:

  build-kotlin-linux:
    name: Build Kotlin Linux
-    if: false #disabled due to continual failure
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04-64core
    steps:
    - name: Checkout
      uses: actions/checkout@v3
-    - name: set up Java
-      uses: actions/setup-java@v4
+    - uses: actions/setup-java@v3
      with:
-        distribution: temurin
-        java-version: 17
-    - name: set up Gradle
-      uses: gradle/actions/setup-gradle@v4
+        distribution: 'temurin'
+        java-version: '11'
+    - uses: gradle/wrapper-validation-action@v1.0.5
    - name: Build flatc
      run: |
       cmake -DFLATBUFFERS_BUILD_TESTS=OFF -DFLATBUFFERS_BUILD_FLATLIB=OFF -DFLATBUFFERS_BUILD_FLATHASH=OFF .
@@ -445,7 +422,7 @@ jobs:

  build-rust-linux:
    name: Build Rust Linux
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04-64core
    steps:
    - uses: actions/checkout@v3
    - name: test
@@ -463,7 +440,7 @@ jobs:

  build-python:
    name: Build Python
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04-64core
    steps:
    - uses: actions/checkout@v3
    - name: flatc
@@ -475,7 +452,7 @@ jobs:

  build-go:
    name: Build Go
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04-64core
    steps:
    - uses: actions/checkout@v3
    - name: flatc
@@ -487,7 +464,7 @@ jobs:

  build-php:
   name: Build PHP
-   runs-on: ubuntu-24.04
+   runs-on: ubuntu-22.04-64core
   steps:
   - uses: actions/checkout@v3
   - name: flatc
@@ -500,72 +477,50 @@ jobs:
       sh phpUnionVectorTest.sh

  build-swift:
-    name: Test Swift
-    strategy:
-      matrix:
-        swift: ["5.9", "5.10", "6.1"]
-    # Only 22.04 has swift at the moment https://github.com/actions/runner-images/blob/main/images/ubuntu/Ubuntu2204-Readme.md?plain=1#L30
-    runs-on: ubuntu-22.04
+    name: Build Swift
+    runs-on: ubuntu-22.04-64core
    steps:
    - uses: actions/checkout@v3
-    - uses: vapor/swiftly-action@v0.2
-      with:
-        toolchain: ${{ matrix.swift }}
-    - name: Get swift version
-      run: swift --version
    - name: test
+      working-directory: tests/swift/tests
      run: |
        swift build --build-tests
        swift test

-  build-swift-windows:
-    name: Test swift windows
-    runs-on: windows-latest
+  build-swift-wasm:
+    name: Build Swift Wasm
+    runs-on: ubuntu-22.04-64core
+    container:
+      image: ghcr.io/swiftwasm/carton:0.15.3
    steps:
      - uses: actions/checkout@v3
-      - uses: SwiftyLab/setup-swift@latest
-        with:
-          swift-version: '6.1'
-      - run: swift build
-      - run: swift test
-
-  build-swift-wasm:
-    name: Test Swift Wasm
-    runs-on: ubuntu-24.04
-    container:
-      image: ghcr.io/swiftwasm/carton:0.20.1
-    steps:
-       - uses: actions/checkout@v3
-       - uses: bytecodealliance/actions/wasmtime/setup@v1
-       - uses: swiftwasm/setup-swiftwasm@v1
-         with:
-           swift-version: "wasm-6.0.2-RELEASE"
-       - name: Test
-         working-directory: tests/swift/Wasm.tests
-         run: swift run carton test
+      - name: Setup Wasmer
+        uses: wasmerio/setup-wasmer@v2
+      - name: Test
+        working-directory: tests/swift/Wasm.tests
+        run: carton test

  build-ts:
    name: Build TS
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04-64core
    steps:
    - uses: actions/checkout@v3
    - name: flatc
      # 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 esbuild
    - name: deps
-      run: pnpm i
+      run: yarn
    - name: compile
-      run: pnpm compile
+      run: yarn compile
    - name: test
      working-directory: tests/ts
      run: |
+        yarn global add esbuild
        python3 TypeScriptTest.py

  build-dart:
    name: Build Dart
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04-64core
    steps:
      - uses: actions/checkout@v3
      - uses: dart-lang/setup-dart@v1
@@ -580,7 +535,7 @@ jobs:

  build-nim:
    name: Build Nim
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04-64core
    steps:
    - uses: actions/checkout@v3
    - name: flatc
@@ -594,27 +549,12 @@ jobs:
      working-directory: tests/nim
      run: python3 testnim.py

-  bazel:
-    name: Bazel
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v3
-      - name: bazel build
-        run: >
-          bazel build
-          //:flatc
-          //:flatbuffers
-      - name: bazel test
-        run: >
-          bazel test
-          //tests:flatbuffers_test
-
  release-digests:
    if: startsWith(github.ref, 'refs/tags/')
    needs: [build-linux, build-windows, build-mac-intel, build-mac-universal]
    outputs:
      digests: ${{ steps.hash.outputs.digests }}
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-22.04-64core
    steps:
      - name: Merge results
        id: hash
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -0,0 +1,71 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+permissions: read-all
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '16 20 * * 0'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'cpp' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://git.io/codeql-language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    # - name: Autobuild
+    #  uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    - run: |
+       cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_STRICT_MODE=ON .
+       make -j       
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -1,36 +0,0 @@
-name: docs
-on:
-  # For manual pushes.
-  workflow_dispatch: 
-
-  # Pushes to main that touch the documentation directory.
-  push:
-    branches:
-      - master
-    paths:
-      - 'docs/**'
-
-permissions:
-  contents: write
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Configure Git Credentials
-        run: |
-          git config user.name github-actions[bot]
-          git config user.email 41898282+github-actions[bot]@users.noreply.github.com
-      - uses: actions/setup-python@v5
-        with:
-          python-version: 3.x
-      - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV 
-      - uses: actions/cache@v4
-        with:
-          key: mkdocs-material-${{ env.cache_id }}
-          path: .cache
-          restore-keys: |
-            mkdocs-material-
-      - run: pip install mkdocs-material 
-      - run: pip install mkdocs-redirects
-      - run: mkdocs gh-deploy --force -f docs/mkdocs.yml
--- a/.github/workflows/extrabuild.yml
+++ b/.github/workflows/extrabuild.yml
@@ -0,0 +1,35 @@
+name: Build and unit tests that are more time consuming
+permissions: read-all
+
+on:
+  # For manual tests.
+  workflow_dispatch:
+  pull_request:
+    types:
+      - closed
+  schedule:
+  - cron: "30 20 * * *"
+
+jobs:
+  build-linux-s390x:
+    name: Build Linux on s390x arch and run unit tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: uraimo/run-on-arch-action@v2
+        name: Run commands
+        id: runcmd
+        with:
+          arch: s390x
+          distro: ubuntu_latest
+          install: |
+            apt-get update -q -y
+            apt-get -y install cmake
+            apt-get -y install make
+            apt-get -y install g++
+          run: |
+            lscpu | grep Endian
+            cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release
+            make -j
+            ./flattests
+
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -1,7 +1,7 @@
 name: OSS-Fuzz
 permissions: read-all

-on:
+on: 
  pull_request:
    branches:
      - master
@@ -27,7 +27,7 @@ jobs:
       language: c++
       fuzz-seconds: 60
   - name: Upload Crash
-     uses: actions/upload-artifact@v4
+     uses: actions/upload-artifact@v1
     if: failure() && steps.build.outcome == 'success'
     with:
       name: artifacts
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -5,7 +5,7 @@ on:
  # For manual tests.
  workflow_dispatch:
  release:
-    types: [published]
+    types: [created]

 jobs:
  publish-npm:
@@ -97,56 +97,9 @@ jobs:
      - name: Publish Maven
        run: mvn --batch-mode clean deploy
        env:
-          OSSRH_USERNAME: ${{ secrets.OSSRH_USER_V2 }}
-          OSSRH_PASSWORD: ${{ secrets.OSSRH_TOKEN_V2 }}
-          MAVEN_GPG_PASSPHRASE: ${{ secrets.MAVEN_GPG_PASSPHRASE }}
-          
-  publish-maven-kotlin:
-    name: Publish Maven - Kotlin
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./kotlin
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up Maven Central Repository
-        uses: actions/setup-java@v3
-        with:
-          java-version: '11'
-          distribution: 'adopt'
-          cache: 'maven'
-          server-id: ossrh
-          server-username: OSSRH_USERNAME
-          server-password: OSSRH_PASSWORD
-          gpg-private-key: ${{ secrets.MAVEN_GPG_PRIVATE_KEY }}
-          gpg-passphrase: MAVEN_GPG_PASSPHRASE # this needs to be an env var
-
-      - name: Publish Kotlin Library on Maven
-        run: ./gradlew publishAllPublicationsToSonatypeRepository
-        env:
-          OSSRH_USERNAME: ${{ secrets.OSSRH_USER_V2 }}
-          OSSRH_PASSWORD: ${{ secrets.OSSRH_TOKEN_V2 }}
+          OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }}
+          OSSRH_PASSWORD: ${{ secrets.OSSRH_TOKEN }}
          MAVEN_GPG_PASSPHRASE: ${{ secrets.MAVEN_GPG_PASSPHRASE }}


-  publish-crates:
-    name: Publish crates.io
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
-          
-      - name: Publish Flatbuffers
-        uses: katyo/publish-crates@v2
-        with:
-          path: ./rust/flatbuffers
-          registry-token: ${{ secrets.CARGO_TOKEN }}

-      - name: Publish Flexbuffers
-        uses: katyo/publish-crates@v2
-        with:
-          path: ./rust/flexbuffers
-          registry-token: ${{ secrets.CARGO_TOKEN }}
--- a/.github/workflows/scorecards.yml
+++ b/.github/workflows/scorecards.yml
@@ -0,0 +1,55 @@
+name: Scorecards supply-chain security
+on:
+  # Only the default branch is supported.
+  branch_protection_rule:
+  schedule:
+    - cron: '21 2 * * 5'
+  push:
+    branches: [ master ]
+
+# Declare default permissions as read only.
+permissions: read-all
+
+jobs:
+  analysis:
+    name: Scorecards analysis
+    runs-on: ubuntu-latest
+    permissions:
+      # Needed to upload the results to code-scanning dashboard.
+      security-events: write
+      actions: read
+      contents: read
+
+    steps:
+      - name: "Checkout code"
+        uses: actions/checkout@a12a3943b4bdde767164f792f33f40b04645d846 # v3.0.0
+        with:
+          persist-credentials: false
+
+      - name: "Run analysis"
+        uses: ossf/scorecard-action@ce330fde6b1a5c9c75b417e7efc510b822a35564 # v1.1.2
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          # Read-only PAT token. To create it,
+          # follow the steps in https://github.com/ossf/scorecard-action#pat-token-creation.
+          repo_token: ${{ secrets.SCORECARD_READ_TOKEN }}
+          # Publish the results to enable scorecard badges. For more details, see
+          # https://github.com/ossf/scorecard-action#publishing-results.
+          # For private repositories, `publish_results` will automatically be set to `false`,
+          # regardless of the value entered here.
+          publish_results: true
+
+      # Upload the results as artifacts (optional).
+      - name: "Upload artifact"
+        uses: actions/upload-artifact@6673cd052c4cd6fcf4b4e6e60ea986c889389535 # v3.0.0
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      # Upload the results to GitHub's code scanning dashboard.
+      - name: "Upload to code-scanning"
+        uses: github/codeql-action/upload-sarif@5f532563584d71fdef14ee64d17bafb34f751ce5 # v1.0.26
+        with:
+          sarif_file: results.sarif
--- a/.gitignore
+++ b/.gitignore
@@ -153,7 +153,3 @@ cmake-build-debug/
 _deps/
 **/.gradle/**
 kotlin/**/generated
-MODULE.bazel.lock
-
-# Ignore the generated docs
-docs/site
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -1,3 +1,5 @@
+load("@aspect_rules_js//npm:defs.bzl", "npm_link_package")
+load("@npm//:defs.bzl", "npm_link_all_packages")
 load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library")

 licenses(["notice"])
@@ -6,6 +8,13 @@ package(
    default_visibility = ["//visibility:public"],
 )

+npm_link_all_packages(name = "node_modules")
+
+npm_link_package(
+    name = "node_modules/flatbuffers",
+    src = "//ts:flatbuffers",
+)
+
 exports_files([
    "LICENSE",
    "tsconfig.json",
@@ -28,16 +37,11 @@ config_setting(
 filegroup(
    name = "distribution",
    srcs = [
-        ".bazelignore",
-        ".npmrc",
        "BUILD.bazel",
-        "MODULE.bazel",
+        "WORKSPACE",
        "build_defs.bzl",
-        "package.json",
-        "pnpm-lock.yaml",
        "typescript.bzl",
        "//grpc/src/compiler:distribution",
-        "//include/codegen:distribution",
        "//reflection:distribution",
        "//src:distribution",
        "//ts:distribution",
@@ -121,7 +125,15 @@ filegroup(
 # Library used by flatbuffer_cc_library rules.
 cc_library(
    name = "runtime_cc",
-    hdrs = ["//:public_headers"],
+    hdrs = [
+        "include/flatbuffers/base.h",
+        "include/flatbuffers/flatbuffers.h",
+        "include/flatbuffers/flexbuffers.h",
+        "include/flatbuffers/stl_emulation.h",
+        "include/flatbuffers/util.h",
+        "include/flatbuffers/vector.h",
+        "include/flatbuffers/verifier.h",
+    ],
    linkstatic = 1,
    strip_include_prefix = "/include",
 )
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,39 +4,7 @@ All major or breaking changes will be documented in this file, as well as any
 new features that should be highlighted. Minor fixes or improvements are not
 necessarily listed.

-## [25.9.23] (September 23 2025)(https://github.com/google/flatbuffers/releases/tag/v25.9.23)
-
-* flatc: `--grpc-callback-api` flag generates C++ gRPC Callback API server `CallbackService` skeletons AND client native callback/async stubs (unary + all streaming reactor forms) (opt-in, non-breaking, issue #8596).
-* Swift - Adds new API to reduce memory copying within swift (#8484)
-* Rust - Support Rust edition 2024 (#8638)
-# [:C++] - Use the Google Style for clang-format without exceptions (#8706)
-
-## [25.2.10] (February 10 2025)(https://github.com/google/flatbuffers/releases/tag/v25.2.10)
-
-* Removed the old documentation pages. The new one is live at https://flatbuffers.dev
-* Swift version 6.0 support (#8414)
-
-## [25.1.24] (January 24 2025)(https://github.com/google/flatbuffers/releases/tag/v25.1.24)
-
-* Mostly related to bazel build support.
-* Min bazel supported is now 7 or higher, as WORKSPACE files are removed (#8509)
-* Minor C++ codegen fix removing extra semicolon (#8488)
-
-## [25.1.21] (January 21 2025)(https://github.com/google/flatbuffers/releases/tag/v25.1.21)
-
-* Rust Full Reflection (#8102)
-* Mostly documentation updates hosted at https://flatbuffers.dev
-
-## [24.3.25] (March 25 2024)(https://github.com/google/flatbuffers/releases/tag/v24.3.25)
-
-* Fixed license metadata parsing (#8253)
-* [C++] Allow string_view in `LookUpByKey` in addition to null-terminated c-style strings (#8203)
-
-## [24.3.7] (March 7 2024)(https://github.com/google/flatbuffers/releases/tag/v24.3.7)
-
-* Just to fix some of the CI build issues from the 24.3.6 release.
-
-## [24.3.6] (March 6 2024)(https://github.com/google/flatbuffers/releases/tag/v24.3.6)
+## [24.3.6] (March 24 2024)(https://github.com/google/flatbuffers/releases/tag/v24.3.6)

 * Fix typescript object API to allow 0 values for null-default scalars (#7864)

--- a/CMake/Version.cmake
+++ b/CMake/Version.cmake
@@ -1,6 +1,6 @@
-set(VERSION_MAJOR 25)
-set(VERSION_MINOR 9)
-set(VERSION_PATCH 23)
+set(VERSION_MAJOR 24)
+set(VERSION_MINOR 3)
+set(VERSION_PATCH 6)
 set(VERSION_COMMIT 0)

 if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git")
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -112,7 +112,6 @@ endif()
 add_definitions(-DFLATBUFFERS_LOCALE_INDEPENDENT=$<BOOL:${FLATBUFFERS_LOCALE_INDEPENDENT}>)

 if(NOT WIN32)
-  include(CheckSymbolExists)
  check_symbol_exists(realpath "stdlib.h" HAVE_REALPATH)
  if(NOT HAVE_REALPATH)
    add_definitions(-DFLATBUFFERS_NO_ABSOLUTE_PATH_RESOLUTION)
@@ -184,10 +183,6 @@ set(FlatBuffers_Compiler_SRCS
  src/bfbs_gen_lua.h
  src/bfbs_gen_nim.h
  src/bfbs_namer.h
-  include/codegen/idl_namer.h
-  include/codegen/namer.h
-  include/codegen/python.h
-  include/codegen/python.cc
  include/flatbuffers/code_generators.h
  src/binary_annotator.h
  src/binary_annotator.cpp
@@ -279,8 +274,6 @@ set(FlatBuffers_GRPCTest_SRCS
  tests/test_builder.cpp
  grpc/tests/grpctest.cpp
  grpc/tests/message_builder_test.cpp
-  grpc/tests/grpctest_callback_compile.cpp
-  grpc/tests/grpctest_callback_client_compile.cpp
 )

 # TODO(dbaileychess): Figure out how this would now work. I posted a question on
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -40,26 +40,3 @@ Some tips for good pull requests:
 # The small print
 Contributions made by corporations are covered by a different agreement than
 the one above, the Software Grant and Corporate Contributor License Agreement.
-
-# Code
-
-TL/DR
-
-See [how to build flatc](https://flatbuffers.dev/building/).
-
-When making changes, build `flatc` and then re-generate the goldens files to see the effect of your changes:
-
-```
-$ cp build/flatc .
-$ goldens/generate_goldens.py
-```
-
-Re-generate other code files to see the effects of the changes:
-
-```
-$ scripts/generate_code.py
-```
-
-Run tests with [TestAll.sh](tests/TestAll.sh) in [tests](tests), or directly any of the sub-scripts run by it.
-
-[Format the code](Formatters.md) before submitting a PR.
--- a/FlatBuffers.podspec
+++ b/FlatBuffers.podspec
@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
  s.name             = 'FlatBuffers'
-  s.version          = '25.9.23'
+  s.version          = '24.3.6'
  s.summary          = 'FlatBuffers: Memory Efficient Serialization Library'

  s.description      = "FlatBuffers is a cross platform serialization library architected for
@@ -10,15 +10,12 @@ Pod::Spec.new do |s|

  s.homepage         = 'https://github.com/google/flatbuffers'
  s.license          = { :type => 'Apache2.0', :file => 'LICENSE' }
-  s.author           = { 'mustii' => 'me@mustiikhalil.se' }
-  s.source           = { :git => 'https://github.com/google/flatbuffers.git', :tag => "v" + s.version.to_s, :submodules => true }
+  s.author           = { 'mustii' => 'mustii@mmk.one' }
+  s.source           = { :git => 'https://github.com/google/flatbuffers.git', :tag => s.version.to_s, :submodules => true }

  s.ios.deployment_target = '11.0'
  s.osx.deployment_target = '10.14'

  s.swift_version = '5.0'
  s.source_files = 'swift/Sources/Flatbuffers/*.swift'
-  s.pod_target_xcconfig = {
-    'BUILD_LIBRARY_FOR_DISTRIBUTION' => 'YES'
-  }
 end
--- a/MODULE.bazel
+++ b/MODULE.bazel
@@ -1,77 +0,0 @@
-module(
-    name = "flatbuffers",
-    version = "25.9.23",
-    compatibility_level = 1,
-    repo_name = "com_github_google_flatbuffers",
-)
-
-bazel_dep(
-    name = "aspect_bazel_lib",
-    version = "2.11.0",
-)
-bazel_dep(
-    name = "aspect_rules_esbuild",
-    version = "0.21.0",
-)
-bazel_dep(
-    name = "aspect_rules_js",
-    version = "2.3.8",
-)
-bazel_dep(
-    name = "aspect_rules_ts",
-    version = "3.6.0",
-)
-bazel_dep(
-    name = "grpc",
-    version = "1.70.1",
-    repo_name = "com_github_grpc_grpc",
-)
-bazel_dep(
-    name = "platforms",
-    version = "0.0.10",
-)
-bazel_dep(
-    name = "rules_cc",
-    version = "0.0.16",
-)
-bazel_dep(
-    name = "rules_go",
-    version = "0.50.1",
-    repo_name = "io_bazel_rules_go",
-)
-bazel_dep(
-    name = "rules_nodejs",
-    version = "6.3.3",
-)
-bazel_dep(
-    name = "rules_shell",
-    version = "0.3.0",
-)
-bazel_dep(
-    name = "rules_swift",
-    version = "2.1.1",
-    repo_name = "build_bazel_rules_swift",
-)
-bazel_dep(
-    name = "bazel_skylib",
-    version = "1.7.1",
-)
-
-npm = use_extension("@aspect_rules_js//npm:extensions.bzl", "npm")
-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")
-
-node = use_extension("@rules_nodejs//nodejs:extensions.bzl", "node")
-use_repo(node, "nodejs_linux_amd64")
-
-rules_ts_ext = use_extension("@aspect_rules_ts//ts:extensions.bzl", "ext")
-rules_ts_ext.deps()
-use_repo(rules_ts_ext, "npm_typescript")
--- a/Package.swift
+++ b/Package.swift
@@ -1,4 +1,4 @@
-// swift-tools-version:5.9
+// swift-tools-version:5.6
 /*
 * Copyright 2020 Google Inc. All rights reserved.
 *
@@ -20,61 +20,17 @@ import PackageDescription
 let package = Package(
  name: "FlatBuffers",
  platforms: [
-    .iOS(.v12),
+    .iOS(.v11),
    .macOS(.v10_14),
  ],
  products: [
    .library(
      name: "FlatBuffers",
      targets: ["FlatBuffers"]),
-    .library(
-      name: "FlexBuffers",
-      targets: ["FlexBuffers"]),
  ],
-  dependencies: .dependencies,
  targets: [
    .target(
      name: "FlatBuffers",
-      dependencies: ["Common"],
-      path: "swift/Sources/FlatBuffers"),
-    .target(
-      name: "FlexBuffers",
-      dependencies: ["Common"],
-      path: "swift/Sources/FlexBuffers"),
-    .target(
-      name: "Common",
-      path: "swift/Sources/Common"),
-    .testTarget(
-      name: "FlatbuffersTests",
-      dependencies: .dependencies,
-      path: "tests/swift/Tests/Flatbuffers"),
-    .testTarget(
-      name: "FlexbuffersTests",
-      dependencies: ["FlexBuffers"],
-      path: "tests/swift/Tests/Flexbuffers"),
+      dependencies: [],
+      path: "swift/Sources"),
  ])
-
-extension Array where Element == Package.Dependency {
-  static var dependencies: [Package.Dependency] {
-    #if os(Windows)
-      []
-    #else
-      // Test only Dependency
-      [.package(url: "https://github.com/grpc/grpc-swift.git", from: "1.4.1")]
-    #endif
-  }
-}
-
-extension Array where Element == PackageDescription.Target.Dependency {
-  static var dependencies: [PackageDescription.Target.Dependency] {
-    #if os(Windows)
-      ["FlatBuffers"]
-    #else
-      // Test only Dependency
-      [
-        .product(name: "GRPC", package: "grpc-swift"),
-        "FlatBuffers",
-      ]
-    #endif
-  }
-}
--- a/tests/swift/fuzzer/Package.swift
+++ b/tests/swift/fuzzer/Package.swift
@@ -1,4 +1,4 @@
-// swift-tools-version:5.9
+// swift-tools-version:5.5
 /*
 * Copyright 2020 Google Inc. All rights reserved.
 *
@@ -18,18 +18,20 @@
 import PackageDescription

 let package = Package(
-  name: "fuzzer",
+  name: "FlatBuffers",
  platforms: [
-    .iOS(.v12),
+    .iOS(.v11),
    .macOS(.v10_14),
  ],
-  dependencies: [
-    .package(path: "../../..")
+  products: [
+    .library(
+      name: "FlatBuffers",
+      targets: ["FlatBuffers"]),
  ],
  targets: [
-    .executableTarget(
-      name: "fuzzer",
-      dependencies: [
-        .product(name: "FlatBuffers", package: "flatbuffers")
-      ])
+    .target(
+      name: "FlatBuffers",
+      dependencies: [],
+      path: "swift/Sources"),
  ])
+
--- a/README.md
+++ b/README.md
@@ -1,9 +1,11 @@
-![logo](https://flatbuffers.dev/assets/flatbuffers_logo.svg) FlatBuffers
+![logo](http://google.github.io/flatbuffers/fpl_logo_small.png) FlatBuffers
 ===========

 ![Build status](https://github.com/google/flatbuffers/actions/workflows/build.yml/badge.svg?branch=master)
 [![BuildKite status](https://badge.buildkite.com/7979d93bc6279aa539971f271253c65d5e8fe2fe43c90bbb25.svg)](https://buildkite.com/bazel/flatbuffers)
 [![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/flatbuffers.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:flatbuffers)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/google/flatbuffers/badge)](https://api.securityscorecards.dev/projects/github.com/google/flatbuffers)
+[![Join the chat at https://gitter.im/google/flatbuffers](https://badges.gitter.im/google/flatbuffers.svg)](https://gitter.im/google/flatbuffers?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![Discord Chat](https://img.shields.io/discord/656202785926152206.svg)](https:///discord.gg/6qgKs3R)
 [![Twitter Follow](https://img.shields.io/twitter/follow/wvo.svg?style=social)](https://twitter.com/wvo)
 [![Twitter Follow](https://img.shields.io/twitter/follow/dbaileychess.svg?style=social)](https://twitter.com/dbaileychess)
@@ -16,7 +18,7 @@ maximum memory efficiency. It allows you to directly access serialized data with

 1. Build the compiler for flatbuffers (`flatc`)

-    Use `cmake` to create the build files for your platform and then perform the compilation (Linux example).
+    Use `cmake` to create the build files for your platform and then perform the compliation (Linux example).

    ```
    cmake -G "Unix Makefiles"
--- a/169
+++ b/169
@@ -0,0 +1,169 @@
+workspace(name = "com_github_google_flatbuffers")
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive", "http_file")
+
+http_archive(
+    name = "platforms",
+    sha256 = "3a561c99e7bdbe9173aa653fd579fe849f1d8d67395780ab4770b1f381431d51",
+    urls = [
+        "https://mirror.bazel.build/github.com/bazelbuild/platforms/releases/download/0.0.7/platforms-0.0.7.tar.gz",
+        "https://github.com/bazelbuild/platforms/releases/download/0.0.7/platforms-0.0.7.tar.gz",
+    ],
+)
+
+http_archive(
+    name = "build_bazel_rules_apple",
+    sha256 = "34c41bfb59cdaea29ac2df5a2fa79e5add609c71bb303b2ebb10985f93fa20e7",
+    url = "https://github.com/bazelbuild/rules_apple/releases/download/3.1.1/rules_apple.3.1.1.tar.gz",
+)
+
+load(
+    "@build_bazel_rules_apple//apple:repositories.bzl",
+    "apple_rules_dependencies",
+)
+
+apple_rules_dependencies()
+
+http_archive(
+    name = "build_bazel_rules_swift",
+    sha256 = "a2fd565e527f83fb3f9eb07eb9737240e668c9242d3bc318712efa54a7deda97",
+    url = "https://github.com/bazelbuild/rules_swift/releases/download/0.27.0/rules_swift.0.27.0.tar.gz",
+)
+
+load(
+    "@build_bazel_rules_swift//swift:repositories.bzl",
+    "swift_rules_dependencies",
+)
+
+swift_rules_dependencies()
+
+load(
+    "@build_bazel_rules_swift//swift:extras.bzl",
+    "swift_rules_extra_dependencies",
+)
+
+swift_rules_extra_dependencies()
+
+http_archive(
+    name = "io_bazel_rules_go",
+    sha256 = "278b7ff5a826f3dc10f04feaf0b70d48b68748ccd512d7f98bf442077f043fe3",
+    urls = [
+        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.41.0/rules_go-v0.41.0.zip",
+        "https://github.com/bazelbuild/rules_go/releases/download/v0.41.0/rules_go-v0.41.0.zip",
+    ],
+)
+
+load("@io_bazel_rules_go//go:deps.bzl", "go_rules_dependencies")
+
+go_rules_dependencies()
+
+##### Protobuf
+_PROTOBUF_VERSION = "3.15.2"
+
+http_archive(
+    name = "com_google_protobuf",
+    strip_prefix = "protobuf-" + _PROTOBUF_VERSION,
+    urls = [
+        "https://github.com/protocolbuffers/protobuf/archive/v" + _PROTOBUF_VERSION + ".tar.gz",
+    ],
+)
+
+##### GRPC
+_GRPC_VERSION = "1.49.0"  # https://github.com/grpc/grpc/releases/tag/v1.48.0
+
+http_archive(
+    name = "com_github_grpc_grpc",
+    patch_args = ["-p1"],
+    patches = ["//grpc:build_grpc_with_cxx14.patch"],
+    sha256 = "15715e1847cc9e42014f02c727dbcb48e39dbdb90f79ad3d66fe4361709ff935",
+    strip_prefix = "grpc-" + _GRPC_VERSION,
+    urls = ["https://github.com/grpc/grpc/archive/refs/tags/v" + _GRPC_VERSION + ".tar.gz"],
+)
+
+load("@com_github_grpc_grpc//bazel:grpc_deps.bzl", "grpc_deps")
+
+grpc_deps()
+
+load("@com_github_grpc_grpc//bazel:grpc_extra_deps.bzl", "grpc_extra_deps")
+
+grpc_extra_deps()
+
+# rules_go from https://github.com/bazelbuild/rules_go/releases/tag/v0.34.0
+
+http_archive(
+    name = "aspect_rules_js",
+    sha256 = "76a04ef2120ee00231d85d1ff012ede23963733339ad8db81f590791a031f643",
+    strip_prefix = "rules_js-1.34.1",
+    url = "https://github.com/aspect-build/rules_js/releases/download/v1.34.1/rules_js-v1.34.1.tar.gz",
+)
+
+load("@aspect_rules_js//js:repositories.bzl", "rules_js_dependencies")
+
+rules_js_dependencies()
+
+load("@aspect_rules_js//npm:npm_import.bzl", "npm_translate_lock", "pnpm_repository")
+
+pnpm_repository(name = "pnpm")
+
+http_archive(
+    name = "aspect_rules_ts",
+    sha256 = "4c3f34fff9f96ffc9c26635d8235a32a23a6797324486c7d23c1dfa477e8b451",
+    strip_prefix = "rules_ts-1.4.5",
+    url = "https://github.com/aspect-build/rules_ts/releases/download/v1.4.5/rules_ts-v1.4.5.tar.gz",
+)
+
+load("@aspect_rules_ts//ts:repositories.bzl", "rules_ts_dependencies")
+
+rules_ts_dependencies(
+    # Since rules_ts doesn't always have the newest integrity hashes, we
+    # compute it manually here.
+    #   $ curl --silent https://registry.npmjs.org/typescript/5.3.3 | jq ._integrity
+    ts_integrity = "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==",
+    ts_version_from = "//:package.json",
+)
+
+load("@rules_nodejs//nodejs:repositories.bzl", "DEFAULT_NODE_VERSION", "nodejs_register_toolchains")
+
+nodejs_register_toolchains(
+    name = "nodejs",
+    node_version = DEFAULT_NODE_VERSION,
+)
+
+npm_translate_lock(
+    name = "npm",
+    npmrc = "//:.npmrc",
+    pnpm_lock = "//:pnpm-lock.yaml",
+    # Set this to True when the lock file needs to be updated, commit the
+    # changes, then set to False again.
+    update_pnpm_lock = False,
+    verify_node_modules_ignored = "//:.bazelignore",
+)
+
+load("@npm//:repositories.bzl", "npm_repositories")
+
+npm_repositories()
+
+http_archive(
+    name = "aspect_rules_esbuild",
+    sha256 = "098e38e5ee868c14a6484ba263b79e57d48afacfc361ba30137c757a9c4716d6",
+    strip_prefix = "rules_esbuild-0.15.0",
+    url = "https://github.com/aspect-build/rules_esbuild/releases/download/v0.15.0/rules_esbuild-v0.15.0.tar.gz",
+)
+
+# Register a toolchain containing esbuild npm package and native bindings
+load("@aspect_rules_esbuild//esbuild:repositories.bzl", "LATEST_ESBUILD_VERSION", "esbuild_register_toolchains")
+
+esbuild_register_toolchains(
+    name = "esbuild",
+    esbuild_version = LATEST_ESBUILD_VERSION,
+)
+
+http_file(
+    name = "bazel_linux_x86_64",
+    downloaded_file_path = "bazel",
+    executable = True,
+    sha256 = "e78fc3394deae5408d6f49a15c7b1e615901969ecf6e50d55ef899996b0b8458",
+    urls = [
+        "https://github.com/bazelbuild/bazel/releases/download/6.3.2/bazel-6.3.2-linux-x86_64",
+    ],
+)
--- a/android/app/src/main/cpp/generated/animal_generated.h
+++ b/android/app/src/main/cpp/generated/animal_generated.h
@@ -1,5 +1,6 @@
 // automatically generated by the FlatBuffers compiler, do not modify

+
 #ifndef FLATBUFFERS_GENERATED_ANIMAL_COM_FBS_APP_H_
 #define FLATBUFFERS_GENERATED_ANIMAL_COM_FBS_APP_H_

@@ -7,10 +8,10 @@

 // 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 == 24 &&
-                  FLATBUFFERS_VERSION_MINOR == 12 &&
-                  FLATBUFFERS_VERSION_REVISION == 23,
-              "Non-compatible flatbuffers version included");
+static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
+              FLATBUFFERS_VERSION_MINOR == 1 &&
+              FLATBUFFERS_VERSION_REVISION == 21,
+             "Non-compatible flatbuffers version included");

 namespace com {
 namespace fbs {
@@ -26,24 +27,29 @@ struct Animal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
    VT_SOUND = 6,
    VT_WEIGHT = 8
  };
-  const ::flatbuffers::String* name() const {
-    return GetPointer<const ::flatbuffers::String*>(VT_NAME);
+  const ::flatbuffers::String *name() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
-  const ::flatbuffers::String* sound() const {
-    return GetPointer<const ::flatbuffers::String*>(VT_SOUND);
+  const ::flatbuffers::String *sound() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_SOUND);
  }
-  uint16_t weight() const { return GetField<uint16_t>(VT_WEIGHT, 0); }
-  bool Verify(::flatbuffers::Verifier& verifier) const {
-    return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_NAME) &&
-           verifier.VerifyString(name()) && VerifyOffset(verifier, VT_SOUND) &&
+  uint16_t weight() const {
+    return GetField<uint16_t>(VT_WEIGHT, 0);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
+           VerifyOffset(verifier, VT_SOUND) &&
           verifier.VerifyString(sound()) &&
-           VerifyField<uint16_t>(verifier, VT_WEIGHT, 2) && verifier.EndTable();
+           VerifyField<uint16_t>(verifier, VT_WEIGHT, 2) &&
+           verifier.EndTable();
  }
 };

 struct AnimalBuilder {
  typedef Animal Table;
-  ::flatbuffers::FlatBufferBuilder& fbb_;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(Animal::VT_NAME, name);
@@ -54,7 +60,8 @@ struct AnimalBuilder {
  void add_weight(uint16_t weight) {
    fbb_.AddElement<uint16_t>(Animal::VT_WEIGHT, weight, 0);
  }
-  explicit AnimalBuilder(::flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
+  explicit AnimalBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Animal> Finish() {
@@ -65,7 +72,7 @@ struct AnimalBuilder {
 };

 inline ::flatbuffers::Offset<Animal> CreateAnimal(
-    ::flatbuffers::FlatBufferBuilder& _fbb,
+    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    ::flatbuffers::Offset<::flatbuffers::String> sound = 0,
    uint16_t weight = 0) {
@@ -77,37 +84,45 @@ inline ::flatbuffers::Offset<Animal> CreateAnimal(
 }

 inline ::flatbuffers::Offset<Animal> CreateAnimalDirect(
-    ::flatbuffers::FlatBufferBuilder& _fbb, const char* name = nullptr,
-    const char* sound = nullptr, uint16_t weight = 0) {
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    const char *name = nullptr,
+    const char *sound = nullptr,
+    uint16_t weight = 0) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto sound__ = sound ? _fbb.CreateString(sound) : 0;
-  return com::fbs::app::CreateAnimal(_fbb, name__, sound__, weight);
+  return com::fbs::app::CreateAnimal(
+      _fbb,
+      name__,
+      sound__,
+      weight);
 }

-inline const com::fbs::app::Animal* GetAnimal(const void* buf) {
+inline const com::fbs::app::Animal *GetAnimal(const void *buf) {
  return ::flatbuffers::GetRoot<com::fbs::app::Animal>(buf);
 }

-inline const com::fbs::app::Animal* GetSizePrefixedAnimal(const void* buf) {
+inline const com::fbs::app::Animal *GetSizePrefixedAnimal(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<com::fbs::app::Animal>(buf);
 }

-inline bool VerifyAnimalBuffer(::flatbuffers::Verifier& verifier) {
+inline bool VerifyAnimalBuffer(
+    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<com::fbs::app::Animal>(nullptr);
 }

-inline bool VerifySizePrefixedAnimalBuffer(::flatbuffers::Verifier& verifier) {
+inline bool VerifySizePrefixedAnimalBuffer(
+    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<com::fbs::app::Animal>(nullptr);
 }

 inline void FinishAnimalBuffer(
-    ::flatbuffers::FlatBufferBuilder& fbb,
+    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<com::fbs::app::Animal> root) {
  fbb.Finish(root);
 }

 inline void FinishSizePrefixedAnimalBuffer(
-    ::flatbuffers::FlatBufferBuilder& fbb,
+    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<com::fbs::app::Animal> root) {
  fbb.FinishSizePrefixed(root);
 }
--- a/android/app/src/main/java/com/flatbuffers/app/MainActivity.kt
+++ b/android/app/src/main/java/com/flatbuffers/app/MainActivity.kt
@@ -1,9 +1,9 @@
 package com.flatbuffers.app

 import android.annotation.SuppressLint
+import androidx.appcompat.app.AppCompatActivity
 import android.os.Bundle
 import android.widget.TextView
-import androidx.appcompat.app.AppCompatActivity
 import com.fbs.app.Animal
 import com.google.flatbuffers.FlatBufferBuilder
 import java.nio.ByteBuffer
@@ -27,15 +27,14 @@ class MainActivity : AppCompatActivity() {
  private external fun createAnimalFromJNI(): ByteArray

  // Create a "Cow" Animal flatbuffers from Kotlin
-  private fun createAnimalFromKotlin(): Animal {
+  private fun createAnimalFromKotlin():Animal {
    val fb = FlatBufferBuilder(100)
-    val cowOffset =
-      Animal.createAnimal(
-        builder = fb,
-        nameOffset = fb.createString("Cow"),
-        soundOffset = fb.createString("Moo"),
-        weight = 720u,
-      )
+    val cowOffset = Animal.createAnimal(
+      builder = fb,
+      nameOffset = fb.createString("Cow"),
+      soundOffset = fb.createString("Moo"),
+      weight = 720u
+    )
    fb.finish(cowOffset)
    return Animal.getRootAsAnimal(fb.dataBuffer())
  }
--- a/android/app/src/main/java/generated/com/fbs/app/Animal.kt
+++ b/android/app/src/main/java/generated/com/fbs/app/Animal.kt
@@ -2,101 +2,83 @@

 package com.fbs.app

+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.LongVector
+import com.google.flatbuffers.StringVector
+import com.google.flatbuffers.Struct
 import com.google.flatbuffers.Table
+import com.google.flatbuffers.UnionVector
 import java.nio.ByteBuffer
 import java.nio.ByteOrder
+import kotlin.math.sign

@Suppress("unused")
@kotlin.ExperimentalUnsignedTypes
 class Animal : Table() {

-  fun __init(_i: Int, _bb: ByteBuffer) {
-    __reset(_i, _bb)
-  }
-
-  fun __assign(_i: Int, _bb: ByteBuffer): Animal {
-    __init(_i, _bb)
-    return this
-  }
-
-  val name: String?
-    get() {
-      val o = __offset(4)
-      return if (o != 0) {
-        __string(o + bb_pos)
-      } else {
-        null
-      }
+    fun __init(_i: Int, _bb: ByteBuffer)  {
+        __reset(_i, _bb)
    }
-
-  val nameAsByteBuffer: ByteBuffer
-    get() = __vector_as_bytebuffer(4, 1)
-
-  fun nameInByteBuffer(_bb: ByteBuffer): ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1)
-
-  val sound: String?
-    get() {
-      val o = __offset(6)
-      return if (o != 0) {
-        __string(o + bb_pos)
-      } else {
-        null
-      }
+    fun __assign(_i: Int, _bb: ByteBuffer) : Animal {
+        __init(_i, _bb)
+        return this
    }
-
-  val soundAsByteBuffer: ByteBuffer
-    get() = __vector_as_bytebuffer(6, 1)
-
-  fun soundInByteBuffer(_bb: ByteBuffer): ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1)
-
-  val weight: UShort
-    get() {
-      val o = __offset(8)
-      return if (o != 0) bb.getShort(o + bb_pos).toUShort() else 0u
+    val name : String?
+        get() {
+            val o = __offset(4)
+            return if (o != 0) {
+                __string(o + bb_pos)
+            } else {
+                null
+            }
+        }
+    val nameAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1)
+    fun nameInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1)
+    val sound : String?
+        get() {
+            val o = __offset(6)
+            return if (o != 0) {
+                __string(o + bb_pos)
+            } else {
+                null
+            }
+        }
+    val soundAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1)
+    fun soundInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1)
+    val weight : UShort
+        get() {
+            val o = __offset(8)
+            return if(o != 0) bb.getShort(o + bb_pos).toUShort() else 0u
+        }
+    companion object {
+        fun validateVersion() = Constants.FLATBUFFERS_24_3_6()
+        fun getRootAsAnimal(_bb: ByteBuffer): Animal = getRootAsAnimal(_bb, Animal())
+        fun getRootAsAnimal(_bb: ByteBuffer, obj: Animal): Animal {
+            _bb.order(ByteOrder.LITTLE_ENDIAN)
+            return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
+        }
+        fun createAnimal(builder: FlatBufferBuilder, nameOffset: Int, soundOffset: Int, weight: UShort) : Int {
+            builder.startTable(3)
+            addSound(builder, soundOffset)
+            addName(builder, nameOffset)
+            addWeight(builder, weight)
+            return endAnimal(builder)
+        }
+        fun startAnimal(builder: FlatBufferBuilder) = builder.startTable(3)
+        fun addName(builder: FlatBufferBuilder, name: Int) = builder.addOffset(0, name, 0)
+        fun addSound(builder: FlatBufferBuilder, sound: Int) = builder.addOffset(1, sound, 0)
+        fun addWeight(builder: FlatBufferBuilder, weight: UShort) = builder.addShort(2, weight.toShort(), 0)
+        fun endAnimal(builder: FlatBufferBuilder) : Int {
+            val o = builder.endTable()
+            return o
+        }
+        fun finishAnimalBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finish(offset)
+        fun finishSizePrefixedAnimalBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finishSizePrefixed(offset)
    }
-
-  companion object {
-    fun validateVersion() = Constants.FLATBUFFERS_25_9_23()
-
-    fun getRootAsAnimal(_bb: ByteBuffer): Animal = getRootAsAnimal(_bb, Animal())
-
-    fun getRootAsAnimal(_bb: ByteBuffer, obj: Animal): Animal {
-      _bb.order(ByteOrder.LITTLE_ENDIAN)
-      return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
-    }
-
-    fun createAnimal(
-      builder: FlatBufferBuilder,
-      nameOffset: Int,
-      soundOffset: Int,
-      weight: UShort,
-    ): Int {
-      builder.startTable(3)
-      addSound(builder, soundOffset)
-      addName(builder, nameOffset)
-      addWeight(builder, weight)
-      return endAnimal(builder)
-    }
-
-    fun startAnimal(builder: FlatBufferBuilder) = builder.startTable(3)
-
-    fun addName(builder: FlatBufferBuilder, name: Int) = builder.addOffset(0, name, 0)
-
-    fun addSound(builder: FlatBufferBuilder, sound: Int) = builder.addOffset(1, sound, 0)
-
-    fun addWeight(builder: FlatBufferBuilder, weight: UShort) =
-      builder.addShort(2, weight.toShort(), 0)
-
-    fun endAnimal(builder: FlatBufferBuilder): Int {
-      val o = builder.endTable()
-      return o
-    }
-
-    fun finishAnimalBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finish(offset)
-
-    fun finishSizePrefixedAnimalBuffer(builder: FlatBufferBuilder, offset: Int) =
-      builder.finishSizePrefixed(offset)
-  }
 }
--- a/benchmarks/cpp/bench.h
+++ b/benchmarks/cpp/bench.h
@@ -8,12 +8,12 @@ struct Bench {

  inline void Add(int64_t value) { sum += value; }

-  virtual uint8_t* Encode(void* buf, int64_t& len) = 0;
-  virtual void* Decode(void* buf, int64_t len) = 0;
-  virtual int64_t Use(void* decoded) = 0;
-  virtual void Dealloc(void* decoded) = 0;
+  virtual uint8_t *Encode(void *buf, int64_t &len) = 0;
+  virtual void *Decode(void *buf, int64_t len) = 0;
+  virtual int64_t Use(void *decoded) = 0;
+  virtual void Dealloc(void *decoded) = 0;

  int64_t sum = 0;
 };

-#endif  // BENCHMARKS_CPP_BENCH_H_
+#endif // BENCHMARKS_CPP_BENCH_H_
--- a/benchmarks/cpp/flatbuffers/bench_generated.h
+++ b/benchmarks/cpp/flatbuffers/bench_generated.h
@@ -1,5 +1,6 @@
 // automatically generated by the FlatBuffers compiler, do not modify

+
 #ifndef FLATBUFFERS_GENERATED_BENCH_BENCHMARKS_FLATBUFFERS_H_
 #define FLATBUFFERS_GENERATED_BENCH_BENCHMARKS_FLATBUFFERS_H_

@@ -7,10 +8,10 @@

 // 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 == 24 &&
-                  FLATBUFFERS_VERSION_MINOR == 12 &&
-                  FLATBUFFERS_VERSION_REVISION == 23,
-              "Non-compatible flatbuffers version included");
+static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
+              FLATBUFFERS_VERSION_MINOR == 0 &&
+              FLATBUFFERS_VERSION_REVISION == 6,
+             "Non-compatible flatbuffers version included");

 namespace benchmarks_flatbuffers {

@@ -33,16 +34,25 @@ enum Enum : int16_t {
 };

 inline const Enum (&EnumValuesEnum())[3] {
-  static const Enum values[] = {Enum_Apples, Enum_Pears, Enum_Bananas};
+  static const Enum values[] = {
+    Enum_Apples,
+    Enum_Pears,
+    Enum_Bananas
+  };
  return values;
 }

-inline const char* const* EnumNamesEnum() {
-  static const char* const names[4] = {"Apples", "Pears", "Bananas", nullptr};
+inline const char * const *EnumNamesEnum() {
+  static const char * const names[4] = {
+    "Apples",
+    "Pears",
+    "Bananas",
+    nullptr
+  };
  return names;
 }

-inline const char* EnumNameEnum(Enum e) {
+inline const char *EnumNameEnum(Enum e) {
  if (flatbuffers::IsOutRange(e, Enum_Apples, Enum_Bananas)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesEnum()[index];
@@ -57,7 +67,12 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Foo FLATBUFFERS_FINAL_CLASS {
  uint32_t length_;

 public:
-  Foo() : id_(0), count_(0), prefix_(0), padding0__(0), length_(0) {
+  Foo()
+      : id_(0),
+        count_(0),
+        prefix_(0),
+        padding0__(0),
+        length_(0) {
    (void)padding0__;
  }
  Foo(uint64_t _id, int16_t _count, int8_t _prefix, uint32_t _length)
@@ -68,10 +83,18 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Foo FLATBUFFERS_FINAL_CLASS {
        length_(flatbuffers::EndianScalar(_length)) {
    (void)padding0__;
  }
-  uint64_t id() const { return flatbuffers::EndianScalar(id_); }
-  int16_t count() const { return flatbuffers::EndianScalar(count_); }
-  int8_t prefix() const { return flatbuffers::EndianScalar(prefix_); }
-  uint32_t length() const { return flatbuffers::EndianScalar(length_); }
+  uint64_t id() const {
+    return flatbuffers::EndianScalar(id_);
+  }
+  int16_t count() const {
+    return flatbuffers::EndianScalar(count_);
+  }
+  int8_t prefix() const {
+    return flatbuffers::EndianScalar(prefix_);
+  }
+  uint32_t length() const {
+    return flatbuffers::EndianScalar(length_);
+  }
 };
 FLATBUFFERS_STRUCT_END(Foo, 16);

@@ -81,17 +104,20 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Bar FLATBUFFERS_FINAL_CLASS {
  int32_t time_;
  float ratio_;
  uint16_t size_;
-  int16_t padding0__;
-  int32_t padding1__;
+  int16_t padding0__;  int32_t padding1__;

 public:
  Bar()
-      : parent_(), time_(0), ratio_(0), size_(0), padding0__(0), padding1__(0) {
+      : parent_(),
+        time_(0),
+        ratio_(0),
+        size_(0),
+        padding0__(0),
+        padding1__(0) {
    (void)padding0__;
    (void)padding1__;
  }
-  Bar(const benchmarks_flatbuffers::Foo& _parent, int32_t _time, float _ratio,
-      uint16_t _size)
+  Bar(const benchmarks_flatbuffers::Foo &_parent, int32_t _time, float _ratio, uint16_t _size)
      : parent_(_parent),
        time_(flatbuffers::EndianScalar(_time)),
        ratio_(flatbuffers::EndianScalar(_ratio)),
@@ -101,10 +127,18 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Bar FLATBUFFERS_FINAL_CLASS {
    (void)padding0__;
    (void)padding1__;
  }
-  const benchmarks_flatbuffers::Foo& parent() const { return parent_; }
-  int32_t time() const { return flatbuffers::EndianScalar(time_); }
-  float ratio() const { return flatbuffers::EndianScalar(ratio_); }
-  uint16_t size() const { return flatbuffers::EndianScalar(size_); }
+  const benchmarks_flatbuffers::Foo &parent() const {
+    return parent_;
+  }
+  int32_t time() const {
+    return flatbuffers::EndianScalar(time_);
+  }
+  float ratio() const {
+    return flatbuffers::EndianScalar(ratio_);
+  }
+  uint16_t size() const {
+    return flatbuffers::EndianScalar(size_);
+  }
 };
 FLATBUFFERS_STRUCT_END(Bar, 32);

@@ -116,28 +150,34 @@ struct FooBar FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    VT_RATING = 8,
    VT_POSTFIX = 10
  };
-  const benchmarks_flatbuffers::Bar* sibling() const {
-    return GetStruct<const benchmarks_flatbuffers::Bar*>(VT_SIBLING);
+  const benchmarks_flatbuffers::Bar *sibling() const {
+    return GetStruct<const benchmarks_flatbuffers::Bar *>(VT_SIBLING);
  }
-  const flatbuffers::String* name() const {
-    return GetPointer<const flatbuffers::String*>(VT_NAME);
+  const flatbuffers::String *name() const {
+    return GetPointer<const flatbuffers::String *>(VT_NAME);
  }
-  double rating() const { return GetField<double>(VT_RATING, 0.0); }
-  uint8_t postfix() const { return GetField<uint8_t>(VT_POSTFIX, 0); }
-  bool Verify(flatbuffers::Verifier& verifier) const {
+  double rating() const {
+    return GetField<double>(VT_RATING, 0.0);
+  }
+  uint8_t postfix() const {
+    return GetField<uint8_t>(VT_POSTFIX, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<benchmarks_flatbuffers::Bar>(verifier, VT_SIBLING, 8) &&
-           VerifyOffset(verifier, VT_NAME) && verifier.VerifyString(name()) &&
+           VerifyOffset(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
           VerifyField<double>(verifier, VT_RATING, 8) &&
-           VerifyField<uint8_t>(verifier, VT_POSTFIX, 1) && verifier.EndTable();
+           VerifyField<uint8_t>(verifier, VT_POSTFIX, 1) &&
+           verifier.EndTable();
  }
 };

 struct FooBarBuilder {
  typedef FooBar Table;
-  flatbuffers::FlatBufferBuilder& fbb_;
+  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
-  void add_sibling(const benchmarks_flatbuffers::Bar* sibling) {
+  void add_sibling(const benchmarks_flatbuffers::Bar *sibling) {
    fbb_.AddStruct(FooBar::VT_SIBLING, sibling);
  }
  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
@@ -149,7 +189,8 @@ struct FooBarBuilder {
  void add_postfix(uint8_t postfix) {
    fbb_.AddElement<uint8_t>(FooBar::VT_POSTFIX, postfix, 0);
  }
-  explicit FooBarBuilder(flatbuffers::FlatBufferBuilder& _fbb) : fbb_(_fbb) {
+  explicit FooBarBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<FooBar> Finish() {
@@ -160,9 +201,10 @@ struct FooBarBuilder {
 };

 inline flatbuffers::Offset<FooBar> CreateFooBar(
-    flatbuffers::FlatBufferBuilder& _fbb,
-    const benchmarks_flatbuffers::Bar* sibling = nullptr,
-    flatbuffers::Offset<flatbuffers::String> name = 0, double rating = 0.0,
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const benchmarks_flatbuffers::Bar *sibling = nullptr,
+    flatbuffers::Offset<flatbuffers::String> name = 0,
+    double rating = 0.0,
    uint8_t postfix = 0) {
  FooBarBuilder builder_(_fbb);
  builder_.add_rating(rating);
@@ -173,12 +215,18 @@ inline flatbuffers::Offset<FooBar> CreateFooBar(
 }

 inline flatbuffers::Offset<FooBar> CreateFooBarDirect(
-    flatbuffers::FlatBufferBuilder& _fbb,
-    const benchmarks_flatbuffers::Bar* sibling = nullptr,
-    const char* name = nullptr, double rating = 0.0, uint8_t postfix = 0) {
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const benchmarks_flatbuffers::Bar *sibling = nullptr,
+    const char *name = nullptr,
+    double rating = 0.0,
+    uint8_t postfix = 0) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
-  return benchmarks_flatbuffers::CreateFooBar(_fbb, sibling, name__, rating,
-                                              postfix);
+  return benchmarks_flatbuffers::CreateFooBar(
+      _fbb,
+      sibling,
+      name__,
+      rating,
+      postfix);
 }

 struct FooBarContainer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -189,53 +237,49 @@ struct FooBarContainer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
    VT_FRUIT = 8,
    VT_LOCATION = 10
  };
-  const flatbuffers::Vector<
-      flatbuffers::Offset<benchmarks_flatbuffers::FooBar>>*
-  list() const {
-    return GetPointer<const flatbuffers::Vector<
-        flatbuffers::Offset<benchmarks_flatbuffers::FooBar>>*>(VT_LIST);
+  const flatbuffers::Vector<flatbuffers::Offset<benchmarks_flatbuffers::FooBar>> *list() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<benchmarks_flatbuffers::FooBar>> *>(VT_LIST);
+  }
+  bool initialized() const {
+    return GetField<uint8_t>(VT_INITIALIZED, 0) != 0;
  }
-  bool initialized() const { return GetField<uint8_t>(VT_INITIALIZED, 0) != 0; }
  benchmarks_flatbuffers::Enum fruit() const {
-    return static_cast<benchmarks_flatbuffers::Enum>(
-        GetField<int16_t>(VT_FRUIT, 0));
+    return static_cast<benchmarks_flatbuffers::Enum>(GetField<int16_t>(VT_FRUIT, 0));
  }
-  const flatbuffers::String* location() const {
-    return GetPointer<const flatbuffers::String*>(VT_LOCATION);
+  const flatbuffers::String *location() const {
+    return GetPointer<const flatbuffers::String *>(VT_LOCATION);
  }
-  bool Verify(flatbuffers::Verifier& verifier) const {
-    return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_LIST) &&
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_LIST) &&
           verifier.VerifyVector(list()) &&
           verifier.VerifyVectorOfTables(list()) &&
           VerifyField<uint8_t>(verifier, VT_INITIALIZED, 1) &&
           VerifyField<int16_t>(verifier, VT_FRUIT, 2) &&
           VerifyOffset(verifier, VT_LOCATION) &&
-           verifier.VerifyString(location()) && verifier.EndTable();
+           verifier.VerifyString(location()) &&
+           verifier.EndTable();
  }
 };

 struct FooBarContainerBuilder {
  typedef FooBarContainer Table;
-  flatbuffers::FlatBufferBuilder& fbb_;
+  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
-  void add_list(flatbuffers::Offset<flatbuffers::Vector<
-                    flatbuffers::Offset<benchmarks_flatbuffers::FooBar>>>
-                    list) {
+  void add_list(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<benchmarks_flatbuffers::FooBar>>> list) {
    fbb_.AddOffset(FooBarContainer::VT_LIST, list);
  }
  void add_initialized(bool initialized) {
-    fbb_.AddElement<uint8_t>(FooBarContainer::VT_INITIALIZED,
-                             static_cast<uint8_t>(initialized), 0);
+    fbb_.AddElement<uint8_t>(FooBarContainer::VT_INITIALIZED, static_cast<uint8_t>(initialized), 0);
  }
  void add_fruit(benchmarks_flatbuffers::Enum fruit) {
-    fbb_.AddElement<int16_t>(FooBarContainer::VT_FRUIT,
-                             static_cast<int16_t>(fruit), 0);
+    fbb_.AddElement<int16_t>(FooBarContainer::VT_FRUIT, static_cast<int16_t>(fruit), 0);
  }
  void add_location(flatbuffers::Offset<flatbuffers::String> location) {
    fbb_.AddOffset(FooBarContainer::VT_LOCATION, location);
  }
-  explicit FooBarContainerBuilder(flatbuffers::FlatBufferBuilder& _fbb)
-      : fbb_(_fbb) {
+  explicit FooBarContainerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  flatbuffers::Offset<FooBarContainer> Finish() {
@@ -246,10 +290,8 @@ struct FooBarContainerBuilder {
 };

 inline flatbuffers::Offset<FooBarContainer> CreateFooBarContainer(
-    flatbuffers::FlatBufferBuilder& _fbb,
-    flatbuffers::Offset<flatbuffers::Vector<
-        flatbuffers::Offset<benchmarks_flatbuffers::FooBar>>>
-        list = 0,
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<benchmarks_flatbuffers::FooBar>>> list = 0,
    bool initialized = false,
    benchmarks_flatbuffers::Enum fruit = benchmarks_flatbuffers::Enum_Apples,
    flatbuffers::Offset<flatbuffers::String> location = 0) {
@@ -262,52 +304,47 @@ inline flatbuffers::Offset<FooBarContainer> CreateFooBarContainer(
 }

 inline flatbuffers::Offset<FooBarContainer> CreateFooBarContainerDirect(
-    flatbuffers::FlatBufferBuilder& _fbb,
-    const std::vector<flatbuffers::Offset<benchmarks_flatbuffers::FooBar>>*
-        list = nullptr,
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<flatbuffers::Offset<benchmarks_flatbuffers::FooBar>> *list = nullptr,
    bool initialized = false,
    benchmarks_flatbuffers::Enum fruit = benchmarks_flatbuffers::Enum_Apples,
-    const char* location = nullptr) {
-  auto list__ =
-      list ? _fbb.CreateVector<
-                 flatbuffers::Offset<benchmarks_flatbuffers::FooBar>>(*list)
-           : 0;
+    const char *location = nullptr) {
+  auto list__ = list ? _fbb.CreateVector<flatbuffers::Offset<benchmarks_flatbuffers::FooBar>>(*list) : 0;
  auto location__ = location ? _fbb.CreateString(location) : 0;
  return benchmarks_flatbuffers::CreateFooBarContainer(
-      _fbb, list__, initialized, fruit, location__);
+      _fbb,
+      list__,
+      initialized,
+      fruit,
+      location__);
 }

-inline const benchmarks_flatbuffers::FooBarContainer* GetFooBarContainer(
-    const void* buf) {
+inline const benchmarks_flatbuffers::FooBarContainer *GetFooBarContainer(const void *buf) {
  return flatbuffers::GetRoot<benchmarks_flatbuffers::FooBarContainer>(buf);
 }

-inline const benchmarks_flatbuffers::FooBarContainer*
-GetSizePrefixedFooBarContainer(const void* buf) {
-  return flatbuffers::GetSizePrefixedRoot<
-      benchmarks_flatbuffers::FooBarContainer>(buf);
+inline const benchmarks_flatbuffers::FooBarContainer *GetSizePrefixedFooBarContainer(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<benchmarks_flatbuffers::FooBarContainer>(buf);
 }

-inline bool VerifyFooBarContainerBuffer(flatbuffers::Verifier& verifier) {
-  return verifier.VerifyBuffer<benchmarks_flatbuffers::FooBarContainer>(
-      nullptr);
+inline bool VerifyFooBarContainerBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<benchmarks_flatbuffers::FooBarContainer>(nullptr);
 }

 inline bool VerifySizePrefixedFooBarContainerBuffer(
-    flatbuffers::Verifier& verifier) {
-  return verifier
-      .VerifySizePrefixedBuffer<benchmarks_flatbuffers::FooBarContainer>(
-          nullptr);
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<benchmarks_flatbuffers::FooBarContainer>(nullptr);
 }

 inline void FinishFooBarContainerBuffer(
-    flatbuffers::FlatBufferBuilder& fbb,
+    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<benchmarks_flatbuffers::FooBarContainer> root) {
  fbb.Finish(root);
 }

 inline void FinishSizePrefixedFooBarContainerBuffer(
-    flatbuffers::FlatBufferBuilder& fbb,
+    flatbuffers::FlatBufferBuilder &fbb,
    flatbuffers::Offset<benchmarks_flatbuffers::FooBarContainer> root) {
  fbb.FinishSizePrefixed(root);
 }
--- a/benchmarks/cpp/flatbuffers/fb_bench.h
+++ b/benchmarks/cpp/flatbuffers/fb_bench.h
@@ -8,16 +8,16 @@
 #include "include/flatbuffers/flatbuffers.h"

 struct StaticAllocator : public flatbuffers::Allocator {
-  explicit StaticAllocator(uint8_t* buffer) : buffer_(buffer) {}
+  explicit StaticAllocator(uint8_t *buffer) : buffer_(buffer) {}

-  uint8_t* allocate(size_t) override { return buffer_; }
+  uint8_t *allocate(size_t) override { return buffer_; }

-  void deallocate(uint8_t*, size_t) override {}
+  void deallocate(uint8_t *, size_t) override {}

-  uint8_t* buffer_;
+  uint8_t *buffer_;
 };

 std::unique_ptr<Bench> NewFlatBuffersBench(
-    int64_t initial_size = 1024, flatbuffers::Allocator* allocator = nullptr);
+    int64_t initial_size = 1024, flatbuffers::Allocator *allocator = nullptr);

 #endif  // BENCHMARKS_CPP_FLATBUFFERS_FB_BENCH_H_
--- a/benchmarks/swift/Benchmarks/FlatbuffersBenchmarks/FlatbuffersBenchmarks.swift
+++ b/benchmarks/swift/Benchmarks/FlatbuffersBenchmarks/FlatbuffersBenchmarks.swift
@@ -1,5 +1,5 @@
 /*
- * Copyright 2024 Google Inc. All rights reserved.
+ * Copyright 2023 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.
@@ -15,8 +15,8 @@
 */

 import Benchmark
+import CoreFoundation
 import FlatBuffers
-import Foundation

@usableFromInline
 struct AA: NativeStruct {
@@ -29,15 +29,6 @@ struct AA: NativeStruct {
 }

 let benchmarks = {
-  let oneGB: Int32 = 1_024_000_000
-  let data = {
-    var array = [8888.88, 8888.88]
-    var data = Data()
-    array.withUnsafeBytes { ptr in
-      data.append(contentsOf: ptr)
-    }
-    return data
-  }()
  let ints: [Int] = Array(repeating: 42, count: 100)
  let bytes: [UInt8] = Array(repeating: 42, count: 100)
  let str10 = (0...9).map { _ -> String in "x" }.joined()
@@ -82,25 +73,12 @@ let benchmarks = {

  Benchmark("Allocating 1GB", configuration: singleConfiguration) { benchmark in
    for _ in benchmark.scaledIterations {
-      blackHole(FlatBufferBuilder(initialSize: oneGB))
-    }
-  }
-
-  Benchmark(
-    "Allocating ByteBuffer 1GB",
-    configuration: singleConfiguration
-  ) { benchmark in
-    let memory = UnsafeMutableRawPointer.allocate(
-      byteCount: 1_024_000_000,
-      alignment: 1)
-    benchmark.startMeasurement()
-    for _ in benchmark.scaledIterations {
-      blackHole(ByteBuffer(assumingMemoryBound: memory, capacity: Int(oneGB)))
+      blackHole(FlatBufferBuilder(initialSize: 1_024_000_000))
    }
  }

  Benchmark("Clearing 1GB", configuration: singleConfiguration) { benchmark in
-    var fb = FlatBufferBuilder(initialSize: oneGB)
+    var fb = FlatBufferBuilder(initialSize: 1_024_000_000)
    benchmark.startMeasurement()
    for _ in benchmark.scaledIterations {
      blackHole(fb.clear())
@@ -108,7 +86,7 @@ let benchmarks = {
  }

  Benchmark("Strings 10") { benchmark in
-    var fb = FlatBufferBuilder(initialSize: 1 << 20)
+    var fb = FlatBufferBuilder(initialSize: 1<<20)
    benchmark.startMeasurement()
    for _ in benchmark.scaledIterations {
      blackHole(fb.create(string: str10))
@@ -116,7 +94,7 @@ let benchmarks = {
  }

  Benchmark("Strings 100") { benchmark in
-    var fb = FlatBufferBuilder(initialSize: 1 << 20)
+    var fb = FlatBufferBuilder(initialSize: 1<<20)
    benchmark.startMeasurement()
    for _ in benchmark.scaledIterations {
      blackHole(fb.create(string: str100))
@@ -124,7 +102,7 @@ let benchmarks = {
  }

  Benchmark("Vector 1 Bytes") { benchmark in
-    var fb = FlatBufferBuilder(initialSize: 1 << 20)
+    var fb = FlatBufferBuilder(initialSize: 1<<20)
    benchmark.startMeasurement()
    for _ in benchmark.scaledIterations {
      blackHole(fb.createVector(bytes: bytes))
@@ -132,7 +110,7 @@ let benchmarks = {
  }

  Benchmark("Vector 1 Ints") { benchmark in
-    var fb = FlatBufferBuilder(initialSize: 1 << 20)
+    var fb = FlatBufferBuilder(initialSize: 1<<20)
    benchmark.startMeasurement()
    for _ in benchmark.scaledIterations {
      blackHole(fb.createVector(ints))
@@ -140,7 +118,7 @@ let benchmarks = {
  }

  Benchmark("Vector 100 Ints") { benchmark in
-    var fb = FlatBufferBuilder(initialSize: 1 << 20)
+    var fb = FlatBufferBuilder(initialSize: 1<<20)
    benchmark.startMeasurement()
    for i in benchmark.scaledIterations {
      blackHole(fb.createVector(ints))
@@ -148,7 +126,7 @@ let benchmarks = {
  }

  Benchmark("Vector 100 Bytes") { benchmark in
-    var fb = FlatBufferBuilder(initialSize: 1 << 20)
+    var fb = FlatBufferBuilder(initialSize: 1<<20)
    benchmark.startMeasurement()
    for i in benchmark.scaledIterations {
      blackHole(fb.createVector(bytes))
@@ -156,7 +134,7 @@ let benchmarks = {
  }

  Benchmark("Vector 100 ContiguousBytes") { benchmark in
-    var fb = FlatBufferBuilder(initialSize: 1 << 20)
+    var fb = FlatBufferBuilder(initialSize: 1<<20)
    benchmark.startMeasurement()
    for i in benchmark.scaledIterations {
      blackHole(fb.createVector(bytes: bytes))
@@ -165,8 +143,8 @@ let benchmarks = {

  Benchmark(
    "FlatBufferBuilder Add",
-    configuration: kiloConfiguration
-  ) { benchmark in
+    configuration: kiloConfiguration)
+  { benchmark in
    var fb = FlatBufferBuilder(initialSize: 1024 * 1024 * 32)
    benchmark.startMeasurement()
    for _ in benchmark.scaledIterations {
@@ -180,26 +158,6 @@ let benchmarks = {
    }
  }

-  Benchmark(
-    "FlatBufferBuilder Start table",
-    configuration: kiloConfiguration
-  ) { benchmark in
-    var fb = FlatBufferBuilder(initialSize: 1024 * 1024 * 32)
-    benchmark.startMeasurement()
-    for _ in benchmark.scaledIterations {
-      let s = fb.startTable(with: 4)
-      blackHole(fb.endTable(at: s))
-    }
-  }
-
-  Benchmark("Struct") { benchmark in
-    var fb = FlatBufferBuilder(initialSize: 1024 * 1024 * 32)
-    benchmark.startMeasurement()
-    for _ in benchmark.scaledIterations {
-      blackHole(fb.create(struct: array.first!))
-    }
-  }
-
  Benchmark("Structs") { benchmark in
    let rawSize = ((16 * 5) * benchmark.scaledIterations.count) / 1024
    var fb = FlatBufferBuilder(initialSize: Int32(rawSize * 1600))
@@ -218,33 +176,6 @@ let benchmarks = {
    let start = fb.startTable(with: 1)
    fb.add(offset: vector, at: 4)
    let root = Offset(offset: fb.endTable(at: start))
-    blackHole(fb.finish(offset: root))
-  }
-
-  Benchmark("Vector of Offsets") { benchmark in
-    let rawSize = ((16 * 5) * benchmark.scaledIterations.count) / 1024
-    var fb = FlatBufferBuilder(initialSize: Int32(rawSize * 1600))
-    benchmark.startMeasurement()
-    for _ in benchmark.scaledIterations {
-      let offsets = [
-        fb.create(string: "T"),
-        fb.create(string: "2"),
-        fb.create(string: "3"),
-      ]
-      let off = fb.createVector(ofOffsets: [
-        fb.createVector(ofOffsets: offsets),
-        fb.createVector(ofOffsets: offsets),
-      ])
-      let s = fb.startTable(with: 2)
-      fb.add(offset: off, at: 2)
-      blackHole(fb.endTable(at: s))
-    }
-  }
-
-  Benchmark("Reading Doubles") { benchmark in
-    let byteBuffer = ByteBuffer(data: data)
-    for _ in benchmark.scaledIterations {
-      blackHole(byteBuffer.read(def: Double.self, position: 0))
-    }
+    fb.finish(offset: root)
  }
 }
--- a/benchmarks/swift/Package.swift
+++ b/benchmarks/swift/Package.swift
@@ -1,4 +1,4 @@
-// swift-tools-version:5.9
+// swift-tools-version:5.8
 /*
 * Copyright 2020 Google Inc. All rights reserved.
 *
@@ -20,13 +20,13 @@ import PackageDescription
 let package = Package(
  name: "benchmarks",
  platforms: [
-    .macOS(.v13)
+    .macOS(.v13),
  ],
  dependencies: [
    .package(path: "../.."),
    .package(
      url: "https://github.com/ordo-one/package-benchmark",
-      from: "1.27.0"),
+      from: "1.12.0"),
  ],
  targets: [
    .executableTarget(
@@ -37,6 +37,6 @@ let package = Package(
      ],
      path: "Benchmarks/FlatbuffersBenchmarks",
      plugins: [
-        .plugin(name: "BenchmarkPlugin", package: "package-benchmark")
-      ])
+        .plugin(name: "BenchmarkPlugin", package: "package-benchmark"),
+      ]),
  ])
--- a/build_defs.bzl
+++ b/build_defs.bzl
@@ -7,13 +7,13 @@ Rules for building C++ flatbuffers with Bazel.

 load("@rules_cc//cc:defs.bzl", "cc_library")

-TRUE_FLATC_PATH = Label("//:flatc")
+TRUE_FLATC_PATH = "@com_github_google_flatbuffers//:flatc"

 DEFAULT_INCLUDE_PATHS = [
    "./",
    "$(GENDIR)",
    "$(BINDIR)",
-    "$(execpath %s).runfiles/%s" % (TRUE_FLATC_PATH, TRUE_FLATC_PATH.repo_name),
+    "$(execpath @com_github_google_flatbuffers//:flatc).runfiles/com_github_google_flatbuffers",
 ]

 def default_include_paths(flatc_path):
@@ -21,7 +21,7 @@ def default_include_paths(flatc_path):
        "./",
        "$(GENDIR)",
        "$(BINDIR)",
-        "$(execpath %s).runfiles/%s" % (flatc_path, flatc_path.repo_name),
+        "$(execpath %s).runfiles/com_github_google_flatbuffers" % (flatc_path),
    ]

 DEFAULT_FLATC_ARGS = [
@@ -47,7 +47,7 @@ def flatbuffer_library_public(
        compatible_with = None,
        restricted_to = None,
        target_compatible_with = None,
-        flatc_path = None,
+        flatc_path = "@com_github_google_flatbuffers//:flatc",
        output_to_bindir = False,
        tools = None,
        extra_env = None,
@@ -87,11 +87,6 @@ def flatbuffer_library_public(
    optionally a Fileset([reflection_name]) with all generated reflection
    binaries.
    """
-    if flatc_path == None:
-        flatc_path = TRUE_FLATC_PATH
-    else:
-        flatc_path = native.package_relative_label(flatc_path)
-
    reflection_include_paths = include_paths
    if include_paths == None:
        include_paths = default_include_paths(flatc_path)
@@ -136,8 +131,6 @@ def flatbuffer_library_public(
        reflection_genrule_cmd = " ".join([
            "SRCS=($(SRCS));",
            "for f in $${SRCS[@]:0:%s}; do" % len(srcs),
-            # Move the .fbs file into the current package if it is not there already
-            'if [[ $$(dirname $$f) != "{0}" ]]; then s="$$f"; f="{0}/$$(basename "$$f")"; mkdir -p "{0}"; mv "$$s" "$$f"; fi;'.format(native.package_relative_label(":invalid").package),
            "$(location %s)" % (TRUE_FLATC_PATH),
            "-b --schema",
            " ".join(flatc_args),
@@ -148,10 +141,9 @@ def flatbuffer_library_public(
            "done",
        ])
        reflection_outs = [
-            (out_prefix + "%s.bfbs") % (native.package_relative_label(s).name.removesuffix(".fbs"))
+            (out_prefix + "%s.bfbs") % (s.replace(".fbs", "").split("/")[-1])
            for s in srcs
        ]
-
        native.genrule(
            name = "%s_srcs" % reflection_name,
            srcs = srcs + includes,
@@ -270,8 +262,8 @@ def flatbuffer_cc_library(
            "-parse_headers",
        ],
        deps = [
-            Label("//:runtime_cc"),
-            Label("//:flatbuffers"),
+            "@com_github_google_flatbuffers//:runtime_cc",
+            "@com_github_google_flatbuffers//:flatbuffers",
        ] + deps,
        includes = cc_include_paths,
        compatible_with = compatible_with,
--- a/conan/build.py
+++ b/conan/build.py
@@ -6,54 +6,45 @@ import subprocess
 from cpt.packager import ConanMultiPackager


+
 def get_branch():
-  try:
-    for line in (
-        subprocess.check_output("git branch", shell=True).decode().splitlines()
-    ):
-      line = line.strip()
-      if line.startswith("*") and " (HEAD detached" not in line:
-        return line.replace("*", "", 1).strip()
+    try:
+        for line in subprocess.check_output("git branch", shell=True).decode().splitlines():
+            line = line.strip()
+            if line.startswith("*") and " (HEAD detached" not in line:
+                return line.replace("*", "", 1).strip()
+        return ""
+    except Exception:
+        pass
    return ""
-  except Exception:
-    pass
-  return ""


 def get_version():
-  version = get_branch()
-  match = re.search(r"v(\d+\.\d+\.\d+.*)", version)
-  if match:
-    return match.group(1)
-  return version
+    version = get_branch()
+    match = re.search(r"v(\d+\.\d+\.\d+.*)", version)
+    if match:
+        return match.group(1)
+    return version


 def get_reference(username):
-  return "flatbuffers/{}@google/stable".format(get_version())
+    return "flatbuffers/{}@google/stable".format(get_version())


 if __name__ == "__main__":
-  login_username = os.getenv("CONAN_LOGIN_USERNAME", "aardappel")
-  username = os.getenv("CONAN_USERNAME", "google")
-  upload = os.getenv(
-      "CONAN_UPLOAD", "https://api.bintray.com/conan/aardappel/flatbuffers"
-  )
-  stable_branch_pattern = os.getenv(
-      "CONAN_STABLE_BRANCH_PATTERN", r"v\d+\.\d+\.\d+.*"
-  )
-  test_folder = os.getenv(
-      "CPT_TEST_FOLDER", os.path.join("conan", "test_package")
-  )
-  upload_only_when_stable = os.getenv("CONAN_UPLOAD_ONLY_WHEN_STABLE", True)
+    login_username = os.getenv("CONAN_LOGIN_USERNAME", "aardappel")
+    username = os.getenv("CONAN_USERNAME", "google")
+    upload = os.getenv("CONAN_UPLOAD", "https://api.bintray.com/conan/aardappel/flatbuffers")
+    stable_branch_pattern = os.getenv("CONAN_STABLE_BRANCH_PATTERN", r"v\d+\.\d+\.\d+.*")
+    test_folder = os.getenv("CPT_TEST_FOLDER", os.path.join("conan", "test_package"))
+    upload_only_when_stable = os.getenv("CONAN_UPLOAD_ONLY_WHEN_STABLE", True)

-  builder = ConanMultiPackager(
-      reference=get_reference(username),
-      username=username,
-      login_username=login_username,
-      upload=upload,
-      stable_branch_pattern=stable_branch_pattern,
-      upload_only_when_stable=upload_only_when_stable,
-      test_folder=test_folder,
-  )
-  builder.add_common_builds(pure_c=False)
-  builder.run()
+    builder = ConanMultiPackager(reference=get_reference(username),
+                                 username=username,
+                                 login_username=login_username,
+                                 upload=upload,
+                                 stable_branch_pattern=stable_branch_pattern,
+                                 upload_only_when_stable=upload_only_when_stable,
+                                 test_folder=test_folder)
+    builder.add_common_builds(pure_c=False)
+    builder.run()
--- a/conan/test_package/conanfile.py
+++ b/conan/test_package/conanfile.py
@@ -1,21 +1,21 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-

+from conans import ConanFile, CMake
 import os
-from conans import CMake, ConanFile


 class TestPackageConan(ConanFile):
-  settings = "os", "compiler", "build_type", "arch"
-  generators = "cmake"
+    settings = "os", "compiler", "build_type", "arch"
+    generators = "cmake"

-  def build(self):
-    cmake = CMake(self)
-    cmake.configure()
-    cmake.build()
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()

-  def test(self):
-    bin_path = os.path.join("bin", "test_package")
-    self.run(bin_path, run_environment=True)
-    self.run("flatc --version", run_environment=True)
-    self.run("flathash fnv1_16 conan", run_environment=True)
+    def test(self):
+        bin_path = os.path.join("bin", "test_package")
+        self.run(bin_path, run_environment=True)
+        self.run("flatc --version", run_environment=True)
+        self.run("flathash fnv1_16 conan", run_environment=True)
--- a/conanfile.py
+++ b/conanfile.py
@@ -1,83 +1,75 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-

-"""Conan recipe package for Google FlatBuffers"""
+"""Conan recipe package for Google FlatBuffers
+"""
 import os
 import shutil
-from conans import CMake, ConanFile, tools
+from conans import ConanFile, CMake, tools


 class FlatbuffersConan(ConanFile):
-  name = "flatbuffers"
-  license = "Apache-2.0"
-  url = "https://github.com/google/flatbuffers"
-  homepage = "http://google.github.io/flatbuffers/"
-  author = "Wouter van Oortmerssen"
-  topics = ("conan", "flatbuffers", "serialization", "rpc", "json-parser")
-  description = "Memory Efficient Serialization Library"
-  settings = "os", "compiler", "build_type", "arch"
-  options = {"shared": [True, False], "fPIC": [True, False]}
-  default_options = {"shared": False, "fPIC": True}
-  generators = "cmake"
-  exports = "LICENSE"
-  exports_sources = [
-      "CMake/*",
-      "include/*",
-      "src/*",
-      "grpc/*",
-      "CMakeLists.txt",
-      "conan/CMakeLists.txt",
-  ]
+    name = "flatbuffers"
+    license = "Apache-2.0"
+    url = "https://github.com/google/flatbuffers"
+    homepage = "http://google.github.io/flatbuffers/"
+    author = "Wouter van Oortmerssen"
+    topics = ("conan", "flatbuffers", "serialization", "rpc", "json-parser")
+    description = "Memory Efficient Serialization Library"
+    settings = "os", "compiler", "build_type", "arch"
+    options = {"shared": [True, False], "fPIC": [True, False]}
+    default_options = {"shared": False, "fPIC": True}
+    generators = "cmake"
+    exports = "LICENSE"
+    exports_sources = ["CMake/*", "include/*", "src/*", "grpc/*", "CMakeLists.txt", "conan/CMakeLists.txt"]

-  def source(self):
-    """Wrap the original CMake file to call conan_basic_setup"""
-    shutil.move("CMakeLists.txt", "CMakeListsOriginal.txt")
-    shutil.move(os.path.join("conan", "CMakeLists.txt"), "CMakeLists.txt")
+    def source(self):
+        """Wrap the original CMake file to call conan_basic_setup
+        """
+        shutil.move("CMakeLists.txt", "CMakeListsOriginal.txt")
+        shutil.move(os.path.join("conan", "CMakeLists.txt"), "CMakeLists.txt")

-  def config_options(self):
-    """Remove fPIC option on Windows platform"""
-    if self.settings.os == "Windows":
-      self.options.remove("fPIC")
+    def config_options(self):
+        """Remove fPIC option on Windows platform
+        """
+        if self.settings.os == "Windows":
+            self.options.remove("fPIC")

-  def configure_cmake(self):
-    """Create CMake instance and execute configure step"""
-    cmake = CMake(self)
-    cmake.definitions["FLATBUFFERS_BUILD_TESTS"] = False
-    cmake.definitions["FLATBUFFERS_BUILD_SHAREDLIB"] = self.options.shared
-    cmake.definitions["FLATBUFFERS_BUILD_FLATLIB"] = not self.options.shared
-    cmake.configure()
-    return cmake
+    def configure_cmake(self):
+        """Create CMake instance and execute configure step
+        """
+        cmake = CMake(self)
+        cmake.definitions["FLATBUFFERS_BUILD_TESTS"] = False
+        cmake.definitions["FLATBUFFERS_BUILD_SHAREDLIB"] = self.options.shared
+        cmake.definitions["FLATBUFFERS_BUILD_FLATLIB"] = not self.options.shared
+        cmake.configure()
+        return cmake

-  def build(self):
-    """Configure, build and install FlatBuffers using CMake."""
-    cmake = self.configure_cmake()
-    cmake.build()
+    def build(self):
+        """Configure, build and install FlatBuffers using CMake.
+        """
+        cmake = self.configure_cmake()
+        cmake.build()

-  def package(self):
-    """Copy Flatbuffers' artifacts to package folder"""
-    cmake = self.configure_cmake()
-    cmake.install()
-    self.copy(pattern="LICENSE", dst="licenses")
-    self.copy(
-        pattern="FindFlatBuffers.cmake",
-        dst=os.path.join("lib", "cmake", "flatbuffers"),
-        src="CMake",
-    )
-    self.copy(pattern="flathash*", dst="bin", src="bin")
-    self.copy(pattern="flatc*", dst="bin", src="bin")
-    if self.settings.os == "Windows" and self.options.shared:
-      if self.settings.compiler == "Visual Studio":
-        shutil.move(
-            os.path.join(self.package_folder, "lib", "%s.dll" % self.name),
-            os.path.join(self.package_folder, "bin", "%s.dll" % self.name),
-        )
-      elif self.settings.compiler == "gcc":
-        shutil.move(
-            os.path.join(self.package_folder, "lib", "lib%s.dll" % self.name),
-            os.path.join(self.package_folder, "bin", "lib%s.dll" % self.name),
-        )
+    def package(self):
+        """Copy Flatbuffers' artifacts to package folder
+        """
+        cmake = self.configure_cmake()
+        cmake.install()
+        self.copy(pattern="LICENSE", dst="licenses")
+        self.copy(pattern="FindFlatBuffers.cmake", dst=os.path.join("lib", "cmake", "flatbuffers"), src="CMake")
+        self.copy(pattern="flathash*", dst="bin", src="bin")
+        self.copy(pattern="flatc*", dst="bin", src="bin")
+        if self.settings.os == "Windows" and self.options.shared:
+            if self.settings.compiler == "Visual Studio":
+                shutil.move(os.path.join(self.package_folder, "lib", "%s.dll" % self.name),
+                            os.path.join(self.package_folder, "bin", "%s.dll" % self.name))
+            elif self.settings.compiler == "gcc":
+                shutil.move(os.path.join(self.package_folder, "lib", "lib%s.dll" % self.name),
+                            os.path.join(self.package_folder, "bin", "lib%s.dll" % self.name))

-  def package_info(self):
-    """Collect built libraries names and solve flatc path."""
-    self.cpp_info.libs = tools.collect_libs(self)
-    self.user_info.flatc = os.path.join(self.package_folder, "bin", "flatc")
+    def package_info(self):
+        """Collect built libraries names and solve flatc path.
+        """
+        self.cpp_info.libs = tools.collect_libs(self)
+        self.user_info.flatc = os.path.join(self.package_folder, "bin", "flatc")
--- a/dart/example/example.dart
+++ b/dart/example/example.dart
@@ -15,7 +15,6 @@
 */

 import 'package:flat_buffers/flat_buffers.dart' as fb;
-
 import './monster_my_game.sample_generated.dart' as my_game;

 // Example how to use FlatBuffers to create and read binary buffers.
@@ -79,8 +78,7 @@ void builderTest() {
  builder.finish(monsteroff);
  if (verify(builder.buffer)) {
    print(
-      "The FlatBuffer was successfully created with a builder and verified!",
-    );
+        "The FlatBuffer was successfully created with a builder and verified!");
  }
 }

@@ -96,10 +94,7 @@ void objectBuilderTest() {
    name: 'Orc',
    inventory: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
    color: my_game.Color.Red,
-    weapons: [
-      my_game.WeaponObjectBuilder(name: 'Sword', damage: 3),
-      axe,
-    ],
+    weapons: [my_game.WeaponObjectBuilder(name: 'Sword', damage: 3), axe],
    equippedType: my_game.EquipmentTypeId.Weapon,
    equipped: axe,
  );
@@ -113,8 +108,7 @@ void objectBuilderTest() {
  // Instead, we're going to access it right away (as if we just received it).
  if (verify(buffer)) {
    print(
-      "The FlatBuffer was successfully created with an object builder and verified!",
-    );
+        "The FlatBuffer was successfully created with an object builder and verified!");
  }
 }

--- a/dart/example/monster_my_game.sample_generated.dart
+++ b/dart/example/monster_my_game.sample_generated.dart
@@ -4,9 +4,9 @@
 library my_game.sample;

 import 'dart:typed_data' show Uint8List;
-
 import 'package:flat_buffers/flat_buffers.dart' as fb;

+
 class Color {
  final int value;
  const Color._(this.value);
@@ -19,7 +19,7 @@ class Color {
    return result;
  }

-  static Color? _createOrNull(int? value) =>
+  static Color? _createOrNull(int? value) => 
      value == null ? null : Color.fromValue(value);

  static const int minValue = 0;
@@ -29,7 +29,10 @@ class Color {
  static const Color Red = Color._(0);
  static const Color Green = Color._(1);
  static const Color Blue = Color._(2);
-  static const Map<int, Color> values = {0: Red, 1: Green, 2: Blue};
+  static const Map<int, Color> values = {
+    0: Red,
+    1: Green,
+    2: Blue};

  static const fb.Reader<Color> reader = _ColorReader();

@@ -57,14 +60,12 @@ class EquipmentTypeId {
  factory EquipmentTypeId.fromValue(int value) {
    final result = values[value];
    if (result == null) {
-      throw StateError(
-        'Invalid value $value for bit flag enum EquipmentTypeId',
-      );
+      throw StateError('Invalid value $value for bit flag enum EquipmentTypeId');
    }
    return result;
  }

-  static EquipmentTypeId? _createOrNull(int? value) =>
+  static EquipmentTypeId? _createOrNull(int? value) => 
      value == null ? null : EquipmentTypeId.fromValue(value);

  static const int minValue = 0;
@@ -73,7 +74,9 @@ class EquipmentTypeId {

  static const EquipmentTypeId NONE = EquipmentTypeId._(0);
  static const EquipmentTypeId Weapon = EquipmentTypeId._(1);
-  static const Map<int, EquipmentTypeId> values = {0: NONE, 1: Weapon};
+  static const Map<int, EquipmentTypeId> values = {
+    0: NONE,
+    1: Weapon};

  static const fb.Reader<EquipmentTypeId> reader = _EquipmentTypeIdReader();

@@ -119,7 +122,8 @@ class _Vec3Reader extends fb.StructReader<Vec3> {
  int get size => 12;

  @override
-  Vec3 createObject(fb.BufferContext bc, int offset) => Vec3._(bc, offset);
+  Vec3 createObject(fb.BufferContext bc, int offset) => 
+    Vec3._(bc, offset);
 }

 class Vec3Builder {
@@ -133,6 +137,7 @@ class Vec3Builder {
    fbBuilder.putFloat32(x);
    return fbBuilder.offset;
  }
+
 }

 class Vec3ObjectBuilder extends fb.ObjectBuilder {
@@ -140,10 +145,14 @@ class Vec3ObjectBuilder extends fb.ObjectBuilder {
  final double _y;
  final double _z;

-  Vec3ObjectBuilder({required double x, required double y, required double z})
-    : _x = x,
-      _y = y,
-      _z = z;
+  Vec3ObjectBuilder({
+    required double x,
+    required double y,
+    required double z,
+  })
+      : _x = x,
+        _y = y,
+        _z = z;

  /// Finish building, and store into the [fbBuilder].
  @override
@@ -162,7 +171,6 @@ class Vec3ObjectBuilder extends fb.ObjectBuilder {
    return fbBuilder.buffer;
  }
 }
-
 class Monster {
  Monster._(this._bc, this._bcOffset);
  factory Monster(List<int> bytes) {
@@ -178,30 +186,18 @@ class Monster {
  Vec3? get pos => Vec3.reader.vTableGetNullable(_bc, _bcOffset, 4);
  int get mana => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 6, 150);
  int get hp => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 8, 100);
-  String? get name =>
-      const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 10);
-  List<int>? get inventory =>
-      const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 14);
-  Color get color =>
-      Color.fromValue(const fb.Int8Reader().vTableGet(_bc, _bcOffset, 16, 2));
-  List<Weapon>? get weapons => const fb.ListReader<Weapon>(
-    Weapon.reader,
-  ).vTableGetNullable(_bc, _bcOffset, 18);
-  EquipmentTypeId? get equippedType => EquipmentTypeId._createOrNull(
-    const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 20),
-  );
+  String? get name => const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 10);
+  List<int>? get inventory => const fb.Uint8ListReader().vTableGetNullable(_bc, _bcOffset, 14);
+  Color get color => Color.fromValue(const fb.Int8Reader().vTableGet(_bc, _bcOffset, 16, 2));
+  List<Weapon>? get weapons => const fb.ListReader<Weapon>(Weapon.reader).vTableGetNullable(_bc, _bcOffset, 18);
+  EquipmentTypeId? get equippedType => EquipmentTypeId._createOrNull(const fb.Uint8Reader().vTableGetNullable(_bc, _bcOffset, 20));
  dynamic get equipped {
    switch (equippedType?.value) {
-      case 1:
-        return Weapon.reader.vTableGetNullable(_bc, _bcOffset, 22);
-      default:
-        return null;
+      case 1: return Weapon.reader.vTableGetNullable(_bc, _bcOffset, 22);
+      default: return null;
    }
  }
-
-  List<Vec3>? get path => const fb.ListReader<Vec3>(
-    Vec3.reader,
-  ).vTableGetNullable(_bc, _bcOffset, 24);
+  List<Vec3>? get path => const fb.ListReader<Vec3>(Vec3.reader).vTableGetNullable(_bc, _bcOffset, 24);

  @override
  String toString() {
@@ -213,8 +209,8 @@ class _MonsterReader extends fb.TableReader<Monster> {
  const _MonsterReader();

  @override
-  Monster createObject(fb.BufferContext bc, int offset) =>
-      Monster._(bc, offset);
+  Monster createObject(fb.BufferContext bc, int offset) => 
+    Monster._(bc, offset);
 }

 class MonsterBuilder {
@@ -230,47 +226,38 @@ class MonsterBuilder {
    fbBuilder.addStruct(0, offset);
    return fbBuilder.offset;
  }
-
  int addMana(int? mana) {
    fbBuilder.addInt16(1, mana);
    return fbBuilder.offset;
  }
-
  int addHp(int? hp) {
    fbBuilder.addInt16(2, hp);
    return fbBuilder.offset;
  }
-
  int addNameOffset(int? offset) {
    fbBuilder.addOffset(3, offset);
    return fbBuilder.offset;
  }
-
  int addInventoryOffset(int? offset) {
    fbBuilder.addOffset(5, offset);
    return fbBuilder.offset;
  }
-
  int addColor(Color? color) {
    fbBuilder.addInt8(6, color?.value);
    return fbBuilder.offset;
  }
-
  int addWeaponsOffset(int? offset) {
    fbBuilder.addOffset(7, offset);
    return fbBuilder.offset;
  }
-
  int addEquippedType(EquipmentTypeId? equippedType) {
    fbBuilder.addUint8(8, equippedType?.value);
    return fbBuilder.offset;
  }
-
  int addEquippedOffset(int? offset) {
    fbBuilder.addOffset(9, offset);
    return fbBuilder.offset;
  }
-
  int addPathOffset(int? offset) {
    fbBuilder.addOffset(10, offset);
    return fbBuilder.offset;
@@ -304,34 +291,29 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
    EquipmentTypeId? equippedType,
    dynamic equipped,
    List<Vec3ObjectBuilder>? path,
-  }) : _pos = pos,
-       _mana = mana,
-       _hp = hp,
-       _name = name,
-       _inventory = inventory,
-       _color = color,
-       _weapons = weapons,
-       _equippedType = equippedType,
-       _equipped = equipped,
-       _path = path;
+  })
+      : _pos = pos,
+        _mana = mana,
+        _hp = hp,
+        _name = name,
+        _inventory = inventory,
+        _color = color,
+        _weapons = weapons,
+        _equippedType = equippedType,
+        _equipped = equipped,
+        _path = path;

  /// Finish building, and store into the [fbBuilder].
  @override
  int finish(fb.Builder fbBuilder) {
-    final int? nameOffset = _name == null
-        ? null
+    final int? nameOffset = _name == null ? null
        : fbBuilder.writeString(_name!);
-    final int? inventoryOffset = _inventory == null
-        ? null
+    final int? inventoryOffset = _inventory == null ? null
        : fbBuilder.writeListUint8(_inventory!);
-    final int? weaponsOffset = _weapons == null
-        ? null
-        : fbBuilder.writeList(
-            _weapons!.map((b) => b.getOrCreateOffset(fbBuilder)).toList(),
-          );
+    final int? weaponsOffset = _weapons == null ? null
+        : fbBuilder.writeList(_weapons!.map((b) => b.getOrCreateOffset(fbBuilder)).toList());
    final int? equippedOffset = _equipped?.getOrCreateOffset(fbBuilder);
-    final int? pathOffset = _path == null
-        ? null
+    final int? pathOffset = _path == null ? null
        : fbBuilder.writeListOfStructs(_path!);
    fbBuilder.startTable(10);
    if (_pos != null) {
@@ -357,7 +339,6 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
    return fbBuilder.buffer;
  }
 }
-
 class Weapon {
  Weapon._(this._bc, this._bcOffset);
  factory Weapon(List<int> bytes) {
@@ -370,8 +351,7 @@ class Weapon {
  final fb.BufferContext _bc;
  final int _bcOffset;

-  String? get name =>
-      const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 4);
+  String? get name => const fb.StringReader().vTableGetNullable(_bc, _bcOffset, 4);
  int get damage => const fb.Int16Reader().vTableGet(_bc, _bcOffset, 6, 0);

  @override
@@ -384,7 +364,8 @@ class _WeaponReader extends fb.TableReader<Weapon> {
  const _WeaponReader();

  @override
-  Weapon createObject(fb.BufferContext bc, int offset) => Weapon._(bc, offset);
+  Weapon createObject(fb.BufferContext bc, int offset) => 
+    Weapon._(bc, offset);
 }

 class WeaponBuilder {
@@ -400,7 +381,6 @@ class WeaponBuilder {
    fbBuilder.addOffset(0, offset);
    return fbBuilder.offset;
  }
-
  int addDamage(int? damage) {
    fbBuilder.addInt16(1, damage);
    return fbBuilder.offset;
@@ -415,15 +395,17 @@ class WeaponObjectBuilder extends fb.ObjectBuilder {
  final String? _name;
  final int? _damage;

-  WeaponObjectBuilder({String? name, int? damage})
-    : _name = name,
-      _damage = damage;
+  WeaponObjectBuilder({
+    String? name,
+    int? damage,
+  })
+      : _name = name,
+        _damage = damage;

  /// Finish building, and store into the [fbBuilder].
  @override
  int finish(fb.Builder fbBuilder) {
-    final int? nameOffset = _name == null
-        ? null
+    final int? nameOffset = _name == null ? null
        : fbBuilder.writeString(_name!);
    fbBuilder.startTable(2);
    fbBuilder.addOffset(0, nameOffset);
--- a/dart/lib/flat_buffers.dart
+++ b/dart/lib/flat_buffers.dart
@@ -27,11 +27,10 @@ class BufferContext {
  ByteData get buffer => _buffer;

  /// Create from a FlatBuffer represented by a list of bytes (uint8).
-  factory BufferContext.fromBytes(List<int> byteList) => BufferContext(
-    byteList is Uint8List
-        ? byteList.buffer.asByteData(byteList.offsetInBytes)
-        : ByteData.view(Uint8List.fromList(byteList).buffer),
-  );
+  factory BufferContext.fromBytes(List<int> byteList) =>
+      BufferContext(byteList is Uint8List
+          ? byteList.buffer.asByteData(byteList.offsetInBytes)
+          : ByteData.view(Uint8List.fromList(byteList).buffer));

  /// Create from a FlatBuffer represented by ByteData.
  BufferContext(this._buffer);
@@ -150,9 +149,9 @@ class Builder {
    bool internStrings = false,
    Allocator allocator = const DefaultAllocator(),
    this.deduplicateTables = true,
-  }) : _allocator = allocator,
-       _buf = allocator.allocate(initialSize),
-       _vTables = deduplicateTables ? [] : const [] {
+  })  : _allocator = allocator,
+        _buf = allocator.allocate(initialSize),
+        _vTables = deduplicateTables ? [] : const [] {
    if (internStrings) {
      _strings = <String, int>{};
    }
@@ -351,10 +350,8 @@ class Builder {
  Uint8List get buffer {
    assert(_finished);
    final finishedSize = size();
-    return _buf.buffer.asUint8List(
-      _buf.lengthInBytes - finishedSize,
-      finishedSize,
-    );
+    return _buf.buffer
+        .asUint8List(_buf.lengthInBytes - finishedSize, finishedSize);
  }

  /// Finish off the creation of the buffer.  The given [offset] is used as the
@@ -371,18 +368,14 @@ class Builder {
    if (fileIdentifier != null) {
      for (var i = 0; i < 4; i++) {
        _setUint8AtTail(
-          finishedSize - _sizeofUint32 - i,
-          fileIdentifier.codeUnitAt(i),
-        );
+            finishedSize - _sizeofUint32 - i, fileIdentifier.codeUnitAt(i));
      }
    }

    // zero out the added padding
-    for (
-      var i = sizeBeforePadding + 1;
-      i <= finishedSize - requiredBytes;
-      i++
-    ) {
+    for (var i = sizeBeforePadding + 1;
+        i <= finishedSize - requiredBytes;
+        i++) {
      _setUint8AtTail(i, 0);
    }
    _finished = true;
@@ -393,7 +386,7 @@ class Builder {
  /// Updates the [offset] pointer.  This method is intended for use when writing structs to the buffer.
  void putFloat64(double value) {
    _prepare(_sizeofFloat64, 1);
-    _setFloat64AtTail(_tail, value);
+    _setFloat32AtTail(_tail, value);
  }

  /// Writes a Float32 to the tail of the buffer after preparing space for it.
@@ -694,10 +687,8 @@ class Builder {
  int writeString(String value, {bool asciiOptimization = false}) {
    assert(!_inVTable);
    if (_strings != null) {
-      return _strings!.putIfAbsent(
-        value,
-        () => _writeString(value, asciiOptimization),
-      );
+      return _strings!
+          .putIfAbsent(value, () => _writeString(value, asciiOptimization));
    } else {
      return _writeString(value, asciiOptimization);
    }
@@ -1014,11 +1005,8 @@ class ListReader<E> extends Reader<List<E>> {
        : List<E>.generate(
            bc.buffer.getUint32(listOffset, Endian.little),
            (int index) => _elementReader.read(
-              bc,
-              listOffset + size + _elementReader.size * index,
-            ),
-            growable: true,
-          );
+                bc, listOffset + size + _elementReader.size * index),
+            growable: true);
  }
 }

@@ -1296,7 +1284,7 @@ class _FbGenericList<E> extends _FbList<E> {
  List<E?>? _items;

  _FbGenericList(this.elementReader, BufferContext bp, int offset)
-    : super(bp, offset);
+      : super(bp, offset);

  @override
  @pragma('vm:prefer-inline')
@@ -1466,11 +1454,7 @@ abstract class Allocator {
  /// Params [inUseBack] and [inUseFront] indicate how much of [oldData] is
  /// actually in use at each end, and needs to be copied.
  ByteData resize(
-    ByteData oldData,
-    int newSize,
-    int inUseBack,
-    int inUseFront,
-  ) {
+      ByteData oldData, int newSize, int inUseBack, int inUseFront) {
    final newData = allocate(newSize);
    _copyDownward(oldData, newData, inUseBack, inUseFront);
    deallocate(oldData);
@@ -1481,25 +1465,17 @@ abstract class Allocator {
  /// memory of size [inUseFront] and [inUseBack] will be copied from the front
  /// and back of the old memory allocation.
  void _copyDownward(
-    ByteData oldData,
-    ByteData newData,
-    int inUseBack,
-    int inUseFront,
-  ) {
+      ByteData oldData, ByteData newData, int inUseBack, int inUseFront) {
    if (inUseBack != 0) {
      newData.buffer.asUint8List().setAll(
-        newData.lengthInBytes - inUseBack,
-        oldData.buffer.asUint8List().getRange(
-          oldData.lengthInBytes - inUseBack,
-          oldData.lengthInBytes,
-        ),
-      );
+          newData.lengthInBytes - inUseBack,
+          oldData.buffer.asUint8List().getRange(
+              oldData.lengthInBytes - inUseBack, oldData.lengthInBytes));
    }
    if (inUseFront != 0) {
-      newData.buffer.asUint8List().setAll(
-        0,
-        oldData.buffer.asUint8List().getRange(0, inUseFront),
-      );
+      newData.buffer
+          .asUint8List()
+          .setAll(0, oldData.buffer.asUint8List().getRange(0, inUseFront));
    }
  }
 }
--- a/dart/lib/src/builder.dart
+++ b/dart/lib/src/builder.dart
@@ -107,11 +107,8 @@ class Builder {
    final newOffset = _newOffset(length + 1);
    _pushBuffer(utf8String);
    _offset = newOffset;
-    final stackValue = _StackValue.withOffset(
-      stringOffset,
-      ValueType.String,
-      bitWidth,
-    );
+    final stackValue =
+        _StackValue.withOffset(stringOffset, ValueType.String, bitWidth);
    _stack.add(stackValue);
    _stringCache[value] = stackValue;
  }
@@ -131,11 +128,8 @@ class Builder {
    final newOffset = _newOffset(length + 1);
    _pushBuffer(utf8String);
    _offset = newOffset;
-    final stackValue = _StackValue.withOffset(
-      keyOffset,
-      ValueType.Key,
-      BitWidth.width8,
-    );
+    final stackValue =
+        _StackValue.withOffset(keyOffset, ValueType.Key, BitWidth.width8);
    _stack.add(stackValue);
    _keyCache[value] = stackValue;
  }
@@ -153,11 +147,8 @@ class Builder {
    final newOffset = _newOffset(length);
    _pushBuffer(value.asUint8List());
    _offset = newOffset;
-    final stackValue = _StackValue.withOffset(
-      blobOffset,
-      ValueType.Blob,
-      bitWidth,
-    );
+    final stackValue =
+        _StackValue.withOffset(blobOffset, ValueType.Blob, bitWidth);
    _stack.add(stackValue);
  }

@@ -179,10 +170,7 @@ class Builder {
    final valueOffset = _offset;
    _pushBuffer(stackValue.asU8List(stackValue.width));
    final stackOffset = _StackValue.withOffset(
-      valueOffset,
-      ValueType.IndirectInt,
-      stackValue.width,
-    );
+        valueOffset, ValueType.IndirectInt, stackValue.width);
    _stack.add(stackOffset);
    _offset = newOffset;
    if (cache) {
@@ -207,10 +195,7 @@ class Builder {
    final valueOffset = _offset;
    _pushBuffer(stackValue.asU8List(stackValue.width));
    final stackOffset = _StackValue.withOffset(
-      valueOffset,
-      ValueType.IndirectFloat,
-      stackValue.width,
-    );
+        valueOffset, ValueType.IndirectFloat, stackValue.width);
    _stack.add(stackOffset);
    _offset = newOffset;
    if (cache) {
@@ -267,10 +252,9 @@ class Builder {
    tmp._offset = _offset;
    tmp._stack = List.from(_stack);
    tmp._stackPointers = List.from(_stackPointers);
-    tmp._buffer.buffer.asUint8List().setAll(
-      0,
-      _buffer.buffer.asUint8List(0, _offset),
-    );
+    tmp._buffer.buffer
+        .asUint8List()
+        .setAll(0, _buffer.buffer.asUint8List(0, _offset));
    for (var i = 0; i < tmp._stackPointers.length; i++) {
      tmp.end();
    }
@@ -287,8 +271,7 @@ class Builder {
    if (_stackPointers.isNotEmpty && _stackPointers.last.isVector == false) {
      if (_stack.last.type != ValueType.Key) {
        throw StateError(
-          'Adding value to a map before adding a key is prohibited',
-        );
+            'Adding value to a map before adding a key is prohibited');
      }
    }
  }
@@ -305,8 +288,7 @@ class Builder {
  void _finish() {
    if (_stack.length != 1) {
      throw StateError(
-        'Stack has to be exactly 1, but is ${_stack.length}. You have to end all started vectors and maps, before calling [finish]',
-      );
+          'Stack has to be exactly 1, but is ${_stack.length}. You have to end all started vectors and maps, before calling [finish]');
    }
    final value = _stack[0];
    final byteWidth = _align(value.elementWidth(_offset, 0));
@@ -316,12 +298,8 @@ class Builder {
    _finished = true;
  }

-  _StackValue _createVector(
-    int start,
-    int vecLength,
-    int step, [
-    _StackValue? keys,
-  ]) {
+  _StackValue _createVector(int start, int vecLength, int step,
+      [_StackValue? keys]) {
    var bitWidth = BitWidthUtil.uwidth(vecLength);
    var prefixElements = 1;
    if (keys != null) {
@@ -348,8 +326,7 @@ class Builder {
      }
    }
    final byteWidth = _align(bitWidth);
-    final fix =
-        typed & ValueTypeUtils.isNumber(vectorType) &&
+    final fix = typed & ValueTypeUtils.isNumber(vectorType) &&
        vecLength >= 2 &&
        vecLength <= 4;
    if (keys != null) {
@@ -372,10 +349,8 @@ class Builder {
      return _StackValue.withOffset(vecOffset, ValueType.Map, bitWidth);
    }
    if (typed) {
-      final vType = ValueTypeUtils.toTypedVector(
-        vectorType,
-        fix ? vecLength : 0,
-      );
+      final vType =
+          ValueTypeUtils.toTypedVector(vectorType, fix ? vecLength : 0);
      return _StackValue.withOffset(vecOffset, vType, bitWidth);
    }
    return _StackValue.withOffset(vecOffset, ValueType.Vector, bitWidth);
@@ -391,8 +366,7 @@ class Builder {
  void _sortKeysAndEndMap(_StackPointer pointer) {
    if (((_stack.length - pointer.stackPosition) & 1) == 1) {
      throw StateError(
-        'The stack needs to hold key value pairs (even number of elements). Check if you combined [addKey] with add... method calls properly.',
-      );
+          'The stack needs to hold key value pairs (even number of elements). Check if you combined [addKey] with add... method calls properly.');
    }

    var sorted = true;
@@ -438,12 +412,8 @@ class Builder {
      keysStackValue = _createVector(pointer.stackPosition, vecLength, 2);
      _keyVectorCache[keysHash] = keysStackValue;
    }
-    final vec = _createVector(
-      pointer.stackPosition + 1,
-      vecLength,
-      2,
-      keysStackValue,
-    );
+    final vec =
+        _createVector(pointer.stackPosition + 1, vecLength, 2, keysStackValue);
    _stack.removeRange(pointer.stackPosition, _stack.length);
    _stack.add(vec);
  }
@@ -451,8 +421,7 @@ class Builder {
  bool _shouldFlip(_StackValue v1, _StackValue v2) {
    if (v1.type != ValueType.Key || v2.type != ValueType.Key) {
      throw StateError(
-        'Stack values are not keys $v1 | $v2. Check if you combined [addKey] with add... method calls properly.',
-      );
+          'Stack values are not keys $v1 | $v2. Check if you combined [addKey] with add... method calls properly.');
    }

    late int c1, c2;
@@ -481,8 +450,7 @@ class Builder {
        _writeUInt(relativeOffset, byteWidth);
      } else {
        throw StateError(
-          'Unexpected size $byteWidth. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new',
-        );
+            'Unexpected size $byteWidth. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new');
      }
    } else {
      _pushBuffer(value.asU8List(BitWidthUtil.fromByteWidth(byteWidth)));
@@ -555,27 +523,29 @@ class _StackValue {
  final ValueType _type;
  final BitWidth _width;

-  _StackValue.withNull() : _type = ValueType.Null, _width = BitWidth.width8;
+  _StackValue.withNull()
+      : _type = ValueType.Null,
+        _width = BitWidth.width8;

  _StackValue.withInt(int value)
-    : _type = ValueType.Int,
-      _width = BitWidthUtil.width(value),
-      _value = value;
+      : _type = ValueType.Int,
+        _width = BitWidthUtil.width(value),
+        _value = value;

  _StackValue.withBool(bool value)
-    : _type = ValueType.Bool,
-      _width = BitWidth.width8,
-      _value = value;
+      : _type = ValueType.Bool,
+        _width = BitWidth.width8,
+        _value = value;

  _StackValue.withDouble(double value)
-    : _type = ValueType.Float,
-      _width = BitWidthUtil.width(value),
-      _value = value;
+      : _type = ValueType.Float,
+        _width = BitWidthUtil.width(value),
+        _value = value;

  _StackValue.withOffset(int value, ValueType type, BitWidth width)
-    : _offset = value,
-      _type = type,
-      _width = width;
+      : _offset = value,
+        _type = type,
+        _width = width;

  BitWidth storedWidth({BitWidth width = BitWidth.width8}) {
    return ValueTypeUtils.isInline(_type)
@@ -592,16 +562,16 @@ class _StackValue {
    final offset = _offset!;
    for (var i = 0; i < 4; i++) {
      final width = 1 << i;
-      final bitWidth = BitWidthUtil.uwidth(
-        size + BitWidthUtil.paddingSize(size, width) + index * width - offset,
-      );
+      final bitWidth = BitWidthUtil.uwidth(size +
+          BitWidthUtil.paddingSize(size, width) +
+          index * width -
+          offset);
      if (1 << bitWidth.index == width) {
        return bitWidth;
      }
    }
    throw StateError(
-      'Element is of unknown. Size: $size at index: $index. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new',
-    );
+        'Element is of unknown. Size: $size at index: $index. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new');
  }

  List<int> asU8List(BitWidth width) {
@@ -649,8 +619,7 @@ class _StackValue {
    }

    throw StateError(
-      'Unexpected type: $_type. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new',
-    );
+        'Unexpected type: $_type. This might be a bug. Please create an issue https://github.com/google/flatbuffers/issues/new');
  }

  ValueType get type {
--- a/dart/lib/src/reference.dart
+++ b/dart/lib/src/reference.dart
@@ -1,7 +1,6 @@
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:typed_data';
-
 import 'types.dart';

 /// Main class to read a value out of a FlexBuffer.
@@ -17,15 +16,10 @@ class Reference {
  int? _length;

  Reference._(
-    this._buffer,
-    this._offset,
-    this._parentWidth,
-    int packedType,
-    this._path, [
-    int? byteWidth,
-    ValueType? valueType,
-  ]) : _byteWidth = byteWidth ?? 1 << (packedType & 3),
-       _valueType = valueType ?? ValueTypeUtils.fromInt(packedType >> 2);
+      this._buffer, this._offset, this._parentWidth, int packedType, this._path,
+      [int? byteWidth, ValueType? valueType])
+      : _byteWidth = byteWidth ?? 1 << (packedType & 3),
+        _valueType = valueType ?? ValueTypeUtils.fromInt(packedType >> 2);

  /// Use this method to access the root value of a FlexBuffer.
  static Reference fromBuffer(ByteBuffer buffer) {
@@ -37,13 +31,8 @@ class Reference {
    final byteWidth = byteData.getUint8(len - 1);
    final packedType = byteData.getUint8(len - 2);
    final offset = len - byteWidth - 2;
-    return Reference._(
-      ByteData.view(buffer),
-      offset,
-      BitWidthUtil.fromByteWidth(byteWidth),
-      packedType,
-      "/",
-    );
+    return Reference._(ByteData.view(buffer), offset,
+        BitWidthUtil.fromByteWidth(byteWidth), packedType, "/");
  }

  /// Returns true if the underlying value is null.
@@ -149,8 +138,7 @@ class Reference {
      final index = key;
      if (index >= length || index < 0) {
        throw ArgumentError(
-          'Key: [$key] is not applicable on: $_path of: $_valueType length: $length',
-        );
+            'Key: [$key] is not applicable on: $_path of: $_valueType length: $length');
      }
      final elementOffset = _indirect + index * _byteWidth;
      int packedType = 0;
@@ -166,14 +154,13 @@ class Reference {
        packedType = _buffer.getUint8(_indirect + length * _byteWidth + index);
      }
      return Reference._(
-        _buffer,
-        elementOffset,
-        BitWidthUtil.fromByteWidth(_byteWidth),
-        packedType,
-        "$_path[$index]",
-        byteWidth,
-        valueType,
-      );
+          _buffer,
+          elementOffset,
+          BitWidthUtil.fromByteWidth(_byteWidth),
+          packedType,
+          "$_path[$index]",
+          byteWidth,
+          valueType);
    }
    if (key is String && _valueType == ValueType.Map) {
      final index = _keyIndex(key);
@@ -182,8 +169,7 @@ class Reference {
      }
    }
    throw ArgumentError(
-      'Key: [$key] is not applicable on: $_path of: $_valueType',
-    );
+        'Key: [$key] is not applicable on: $_path of: $_valueType');
  }

  /// Get an iterable if the underlying flexBuffer value is a vector.
@@ -227,24 +213,18 @@ class Reference {
          ValueTypeUtils.isAVector(_valueType) ||
          _valueType == ValueType.Map) {
        _length = _readUInt(
-          _indirect - _byteWidth,
-          BitWidthUtil.fromByteWidth(_byteWidth),
-        );
+            _indirect - _byteWidth, BitWidthUtil.fromByteWidth(_byteWidth));
      } else if (_valueType == ValueType.Null) {
        _length = 0;
      } else if (_valueType == ValueType.String) {
        final indirect = _indirect;
        var sizeByteWidth = _byteWidth;
-        var size = _readUInt(
-          indirect - sizeByteWidth,
-          BitWidthUtil.fromByteWidth(sizeByteWidth),
-        );
+        var size = _readUInt(indirect - sizeByteWidth,
+            BitWidthUtil.fromByteWidth(sizeByteWidth));
        while (_buffer.getInt8(indirect + size) != 0) {
          sizeByteWidth <<= 1;
-          size = _readUInt(
-            indirect - sizeByteWidth,
-            BitWidthUtil.fromByteWidth(sizeByteWidth),
-          );
+          size = _readUInt(indirect - sizeByteWidth,
+              BitWidthUtil.fromByteWidth(sizeByteWidth));
        }
        _length = size;
      } else if (_valueType == ValueType.Key) {
@@ -309,8 +289,7 @@ class Reference {
      return result.toString();
    }
    throw UnsupportedError(
-      'Type: $_valueType is not supported for JSON conversion',
-    );
+        'Type: $_valueType is not supported for JSON conversion');
  }

  /// Computes the indirect offset of the value.
@@ -375,13 +354,10 @@ class Reference {
  int? _keyIndex(String key) {
    final input = utf8.encode(key);
    final keysVectorOffset = _indirect - _byteWidth * 3;
-    final indirectOffset =
-        keysVectorOffset -
+    final indirectOffset = keysVectorOffset -
        _readUInt(keysVectorOffset, BitWidthUtil.fromByteWidth(_byteWidth));
    final byteWidth = _readUInt(
-      keysVectorOffset + _byteWidth,
-      BitWidthUtil.fromByteWidth(_byteWidth),
-    );
+        keysVectorOffset + _byteWidth, BitWidthUtil.fromByteWidth(_byteWidth));
    var low = 0;
    var high = length - 1;
    while (low <= high) {
@@ -414,37 +390,24 @@ class Reference {
    final indirect = _indirect;
    final elementOffset = indirect + index * _byteWidth;
    final packedType = _buffer.getUint8(indirect + length * _byteWidth + index);
-    return Reference._(
-      _buffer,
-      elementOffset,
-      BitWidthUtil.fromByteWidth(_byteWidth),
-      packedType,
-      "$_path/$key",
-    );
+    return Reference._(_buffer, elementOffset,
+        BitWidthUtil.fromByteWidth(_byteWidth), packedType, "$_path/$key");
  }

  Reference _valueForIndex(int index) {
    final indirect = _indirect;
    final elementOffset = indirect + index * _byteWidth;
    final packedType = _buffer.getUint8(indirect + length * _byteWidth + index);
-    return Reference._(
-      _buffer,
-      elementOffset,
-      BitWidthUtil.fromByteWidth(_byteWidth),
-      packedType,
-      "$_path/[$index]",
-    );
+    return Reference._(_buffer, elementOffset,
+        BitWidthUtil.fromByteWidth(_byteWidth), packedType, "$_path/[$index]");
  }

  String _keyForIndex(int index) {
    final keysVectorOffset = _indirect - _byteWidth * 3;
-    final indirectOffset =
-        keysVectorOffset -
+    final indirectOffset = keysVectorOffset -
        _readUInt(keysVectorOffset, BitWidthUtil.fromByteWidth(_byteWidth));
    final byteWidth = _readUInt(
-      keysVectorOffset + _byteWidth,
-      BitWidthUtil.fromByteWidth(_byteWidth),
-    );
+        keysVectorOffset + _byteWidth, BitWidthUtil.fromByteWidth(_byteWidth));
    final keyOffset = indirectOffset + index * byteWidth;
    final keyIndirectOffset =
        keyOffset - _readUInt(keyOffset, BitWidthUtil.fromByteWidth(byteWidth));
--- a/dart/lib/src/types.dart
+++ b/dart/lib/src/types.dart
@@ -86,8 +86,7 @@ enum ValueType {
  VectorFloat,
  VectorKey,
  @Deprecated(
-    'VectorString is deprecated due to a flaw in the binary format (https://github.com/google/flatbuffers/issues/5627)',
-  )
+      'VectorString is deprecated due to a flaw in the binary format (https://github.com/google/flatbuffers/issues/5627)')
  VectorString,
  VectorInt2,
  VectorUInt2,
@@ -100,7 +99,7 @@ enum ValueType {
  VectorFloat4,
  Blob,
  Bool,
-  VectorBool,
+  VectorBool
 }

 class ValueTypeUtils {
@@ -154,37 +153,31 @@ class ValueTypeUtils {
  static ValueType toTypedVector(ValueType self, int length) {
    if (length == 0) {
      return ValueTypeUtils.fromInt(
-        toInt(self) - toInt(ValueType.Int) + toInt(ValueType.VectorInt),
-      );
+          toInt(self) - toInt(ValueType.Int) + toInt(ValueType.VectorInt));
    }
    if (length == 2) {
      return ValueTypeUtils.fromInt(
-        toInt(self) - toInt(ValueType.Int) + toInt(ValueType.VectorInt2),
-      );
+          toInt(self) - toInt(ValueType.Int) + toInt(ValueType.VectorInt2));
    }
    if (length == 3) {
      return ValueTypeUtils.fromInt(
-        toInt(self) - toInt(ValueType.Int) + toInt(ValueType.VectorInt3),
-      );
+          toInt(self) - toInt(ValueType.Int) + toInt(ValueType.VectorInt3));
    }
    if (length == 4) {
      return ValueTypeUtils.fromInt(
-        toInt(self) - toInt(ValueType.Int) + toInt(ValueType.VectorInt4),
-      );
+          toInt(self) - toInt(ValueType.Int) + toInt(ValueType.VectorInt4));
    }
    throw Exception('unexpected length ' + length.toString());
  }

  static ValueType typedVectorElementType(ValueType self) {
    return ValueTypeUtils.fromInt(
-      toInt(self) - toInt(ValueType.VectorInt) + toInt(ValueType.Int),
-    );
+        toInt(self) - toInt(ValueType.VectorInt) + toInt(ValueType.Int));
  }

  static ValueType fixedTypedVectorElementType(ValueType self) {
    return ValueTypeUtils.fromInt(
-      (toInt(self) - toInt(ValueType.VectorInt2)) % 3 + toInt(ValueType.Int),
-    );
+        (toInt(self) - toInt(ValueType.VectorInt2)) % 3 + toInt(ValueType.Int));
  }

  static int fixedTypedVectorElementSize(ValueType self) {
--- a/dart/pubspec.yaml
+++ b/dart/pubspec.yaml
@@ -1,11 +1,11 @@
 name: flat_buffers
-version: 25.9.23
+version: 24.3.6
 description: FlatBuffers reading and writing library for Dart. Based on original work by Konstantin Scheglov and Paul Berry of the Dart SDK team.
 homepage: https://github.com/google/flatbuffers
 documentation: https://google.github.io/flatbuffers/index.html

 environment:
-  sdk: '>=2.17.0 <4.0.0'
+  sdk: '>=2.12.0 <4.0.0'

 dev_dependencies:
  test: ^1.17.7
--- a/dart/test/bool_structs_generated.dart
+++ b/dart/test/bool_structs_generated.dart
@@ -1,10 +1,10 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names
+// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable

 import 'dart:typed_data' show Uint8List;
-
 import 'package:flat_buffers/flat_buffers.dart' as fb;

+
 class Foo {
  Foo._(this._bc, this._bcOffset);
  factory Foo(List<int> bytes) {
@@ -17,15 +17,15 @@ class Foo {
  final fb.BufferContext _bc;
  final int _bcOffset;

-  FooProperties? get myFoo =>
-      FooProperties.reader.vTableGetNullable(_bc, _bcOffset, 4);
+  FooProperties? get myFoo => FooProperties.reader.vTableGetNullable(_bc, _bcOffset, 4);

  @override
  String toString() {
    return 'Foo{myFoo: ${myFoo}}';
  }

-  FooT unpack() => FooT(myFoo: myFoo?.unpack());
+  FooT unpack() => FooT(
+      myFoo: myFoo?.unpack());

  static int pack(fb.Builder fbBuilder, FooT? object) {
    if (object == null) return 0;
@@ -36,7 +36,8 @@ class Foo {
 class FooT implements fb.Packable {
  FooPropertiesT? myFoo;

-  FooT({this.myFoo});
+  FooT({
+      this.myFoo});

  @override
  int pack(fb.Builder fbBuilder) {
@@ -57,7 +58,8 @@ class _FooReader extends fb.TableReader<Foo> {
  const _FooReader();

  @override
-  Foo createObject(fb.BufferContext bc, int offset) => Foo._(bc, offset);
+  Foo createObject(fb.BufferContext bc, int offset) => 
+    Foo._(bc, offset);
 }

 class FooBuilder {
@@ -82,7 +84,10 @@ class FooBuilder {
 class FooObjectBuilder extends fb.ObjectBuilder {
  final FooPropertiesObjectBuilder? _myFoo;

-  FooObjectBuilder({FooPropertiesObjectBuilder? myFoo}) : _myFoo = myFoo;
+  FooObjectBuilder({
+    FooPropertiesObjectBuilder? myFoo,
+  })
+      : _myFoo = myFoo;

  /// Finish building, and store into the [fbBuilder].
  @override
@@ -102,7 +107,6 @@ class FooObjectBuilder extends fb.ObjectBuilder {
    return fbBuilder.buffer;
  }
 }
-
 class FooProperties {
  FooProperties._(this._bc, this._bcOffset);

@@ -119,7 +123,9 @@ class FooProperties {
    return 'FooProperties{a: ${a}, b: ${b}}';
  }

-  FooPropertiesT unpack() => FooPropertiesT(a: a, b: b);
+  FooPropertiesT unpack() => FooPropertiesT(
+      a: a,
+      b: b);

  static int pack(fb.Builder fbBuilder, FooPropertiesT? object) {
    if (object == null) return 0;
@@ -131,7 +137,9 @@ class FooPropertiesT implements fb.Packable {
  bool a;
  bool b;

-  FooPropertiesT({required this.a, required this.b});
+  FooPropertiesT({
+      required this.a,
+      required this.b});

  @override
  int pack(fb.Builder fbBuilder) {
@@ -153,8 +161,8 @@ class _FooPropertiesReader extends fb.StructReader<FooProperties> {
  int get size => 2;

  @override
-  FooProperties createObject(fb.BufferContext bc, int offset) =>
-      FooProperties._(bc, offset);
+  FooProperties createObject(fb.BufferContext bc, int offset) => 
+    FooProperties._(bc, offset);
 }

 class FooPropertiesBuilder {
@@ -167,15 +175,19 @@ class FooPropertiesBuilder {
    fbBuilder.putBool(a);
    return fbBuilder.offset;
  }
+
 }

 class FooPropertiesObjectBuilder extends fb.ObjectBuilder {
  final bool _a;
  final bool _b;

-  FooPropertiesObjectBuilder({required bool a, required bool b})
-    : _a = a,
-      _b = b;
+  FooPropertiesObjectBuilder({
+    required bool a,
+    required bool b,
+  })
+      : _a = a,
+        _b = b;

  /// Finish building, and store into the [fbBuilder].
  @override
--- a/dart/test/flat_buffers_test.dart
+++ b/dart/test/flat_buffers_test.dart
@@ -1,15 +1,16 @@
-import 'dart:io' as io;
 import 'dart:typed_data';
+import 'dart:io' as io;
+
+import 'package:path/path.dart' as path;

 import 'package:flat_buffers/flat_buffers.dart';
-import 'package:path/path.dart' as path;
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';

-import './bool_structs_generated.dart' as example4;
-import './monster_test_my_game.example2_generated.dart' as example2;
 import './monster_test_my_game.example_generated.dart' as example;
-import 'enums_generated.dart' as example3;
+import './monster_test_my_game.example2_generated.dart' as example2;
+import './list_of_enums_generated.dart' as example3;
+import './bool_structs_generated.dart' as example4;

 main() {
  defineReflectiveSuite(() {
@@ -28,9 +29,11 @@ int indexToField(int index) {
@reflectiveTest
 class CheckOtherLangaugesData {
  test_cppData() async {
-    List<int> data = await io.File(
-      path.join(path.context.current, 'test', 'monsterdata_test.mon'),
-    ).readAsBytes();
+    List<int> data = await io.File(path.join(
+      path.context.current,
+      'test',
+      'monsterdata_test.mon',
+    )).readAsBytes();
    example.Monster mon = example.Monster(data);
    expect(mon.hp, 80);
    expect(mon.mana, 150);
@@ -58,92 +61,91 @@ class CheckOtherLangaugesData {

    // this will fail if accessing any field fails.
    expect(
-      mon.toString(),
-      'Monster{'
-      'pos: Vec3{x: 1.0, y: 2.0, z: 3.0, test1: 3.0, test2: Color.Green, test3: Test{a: 5, b: 6}}, '
-      'mana: 150, hp: 80, name: MyMonster, inventory: [0, 1, 2, 3, 4], '
-      'color: Color.Blue, testType: AnyTypeId.Monster, '
-      'test: Monster{pos: null, mana: 150, hp: 100, name: Fred, '
-      'inventory: null, color: Color.Blue, testType: null, '
-      'test: null, test4: null, testarrayofstring: null, '
-      'testarrayoftables: null, enemy: null, testnestedflatbuffer: null, '
-      'testempty: null, testbool: false, testhashs32Fnv1: 0, '
-      'testhashu32Fnv1: 0, testhashs64Fnv1: 0, testhashu64Fnv1: 0, '
-      'testhashs32Fnv1a: 0, testhashu32Fnv1a: 0, testhashs64Fnv1a: 0, '
-      'testhashu64Fnv1a: 0, testarrayofbools: null, testf: 3.14159, '
-      'testf2: 3.0, testf3: 0.0, testarrayofstring2: null, '
-      'testarrayofsortedstruct: null, flex: null, test5: null, '
-      'vectorOfLongs: null, vectorOfDoubles: null, parentNamespaceTest: null, '
-      'vectorOfReferrables: null, singleWeakReference: 0, '
-      'vectorOfWeakReferences: null, vectorOfStrongReferrables: null, '
-      'coOwningReference: 0, vectorOfCoOwningReferences: null, '
-      'nonOwningReference: 0, vectorOfNonOwningReferences: null, '
-      'anyUniqueType: null, anyUnique: null, anyAmbiguousType: null, '
-      'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race.None, '
-      'testrequirednestedflatbuffer: null, scalarKeySortedTables: null, '
-      'nativeInline: null, '
-      'longEnumNonEnumDefault: LongEnum._default, '
-      'longEnumNormalDefault: LongEnum.LongOne, nanDefault: NaN, '
-      'infDefault: Infinity, positiveInfDefault: Infinity, infinityDefault: '
-      'Infinity, positiveInfinityDefault: Infinity, negativeInfDefault: '
-      '-Infinity, negativeInfinityDefault: -Infinity, doubleInfDefault: Infinity}, '
-      'test4: [Test{a: 10, b: 20}, Test{a: 30, b: 40}], '
-      'testarrayofstring: [test1, test2], testarrayoftables: null, '
-      'enemy: Monster{pos: null, mana: 150, hp: 100, name: Fred, '
-      'inventory: null, color: Color.Blue, testType: null, '
-      'test: null, test4: null, testarrayofstring: null, '
-      'testarrayoftables: null, enemy: null, testnestedflatbuffer: null, '
-      'testempty: null, testbool: false, testhashs32Fnv1: 0, '
-      'testhashu32Fnv1: 0, testhashs64Fnv1: 0, testhashu64Fnv1: 0, '
-      'testhashs32Fnv1a: 0, testhashu32Fnv1a: 0, testhashs64Fnv1a: 0, '
-      'testhashu64Fnv1a: 0, testarrayofbools: null, testf: 3.14159, '
-      'testf2: 3.0, testf3: 0.0, testarrayofstring2: null, '
-      'testarrayofsortedstruct: null, flex: null, test5: null, '
-      'vectorOfLongs: null, vectorOfDoubles: null, parentNamespaceTest: null, '
-      'vectorOfReferrables: null, singleWeakReference: 0, '
-      'vectorOfWeakReferences: null, vectorOfStrongReferrables: null, '
-      'coOwningReference: 0, vectorOfCoOwningReferences: null, '
-      'nonOwningReference: 0, vectorOfNonOwningReferences: null, '
-      'anyUniqueType: null, anyUnique: null, anyAmbiguousType: null, '
-      'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race.None, '
-      'testrequirednestedflatbuffer: null, scalarKeySortedTables: null, '
-      'nativeInline: null, '
-      'longEnumNonEnumDefault: LongEnum._default, '
-      'longEnumNormalDefault: LongEnum.LongOne, nanDefault: NaN, '
-      'infDefault: Infinity, positiveInfDefault: Infinity, infinityDefault: '
-      'Infinity, positiveInfinityDefault: Infinity, negativeInfDefault: '
-      '-Infinity, negativeInfinityDefault: -Infinity, doubleInfDefault: Infinity}, '
-      'testnestedflatbuffer: null, testempty: null, testbool: true, '
-      'testhashs32Fnv1: -579221183, testhashu32Fnv1: 3715746113, '
-      'testhashs64Fnv1: 7930699090847568257, '
-      'testhashu64Fnv1: 7930699090847568257, '
-      'testhashs32Fnv1a: -1904106383, testhashu32Fnv1a: 2390860913, '
-      'testhashs64Fnv1a: 4898026182817603057, '
-      'testhashu64Fnv1a: 4898026182817603057, '
-      'testarrayofbools: [true, false, true], testf: 3.14159, testf2: 3.0, '
-      'testf3: 0.0, testarrayofstring2: null, testarrayofsortedstruct: ['
-      'Ability{id: 0, distance: 45}, Ability{id: 1, distance: 21}, '
-      'Ability{id: 5, distance: 12}], '
-      'flex: null, test5: [Test{a: 10, b: 20}, Test{a: 30, b: 40}], '
-      'vectorOfLongs: [1, 100, 10000, 1000000, 100000000], '
-      'vectorOfDoubles: [-1.7976931348623157e+308, 0.0, 1.7976931348623157e+308], '
-      'parentNamespaceTest: null, vectorOfReferrables: null, '
-      'singleWeakReference: 0, vectorOfWeakReferences: null, '
-      'vectorOfStrongReferrables: null, coOwningReference: 0, '
-      'vectorOfCoOwningReferences: null, nonOwningReference: 0, '
-      'vectorOfNonOwningReferences: null, '
-      'anyUniqueType: null, anyUnique: null, '
-      'anyAmbiguousType: null, '
-      'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race.None, '
-      'testrequirednestedflatbuffer: null, scalarKeySortedTables: [Stat{id: '
-      'miss, val: 0, count: 0}, Stat{id: hit, val: 10, count: 1}], '
-      'nativeInline: Test{a: 1, b: 2}, '
-      'longEnumNonEnumDefault: LongEnum._default, '
-      'longEnumNormalDefault: LongEnum.LongOne, nanDefault: NaN, '
-      'infDefault: Infinity, positiveInfDefault: Infinity, infinityDefault: '
-      'Infinity, positiveInfinityDefault: Infinity, negativeInfDefault: '
-      '-Infinity, negativeInfinityDefault: -Infinity, doubleInfDefault: Infinity}',
-    );
+        mon.toString(),
+        'Monster{'
+        'pos: Vec3{x: 1.0, y: 2.0, z: 3.0, test1: 3.0, test2: Color{value: 2}, test3: Test{a: 5, b: 6}}, '
+        'mana: 150, hp: 80, name: MyMonster, inventory: [0, 1, 2, 3, 4], '
+        'color: Color{value: 8}, testType: AnyTypeId{value: 1}, '
+        'test: Monster{pos: null, mana: 150, hp: 100, name: Fred, '
+        'inventory: null, color: Color{value: 8}, testType: null, '
+        'test: null, test4: null, testarrayofstring: null, '
+        'testarrayoftables: null, enemy: null, testnestedflatbuffer: null, '
+        'testempty: null, testbool: false, testhashs32Fnv1: 0, '
+        'testhashu32Fnv1: 0, testhashs64Fnv1: 0, testhashu64Fnv1: 0, '
+        'testhashs32Fnv1a: 0, testhashu32Fnv1a: 0, testhashs64Fnv1a: 0, '
+        'testhashu64Fnv1a: 0, testarrayofbools: null, testf: 3.14159, '
+        'testf2: 3.0, testf3: 0.0, testarrayofstring2: null, '
+        'testarrayofsortedstruct: null, flex: null, test5: null, '
+        'vectorOfLongs: null, vectorOfDoubles: null, parentNamespaceTest: null, '
+        'vectorOfReferrables: null, singleWeakReference: 0, '
+        'vectorOfWeakReferences: null, vectorOfStrongReferrables: null, '
+        'coOwningReference: 0, vectorOfCoOwningReferences: null, '
+        'nonOwningReference: 0, vectorOfNonOwningReferences: null, '
+        'anyUniqueType: null, anyUnique: null, anyAmbiguousType: null, '
+        'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race{value: -1}, '
+        'testrequirednestedflatbuffer: null, scalarKeySortedTables: null, '
+        'nativeInline: null, '
+        'longEnumNonEnumDefault: LongEnum{value: 0}, '
+        'longEnumNormalDefault: LongEnum{value: 2}, nanDefault: NaN, '
+        'infDefault: Infinity, positiveInfDefault: Infinity, infinityDefault: '
+        'Infinity, positiveInfinityDefault: Infinity, negativeInfDefault: '
+        '-Infinity, negativeInfinityDefault: -Infinity, doubleInfDefault: Infinity}, '
+        'test4: [Test{a: 10, b: 20}, Test{a: 30, b: 40}], '
+        'testarrayofstring: [test1, test2], testarrayoftables: null, '
+        'enemy: Monster{pos: null, mana: 150, hp: 100, name: Fred, '
+        'inventory: null, color: Color{value: 8}, testType: null, '
+        'test: null, test4: null, testarrayofstring: null, '
+        'testarrayoftables: null, enemy: null, testnestedflatbuffer: null, '
+        'testempty: null, testbool: false, testhashs32Fnv1: 0, '
+        'testhashu32Fnv1: 0, testhashs64Fnv1: 0, testhashu64Fnv1: 0, '
+        'testhashs32Fnv1a: 0, testhashu32Fnv1a: 0, testhashs64Fnv1a: 0, '
+        'testhashu64Fnv1a: 0, testarrayofbools: null, testf: 3.14159, '
+        'testf2: 3.0, testf3: 0.0, testarrayofstring2: null, '
+        'testarrayofsortedstruct: null, flex: null, test5: null, '
+        'vectorOfLongs: null, vectorOfDoubles: null, parentNamespaceTest: null, '
+        'vectorOfReferrables: null, singleWeakReference: 0, '
+        'vectorOfWeakReferences: null, vectorOfStrongReferrables: null, '
+        'coOwningReference: 0, vectorOfCoOwningReferences: null, '
+        'nonOwningReference: 0, vectorOfNonOwningReferences: null, '
+        'anyUniqueType: null, anyUnique: null, anyAmbiguousType: null, '
+        'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race{value: -1}, '
+        'testrequirednestedflatbuffer: null, scalarKeySortedTables: null, '
+        'nativeInline: null, '
+        'longEnumNonEnumDefault: LongEnum{value: 0}, '
+        'longEnumNormalDefault: LongEnum{value: 2}, nanDefault: NaN, '
+        'infDefault: Infinity, positiveInfDefault: Infinity, infinityDefault: '
+        'Infinity, positiveInfinityDefault: Infinity, negativeInfDefault: '
+        '-Infinity, negativeInfinityDefault: -Infinity, doubleInfDefault: Infinity}, '
+        'testnestedflatbuffer: null, testempty: null, testbool: true, '
+        'testhashs32Fnv1: -579221183, testhashu32Fnv1: 3715746113, '
+        'testhashs64Fnv1: 7930699090847568257, '
+        'testhashu64Fnv1: 7930699090847568257, '
+        'testhashs32Fnv1a: -1904106383, testhashu32Fnv1a: 2390860913, '
+        'testhashs64Fnv1a: 4898026182817603057, '
+        'testhashu64Fnv1a: 4898026182817603057, '
+        'testarrayofbools: [true, false, true], testf: 3.14159, testf2: 3.0, '
+        'testf3: 0.0, testarrayofstring2: null, testarrayofsortedstruct: ['
+        'Ability{id: 0, distance: 45}, Ability{id: 1, distance: 21}, '
+        'Ability{id: 5, distance: 12}], '
+        'flex: null, test5: [Test{a: 10, b: 20}, Test{a: 30, b: 40}], '
+        'vectorOfLongs: [1, 100, 10000, 1000000, 100000000], '
+        'vectorOfDoubles: [-1.7976931348623157e+308, 0.0, 1.7976931348623157e+308], '
+        'parentNamespaceTest: null, vectorOfReferrables: null, '
+        'singleWeakReference: 0, vectorOfWeakReferences: null, '
+        'vectorOfStrongReferrables: null, coOwningReference: 0, '
+        'vectorOfCoOwningReferences: null, nonOwningReference: 0, '
+        'vectorOfNonOwningReferences: null, '
+        'anyUniqueType: null, anyUnique: null, '
+        'anyAmbiguousType: null, '
+        'anyAmbiguous: null, vectorOfEnums: null, signedEnum: Race{value: -1}, '
+        'testrequirednestedflatbuffer: null, scalarKeySortedTables: [Stat{id: '
+        'miss, val: 0, count: 0}, Stat{id: hit, val: 10, count: 1}], '
+        'nativeInline: Test{a: 1, b: 2}, '
+        'longEnumNonEnumDefault: LongEnum{value: 0}, '
+        'longEnumNormalDefault: LongEnum{value: 2}, nanDefault: NaN, '
+        'infDefault: Infinity, positiveInfDefault: Infinity, infinityDefault: '
+        'Infinity, positiveInfinityDefault: Infinity, negativeInfDefault: '
+        '-Infinity, negativeInfinityDefault: -Infinity, doubleInfDefault: Infinity}');
  }
 }

@@ -213,10 +215,6 @@ class BuilderTest {
      ..addTestarrayofstringOffset(testArrayOfString);
    final mon = monBuilder.finish();
    fbBuilder.finish(mon);
-
-    final mon3 = example.Monster(fbBuilder.buffer);
-    expect(mon3.name, 'MyMonster');
-    expect(mon3.pos!.test1, 3.0);
  }

  void test_error_addInt32_withoutStartTable([Builder? builder]) {
@@ -296,72 +294,20 @@ class BuilderTest {
    expect(allocator.buffer(builder.size()), [2, 0, 0, 0, 0, 0, 0, 1]);

    builder.putUint8(3);
-    expect(allocator.buffer(builder.size()), [
-      0,
-      0,
-      0,
-      3,
-      2,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      1,
-    ]);
+    expect(
+        allocator.buffer(builder.size()), [0, 0, 0, 3, 2, 0, 0, 0, 0, 0, 0, 1]);

    builder.putUint8(4);
-    expect(allocator.buffer(builder.size()), [
-      0,
-      0,
-      4,
-      3,
-      2,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      1,
-    ]);
+    expect(
+        allocator.buffer(builder.size()), [0, 0, 4, 3, 2, 0, 0, 0, 0, 0, 0, 1]);

    builder.putUint8(5);
-    expect(allocator.buffer(builder.size()), [
-      0,
-      5,
-      4,
-      3,
-      2,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      1,
-    ]);
+    expect(
+        allocator.buffer(builder.size()), [0, 5, 4, 3, 2, 0, 0, 0, 0, 0, 0, 1]);

    builder.putUint32(6);
-    expect(allocator.buffer(builder.size()), [
-      6,
-      0,
-      0,
-      0,
-      0,
-      5,
-      4,
-      3,
-      2,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      1,
-    ]);
+    expect(allocator.buffer(builder.size()),
+        [6, 0, 0, 0, 0, 5, 4, 3, 2, 0, 0, 0, 0, 0, 0, 1]);
  }

  void test_table_default() {
@@ -381,14 +327,14 @@ class BuilderTest {
    int objectOffset = buffer.derefObject(0);
    // was not written, so uses the new default value
    expect(
-      const Int32Reader().vTableGet(buffer, objectOffset, indexToField(0), 15),
-      15,
-    );
+        const Int32Reader()
+            .vTableGet(buffer, objectOffset, indexToField(0), 15),
+        15);
    // has the written value
    expect(
-      const Int32Reader().vTableGet(buffer, objectOffset, indexToField(1), 15),
-      20,
-    );
+        const Int32Reader()
+            .vTableGet(buffer, objectOffset, indexToField(1), 15),
+        20);
  }

  void test_table_format([Builder? builder]) {
@@ -420,9 +366,7 @@ class BuilderTest {
    for (int i = 0; i < 3; i++) {
      int offset = byteData.getUint16(vTableLoc + 4 + 2 * i, Endian.little);
      expect(
-        byteData.getInt32(tableDataLoc + offset, Endian.little),
-        10 + 10 * i,
-      );
+          byteData.getInt32(tableDataLoc + offset, Endian.little), 10 + 10 * i);
    }
  }

@@ -432,14 +376,10 @@ class BuilderTest {
    List<int> byteList;
    {
      Builder builder = Builder(initialSize: 0);
-      int? latinStringOffset = builder.writeString(
-        latinString,
-        asciiOptimization: true,
-      );
-      int? unicodeStringOffset = builder.writeString(
-        unicodeString,
-        asciiOptimization: true,
-      );
+      int? latinStringOffset =
+          builder.writeString(latinString, asciiOptimization: true);
+      int? unicodeStringOffset =
+          builder.writeString(unicodeString, asciiOptimization: true);
      builder.startTable(2);
      builder.addOffset(0, latinStringOffset);
      builder.addOffset(1, unicodeStringOffset);
@@ -451,19 +391,13 @@ class BuilderTest {
    BufferContext buf = BufferContext.fromBytes(byteList);
    int objectOffset = buf.derefObject(0);
    expect(
-      const StringReader().vTableGetNullable(
-        buf,
-        objectOffset,
-        indexToField(0),
-      ),
-      latinString,
-    );
+        const StringReader()
+            .vTableGetNullable(buf, objectOffset, indexToField(0)),
+        latinString);
    expect(
-      const StringReader(
-        asciiOptimization: true,
-      ).vTableGetNullable(buf, objectOffset, indexToField(1)),
-      unicodeString,
-    );
+        const StringReader(asciiOptimization: true)
+            .vTableGetNullable(buf, objectOffset, indexToField(1)),
+        unicodeString);
  }

  void test_table_types([Builder? builder]) {
@@ -487,41 +421,33 @@ class BuilderTest {
    BufferContext buf = BufferContext.fromBytes(byteList);
    int objectOffset = buf.derefObject(0);
    expect(
-      const BoolReader().vTableGetNullable(buf, objectOffset, indexToField(0)),
-      true,
-    );
+        const BoolReader()
+            .vTableGetNullable(buf, objectOffset, indexToField(0)),
+        true);
    expect(
-      const Int8Reader().vTableGetNullable(buf, objectOffset, indexToField(1)),
-      10,
-    );
+        const Int8Reader()
+            .vTableGetNullable(buf, objectOffset, indexToField(1)),
+        10);
    expect(
-      const Int32Reader().vTableGetNullable(buf, objectOffset, indexToField(2)),
-      20,
-    );
+        const Int32Reader()
+            .vTableGetNullable(buf, objectOffset, indexToField(2)),
+        20);
    expect(
-      const StringReader().vTableGetNullable(
-        buf,
-        objectOffset,
-        indexToField(3),
-      ),
-      '12345',
-    );
+        const StringReader()
+            .vTableGetNullable(buf, objectOffset, indexToField(3)),
+        '12345');
    expect(
-      const Int32Reader().vTableGetNullable(buf, objectOffset, indexToField(4)),
-      40,
-    );
+        const Int32Reader()
+            .vTableGetNullable(buf, objectOffset, indexToField(4)),
+        40);
    expect(
-      const Uint32Reader().vTableGetNullable(
-        buf,
-        objectOffset,
-        indexToField(5),
-      ),
-      0x9ABCDEF0,
-    );
+        const Uint32Reader()
+            .vTableGetNullable(buf, objectOffset, indexToField(5)),
+        0x9ABCDEF0);
    expect(
-      const Uint8Reader().vTableGetNullable(buf, objectOffset, indexToField(6)),
-      0x9A,
-    );
+        const Uint8Reader()
+            .vTableGetNullable(buf, objectOffset, indexToField(6)),
+        0x9A);
  }

  void test_writeList_of_Uint32() {
@@ -666,9 +592,8 @@ class BuilderTest {
    }
    // read and verify
    BufferContext buf = BufferContext.fromBytes(byteList);
-    List<TestPointImpl> items = const ListReader<TestPointImpl>(
-      TestPointReader(),
-    ).read(buf, 0);
+    List<TestPointImpl> items =
+        const ListReader<TestPointImpl>(TestPointReader()).read(buf, 0);
    expect(items, hasLength(2));
    expect(items[0].x, 10);
    expect(items[0].y, 20);
@@ -698,10 +623,8 @@ class BuilderTest {
    List<int> byteList;
    {
      builder ??= Builder(initialSize: 0);
-      int listOffset = builder.writeList([
-        builder.writeString('12345'),
-        builder.writeString('ABC'),
-      ]);
+      int listOffset = builder.writeList(
+          [builder.writeString('12345'), builder.writeString('ABC')]);
      builder.startTable(1);
      builder.addOffset(0, listOffset);
      int offset = builder.endTable();
@@ -780,14 +703,13 @@ class BuilderTest {
      test_table_format,
      test_table_types,
      test_writeList_ofObjects,
-      test_writeList_ofStrings_inObject,
+      test_writeList_ofStrings_inObject
    ];

    // Execute all test cases in all permutations of their order.
    // To do that, we generate permutations of test case indexes.
-    final testCasesPermutations = _permutationsOf(
-      List.generate(testCases.length, (index) => index),
-    );
+    final testCasesPermutations =
+        _permutationsOf(List.generate(testCases.length, (index) => index));
    expect(testCasesPermutations.length, _factorial(testCases.length));

    for (var indexes in testCasesPermutations) {
@@ -857,13 +779,12 @@ class ObjectAPITest {
  void test_tableMonster() {
    final monster = example.MonsterT()
      ..pos = example.Vec3T(
-        x: 1,
-        y: 2,
-        z: 3,
-        test1: 4.0,
-        test2: example.Color.Red,
-        test3: example.TestT(a: 1, b: 2),
-      )
+          x: 1,
+          y: 2,
+          z: 3,
+          test1: 4.0,
+          test2: example.Color.Red,
+          test3: example.TestT(a: 1, b: 2))
      ..mana = 2
      ..name = 'Monstrous'
      ..inventory = [24, 42]
@@ -879,7 +800,7 @@ class ObjectAPITest {
      ..testf = 42.24
      ..testarrayofsortedstruct = [
        example.AbilityT(id: 1, distance: 5),
-        example.AbilityT(id: 3, distance: 7),
+        example.AbilityT(id: 3, distance: 7)
      ]
      ..vectorOfLongs = [5, 6, 7]
      ..vectorOfDoubles = [8.9, 9.0, 10.1, 11.2]
@@ -942,9 +863,8 @@ class StringListWrapperImpl {

  StringListWrapperImpl(this.bp, this.offset);

-  List<String>? get items => const ListReader<String>(
-    StringReader(),
-  ).vTableGetNullable(bp, offset, indexToField(0));
+  List<String>? get items => const ListReader<String>(StringReader())
+      .vTableGetNullable(bp, offset, indexToField(0));
 }

 class StringListWrapperReader extends TableReader<StringListWrapperImpl> {
@@ -982,14 +902,10 @@ class GeneratorTest {
    expect(example.Color.values, same(example.Color.values));
    expect(example.Race.values, same(example.Race.values));
    expect(example.AnyTypeId.values, same(example.AnyTypeId.values));
-    expect(
-      example.AnyUniqueAliasesTypeId.values,
-      same(example.AnyUniqueAliasesTypeId.values),
-    );
-    expect(
-      example.AnyAmbiguousAliasesTypeId.values,
-      same(example.AnyAmbiguousAliasesTypeId.values),
-    );
+    expect(example.AnyUniqueAliasesTypeId.values,
+        same(example.AnyUniqueAliasesTypeId.values));
+    expect(example.AnyAmbiguousAliasesTypeId.values,
+        same(example.AnyAmbiguousAliasesTypeId.values));
  }
 }

@@ -997,13 +913,11 @@ class GeneratorTest {
@reflectiveTest
 class ListOfEnumsTest {
  void test_listOfEnums() async {
-    var mytable = example3.MyTableObjectBuilder(
-      options: [
-        example3.OptionsEnum.A,
-        example3.OptionsEnum.B,
-        example3.OptionsEnum.C,
-      ],
-    );
+    var mytable = example3.MyTableObjectBuilder(options: [
+      example3.OptionsEnum.A,
+      example3.OptionsEnum.B,
+      example3.OptionsEnum.C
+    ]);
    var bytes = mytable.toBytes();
    var mytable_read = example3.MyTable(bytes);
    expect(mytable_read.options![0].value, example3.OptionsEnum.A.value);
@@ -1016,8 +930,7 @@ class ListOfEnumsTest {
 class BoolInStructTest {
  void test_boolInStruct() async {
    var mystruct = example4.FooObjectBuilder(
-      myFoo: example4.FooPropertiesObjectBuilder(a: true, b: false),
-    );
+        myFoo: example4.FooPropertiesObjectBuilder(a: true, b: false));
    var bytes = mystruct.toBytes();
    var mystruct_read = example4.Foo(bytes);
    expect(mystruct_read.myFoo!.a, true);
--- a/dart/test/flex_builder_test.dart
+++ b/dart/test/flex_builder_test.dart
@@ -62,23 +62,8 @@ void main() {
    {
      var flx = Builder();
      flx.addString('hello 😱');
-      expect(flx.finish(), [
-        10,
-        104,
-        101,
-        108,
-        108,
-        111,
-        32,
-        240,
-        159,
-        152,
-        177,
-        0,
-        11,
-        20,
-        1,
-      ]);
+      expect(flx.finish(),
+          [10, 104, 101, 108, 108, 111, 32, 240, 159, 152, 177, 0, 11, 20, 1]);
    }
  });

@@ -132,7 +117,7 @@ void main() {
        192,
        16,
        75,
-        1,
+        1
      ]);
    }
    {
@@ -192,7 +177,7 @@ void main() {
        7,
        3,
        60,
-        1,
+        1
      ]);
    }
    {
@@ -230,7 +215,7 @@ void main() {
        10,
        6,
        60,
-        1,
+        1
      ]);
    }
    {
@@ -315,7 +300,7 @@ void main() {
        104,
        45,
        43,
-        1,
+        1
      ]);
    }
  });
@@ -337,24 +322,8 @@ void main() {
        ..addKey('')
        ..addInt(45)
        ..end();
-      expect(flx.finish(), [
-        97,
-        0,
-        0,
-        2,
-        2,
-        5,
-        2,
-        1,
-        2,
-        45,
-        12,
-        4,
-        4,
-        4,
-        36,
-        1,
-      ]);
+      expect(
+          flx.finish(), [97, 0, 0, 2, 2, 5, 2, 1, 2, 45, 12, 4, 4, 4, 36, 1]);
    }
    {
      var flx = Builder()
@@ -398,7 +367,7 @@ void main() {
        36,
        4,
        40,
-        1,
+        1
      ]);
    }
  });
@@ -412,152 +381,133 @@ void main() {

  test('build from object', () {
    expect(
-      Builder.buildFromObject(
-        Uint8List.fromList([1, 2, 3]).buffer,
-      ).asUint8List(),
-      [3, 1, 2, 3, 3, 100, 1],
-    );
+        Builder.buildFromObject(Uint8List.fromList([1, 2, 3]).buffer)
+            .asUint8List(),
+        [3, 1, 2, 3, 3, 100, 1]);
    expect(Builder.buildFromObject(null).asUint8List(), [0, 0, 1]);
    expect(Builder.buildFromObject(true).asUint8List(), [1, 104, 1]);
    expect(Builder.buildFromObject(false).asUint8List(), [0, 104, 1]);
    expect(Builder.buildFromObject(25).asUint8List(), [25, 4, 1]);
    expect(Builder.buildFromObject(-250).asUint8List(), [6, 255, 5, 2]);
-    expect(Builder.buildFromObject(-2.50).asUint8List(), [
-      0,
-      0,
-      32,
-      192,
-      14,
-      4,
-    ]);
-    expect(Builder.buildFromObject('Maxim').asUint8List(), [
-      5,
-      77,
-      97,
-      120,
-      105,
-      109,
-      0,
-      6,
-      20,
-      1,
-    ]);
    expect(
-      Builder.buildFromObject([1, 3.3, 'max', true, null, false]).asUint8List(),
-      [
-        3,
-        109,
-        97,
-        120,
-        0,
-        0,
-        0,
-        0,
-        6,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        1,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        102,
-        102,
-        102,
-        102,
-        102,
-        102,
-        10,
-        64,
-        31,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        1,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        0,
-        4,
-        15,
-        20,
-        104,
-        0,
-        104,
-        54,
-        43,
-        1,
-      ],
-    );
+        Builder.buildFromObject(-2.50).asUint8List(), [0, 0, 32, 192, 14, 4]);
+    expect(Builder.buildFromObject('Maxim').asUint8List(),
+        [5, 77, 97, 120, 105, 109, 0, 6, 20, 1]);
    expect(
-      Builder.buildFromObject([
-        {'something': 12},
-        {'something': 45},
-      ]).asUint8List(),
-      [
-        115,
-        111,
-        109,
-        101,
-        116,
-        104,
-        105,
-        110,
-        103,
-        0,
-        1,
-        11,
-        1,
-        1,
-        1,
-        12,
-        4,
-        6,
-        1,
-        1,
-        45,
-        4,
-        2,
-        8,
-        4,
-        36,
-        36,
-        4,
-        40,
-        1,
-      ],
-    );
+        Builder.buildFromObject([1, 3.3, 'max', true, null, false])
+            .asUint8List(),
+        [
+          3,
+          109,
+          97,
+          120,
+          0,
+          0,
+          0,
+          0,
+          6,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          102,
+          102,
+          102,
+          102,
+          102,
+          102,
+          10,
+          64,
+          31,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          4,
+          15,
+          20,
+          104,
+          0,
+          104,
+          54,
+          43,
+          1
+        ]);
+    expect(
+        Builder.buildFromObject([
+          {'something': 12},
+          {'something': 45}
+        ]).asUint8List(),
+        [
+          115,
+          111,
+          109,
+          101,
+          116,
+          104,
+          105,
+          110,
+          103,
+          0,
+          1,
+          11,
+          1,
+          1,
+          1,
+          12,
+          4,
+          6,
+          1,
+          1,
+          45,
+          4,
+          2,
+          8,
+          4,
+          36,
+          36,
+          4,
+          40,
+          1
+        ]);
  });

  test('add double indirectly', () {
@@ -593,7 +543,7 @@ void main() {
      35,
      8,
      40,
-      1,
+      1
    ]);
  });

@@ -630,7 +580,7 @@ void main() {
      27,
      8,
      40,
-      1,
+      1
    ]);
  });

--- a/dart/test/flex_reader_test.dart
+++ b/dart/test/flex_reader_test.dart
--- a/dart/test/flex_types_test.dart
+++ b/dart/test/flex_types_test.dart
@@ -48,210 +48,116 @@ void main() {
    expect(ValueTypeUtils.isFixedTypedVector(ValueType.VectorInt), isFalse);
  });
  test('to typed vector', () {
-    expect(
-      ValueTypeUtils.toTypedVector(ValueType.Int, 0),
-      equals(ValueType.VectorInt),
-    );
-    expect(
-      ValueTypeUtils.toTypedVector(ValueType.UInt, 0),
-      equals(ValueType.VectorUInt),
-    );
-    expect(
-      ValueTypeUtils.toTypedVector(ValueType.Bool, 0),
-      equals(ValueType.VectorBool),
-    );
-    expect(
-      ValueTypeUtils.toTypedVector(ValueType.Float, 0),
-      equals(ValueType.VectorFloat),
-    );
-    expect(
-      ValueTypeUtils.toTypedVector(ValueType.Key, 0),
-      equals(ValueType.VectorKey),
-    );
-    expect(
-      ValueTypeUtils.toTypedVector(ValueType.String, 0),
-      equals(ValueType.VectorString),
-    );
+    expect(ValueTypeUtils.toTypedVector(ValueType.Int, 0),
+        equals(ValueType.VectorInt));
+    expect(ValueTypeUtils.toTypedVector(ValueType.UInt, 0),
+        equals(ValueType.VectorUInt));
+    expect(ValueTypeUtils.toTypedVector(ValueType.Bool, 0),
+        equals(ValueType.VectorBool));
+    expect(ValueTypeUtils.toTypedVector(ValueType.Float, 0),
+        equals(ValueType.VectorFloat));
+    expect(ValueTypeUtils.toTypedVector(ValueType.Key, 0),
+        equals(ValueType.VectorKey));
+    expect(ValueTypeUtils.toTypedVector(ValueType.String, 0),
+        equals(ValueType.VectorString));

-    expect(
-      ValueTypeUtils.toTypedVector(ValueType.Int, 2),
-      equals(ValueType.VectorInt2),
-    );
-    expect(
-      ValueTypeUtils.toTypedVector(ValueType.UInt, 2),
-      equals(ValueType.VectorUInt2),
-    );
-    expect(
-      ValueTypeUtils.toTypedVector(ValueType.Float, 2),
-      equals(ValueType.VectorFloat2),
-    );
+    expect(ValueTypeUtils.toTypedVector(ValueType.Int, 2),
+        equals(ValueType.VectorInt2));
+    expect(ValueTypeUtils.toTypedVector(ValueType.UInt, 2),
+        equals(ValueType.VectorUInt2));
+    expect(ValueTypeUtils.toTypedVector(ValueType.Float, 2),
+        equals(ValueType.VectorFloat2));

-    expect(
-      ValueTypeUtils.toTypedVector(ValueType.Int, 3),
-      equals(ValueType.VectorInt3),
-    );
-    expect(
-      ValueTypeUtils.toTypedVector(ValueType.UInt, 3),
-      equals(ValueType.VectorUInt3),
-    );
-    expect(
-      ValueTypeUtils.toTypedVector(ValueType.Float, 3),
-      equals(ValueType.VectorFloat3),
-    );
+    expect(ValueTypeUtils.toTypedVector(ValueType.Int, 3),
+        equals(ValueType.VectorInt3));
+    expect(ValueTypeUtils.toTypedVector(ValueType.UInt, 3),
+        equals(ValueType.VectorUInt3));
+    expect(ValueTypeUtils.toTypedVector(ValueType.Float, 3),
+        equals(ValueType.VectorFloat3));

-    expect(
-      ValueTypeUtils.toTypedVector(ValueType.Int, 4),
-      equals(ValueType.VectorInt4),
-    );
-    expect(
-      ValueTypeUtils.toTypedVector(ValueType.UInt, 4),
-      equals(ValueType.VectorUInt4),
-    );
-    expect(
-      ValueTypeUtils.toTypedVector(ValueType.Float, 4),
-      equals(ValueType.VectorFloat4),
-    );
+    expect(ValueTypeUtils.toTypedVector(ValueType.Int, 4),
+        equals(ValueType.VectorInt4));
+    expect(ValueTypeUtils.toTypedVector(ValueType.UInt, 4),
+        equals(ValueType.VectorUInt4));
+    expect(ValueTypeUtils.toTypedVector(ValueType.Float, 4),
+        equals(ValueType.VectorFloat4));
  });
  test('typed vector element type', () {
-    expect(
-      ValueTypeUtils.typedVectorElementType(ValueType.VectorInt),
-      equals(ValueType.Int),
-    );
-    expect(
-      ValueTypeUtils.typedVectorElementType(ValueType.VectorUInt),
-      equals(ValueType.UInt),
-    );
-    expect(
-      ValueTypeUtils.typedVectorElementType(ValueType.VectorFloat),
-      equals(ValueType.Float),
-    );
-    expect(
-      ValueTypeUtils.typedVectorElementType(ValueType.VectorString),
-      equals(ValueType.String),
-    );
-    expect(
-      ValueTypeUtils.typedVectorElementType(ValueType.VectorKey),
-      equals(ValueType.Key),
-    );
-    expect(
-      ValueTypeUtils.typedVectorElementType(ValueType.VectorBool),
-      equals(ValueType.Bool),
-    );
+    expect(ValueTypeUtils.typedVectorElementType(ValueType.VectorInt),
+        equals(ValueType.Int));
+    expect(ValueTypeUtils.typedVectorElementType(ValueType.VectorUInt),
+        equals(ValueType.UInt));
+    expect(ValueTypeUtils.typedVectorElementType(ValueType.VectorFloat),
+        equals(ValueType.Float));
+    expect(ValueTypeUtils.typedVectorElementType(ValueType.VectorString),
+        equals(ValueType.String));
+    expect(ValueTypeUtils.typedVectorElementType(ValueType.VectorKey),
+        equals(ValueType.Key));
+    expect(ValueTypeUtils.typedVectorElementType(ValueType.VectorBool),
+        equals(ValueType.Bool));
  });
  test('fixed typed vector element type', () {
-    expect(
-      ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorInt2),
-      equals(ValueType.Int),
-    );
-    expect(
-      ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorInt3),
-      equals(ValueType.Int),
-    );
-    expect(
-      ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorInt4),
-      equals(ValueType.Int),
-    );
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorInt2),
+        equals(ValueType.Int));
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorInt3),
+        equals(ValueType.Int));
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorInt4),
+        equals(ValueType.Int));

-    expect(
-      ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorUInt2),
-      equals(ValueType.UInt),
-    );
-    expect(
-      ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorUInt3),
-      equals(ValueType.UInt),
-    );
-    expect(
-      ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorUInt4),
-      equals(ValueType.UInt),
-    );
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorUInt2),
+        equals(ValueType.UInt));
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorUInt3),
+        equals(ValueType.UInt));
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorUInt4),
+        equals(ValueType.UInt));

-    expect(
-      ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorFloat2),
-      equals(ValueType.Float),
-    );
-    expect(
-      ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorFloat3),
-      equals(ValueType.Float),
-    );
-    expect(
-      ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorFloat4),
-      equals(ValueType.Float),
-    );
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorFloat2),
+        equals(ValueType.Float));
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorFloat3),
+        equals(ValueType.Float));
+    expect(ValueTypeUtils.fixedTypedVectorElementType(ValueType.VectorFloat4),
+        equals(ValueType.Float));
  });
  test('fixed typed vector element size', () {
-    expect(
-      ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorInt2),
-      equals(2),
-    );
-    expect(
-      ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorInt3),
-      equals(3),
-    );
-    expect(
-      ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorInt4),
-      equals(4),
-    );
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorInt2),
+        equals(2));
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorInt3),
+        equals(3));
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorInt4),
+        equals(4));

-    expect(
-      ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorUInt2),
-      equals(2),
-    );
-    expect(
-      ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorUInt3),
-      equals(3),
-    );
-    expect(
-      ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorUInt4),
-      equals(4),
-    );
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorUInt2),
+        equals(2));
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorUInt3),
+        equals(3));
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorUInt4),
+        equals(4));

-    expect(
-      ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorFloat2),
-      equals(2),
-    );
-    expect(
-      ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorFloat3),
-      equals(3),
-    );
-    expect(
-      ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorFloat4),
-      equals(4),
-    );
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorFloat2),
+        equals(2));
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorFloat3),
+        equals(3));
+    expect(ValueTypeUtils.fixedTypedVectorElementSize(ValueType.VectorFloat4),
+        equals(4));
  });
  test('packed type', () {
    expect(
-      ValueTypeUtils.packedType(ValueType.Null, BitWidth.width8),
-      equals(0),
-    );
+        ValueTypeUtils.packedType(ValueType.Null, BitWidth.width8), equals(0));
    expect(
-      ValueTypeUtils.packedType(ValueType.Null, BitWidth.width16),
-      equals(1),
-    );
+        ValueTypeUtils.packedType(ValueType.Null, BitWidth.width16), equals(1));
    expect(
-      ValueTypeUtils.packedType(ValueType.Null, BitWidth.width32),
-      equals(2),
-    );
+        ValueTypeUtils.packedType(ValueType.Null, BitWidth.width32), equals(2));
    expect(
-      ValueTypeUtils.packedType(ValueType.Null, BitWidth.width64),
-      equals(3),
-    );
+        ValueTypeUtils.packedType(ValueType.Null, BitWidth.width64), equals(3));

    expect(
-      ValueTypeUtils.packedType(ValueType.Int, BitWidth.width8),
-      equals(4),
-    );
+        ValueTypeUtils.packedType(ValueType.Int, BitWidth.width8), equals(4));
    expect(
-      ValueTypeUtils.packedType(ValueType.Int, BitWidth.width16),
-      equals(5),
-    );
+        ValueTypeUtils.packedType(ValueType.Int, BitWidth.width16), equals(5));
    expect(
-      ValueTypeUtils.packedType(ValueType.Int, BitWidth.width32),
-      equals(6),
-    );
+        ValueTypeUtils.packedType(ValueType.Int, BitWidth.width32), equals(6));
    expect(
-      ValueTypeUtils.packedType(ValueType.Int, BitWidth.width64),
-      equals(7),
-    );
+        ValueTypeUtils.packedType(ValueType.Int, BitWidth.width64), equals(7));
  });
  test('bit width', () {
    expect(BitWidthUtil.width(0), BitWidth.width8);
--- a/dart/test/include_test1_generated.dart
+++ b/dart/test/include_test1_generated.dart
@@ -1,12 +1,11 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names
+// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable

 import 'dart:typed_data' show Uint8List;
-
 import 'package:flat_buffers/flat_buffers.dart' as fb;

-import './include_test2_my_game.other_name_space_generated.dart'
-    as my_game_other_name_space;
+
+import './include_test2_my_game.other_name_space_generated.dart' as my_game_other_name_space;

 class TableA {
  TableA._(this._bc, this._bcOffset);
@@ -20,17 +19,15 @@ class TableA {
  final fb.BufferContext _bc;
  final int _bcOffset;

-  my_game_other_name_space.TableB? get b => my_game_other_name_space
-      .TableB
-      .reader
-      .vTableGetNullable(_bc, _bcOffset, 4);
+  my_game_other_name_space.TableB? get b => my_game_other_name_space.TableB.reader.vTableGetNullable(_bc, _bcOffset, 4);

  @override
  String toString() {
    return 'TableA{b: ${b}}';
  }

-  TableAT unpack() => TableAT(b: b?.unpack());
+  TableAT unpack() => TableAT(
+      b: b?.unpack());

  static int pack(fb.Builder fbBuilder, TableAT? object) {
    if (object == null) return 0;
@@ -41,7 +38,8 @@ class TableA {
 class TableAT implements fb.Packable {
  my_game_other_name_space.TableBT? b;

-  TableAT({this.b});
+  TableAT({
+      this.b});

  @override
  int pack(fb.Builder fbBuilder) {
@@ -61,7 +59,8 @@ class _TableAReader extends fb.TableReader<TableA> {
  const _TableAReader();

  @override
-  TableA createObject(fb.BufferContext bc, int offset) => TableA._(bc, offset);
+  TableA createObject(fb.BufferContext bc, int offset) => 
+    TableA._(bc, offset);
 }

 class TableABuilder {
@@ -86,8 +85,10 @@ class TableABuilder {
 class TableAObjectBuilder extends fb.ObjectBuilder {
  final my_game_other_name_space.TableBObjectBuilder? _b;

-  TableAObjectBuilder({my_game_other_name_space.TableBObjectBuilder? b})
-    : _b = b;
+  TableAObjectBuilder({
+    my_game_other_name_space.TableBObjectBuilder? b,
+  })
+      : _b = b;

  /// Finish building, and store into the [fbBuilder].
  @override
--- a/dart/test/include_test2_my_game.other_name_space_generated.dart
+++ b/dart/test/include_test2_my_game.other_name_space_generated.dart
@@ -1,35 +1,43 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names
+// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable

 library my_game.other_name_space;

 import 'dart:typed_data' show Uint8List;
-
 import 'package:flat_buffers/flat_buffers.dart' as fb;

+
 import './include_test1_generated.dart';

-enum FromInclude {
-  IncludeVal(0);
-
+class FromInclude {
  final int value;
-  const FromInclude(this.value);
+  const FromInclude._(this.value);

  factory FromInclude.fromValue(int value) {
-    switch (value) {
-      case 0:
-        return FromInclude.IncludeVal;
-      default:
-        throw StateError('Invalid value $value for bit flag enum');
+    final result = values[value];
+    if (result == null) {
+        throw StateError('Invalid value $value for bit flag enum FromInclude');
    }
+    return result;
  }

-  static FromInclude? _createOrNull(int? value) =>
+  static FromInclude? _createOrNull(int? value) => 
      value == null ? null : FromInclude.fromValue(value);

  static const int minValue = 0;
  static const int maxValue = 0;
+  static bool containsValue(int value) => values.containsKey(value);
+
+  static const FromInclude IncludeVal = FromInclude._(0);
+  static const Map<int, FromInclude> values = {
+    0: IncludeVal};
+
  static const fb.Reader<FromInclude> reader = _FromIncludeReader();
+
+  @override
+  String toString() {
+    return 'FromInclude{value: $value}';
+  }
 }

 class _FromIncludeReader extends fb.Reader<FromInclude> {
@@ -58,7 +66,8 @@ class Unused {
    return 'Unused{a: ${a}}';
  }

-  UnusedT unpack() => UnusedT(a: a);
+  UnusedT unpack() => UnusedT(
+      a: a);

  static int pack(fb.Builder fbBuilder, UnusedT? object) {
    if (object == null) return 0;
@@ -69,7 +78,8 @@ class Unused {
 class UnusedT implements fb.Packable {
  int a;

-  UnusedT({required this.a});
+  UnusedT({
+      required this.a});

  @override
  int pack(fb.Builder fbBuilder) {
@@ -90,7 +100,8 @@ class _UnusedReader extends fb.StructReader<Unused> {
  int get size => 4;

  @override
-  Unused createObject(fb.BufferContext bc, int offset) => Unused._(bc, offset);
+  Unused createObject(fb.BufferContext bc, int offset) => 
+    Unused._(bc, offset);
 }

 class UnusedBuilder {
@@ -102,12 +113,16 @@ class UnusedBuilder {
    fbBuilder.putInt32(a);
    return fbBuilder.offset;
  }
+
 }

 class UnusedObjectBuilder extends fb.ObjectBuilder {
  final int _a;

-  UnusedObjectBuilder({required int a}) : _a = a;
+  UnusedObjectBuilder({
+    required int a,
+  })
+      : _a = a;

  /// Finish building, and store into the [fbBuilder].
  @override
@@ -124,7 +139,6 @@ class UnusedObjectBuilder extends fb.ObjectBuilder {
    return fbBuilder.buffer;
  }
 }
-
 class TableB {
  TableB._(this._bc, this._bcOffset);
  factory TableB(List<int> bytes) {
@@ -144,7 +158,8 @@ class TableB {
    return 'TableB{a: ${a}}';
  }

-  TableBT unpack() => TableBT(a: a?.unpack());
+  TableBT unpack() => TableBT(
+      a: a?.unpack());

  static int pack(fb.Builder fbBuilder, TableBT? object) {
    if (object == null) return 0;
@@ -155,7 +170,8 @@ class TableB {
 class TableBT implements fb.Packable {
  TableAT? a;

-  TableBT({this.a});
+  TableBT({
+      this.a});

  @override
  int pack(fb.Builder fbBuilder) {
@@ -175,7 +191,8 @@ class _TableBReader extends fb.TableReader<TableB> {
  const _TableBReader();

  @override
-  TableB createObject(fb.BufferContext bc, int offset) => TableB._(bc, offset);
+  TableB createObject(fb.BufferContext bc, int offset) => 
+    TableB._(bc, offset);
 }

 class TableBBuilder {
@@ -200,7 +217,10 @@ class TableBBuilder {
 class TableBObjectBuilder extends fb.ObjectBuilder {
  final TableAObjectBuilder? _a;

-  TableBObjectBuilder({TableAObjectBuilder? a}) : _a = a;
+  TableBObjectBuilder({
+    TableAObjectBuilder? a,
+  })
+      : _a = a;

  /// Finish building, and store into the [fbBuilder].
  @override
--- a/dart/test/keyword_test_keyword_test_generated.dart
+++ b/dart/test/keyword_test_keyword_test_generated.dart
@@ -1,5 +1,5 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names
+// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable

 library keyword_test;

@@ -7,29 +7,39 @@ import 'dart:typed_data' show Uint8List;
 import 'package:flat_buffers/flat_buffers.dart' as fb;


-enum Abc {
-  $void(0),
-  where(1),
-  stackalloc(2);
-
+class Abc {
  final int value;
-  const Abc(this.value);
+  const Abc._(this.value);

  factory Abc.fromValue(int value) {
-    switch (value) {
-      case 0: return Abc.$void;
-      case 1: return Abc.where;
-      case 2: return Abc.stackalloc;
-      default: throw StateError('Invalid value $value for bit flag enum');
+    final result = values[value];
+    if (result == null) {
+        throw StateError('Invalid value $value for bit flag enum Abc');
    }
+    return result;
  }

-  static Abc? _createOrNull(int? value) =>
+  static Abc? _createOrNull(int? value) => 
      value == null ? null : Abc.fromValue(value);

  static const int minValue = 0;
  static const int maxValue = 2;
+  static bool containsValue(int value) => values.containsKey(value);
+
+  static const Abc $void = Abc._(0);
+  static const Abc where = Abc._(1);
+  static const Abc stackalloc = Abc._(2);
+  static const Map<int, Abc> values = {
+    0: $void,
+    1: where,
+    2: stackalloc};
+
  static const fb.Reader<Abc> reader = _AbcReader();
+
+  @override
+  String toString() {
+    return 'Abc{value: $value}';
+  }
 }

 class _AbcReader extends fb.Reader<Abc> {
@@ -43,25 +53,35 @@ class _AbcReader extends fb.Reader<Abc> {
      Abc.fromValue(const fb.Int32Reader().read(bc, offset));
 }

-enum Public {
-  NONE(0);
-
+class Public {
  final int value;
-  const Public(this.value);
+  const Public._(this.value);

  factory Public.fromValue(int value) {
-    switch (value) {
-      case 0: return Public.NONE;
-      default: throw StateError('Invalid value $value for bit flag enum');
+    final result = values[value];
+    if (result == null) {
+        throw StateError('Invalid value $value for bit flag enum Public');
    }
+    return result;
  }

-  static Public? _createOrNull(int? value) =>
+  static Public? _createOrNull(int? value) => 
      value == null ? null : Public.fromValue(value);

  static const int minValue = 0;
  static const int maxValue = 0;
+  static bool containsValue(int value) => values.containsKey(value);
+
+  static const Public NONE = Public._(0);
+  static const Map<int, Public> values = {
+    0: NONE};
+
  static const fb.Reader<Public> reader = _PublicReader();
+
+  @override
+  String toString() {
+    return 'Public{value: $value}';
+  }
 }

 class _PublicReader extends fb.Reader<Public> {
@@ -75,29 +95,39 @@ class _PublicReader extends fb.Reader<Public> {
      Public.fromValue(const fb.Int32Reader().read(bc, offset));
 }

-enum KeywordsInUnionTypeId {
-  NONE(0),
-  $static(1),
-  internal(2);
-
+class KeywordsInUnionTypeId {
  final int value;
-  const KeywordsInUnionTypeId(this.value);
+  const KeywordsInUnionTypeId._(this.value);

  factory KeywordsInUnionTypeId.fromValue(int value) {
-    switch (value) {
-      case 0: return KeywordsInUnionTypeId.NONE;
-      case 1: return KeywordsInUnionTypeId.$static;
-      case 2: return KeywordsInUnionTypeId.internal;
-      default: throw StateError('Invalid value $value for bit flag enum');
+    final result = values[value];
+    if (result == null) {
+        throw StateError('Invalid value $value for bit flag enum KeywordsInUnionTypeId');
    }
+    return result;
  }

-  static KeywordsInUnionTypeId? _createOrNull(int? value) =>
+  static KeywordsInUnionTypeId? _createOrNull(int? value) => 
      value == null ? null : KeywordsInUnionTypeId.fromValue(value);

  static const int minValue = 0;
  static const int maxValue = 2;
+  static bool containsValue(int value) => values.containsKey(value);
+
+  static const KeywordsInUnionTypeId NONE = KeywordsInUnionTypeId._(0);
+  static const KeywordsInUnionTypeId $static = KeywordsInUnionTypeId._(1);
+  static const KeywordsInUnionTypeId internal = KeywordsInUnionTypeId._(2);
+  static const Map<int, KeywordsInUnionTypeId> values = {
+    0: NONE,
+    1: $static,
+    2: internal};
+
  static const fb.Reader<KeywordsInUnionTypeId> reader = _KeywordsInUnionTypeIdReader();
+
+  @override
+  String toString() {
+    return 'KeywordsInUnionTypeId{value: $value}';
+  }
 }

 class _KeywordsInUnionTypeIdReader extends fb.Reader<KeywordsInUnionTypeId> {
--- a/dart/test/list_of_enums.fbs
+++ b/dart/test/list_of_enums.fbs
--- a/dart/test/list_of_enums_generated.dart
+++ b/dart/test/list_of_enums_generated.dart
@@ -1,37 +1,43 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names
+// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable

 import 'dart:typed_data' show Uint8List;
-
 import 'package:flat_buffers/flat_buffers.dart' as fb;

-enum OptionsEnum {
-  A(1),
-  B(2),
-  C(3);

+class OptionsEnum {
  final int value;
-  const OptionsEnum(this.value);
+  const OptionsEnum._(this.value);

  factory OptionsEnum.fromValue(int value) {
-    switch (value) {
-      case 1:
-        return OptionsEnum.A;
-      case 2:
-        return OptionsEnum.B;
-      case 3:
-        return OptionsEnum.C;
-      default:
-        throw StateError('Invalid value $value for bit flag enum');
+    final result = values[value];
+    if (result == null) {
+        throw StateError('Invalid value $value for bit flag enum OptionsEnum');
    }
+    return result;
  }

-  static OptionsEnum? _createOrNull(int? value) =>
+  static OptionsEnum? _createOrNull(int? value) => 
      value == null ? null : OptionsEnum.fromValue(value);

  static const int minValue = 1;
  static const int maxValue = 3;
+  static bool containsValue(int value) => values.containsKey(value);
+
+  static const OptionsEnum A = OptionsEnum._(1);
+  static const OptionsEnum B = OptionsEnum._(2);
+  static const OptionsEnum C = OptionsEnum._(3);
+  static const Map<int, OptionsEnum> values = {
+    1: A,
+    2: B,
+    3: C};
+
  static const fb.Reader<OptionsEnum> reader = _OptionsEnumReader();
+
+  @override
+  String toString() {
+    return 'OptionsEnum{value: $value}';
+  }
 }

 class _OptionsEnumReader extends fb.Reader<OptionsEnum> {
@@ -57,9 +63,7 @@ class MyTable {
  final fb.BufferContext _bc;
  final int _bcOffset;

-  List<OptionsEnum>? get options => const fb.ListReader<OptionsEnum>(
-    OptionsEnum.reader,
-  ).vTableGetNullable(_bc, _bcOffset, 4);
+  List<OptionsEnum>? get options => const fb.ListReader<OptionsEnum>(OptionsEnum.reader).vTableGetNullable(_bc, _bcOffset, 4);

  @override
  String toString() {
@@ -67,11 +71,7 @@ class MyTable {
  }

  MyTableT unpack() => MyTableT(
-    options: const fb.ListReader<OptionsEnum>(
-      OptionsEnum.reader,
-      lazy: false,
-    ).vTableGetNullable(_bc, _bcOffset, 4),
-  );
+      options: const fb.ListReader<OptionsEnum>(OptionsEnum.reader, lazy: false).vTableGetNullable(_bc, _bcOffset, 4));

  static int pack(fb.Builder fbBuilder, MyTableT? object) {
    if (object == null) return 0;
@@ -82,12 +82,12 @@ class MyTable {
 class MyTableT implements fb.Packable {
  List<OptionsEnum>? options;

-  MyTableT({this.options});
+  MyTableT({
+      this.options});

  @override
  int pack(fb.Builder fbBuilder) {
-    final int? optionsOffset = options == null
-        ? null
+    final int? optionsOffset = options == null ? null
        : fbBuilder.writeListUint32(options!.map((f) => f.value).toList());
    fbBuilder.startTable(1);
    fbBuilder.addOffset(0, optionsOffset);
@@ -104,8 +104,8 @@ class _MyTableReader extends fb.TableReader<MyTable> {
  const _MyTableReader();

  @override
-  MyTable createObject(fb.BufferContext bc, int offset) =>
-      MyTable._(bc, offset);
+  MyTable createObject(fb.BufferContext bc, int offset) => 
+    MyTable._(bc, offset);
 }

 class MyTableBuilder {
@@ -130,13 +130,15 @@ class MyTableBuilder {
 class MyTableObjectBuilder extends fb.ObjectBuilder {
  final List<OptionsEnum>? _options;

-  MyTableObjectBuilder({List<OptionsEnum>? options}) : _options = options;
+  MyTableObjectBuilder({
+    List<OptionsEnum>? options,
+  })
+      : _options = options;

  /// Finish building, and store into the [fbBuilder].
  @override
  int finish(fb.Builder fbBuilder) {
-    final int? optionsOffset = _options == null
-        ? null
+    final int? optionsOffset = _options == null ? null
        : fbBuilder.writeListUint32(_options!.map((f) => f.value).toList());
    fbBuilder.startTable(1);
    fbBuilder.addOffset(0, optionsOffset);
--- a/dart/test/monster_test_my_game.example2_generated.dart
+++ b/dart/test/monster_test_my_game.example2_generated.dart
@@ -1,15 +1,15 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names
+// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable

 library my_game.example2;

 import 'dart:typed_data' show Uint8List;
-
 import 'package:flat_buffers/flat_buffers.dart' as fb;

-import './include_test1_generated.dart';
-import './monster_test_my_game.example_generated.dart' as my_game_example;
 import './monster_test_my_game_generated.dart' as my_game;
+import './monster_test_my_game.example_generated.dart' as my_game_example;
+
+import './include_test1_generated.dart';

 class Monster {
  Monster._(this._bc, this._bcOffset);
@@ -23,6 +23,7 @@ class Monster {
  final fb.BufferContext _bc;
  final int _bcOffset;

+
  @override
  String toString() {
    return 'Monster{}';
@@ -53,11 +54,12 @@ class _MonsterReader extends fb.TableReader<Monster> {
  const _MonsterReader();

  @override
-  Monster createObject(fb.BufferContext bc, int offset) =>
-      Monster._(bc, offset);
+  Monster createObject(fb.BufferContext bc, int offset) => 
+    Monster._(bc, offset);
 }

 class MonsterObjectBuilder extends fb.ObjectBuilder {
+
  MonsterObjectBuilder();

  /// Finish building, and store into the [fbBuilder].
--- a/dart/test/monster_test_my_game.example_generated.dart
+++ b/dart/test/monster_test_my_game.example_generated.dart
--- a/dart/test/monster_test_my_game_generated.dart
+++ b/dart/test/monster_test_my_game_generated.dart
@@ -1,15 +1,15 @@
 // automatically generated by the FlatBuffers compiler, do not modify
-// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable, constant_identifier_names
+// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable

 library my_game;

 import 'dart:typed_data' show Uint8List;
-
 import 'package:flat_buffers/flat_buffers.dart' as fb;

-import './include_test1_generated.dart';
-import './monster_test_my_game.example2_generated.dart' as my_game_example2;
 import './monster_test_my_game.example_generated.dart' as my_game_example;
+import './monster_test_my_game.example2_generated.dart' as my_game_example2;
+
+import './include_test1_generated.dart';

 class InParentNamespace {
  InParentNamespace._(this._bc, this._bcOffset);
@@ -23,6 +23,7 @@ class InParentNamespace {
  final fb.BufferContext _bc;
  final int _bcOffset;

+
  @override
  String toString() {
    return 'InParentNamespace{}';
@@ -53,11 +54,12 @@ class _InParentNamespaceReader extends fb.TableReader<InParentNamespace> {
  const _InParentNamespaceReader();

  @override
-  InParentNamespace createObject(fb.BufferContext bc, int offset) =>
-      InParentNamespace._(bc, offset);
+  InParentNamespace createObject(fb.BufferContext bc, int offset) => 
+    InParentNamespace._(bc, offset);
 }

 class InParentNamespaceObjectBuilder extends fb.ObjectBuilder {
+
  InParentNamespaceObjectBuilder();

  /// Finish building, and store into the [fbBuilder].
--- a/docs/README.md
+++ b/docs/README.md
@@ -1,24 +0,0 @@
-# Documentation
-
-This is the source of the FlatBuffers documentation, that is served at
-https://flatbuffers.dev.
-
-
-## Local Building
-
-The documentation can be built and served locally during development, see <https://flatbuffers.dev/contributing/#local-development> for full details.
-
-__tl;dr__
-
-Install:
-
-```
-pip install mkdocs-material
-pip install mkdocs-redirects
-```
-
-Build and Serve:
-
-```
-mkdocs serve -f docs/mkdocs.yml
-```
--- a/docs/footer.html
+++ b/docs/footer.html
@@ -0,0 +1,14 @@
+<!-- Google Analytics -->
+<script>
+  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+  })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
+
+  ga('create', 'UA-49880327-7', 'auto');
+  ga('send', 'pageview');
+
+</script>
+
+</body>
+</html>
--- a/docs/header.html
+++ b/docs/header.html
@@ -0,0 +1,62 @@
+<!-- HTML header for doxygen 1.8.6-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen $doxygenversion"/>
+<!--BEGIN PROJECT_NAME--><title>$projectname: $title</title><!--END PROJECT_NAME-->
+<!--BEGIN !PROJECT_NAME--><title>$title</title><!--END !PROJECT_NAME-->
+<link href="$relpath^tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="$relpath^jquery.js"></script>
+<script type="text/javascript" src="$relpath^dynsections.js"></script>
+$treeview
+$search
+$mathjax
+<link href="$relpath^$stylesheet" rel="stylesheet" type="text/css" />
+<link href="https://fonts.googleapis.com/css?family=Roboto:300,400,400italic,500,500italic,700,700italic|Roboto+Mono:400,700" rel="stylesheet">
+$extrastylesheet
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+
+<!--BEGIN TITLEAREA-->
+<div id="titlearea" style="height: 110px;">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <!--BEGIN PROJECT_LOGO-->
+  <td id="projectlogo"><img alt="Logo" src="$relpath^$projectlogo"/></td>
+  <!--END PROJECT_LOGO-->
+  <td id="commonprojectlogo">
+    <img alt="Logo" src="$relpath^fpl_logo_small.png"/>
+  </td>
+  <!--BEGIN PROJECT_NAME-->
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">$projectname
+   <!--BEGIN PROJECT_NUMBER-->&#160;<span id="projectnumber">$projectnumber</span><!--END PROJECT_NUMBER-->
+   </div>
+   <div style="font-size:12px;">
+    An open source project by <a href="https://developers.google.com/games/#Tools">FPL</a>.
+   </div>
+   <!--BEGIN PROJECT_BRIEF--><div id="projectbrief">$projectbrief</div><!--END PROJECT_BRIEF-->
+  </td>
+  <!--END PROJECT_NAME-->
+  <!--BEGIN !PROJECT_NAME-->
+   <!--BEGIN PROJECT_BRIEF-->
+    <td style="padding-left: 0.5em;">
+    <div id="projectbrief">$projectbrief</div>
+    </td>
+   <!--END PROJECT_BRIEF-->
+  <!--END !PROJECT_NAME-->
+  <!--BEGIN DISABLE_INDEX-->
+   <!--BEGIN SEARCHENGINE-->
+   <td>$searchbox</td>
+   <!--END SEARCHENGINE-->
+  <!--END DISABLE_INDEX-->
+ </tr>
+ </tbody>
+</table>
+</div>
+<!--END TITLEAREA-->
+<!-- end header part -->
--- a/docs/images/fpl_logo_small.png
+++ b/docs/images/fpl_logo_small.png
--- a/docs/images/ftv2mnode.png
+++ b/docs/images/ftv2mnode.png
--- a/docs/images/ftv2pnode.png
+++ b/docs/images/ftv2pnode.png
--- a/docs/mkdocs.yml
+++ b/docs/mkdocs.yml
@@ -1,159 +0,0 @@
-site_name: FlatBuffers Docs
-docs_dir: source
-site_url: https://flatbuffers.dev
-repo_name: google/FlatBuffers
-repo_url: https://github.com/google/flatbuffers
-edit_uri: edit/master/docs/source/
-copyright: Copyright &copy; 2025 Google
-theme:
-  name: material
-  logo: assets/flatbuffers_logo.svg
-  icon:
-    repo: fontawesome/brands/github
-  custom_dir: overrides
-  palette:
-    # Palette toggle for light mode
-    - scheme: default
-      toggle:
-        icon: material/brightness-7
-        name: Switch to dark mode
-
-    # Palette toggle for dark mode
-    - scheme: slate
-      toggle:
-        icon: material/brightness-4
-        name: Switch to light mode
-
-  features:
-    # Allows code block annotations
-    - content.code.annotate
-
-    # Allows content tabs to link together
-    - content.tabs.link
-  
-    # Expand nav folders by default
-    - navigation.expand
-
-    # Enable the footer
-    - navigation.footer
-    
-    # Auto hide the header after scrolling
-    - header.autohide
-
-    - content.action.edit
-
-extra:
-  social:
-    - icon: fontawesome/brands/github
-      link: https://github.com/google/flatbuffers
-
-    - icon: fontawesome/brands/discord
-      link: https:///discord.gg/6qgKs3R
-
-    - icon: fontawesome/brands/x-twitter
-      link: https://twitter.com/dbaileychess
-
-plugins:
-  # Use redirects to update links from the original docs to the new ones.
-  #
-  # https://github.com/mkdocs/mkdocs-redirects
-  - redirects:
-      # Note the .html are suffixed with .md to avoid warnings. Got from 
-      # https://github.com/mkdocs/mkdocs-redirects/issues/51#issuecomment-2408548029
-      redirect_maps:
-        'flatbuffers_guide_building.html.md': 'building.md'
-        'flatbuffers_guide_tutorial.html.md': 'tutorial.md'
-        'flatbuffers_guide_using_schema_compiler.html.md': 'flatc.md'
-        'flatbuffers_guide_writing_schema.html.md': 'schema.md'
-        'md__schemas.html.md': 'schema.md' # issue #8485
-        'flatbuffers_guide_use_c.html.md': 'languages/c.md'
-        'flatbuffers_guide_use_cpp.html.md': 'languages/cpp.md'
-        'flatbuffers_guide_use_c-sharp.html.md': 'languages/c_sharp.md'
-        'flatbuffers_guide_use_dart.html.md': 'languages/dart.md'
-        'flatbuffers_guide_use_go.html.md': 'languages/go.md'
-        'flatbuffers_guide_use_java.html.md': 'languages/java.md'
-        'flatbuffers_guide_use_javascript.html.md': 'languages/javascript.md'
-        'flatbuffers_guide_use_lobster.html.md': 'languages/lobster.md'
-        'flatbuffers_guide_use_lua.html.md': 'languages/lua.md'
-        'flatbuffers_guide_use_php.html.md': 'languages/php.md'
-        'flatbuffers_guide_use_python.html.md': 'languages/python.md'
-        'flatbuffers_guide_use_rust.html.md': 'languages/rust.md'
-        'flatbuffers_guide_use_swift.html.md': 'languages/swift.md'
-        'flatbuffers_guide_use_typescript.html.md': 'languages/typescript.md'
-        'flatbuffers_grpc_guide_use_cpp.html.md' : "languages/cpp.md#grpc"
-        'flatbuffers_support.html.md': 'support.md'
-        'flatbuffers_white_paper.html.md': 'white_paper.md'
-        'flatbuffers_grammar.html.md': 'grammar.md'
-        'flatbuffers_internals.html.md': 'internals.md'
-        'intermediate_representation.html.md': 'intermediate_representation.md'
-        'flatbuffers_benchmarks.html.md': 'benchmarks.md'
-        'flexbuffers.html.md': 'flexbuffers.md'
-        'contributing.html.md': 'contributing.md'
-
-
-markdown_extensions:
-  - admonition
-  - attr_list
-  - md_in_html
-  - pymdownx.critic
-  - pymdownx.details
-  - pymdownx.emoji:
-      emoji_index: !!python/name:material.extensions.emoji.twemoji
-      emoji_generator: !!python/name:material.extensions.emoji.to_svg
-  - pymdownx.snippets:
-      # Allows direct embedded of remote files
-      url_download: true
-  - pymdownx.superfences
-  - pymdownx.tabbed:
-      alternate_style: true
-      slugify: !!python/object/apply:pymdownx.slugs.slugify
-        kwds:
-          case: lower
-  - pymdownx.highlight:
-      extend_pygments_lang:
-        # PHP wasn't highlighting correctly. This is a work around found
-        # https://github.com/squidfunk/mkdocs-material/issues/138#issuecomment-2294025627
-        - name: php
-          lang: php
-          options:
-            startinline: true
-  - tables
-
-
-
-nav:
-  - Overview: "index.md"
-  - Quick Start: "quick_start.md"
-  - Tutorial: "tutorial.md"
-  - Compiler (flatc): 
-    - Building: "building.md"
-    - Using: "flatc.md"
-  - Schema (.fbs): 
-    - Overview: "schema.md"
-    - Evolution: "evolution.md"
-    - Grammar: "grammar.md"
-  - Language Guides:
-    - C: "languages/c.md"
-    - C++: "languages/cpp.md"
-    - C#: "languages/c_sharp.md"
-    - Dart: "languages/dart.md"
-    - Go: "languages/go.md"
-    - Java: "languages/java.md"
-    - JavaScript: "languages/javascript.md"
-    - Kotlin: "languages/kotlin.md"
-    - Lobster: "languages/lobster.md"
-    - Lua: "languages/lua.md"
-    - PHP: "languages/php.md"
-    - Python: "languages/python.md"
-    - Rust: "languages/rust.md"
-    - Swift: "languages/swift.md"
-    - TypeScript: "languages/typescript.md"
-  - Supported Configurations: "support.md"
-  - White Paper: "white_paper.md"
-  - Advanced:
-    - FlatBuffers Internals: "internals.md"
-    - Intermediate Representation: "intermediate_representation.md"
-    - Annotating Buffers (.afb): "annotation.md"
-    - Benchmarks: "benchmarks.md"
-  - FlexBuffers (Schema-less version): "flexbuffers.md"
-  - Contributing: "contributing.md"
--- a/docs/overrides/404.html
+++ b/docs/overrides/404.html
@@ -1,10 +0,0 @@
-{% extends "main.html" %}
-
-<!-- Content -->
-{% block content %}
-  <h1>404 - Not found</h1>
-  <br>
-  FlatBuffers has migrated their documentation system recently.
-  
-  Please <a href="https://github.com/google/flatbuffers/issues/new?template=404-doc.md">file an issue</a> indicating the broken link.
-{% endblock %}
--- a/docs/overrides/main.html
+++ b/docs/overrides/main.html
@@ -1 +0,0 @@
-{% extends "base.html" %}
--- a/docs/source/Benchmarks.md
+++ b/docs/source/Benchmarks.md
--- a/docs/source/Building.md
+++ b/docs/source/Building.md
@@ -1,93 +1,52 @@
-# Building
+Building    {#flatbuffers_guide_building}
+========

 ## Building with CMake

-The distribution main build system is configured by
-[`cmake`](https://www.cmake.org) which allows you to build the project for any
-platform.
+The distribution comes with a `cmake` file that should allow
+you to build project/make files for any platform. For details on `cmake`, see
+<https://www.cmake.org>. In brief, depending on your platform, use one of
+e.g.:

-### Configuration
-
-Use `cmake` to configure a project based on your environment and platform.
-
-=== "Unix"
-
-    ```sh
    cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Release
-    ```
-
-To use `clang` instead of `gcc` you may need to set prepend some environment
-variables e.g. `CC=/usr/bin/clang CXX=/usr/bin/clang++ cmake -G "Unix
-MakeFiles"`
-
-=== "Windows"
-
-    ```sh
-    cmake -G "Visual Studio 17 2022" -DCMAKE_BUILD_TYPE=Release
-    ```
-
-=== "MacOS"
-
-    ```sh
+    cmake -G "Visual Studio 10" -DCMAKE_BUILD_TYPE=Release
    cmake -G "Xcode" -DCMAKE_BUILD_TYPE=Release
-    ```

-#### Strict Mode
+Then, build as normal for your platform. This should result in a `flatc`
+executable, essential for the next steps.
+Note that to use clang instead of gcc, you may need to set up your environment
+variables, e.g.
+`CC=/usr/bin/clang CXX=/usr/bin/clang++ cmake -G "Unix Makefiles"`.

-By default, `cmake` will configure targets to **not** build with strict warnings
-on (e.g. `-Werror` or `/WX`). This may cause into issues when submitting code
-changes since our CI requires the code to compile in strict mode.
+Optionally, run the `flattests` executable from the root `flatbuffers/`
+directory to ensure everything is working correctly on your system. If this
+fails, please contact us!

-To enable the extra warnings, turn on strict mode with the
-`FLATBUFFERS_STRICT_MODE` cmake option.
+Building should also produce two sample executables, `flatsamplebinary` and
+`flatsampletext`, see the corresponding `.cpp` files in the
+`flatbuffers/samples` directory.

-```cmake
-cmake -DFLATBUFFERS_STRICT_MODE=ON
+*Note that you MUST be in the root of the FlatBuffers distribution when you
+run 'flattests' or `flatsampletext`, or it will fail to load its files.*
+
+### Make all warnings into errors
+
+By default all Flatbuffers `cmake` targets are **not** built with the `-Werror` 
+(or `/WX` for MSVC) flag that treats any warning as an error. This allows more 
+flexibility for users of Flatbuffers to use newer compilers and toolsets that
+may add new warnings that would cause a build failure.
+
+To enable a stricter build that does treat warnings as errors, set the
+`FLATBUFFERS_STRICT_MODE` `cmake` compliation flag to `ON`. 
+
+```
+cmake . -DFLATBUFFERS_STRICT_MODE=ON
 ```

-
-### Building
-
-Once the project files are generated, build as normal for your platform.
-
-=== "Unix"
-
-    ```sh
-    make -j
-    ```
-
-=== "Windows"
-
-    ```sh
-    msbuild.exe FlatBuffers.sln
-    ```
-
-=== "MacOS"
-
-    ```sh
-    xcodebuild -toolchain clang -configuration Release
-    ```
-
-
-
-
-
-
-## Building with Bazel
-
-You can use [Bazelisk](https://github.com/bazelbuild/bazelisk) to manage your Bazel environment.
-For Swift support, you also need Clang and [Swift SDK](https://download.swift.org/).
-
-```sh
-curl -sL --fail https://github.com/bazelbuild/bazelisk/releases/download/v1.25.0/bazelisk-linux-amd64 -o bazelisk && chmod +x bazelisk
-sudo apt install -y clang
-SWIFT_VERSION="6.0.3"
-curl -L https://download.swift.org/swift-${SWIFT_VERSION}-release/debian12/swift-${SWIFT_VERSION}-RELEASE/swift-${SWIFT_VERSION}-RELEASE-debian12.tar.gz | tar xz
-CC=clang PATH=$PATH:$(pwd)/swift-${SWIFT_VERSION}-RELEASE-debian12/usr/bin bazel build //...
-CC=clang PATH=$PATH:$(pwd)/swift-${SWIFT_VERSION}-RELEASE-debian12/usr/bin bazel test //...
-```
-
-If you are unsure which versions to use, check our CI config at `.bazelci/presubmit.yml`.
+Our CI builds run with strict mode on, ensuring the code that is committed to 
+the project is as portable and warning free as possible. Thus developers
+contributing to the project should enable strict mode locally before making a 
+PR.

 ## Building with VCPKG

@@ -102,7 +61,17 @@ You can download and install flatbuffers using the [vcpkg](https://github.com/Mi
 The flatbuffers port in vcpkg is kept up to date by Microsoft team members and community contributors.
 If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.

+## Downloading binaries
+You can download the binaries from the
+[GitHub release page](https://github.com/google/flatbuffers/releases).

+We generate [SLSA3 signatures](slsa.dev) using the OpenSSF's [slsa-framework/slsa-github-generator](https://github.com/slsa-framework/slsa-github-generator). To verify the binaries:
+1. Install the verification tool from [slsa-framework/slsa-verifier#installation](https://github.com/slsa-framework/slsa-verifier#installation)
+1. Download the file named `attestation.intoto.jsonl` from the GitHub release
+1. Run:
+```shell
+$ slsa-verifier -artifact-path <downloaded.zip> -provenance attestation.intoto.jsonl -source github.com/google/flatbuffers -tag <version>
+  PASSED: Verified SLSA provenance

 ## Building for Android

@@ -127,7 +96,7 @@ also compile/link `src/idl_parser.cpp` (and `src/idl_gen_text.cpp` if you
 also want to be able convert binary to text).

 To see how to include FlatBuffers in any of our supported languages, please
-view the [Tutorial](tutorial.md) and select your appropriate
+view the [Tutorial](@ref flatbuffers_guide_tutorial) and select your appropriate
 language using the radio buttons.

 ### Using in CMake-based projects
@@ -156,22 +125,9 @@ When build your project the `flatbuffers` library will be compiled and linked
 to a target as part of your project.

 #### Override default depth limit of nested objects
-To override [the depth limit of recursion](languages/cpp.md), 
+To override [the depth limit of recursion](@ref flatbuffers_guide_use_cpp), 
 add this directive:
 ```cmake
 set(FLATBUFFERS_MAX_PARSING_DEPTH 16)
 ```
 to `CMakeLists.txt` file before `add_subdirectory(${FLATBUFFERS_SRC_DIR})` line.
-
-## Downloading binaries
-You can download the binaries from the
-[GitHub release page](https://github.com/google/flatbuffers/releases).
-
-We generate [SLSA3 signatures](http://slsa.dev) using the OpenSSF's [slsa-framework/slsa-github-generator](https://github.com/slsa-framework/slsa-github-generator). To verify the binaries:
-1. Install the verification tool from [slsa-framework/slsa-verifier#installation](https://github.com/slsa-framework/slsa-verifier#installation)
-1. Download the file named `attestation.intoto.jsonl` from the GitHub release
-1. Run:
-```shell
-$ slsa-verifier -artifact-path <downloaded.zip> -provenance attestation.intoto.jsonl -source github.com/google/flatbuffers -tag <version>
-  PASSED: Verified SLSA provenance
-```
--- a/docs/source/CNAME
+++ b/docs/source/CNAME
@@ -1 +0,0 @@
-flatbuffers.dev
--- a/docs/source/CONTRIBUTING.md
+++ b/docs/source/CONTRIBUTING.md
@@ -0,0 +1 @@
+../../CONTRIBUTING.md
--- a/docs/source/languages/c.md
+++ b/docs/source/languages/c.md
@@ -12,7 +12,7 @@ project.

 ## General Documention

- [Tutorial](../tutorial.md) - select C as language
+- [Tutorial](@ref flatbuffers_guide_tutorial) - select C as language
  when scrolling down
 - [FlatCC Guide](https://github.com/dvidelabs/flatcc#flatcc-flatbuffers-in-c-for-c)
 - [The C Builder Interface](https://github.com/dvidelabs/flatcc/blob/master/doc/builder.md#the-builder-interface)
--- a/docs/source/Compiler.md
+++ b/docs/source/Compiler.md
@@ -1,91 +1,70 @@
-# FlatBuffers Compiler (`flatc`)
+Using the schema compiler    {#flatbuffers_guide_using_schema_compiler}
+=========================

-The main compiler for FlatBuffers is called `flatc` and is used to convert
-schema definitions into generated code files for a variety of languages. 
+Usage:

-After [building](building.md) `flatc`, it is used as follows:
+    flatc [ GENERATOR OPTIONS ] [ -o PATH ] [ -I PATH ] FILES...
+          [ -- FILES...]

-```sh
-flatc [ GENERATOR_OPTIONS ] [ -o PATH ] [- I PATH ] 
-  FILES... 
-  [ -- BINARY_FILES... ]
-```
+The files are read and parsed in order, and can contain either schemas
+or data (see below). Data files are processed according to the definitions of
+the most recent schema specified.

-* The `GENERATOR_OPTIONS` specify the language(s) to compile code for as well as
-various features to enable/disable.
+`--` indicates that the following files are binary files in
+FlatBuffer format conforming to the schema indicated before it.

-* The `-o PATH` specifies the path where the generated files are placed. It
-defaults to the current path if not specified.
+Depending on the flags passed, additional files may
+be generated for each file processed:

-* The `-I PATH` specifies the paths where included schema files are located. It
-  defaults to the current path if not specified.
+For any schema input files, one or more generators can be specified:

-## Input Files
+-   `--cpp`, `-c` : Generate a C++ header for all definitions in this file (as
+    `filename_generated.h`).

-`FILES...` specifies one or more schema or data files to process. They are
-processed in the order provided.
+-   `--java`, `-j` : Generate Java code.

-### Schema Files
+-   `--kotlin` , `--kotlin-kmp` : Generate Kotlin code.

-For schema files, language specifiers indicate what languages to generate code
-for.
+-   `--csharp`, `-n` : Generate C# code.

-  * `--cpp`: C++
-  * `--java`: Java
-  * `--kotlin`: Kotlin
-  * `--csharp`: C#
-  * `--go`: Golang
-  * `--python`: Python
-  * `--js`: JavaScript
-  * `--ts`: TypeScript
-  * `--php`: PHP
-  * `--dart`: Dart
-  * `--lua`: Lua
-  * `--lobster`: Lobster
-  * `--rust`: Rust
-  * `--swift`: Swift
-  * `--nim`: Nim
+-   `--go`, `-g` : Generate Go code.

-Additionally, adding:
+-   `--python`, `-p` : Generate Python code.

-  * `--grpc` Will generate RPC stub code for gRPC (not available in all
-    languages)
+-   `--js`, `-s` : Generate JavaScript code.

-### Data Files
+-   `--ts`, `-T` : Generate TypeScript code.

-If `FILES...` contain data files, they can be exported to either a binary or
-JSON representation.
+-   `--php` : Generate PHP code.

-* `--binary`, `-b`: Generate a binary file containing a serialized flatbuffer.
-* `--json`, `-j`: Generate JSON file from a serialized flatbuffer.
+-   `--grpc` : Generate RPC stub code for GRPC.

-Both options require the corresponding schema file to be included first in the
-list of `FILES...`.
+-   `--dart`, `-d` : Generate Dart code.

-=== "To Binary"
+-   `--lua`, `-l` : Generate Lua code.

-    To serialize the JSON data in `mydata.json` using the schema `myschema.fbs`:
-   
-    ```sh
-    flatc --binary myschema.fbs mydata.json
-    ```
+-   `--lobster` : Generate Lobster code.

-    This will generate a `mydata_wire.bin` file containing the serialized 
-    flatbuffer data.
+-   `--rust`, `-r` : Generate Rust code.

-=== "To JSON"
+-   `--swift` : Generate Swift code.

-    To convert the serialized binary flatbuffer `mydata.bin` using the schema 
-    `myschema.fbs` to JSON:
-
-    ```sh
-    flatc --json myschema.fbs mydata.bin
-    ```
-
-    This will generate a `mydata.json` file.
+-   `--nim` : Generate Nim code.


-### Additional options
+
+For any data input files:
+
+-   `--binary`, `-b` : If data is contained in this file, generate a
+    `filename.bin` containing the binary flatbuffer (or a different extension
+    if one is specified in the schema).
+
+-   `--json`, `-t` : If data is contained in this file, generate a
+    `filename.json` representing the data in the flatbuffer.
+
+-   `--jsonschema` : Generate Json schema
+
+Additional options:

 -   `-o PATH` : Output all generated files to PATH (either absolute, or
    relative to the current directory). If omitted, PATH will be the
@@ -117,10 +96,10 @@ list of `FILES...`.

 -   `--scoped-enums` : Use C++11 style scoped and strongly typed enums in
    generated C++. This also implies `--no-prefix`.
-
+    
 -   `--no-emit-min-max-enum-values` : Disable generation of MIN and MAX
    enumerated values for scoped enums and prefixed enums.
-
+    
 -   `--gen-includes` : (deprecated), this is the default behavior.
                       If the original behavior is required (no include
 	                   statements) use `--no-includes.`
@@ -131,7 +110,7 @@ list of `FILES...`.
 -   `--gen-mutable` : Generate additional non-const accessors for mutating
    FlatBuffers in-place.

-   `--gen-onefile` : Generate a single output file for C#, Go, Java, Kotlin and Python.
+-   `--gen-onefile` : Generate single output file for C#, Go, and Python.

 -   `--gen-name-strings` : Generate type name functions for C++.

@@ -259,47 +238,5 @@ list of `FILES...`.

 -   `--python-typing` : Generate Python type annotations

-   `--python-decode-obj-api-strings` : Decode bytes automaticaly with utf-8
-
-Additional gRPC options:
-
-   `--grpc-filename-suffix`: `[C++]` An optional suffix for the generated
-    files' names. For example, compiling gRPC for C++ with
-    `--grpc-filename-suffix=.fbs` will generate `{name}.fbs.h` and
-    `{name}.fbs.cc` files.
-
-   `--grpc-additional-header`: `[C++]` Additional headers to include in the
-    generated files.
-
-   `--grpc-search-path`: `[C++]` An optional prefix for the gRPC runtime path.
-    For example, compiling gRPC for C++ with `--grpc-search-path=some/path` will
-    generate the following includes:
-
-    ```cpp
-      #include "some/path/grpcpp/impl/codegen/async_stream.h"
-      #include "some/path/grpcpp/impl/codegen/async_unary_call.h"
-      #include "some/path/grpcpp/impl/codegen/method_handler.h"
-      ...
-    ```
-
-   `--grpc-use-system-headers`: `[C++]` Whether to generate `#include <header>`
-    instead of `#include "header.h"` for all headers when compiling gRPC for
-    C++. For example, compiling gRPC for C++ with `--grpc-use-system-headers`
-    will generate the following includes:
-
-    ```cpp
-      #include <some/path/grpcpp/impl/codegen/async_stream.h>
-      #include <some/path/grpcpp/impl/codegen/async_unary_call.h>
-      #include <some/path/grpcpp/impl/codegen/method_handler.h>
-      ...
-    ```
-
-    NOTE: This option can be negated with `--no-grpc-use-system-headers`.
-
-   `--grpc-python-typed-handlers`: `[Python]` Whether to generate the typed
-    handlers that use the generated Python classes instead of raw bytes for
-    requests/responses.
-
 NOTE: short-form options for generators are deprecated, use the long form
 whenever possible.
-
--- a/docs/source/languages/cpp.md
+++ b/docs/source/languages/cpp.md
@@ -1,9 +1,10 @@
-# Language Guide: C++
+Use in C++    {#flatbuffers_guide_use_cpp}
+==========

 ## Before you get started

 Before diving into the FlatBuffers usage in C++, it should be noted that
-the [Tutorial](../tutorial.md) page has a complete guide
+the [Tutorial](@ref flatbuffers_guide_tutorial) page has a complete guide
 to general FlatBuffers usage in all of the supported languages (including C++).
 This page is designed to cover the nuances of FlatBuffers usage, specific to
 C++.
@@ -12,8 +13,8 @@ C++.

 This page assumes you have written a FlatBuffers schema and compiled it
 with the Schema Compiler. If you have not, please see
-[Using the schema compiler](../flatc.md)
-and [Writing a schema](../schema.md).
+[Using the schema compiler](@ref flatbuffers_guide_using_schema_compiler)
+and [Writing a schema](@ref flatbuffers_guide_writing_schema).

 Assuming you wrote a schema, say `mygame.fbs` (though the extension doesn't
 matter), you've generated a C++ header called `mygame_generated.h` using the
@@ -34,7 +35,7 @@ The test code itself is located in
 [test.cpp](https://github.com/google/flatbuffers/blob/master/tests/test.cpp).

 This test file is built alongside `flatc`. To review how to build the project,
-please read the [Building](../building.md) documentation.
+please read the [Building](@ref flatbuffers_guide_building) documentation.

 To run the tests, execute `flattests` from the root `flatbuffers/` directory.
 For example, on [Linux](https://en.wikipedia.org/wiki/Linux), you would simply
@@ -42,7 +43,7 @@ run: `./flattests`.

 ## Using the FlatBuffers C++ library

-*Note: See [Tutorial](../tutorial.md) for a more in-depth
+*Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
 example of how to use FlatBuffers in C++.*

 FlatBuffers supports both reading and writing FlatBuffers in C++.
@@ -95,7 +96,7 @@ The following attributes are supported:
    Specifically, `CreateXxxDirect` functions and `Pack` functions for object
    based API (see below) will use `CreateSharedString` to create strings.

-## Object based API
+## Object based API  {#flatbuffers_cpp_object_based_api}

 FlatBuffers is all about memory efficiency, which is why its base API is written
 around using as little as possible of it. This does make the API clumsier
@@ -253,7 +254,7 @@ Finally, the following top-level attributes:
 -   `force_align`: this attribute may not be respected in the object API,
    depending on the aligned of the allocator used with `new`.

-## External references
+# External references

 An additional feature of the object API is the ability to allow you to load
 multiple independent FlatBuffers, and have them refer to eachothers objects
@@ -261,7 +262,7 @@ using hashes which are then represented as typed pointers in the object API.

 To make this work have a field in the objects you want to referred to which is
 using the string hashing feature (see `hash` attribute in the
-[schema](../schema.md) documentation). Then you have
+[schema](@ref flatbuffers_guide_writing_schema) documentation). Then you have
 a similar hash in the field referring to it, along with a `cpp_type`
 attribute specifying the C++ type this will refer to (this can be any C++
 type, and will get a `*` added).
@@ -272,7 +273,7 @@ same string (or hash).
 When you call `UnPack` (or `Create`), you'll need a function that maps from
 hash to the object (see `resolver_function_t` for details).

-## Using different pointer types
+# Using different pointer types

 By default the object tree is built out of `std::unique_ptr`, but you can
 influence this either globally (using the `--cpp-ptr-type` argument to
@@ -283,7 +284,7 @@ you, so you'll have to manage their lifecycles manually.  To reference the
 pointer type specified by the `--cpp-ptr-type` argument to `flatc` from a
 flatbuffer field set the `cpp_ptr_type` attribute to `default_ptr_type`.

-## Using different string type
+# Using different string type

 By default the object tree is built out of `std::string`, but you can
 influence this either globally (using the `--cpp-str-type` argument to
@@ -419,8 +420,7 @@ Each root type will have a verification function generated for it,
 e.g. for `Monster`, you can call:

 ```cpp
-	Verifier verifier(buf, len);
-	bool ok = VerifyMonsterBuffer(verifier);
+	bool ok = VerifyMonsterBuffer(Verifier(buf, len));
 ```

 if `ok` is true, the buffer is safe to read.
@@ -556,11 +556,11 @@ recursion depth. Number of nested declarations in a schema or number of
 nested json-objects is limited. By default, this depth limit set to `64`.
 It is possible to override this limit with `FLATBUFFERS_MAX_PARSING_DEPTH`
 definition. This definition can be helpful for testing purposes or embedded
-applications. For details see [build](../building.md) of
+applications. For details see [build](@ref flatbuffers_guide_building) of
 CMake-based projects.

 ## Dependence from C-locale {#flatbuffers_locale_cpp}
-The Flatbuffers [grammar](../grammar.md) uses ASCII
+The Flatbuffers [grammar](@ref flatbuffers grammar) uses ASCII
 character set for identifiers, alphanumeric literals, reserved words.

 Internal implementation of the Flatbuffers depends from functions which
@@ -603,7 +603,7 @@ compatible with the `IEEE-754` floating-point standard.
 The schema and json parser may fail if `fast-math` or `/fp:fast` mode is active.

 ### Support of hexadecimal and special floating-point numbers
-According to the [grammar](../grammar.md) `fbs` and `json` files
+According to the [grammar](@ref flatbuffers_grammar) `fbs` and `json` files
 may use hexadecimal and special (`NaN`, `Inf`) floating-point literals.
 The Flatbuffers uses `strtof` and `strtod` functions to parse floating-point
 literals. The Flatbuffers library has a code to detect a compiler compatibility
@@ -626,7 +626,7 @@ According to the `IEEE-754`, a comparison with `NaN` always returns
 an unordered result even when compared with itself. As a result, a whole
 Flatbuffers object will be not equal to itself if has one or more `NaN`.
 Flatbuffers scalar fields that have the default value are not actually stored
-in the serialized data but are generated in code (see [Writing a schema](../schema.md)).
+in the serialized data but are generated in code (see [Writing a schema](@ref flatbuffers_guide_writing_schema)).
 Scalar fields with `NaN` defaults break this behavior.
 If a schema has a lot of `NaN` defaults the Flatbuffers can override
 the unordered comparison by the ordered: `(NaN==NaN)->true`.
@@ -636,38 +636,4 @@ Additional computations added by `FLATBUFFERS_NAN_DEFAULTS` are very cheap
 if GCC or Clang used. These compilers have a compile-time implementation
 of `isnan` checking which MSVC does not.

-## gRPC
-
-### Before you get started
-
-Before diving into the FlatBuffers gRPC usage in C++, you should already be
-familiar with the following:
-
- FlatBuffers as a serialization format
- [gRPC](http://www.grpc.io/docs/) usage
-
-### Using the FlatBuffers gRPC C++ library
-
-NOTE: The examples below are also in the `grpc/samples/greeter` directory.
-
-We will illustrate usage with the following schema:
-
-```c++ title="grpc/samples/greeter/greeter.fbs"
--8<-- "https://raw.githubusercontent.com/google/flatbuffers/refs/heads/master/grpc/samples/greeter/greeter.fbs"
-```
-
-When we run `flatc`, we pass in the `--grpc` option and generage an additional
-`greeter.grpc.fb.h` and `greeter.grpc.fb.cc`.
-
-Example server code looks like this:
-
-```c++ title="grpc/samples/greeter/server.cpp"
--8<-- "https://raw.githubusercontent.com/google/flatbuffers/refs/heads/master/grpc/samples/greeter/server.cpp"
-```
-
-Example client code looks like this:
-
-```c++ title="grpc/samples/greeter/client.cpp"
--8<-- "https://raw.githubusercontent.com/google/flatbuffers/refs/heads/master/grpc/samples/greeter/client.cpp"
-```
-
+<br>
--- a/docs/source/languages/c_sharp.md
+++ b/docs/source/languages/c_sharp.md
@@ -1,18 +1,18 @@
-Use in C\#    {#flatbuffers_guide_use_c-sharp}
+Use in C#    {#flatbuffers_guide_use_c-sharp}
 ==============

 ## Before you get started

 Before diving into the FlatBuffers usage in C#, it should be noted that
-the [Tutorial](../tutorial.md) page has a complete guide to
+the [Tutorial](@ref flatbuffers_guide_tutorial) page has a complete guide to
 general FlatBuffers usage in all of the supported languages (including C#).
 This page is designed to cover the nuances of FlatBuffers usage,
 specific to C#.

-You should also have read the [Building](../building.md)
+You should also have read the [Building](@ref flatbuffers_guide_building)
 documentation to build `flatc` and should be familiar with
-[Using the schema compiler](../flatc.md) and
-[Writing a schema](../schema.md).
+[Using the schema compiler](@ref flatbuffers_guide_using_schema_compiler) and
+[Writing a schema](@ref flatbuffers_guide_writing_schema).

 ## FlatBuffers C# code location

@@ -62,7 +62,7 @@ by running the following commands from inside the `FlatBuffers.Test` folder:

 ## Using the FlatBuffers C# library

-*Note: See [Tutorial](../tutorial.md) for a more in-depth
+*Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
 example of how to use FlatBuffers in C#.*

 FlatBuffers supports reading and writing binary FlatBuffers in C#.
@@ -141,7 +141,7 @@ To use it:

 ## Buffer verification

-As mentioned in [C++ Usage](cpp.md) buffer
+As mentioned in [C++ Usage](@ref flatbuffers_guide_use_cpp) buffer
 accessor functions do not verify buffer offsets at run-time.
 If it is necessary, you can optionally use a buffer verifier before you
 access the data. This verifier will check all offsets, all sizes of
--- a/docs/source/languages/dart.md
+++ b/docs/source/languages/dart.md
@@ -4,15 +4,15 @@ Use in Dart    {#flatbuffers_guide_use_dart}
 ## Before you get started

 Before diving into the FlatBuffers usage in Dart, it should be noted that
-the [Tutorial](../tutorial.md) page has a complete guide
+the [Tutorial](@ref flatbuffers_guide_tutorial) page has a complete guide
 to general FlatBuffers usage in all of the supported languages (including Dart).
 This page is designed to cover the nuances of FlatBuffers usage, specific to
 Dart.

-You should also have read the [Building](../building.md)
+You should also have read the [Building](@ref flatbuffers_guide_building)
 documentation to build `flatc` and should be familiar with
-[Using the schema compiler](../flatc.md) and
-[Writing a schema](../schema.md).
+[Using the schema compiler](@ref flatbuffers_guide_using_schema_compiler) and
+[Writing a schema](@ref flatbuffers_guide_writing_schema).

 ## FlatBuffers Dart library code location

@@ -34,7 +34,7 @@ to be installed.*

 ## Using the FlatBuffers Dart library

-*Note: See [Tutorial](../tutorial.md) for a more in-depth
+*Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
 example of how to use FlatBuffers in Dart.*

 FlatBuffers supports reading and writing binary FlatBuffers in Dart.
--- a/docs/source/FlatBuffers.md
+++ b/docs/source/FlatBuffers.md
@@ -0,0 +1,188 @@
+FlatBuffers    {#flatbuffers_index}
+===========
+
+# Overview {#flatbuffers_overview}
+
+[FlatBuffers](@ref flatbuffers_overview) is an efficient cross platform
+serialization library for C++, C#, C, Go, Java, Kotlin, JavaScript, Lobster, Lua, TypeScript, PHP, Python, Rust and Swift.
+It was originally created at Google for game development and other
+performance-critical applications.
+
+It is available as Open Source on [GitHub](http://github.com/google/flatbuffers)
+under the Apache license, v2 (see LICENSE).
+
+## Why use FlatBuffers?
+
+-   **Access to serialized data without parsing/unpacking** - What sets
+    FlatBuffers apart is that it represents hierarchical data in a flat
+    binary buffer in such a way that it can still be accessed directly
+    without parsing/unpacking, while also still supporting data
+    structure evolution (forwards/backwards compatibility).
+
+-   **Memory efficiency and speed** - The only memory needed to access
+    your data is that of the buffer. It requires 0 additional allocations
+    (in C++, other languages may vary). FlatBuffers is also very
+    suitable for use with mmap (or streaming), requiring only part of the
+    buffer to be in memory. Access is close to the speed of raw
+    struct access with only one extra indirection (a kind of vtable) to
+    allow for format evolution and optional fields. It is aimed at
+    projects where spending time and space (many memory allocations) to
+    be able to access or construct serialized data is undesirable, such
+    as in games or any other performance sensitive applications. See the
+    [benchmarks](@ref flatbuffers_benchmarks) for details.
+
+-   **Flexible** - Optional fields means not only do you get great
+    forwards and backwards compatibility (increasingly important for
+    long-lived games: don't have to update all data with each new
+    version!). It also means you have a lot of choice in what data you
+    write and what data you don't, and how you design data structures.
+
+-   **Tiny code footprint** - Small amounts of generated code, and just
+    a single small header as the minimum dependency, which is very easy
+    to integrate. Again, see the benchmark section for details.
+
+-   **Strongly typed** - Errors happen at compile time rather than
+    manually having to write repetitive and error prone run-time checks.
+    Useful code can be generated for you.
+
+-   **Convenient to use** - Generated C++ code allows for terse access
+    & construction code. Then there's optional functionality for parsing
+    schemas and JSON-like text representations at runtime efficiently if
+    needed (faster and more memory efficient than other JSON
+    parsers).
+
+    Java, Kotlin and Go code supports object-reuse. C# has efficient struct based
+    accessors.
+
+-   **Cross platform code with no dependencies** - C++ code will work
+    with any recent gcc/clang and VS2010. Comes with build files for the tests &
+    samples (Android .mk files, and cmake for all other platforms).
+
+### Why not use Protocol Buffers, or .. ?
+
+Protocol Buffers is indeed relatively similar to FlatBuffers,
+with the primary difference being that FlatBuffers does not need a parsing/
+unpacking step to a secondary representation before you can
+access data, often coupled with per-object memory allocation. The code
+is an order of magnitude bigger, too. Protocol Buffers has no optional
+text import/export.
+
+### But all the cool kids use JSON!
+
+JSON is very readable (which is why we use it as our optional text
+format) and very convenient when used together with dynamically typed
+languages (such as JavaScript). When serializing data from statically
+typed languages, however, JSON not only has the obvious drawback of runtime
+inefficiency, but also forces you to write *more* code to access data
+(counterintuitively) due to its dynamic-typing serialization system.
+In this context, it is only a better choice for systems that have very
+little to no information ahead of time about what data needs to be stored.
+
+If you do need to store data that doesn't fit a schema, FlatBuffers also
+offers a schema-less (self-describing) version!
+
+Read more about the "why" of FlatBuffers in the
+[white paper](@ref flatbuffers_white_paper).
+
+### Who uses FlatBuffers?
+-   [Cocos2d-x](http://www.cocos2d-x.org/), the #1 open source mobile game
+    engine, uses it to serialize all their
+    [game data](http://www.cocos2d-x.org/reference/native-cpp/V3.5/d7/d2d/namespaceflatbuffers.html).
+-   [Facebook](http://facebook.com/) uses it for client-server communication in
+    their Android app. They have a nice
+    [article](https://code.facebook.com/posts/872547912839369/improving-facebook-s-performance-on-android-with-flatbuffers/)
+    explaining how it speeds up loading their posts.
+-   [Fun Propulsion Labs](https://developers.google.com/games/#Tools)
+    at Google uses it extensively in all their libraries and games.
+
+## Usage in brief
+
+This section is a quick rundown of how to use this system. Subsequent
+sections provide a more in-depth usage guide.
+
+-   Write a schema file that allows you to define the data structures
+    you may want to serialize. Fields can have a scalar type
+    (ints/floats of all sizes), or they can be a: string; array of any type;
+    reference to yet another object; or, a set of possible objects (unions).
+    Fields are optional and have defaults, so they don't need to be
+    present for every object instance.
+
+-   Use `flatc` (the FlatBuffer compiler) to generate a C++ header (or
+    Java/Kotlin/C#/Go/Python.. classes) with helper classes to access and construct
+    serialized data. This header (say `mydata_generated.h`) only depends on
+    `flatbuffers.h`, which defines the core functionality.
+
+-   Use the `FlatBufferBuilder` class to construct a flat binary buffer.
+    The generated functions allow you to add objects to this
+    buffer recursively, often as simply as making a single function call.
+
+-   Store or send your buffer somewhere!
+
+-   When reading it back, you can obtain the pointer to the root object
+    from the binary buffer, and from there traverse it conveniently
+    in-place with `object->field()`.
+
+## In-depth documentation
+
+-   How to [build the compiler](@ref flatbuffers_guide_building) and samples on
+    various platforms.
+-   How to [use the compiler](@ref flatbuffers_guide_using_schema_compiler).
+-   How to [write a schema](@ref flatbuffers_guide_writing_schema).
+-   How to [use the generated C++ code](@ref flatbuffers_guide_use_cpp) in your
+    own programs.
+-   How to [use the generated Java code](@ref flatbuffers_guide_use_java)
+    in your own programs.
+-   How to [use the generated C# code](@ref flatbuffers_guide_use_c-sharp)
+    in your own programs.
+-   How to [use the generated Kotlin code](@ref flatbuffers_guide_use_kotlin)
+        in your own programs.
+-   How to [use the generated Go code](@ref flatbuffers_guide_use_go) in your
+    own programs.
+-   How to [use the generated Lua code](@ref flatbuffers_guide_use_lua) in your
+    own programs.
+-   How to [use the generated JavaScript code](@ref flatbuffers_guide_use_javascript) in your
+    own programs.
+-   How to [use the generated TypeScript code](@ref flatbuffers_guide_use_typescript) in your
+    own programs.
+-   How to [use FlatBuffers in C with `flatcc`](@ref flatbuffers_guide_use_c) in your
+    own programs.
+-   How to [use the generated Lobster code](@ref flatbuffers_guide_use_lobster) in your
+    own programs.
+-   How to [use the generated Rust code](@ref flatbuffers_guide_use_rust) in your
+    own programs.
+-   How to [use the generated Swift code](@ref flatbuffers_guide_use_swift) in your
+    own programs.
+-   [Support matrix](@ref flatbuffers_support) for platforms/languages/features.
+-   Some [benchmarks](@ref flatbuffers_benchmarks) showing the advantage of
+    using FlatBuffers.
+-   A [white paper](@ref flatbuffers_white_paper) explaining the "why" of
+    FlatBuffers.
+-   How to use the [schema-less](@ref flexbuffers) version of
+    FlatBuffers.
+-   A description of the [internals](@ref flatbuffers_internals) of FlatBuffers.
+-   A formal [grammar](@ref flatbuffers_grammar) of the schema language.
+
+## Online resources
+
+-   [GitHub repository](http://github.com/google/flatbuffers)
+-   [Landing page](http://google.github.io/flatbuffers)
+-   [FlatBuffers Google Group](https://groups.google.com/forum/#!forum/flatbuffers)
+-   [Discord](https://discord.gg/6qgKs3R) and [Gitter](https://gitter.im/lobster_programming_language/community) chat.
+-   [FlatBuffers Issues Tracker](http://github.com/google/flatbuffers/issues)
+-   Independent implementations & tools:
+    - [FlatCC](https://github.com/dvidelabs/flatcc) Alternative FlatBuffers
+      parser, code generator and runtime all in C.
+-   Videos:
+    - Colt's [DevByte](https://www.youtube.com/watch?v=iQTxMkSJ1dQ).
+    - GDC 2015 [Lightning Talk](https://www.youtube.com/watch?v=olmL1fUnQAQ).
+    - FlatBuffers for [Go](https://www.youtube.com/watch?v=-BPVId_lA5w).
+    - Evolution of FlatBuffers
+      [visualization](https://www.youtube.com/watch?v=a0QE0xS8rKM).
+-   Useful documentation created by others:
+    - [FlatBuffers in Go](https://rwinslow.com/tags/flatbuffers/)
+    - [FlatBuffers in Android](http://frogermcs.github.io/flatbuffers-in-android-introdution/)
+    - [Parsing JSON to FlatBuffers in Java](http://frogermcs.github.io/json-parsing-with-flatbuffers-in-android/)
+    - [FlatBuffers in Unity](http://exiin.com/blog/flatbuffers-for-unity-sample-code/)
+    - [FlexBuffers C#](https://github.com/mzaks/FlexBuffers-CSharp) and
+      [article](https://medium.com/@icex33/flexbuffers-for-unity3d-4d1ab5c53fbe?)
+      on its use.
--- a/docs/source/FlexBuffers.md
+++ b/docs/source/FlexBuffers.md
@@ -163,7 +163,7 @@ map.get("unknown").isNull();  // true
 # Binary encoding

 A description of how FlexBuffers are encoded is in the
-[internals](internals.md) document.
+[internals](@ref flatbuffers_internals) document.


 # Nesting inside a FlatBuffer
--- a/docs/source/GoApi.md
+++ b/docs/source/GoApi.md
@@ -0,0 +1,26 @@
+Go API
+======
+
+\addtogroup flatbuffers_go_api
+
+<!-- Note: The `GoApi_generate.txt` code snippet was generated using `godoc` and
+     customized for use with this markdown file. To regenerate the file, use the
+     `godoc` tool (http://godoc.org) with the files in the `flatbuffers/go`
+     folder.
+
+     You may need to ensure that copies of the files exist in the `src/`
+     subfolder at the path set by the `$GOROOT` environment variable. You can
+     either move the files to `$GOROOT/src/flatbuffers` manually, if `$GOROOT`
+     is already set, otherwise you will need to manually set the `$GOROOT`
+     variable to a path and create `src/flatbuffers` subfolders at that path.
+     Then copy the flatbuffers files into `$GOROOT/src/flatbuffers`. (Some
+     versions of `godoc` include a `-path` flag. This could be used instead, if
+     available).
+
+     Once the files exist at the `$GOROOT/src/flatbuffers` location, you can
+     regenerate this doc using the following command:
+     `godoc flatbuffers > GoApi_generated.txt`.
+
+     After the documentation is generated, you will have to manually remove any
+     non-user facing documentation from this file. -->
+\snippet GoApi_generated.txt Go API
--- a/docs/source/GoApi_generated.txt
+++ b/docs/source/GoApi_generated.txt
@@ -0,0 +1,125 @@
+// This file was generated using `godoc` and customized for use with the
+// API Reference documentation. To recreate this file, use the `godoc` tool
+// (http://godoc.org) with the files in the `flatbuffers/go` folder.
+//
+// Note: You may need to ensure that copies of the files exist in the
+// `src/` subfolder at the path set by the `$GOROOT` environment variable.
+// You can either move the files to `$GOROOT/src/flatbuffers` manually, if
+// `$GOROOT` is already set, otherwise you will need to manually set the
+// `$GOROOT` variable to a path and create `src/flatbuffers` subfolders at that
+// path. Then copy these files into `$GOROOT/src/flatbuffers`. (Some versions of
+// `godoc` include a `-path` flag. This could be used instead, if available).
+//
+// Once the files exist at the `$GOROOT/src/flatbuffers` location, you can
+// regenerate this doc using the following command:
+// `godoc flatbuffers > GoApi_generated.txt`.
+//
+// After the documentation is generated, you will have to manually remove any
+// non-user facing documentation from this file.
+
+/// [Go API]
+PACKAGE DOCUMENTATION
+
+package flatbuffers
+    Package flatbuffers provides facilities to read and write flatbuffers
+    objects.
+
+TYPES
+
+type Builder struct {
+    // `Bytes` gives raw access to the buffer. Most users will want to use
+    // FinishedBytes() instead.
+    Bytes []byte
+}
+    Builder is a state machine for creating FlatBuffer objects. Use a
+    Builder to construct object(s) starting from leaf nodes.
+
+    A Builder constructs byte buffers in a last-first manner for simplicity
+    and performance.
+
+FUNCTIONS
+
+func NewBuilder(initialSize int) *Builder
+    NewBuilder initializes a Builder of size `initial_size`. The internal
+    buffer is grown as needed.
+
+func (b *Builder) CreateByteString(s []byte) UOffsetT
+    CreateByteString writes a byte slice as a string (null-terminated).
+
+func (b *Builder) CreateByteVector(v []byte) UOffsetT
+    CreateByteVector writes a ubyte vector
+
+func (b *Builder) CreateString(s string) UOffsetT
+    CreateString writes a null-terminated string as a vector.
+
+func (b *Builder) EndVector(vectorNumElems int) UOffsetT
+    EndVector writes data necessary to finish vector construction.
+
+func (b *Builder) Finish(rootTable UOffsetT)
+    Finish finalizes a buffer, pointing to the given `rootTable`.
+
+func (b *Builder) FinishedBytes() []byte
+    FinishedBytes returns a pointer to the written data in the byte buffer.
+    Panics if the builder is not in a finished state (which is caused by
+    calling `Finish()`).
+
+func (b *Builder) Head() UOffsetT
+    Head gives the start of useful data in the underlying byte buffer. Note:
+    unlike other functions, this value is interpreted as from the left.
+
+func (b *Builder) PrependBool(x bool)
+    PrependBool prepends a bool to the Builder buffer. Aligns and checks for
+    space.
+
+func (b *Builder) PrependByte(x byte)
+    PrependByte prepends a byte to the Builder buffer. Aligns and checks for
+    space.
+
+func (b *Builder) PrependFloat32(x float32)
+    PrependFloat32 prepends a float32 to the Builder buffer. Aligns and
+    checks for space.
+
+func (b *Builder) PrependFloat64(x float64)
+    PrependFloat64 prepends a float64 to the Builder buffer. Aligns and
+    checks for space.
+
+func (b *Builder) PrependInt16(x int16)
+    PrependInt16 prepends a int16 to the Builder buffer. Aligns and checks
+    for space.
+
+func (b *Builder) PrependInt32(x int32)
+    PrependInt32 prepends a int32 to the Builder buffer. Aligns and checks
+    for space.
+
+func (b *Builder) PrependInt64(x int64)
+    PrependInt64 prepends a int64 to the Builder buffer. Aligns and checks
+    for space.
+
+func (b *Builder) PrependInt8(x int8)
+    PrependInt8 prepends a int8 to the Builder buffer. Aligns and checks for
+    space.
+
+func (b *Builder) PrependUOffsetT(off UOffsetT)
+    PrependUOffsetT prepends an UOffsetT, relative to where it will be
+    written.
+
+func (b *Builder) PrependUint16(x uint16)
+    PrependUint16 prepends a uint16 to the Builder buffer. Aligns and checks
+    for space.
+
+func (b *Builder) PrependUint32(x uint32)
+    PrependUint32 prepends a uint32 to the Builder buffer. Aligns and checks
+    for space.
+
+func (b *Builder) PrependUint64(x uint64)
+    PrependUint64 prepends a uint64 to the Builder buffer. Aligns and checks
+    for space.
+
+func (b *Builder) PrependUint8(x uint8)
+    PrependUint8 prepends a uint8 to the Builder buffer. Aligns and checks
+    for space.
+
+func (b *Builder) Reset()
+    Reset truncates the underlying Builder buffer, facilitating alloc-free
+    reuse of a Builder. It also resets bookkeeping data.
+/// [Go API]
--- a/docs/source/languages/go.md
+++ b/docs/source/languages/go.md
@@ -4,15 +4,15 @@ Use in Go    {#flatbuffers_guide_use_go}
 ## Before you get started

 Before diving into the FlatBuffers usage in Go, it should be noted that
-the [Tutorial](../tutorial.md) page has a complete guide
+the [Tutorial](@ref flatbuffers_guide_tutorial) page has a complete guide
 to general FlatBuffers usage in all of the supported languages (including Go).
 This page is designed to cover the nuances of FlatBuffers usage, specific to
 Go.

-You should also have read the [Building](../building.md)
+You should also have read the [Building](@ref flatbuffers_guide_building)
 documentation to build `flatc` and should be familiar with
-[Using the schema compiler](../flatc.md) and
-[Writing a schema](../schema.md).
+[Using the schema compiler](@ref flatbuffers_guide_using_schema_compiler) and
+[Writing a schema](@ref flatbuffers_guide_writing_schema).

 ## FlatBuffers Go library code location

@@ -34,7 +34,7 @@ be installed.*

 ## Using the FlatBuffers Go library

-*Note: See [Tutorial](../tutorial.md) for a more in-depth
+*Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
 example of how to use FlatBuffers in Go.*

 FlatBuffers supports reading and writing binary FlatBuffers in Go.
--- a/docs/source/Grammar.md
+++ b/docs/source/Grammar.md
@@ -0,0 +1,74 @@
+Grammar of the schema language    {#flatbuffers_grammar}
+==============================
+
+schema = include*
+         ( namespace\_decl | type\_decl | enum\_decl | root\_decl |
+           file_extension_decl | file_identifier_decl |
+           attribute\_decl | rpc\_decl | object )*
+
+include = `include` string\_constant `;`
+
+namespace\_decl = `namespace` ident ( `.` ident )* `;`
+
+attribute\_decl = `attribute` ident | `"` ident `"` `;`
+
+type\_decl = ( `table` | `struct` ) ident metadata `{` field\_decl+ `}`
+
+enum\_decl = ( `enum` ident `:` type | `union` ident )  metadata `{`
+commasep( enumval\_decl ) `}`
+
+root\_decl = `root_type` ident `;`
+
+field\_decl = ident `:` type [ `=` scalar ] metadata `;`
+
+rpc\_decl = `rpc_service` ident `{` rpc\_method+ `}`
+
+rpc\_method = ident `(` ident `)` `:` ident metadata `;`
+
+type = `bool` | `byte` | `ubyte` | `short` | `ushort` | `int` | `uint` |
+`float` | `long` | `ulong` | `double` |
+`int8` | `uint8` | `int16` | `uint16` | `int32` | `uint32`| `int64` | `uint64` |
+`float32` | `float64` |
+`string` | `[` type `]` | ident
+
+enumval\_decl = ident [ `=` integer\_constant ] metadata
+
+metadata = [ `(` commasep( ident [ `:` single\_value ] ) `)` ]
+
+scalar = boolean\_constant | integer\_constant | float\_constant
+
+object = `{` commasep( ident `:` value ) `}`
+
+single\_value = scalar | string\_constant
+
+value = single\_value | object | `[` commasep( value ) `]`
+
+commasep(x) = [ x ( `,` x )\* ]
+
+file_extension_decl = `file_extension` string\_constant `;`
+
+file_identifier_decl = `file_identifier` string\_constant `;`
+
+string\_constant = `\".*?\"`
+
+ident = `[a-zA-Z_][a-zA-Z0-9_]*`
+
+`[:digit:]` = `[0-9]`
+
+`[:xdigit:]` = `[0-9a-fA-F]`
+
+dec\_integer\_constant = `[-+]?[:digit:]+`
+
+hex\_integer\_constant = `[-+]?0[xX][:xdigit:]+`
+
+integer\_constant = dec\_integer\_constant | hex\_integer\_constant
+
+dec\_float\_constant = `[-+]?(([.][:digit:]+)|([:digit:]+[.][:digit:]*)|([:digit:]+))([eE][-+]?[:digit:]+)?`
+
+hex\_float\_constant = `[-+]?0[xX](([.][:xdigit:]+)|([:xdigit:]+[.][:xdigit:]*)|([:xdigit:]+))([pP][-+]?[:digit:]+)`
+
+special\_float\_constant = `[-+]?(nan|inf|infinity)`
+
+float\_constant = dec\_float\_constant | hex\_float\_constant | special\_float\_constant
+
+boolean\_constant = `true` | `false`
--- a/docs/source/intermediate_representation.md
+++ b/docs/source/intermediate_representation.md
--- a/docs/source/Internals.md
+++ b/docs/source/Internals.md
@@ -316,7 +316,7 @@ that may further help clarify the format.

 # FlexBuffers

-The [schema-less](flexbuffers.md) version of FlatBuffers have their
+The [schema-less](@ref flexbuffers) version of FlatBuffers have their
 own encoding, detailed here.

 It shares many properties mentioned above, in that all data is accessed
@@ -464,3 +464,5 @@ So for example, the integer value `13` as root would be:

    uint8_t 13, 4, 1    // Value, type, root byte width.

+
+<br>
--- a/docs/source/languages/javascript.md
+++ b/docs/source/languages/javascript.md
@@ -4,15 +4,15 @@ Use in JavaScript    {#flatbuffers_guide_use_javascript}
 ## Before you get started

 Before diving into the FlatBuffers usage in JavaScript, it should be noted that
-the [Tutorial](../tutorial.md) page has a complete guide to
+the [Tutorial](@ref flatbuffers_guide_tutorial) page has a complete guide to
 general FlatBuffers usage in all of the supported languages
 (including JavaScript). This page is specifically designed to cover the nuances
 of FlatBuffers usage in JavaScript.

-You should also have read the [Building](../building.md)
+You should also have read the [Building](@ref flatbuffers_guide_building)
 documentation to build `flatc` and should be familiar with
-[Using the schema compiler](../flatc.md) and
-[Writing a schema](../schema.md).
+[Using the schema compiler](@ref flatbuffers_guide_using_schema_compiler) and
+[Writing a schema](@ref flatbuffers_guide_writing_schema).

 ## FlatBuffers JavaScript library code location

@@ -25,13 +25,13 @@ folder as the source.

 ## Using the FlatBuffers JavaScript library

-*Note: See [Tutorial](../tutorial.md) for a more in-depth
+*Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
 example of how to use FlatBuffers.*

 Due to the complexity related with large amounts of JS flavors and module types,
 native JS support has been replaced in 2.0 by transpilation from TypeScript.

-Please look at [TypeScript usage](typescript.md) and
+Please look at [TypeScript usage](@ref flatbuffers_guide_use_typescript) and
 transpile your sources to desired JS flavor. The minimal steps to get up and
 running with JS are:

--- a/docs/source/languages/java.md
+++ b/docs/source/languages/java.md
@@ -4,15 +4,15 @@ Use in Java    {#flatbuffers_guide_use_java}
 ## Before you get started

 Before diving into the FlatBuffers usage in Java, it should be noted that
-the [Tutorial](../tutorial.md) page has a complete guide to
+the [Tutorial](@ref flatbuffers_guide_tutorial) page has a complete guide to
 general FlatBuffers usage in all of the supported languages (including Java).
 This page is designed to cover the nuances of FlatBuffers usage,
 specific to Java.

-You should also have read the [Building](../building.md)
+You should also have read the [Building](@ref flatbuffers_guide_building)
 documentation to build `flatc` and should be familiar with
-[Using the schema compiler](../flatc.md) and
-[Writing a schema](../schema.md).
+[Using the schema compiler](@ref flatbuffers_guide_using_schema_compiler) and
+[Writing a schema](@ref flatbuffers_guide_writing_schema).

 ## FlatBuffers Java code location

@@ -38,7 +38,7 @@ is installed.*

 ## Using the FlatBuffers Java library

-*Note: See [Tutorial](../tutorial.md) for a more in-depth
+*Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
 example of how to use FlatBuffers in Java.*

 FlatBuffers supports reading and writing binary FlatBuffers in Java.
--- a/docs/source/languages/kotlin.md
+++ b/docs/source/languages/kotlin.md
@@ -4,15 +4,15 @@ Use in Kotlin    {#flatbuffers_guide_use_kotlin}
 ## Before you get started

 Before diving into the FlatBuffers usage in Kotlin, it should be noted that
-the [Tutorial](../tutorial.md) page has a complete guide to
+the [Tutorial](@ref flatbuffers_guide_tutorial) page has a complete guide to
 general FlatBuffers usage in all of the supported languages (including K).

 This page is designed to cover the nuances of FlatBuffers usage, specific to Kotlin.

-You should also have read the [Building](../building.md)
+You should also have read the [Building](@ref flatbuffers_guide_building)
 documentation to build `flatc` and should be familiar with
-[Using the schema compiler](../flatc.md) and
-[Writing a schema](../schema.md).
+[Using the schema compiler](@ref flatbuffers_guide_using_schema_compiler) and
+[Writing a schema](@ref flatbuffers_guide_writing_schema).

 ## Kotlin and FlatBuffers Java code location

@@ -35,7 +35,7 @@ flatbuffers/blob/master/tests/KotlinTest.sh) shell script.

 ## Using the FlatBuffers Kotlin library

-*Note: See [Tutorial](../tutorial.md) for a more in-depth
+*Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
 example of how to use FlatBuffers in Kotlin.*

 FlatBuffers supports reading and writing binary FlatBuffers in Kotlin.
--- a/docs/source/languages/lobster.md
+++ b/docs/source/languages/lobster.md
@@ -4,15 +4,15 @@ Use in Lobster    {#flatbuffers_guide_use_lobster}
 ## Before you get started

 Before diving into the FlatBuffers usage in Lobster, it should be noted that the
-[Tutorial](../tutorial.md) page has a complete guide to general
+[Tutorial](@ref flatbuffers_guide_tutorial) page has a complete guide to general
 FlatBuffers usage in all of the supported languages (including Lobster). This
 page is designed to cover the nuances of FlatBuffers usage, specific to
 Lobster.

-You should also have read the [Building](../building.md)
+You should also have read the [Building](@ref flatbuffers_guide_building)
 documentation to build `flatc` and should be familiar with
-[Using the schema compiler](../flatc.md) and
-[Writing a schema](../schema.md).
+[Using the schema compiler](@ref flatbuffers_guide_using_schema_compiler) and
+[Writing a schema](@ref flatbuffers_guide_writing_schema).

 ## FlatBuffers Lobster library code location

@@ -34,7 +34,7 @@ platform.

 ## Using the FlatBuffers Lobster library

-*Note: See [Tutorial](../tutorial.md) for a more in-depth
+*Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
 example of how to use FlatBuffers in Lobster.*

 There is support for both reading and writing FlatBuffers in Lobster.
--- a/docs/source/languages/lua.md
+++ b/docs/source/languages/lua.md
@@ -4,15 +4,15 @@ Use in Lua    {#flatbuffers_guide_use_lua}
 ## Before you get started

 Before diving into the FlatBuffers usage in Lua, it should be noted that the
-[Tutorial](../tutorial.md) page has a complete guide to general
+[Tutorial](@ref flatbuffers_guide_tutorial) page has a complete guide to general
 FlatBuffers usage in all of the supported languages (including Lua). This
 page is designed to cover the nuances of FlatBuffers usage, specific to
 Lua.

-You should also have read the [Building](../building.md)
+You should also have read the [Building](@ref flatbuffers_guide_building)
 documentation to build `flatc` and should be familiar with
-[Using the schema compiler](../flatc.md) and
-[Writing a schema](../schema.md).
+[Using the schema compiler](@ref flatbuffers_guide_using_schema_compiler) and
+[Writing a schema](@ref flatbuffers_guide_writing_schema).

 ## FlatBuffers Lua library code location

@@ -34,7 +34,7 @@ blob/master/tests/LuaTest.sh) shell script.

 ## Using the FlatBuffers Lua library

-*Note: See [Tutorial](../tutorial.md) for a more in-depth
+*Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
 example of how to use FlatBuffers in Lua.*

 There is support for both reading and writing FlatBuffers in Lua.
--- a/docs/source/languages/php.md
+++ b/docs/source/languages/php.md
@@ -4,15 +4,15 @@ Use in PHP    {#flatbuffers_guide_use_php}
 ## Before you get started

 Before diving into the FlatBuffers usage in PHP, it should be noted that
-the [Tutorial](../tutorial.md) page has a complete guide to
+the [Tutorial](@ref flatbuffers_guide_tutorial) page has a complete guide to
 general FlatBuffers usage in all of the supported languages
 (including PHP). This page is specifically designed to cover the nuances of
 FlatBuffers usage in PHP.

-You should also have read the [Building](../building.md)
+You should also have read the [Building](@ref flatbuffers_guide_building)
 documentation to build `flatc` and should be familiar with
-[Using the schema compiler](../flatc.md) and
-[Writing a schema](../schema.md).
+[Using the schema compiler](@ref flatbuffers_guide_using_schema_compiler) and
+[Writing a schema](@ref flatbuffers_guide_writing_schema).

 ## FlatBuffers PHP library code location

@@ -33,7 +33,7 @@ You can run the test with `php phpTest.php` from the command line.

 ## Using theFlatBuffers PHP library

-*Note: See [Tutorial](../tutorial.md) for a more in-depth
+*Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
 example of how to use FlatBuffers in PHP.*

 FlatBuffers supports both reading and writing FlatBuffers in PHP.
@@ -48,7 +48,7 @@ function). Then you can read a FlatBuffer binary file, which you
 pass the contents of to the `GetRootAsMonster` function:

 ~~~{.php}
-  // It is recommended that you use PSR autoload when using FlatBuffers in PHP.
+  // It is recommended that your use PSR autoload when using FlatBuffers in PHP.
  // Here is an example:
  function __autoload($class_name) {
    // The last segment of the class name matches the file name.
@@ -69,7 +69,7 @@ pass the contents of to the `GetRootAsMonster` function:
  // Read the contents of the FlatBuffer binary file.
  $filename = "monster.dat";
  $handle = fopen($filename, "rb");
-  $contents = fread($handle, filesize($filename));
+  $contents = $fread($handle, filesize($filename));
  fclose($handle);

  // Pass the contents to `GetRootAsMonster`.
--- a/docs/source/languages/python.md
+++ b/docs/source/languages/python.md
@@ -4,15 +4,15 @@ Use in Python    {#flatbuffers_guide_use_python}
 ## Before you get started

 Before diving into the FlatBuffers usage in Python, it should be noted that the
-[Tutorial](../tutorial.md) page has a complete guide to general
+[Tutorial](@ref flatbuffers_guide_tutorial) page has a complete guide to general
 FlatBuffers usage in all of the supported languages (including Python). This
 page is designed to cover the nuances of FlatBuffers usage, specific to
 Python.

-You should also have read the [Building](../building.md)
+You should also have read the [Building](@ref flatbuffers_guide_building)
 documentation to build `flatc` and should be familiar with
-[Using the schema compiler](../flatc.md) and
-[Writing a schema](../schema.md).
+[Using the schema compiler](@ref flatbuffers_guide_using_schema_compiler) and
+[Writing a schema](@ref flatbuffers_guide_writing_schema).

 ## FlatBuffers Python library code location

@@ -35,7 +35,7 @@ installed.*

 ## Using the FlatBuffers Python library

-*Note: See [Tutorial](../tutorial.md) for a more in-depth
+*Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
 example of how to use FlatBuffers in Python.*

 There is support for both reading and writing FlatBuffers in Python.
--- a/docs/source/README_TO_GENERATE_DOCS.md
+++ b/docs/source/README_TO_GENERATE_DOCS.md
@@ -0,0 +1,32 @@
+## Prerequisites
+
+To generate the docs for FlatBuffers from the source files, you
+will first need to install two programs.
+
+1. You will need to install `doxygen`. See
+   [Download Doxygen](https://doxygen.nl/download.html).
+
+2. You will need to install `doxypypy` to format python comments appropriately.
+   Install it from [here](https://github.com/Feneric/doxypypy).
+
+*Note: You will need both `doxygen` and `doxypypy` to be in your
+[PATH](https://en.wikipedia.org/wiki/PATH_(variable)) environment variable.*
+
+After you have both of those files installed and in your path, you need to
+set up the `py_filter` to invoke `doxypypy` from `doxygen`.
+
+Follow the steps
+[here](https://github.com/Feneric/doxypypy#invoking-doxypypy-from-doxygen).
+
+## Generating Docs
+
+Run the following commands to generate the docs:
+
+`cd flatbuffers/docs/source`
+`doxygen`
+
+The output is placed in `flatbuffers/docs/html`.
+
+*Note: The Go API Reference code must be generated ahead of time. For
+instructions on how to regenerated this file, please read the comments
+in `GoApi.md`.*
--- a/docs/source/languages/rust.md
+++ b/docs/source/languages/rust.md
@@ -4,7 +4,7 @@ Use in Rust    {#flatbuffers_guide_use_rust}
 ## Before you get started

 Before diving into the FlatBuffers usage in Rust, it should be noted that
-the [Tutorial](../tutorial.md) page has a complete guide
+the [Tutorial](@ref flatbuffers_guide_tutorial) page has a complete guide
 to general FlatBuffers usage in all of the supported languages (including Rust).
 This page is designed to cover the nuances of FlatBuffers usage, specific to
 Rust.
@@ -13,8 +13,8 @@ Rust.

 This page assumes you have written a FlatBuffers schema and compiled it
 with the Schema Compiler. If you have not, please see
-[Using the schema compiler](../flatc.md)
-and [Writing a schema](../schema.md).
+[Using the schema compiler](@ref flatbuffers_guide_using_schema_compiler)
+and [Writing a schema](@ref flatbuffers_guide_writing_schema).

 Assuming you wrote a schema, say `mygame.fbs` (though the extension doesn't
 matter), you've generated a Rust file called `mygame_generated.rs` using the
@@ -36,7 +36,7 @@ The test code itself is located in
 [integration_test.rs](https://github.com/google/flatbuffers/blob/master/tests/rust_usage_test/tests/integration_test.rs)

 This test file requires `flatc` to be present. To review how to build the project,
-please read the [Building](../building.md) documentation.
+please read the [Building](@ref flatbuffers_guide_building) documentation.

 To run the tests, execute `RustTest.sh` from the `flatbuffers/tests` directory.
 For example, on [Linux](https://en.wikipedia.org/wiki/Linux), you would simply
@@ -47,7 +47,7 @@ be installed.*

 ## Using the FlatBuffers Rust library

-*Note: See [Tutorial](../tutorial.md) for a more in-depth
+*Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
 example of how to use FlatBuffers in Rust.*

 FlatBuffers supports both reading and writing FlatBuffers in Rust.
@@ -177,34 +177,6 @@ functions require a mutable (aka exclusive) reference which can only be created
 when no other references to the `FlatBufferBuilder` exist, and may not be copied
 within the same thread, let alone to a second thread.

-## Reflection (& Resizing)
-
-There is experimental support for reflection in FlatBuffers, allowing you to
-read and write data even if you don't know the exact format of a buffer, and
-even allows you to change sizes of strings in-place.
-
-The way this works is very elegant; there is actually a FlatBuffer schema that
-describes schemas (\!) which you can find in `reflection/reflection.fbs`.
-The compiler, `flatc`, can write out any schemas it has just parsed as a binary
-FlatBuffer, corresponding to this meta-schema.
-
-Loading in one of these binary schemas at runtime allows you to traverse any
-FlatBuffer data that corresponds to it without knowing the exact format. You
-can query what fields are present, and then read/write them after.
-
-For convenient field manipulation, you can use the crate
-`flatbuffers-reflection` which includes both the generated code from the meta
-schema, as well as a lot of helper functions.
-
-And example of usage, for the time being, can be found in
-`tests/rust_reflection_test/src/lib.rs`. Two sets of APIs are provided:
-
- [Unsafe getters/setters](https://docs.rs/flatbuffers-reflection/latest/flatbuffers_reflection/#functions),
- which you can use when you are processing trusted data (either from a source you know, or has been verified)
-
- 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
-
 ## Useful tools created by others

 * [flatc-rust](https://github.com/frol/flatc-rust) - FlatBuffers compiler
--- a/docs/source/Schemas.md
+++ b/docs/source/Schemas.md
@@ -0,0 +1,685 @@
+Writing a schema    {#flatbuffers_guide_writing_schema}
+================
+
+The syntax of the schema language (aka IDL, [Interface Definition Language][])
+should look quite familiar to users of any of the C family of
+languages, and also to users of other IDLs. Let's look at an example
+first:
+
+    // example IDL file
+
+    namespace MyGame;
+
+    attribute "priority";
+
+    enum Color : byte { Red = 1, Green, Blue }
+
+    union Any { Monster, Weapon, Pickup }
+
+    struct Vec3 {
+      x:float;
+      y:float;
+      z:float;
+    }
+
+    table Monster {
+      pos:Vec3;
+      mana:short = 150;
+      hp:short = 100;
+      name:string;
+      friendly:bool = false (deprecated, priority: 1);
+      inventory:[ubyte];
+      color:Color = Blue;
+      test:Any;
+    }
+
+    root_type Monster;
+
+(`Weapon` & `Pickup` not defined as part of this example).
+
+### Tables
+
+Tables are the main way of defining objects in FlatBuffers, and consist of a
+name (here `Monster`) and a list of fields. Each field has a name, a type, and
+optionally a default value. If the default value is not specified in the schema,
+it will be `0` for scalar types, or `null` for other types. Some languages
+support setting a scalar's default to `null`. This makes the scalar optional.
+
+Fields do not have to appear in the wire representation, and you can choose
+to omit fields when constructing an object. You have the flexibility to add
+fields without fear of bloating your data. This design is also FlatBuffer's
+mechanism for forward and backwards compatibility. Note that:
+
+-   You can add new fields in the schema ONLY at the end of a table
+    definition. Older data will still
+    read correctly, and give you the default value when read. Older code
+    will simply ignore the new field.
+    If you want to have flexibility to use any order for fields in your
+    schema, you can manually assign ids (much like Protocol Buffers),
+    see the `id` attribute below.
+
+-   You cannot delete fields you don't use anymore from the schema,
+    but you can simply
+    stop writing them into your data for almost the same effect.
+    Additionally you can mark them as `deprecated` as in the example
+    above, which will prevent the generation of accessors in the
+    generated C++, as a way to enforce the field not being used any more.
+    (careful: this may break code!).
+
+-   You may change field names and table names, if you're ok with your
+    code breaking until you've renamed them there too.
+
+See "Schema evolution examples" below for more on this
+topic.
+
+### Structs
+
+Similar to a table, only now none of the fields are optional (so no defaults
+either), and fields may not be added or be deprecated. Structs may only contain
+scalars or other structs. Use this for
+simple objects where you are very sure no changes will ever be made
+(as quite clear in the example `Vec3`). Structs use less memory than
+tables and are even faster to access (they are always stored in-line in their
+parent object, and use no virtual table).
+
+### Types
+
+Built-in scalar types are
+
+-   8 bit: `byte` (`int8`), `ubyte` (`uint8`), `bool`
+
+-   16 bit: `short` (`int16`), `ushort` (`uint16`)
+
+-   32 bit: `int` (`int32`), `uint` (`uint32`), `float` (`float32`)
+
+-   64 bit: `long` (`int64`), `ulong` (`uint64`), `double` (`float64`)
+
+The type names in parentheses are alias names such that for example
+`uint8` can be used in place of `ubyte`, and `int32` can be used in
+place of `int` without affecting code generation.
+
+Built-in non-scalar types:
+
+-   Vector of any other type (denoted with `[type]`). Nesting vectors
+    is not supported, instead you can wrap the inner vector in a table.
+
+-   `string`, which may only hold UTF-8 or 7-bit ASCII. For other text encodings
+    or general binary data use vectors (`[byte]` or `[ubyte]`) instead.
+
+-   References to other tables or structs, enums or unions (see
+    below).
+
+You can't change types of fields once they're used, with the exception
+of same-size data where a `reinterpret_cast` would give you a desirable result,
+e.g. you could change a `uint` to an `int` if no values in current data use the
+high bit yet.
+
+### Arrays
+
+Arrays are a convenience short-hand for a fixed-length collection of elements.
+Arrays can be used to replace the following schema:
+
+    struct Vec3 {
+        x:float;
+        y:float;
+        z:float;
+    }
+
+with the following schema:
+
+    struct Vec3 {
+        v:[float:3];
+    }
+
+Both representations are binary equivalent.
+
+Arrays are currently only supported in a `struct`.
+
+### Default, Optional and Required Values
+
+There are three, mutually exclusive, reactions to the non-presence of a table's
+field in the binary data:
+
+1.   Default valued fields will return the default value (as defined in the schema).
+2.   Optional valued fields will return some form of `null` depending on the
+     local language. (In a sense, `null` is the default value).
+3.   Required fields will cause an error. Flatbuffer verifiers would
+     consider the whole buffer invalid. See the `required` tag below.
+
+When writing a schema, values are a sequence of digits. Values may be optionally
+followed by a decimal point (`.`) and more digits, for float constants, or
+optionally prefixed by a `-`. Floats may also be in scientific notation;
+optionally ending with an `e` or `E`, followed by a `+` or `-` and more digits.
+Values can also be the keyword `null`.
+
+Only scalar values can have defaults, non-scalar (string/vector/table) fields
+default to `null` when not present.
+
+You generally do not want to change default values after they're initially
+defined. Fields that have the default value are not actually stored in the
+serialized data (see also Gotchas below). Values explicitly written by code
+generated by the old schema old version, if they happen to be the default, will
+be read as a different value by code generated with the new schema. This is
+slightly less bad when converting an optional scalar into a default valued
+scalar since non-presence would not be overloaded with a previous default value.
+There are situations, however, where this may be desirable, especially if you
+can ensure a simultaneous rebuild of all code.
+
+### Enums
+
+Define a sequence of named constants, each with a given value, or
+increasing by one from the previous one. The default first value
+is `0`. As you can see in the enum declaration, you specify the underlying
+integral type of the enum with `:` (in this case `byte`), which then determines
+the type of any fields declared with this enum type.
+
+Only integer types are allowed, i.e. `byte`, `ubyte`, `short` `ushort`, `int`,
+`uint`, `long` and `ulong`.
+
+Typically, enum values should only ever be added, never removed (there is no
+deprecation for enums). This requires code to handle forwards compatibility
+itself, by handling unknown enum values.
+
+### Unions
+
+Unions share a lot of properties with enums, but instead of new names
+for constants, you use names of tables. You can then declare
+a union field, which can hold a reference to any of those types, and
+additionally a field with the suffix `_type` is generated that holds
+the corresponding enum value, allowing you to know which type to cast
+to at runtime.
+
+It's possible to give an alias name to a type union. This way a type can even be
+used to mean different things depending on the name used:
+
+    table PointPosition { x:uint; y:uint; }
+    table MarkerPosition {}
+    union Position {
+      Start:MarkerPosition,
+      Point:PointPosition,
+      Finish:MarkerPosition
+    }
+
+Unions contain a special `NONE` marker to denote that no value is stored so that
+name cannot be used as an alias.
+
+Unions are a good way to be able to send multiple message types as a FlatBuffer.
+Note that because a union field is really two fields, it must always be
+part of a table, it cannot be the root of a FlatBuffer by itself.
+
+If you have a need to distinguish between different FlatBuffers in a more
+open-ended way, for example for use as files, see the file identification
+feature below.
+
+There is an experimental support only in C++ for a vector of unions (and
+types). In the example IDL file above, use [Any] to add a vector of Any to
+Monster table. There is also experimental support for other types besides
+tables in unions, in particular structs and strings. There's no direct support
+for scalars in unions, but they can be wrapped in a struct at no space cost.
+
+### Namespaces
+
+These will generate the corresponding namespace in C++ for all helper
+code, and packages in Java. You can use `.` to specify nested namespaces /
+packages.
+
+### Includes
+
+You can include other schemas files in your current one, e.g.:
+
+    include "mydefinitions.fbs";
+
+This makes it easier to refer to types defined elsewhere. `include`
+automatically ensures each file is parsed just once, even when referred to
+more than once.
+
+When using the `flatc` compiler to generate code for schema definitions,
+only definitions in the current file will be generated, not those from the
+included files (those you still generate separately).
+
+### Root type
+
+This declares what you consider to be the root table of the serialized
+data. This is particularly important for parsing JSON data, which doesn't
+include object type information.
+
+### File identification and extension
+
+Typically, a FlatBuffer binary buffer is not self-describing, i.e. it
+needs you to know its schema to parse it correctly. But if you
+want to use a FlatBuffer as a file format, it would be convenient
+to be able to have a "magic number" in there, like most file formats
+have, to be able to do a sanity check to see if you're reading the
+kind of file you're expecting.
+
+Now, you can always prefix a FlatBuffer with your own file header,
+but FlatBuffers has a built-in way to add an identifier to a
+FlatBuffer that takes up minimal space, and keeps the buffer
+compatible with buffers that don't have such an identifier.
+
+You can specify in a schema, similar to `root_type`, that you intend
+for this type of FlatBuffer to be used as a file format:
+
+    file_identifier "MYFI";
+
+Identifiers must always be exactly 4 characters long. These 4 characters
+will end up as bytes at offsets 4-7 (inclusive) in the buffer.
+
+For any schema that has such an identifier, `flatc` will automatically
+add the identifier to any binaries it generates (with `-b`),
+and generated calls like `FinishMonsterBuffer` also add the identifier.
+If you have specified an identifier and wish to generate a buffer
+without one, you can always still do so by calling
+`FlatBufferBuilder::Finish` explicitly.
+
+After loading a buffer, you can use a call like
+`MonsterBufferHasIdentifier` to check if the identifier is present.
+
+Note that this is best for open-ended uses such as files. If you simply wanted
+to send one of a set of possible messages over a network for example, you'd
+be better off with a union.
+
+Additionally, by default `flatc` will output binary files as `.bin`.
+This declaration in the schema will change that to whatever you want:
+
+    file_extension "ext";
+
+### RPC interface declarations
+
+You can declare RPC calls in a schema, that define a set of functions
+that take a FlatBuffer as an argument (the request) and return a FlatBuffer
+as the response (both of which must be table types):
+
+    rpc_service MonsterStorage {
+      Store(Monster):StoreResponse;
+      Retrieve(MonsterId):Monster;
+    }
+
+What code this produces and how it is used depends on language and RPC system
+used, there is preliminary support for GRPC through the `--grpc` code generator,
+see `grpc/tests` for an example.
+
+### Comments & documentation
+
+May be written as in most C-based languages. Additionally, a triple
+comment (`///`) on a line by itself signals that a comment is documentation
+for whatever is declared on the line after it
+(table/struct/field/enum/union/element), and the comment is output
+in the corresponding C++ code. Multiple such lines per item are allowed.
+
+### Attributes
+
+Attributes may be attached to a declaration, behind a field/enum value,
+or after the name of a table/struct/enum/union. These may either have
+a value or not. Some attributes like `deprecated` are understood by
+the compiler; user defined ones need to be declared with the attribute
+declaration (like `priority` in the example above), and are
+available to query if you parse the schema at runtime.
+This is useful if you write your own code generators/editors etc., and
+you wish to add additional information specific to your tool (such as a
+help text).
+
+Current understood attributes:
+
+-   `id: n` (on a table field): manually set the field identifier to `n`.
+    If you use this attribute, you must use it on ALL fields of this table,
+    and the numbers must be a contiguous range from 0 onwards.
+    Additionally, since a union type effectively adds two fields, its
+    id must be that of the second field (the first field is the type
+    field and not explicitly declared in the schema).
+    For example, if the last field before the union field had id 6,
+    the union field should have id 8, and the unions type field will
+    implicitly be 7.
+    IDs allow the fields to be placed in any order in the schema.
+    When a new field is added to the schema it must use the next available ID.
+-   `deprecated` (on a field): do not generate accessors for this field
+    anymore, code should stop using this data. Old data may still contain this
+    field, but 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` (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 structures. By specifying this attribute, you make non-
+    presence in an error for both reader and writer. The reading code may access
+    the field directly, without checking for null. If the constructing code does
+    not initialize this field, they will get an assert, and also the verifier
+    will fail on buffers that have missing required fields. Both adding and
+    removing this attribute may be forwards/backwards incompatible as readers
+    will be unable read old or new data, respectively, unless the data happens to
+    always have the field set.
+-   `force_align: size` (on a struct): force the alignment of this struct
+    to be something higher than what it is naturally aligned to. Causes
+    these structs to be aligned to that amount inside a buffer, IF that
+    buffer is allocated with that alignment (which is not necessarily
+    the case for buffers accessed directly inside a `FlatBufferBuilder`).
+    Note: currently not guaranteed to have an effect when used with
+    `--object-api`, since that may allocate objects at alignments less than
+    what you specify with `force_align`.
+-   `force_align: size` (on a vector): force the alignment of this vector to be
+    something different than what the element size would normally dictate.
+    Note: Now only work for generated C++ code.
+-   `bit_flags` (on an unsigned enum): the values of this field indicate bits,
+    meaning that any unsigned value N specified in the schema will end up
+    representing 1<<N, or if you don't specify values at all, you'll get
+    the sequence 1, 2, 4, 8, ...
+-   `nested_flatbuffer: "table_name"` (on a field): this indicates that the field
+    (which must be a vector of ubyte) contains flatbuffer data, for which the
+    root type is given by `table_name`. The generated code will then produce
+    a convenient accessor for the nested FlatBuffer.
+-   `flexbuffer` (on a field): this indicates that the field
+    (which must be a vector of ubyte) contains flexbuffer data. The generated
+    code will then produce a convenient accessor for the FlexBuffer root.
+-   `key` (on a field): this field is meant to be used as a key when sorting
+    a vector of the type of table it sits in. Can be used for in-place
+    binary search.
+-   `hash` (on a field). This is an (un)signed 32/64 bit integer field, whose
+    value during JSON parsing is allowed to be a string, which will then be
+    stored as its hash. The value of attribute is the hashing algorithm to
+    use, one of `fnv1_32` `fnv1_64` `fnv1a_32` `fnv1a_64`.
+-   `original_order` (on a table): since elements in a table do not need
+    to be stored in any particular order, they are often optimized for
+    space by sorting them to size. This attribute stops that from happening.
+    There should generally not be any reason to use this flag.
+-   'native_*'.  Several attributes have been added to support the [C++ object
+    Based API](@ref flatbuffers_cpp_object_based_api).  All such attributes
+    are prefixed with the term "native_".
+
+
+## JSON Parsing
+
+The same parser that parses the schema declarations above is also able
+to parse JSON objects that conform to this schema. So, unlike other JSON
+parsers, this parser is strongly typed, and parses directly into a FlatBuffer
+(see the compiler documentation on how to do this from the command line, or
+the C++ documentation on how to do this at runtime).
+
+Besides needing a schema, there are a few other changes to how it parses
+JSON:
+
+-   It accepts field names with and without quotes, like many JSON parsers
+    already do. It outputs them without quotes as well, though can be made
+    to output them using the `strict_json` flag.
+-   If a field has an enum type, the parser will recognize symbolic enum
+    values (with or without quotes) instead of numbers, e.g.
+    `field: EnumVal`. If a field is of integral type, you can still use
+    symbolic names, but values need to be prefixed with their type and
+    need to be quoted, e.g. `field: "Enum.EnumVal"`. For enums
+    representing flags, you may place multiple inside a string
+    separated by spaces to OR them, e.g.
+    `field: "EnumVal1 EnumVal2"` or `field: "Enum.EnumVal1 Enum.EnumVal2"`.
+-   Similarly, for unions, these need to specified with two fields much like
+    you do when serializing from code. E.g. for a field `foo`, you must
+    add a field `foo_type: FooOne` right before the `foo` field, where
+    `FooOne` would be the table out of the union you want to use.
+-   A field that has the value `null` (e.g. `field: null`) is intended to
+    have the default value for that field (thus has the same effect as if
+    that field wasn't specified at all).
+-   It has some built in conversion functions, so you can write for example
+    `rad(180)` where ever you'd normally write `3.14159`.
+    Currently supports the following functions: `rad`, `deg`, `cos`, `sin`,
+    `tan`, `acos`, `asin`, `atan`.
+
+When parsing JSON, it recognizes the following escape codes in strings:
+
+-   `\n` - linefeed.
+-   `\t` - tab.
+-   `\r` - carriage return.
+-   `\b` - backspace.
+-   `\f` - form feed.
+-   `\"` - double quote.
+-   `\\` - backslash.
+-   `\/` - forward slash.
+-   `\uXXXX` - 16-bit unicode code point, converted to the equivalent UTF-8
+    representation.
+-   `\xXX` - 8-bit binary hexadecimal number XX. This is the only one that is
+     not in the JSON spec (see http://json.org/), but is needed to be able to
+     encode arbitrary binary in strings to text and back without losing
+     information (e.g. the byte 0xFF can't be represented in standard JSON).
+
+It also generates these escape codes back again when generating JSON from a
+binary representation.
+
+When parsing numbers, the parser is more flexible than JSON.
+A format of numeric literals is more close to the C/C++.
+According to the [grammar](@ref flatbuffers_grammar), it accepts the following
+numerical literals:
+
+-   An integer literal can have any number of leading zero `0` digits.
+    Unlike C/C++, the parser ignores a leading zero, not interpreting it as the
+    beginning of the octal number.
+    The numbers `[081, -00094]` are equal to `[81, -94]`  decimal integers.
+-   The parser accepts unsigned and signed hexadecimal integer numbers.
+    For example: `[0x123, +0x45, -0x67]` are equal to `[291, 69, -103]` decimals.
+-   The format of float-point numbers is fully compatible with C/C++ format.
+    If a modern C++ compiler is used the parser accepts hexadecimal and special
+    floating-point literals as well:
+    `[-1.0, 2., .3e0, 3.e4, 0x21.34p-5, -inf, nan]`.
+
+    The following conventions for floating-point numbers are used:
+    - The exponent suffix of hexadecimal floating-point number is mandatory.
+    - Parsed `NaN` converted to unsigned IEEE-754 `quiet-NaN` value.
+
+    Extended floating-point support was tested with:
+    - x64 Windows: `MSVC2015` and higher.
+    - x64 Linux: `LLVM 6.0`, `GCC 4.9` and higher.
+
+    For details, see [Use in C++](@ref flatbuffers_guide_use_cpp) section.
+
+-   For compatibility with a JSON lint tool all numeric literals of scalar
+    fields can be wrapped to quoted string:
+    `"1", "2.0", "0x48A", "0x0C.0Ep-1", "-inf", "true"`.
+
+## Guidelines
+
+### Efficiency
+
+FlatBuffers is all about efficiency, but to realize that efficiency you
+require an efficient schema. There are usually multiple choices on
+how to represent data that have vastly different size characteristics.
+
+It is very common nowadays to represent any kind of data as dictionaries
+(as in e.g. JSON), because of its flexibility and extensibility. While
+it is possible to emulate this in FlatBuffers (as a vector
+of tables with key and value(s)), this is a bad match for a strongly
+typed system like FlatBuffers, leading to relatively large binaries.
+FlatBuffer tables are more flexible than classes/structs in most systems,
+since having a large number of fields only few of which are actually
+used is still efficient. You should thus try to organize your data
+as much as possible such that you can use tables where you might be
+tempted to use a dictionary.
+
+Similarly, strings as values should only be used when they are
+truly open-ended. If you can, always use an enum instead.
+
+FlatBuffers doesn't have inheritance, so the way to represent a set
+of related data structures is a union. Unions do have a cost however,
+so an alternative to a union is to have a single table that has
+all the fields of all the data structures you are trying to
+represent, if they are relatively similar / share many fields.
+Again, this is efficient because non-present fields are cheap.
+
+FlatBuffers supports the full range of integer sizes, so try to pick
+the smallest size needed, rather than defaulting to int/long.
+
+Remember that you can share data (refer to the same string/table
+within a buffer), so factoring out repeating data into its own
+data structure may be worth it.
+
+### Style guide
+
+Identifiers in a schema are meant to translate to many different programming
+languages, so using the style of your "main" language is generally a bad idea.
+
+For this reason, below is a suggested style guide to adhere to, to keep schemas
+consistent for interoperation regardless of the target language.
+
+Where possible, the code generators for specific languages will generate
+identifiers that adhere to the language style, based on the schema identifiers.
+
+- Table, struct, enum and rpc names (types): UpperCamelCase.
+- Table and struct field names: snake_case. This is translated to lowerCamelCase
+  automatically for some languages, e.g. Java.
+- Enum values: UpperCamelCase.
+- namespaces: UpperCamelCase.
+
+Formatting (this is less important, but still worth adhering to):
+
+- Opening brace: on the same line as the start of the declaration.
+- Spacing: Indent by 2 spaces. None around `:` for types, on both sides for `=`.
+
+For an example, see the schema at the top of this file.
+
+## Gotchas
+
+### Schemas and version control
+
+FlatBuffers relies on new field declarations being added at the end, and earlier
+declarations to not be removed, but be marked deprecated when needed. We think
+this is an improvement over the manual number assignment that happens in
+Protocol Buffers (and which is still an option using the `id` attribute
+mentioned above).
+
+One place where this is possibly problematic however is source control. If user
+A adds a field, generates new binary data with this new schema, then tries to
+commit both to source control after user B already committed a new field also,
+and just auto-merges the schema, the binary files are now invalid compared to
+the new schema.
+
+The solution of course is that you should not be generating binary data before
+your schema changes have been committed, ensuring consistency with the rest of
+the world. If this is not practical for you, use explicit field ids, which
+should always generate a merge conflict if two people try to allocate the same
+id.
+
+### Schema evolution examples (tables)
+
+Some examples to clarify what happens as you change a schema:
+
+If we have the following original schema:
+
+    table { a:int; b:int; }
+
+And we extend it:
+
+    table { a:int; b:int; c:int; }
+
+This is ok. Code compiled with the old schema reading data generated with the
+new one will simply ignore the presence of the new field. Code compiled with the
+new schema reading old data will get the default value for `c` (which is 0
+in this case, since it is not specified).
+
+    table { a:int (deprecated); b:int; }
+
+This is also ok. Code compiled with the old schema reading newer data will now
+always get the default value for `a` since it is not present. Code compiled
+with the new schema now cannot read nor write `a` anymore (any existing code
+that tries to do so will result in compile errors), but can still read
+old data (they will ignore the field).
+
+    table { c:int; a:int; b:int; }
+
+This is NOT ok, as this makes the schemas incompatible. Old code reading newer
+data will interpret `c` as if it was `a`, and new code reading old data
+accessing `a` will instead receive `b`.
+
+    table { c:int (id: 2); a:int (id: 0); b:int (id: 1); }
+
+This is ok. If your intent was to order/group fields in a way that makes sense
+semantically, you can do so using explicit id assignment. Now we are compatible
+with the original schema, and the fields can be ordered in any way, as long as
+we keep the sequence of ids.
+
+    table { b:int; }
+
+NOT ok. We can only remove a field by deprecation, regardless of whether we use
+explicit ids or not.
+
+    table { a:uint; b:uint; }
+
+This is MAYBE ok, and only in the case where the type change is the same size,
+like here. If old data never contained any negative numbers, this will be
+safe to do.
+
+    table { a:int = 1; b:int = 2; }
+
+Generally NOT ok. Any older data written that had 0 values were not written to
+the buffer, and rely on the default value to be recreated. These will now have
+those values appear to `1` and `2` instead. There may be cases in which this
+is ok, but care must be taken.
+
+    table { aa:int; bb:int; }
+
+Occasionally ok. You've renamed fields, which will break all code (and JSON
+files!) that use this schema, but as long as the change is obvious, this is not
+incompatible with the actual binary buffers, since those only ever address
+fields by id/offset.
+
+#### Schema evolution examples (unions)
+
+Suppose we have the following schema:
+```
+union Foo { A, B }
+```
+We can add another variant at the end.
+```
+union Foo { A, B, another_a: A }
+```
+and this will be okay. Old code will not recognize `another_a`.
+However if we add `another_a` anywhere but the end, e.g.
+```
+union Foo { A, another_a: A, B }
+```
+this is not okay. When new code writes `another_a`, old code will
+misinterpret it as `B` (and vice versa). However you can explicitly
+set the union's "discriminant" value like so:
+```
+union Foo { A = 1, another_a: A = 3, B = 2 }
+```
+This is okay.
+
+```
+union Foo { original_a: A = 1, another_a: A = 3, B = 2 }
+```
+Renaming fields will break code and any saved human readable representations,
+such as json files, but the binary buffers will be the same.
+
+
+
+
+
+
+<br>
+
+### Testing whether a field is present in a table
+
+Most serialization formats (e.g. JSON or Protocol Buffers) make it very
+explicit in the format whether a field is present in an object or not,
+allowing you to use this as "extra" information.
+
+FlatBuffers will not write fields that are equal to their default value,
+sometimes resulting in significant space savings. However, this also means we
+cannot disambiguate the meaning of non-presence as "written default value" or
+"not written at all". This only applies to scalar fields since only they support
+default values. Unless otherwise specified, their default is 0.
+
+If you care about the presence of scalars, most languages support "optional
+scalars." You can set `null` as the default value in the schema. `null` is a
+value that's outside of all types, so we will always write if `add_field` is
+called. The generated field accessor should use the local language's canonical
+optional type.
+
+Some `FlatBufferBuilder` implementations have an option called `force_defaults`
+that circumvents this "not writing defaults" behavior you can then use
+`IsFieldPresent` to query presence.
+/
+Another option that works in all languages is to wrap a scalar field in a
+struct. This way it will return null if it is not present. This will be slightly
+less ergonomic but structs don't take up any more space than the scalar they
+represent.
+
+   [Interface Definition Language]: https://en.wikipedia.org/wiki/Interface_description_language
+
+## Writing your own code generator.
+
+See [our intermediate representation](@ref intermediate_representation).
--- a/docs/source/Support.md
+++ b/docs/source/Support.md
--- a/docs/source/languages/swift.md
+++ b/docs/source/languages/swift.md
@@ -4,15 +4,15 @@ Use in Swift {#flatbuffers_guide_use_swift}
 ## Before you get started

 Before diving into the FlatBuffers usage in Swift, it should be noted that
-the [Tutorial](../tutorial.md) page has a complete guide
+the [Tutorial](@ref flatbuffers_guide_tutorial) page has a complete guide
 to general FlatBuffers usage in all of the supported languages (including Swift).
 This page is designed to cover the nuances of FlatBuffers usage, specific to
 Swift.

-You should also have read the [Building](../building.md)
+You should also have read the [Building](@ref flatbuffers_guide_building)
 documentation to build `flatc` and should be familiar with
-[Using the schema compiler](../flatc.md) and
-[Writing a schema](../schema.md).
+[Using the schema compiler](@ref flatbuffers_guide_using_schema_compiler) and
+[Writing a schema](@ref flatbuffers_guide_writing_schema).

 ## FlatBuffers Swift library code location

@@ -32,7 +32,7 @@ be installed.*

 ## Using the FlatBuffers Swift library

-*Note: See [Tutorial](../tutorial.md) for a more in-depth
+*Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
 example of how to use FlatBuffers in Swift.*

 FlatBuffers supports reading and writing binary FlatBuffers in Swift.
@@ -57,7 +57,7 @@ a data object from the server, which you can pass into the `GetRootAsMonster` fu
    let url = URL(fileURLWithPath: path, isDirectory: true).appendingPathComponent("monsterdata_test").appendingPathExtension("mon")
    guard let data = try? Data(contentsOf: url) else { return }

-    let monster: Monster = try! getCheckedRoot(byteBuffer: &byteBuffer)
+    let monster = Monster.getRootAsMonster(bb: ByteBuffer(data: data))
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 Now you can access values like this:
--- a/docs/source/Tutorial.md
+++ b/docs/source/Tutorial.md
--- a/docs/source/languages/typescript.md
+++ b/docs/source/languages/typescript.md
@@ -4,15 +4,15 @@ Use in TypeScript    {#flatbuffers_guide_use_typescript}
 ## Before you get started

 Before diving into the FlatBuffers usage in TypeScript, it should be noted that
-the [Tutorial](../tutorial.md) page has a complete guide to
+the [Tutorial](@ref flatbuffers_guide_tutorial) page has a complete guide to
 general FlatBuffers usage in all of the supported languages
 (including TypeScript). This page is specifically designed to cover the nuances
 of FlatBuffers usage in TypeScript.

-You should also have read the [Building](../building.md)
+You should also have read the [Building](@ref flatbuffers_guide_building)
 documentation to build `flatc` and should be familiar with
-[Using the schema compiler](../flatc.md) and
-[Writing a schema](../schema.md).
+[Using the schema compiler](@ref flatbuffers_guide_using_schema_compiler) and
+[Writing a schema](@ref flatbuffers_guide_writing_schema).

 ## FlatBuffers TypeScript library code location

@@ -28,7 +28,7 @@ flatbuffers/blob/master/tests/TypeScriptTest.py) Python3 script.

 ## Using the FlatBuffers TypeScript library

-*Note: See [Tutorial](../tutorial.md) for a more in-depth
+*Note: See [Tutorial](@ref flatbuffers_guide_tutorial) for a more in-depth
 example of how to use FlatBuffers in TypeScript.*

 FlatBuffers supports both reading and writing FlatBuffers in TypeScript.
--- a/docs/source/white_paper.md
+++ b/docs/source/white_paper.md
--- a/docs/source/annotation.md
+++ b/docs/source/annotation.md
@@ -1,149 +0,0 @@
-# Annotating FlatBuffers
-
-This provides a way to annotate flatbuffer binary data, byte-by-byte, with a
-schema. It is useful for development purposes and understanding the details of
-the internal format.
-
-## Annotating
-
-Given a `schema`, as either a plain-text (`.fbs`) or a binary schema (`.bfbs`),
-and `binary` file(s) that were created by the `schema`. You can annotate them
-using:
-
-```sh
-flatc --annotate SCHEMA -- BINARY_FILES...
-```
-
-This will produce a set of annotated files (`.afb` Annotated FlatBuffer)
-corresponding to the input binary files.
-
-### Example
-
-Taken from the [tests/annotated_binary](https://github.com/google/flatbuffers/tree/master/tests/annotated_binary).
-
-```sh
-cd tests/annotated_binary
-../../flatc --annotate annotated_binary.fbs -- annotated_binary.bin
-```
-
-Which will produce a `annotated_binary.afb` file in the current directory.
-
-The `annotated_binary.bin` is the flatbufer binary of the data contained within
-`annotated_binary.json`, which was made by the following command:
-
-```sh
-..\..\flatc -b annotated_binary.fbs annotated_binary.json
-```
-
-## .afb Text Format
-
-Currently there is a built-in text-based format for outputting the annotations.
-A full example is shown here:
-[`annotated_binary.afb`](https://github.com/google/flatbuffers/blob/master/tests/annotated_binary/annotated_binary.afb)
-
-The data is organized as a table with fixed [columns](#columns) grouped into
-Binary [sections](#binary-sections) and [regions](#binary-regions), starting
-from the beginning of the binary (offset `0`).
-
-### Columns
-
-The columns are as follows:
-
-1. The offset from the start of the binary, expressed in hexadecimal format
-   (e.g. `+0x003c`).
-
-    The prefix `+` is added to make searching for the offset (compared to some
-    random value) a bit easier.
-
-2. The raw binary data, expressed in hexadecimal format. 
-   
-    This is in the little endian format the buffer uses internally and what you
-    would see with a normal binary text viewer.
-
-3. The type of the data.
-
-    This may be the type specified in the schema or some internally defined
-    types:
-
-
-    | Internal Type | Purpose                                            |
-    |---------------|----------------------------------------------------|
-    | `VOffset16`   | Virtual table offset, relative to the table offset |
-    | `UOffset32`   | Unsigned offset, relative to the current offset    |
-    | `SOffset32`   | Signed offset, relative to the current offset      |
-
-
-4. The value of the data.
-
-    This is shown in big endian format that is generally written for humans to
-    consume (e.g. `0x0013`). As well as the "casted" value (e.g. `0x0013 `is
-    `19` in decimal) in parentheses.
-
-5. Notes about the particular data.
-
-    This describes what the data is about, either some internal usage, or tied
-    to the schema.
-
-### Binary Sections
-
-The file is broken up into Binary Sections, which are comprised of contiguous
-[binary regions](#binary-regions) that are logically grouped together. For
-example, a binary section may be a single instance of a flatbuffer `Table` or
-its `vtable`. The sections may be labelled with the name of the associated type,
-as defined in the input schema.
-
-An example of a `vtable` Binary Section that is associated with the user-defined
-`AnnotateBinary.Bar` table.
-
-```
-vtable (AnnotatedBinary.Bar):
-  +0x00A0 | 08 00      | uint16_t   | 0x0008 (8)   | size of this vtable
-  +0x00A2 | 13 00      | uint16_t   | 0x0013 (19)  | size of referring table
-  +0x00A4 | 08 00      | VOffset16  | 0x0008 (8)   | offset to field `a` (id: 0)
-  +0x00A6 | 04 00      | VOffset16  | 0x0004 (4)   | offset to field `b` (id: 1)
-```
-
-These are purely annotative, there is no embedded information about these
-regions in the flatbuffer itself.
-
-### Binary Regions
-
-Binary regions are contiguous bytes regions that are grouped together to form 
-some sort of value, e.g. a `scalar` or an array of scalars. A binary region may
-be split up over multiple text lines, if the size of the region is large.
-
-#### Annotation Example
-
-Looking at an example binary region:
-
-```
-vtable (AnnotatedBinary.Bar):
-  +0x00A0 | 08 00      | uint16_t   | 0x0008 (8)   | size of this vtable
-```
-
-The first column (`+0x00A0`) is the offset to this region from the beginning of
-the buffer. 
-
-The second column are the raw bytes (hexadecimal) that make up this region.
-These are expressed in the little-endian format that flatbuffers uses for the
-wire format.
-
-The third column is the type to interpret the bytes as. For the above example,
-the type is `uint16_t` which is a 16-bit unsigned integer type.
-
-The fourth column shows the raw bytes as a compacted, big-endian value. The raw
-bytes are duplicated in this fashion since it is more intuitive to read the data
-in the big-endian format (e.g., `0x0008`). This value is followed by the decimal
-representation of the value (e.g., `(8)`). For strings, the raw string value is
-shown instead. 
-
-The fifth column is a textual comment on what the value is. As much metadata as
-known is provided.
-
-### Offsets
-
-If the type in the 3rd column is of an absolute offset (`SOffet32` or
-`Offset32`), the fourth column also shows an `Loc: +0x025A` value which shows
-where in the binary this region is pointing to. These values are absolute from
-the beginning of the file, their calculation from the raw value in the 4th
-column depends on the context.
--- a/docs/source/assets/flatbuffers_logo.svg
+++ b/docs/source/assets/flatbuffers_logo.svg
@@ -1,318 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   width="48"
-   height="48"
-   viewBox="0 0 12.699999 12.699999"
-   version="1.1"
-   id="svg5"
-   xml:space="preserve"
-   inkscape:version="1.2.1 (9c6d41e410, 2022-07-14)"
-   sodipodi:docname="flatbuffer_logo.svg"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:xlink="http://www.w3.org/1999/xlink"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:svg="http://www.w3.org/2000/svg"><sodipodi:namedview
-     id="namedview7"
-     pagecolor="#ffffff"
-     bordercolor="#000000"
-     borderopacity="0.25"
-     inkscape:showpageshadow="2"
-     inkscape:pageopacity="0.0"
-     inkscape:pagecheckerboard="0"
-     inkscape:deskcolor="#d1d1d1"
-     inkscape:document-units="mm"
-     showgrid="false"
-     inkscape:zoom="16"
-     inkscape:cx="30.03125"
-     inkscape:cy="31.0625"
-     inkscape:window-width="2560"
-     inkscape:window-height="1377"
-     inkscape:window-x="2552"
-     inkscape:window-y="-8"
-     inkscape:window-maximized="1"
-     inkscape:current-layer="layer1" /><defs
-     id="defs2"><linearGradient
-       inkscape:collect="always"
-       id="linearGradient51996"><stop
-         style="stop-color:#ff0c0c;stop-opacity:1;"
-         offset="0"
-         id="stop51992" /><stop
-         style="stop-color:#ffc402;stop-opacity:1;"
-         offset="1"
-         id="stop51994" /></linearGradient><inkscape:path-effect
-       effect="mirror_symmetry"
-       start_point="78.68,115.48"
-       end_point="78.68,120.48705"
-       center_point="78.68,117.98353"
-       id="path-effect36913"
-       is_visible="true"
-       lpeversion="1.2"
-       lpesatellites=""
-       mode="free"
-       discard_orig_path="false"
-       fuse_paths="true"
-       oposite_fuse="true"
-       split_items="false"
-       split_open="false"
-       link_styles="false" /><inkscape:path-effect
-       effect="mirror_symmetry"
-       start_point="78.68,115.48"
-       end_point="78.68,120.48705"
-       center_point="78.68,117.98353"
-       id="path-effect36913-5"
-       is_visible="true"
-       lpeversion="1.2"
-       lpesatellites=""
-       mode="free"
-       discard_orig_path="false"
-       fuse_paths="true"
-       oposite_fuse="true"
-       split_items="false"
-       split_open="false"
-       link_styles="false" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient51998"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.605698"
-       y2="123.67016"
-       gradientUnits="userSpaceOnUse" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient1071"
-       gradientUnits="userSpaceOnUse"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.605698"
-       y2="123.67016" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient1073"
-       gradientUnits="userSpaceOnUse"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.605698"
-       y2="123.67016" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient1075"
-       gradientUnits="userSpaceOnUse"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.579903"
-       y2="124.25231" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient1077"
-       gradientUnits="userSpaceOnUse"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.605698"
-       y2="123.67016" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient1079"
-       gradientUnits="userSpaceOnUse"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.605698"
-       y2="123.67016" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient1081"
-       gradientUnits="userSpaceOnUse"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.605698"
-       y2="123.67016" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient1083"
-       gradientUnits="userSpaceOnUse"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.605698"
-       y2="123.67016" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient1085"
-       gradientUnits="userSpaceOnUse"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.605698"
-       y2="123.67016" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient1087"
-       gradientUnits="userSpaceOnUse"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.605698"
-       y2="123.67016" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient1089"
-       gradientUnits="userSpaceOnUse"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.605698"
-       y2="123.67016" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient1091"
-       gradientUnits="userSpaceOnUse"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.605698"
-       y2="123.67016" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient1093"
-       gradientUnits="userSpaceOnUse"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.605698"
-       y2="123.67016" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient1095"
-       gradientUnits="userSpaceOnUse"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.605698"
-       y2="123.67016" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient1097"
-       gradientUnits="userSpaceOnUse"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.605698"
-       y2="123.67016" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient1099"
-       gradientUnits="userSpaceOnUse"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.605698"
-       y2="123.67016" /><linearGradient
-       inkscape:collect="always"
-       xlink:href="#linearGradient51996"
-       id="linearGradient1101"
-       gradientUnits="userSpaceOnUse"
-       x1="78.572853"
-       y1="121.57343"
-       x2="78.605698"
-       y2="123.67016" /></defs><g
-     inkscape:label="Layer 1"
-     inkscape:groupmode="layer"
-     id="layer1"><path
-       style="fill:#ee2349;fill-opacity:1;stroke-width:0.264583"
-       d="m 78.679688,115.50977 c -0.120712,0.0641 -0.42793,0.23077 -0.582032,0.34961 -0.183353,0.14139 -0.341667,0.2967 -0.496094,0.48632 -0.09316,0.11439 -0.175141,0.29861 -0.208984,0.46485 -0.05593,0.27473 -0.01958,0.56221 0.01953,0.83984 0.0674,0.47849 0.369141,1.40234 0.369141,1.40234 0,0 -0.370215,0.25236 -0.529297,0.40821 -0.08369,0.082 -0.134669,0.16526 -0.179687,0.27344 -0.06269,0.15064 -0.0906,0.32319 -0.09375,0.48632 -0.0016,0.0822 0.01367,0.26563 0.01367,0.26563 -10e-7,0 0.365376,-0.37098 0.609374,-0.45117 0.135542,-0.0445 0.296791,-0.0606 0.427735,-0.004 0.05341,0.0231 0.05909,0.12539 0.117187,0.12891 0.134803,0.008 0.418285,0.003 0.533204,0 0.114918,0.003 0.3984,0.008 0.533203,0 0.05809,-0.004 0.06378,-0.10581 0.117187,-0.12891 0.130944,-0.0567 0.294146,-0.0406 0.429688,0.004 0.243998,0.0802 0.607422,0.45117 0.607422,0.45117 0,0 0.01722,-0.18343 0.01562,-0.26563 -0.0031,-0.16313 -0.03106,-0.33569 -0.09375,-0.48632 -0.04502,-0.10818 -0.09795,-0.19144 -0.18164,-0.27344 -0.159082,-0.15585 -0.529297,-0.40821 -0.529297,-0.40821 0,0 0.303694,-0.92385 0.371094,-1.40234 0.03911,-0.27763 0.07351,-0.56511 0.01758,-0.83984 -0.03384,-0.16624 -0.115825,-0.35046 -0.208985,-0.46485 -0.154426,-0.18962 -0.31274,-0.34493 -0.496093,-0.48632 -0.154102,-0.11884 -0.46132,-0.28549 -0.582031,-0.34961 z"
-       id="path36791-6"
-       sodipodi:nodetypes="csssscssscssscc"
-       class="UnoptimicedTransforms"
-       transform="matrix(-1.5867841,0,0,1.5867841,131.19823,-183.26425)"
-       inkscape:path-effect="#path-effect36913"
-       inkscape:original-d="m 78.629702,115.48256 c 0,0 0.438268,0.22675 0.632602,0.37661 0.183353,0.1414 0.340934,0.29733 0.49536,0.48695 0.09316,0.11439 0.17524,0.29778 0.209083,0.46402 0.05593,0.27473 0.02088,0.56327 -0.01823,0.8409 -0.0674,0.47849 -0.370162,1.40159 -0.370162,1.40159 0,0 0.369865,0.25228 0.528947,0.40813 0.08369,0.082 0.136292,0.16564 0.18131,0.27381 0.06269,0.15064 0.09017,0.32334 0.09332,0.48647 0.0016,0.0822 -0.01413,0.26601 -0.01413,0.26601 0,0 -0.36491,-0.37107 -0.608908,-0.45126 -0.135542,-0.0445 -0.29706,-0.0607 -0.428004,-0.004 -0.05341,0.0231 -0.06025,0.12485 -0.118343,0.12837 -0.171522,0.0104 -0.582695,-0.002 -0.582695,-0.002 z" /><circle
-       style="fill:#ffffff;fill-opacity:1;stroke-width:0.461723"
-       id="path37027"
-       cx="6.346231"
-       cy="2.3943322"
-       r="1.2447678" /><circle
-       style="font-variation-settings:normal;vector-effect:none;fill:#ffc402;fill-opacity:1;stroke-width:0.141574;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
-       id="path37568-5-9-1-3-6-1"
-       cx="6.5362368"
-       cy="12.559268"
-       r="0.11592077" /><g
-       id="g51228"
-       style="fill:url(#linearGradient51998);fill-opacity:1"
-       transform="matrix(1.5867841,0,0,1.5867841,-120.3592,-185.13424)"><circle
-         style="fill:url(#linearGradient1071);fill-opacity:1;stroke-width:0.224809"
-         id="path37568"
-         cx="79.219589"
-         cy="121.77583"
-         r="0.18407404" /><circle
-         style="font-variation-settings:normal;opacity:1;vector-effect:none;fill:url(#linearGradient1073);fill-opacity:1;stroke-width:0.377183;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000;stop-opacity:1"
-         id="path37568-5"
-         cx="79.928802"
-         cy="121.81054"
-         r="0.30883789" /><circle
-         style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient1075);fill-opacity:1;stroke-width:0.518098;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
-         id="path37568-5-9"
-         cx="79.265541"
-         cy="122.34314"
-         r="0.42421949" /><circle
-         style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient1077);fill-opacity:1;stroke-width:0.194865;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
-         id="path37568-5-9-8"
-         cx="78.911224"
-         cy="122.55578"
-         r="0.15955541" /><circle
-         style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient1079);fill-opacity:1;stroke-width:0.317766;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
-         id="path37568-5-9-1"
-         cx="79.634331"
-         cy="122.87711"
-         r="0.26018718" /><circle
-         style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient1081);fill-opacity:1;stroke-width:0.378906;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
-         id="path37568-5-9-1-3"
-         cx="80.265633"
-         cy="123.65545"
-         r="0.31024873" /><circle
-         style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient1083);fill-opacity:1;stroke-width:0.177006;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
-         id="path37568-5-9-1-3-6"
-         cx="79.914619"
-         cy="124.27737"
-         r="0.14493258" /><circle
-         style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient1085);fill-opacity:1;stroke-width:0.0989143;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
-         id="path37568-5-9-1-3-6-6"
-         cx="80.206474"
-         cy="124.00723"
-         r="0.080991074" /><circle
-         style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient1087);fill-opacity:1;stroke-width:0.221224;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
-         id="path37568-5-9-1-3-6-0"
-         cx="79.695312"
-         cy="123.76383"
-         r="0.18113838" /><ellipse
-         style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient1089);fill-opacity:1;stroke-width:0.271828;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
-         id="path37568-5-9-1-3-6-0-6"
-         cx="79.60508"
-         cy="123.37116"
-         rx="0.22375529"
-         ry="0.22139755" /><ellipse
-         style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient1091);fill-opacity:1;stroke-width:0.271828;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
-         id="path37568-5-9-1-3-6-0-6-7"
-         cx="79.846291"
-         cy="123.10796"
-         rx="0.22375529"
-         ry="0.22139755" /><ellipse
-         style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient1093);fill-opacity:1;stroke-width:0.244555;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
-         id="path37568-5-9-1-3-6-0-6-2"
-         cx="79.247681"
-         cy="123.40287"
-         rx="0.19959654"
-         ry="0.20088845" /><circle
-         style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient1095);fill-opacity:1;stroke-width:0.243037;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
-         id="path37568-5-9-1-2"
-         cx="80.333969"
-         cy="122.72621"
-         r="0.19899905" /><circle
-         style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient1097);fill-opacity:1;stroke-width:0.282009;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
-         id="path37568-5-9-1-2-0-9"
-         cx="80.747818"
-         cy="122.34882"
-         r="0.23090924" /><circle
-         style="font-variation-settings:normal;vector-effect:none;fill:url(#linearGradient1099);fill-opacity:1;stroke-width:0.313683;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;-inkscape-stroke:none;stop-color:#000000"
-         id="path37568-5-9-1-2-7"
-         cx="80.58844"
-         cy="122.97715"
-         r="0.25684434" /><circle
-         style="fill:url(#linearGradient1101);fill-opacity:1;stroke-width:0.426803"
-         id="path37568-5-6"
-         cx="80.422928"
-         cy="122.06255"
-         r="0.34946665" /></g></g></svg>
--- a/Show More
+++ b/Show More