diff --git a/.editorconfig b/.editorconfig
index 50d16bc2ce..f8db50e18e 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -5,7 +5,7 @@ insert_final_newline = true
 trim_trailing_whitespace = true
 charset = utf-8
 
-[*.{cpp,c,h,html,py,kt}]
+[*.{cpp,c,h,html,py,kt,cs,qlm}]
 indent_style = tab
 indent_size = 4
 max_line_length = 135
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d476f125a2..4691012156 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -17,141 +17,206 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [windows-latest, ubuntu-latest, macOS-latest]
+        os: [windows-latest, ubuntu-latest, macos-13]
       # don't cancel all jobs just because one of them failed
       fail-fast: false
 
     # Steps represent a sequence of tasks that will be executed as part of the job
     steps:
-    # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+
     - name: Setup Python 3
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: '3.x'
-    - name: Create Build Environment
-      # Some projects don't allow in-source building, so create a separate build directory
-      # We'll use this as our working directory for all subsequent commands
-      run: cmake -E make_directory ${{runner.workspace}}/build
-
-    - name: Configure CMake
-      working-directory: ${{runner.workspace}}/build
-      # Use a bash shell so we can use the same syntax for environment variable
-      # access regardless of the host operating system
-      shell: bash
-      run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DBUILD_BLACKBOX_TESTS=ON -DBUILD_UNIT_TESTS=ON -DBUILD_PYTHON_MODULE=ON -DBUILD_C_API=ON
+
+    - name: Configure
+      run: >
+        cmake -S . -B build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DBUILD_SHARED_LIBS=ON
+        -DZXING_READERS=ON -DZXING_WRITERS=ON
+        -DZXING_BLACKBOX_TESTS=ON -DZXING_UNIT_TESTS=ON -DZXING_PYTHON_MODULE=ON -DZXING_C_API=ON
 
     - name: Build
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      # Execute the build.  You can specify a specific target with "--target <NAME>"
-      run: cmake --build . -j8 --config $BUILD_TYPE
+      run: cmake --build build -j8 --config ${{env.BUILD_TYPE}}
+
+    # - name: Set PATH for Tests
+    #   shell: bash # to make the $GITHUB_PATH update work
+    #   if: runner.os == 'Windows'
+    #   run: |
+    #     echo "${GITHUB_WORKSPACE}/build/core/${BUILD_TYPE}" >> $GITHUB_PATH
+    #     echo "${GITHUB_WORKSPACE}/build/lib/${BUILD_TYPE}" >> $GITHUB_PATH
 
     - name: Test
-      working-directory: ${{runner.workspace}}/build
-      shell: bash
-      # Execute tests defined by the CMake configuration.
-      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
-      run: ctest -V -C $BUILD_TYPE
+      if: runner.os != 'Windows' # need to disable ctest on Windows when build as shared library for now
+      run: ctest --test-dir build -V -C ${{env.BUILD_TYPE}}
+
+    - name: Install
+      run: |
+        cmake -E make_directory install
+        cmake --install build --config ${{env.BUILD_TYPE}} --prefix ${{github.workspace}}/install
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: ${{matrix.os}}-artifacts
+        path: install
+
+  build-experimental:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [windows-latest, ubuntu-latest, macos-13]
 
-  build-ubuntu-sanitize:
-    runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        submodules: true
+
+    - name: Configure
+      run: >
+        cmake -S . -B build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DBUILD_SHARED_LIBS=ON
+        -DZXING_READERS=ON -DZXING_WRITERS=NEW -DZXING_EXPERIMENTAL_API=ON
+        -DZXING_BLACKBOX_TESTS=ON -DZXING_UNIT_TESTS=OFF -DZXING_PYTHON_MODULE=OFF -DZXING_C_API=ON
+
+    - name: Build
+      run: cmake --build build -j8 --config ${{env.BUILD_TYPE}}
+
+    - name: Test
+      if: runner.os != 'Windows' # need to disable ctest on Windows when build as shared library for now
+      run: ctest --test-dir build -V -C ${{env.BUILD_TYPE}}
+
+    - name: Install
+      run: |
+        cmake -E make_directory install
+        cmake --install build --config ${{env.BUILD_TYPE}} --prefix ${{github.workspace}}/install
+
+    - uses: actions/upload-artifact@v4
       with:
-        ref: ${{github.ref}}
-    - name: Create Build Environment
-      run: cmake -E make_directory ${{runner.workspace}}/build
+        name: ${{matrix.os}}-exp-artifacts
+        path: install
+
+  build-ubuntu-sanitize:
+    runs-on: ubuntu-20.04 # see https://github.com/quantumlib/Stim/issues/717#issuecomment-2002623560
+    steps:
+    - uses: actions/checkout@v4
 
     - name: Configure
-      run: cmake -S $GITHUB_WORKSPACE -B ${{runner.workspace}}/build -DCMAKE_BUILD_TYPE=RelWithDebInfo -DBUILD_BLACKBOX_TESTS=ON -DBUILD_UNIT_TESTS=ON -DBUILD_PYTHON_MODULE=OFF -DBUILD_C_API=ON -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_CXX_FLAGS="-march=native -fsanitize=address,undefined -fno-optimize-sibling-calls -fsanitize-address-use-after-scope -fno-omit-frame-pointer"
+      run: >
+        cmake -S . -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo
+        -DZXING_READERS=ON -DZXING_WRITERS=ON
+        -DZXING_BLACKBOX_TESTS=ON -DZXING_UNIT_TESTS=ON -DZXING_PYTHON_MODULE=OFF -DZXING_C_API=OFF
+        -DCMAKE_CXX_COMPILER=clang++
+        -DCMAKE_CXX_FLAGS="-march=native -fsanitize=address,undefined -fno-optimize-sibling-calls -fsanitize-address-use-after-scope -fno-omit-frame-pointer"
+        -DCMAKE_C_COMPILER=clang
+        -DCMAKE_C_FLAGS="-march=native -fsanitize=address,undefined -fno-optimize-sibling-calls -fsanitize-address-use-after-scope -fno-omit-frame-pointer"
 
     - name: Build
-      run: cmake --build ${{runner.workspace}}/build -j8
+      run: cmake --build build -j8
 
     - name: Test
-      working-directory: ${{runner.workspace}}/build
-      run: ctest -V
+      run: ctest -V --test-dir build
 
   build-ios:
-    runs-on: macos-latest
+    runs-on: macos-13
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
-        ref: ${{github.ref}}
+        submodules: true
 
     - name: Build the swift package
-      shell: sh
-      working-directory: ${{runner.workspace}}/${{github.event.repository.name}}
       run: swift build
 
     - name: Build the demo app
-      shell: sh
-      working-directory: ${{runner.workspace}}/${{github.event.repository.name}}/wrappers/ios/demo
+      working-directory: wrappers/ios/demo
       run: xcodebuild build -scheme demo -sdk "iphonesimulator"
 
     - name: Validate the Pod
-      shell: sh
-      working-directory: ${{runner.workspace}}/${{github.event.repository.name}}
       run: pod lib lint --allow-warnings
 
   build-android:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions/setup-java@v3
+    - uses: actions/checkout@v4
+    - uses: actions/setup-java@v4
       with:
         distribution: 'temurin'
         java-version: '17'
 
     - name: Build the lib/app
       working-directory: wrappers/android
-      run: ./gradlew assembleDebug # build only the debug version of the aar (faster build)
+      run: ./gradlew assembleRelease
 
-    - uses: actions/upload-artifact@v3
+    - uses: actions/upload-artifact@v4
       with:
         name: android-artifacts
-        path: "wrappers/android/zxingcpp/build/outputs/aar/zxingcpp-debug.aar"
+        path: "wrappers/android/zxingcpp/build/outputs/aar/zxingcpp-release.aar"
 
-  build-wasm:
+    - name: Publish Library Snapshot
+      if: github.repository == 'zxing-cpp/zxing-cpp' && github.event_name != 'pull_request'
+      working-directory: wrappers/android
+      env:
+        ORG_GRADLE_PROJECT_publishSnapshot: true
+        ORG_GRADLE_PROJECT_signingKey: ${{ secrets.OSSRH_GPG_SECRET_KEY }}
+        ORG_GRADLE_PROJECT_signingPassword: ${{ secrets.OSSRH_GPG_SECRET_KEY_PASSWORD }}
+        ORG_GRADLE_PROJECT_ossrhUsername: ${{ secrets.OSSRH_USERNAME }}
+        ORG_GRADLE_PROJECT_ossrhPassword: ${{ secrets.OSSRH_PASSWORD }}
+      run: ./gradlew publishReleasePublicationToSonatypeRepository
+
+  build-kn:
     runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: wrappers/kn
     steps:
-    - uses: actions/checkout@v3
-    - uses: mymindstorm/setup-emsdk@v12
+    - name: Checkout repository
+      uses: actions/checkout@v4
+      with:
+        submodules: true
 
-    - name: Configure
-      run: emcmake cmake -Swrappers/wasm -Bbuild
+    - name: Checkout toolchain initializer repository
+      uses: actions/checkout@v4
+      with:
+        repository: ISNing/kn-toolchain-initializer
+        path: wrappers/kn/.kn-toolchain-initializer
 
-    - name: Build
-      run: cmake --build build -j4
+    - name: Set up JDK
+      uses: actions/setup-java@v4
+      with:
+        java-version: 17
+        distribution: temurin
 
-#    - name: Test
-#      run: node build/EmGlueTests.js
+    - name: Setup Gradle
+      uses: gradle/actions/setup-gradle@v3
 
-    - uses: actions/upload-artifact@v3
-      with:
-        name: wasm-artifacts
-        path: |
-            build/zxing*
-            build/demo*
+    - name: Validate Gradle Wrapper
+      uses: gradle/wrapper-validation-action@v2
+
+    - name: Initialize Kotlin/Native toolchain
+      working-directory: wrappers/kn/.kn-toolchain-initializer
+      run: ./gradlew build -DkotlinVersion=1.9.22
+
+    - name: Run test for linuxX64 target
+      run: |
+        echo -e "konan.dir=$HOME/.konan/kotlin-native-prebuilt-linux-x86_64-1.9.22" > local.properties
+        ./gradlew linuxX64Test
 
   build-python:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         python-version: ['3.12']
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [ubuntu-latest, macos-13, windows-latest]
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        submodules: true
 
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
 
     - name: Install dependencies
-      working-directory: wrappers/python
       run: |
         python -m pip install --upgrade pip setuptools
         python -m pip install numpy pillow
@@ -163,3 +228,76 @@ jobs:
     - name: Test module
       working-directory: wrappers/python
       run: python -m unittest -v
+
+  build-rust:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-13, windows-latest]
+    defaults:
+      run:
+        working-directory: wrappers/rust
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: true
+
+    - name: Lint
+      run: |
+        cargo fmt --check
+        cargo clippy -- -Dwarnings
+
+    - name: Build
+      run: cargo build --release --verbose --all-features --examples
+
+    - name: Test
+      run: cargo test --release --all-features
+
+    - name: Package
+      # --allow-dirty is required on the windows build (but not the ubuntu build?!)
+      run: cargo package --verbose --allow-dirty --all-features
+
+  build-wasm:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: mymindstorm/setup-emsdk@v14
+
+    - name: Configure
+      run: emcmake cmake -Swrappers/wasm -Bbuild
+
+    - name: Build
+      run: cmake --build build -j4
+
+#    - name: Test
+#      run: node build/EmGlueTests.js
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: wasm-artifacts
+        path: |
+            build/zxing*
+            build/demo*
+
+  build-winrt:
+    runs-on: windows-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Configure
+      shell: cmd # powershell messes up the arguments containing a '.' ?!?
+      run: >
+        cmake -S wrappers/winrt -B build -A ARM64
+        -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=10.0 -DCMAKE_BUILD_TYPE=Release
+        -DBUILD_WINRT_LIB=ON -DZXING_EXAMPLES=OFF -DZXING_BLACKBOX_TESTS=OFF -DZXING_C_API=OFF
+        -DEXTENSION_SDK_OUTPUT=dist/UAP/v0.8.0.0/ExtensionSDKs/ZXingWinRT/1.0.0.0
+
+    - name: Build
+      run: cmake --build build -j8 --config Release
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: winrt-ARM64-artifacts
+        path: build/dist
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 96f35f4209..12934f156b 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -37,11 +37,11 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
+      uses: github/codeql-action/init@v3
       with:
         languages: ${{ matrix.language }}
         # If you wish to specify custom queries, you can do so here or in a config file.
@@ -52,7 +52,7 @@ jobs:
     # 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
+      uses: github/codeql-action/autobuild@v3
 
     # ℹ️ Command-line programs to run using the OS shell.
     # 📚 https://git.io/JvXDl
@@ -66,6 +66,6 @@ jobs:
     #   make release
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
+      uses: github/codeql-action/analyze@v3
       with:
         category: "/language:${{matrix.language}}"
diff --git a/.github/workflows/gh-pages.yml b/.github/workflows/gh-pages.yml
index df51ce0721..acaf23ff26 100644
--- a/.github/workflows/gh-pages.yml
+++ b/.github/workflows/gh-pages.yml
@@ -29,10 +29,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Setup EMSDK
-        uses: mymindstorm/setup-emsdk@v12
+        uses: mymindstorm/setup-emsdk@v14
 
       - name: Configure
         run: emcmake cmake -Swrappers/wasm -Bbuild
@@ -47,10 +47,10 @@ jobs:
           mv build/zxing_* build/*.html pages
  
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v1
+        uses: actions/upload-pages-artifact@v3
         with:
           path: 'pages'
 
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v2
+        uses: actions/deploy-pages@v4
diff --git a/.github/workflows/msvc-analysis.yml b/.github/workflows/msvc-analysis.yml
index 4c9342c845..4659e4efcf 100644
--- a/.github/workflows/msvc-analysis.yml
+++ b/.github/workflows/msvc-analysis.yml
@@ -37,7 +37,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Configure CMake
         run: cmake -B ${{ env.build }} -DCMAKE_BUILD_TYPE=${{ env.config }}
@@ -60,13 +60,13 @@ jobs:
 
       # Upload SARIF file to GitHub Code Scanning Alerts
       - name: Upload SARIF to GitHub
-        uses: github/codeql-action/upload-sarif@v2
+        uses: github/codeql-action/upload-sarif@v3
         with:
           sarif_file: ${{ steps.run-analysis.outputs.sarif }}
 
       # Upload SARIF file as an Artifact to download and view
       # - name: Upload SARIF as an Artifact
-      #   uses: actions/upload-artifact@v3
+      #   uses: actions/upload-artifact@v4
       #   with:
       #     name: sarif-file
       #     path: ${{ steps.run-analysis.outputs.sarif }}
diff --git a/.github/workflows/publish-android.yml b/.github/workflows/publish-android.yml
index eb789c3d26..afb3be26c4 100644
--- a/.github/workflows/publish-android.yml
+++ b/.github/workflows/publish-android.yml
@@ -1,4 +1,4 @@
-name: publish-adroid
+name: publish-android
 
 on:
 #  release:
@@ -14,14 +14,20 @@ jobs:
   publish:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
-    - uses: actions/setup-java@v3
+    - uses: actions/checkout@v4
+    - uses: actions/setup-java@v4
       with:
         distribution: 'temurin'
         java-version: '17'
 #      working-directory: wrappers/android
 #      run: ./gradlew versionDisplay
+
+    - name: Build Library
+      working-directory: wrappers/android
+      run: ./gradlew assembleRelease
+
     - name: Publish Library
+      if: ${{ github.event.inputs.publish == 'y' }}
       working-directory: wrappers/android
       env:
         ORG_GRADLE_PROJECT_signingKey: ${{ secrets.OSSRH_GPG_SECRET_KEY }}
diff --git a/.github/workflows/publish-kn.yml b/.github/workflows/publish-kn.yml
new file mode 100644
index 0000000000..436b32678a
--- /dev/null
+++ b/.github/workflows/publish-kn.yml
@@ -0,0 +1,77 @@
+name: publish-kn
+
+on:
+  workflow_dispatch:
+    inputs:
+      publish:
+        description: 'Publish package (y/n)'
+        default: 'n'
+
+jobs:
+  publish:
+    name: Library Publish
+
+    runs-on: macos-13 # at least macos-13 is required to enable c++20 support
+
+    defaults:
+      run:
+        working-directory: ./wrappers/kn
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - name: Checkout toolchain initializer repository
+        uses: actions/checkout@v4
+        with:
+          repository: ISNing/kn-toolchain-initializer
+          path: wrappers/kn/.kn-toolchain-initializer
+
+      - name: Set up JDK
+        uses: actions/setup-java@v4
+        with:
+          java-version: 17
+          distribution: temurin
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v3
+
+      - name: Validate Gradle Wrapper
+        uses: gradle/wrapper-validation-action@v2
+
+      - name: Initialize Kotlin/Native toolchain
+        working-directory: wrappers/kn/.kn-toolchain-initializer
+        run: ./gradlew build -DkotlinVersion=1.9.22
+
+      - name: Export Toolchain properties
+        run: |
+          echo -e "konan.dir=$HOME/.konan/kotlin-native-prebuilt-macos-x86_64-1.9.22" > local.properties
+
+      - name: Build Library
+        run: |
+          export PATH="$PATH:$(brew --prefix llvm@15)/bin"
+          ./gradlew assemble
+
+      - name: Run All Library Tests
+        run: |
+          export PATH="$PATH:$(brew --prefix llvm@15)/bin"
+          ./gradlew allTests
+
+      - name: Upload Library Test Reports
+        uses: actions/upload-artifact@v4
+        with:
+          name: allTests-reports
+          path: wrappers/kn/build/reports/tests/allTests
+
+      - name: Publish Library
+        if: ${{ github.event.inputs.publish == 'y' }}
+        env:
+          ORG_GRADLE_PROJECT_signingKey: ${{ secrets.OSSRH_GPG_SECRET_KEY }}
+          ORG_GRADLE_PROJECT_signingPassword: ${{ secrets.OSSRH_GPG_SECRET_KEY_PASSWORD }}
+          ORG_GRADLE_PROJECT_ossrhUsername: ${{ secrets.OSSRH_USERNAME }}
+          ORG_GRADLE_PROJECT_ossrhPassword: ${{ secrets.OSSRH_PASSWORD }}
+        run: |
+          export PATH="$PATH:$(brew --prefix llvm@15)/bin"
+          ./gradlew publishAllPublicationsToSonatypeRepository
diff --git a/.github/workflows/publish-python.yml b/.github/workflows/publish-python.yml
index 637e91e557..d00b3f141b 100644
--- a/.github/workflows/publish-python.yml
+++ b/.github/workflows/publish-python.yml
@@ -22,43 +22,55 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [ubuntu-latest, macos-13, windows-latest] # at least macos-13 is required to enable c++20 support
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        submodules: true
 
     - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: '3.12'
 
     - name: Install cibuildwheel
-      run: python3 -m pip install cibuildwheel==2.16.2
+      run: python3 -m pip install cibuildwheel==2.22.0
 
     - name: Build wheels
       run: python3 -m cibuildwheel --output-dir wheelhouse wrappers/python
       env:
-        CIBW_BUILD: cp38-* cp39-* cp310-* cp311-* cp312-*
+        # TODO: setup a "BEFORE" cmake build and link the python module to the prebuild libZXing.a
+        # see https://github.com/YannickJadoul/Parselmouth/blob/523c117aa780184345121f6ff8315670bc7d4d94/.github/workflows/wheels.yml#L120
+        CIBW_BUILD: cp39-* cp310-* cp311-* cp312-* cp313-*
         CIBW_SKIP: "*musllinux*"
+        # the default maylinux2014 image does not contain a c++20 compiler, see https://github.com/pypa/manylinux
+        CIBW_MANYLINUX_X86_64_IMAGE: quay.io/pypa/manylinux_2_28_x86_64
+        # CIBW_ARCHS_MACOS: "x86_64 arm64"
         CIBW_ARCHS_MACOS: universal2
         CIBW_ENVIRONMENT_MACOS: CMAKE_OSX_ARCHITECTURES="arm64;x86_64"
+        # the default macOS target version is 10.9. it might be required to increase that to support c++20 or later features.
+        # MACOSX_DEPLOYMENT_TARGET: "10.15"
+        CIBW_BUILD_VERBOSITY: 1
 
-    - uses: actions/upload-artifact@v3
+    - name: Upload wheels
+      uses: actions/upload-artifact@v4
       with:
+        name: cibw-wheels-${{ matrix.os }}
         path: ./wheelhouse/*.whl
 
   build-sdist:
     name: Build source distribution
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
-        submodules: recursive
+        submodules: true
 
     - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
-        python-version: '3.12'
+        python-version: '3.13'
 
     - name: Install dependencies
       working-directory: wrappers/python
@@ -68,8 +80,10 @@ jobs:
       working-directory: wrappers/python
       run: python3 setup.py sdist
 
-    - uses: actions/upload-artifact@v3
+    - name: Upload sdist
+      uses: actions/upload-artifact@v4
       with:
+        name: cibw-sdist
         path: wrappers/python/dist/*.tar.gz
 
   upload-pypi:
@@ -85,10 +99,14 @@ jobs:
 #    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
     if: github.event_name == 'release' || github.event.inputs.publish == 'y'
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
-          name: artifact
+          pattern: cibw-*
           path: dist
+          merge-multiple: true
+
+      - name: List wheels
+        run: ls dist
 
       - uses: pypa/gh-action-pypi-publish@release/v1
 #        with:
diff --git a/.github/workflows/build-winrt.yml b/.github/workflows/publish-winrt.yml
similarity index 81%
rename from .github/workflows/build-winrt.yml
rename to .github/workflows/publish-winrt.yml
index d4d8832d0e..880ad39a69 100644
--- a/.github/workflows/build-winrt.yml
+++ b/.github/workflows/publish-winrt.yml
@@ -1,4 +1,4 @@
-name: build-winrt
+name: publish-winrt
 on:
   release:
     types: [published]
@@ -17,10 +17,10 @@ jobs:
     runs-on: windows-latest
     strategy:
       matrix:
-        target: [Win32, x64, ARM, ARM64]
+        target: [Win32, x64, ARM64]
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     - name: Create build environment
       shell: cmd
@@ -32,14 +32,14 @@ jobs:
     - name: Configure CMake
       shell: cmd
       working-directory: ${{runner.workspace}}/build
-      run: cmake ${{github.workspace}}/wrappers/winrt -A ${{matrix.target}} -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=10.0 -DCMAKE_BUILD_TYPE=Release -DBUILD_WINRT_LIB=ON -DBUILD_EXAMPLES=OFF -DBUILD_BLACKBOX_TESTS=OFF -DEXTENSION_SDK_OUTPUT=dist/UAP/v0.8.0.0/ExtensionSDKs/ZXingWinRT/1.0.0.0
+      run: cmake ${{github.workspace}}/wrappers/winrt -A ${{matrix.target}} -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=10.0 -DCMAKE_BUILD_TYPE=Release -DBUILD_WINRT_LIB=ON -DZXING_EXAMPLES=OFF -DZXING_BLACKBOX_TESTS=OFF -DEXTENSION_SDK_OUTPUT=dist/UAP/v0.8.0.0/ExtensionSDKs/ZXingWinRT/1.0.0.0
 
     - name: Build
       shell: cmd
       working-directory: ${{runner.workspace}}/build
       run: cmake --build . -j8 --config Release
 
-    - uses: actions/upload-artifact@v3
+    - uses: actions/upload-artifact@v4
       with:
         name: winrt-${{matrix.target}}-artifacts
         path: ${{runner.workspace}}/build/dist
@@ -49,16 +49,13 @@ jobs:
     runs-on: windows-latest
     if: ${{ github.event_name == 'release' || github.event.inputs.publish == 'y' }}
     steps:
-    - uses: actions/download-artifact@v3
+    - uses: actions/download-artifact@v4
       with:
         name: winrt-Win32-artifacts
-    - uses: actions/download-artifact@v3
+    - uses: actions/download-artifact@v4
       with:
         name: winrt-x64-artifacts
-    - uses: actions/download-artifact@v3
-      with:
-        name: winrt-ARM-artifacts
-    - uses: actions/download-artifact@v3
+    - uses: actions/download-artifact@v4
       with:
         name: winrt-ARM64-artifacts
 
@@ -78,7 +75,7 @@ jobs:
       shell: cmd
       run: nuget push huycn.zxingcpp.winrt.nupkg -ApiKey ${{ secrets.NUGET_API_KEY }} -Source https://api.nuget.org/v3/index.json
 
-    - uses: actions/upload-artifact@v3
+    - uses: actions/upload-artifact@v4
       with:
         name: nuget-package
         path: huycn.zxingcpp.winrt.nupkg
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000000..23eb394603
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,4 @@
+[submodule "zint"]
+	path = zint
+	url = https://github.com/zint/zint.git
+	shallow = true
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7c6cc67d41..b48b2d09e2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,16 +1,17 @@
-cmake_minimum_required(VERSION 3.15)
+cmake_minimum_required(VERSION 3.16)
 
 project(ZXing)
 
-option (BUILD_WRITERS "Build with writer support (encoders)" ON)
-option (BUILD_READERS "Build with reader support (decoders)" ON)
-option (BUILD_EXAMPLES "Build the example barcode reader/writer applications" ON)
-option (BUILD_BLACKBOX_TESTS "Build the black box reader/writer tests" OFF)
-option (BUILD_UNIT_TESTS "Build the unit tests (don't enable for production builds)" OFF)
-option (BUILD_PYTHON_MODULE "Build the python module" OFF)
-option (BUILD_C_API "Build the C-API" OFF)
-option (BUILD_EXPERIMENTAL_API "Build with experimental API" OFF)
-set(BUILD_DEPENDENCIES "AUTO" CACHE STRING "Fetch from github or use locally installed (AUTO/GITHUB/LOCAL)")
+option (ZXING_READERS "Build with reader support (decoders)" ON)
+set    (ZXING_WRITERS "ON" CACHE STRING "Build with old and/or new writer (encoder) backend (OFF/ON/OLD/NEW/BOTH)")
+option (ZXING_USE_BUNDLED_ZINT "Use the bundled libzint for barcode creation/writing" ON)
+option (ZXING_C_API "Build the C-API" OFF)
+option (ZXING_EXPERIMENTAL_API "Build with experimental API" OFF)
+option (ZXING_EXAMPLES "Build the example barcode reader/writer applications" ON)
+option (ZXING_BLACKBOX_TESTS "Build the black box reader/writer tests" OFF)
+option (ZXING_UNIT_TESTS "Build the unit tests (don't enable for production builds)" OFF)
+option (ZXING_PYTHON_MODULE "Build the python module" OFF)
+set    (ZXING_DEPENDENCIES "AUTO" CACHE STRING "Fetch from github or use locally installed (AUTO/GITHUB/LOCAL)")
 
 if (WIN32)
     option (BUILD_SHARED_LIBS "Build and link as shared library" OFF)
@@ -20,8 +21,8 @@ endif()
 
 if (MSVC)
     add_definitions (-DUNICODE -D_UNICODE -D_CRT_SECURE_NO_WARNINGS)
-    option (LINK_CPP_STATICALLY "MSVC only, link standard library statically (/MT and /MTd)" OFF)
-    if (LINK_CPP_STATICALLY)
+    option (ZXING_LINK_CPP_STATICALLY "MSVC only, link standard library statically (/MT and /MTd)" OFF)
+    if (LINK_CPP_STATICALLY OR ZXING_LINK_CPP_STATICALLY)
         set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
     endif()
 endif()
@@ -33,35 +34,49 @@ if (NOT CMAKE_BUILD_TYPE)
     set_property (CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
 endif()
 
-if (BUILD_SHARED_LIBS)
-    set (CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+# provide backward compatibility for deprecated BUILD_... options
+if (DEFINED BUILD_READERS)
+    set (ZXING_READERS ${BUILD_READERS})
 endif()
-
-if (NOT CMAKE_CXX_STANDARD)
-    set (CMAKE_CXX_STANDARD 17)
+if (DEFINED BUILD_WRITERS)
+    set (ZXING_WRITERS ${BUILD_WRITERS})
 endif()
-if (NOT CMAKE_CXX_EXTENSIONS)
-    set (CMAKE_CXX_EXTENSIONS OFF)
+if (DEFINED BUILD_EXAMPLES)
+    message (WARNING "zxing-cpp cmake options BUILD_... are deprecated, please switch to ZXING_... variant")
+    set (ZXING_EXAMPLES ${BUILD_EXAMPLES})
+endif()
+if (DEFINED BUILD_PYTHON_MODULE)
+    message (WARNING "zxing-cpp cmake options BUILD_... are deprecated, please switch to ZXING_... variant")
+    set (ZXING_PYTHON_MODULE ${BUILD_PYTHON_MODULE})
+endif()
+if (DEFINED BUILD_DEPENDENCIES)
+    message (WARNING "zxing-cpp cmake options BUILD_... are deprecated, please switch to ZXING_... variant")
+    set (ZXING_DEPENDENCIES ${BUILD_DEPENDENCIES})
 endif()
 
-if (NOT (BUILD_READERS OR BUILD_WRITERS))
-    message(FATAL_ERROR "At least one of BUILD_READERS/BUILD_WRITERS must be enabled.")
+if (NOT (ZXING_READERS OR ZXING_WRITERS))
+    message(FATAL_ERROR "At least one of ZXING_READERS/ZXING_WRITERS must be enabled.")
 endif()
 
-if (BUILD_UNIT_TESTS AND (NOT BUILD_WRITERS OR NOT BUILD_READERS))
-    message("Note: To build with unit tests, the library will be build with READERS and WRITERS.")
-    set (BUILD_WRITERS ON)
-    set (BUILD_READERS ON)
+set(ZXING_WRITERS_LIST OFF ON OLD NEW BOTH)
+set_property(CACHE ZXING_WRITERS PROPERTY STRINGS ${ZXING_WRITERS_LIST})
+if(NOT ZXING_WRITERS IN_LIST ZXING_WRITERS_LIST)
+    message(FATAL_ERROR "ZXING_WRITERS must be one of ${ZXING_WRITERS_LIST}")
 endif()
 
-if (BUILD_EXPERIMENTAL_API)
-    add_definitions (-DZXING_BUILD_EXPERIMENTAL_API)
+set(ZXING_DEPENDENCIES_LIST AUTO GITHUB LOCAL)
+set_property(CACHE ZXING_DEPENDENCIES PROPERTY STRINGS ${ZXING_DEPENDENCIES_LIST})
+if(NOT ZXING_DEPENDENCIES IN_LIST ZXING_DEPENDENCIES_LIST)
+    message(FATAL_ERROR "ZXING_DEPENDENCIES must be one of ${ZXING_DEPENDENCIES_LIST}")
 endif()
 
-set(BUILD_DEPENDENCIES_LIST AUTO GITHUB LOCAL)
-set_property(CACHE BUILD_DEPENDENCIES PROPERTY STRINGS ${BUILD_DEPENDENCIES_LIST})
-if(NOT BUILD_DEPENDENCIES IN_LIST BUILD_DEPENDENCIES_LIST)
-    message(FATAL_ERROR "BUILD_DEPENDENCIES must be one of ${BUILD_DEPENDENCIES_LIST}")
+if (NOT DEFINED CMAKE_CXX_STANDARD)
+    set (CMAKE_CXX_STANDARD 20)
+    # Allow the fallback to earlier versions if the compiler does not support it.
+    set(CMAKE_CXX_STANDARD_REQUIRED OFF)
+endif()
+if (NOT DEFINED CMAKE_CXX_EXTENSIONS)
+    set (CMAKE_CXX_EXTENSIONS OFF)
 endif()
 
 add_subdirectory (core)
@@ -70,18 +85,18 @@ enable_testing()
 
 include(zxing.cmake)
 
-if (BUILD_EXAMPLES)
+if (ZXING_EXAMPLES)
     add_subdirectory (example)
 endif()
-if (BUILD_BLACKBOX_TESTS)
+if (ZXING_BLACKBOX_TESTS)
     add_subdirectory (test/blackbox)
 endif()
-if (BUILD_UNIT_TESTS)
+if (ZXING_UNIT_TESTS)
     add_subdirectory (test/unit)
 endif()
-if (BUILD_PYTHON_MODULE)
+if (ZXING_PYTHON_MODULE)
     add_subdirectory (wrappers/python)
 endif()
-if (BUILD_C_API)
+if (ZXING_C_API)
     add_subdirectory (wrappers/c)
 endif()
diff --git a/Package.swift b/Package.swift
index 27e70a9bc2..5faf571d10 100644
--- a/Package.swift
+++ b/Package.swift
@@ -15,7 +15,11 @@ let package = Package(
         .target(
             name: "ZXingCppCore",
             path: "core/src",
-            publicHeadersPath: "."
+            exclude: ["libzint", "ZXingC.cpp", "ZXingCpp.cpp"],
+            publicHeadersPath: ".",
+            cxxSettings: [
+                .define("ZXING_READERS")
+            ]
         ),
         .target(
             name: "ZXingCpp",
diff --git a/README.md b/README.md
index 1054cb2fae..112324a1da 100644
--- a/README.md
+++ b/README.md
@@ -11,48 +11,50 @@ It was originally ported from the Java [ZXing Library](https://github.com/zxing/
 You can sponsor this library at [GitHub Sponsors](https://github.com/sponsors/axxel).
 
 Named Sponsors:
-* [Liftric GmbH](https://github.com/Liftric)
 * [KURZ Digital Solutions GmbH & Co. KG](https://github.com/kurzdigital)
 * [Useful Sensors Inc](https://github.com/usefulsensors)
-* [Sergio Olivo](https://github.com/sergio-)
+* [EUREKAM](https://eurekam.fr/)
 
 Thanks a lot for your contribution!
 
 ## Features
 
-* Written in pure C++17 (/C++20), no third-party dependencies (for the library itself)
+* Written in pure C++20 (/C++17), no third-party dependencies (for the library itself)
 * Thread safe
 * Wrappers/Bindings for:
   * [Android](wrappers/android/README.md)
   * [C](wrappers/c/README.md)
   * [iOS](wrappers/ios/README.md)
+  * [Kotlin/Native](wrappers/kn/README.md)
+  * [.NET](wrappers/dotnet/README.md)
   * [Python](wrappers/python/README.md)
+  * [Rust](wrappers/rust/README.md)
   * [WebAssembly](wrappers/wasm/README.md)
   * [WinRT](wrappers/winrt/README.md)
   * [Flutter](https://pub.dev/packages/flutter_zxing) (external project)
 
 ## Supported Formats
 
-| Linear product | Linear industrial | Matrix             |
-|----------------|-------------------|--------------------|
-| UPC-A          | Code 39           | QR Code            |
-| UPC-E          | Code 93           | Micro QR Code      |
-| EAN-8          | Code 128          | rMQR Code          |
-| EAN-13         | Codabar           | Aztec              |
-| DataBar        | DataBar Expanded  | DataMatrix         |
-|                | ITF               | PDF417             |
-|                |                   | MaxiCode (partial) |
+| Linear product  | Linear industrial | Matrix             |
+|-----------------|-------------------|--------------------|
+| UPC-A           | Code 39           | QR Code            |
+| UPC-E           | Code 93           | Micro QR Code      |
+| EAN-8           | Code 128          | rMQR Code          |
+| EAN-13          | Codabar           | Aztec              |
+| DataBar         | DataBar Expanded  | DataMatrix         |
+| DataBar Limited | DX Film Edge      | PDF417             |
+|                 | ITF               | MaxiCode (partial) |
 
 [Note:]
  * DataBar used to be called RSS.
- * DataBar, MaxiCode, Micro QR Code and rMQR Code are not supported for writing.
- * Building with C++20 (see [CMakeLists.txt](https://github.com/zxing-cpp/zxing-cpp/blob/d4b0f502775857f257d13efd25fb840ece1bca3e/CMakeLists.txt#L45)) changes the behaviour of the library: it then supports multi-symbol and position independent detection for DataMatrix. This comes at a noticable performace cost. C++20 is enabled by default for the Android, iOS, Python and WASM wrappers.
+ * DataBar, DX Film Edge, MaxiCode, Micro QR Code and rMQR Code are not supported for writing (unless the library is configured `ZXING_WRITERS=NEW` and `ZING_EXPERIMENTAL_API=ON`).
+ * Building with only C++17 (see [CMakeLists.txt](https://github.com/zxing-cpp/zxing-cpp/blob/d4b0f502775857f257d13efd25fb840ece1bca3e/CMakeLists.txt#L45)) changes the behavior of the library: it then lacks support for DataBarLimited and multi-symbol and position independent detection for DataMatrix.
 
 ## Getting Started
 
 ### To read barcodes:
 1. Load your image into memory (3rd-party library required).
-2. Call `ReadBarcodes()` from [`ReadBarcode.h`](core/src/ReadBarcode.h), the simplest API to get a list of `Result` objects.
+2. Call `ReadBarcodes()` from [`ReadBarcode.h`](core/src/ReadBarcode.h), the simplest API to get a list of `Barcode` objects.
 
 A very simple example looks like this:
 ```c++
@@ -67,22 +69,24 @@ int main(int argc, char** argv)
 
     auto image = ZXing::ImageView(data, width, height, ZXing::ImageFormat::Lum);
     auto options = ZXing::ReaderOptions().setFormats(ZXing::BarcodeFormat::Any);
-    auto results = ZXing::ReadBarcodes(image, options);
+    auto barcodes = ZXing::ReadBarcodes(image, options);
 
-    for (const auto& r : results)
-        std::cout << ZXing::ToString(r.format()) << ": " << r.text() << "\n";
+    for (const auto& b : barcodes)
+        std::cout << ZXing::ToString(b.format()) << ": " << b.text() << "\n";
 
     return 0;
 }
 ```
 To see the full capability of the API, have a look at [`ZXingReader.cpp`](example/ZXingReader.cpp).
 
+[Note: At least C++17 is required on the client side to use the API.]
+
 ### To write barcodes:
 1. Create a [`MultiFormatWriter`](core/src/MultiFormatWriter.h) instance with the format you want to generate. Set encoding and margins if needed.
 2. Call `encode()` with text content and the image size. This returns a [`BitMatrix`](core/src/BitMatrix.h) which is a binary image of the barcode where `true` == visual black and `false` == visual white.
 3. Convert the bit matrix to your native image format. See also the `ToMatrix<T>(BitMatrix&)` helper function.
 
-As an example, have a look at [`ZXingWriter.cpp`](example/ZXingWriter.cpp).
+As an example, have a look at [`ZXingWriter.cpp`](example/ZXingWriter.cpp). That file also contains example code showing the new `ZXING_EXPERIMENTAL_API` for writing barcodes.
 
 ## Web Demos
 - [Read barcodes](https://zxing-cpp.github.io/zxing-cpp/demo_reader.html)
@@ -94,12 +98,12 @@ As an example, have a look at [`ZXingWriter.cpp`](example/ZXingWriter.cpp).
 ## Build Instructions
 These are the generic instructions to build the library on Windows/macOS/Linux. For details on how to build the individual wrappers, follow the links above.
 
-1. Make sure [CMake](https://cmake.org) version 3.15 or newer is installed.
-2. Make sure a C++17 compliant compiler is installed (minimum VS 2019 16.8 / gcc 7 / clang 5).
-3. See the cmake `BUILD_...` options to enable the testing code, python wrapper, etc.
+1. Make sure [CMake](https://cmake.org) version 3.16 or newer is installed. The python module requires 3.18 or higher.
+2. Make sure a sufficiently C++20 compliant compiler is installed (minimum VS 2019 16.10? / gcc 11 / clang 12?).
+3. See the cmake `ZXING_...` options to enable the testing code, python wrapper, etc.
 
 ```
-git clone https://github.com/zxing-cpp/zxing-cpp.git --single-branch --depth 1
+git clone https://github.com/zxing-cpp/zxing-cpp.git --recursive --single-branch --depth 1
 cmake -S zxing-cpp -B zxing-cpp.release -DCMAKE_BUILD_TYPE=Release
 cmake --build zxing-cpp.release -j8 --config Release
 ```
diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index e870fb9c66..fb19617bb8 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -1,146 +1,200 @@
-cmake_minimum_required(VERSION 3.15)
+cmake_minimum_required(VERSION 3.16)
 
-project (ZXing VERSION "2.2.1")
+project (ZXing VERSION "2.3.0")
 set (ZXING_SONAME 3) # see https://github.com/zxing-cpp/zxing-cpp/issues/333
 
-include(../zxing.cmake)
 if (BUILD_SHARED_LIBS)
     set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 endif()
 
-if (NOT DEFINED BUILD_WRITERS)
-    set (BUILD_WRITERS OFF)
+if (DEFINED BUILD_READERS)
+    set (ZXING_READERS ${BUILD_READERS})
+    message (WARNING "zxing-cpp cmake options BUILD_... are deprecated, please switch to ZXING_... variant")
+endif()
+if (DEFINED BUILD_WRITERS)
+    set (ZXING_WRITERS ${BUILD_WRITERS})
+    message (WARNING "zxing-cpp cmake options BUILD_... are deprecated, please switch to ZXING_... variant")
+endif()
+
+if (NOT DEFINED ZXING_WRITERS)
+    set (ZXING_WRITERS OFF)
+endif()
+
+if (NOT DEFINED ZXING_READERS)
+    set (ZXING_READERS ON)
 endif()
 
-if (NOT DEFINED BUILD_READERS)
-    set (BUILD_READERS ON)
+set (ZXING_WRITERS_NEW OFF)
+set (ZXING_WRITERS_OLD OFF)
+if (ZXING_WRITERS MATCHES "OLD|ON")
+    set (ZXING_WRITERS ON)
+    set (ZXING_WRITERS_OLD ON)
+elseif (ZXING_WRITERS MATCHES "NEW")
+    set (ZXING_WRITERS ON)
+    set (ZXING_WRITERS_NEW ON)
+elseif (ZXING_WRITERS MATCHES "BOTH")
+    set (ZXING_WRITERS ON)
+    set (ZXING_WRITERS_NEW ON)
+    set (ZXING_WRITERS_OLD ON)
 endif()
 
-set (ZXING_CORE_DEFINES)
+if (BUILD_SHARED_LIBS)
+    set (CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+endif()
+
+set (ZXING_PUBLIC_FLAGS
+    $<$<BOOL:${ZXING_EXPERIMENTAL_API}>:-DZXING_EXPERIMENTAL_API>
+)
 if (WINRT)
-    set (ZXING_CORE_DEFINES ${ZXING_CORE_DEFINES}
+    set (ZXING_PUBLIC_FLAGS ${ZXING_PUBLIC_FLAGS}
         -DWINRT
     )
 endif()
 if (MSVC)
-    set (ZXING_CORE_DEFINES ${ZXING_CORE_DEFINES}
-        /Zc:__cplusplus
+    set (ZXING_PUBLIC_FLAGS ${ZXING_PUBLIC_FLAGS}
+        $<$<CXX_COMPILER_ID:MSVC>:/Zc:__cplusplus>
     )
 endif()
 
-set (ZXING_CORE_LOCAL_DEFINES
-    $<$<BOOL:${BUILD_READERS}>:-DZXING_BUILD_READERS>
-    $<$<BOOL:${BUILD_WRITERS}>:-DZXING_BUILD_WRITERS>
-    $<$<BOOL:${BUILD_UNIT_TESTS}>:-DZXING_BUILD_FOR_TEST>
+set (ZXING_PRIVATE_FLAGS
+    $<$<BOOL:${ZXING_WRITERS_NEW}>:-DZXING_USE_ZINT>
+    $<$<BOOL:${ZXING_UNIT_TESTS}>:-DZXING_BUILD_FOR_TEST>
 )
 if (MSVC)
-    set (ZXING_CORE_LOCAL_DEFINES ${ZXING_CORE_LOCAL_DEFINES}
+    set (ZXING_PRIVATE_FLAGS ${ZXING_PRIVATE_FLAGS}
         -D_SCL_SECURE_NO_WARNINGS
         -D_CRT_SECURE_NO_WARNINGS
         -D_CRT_NONSTDC_NO_WARNINGS
         -DNOMINMAX
+        /utf-8 # see https://github.com/zxing-cpp/zxing-cpp/issues/757
     )
 else()
-    set (ZXING_CORE_LOCAL_DEFINES ${ZXING_CORE_LOCAL_DEFINES}
+    set (ZXING_PRIVATE_FLAGS ${ZXING_PRIVATE_FLAGS}
         -Wall -Wextra -Wno-missing-braces -Werror=undef -Werror=return-type)
 endif()
 
+include (CheckCXXCompilerFlag)
+
+# This is needed for reproducible builds across different build directories.
+# Without this, the usage of the __FILE__ macro leaves the build directory in
+# the binary. When building the Python extension with build isolation enabled
+# this would lead to random paths in the binary.
+set(FILE_PREFIX_ARG "-fmacro-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}/=")
+check_cxx_compiler_flag("${FILE_PREFIX_ARG}" HAS_FILE_PREFIX_ARG)
+if(HAS_FILE_PREFIX_ARG)
+    set(ZXING_PRIVATE_FLAGS ${ZXING_PRIVATE_FLAGS} "${FILE_PREFIX_ARG}")
+endif()
 
 ################# Source files
 
 set (COMMON_FILES
+    src/Barcode.h
+    src/Barcode.cpp
     src/BarcodeFormat.h
     src/BarcodeFormat.cpp
-    src/BitArray.h
-    src/BitArray.cpp
     src/BitHacks.h
     src/BitMatrix.h
     src/BitMatrix.cpp
-    src/BitMatrixCursor.h
     src/BitMatrixIO.h
     src/BitMatrixIO.cpp
     src/ByteArray.h
     src/ByteMatrix.h
     src/CharacterSet.h
     src/CharacterSet.cpp
-    src/ConcentricFinder.h
-    src/ConcentricFinder.cpp
-    src/CustomData.h
+    src/Content.h
+    src/Content.cpp
     src/ECI.h
     src/ECI.cpp
+    src/Error.h
+    src/Error.cpp
     src/Flags.h
-    src/Generator.h
-    src/GenericGF.h
-    src/GenericGF.cpp
-    src/GenericGFPoly.h
-    src/GenericGFPoly.cpp
     src/GTIN.h
     src/GTIN.cpp
-    src/LogMatrix.h
+    src/ImageView.h
     src/Matrix.h
-    src/Pattern.h
     src/Point.h
     src/Quadrilateral.h
     src/Range.h
-    src/RegressionLine.h
-    src/Scope.h
-    src/TextUtfEncoding.h # [[deprecated]]
-    src/TextUtfEncoding.cpp # [[deprecated]]
-    src/TritMatrix.h
+    src/ReaderOptions.h
+    src/ReadBarcode.h
+    src/ReadBarcode.cpp
     src/Utf.h
     src/Utf.cpp
+    src/WriteBarcode.h
+    src/WriteBarcode.cpp
+    src/ZXingCpp.h
+    src/ZXingCpp.cpp
     src/ZXAlgorithms.h
-    src/ZXBigInteger.h
-    src/ZXBigInteger.cpp
     src/ZXConfig.h
-    src/ZXNullable.h
     src/ZXTestSupport.h
+    src/ZXVersion.h # [[deprecated]]
+    $<$<BOOL:${ZXING_C_API}>:src/ZXingC.h>
+    $<$<BOOL:${ZXING_C_API}>:src/ZXingC.cpp>
 )
-if (BUILD_READERS)
+if (ZXING_READERS OR ZXING_WRITERS_OLD)
+    set (COMMON_FILES ${COMMON_FILES}
+        src/BitArray.h
+        src/BitArray.cpp
+        src/Generator.h
+        src/GenericGF.h
+        src/GenericGF.cpp
+        src/GenericGFPoly.h
+        src/GenericGFPoly.cpp
+        src/TextUtfEncoding.h # [[deprecated]]
+        src/TextUtfEncoding.cpp # [[deprecated]]
+        src/Scope.h
+    )
+endif()
+if (ZXING_READERS)
     set (COMMON_FILES ${COMMON_FILES}
         src/BinaryBitmap.h
         src/BinaryBitmap.cpp
+        src/BitMatrixCursor.h
         src/BitSource.h
         src/BitSource.cpp
-        src/Content.h
-        src/Content.cpp
+        src/ConcentricFinder.h
+        src/ConcentricFinder.cpp
         src/DecodeHints.h
-        src/DecodeHints.cpp
+        $<$<BOOL:${BUILD_SHARED_LIBS}>:src/DecodeHints.cpp> # [[deprecated]]
         src/DecoderResult.h
         src/DetectorResult.h
-        src/Error.h
         src/GlobalHistogramBinarizer.h
         src/GlobalHistogramBinarizer.cpp
         src/GridSampler.h
         src/GridSampler.cpp
+        src/LogMatrix.h
         src/HRI.h
         src/HRI.cpp
         src/HybridBinarizer.h
         src/HybridBinarizer.cpp
-        src/ImageView.h
         src/MultiFormatReader.h
         src/MultiFormatReader.cpp
+        src/Pattern.h
         src/PerspectiveTransform.h
         src/PerspectiveTransform.cpp
         src/Reader.h
-        src/ReaderOptions.h
-        src/ReadBarcode.h
-        src/ReadBarcode.cpp
         src/ReedSolomonDecoder.h
         src/ReedSolomonDecoder.cpp
-        src/Result.h
-        src/Result.cpp
+        src/RegressionLine.h
+        src/Result.h # [[deprecated]]
         src/ResultPoint.h
         src/ResultPoint.cpp
         src/StructuredAppend.h
         src/TextDecoder.h
         src/TextDecoder.cpp
         src/ThresholdBinarizer.h
+        src/TritMatrix.h # QRCode
         src/WhiteRectDetector.h
         src/WhiteRectDetector.cpp
     )
 endif()
-if (BUILD_WRITERS)
+
+if (ZXING_WRITERS)
+    set (COMMON_FILES ${COMMON_FILES}
+    )
+endif()
+
+if (ZXING_WRITERS_OLD)
     set (COMMON_FILES ${COMMON_FILES}
         src/ByteMatrix.h
         src/ReedSolomonEncoder.h
@@ -154,44 +208,46 @@ endif()
 
 # define subset of public headers that get distributed with the binaries
 set (PUBLIC_HEADERS
+    src/Barcode.h
     src/BarcodeFormat.h
     src/BitHacks.h
     src/ByteArray.h
     src/CharacterSet.h
+    src/Content.h
+    src/Error.h
     src/Flags.h
     src/GTIN.h
+    src/ImageView.h
+    src/Point.h
+    src/Quadrilateral.h
+    src/ReadBarcode.h
+    src/ReaderOptions.h
+    src/StructuredAppend.h
     src/TextUtfEncoding.h # [[deprecated]]
+    src/ZXingCpp.h
     src/ZXAlgorithms.h
-    src/ZXConfig.h
+    src/ZXVersion.h # [[deprecated]]
+    $<$<BOOL:${ZXING_C_API}>:${CMAKE_CURRENT_SOURCE_DIR}/src/ZXingC.h>
+    $<$<BOOL:${ZXING_EXPERIMENTAL_API}>:${CMAKE_CURRENT_SOURCE_DIR}/src/WriteBarcode.h>
 )
-if (BUILD_READERS)
+if (ZXING_READERS)
     set (PUBLIC_HEADERS ${PUBLIC_HEADERS}
-        src/Content.h
-        src/DecodeHints.h
-        src/Error.h
-        src/ImageView.h
-        src/Point.h
-        src/Quadrilateral.h
-        src/ReadBarcode.h
-        src/ReaderOptions.h
-        src/Result.h
-        src/StructuredAppend.h
+        src/DecodeHints.h # [[deprecated]]
+        src/Result.h # [[deprecated]]
     )
 endif()
-if (BUILD_WRITERS)
+if (ZXING_WRITERS_OLD)
     set (PUBLIC_HEADERS ${PUBLIC_HEADERS}
         src/BitMatrix.h
         src/BitMatrixIO.h
+        src/Range.h
         src/Matrix.h
         src/MultiFormatWriter.h
-        src/Range.h
     )
 endif()
 # end of public header set
 
-set (AZTEC_FILES
-)
-if (BUILD_READERS)
+if (ZXING_READERS)
     set (AZTEC_FILES ${AZTEC_FILES}
         src/aztec/AZDecoder.h
         src/aztec/AZDecoder.cpp
@@ -202,7 +258,7 @@ if (BUILD_READERS)
         src/aztec/AZReader.cpp
     )
 endif()
-if (BUILD_WRITERS)
+if (ZXING_WRITERS_OLD)
     set (AZTEC_FILES ${AZTEC_FILES}
         src/aztec/AZEncodingState.h
         src/aztec/AZEncoder.h
@@ -217,13 +273,15 @@ if (BUILD_WRITERS)
 endif()
 
 
-set (DATAMATRIX_FILES
-    src/datamatrix/DMBitLayout.h
-    src/datamatrix/DMBitLayout.cpp
-    src/datamatrix/DMVersion.h
-    src/datamatrix/DMVersion.cpp
-)
-if (BUILD_READERS)
+if (ZXING_READERS OR ZXING_WRITERS_OLD)
+    set (DATAMATRIX_FILES
+        src/datamatrix/DMBitLayout.h
+        src/datamatrix/DMBitLayout.cpp
+        src/datamatrix/DMVersion.h
+        src/datamatrix/DMVersion.cpp
+    )
+endif()
+if (ZXING_READERS)
     set (DATAMATRIX_FILES ${DATAMATRIX_FILES}
         src/datamatrix/DMDataBlock.h
         src/datamatrix/DMDataBlock.cpp
@@ -235,7 +293,7 @@ if (BUILD_READERS)
         src/datamatrix/DMReader.cpp
     )
 endif()
-if (BUILD_WRITERS)
+if (ZXING_WRITERS_OLD)
     set (DATAMATRIX_FILES ${DATAMATRIX_FILES}
         src/datamatrix/DMECEncoder.h
         src/datamatrix/DMECEncoder.cpp
@@ -251,9 +309,7 @@ if (BUILD_WRITERS)
 endif()
 
 
-set (MAXICODE_FILES
-)
-if (BUILD_READERS)
+if (ZXING_READERS)
     set (MAXICODE_FILES ${MAXICODE_FILES}
         src/maxicode/MCBitMatrixParser.h
         src/maxicode/MCBitMatrixParser.cpp
@@ -265,13 +321,15 @@ if (BUILD_READERS)
 endif()
 
 
-set (ONED_FILES
-    src/oned/ODUPCEANCommon.h
-    src/oned/ODUPCEANCommon.cpp
-    src/oned/ODCode128Patterns.h
-    src/oned/ODCode128Patterns.cpp
-)
-if (BUILD_READERS)
+if (ZXING_READERS OR ZXING_WRITERS_OLD)
+    set (ONED_FILES
+        src/oned/ODUPCEANCommon.h
+        src/oned/ODUPCEANCommon.cpp
+        src/oned/ODCode128Patterns.h
+        src/oned/ODCode128Patterns.cpp
+    )
+endif()
+if (ZXING_READERS)
     set (ONED_FILES ${ONED_FILES}
         src/oned/ODCodabarReader.h
         src/oned/ODCodabarReader.cpp
@@ -289,6 +347,10 @@ if (BUILD_READERS)
         src/oned/ODDataBarExpandedBitDecoder.cpp
         src/oned/ODDataBarExpandedReader.h
         src/oned/ODDataBarExpandedReader.cpp
+        src/oned/ODDataBarLimitedReader.h
+        src/oned/ODDataBarLimitedReader.cpp
+        src/oned/ODDXFilmEdgeReader.h
+        src/oned/ODDXFilmEdgeReader.cpp
         src/oned/ODITFReader.h
         src/oned/ODITFReader.cpp
         src/oned/ODMultiUPCEANReader.h
@@ -296,10 +358,9 @@ if (BUILD_READERS)
         src/oned/ODReader.h
         src/oned/ODReader.cpp
         src/oned/ODRowReader.h
-        src/oned/ODRowReader.cpp
     )
 endif()
-if (BUILD_WRITERS)
+if (ZXING_WRITERS_OLD)
     set (ONED_FILES ${ONED_FILES}
         src/oned/ODCodabarWriter.h
         src/oned/ODCodabarWriter.cpp
@@ -325,9 +386,13 @@ if (BUILD_WRITERS)
 endif()
 
 
-set (PDF417_FILES
-)
-if (BUILD_READERS)
+if (ZXING_READERS OR ZXING_WRITERS_OLD)
+    set (PDF417_FILES
+        src/pdf417/ZXBigInteger.h
+        src/pdf417/ZXBigInteger.cpp
+    )
+endif()
+if (ZXING_READERS)
     set (PDF417_FILES ${PDF417_FILES}
         src/pdf417/PDFBarcodeMetadata.h
         src/pdf417/PDFBarcodeValue.h
@@ -354,9 +419,11 @@ if (BUILD_READERS)
         src/pdf417/PDFReader.cpp
         src/pdf417/PDFScanningDecoder.h
         src/pdf417/PDFScanningDecoder.cpp
+        src/pdf417/CustomData.h
+        src/pdf417/ZXNullable.h
     )
 endif()
-if (BUILD_WRITERS)
+if (ZXING_WRITERS_OLD)
     set (PDF417_FILES ${PDF417_FILES}
         src/pdf417/PDFCompaction.h
         src/pdf417/PDFEncoder.h
@@ -369,15 +436,17 @@ if (BUILD_WRITERS)
 endif()
 
 
-set (QRCODE_FILES
-    src/qrcode/QRCodecMode.h
-    src/qrcode/QRCodecMode.cpp
-    src/qrcode/QRErrorCorrectionLevel.h
-    src/qrcode/QRErrorCorrectionLevel.cpp
-    src/qrcode/QRVersion.h
-    src/qrcode/QRVersion.cpp
-)
-if (BUILD_READERS)
+if (ZXING_READERS OR ZXING_WRITERS_OLD)
+    set (QRCODE_FILES
+        src/qrcode/QRCodecMode.h
+        src/qrcode/QRCodecMode.cpp
+        src/qrcode/QRErrorCorrectionLevel.h
+        src/qrcode/QRErrorCorrectionLevel.cpp
+        src/qrcode/QRVersion.h
+        src/qrcode/QRVersion.cpp
+    )
+endif()
+if (ZXING_READERS)
     set (QRCODE_FILES ${QRCODE_FILES}
         src/qrcode/QRBitMatrixParser.h
         src/qrcode/QRBitMatrixParser.cpp
@@ -395,7 +464,7 @@ if (BUILD_READERS)
         src/qrcode/QRReader.cpp
     )
 endif()
-if (BUILD_WRITERS)
+if (ZXING_WRITERS_OLD)
     set (QRCODE_FILES ${QRCODE_FILES}
         src/qrcode/QREncoder.h
         src/qrcode/QREncoder.cpp
@@ -409,18 +478,6 @@ if (BUILD_WRITERS)
     )
 endif()
 
-set (LIBZUECI_FILES
-    src/libzueci/zueci.c
-    src/libzueci/zueci.h
-)
-
-if (NOT BUILD_READERS)
-    set_source_files_properties(src/libzueci/zueci.c PROPERTIES COMPILE_FLAGS -DZUECI_EMBED_NO_TO_UTF)
-endif()
-if (NOT BUILD_WRITERS)
-    set_source_files_properties(src/libzueci/zueci.c PROPERTIES COMPILE_FLAGS -DZUECI_EMBED_NO_TO_ECI)
-endif()
-
 source_group (Sources FILES ${COMMON_FILES})
 source_group (Sources\\aztec FILES ${AZTEC_FILES})
 source_group (Sources\\datamatrix FILES ${DATAMATRIX_FILES})
@@ -428,7 +485,6 @@ source_group (Sources\\maxicode FILES ${MAXICODE_FILES})
 source_group (Sources\\oned FILES ${ONED_FILES})
 source_group (Sources\\pdf417 FILES ${PDF417_FILES})
 source_group (Sources\\qrcode FILES ${QRCODE_FILES})
-source_group (Sources\\libzueci FILES ${LIBZUECI_FILES})
 
 set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
 set(THREADS_PREFER_PTHREAD_FLAG TRUE)
@@ -442,7 +498,6 @@ add_library (ZXing
     ${ONED_FILES}
     ${PDF417_FILES}
     ${QRCODE_FILES}
-    ${LIBZUECI_FILES}
 )
 
 target_include_directories (ZXing
@@ -451,25 +506,43 @@ target_include_directories (ZXing
 )
 
 target_compile_options (ZXing
-    PUBLIC ${ZXING_CORE_DEFINES}
-    PRIVATE ${ZXING_CORE_LOCAL_DEFINES}
+    PUBLIC ${ZXING_PUBLIC_FLAGS}
+    PRIVATE ${ZXING_PRIVATE_FLAGS}
 )
 
-include (CheckCXXCompilerFlag)
+target_compile_features(ZXing PUBLIC cxx_std_17)
 
-CHECK_CXX_COMPILER_FLAG ("-ffloat-store" COMPILER_NEEDS_FLOAT_STORE)
-if (COMPILER_NEEDS_FLOAT_STORE)
-    target_compile_options(ZXing PRIVATE
-        -ffloat-store   # same floating point precision in all optimization levels
+target_link_libraries (ZXing PRIVATE Threads::Threads)
+
+if (ZXING_READERS OR ZXING_WRITERS_OLD)
+    set (LIBZUECI_FILES
+        src/libzueci/zueci.c
+        src/libzueci/zueci.h
+    )
+    set_source_files_properties(${LIBZUECI_FILES} PROPERTIES
+        COMPILE_FLAGS "$<$<NOT:$<BOOL:${ZXING_READERS}>>:-DZUECI_EMBED_NO_TO_UTF> $<$<NOT:$<BOOL:${ZXING_WRITERS_OLD}>>:-DZUECI_EMBED_NO_TO_ECI>"
+        SKIP_PRECOMPILE_HEADERS ON
     )
+    target_sources(ZXing PRIVATE ${LIBZUECI_FILES})
+    source_group (Sources\\libzueci FILES ${LIBZUECI_FILES})
 endif()
 
-target_compile_features(ZXing PUBLIC cxx_std_17)
-
-target_link_libraries (ZXing PRIVATE Threads::Threads)
+if (ZXING_WRITERS_NEW)
+    if (ZXING_USE_BUNDLED_ZINT)
+        aux_source_directory(src/libzint LIBZINT_FILES) # manually re-run cmake after adding a new file/symlink
+        set_source_files_properties(${LIBZINT_FILES} PROPERTIES SKIP_PRECOMPILE_HEADERS ON)
+        target_sources(ZXing PRIVATE ${LIBZINT_FILES})
+        source_group (Sources\\libzint FILES ${LIBZINT_FILES})
+        target_include_directories (ZXing PRIVATE "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/libzint>")
+    else()
+        include(../zxing.cmake)
+        zxing_add_package(zint zint https://github.com/zint/zint.git 7a9fdd6cd00cd5bfd0082705d934c13ef84f25e1)
+        target_link_libraries (ZXing PRIVATE zint)
+    endif()
+endif()
 
 add_library(ZXing::ZXing ALIAS ZXing)
-# add the old alias as well, to keep old clients compiling
+# add the old alias as well, to keep old clients compiling [[deprecated]]
 # note: this only affects client code that includes ZXing via sub_directory.
 #       for clients using the exported target, see ZXingConfig.cmake.in
 add_library(ZXing::Core ALIAS ZXing)
@@ -484,6 +557,49 @@ endif()
 
 set_target_properties(ZXing PROPERTIES PUBLIC_HEADER "${PUBLIC_HEADERS}")
 
+set(PRECOMPILE_HEADERS ${PUBLIC_HEADERS})
+list(REMOVE_ITEM PRECOMPILE_HEADERS "$<$<BOOL:${ZXING_C_API}>:${CMAKE_CURRENT_SOURCE_DIR}/src/ZXingC.h>")
+list(REMOVE_ITEM PRECOMPILE_HEADERS src/DecodeHints.h) # [[deprecated]]
+list(REMOVE_ITEM PRECOMPILE_HEADERS src/Result.h)      # [[deprecated]]
+list(REMOVE_ITEM PRECOMPILE_HEADERS src/ZXVersion.h)   # [[deprecated]]
+target_precompile_headers(ZXing PRIVATE ${PRECOMPILE_HEADERS})
+set_source_files_properties(src/DecodeHints.cpp PROPERTIES SKIP_PRECOMPILE_HEADERS ON)
+
+if(CMAKE_BUILD_TYPE MATCHES "Release|RelWithDebInfo")
+    # The following is a list of translation units that fulfill two criteria regarding the use of -Os vs -O3:
+    #  1. their binary size decreases significantly
+    #  2. the runtime of ReaderTest is not (measurably) affected
+    # Compiling them with -Os saves about 40kB (3%) with clang and 190kB (12%) with gcc.
+    check_cxx_compiler_flag("-Os" COMPILER_KNOWS_Os)
+    if(COMPILER_KNOWS_Os)
+    set_source_files_properties(
+        src/Barcode.cpp
+        src/BarcodeFormat.cpp
+        src/BitMatrixIO.cpp
+        src/Error.cpp
+        src/GTIN.cpp
+        src/HRI.cpp
+        src/MultiFormatReader.cpp
+        src/WriteBarcode.cpp
+        src/ZXingC.cpp
+        src/ZXingCpp.cpp
+        src/aztec/AZHighLevelEncoder.cpp
+        src/datamatrix/DMDataBlock.cpp
+        src/datamatrix/DMHighLevelEncoder.cpp
+        src/oned/ODDataBarExpandedBitDecoder.cpp
+        src/pdf417/PDFHighLevelEncoder.cpp
+        src/qrcode/QRBitMatrixParser.cpp
+        src/qrcode/QRDataBlock.cpp
+        src/qrcode/QRDecoder.cpp
+        src/qrcode/QREncoder.cpp
+        src/qrcode/QRMaskUtil.cpp
+        src/qrcode/QRReader.cpp
+        src/qrcode/QRVersion.cpp
+        ${LIBZINT_FILES}
+        PROPERTIES SKIP_PRECOMPILE_HEADERS ON COMPILE_FLAGS -Os)
+    endif()
+endif()
+
 include (GNUInstallDirs)
 
 set(ZX_INSTALL_TARGETS ZXing)
@@ -498,10 +614,10 @@ install (
     PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/ZXing"
 )
 
-configure_file (ZXVersion.h.in ZXVersion.h)
+configure_file (Version.h.in Version.h)
 
 install (
-    FILES "${CMAKE_CURRENT_BINARY_DIR}/ZXVersion.h"
+    FILES "${CMAKE_CURRENT_BINARY_DIR}/Version.h"
     DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/ZXing"
 )
 
@@ -511,7 +627,7 @@ if (MSVC)
         COMPILE_PDB_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
     install(FILES ${CMAKE_CURRENT_BINARY_DIR}/ZXing.pdb
             DESTINATION ${CMAKE_INSTALL_LIBDIR}
-            CONFIGURATIONS Debug RelWithDebInfo 
+            CONFIGURATIONS Debug RelWithDebInfo
             OPTIONAL)
 endif()
 
diff --git a/core/ZXVersion.h.in b/core/Version.h.in
similarity index 66%
rename from core/ZXVersion.h.in
rename to core/Version.h.in
index 41dd401145..09105fca9c 100644
--- a/core/ZXVersion.h.in
+++ b/core/Version.h.in
@@ -6,13 +6,12 @@
 
 #pragma once
 
+#cmakedefine ZXING_READERS
+#cmakedefine ZXING_WRITERS
+
 // Version numbering
 #define ZXING_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
 #define ZXING_VERSION_MINOR @PROJECT_VERSION_MINOR@
 #define ZXING_VERSION_PATCH @PROJECT_VERSION_PATCH@
 
-namespace ZXing {
-
-constexpr const char* ZXING_VERSION_STR = "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@";
-
-}
+#define ZXING_VERSION_STR "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@"
diff --git a/core/src/Result.cpp b/core/src/Barcode.cpp
similarity index 52%
rename from core/src/Result.cpp
rename to core/src/Barcode.cpp
index 427ed84e51..41b2137d36 100644
--- a/core/src/Result.cpp
+++ b/core/src/Barcode.cpp
@@ -4,12 +4,28 @@
 */
 // SPDX-License-Identifier: Apache-2.0
 
-#include "Result.h"
+#include "Barcode.h"
 
 #include "DecoderResult.h"
-#include "TextDecoder.h"
+#include "DetectorResult.h"
 #include "ZXAlgorithms.h"
 
+#ifdef ZXING_EXPERIMENTAL_API
+#include "BitMatrix.h"
+
+#ifdef ZXING_USE_ZINT
+#include <zint.h>
+void zint_symbol_deleter::operator()(zint_symbol* p) const noexcept
+{
+	ZBarcode_Delete(p);
+}
+#else
+struct zint_symbol {};
+void zint_symbol_deleter::operator()(zint_symbol*) const noexcept {}
+#endif
+
+#endif
+
 #include <cmath>
 #include <list>
 #include <map>
@@ -25,15 +41,18 @@ Result::Result(const std::string& text, int y, int xStart, int xStop, BarcodeFor
 	  _readerInit(readerInit)
 {}
 
-Result::Result(DecoderResult&& decodeResult, Position&& position, BarcodeFormat format)
+Result::Result(DecoderResult&& decodeResult, DetectorResult&& detectorResult, BarcodeFormat format)
 	: _content(std::move(decodeResult).content()),
 	  _error(std::move(decodeResult).error()),
-	  _position(std::move(position)),
+	  _position(std::move(detectorResult).position()),
 	  _sai(decodeResult.structuredAppend()),
 	  _format(format),
 	  _lineCount(decodeResult.lineCount()),
 	  _isMirrored(decodeResult.isMirrored()),
 	  _readerInit(decodeResult.readerInit())
+#ifdef ZXING_EXPERIMENTAL_API
+	  , _symbol(std::make_shared<BitMatrix>(std::move(detectorResult).bits()))
+#endif
 {
 	if (decodeResult.versionNumber())
 		snprintf(_version, 4, "%d", decodeResult.versionNumber());
@@ -42,9 +61,13 @@ Result::Result(DecoderResult&& decodeResult, Position&& position, BarcodeFormat
 	// TODO: add type opaque and code specific 'extra data'? (see DecoderResult::extra())
 }
 
+Result::Result(DecoderResult&& decodeResult, Position&& position, BarcodeFormat format)
+	: Result(std::move(decodeResult), {{}, std::move(position)}, format)
+{}
+
 bool Result::isValid() const
 {
-	return format() != BarcodeFormat::None && _content.symbology.code != 0 && !error();
+	return format() != BarcodeFormat::None && !_content.bytes.empty() && !error();
 }
 
 const ByteArray& Result::bytes() const
@@ -121,6 +144,24 @@ Result& Result::setReaderOptions(const ReaderOptions& opts)
 	return *this;
 }
 
+#ifdef ZXING_EXPERIMENTAL_API
+void Result::symbol(BitMatrix&& bits)
+{
+	bits.flipAll();
+	_symbol = std::make_shared<BitMatrix>(std::move(bits));
+}
+
+ImageView Result::symbol() const
+{
+	return {_symbol->row(0).begin(), _symbol->width(), _symbol->height(), ImageFormat::Lum};
+}
+
+void Result::zint(unique_zint_symbol&& z)
+{
+	_zint = std::shared_ptr(std::move(z));
+}
+#endif
+
 bool Result::operator==(const Result& o) const
 {
 	// handle case where both are MatrixCodes first
@@ -144,59 +185,64 @@ bool Result::operator==(const Result& o) const
 	// the following code is only meant for this or other lineCount == 1
 	assert(lineCount() == 1 || o.lineCount() == 1);
 
-	const auto& r1 = lineCount() == 1 ? *this : o;
-	const auto& r2 = lineCount() == 1 ? o : *this;
+	// sl == single line, ml = multi line
+	const auto& sl = lineCount() == 1 ? *this : o;
+	const auto& ml = lineCount() == 1 ? o : *this;
 
-	// if one line is less than half the length of the other away from the
-	// latter, we consider it to belong to the same symbol. additionally, both need to have
-	// roughly the same length (see #367)
-	auto dTop = maxAbsComponent(r2.position().topLeft() - r1.position().topLeft());
-	auto dBot = maxAbsComponent(r2.position().bottomLeft() - r1.position().topLeft());
-	auto length = maxAbsComponent(r1.position().topLeft() - r1.position().bottomRight());
-	auto dLength = std::abs(length - maxAbsComponent(r2.position().topLeft() - r2.position().bottomRight()));
+	// If one line is less than half the length of the other away from the
+	// latter, we consider it to belong to the same symbol.
+	// Additionally, both need to have roughly the same length (see #367).
+	auto dTop = maxAbsComponent(ml.position().topLeft() - sl.position().topLeft());
+	auto dBot = maxAbsComponent(ml.position().bottomLeft() - sl.position().topLeft());
+	auto slLength = maxAbsComponent(sl.position().topLeft() - sl.position().bottomRight());
+	bool isHorizontal = sl.position().topLeft().y == sl.position().bottomRight().y;
+	// Measure the multi line length in the same direction as the single line one (not diagonaly)
+	// to make sure overly tall symbols don't get segmented (see #769).
+	auto mlLength = isHorizontal ? std::abs(ml.position().topLeft().x - ml.position().bottomRight().x)
+								 : std::abs(ml.position().topLeft().y - ml.position().bottomRight().y);
 
-	return std::min(dTop, dBot) < length / 2 && dLength < length / 5;
+	return std::min(dTop, dBot) < slLength / 2 && std::abs(slLength - mlLength) < slLength / 5;
 }
 
-Result MergeStructuredAppendSequence(const Results& results)
+Barcode MergeStructuredAppendSequence(const Barcodes& barcodes)
 {
-	if (results.empty())
+	if (barcodes.empty())
 		return {};
 
-	std::list<Result> allResults(results.begin(), results.end());
-	allResults.sort([](const Result& r1, const Result& r2) { return r1.sequenceIndex() < r2.sequenceIndex(); });
+	std::list<Barcode> allBarcodes(barcodes.begin(), barcodes.end());
+	allBarcodes.sort([](const Barcode& r1, const Barcode& r2) { return r1.sequenceIndex() < r2.sequenceIndex(); });
 
-	Result res = allResults.front();
-	for (auto i = std::next(allResults.begin()); i != allResults.end(); ++i)
+	Barcode res = allBarcodes.front();
+	for (auto i = std::next(allBarcodes.begin()); i != allBarcodes.end(); ++i)
 		res._content.append(i->_content);
 
 	res._position = {};
 	res._sai.index = -1;
 
-	if (allResults.back().sequenceSize() != Size(allResults) ||
-		!std::all_of(allResults.begin(), allResults.end(),
-					 [&](Result& it) { return it.sequenceId() == allResults.front().sequenceId(); }))
+	if (allBarcodes.back().sequenceSize() != Size(allBarcodes) ||
+		!std::all_of(allBarcodes.begin(), allBarcodes.end(),
+					 [&](Barcode& it) { return it.sequenceId() == allBarcodes.front().sequenceId(); }))
 		res._error = FormatError("sequenceIDs not matching during structured append sequence merging");
 
 	return res;
 }
 
-Results MergeStructuredAppendSequences(const Results& results)
+Barcodes MergeStructuredAppendSequences(const Barcodes& barcodes)
 {
-	std::map<std::string, Results> sas;
-	for (auto& res : results) {
-		if (res.isPartOfSequence())
-			sas[res.sequenceId()].push_back(res);
+	std::map<std::string, Barcodes> sas;
+	for (auto& barcode : barcodes) {
+		if (barcode.isPartOfSequence())
+			sas[barcode.sequenceId()].push_back(barcode);
 	}
 
-	Results saiResults;
+	Barcodes res;
 	for (auto& [id, seq] : sas) {
-		auto res = MergeStructuredAppendSequence(seq);
-		if (res.isValid())
-			saiResults.push_back(std::move(res));
+		auto barcode = MergeStructuredAppendSequence(seq);
+		if (barcode.isValid())
+			res.push_back(std::move(barcode));
 	}
 
-	return saiResults;
+	return res;
 }
 
-} // ZXing
+} // namespace ZXing
diff --git a/core/src/Barcode.h b/core/src/Barcode.h
new file mode 100644
index 0000000000..051205ae41
--- /dev/null
+++ b/core/src/Barcode.h
@@ -0,0 +1,215 @@
+/*
+* Copyright 2016 Nu-book Inc.
+* Copyright 2016 ZXing authors
+* Copyright 2020 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "BarcodeFormat.h"
+#include "ByteArray.h"
+#include "Content.h"
+#include "ReaderOptions.h"
+#include "Error.h"
+#include "ImageView.h"
+#include "Quadrilateral.h"
+#include "StructuredAppend.h"
+
+#ifdef ZXING_EXPERIMENTAL_API
+#include <memory>
+namespace ZXing {
+class BitMatrix;
+}
+
+extern "C" struct zint_symbol;
+struct zint_symbol_deleter
+{
+	void operator()(zint_symbol* p) const noexcept;
+};
+using unique_zint_symbol = std::unique_ptr<zint_symbol, zint_symbol_deleter>;
+#endif
+
+#include <string>
+#include <vector>
+
+namespace ZXing {
+
+class DecoderResult;
+class DetectorResult;
+class WriterOptions;
+class Result; // TODO: 3.0 replace deprected symbol name
+
+using Position = QuadrilateralI;
+using Barcode = Result;
+using Barcodes = std::vector<Barcode>;
+using Results = std::vector<Result>;
+
+/**
+ * @brief The Barcode class encapsulates the result of decoding a barcode within an image.
+ */
+class Result
+{
+	void setIsInverted(bool v) { _isInverted = v; }
+	Result& setReaderOptions(const ReaderOptions& opts);
+
+	friend Barcode MergeStructuredAppendSequence(const Barcodes&);
+	friend Barcodes ReadBarcodes(const ImageView&, const ReaderOptions&);
+	friend Image WriteBarcodeToImage(const Barcode&, const WriterOptions&);
+	friend void IncrementLineCount(Barcode&);
+
+public:
+	Result() = default;
+
+	// linear symbology convenience constructor
+	Result(const std::string& text, int y, int xStart, int xStop, BarcodeFormat format, SymbologyIdentifier si, Error error = {},
+		   bool readerInit = false);
+
+	Result(DecoderResult&& decodeResult, DetectorResult&& detectorResult, BarcodeFormat format);
+
+	[[deprecated]] Result(DecoderResult&& decodeResult, Position&& position, BarcodeFormat format);
+
+	bool isValid() const;
+
+	const Error& error() const { return _error; }
+
+	BarcodeFormat format() const { return _format; }
+
+	/**
+	 * @brief bytes is the raw / standard content without any modifications like character set conversions
+	 */
+	const ByteArray& bytes() const;
+
+	/**
+	 * @brief bytesECI is the raw / standard content following the ECI protocol
+	 */
+	ByteArray bytesECI() const;
+
+	/**
+	 * @brief text returns the bytes() content rendered to unicode/utf8 text accoring to specified TextMode
+	 */
+	std::string text(TextMode mode) const;
+
+	/**
+	 * @brief text returns the bytes() content rendered to unicode/utf8 text accoring to the TextMode set in the ReaderOptions
+	 */
+	std::string text() const;
+
+	/**
+	 * @brief ecLevel returns the error correction level of the symbol (empty string if not applicable)
+	 */
+	std::string ecLevel() const;
+
+	/**
+	 * @brief contentType gives a hint to the type of content found (Text/Binary/GS1/etc.)
+	 */
+	ContentType contentType() const;
+
+	/**
+	 * @brief hasECI specifies wheter or not an ECI tag was found
+	 */
+	bool hasECI() const;
+
+	const Position& position() const { return _position; }
+	void setPosition(Position pos) { _position = pos; }
+
+	/**
+	 * @brief orientation of barcode in degree, see also Position::orientation()
+	 */
+	int orientation() const;
+
+	/**
+	 * @brief isMirrored is the symbol mirrored (currently only supported by QRCode and DataMatrix)
+	 */
+	bool isMirrored() const { return _isMirrored; }
+
+	/**
+	 * @brief isInverted is the symbol inverted / has reveresed reflectance (see ReaderOptions::tryInvert)
+	 */
+	bool isInverted() const { return _isInverted; }
+
+	/**
+	 * @brief symbologyIdentifier Symbology identifier "]cm" where "c" is symbology code character, "m" the modifier.
+	 */
+	std::string symbologyIdentifier() const;
+
+	/**
+	 * @brief sequenceSize number of symbols in a structured append sequence.
+	 *
+	 * If this is not part of a structured append sequence, the returned value is -1.
+	 * If it is a structured append symbol but the total number of symbols is unknown, the
+	 * returned value is 0 (see PDF417 if optional "Segment Count" not given).
+	 */
+	int sequenceSize() const;
+
+	/**
+	 * @brief sequenceIndex the 0-based index of this symbol in a structured append sequence.
+	 */
+	int sequenceIndex() const;
+
+	/**
+	 * @brief sequenceId id to check if a set of symbols belongs to the same structured append sequence.
+	 *
+	 * If the symbology does not support this feature, the returned value is empty (see MaxiCode).
+	 * For QR Code, this is the parity integer converted to a string.
+	 * For PDF417 and DataMatrix, this is the "fileId".
+	 */
+	std::string sequenceId() const;
+
+	bool isLastInSequence() const { return sequenceSize() == sequenceIndex() + 1; }
+	bool isPartOfSequence() const { return sequenceSize() > -1 && sequenceIndex() > -1; }
+
+	/**
+	 * @brief readerInit Set if Reader Initialisation/Programming symbol.
+	 */
+	bool readerInit() const { return _readerInit; }
+
+	/**
+	 * @brief lineCount How many lines have been detected with this code (applies only to linear symbologies)
+	 */
+	int lineCount() const { return _lineCount; }
+
+	/**
+	 * @brief version QRCode / DataMatrix / Aztec version or size.
+	 */
+	std::string version() const;
+
+#ifdef ZXING_EXPERIMENTAL_API
+	void symbol(BitMatrix&& bits);
+	ImageView symbol() const;
+	void zint(unique_zint_symbol&& z);
+	zint_symbol* zint() const { return _zint.get(); }
+#endif
+
+	bool operator==(const Result& o) const;
+
+private:
+	Content _content;
+	Error _error;
+	Position _position;
+	ReaderOptions _readerOpts; // TODO: 3.0 switch order to prevent 4 padding bytes
+	StructuredAppendInfo _sai;
+	BarcodeFormat _format = BarcodeFormat::None;
+	char _ecLevel[4] = {};
+	char _version[4] = {};
+	int _lineCount = 0;
+	bool _isMirrored = false;
+	bool _isInverted = false;
+	bool _readerInit = false;
+#ifdef ZXING_EXPERIMENTAL_API
+	std::shared_ptr<BitMatrix> _symbol;
+	std::shared_ptr<zint_symbol> _zint;
+#endif
+};
+
+/**
+ * @brief Merge a list of Barcodes from one Structured Append sequence to a single barcode
+ */
+Barcode MergeStructuredAppendSequence(const Barcodes& results);
+
+/**
+ * @brief Automatically merge all Structured Append sequences found in the given list of barcodes
+ */
+Barcodes MergeStructuredAppendSequences(const Barcodes& barcodes);
+
+} // ZXing
diff --git a/core/src/BarcodeFormat.cpp b/core/src/BarcodeFormat.cpp
index 01f4d3860e..ba9a2937cf 100644
--- a/core/src/BarcodeFormat.cpp
+++ b/core/src/BarcodeFormat.cpp
@@ -31,7 +31,9 @@ static BarcodeFormatName NAMES[] = {
 	{BarcodeFormat::Code128, "Code128"},
 	{BarcodeFormat::DataBar, "DataBar"},
 	{BarcodeFormat::DataBarExpanded, "DataBarExpanded"},
+	{BarcodeFormat::DataBarLimited, "DataBarLimited"},
 	{BarcodeFormat::DataMatrix, "DataMatrix"},
+	{BarcodeFormat::DXFilmEdge, "DXFilmEdge"},
 	{BarcodeFormat::EAN8, "EAN-8"},
 	{BarcodeFormat::EAN13, "EAN-13"},
 	{BarcodeFormat::ITF, "ITF"},
@@ -66,7 +68,11 @@ static std::string NormalizeFormatString(std::string_view sv)
 {
 	std::string str(sv);
 	std::transform(str.begin(), str.end(), str.begin(), [](char c) { return (char)std::tolower(c); });
+#ifdef __cpp_lib_erase_if
+	std::erase_if(str, [](char c) { return Contains("_-[]", c); });
+#else
 	str.erase(std::remove_if(str.begin(), str.end(), [](char c) { return Contains("_-[]", c); }), str.end());
+#endif
 	return str;
 }
 
diff --git a/core/src/BarcodeFormat.h b/core/src/BarcodeFormat.h
index 72542ed363..1b29272410 100644
--- a/core/src/BarcodeFormat.h
+++ b/core/src/BarcodeFormat.h
@@ -1,4 +1,4 @@
-/*
+/*
 * Copyright 2016 Nu-book Inc.
 * Copyright 2016 ZXing authors
 */
@@ -40,12 +40,15 @@ enum class BarcodeFormat
 	UPCE            = (1 << 15), ///< UPC-E
 	MicroQRCode     = (1 << 16), ///< Micro QR Code
 	RMQRCode        = (1 << 17), ///< Rectangular Micro QR Code
+	DXFilmEdge      = (1 << 18), ///< DX Film Edge Barcode
+	DataBarLimited  = (1 << 19), ///< GS1 DataBar Limited
 
-	LinearCodes = Codabar | Code39 | Code93 | Code128 | EAN8 | EAN13 | ITF | DataBar | DataBarExpanded | UPCA | UPCE,
+	LinearCodes = Codabar | Code39 | Code93 | Code128 | EAN8 | EAN13 | ITF | DataBar | DataBarExpanded | DataBarLimited
+				  | DXFilmEdge | UPCA | UPCE,
 	MatrixCodes = Aztec | DataMatrix | MaxiCode | PDF417 | QRCode | MicroQRCode | RMQRCode,
 	Any         = LinearCodes | MatrixCodes,
 
-	_max = RMQRCode, ///> implementation detail, don't use
+	_max = DataBarLimited, ///> implementation detail, don't use
 };
 
 ZX_DECLARE_FLAGS(BarcodeFormats, BarcodeFormat)
diff --git a/core/src/BinaryBitmap.cpp b/core/src/BinaryBitmap.cpp
index 4cbe5d5ef2..8b4914e9bf 100644
--- a/core/src/BinaryBitmap.cpp
+++ b/core/src/BinaryBitmap.cpp
@@ -69,6 +69,8 @@ void BinaryBitmap::invert()
 template <typename F>
 void SumFilter(const BitMatrix& in, BitMatrix& out, F func)
 {
+	assert(in.height() >= 3);
+
 	const auto* in0 = in.row(0).begin();
 	const auto* in1 = in.row(1).begin();
 	const auto* in2 = in.row(2).begin();
diff --git a/core/src/BitArray.h b/core/src/BitArray.h
index a260b3a3b8..c9e38c87eb 100644
--- a/core/src/BitArray.h
+++ b/core/src/BitArray.h
@@ -13,10 +13,8 @@
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
-#include <iterator>
 #include <stdexcept>
 #include <type_traits>
-#include <utility>
 #include <vector>
 
 namespace ZXing {
diff --git a/core/src/BitHacks.h b/core/src/BitHacks.h
index d943a1269a..20b4231513 100644
--- a/core/src/BitHacks.h
+++ b/core/src/BitHacks.h
@@ -8,13 +8,19 @@
 
 #include <cassert>
 #include <cstdint>
+#include <cstring>
 #include <vector>
 
-#if __has_include(<bit>) && __cplusplus > 201703L // MSVC has the <bit> header but then warns about including it
+// MSVC has the <bit> header but then warns about including it.
+// We check for _MSVC_LANG here as well, so client code is depending on /Zc:__cplusplus
+#if __has_include(<bit>) && (__cplusplus > 201703L || (defined(_MSVC_LANG) && _MSVC_LANG > 201703L))
 #include <bit>
 #if __cplusplus > 201703L && defined(__ANDROID__) // NDK 25.1.8937393 has the implementation but fails to advertise it
 #define __cpp_lib_bitops 201907L
 #endif
+#elif defined(_MSC_VER)
+// accoring to #863 MSVC defines __cpp_lib_bitops even when <bit> it not included and bitops are not available
+#undef __cpp_lib_bitops
 #endif
 
 #if defined(__clang__) || defined(__GNUC__)
@@ -41,12 +47,16 @@ inline int NumberOfLeadingZeros(T x)
 	return std::countl_zero(static_cast<std::make_unsigned_t<T>>(x));
 #else
 	if constexpr (sizeof(x) <= 4) {
+		static_assert(sizeof(x) == 4, "NumberOfLeadingZeros not implemented for 8 and 16 bit ints.");
 		if (x == 0)
 			return 32;
 #ifdef ZX_HAS_GCC_BUILTINS
 		return __builtin_clz(x);
 #elif defined(ZX_HAS_MSC_BUILTINS)
-		return __lzcnt(x);
+		unsigned long where;
+		if (_BitScanReverse(&where, x))
+			return 31 - static_cast<int>(where);
+		return 32;
 #else
 		int n = 0;
 		if ((x & 0xFFFF0000) == 0) { n = n + 16; x = x << 16; }
@@ -61,9 +71,7 @@ inline int NumberOfLeadingZeros(T x)
 			return 64;
 #ifdef ZX_HAS_GCC_BUILTINS
 		return __builtin_clzll(x);
-#elif defined(ZX_HAS_MSC_BUILTINS)
-		return __lzcnt64(x);
-#else
+#else // including ZX_HAS_MSC_BUILTINS
 		int n = NumberOfLeadingZeros(static_cast<uint32_t>(x >> 32));
 		if (n == 32)
 			n += NumberOfLeadingZeros(static_cast<uint32_t>(x));
@@ -79,13 +87,13 @@ inline int NumberOfLeadingZeros(T x)
 template<typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
 inline int NumberOfTrailingZeros(T v)
 {
-	assert(v != 0);
 #ifdef __cpp_lib_bitops
 	return std::countr_zero(static_cast<std::make_unsigned_t<T>>(v));
 #else
 	if constexpr (sizeof(v) <= 4) {
+		static_assert(sizeof(v) == 4, "NumberOfTrailingZeros not implemented for 8 and 16 bit ints.");
 #ifdef ZX_HAS_GCC_BUILTINS
-		return __builtin_ctz(v);
+		return v == 0 ? 32 : __builtin_ctz(v);
 #elif defined(ZX_HAS_MSC_BUILTINS)
 		unsigned long where;
 		if (_BitScanForward(&where, v))
@@ -104,22 +112,8 @@ inline int NumberOfTrailingZeros(T v)
 #endif
 	} else {
 #ifdef ZX_HAS_GCC_BUILTINS
-		return __builtin_ctzll(v);
-#elif defined(ZX_HAS_MSC_BUILTINS)
-		unsigned long where;
-	#if defined(_WIN64)
-		if (_BitScanForward64(&where, v))
-			return static_cast<int>(where);
-	#elif defined(_WIN32)
-		if (_BitScanForward(&where, static_cast<unsigned long>(v)))
-			return static_cast<int>(where);
-		if (_BitScanForward(&where, static_cast<unsigned long>(v >> 32)))
-			return static_cast<int>(where + 32);
-	#else
-		#error "Implementation of __builtin_ctzll required"
-	#endif
-		return 64;
-#else
+		return v == 0 ? 64 : __builtin_ctzll(v);
+#else // including ZX_HAS_MSC_BUILTINS
 		int n = NumberOfTrailingZeros(static_cast<uint32_t>(v));
 		if (n == 32)
 			n += NumberOfTrailingZeros(static_cast<uint32_t>(v >> 32));
diff --git a/core/src/BitMatrix.cpp b/core/src/BitMatrix.cpp
index 729a5752b3..f03cde7471 100644
--- a/core/src/BitMatrix.cpp
+++ b/core/src/BitMatrix.cpp
@@ -173,4 +173,3 @@ BitMatrix Deflate(const BitMatrix& input, int width, int height, float top, floa
 }
 
 } // ZXing
-
diff --git a/core/src/BitMatrix.h b/core/src/BitMatrix.h
index 6d7dd54c9e..821a035e79 100644
--- a/core/src/BitMatrix.h
+++ b/core/src/BitMatrix.h
@@ -11,10 +11,8 @@
 #include "Point.h"
 #include "Range.h"
 
-#include <algorithm>
 #include <cstdint>
 #include <stdexcept>
-#include <utility>
 #include <vector>
 
 namespace ZXing {
@@ -64,7 +62,7 @@ class BitMatrix
 	BitMatrix(int width, int height) : _width(width), _height(height), _bits(width * height, UNSET_V)
 	{
 		if (width != 0 && Size(_bits) / width != height)
-			throw std::invalid_argument("invalid size: width * height is too big");
+			throw std::invalid_argument("Invalid size: width * height is too big");
 	}
 
 	explicit BitMatrix(int dimension) : BitMatrix(dimension, dimension) {} // Construct a square matrix.
diff --git a/core/src/BitMatrixCursor.h b/core/src/BitMatrixCursor.h
index 25cc95cb13..a7fae30dc9 100644
--- a/core/src/BitMatrixCursor.h
+++ b/core/src/BitMatrixCursor.h
@@ -7,7 +7,6 @@
 
 #include "BitMatrix.h"
 
-#include <array>
 #include <climits>
 
 namespace ZXing {
diff --git a/core/src/ByteMatrix.h b/core/src/ByteMatrix.h
index e94f589c7e..a7fde0f3e8 100644
--- a/core/src/ByteMatrix.h
+++ b/core/src/ByteMatrix.h
@@ -14,7 +14,7 @@ namespace ZXing {
 
 // TODO: If kept at all, this should be replaced by `using ByteMatrix = Matrix<uint8_t>;` to be consistent with ByteArray
 // This non-template class is kept for now to stay source-compatible with older versions of the library.
-
+// [[deprecated]]
 class ByteMatrix : public Matrix<int8_t>
 {
 public:
diff --git a/core/src/CharacterSet.cpp b/core/src/CharacterSet.cpp
index 8676ad0950..fd778a5461 100644
--- a/core/src/CharacterSet.cpp
+++ b/core/src/CharacterSet.cpp
@@ -68,7 +68,11 @@ static std::string NormalizeName(std::string_view sv)
 {
 	std::string str(sv);
 	std::transform(str.begin(), str.end(), str.begin(), [](char c) { return (char)std::tolower(c); });
+#ifdef __cpp_lib_erase_if
+	std::erase_if(str, [](char c) { return Contains("_-[] ", c); });
+#else
 	str.erase(std::remove_if(str.begin(), str.end(), [](char c) { return Contains("_-[] ", c); }), str.end());
+#endif
 	return str;
 }
 
diff --git a/core/src/ConcentricFinder.cpp b/core/src/ConcentricFinder.cpp
index c21a6455e3..e21f65e664 100644
--- a/core/src/ConcentricFinder.cpp
+++ b/core/src/ConcentricFinder.cpp
@@ -39,6 +39,24 @@ std::optional<PointF> CenterOfDoubleCross(const BitMatrix& image, PointI center,
 
 std::optional<PointF> CenterOfRing(const BitMatrix& image, PointI center, int range, int nth, bool requireCircle)
 {
+#if 0
+	if (requireCircle) {
+		// alternative implementation with the aim of discarding closed loops that are not all circle like (M > 5*m)
+		auto points = CollectRingPoints(image, center, range, std::abs(nth), nth < 0);
+		if (points.empty())
+			return {};
+		auto res = Reduce(points, PointF{}, std::plus{}) / Size(points);
+
+		double m = range, M = 0;
+		for (auto p : points)
+			UpdateMinMax(m, M, maxAbsComponent(p - res));
+
+		if (M > 5 * m)
+			return {};
+
+		return res;
+	}
+#endif
 	// range is the approximate width/height of the nth ring, if nth>1 then it would be plausible to limit the search radius
 	// to approximately range / 2 * sqrt(2) == range * 0.75 but it turned out to be too limiting with realworld/noisy data.
 	int radius = range;
diff --git a/core/src/ConcentricFinder.h b/core/src/ConcentricFinder.h
index 02c72c171c..68f29b6d45 100644
--- a/core/src/ConcentricFinder.h
+++ b/core/src/ConcentricFinder.h
@@ -27,7 +27,7 @@ static float CenterFromEnd(const std::array<T, N>& pattern, float end)
 		float b = (pattern[2] + pattern[1] + pattern[0]) / 2.f;
 		return end - (2 * a + b) / 3;
 	} else { // aztec
-		auto a = std::accumulate(pattern.begin() + (N/2 + 1), pattern.end(), pattern[N/2] / 2.f);
+		auto a = Reduce(pattern.begin() + (N/2 + 1), pattern.end(), pattern[N/2] / 2.f);
 		return end - a;
 	}
 }
diff --git a/core/src/Content.cpp b/core/src/Content.cpp
index 4d3c44657c..d0f2e80a16 100644
--- a/core/src/Content.cpp
+++ b/core/src/Content.cpp
@@ -12,6 +12,10 @@
 #include "Utf.h"
 #include "ZXAlgorithms.h"
 
+#if !defined(ZXING_READERS) && !defined(ZXING_WRITERS)
+#include "Version.h"
+#endif
+
 #include <cctype>
 
 namespace ZXing {
@@ -98,6 +102,7 @@ std::string Content::render(bool withECI) const
 	if (empty() || !canProcess())
 		return {};
 
+#ifdef ZXING_READERS
 	std::string res;
 	if (withECI)
 		res = symbology.toString(true);
@@ -136,6 +141,10 @@ std::string Content::render(bool withECI) const
 	});
 
 	return res;
+#else
+	//TODO: replace by proper construction from encoded data from within zint
+	return std::string(bytes.asString());
+#endif
 }
 
 std::string Content::text(TextMode mode) const
@@ -145,6 +154,7 @@ std::string Content::text(TextMode mode) const
 	case TextMode::ECI: return render(true);
 	case TextMode::HRI:
 		switch (type()) {
+#ifdef ZXING_READERS
 		case ContentType::GS1: {
 			auto plain = render(false);
 			auto hri = HRIFromGS1(plain);
@@ -152,6 +162,7 @@ std::string Content::text(TextMode mode) const
 		}
 		case ContentType::ISO15434: return HRIFromISO15434(render(false));
 		case ContentType::Text: return render(false);
+#endif
 		default: return text(TextMode::Escaped);
 		}
 	case TextMode::Hex: return ToHex(bytes);
@@ -190,6 +201,7 @@ ByteArray Content::bytesECI() const
 
 CharacterSet Content::guessEncoding() const
 {
+#ifdef ZXING_READERS
 	// assemble all blocks with unknown encoding
 	ByteArray input;
 	ForEachECIBlock([&](ECI eci, int begin, int end) {
@@ -201,10 +213,14 @@ CharacterSet Content::guessEncoding() const
 		return CharacterSet::Unknown;
 
 	return TextDecoder::GuessEncoding(input.data(), input.size(), CharacterSet::ISO8859_1);
+#else
+	return CharacterSet::Unknown;
+#endif
 }
 
 ContentType Content::type() const
 {
+#ifdef ZXING_READERS
 	if (empty())
 		return ContentType::Text;
 
@@ -235,6 +251,10 @@ ContentType Content::type() const
 		return ContentType::Binary;
 
 	return ContentType::Mixed;
+#else
+	//TODO: replace by proper construction from encoded data from within zint
+	return ContentType::Text;
+#endif
 }
 
 } // namespace ZXing
diff --git a/core/src/DecodeHints.cpp b/core/src/DecodeHints.cpp
index 8dbd5a8685..9a54d8d2fb 100644
--- a/core/src/DecodeHints.cpp
+++ b/core/src/DecodeHints.cpp
@@ -17,12 +17,12 @@ struct DecodeHints
 	char data[sizeof(ReaderOptions)];
 };
 
-Result ReadBarcode(const ImageView& image, const DecodeHints& hints = {})
+Barcode ReadBarcode(const ImageView& image, const DecodeHints& hints = {})
 {
 	return ReadBarcode(image, reinterpret_cast<const ReaderOptions&>(hints));
 }
 
-Results ReadBarcodes(const ImageView& image, const DecodeHints& hints = {})
+Barcodes ReadBarcodes(const ImageView& image, const DecodeHints& hints = {})
 {
 	return ReadBarcodes(image, reinterpret_cast<const ReaderOptions&>(hints));
 }
diff --git a/core/src/DecoderResult.h b/core/src/DecoderResult.h
index 02b2850841..de068c4263 100644
--- a/core/src/DecoderResult.h
+++ b/core/src/DecoderResult.h
@@ -24,6 +24,7 @@ class DecoderResult
 	std::string _ecLevel;
 	int _lineCount = 0;
 	int _versionNumber = 0;
+	int _dataMask = 0;
 	StructuredAppendInfo _structuredAppend;
 	bool _isMirrored = false;
 	bool _readerInit = false;
@@ -43,7 +44,7 @@ class DecoderResult
 
 	bool isValid(bool includeErrors = false) const
 	{
-		return includeErrors || (_content.symbology.code != 0 && !_error);
+		return (!_content.bytes.empty() && !_error) || (includeErrors && !!_error);
 	}
 
 	const Content& content() const & { return _content; }
@@ -71,6 +72,7 @@ class DecoderResult
 	ZX_PROPERTY(std::string, ecLevel, setEcLevel)
 	ZX_PROPERTY(int, lineCount, setLineCount)
 	ZX_PROPERTY(int, versionNumber, setVersionNumber)
+	ZX_PROPERTY(int, dataMask, setDataMask)
 	ZX_PROPERTY(StructuredAppendInfo, structuredAppend, setStructuredAppend)
 	ZX_PROPERTY(Error, error, setError)
 	ZX_PROPERTY(bool, isMirrored, setIsMirrored)
diff --git a/core/src/Error.cpp b/core/src/Error.cpp
new file mode 100644
index 0000000000..c46a6c6232
--- /dev/null
+++ b/core/src/Error.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2022 Axel Waggershauser
+ */
+// SPDX-License-Identifier: Apache-2.0
+
+#include "Error.h"
+
+namespace ZXing {
+
+std::string Error::location() const
+{
+	if (!_file)
+		return {};
+	std::string file(_file);
+	return file.substr(file.find_last_of("/\\") + 1) + ":" + std::to_string(_line);
+}
+
+std::string ToString(const Error& e)
+{
+	const char* name[] = {"", "FormatError", "ChecksumError", "Unsupported"};
+	std::string ret = name[static_cast<int>(e.type())];
+	if (!e.msg().empty())
+		ret += " (" + e.msg() + ")";
+	if (auto location = e.location(); !location.empty())
+		ret += " @ " + e.location();
+	return ret;
+}
+
+}
diff --git a/core/src/Error.h b/core/src/Error.h
index 07e7ff0390..fbccf9faa7 100644
--- a/core/src/Error.h
+++ b/core/src/Error.h
@@ -10,6 +10,24 @@
 
 namespace ZXing {
 
+/**
+ * @brief The Error class is a value type for the error() member of @Barcode
+ *
+ * The use-case of this class is to communicate whether or not a particular Barcode
+ * symbol is in error. It is (primarily) not meant to be thrown as an exception and
+ * therefore not derived from std::exception. The library code may throw (and catch!)
+ * objects of this class as a convenient means of flow control (c++23's std::expected
+ * will allow to replace those use-cases with something similarly convenient). In
+ * those situations, the author is advised to make sure any thrown Error object is
+ * caught before leaking into user/wrapper code, i.e. the functions of the public
+ * API should be considered `noexcept` with respect to this class.
+ *
+ * Looking at the implementation of std::runtime_exception, it might actually be of
+ * interest to replace the std::string msg member with a std::runtime_exception base
+ * class, thereby reducing sizeof(Error) by 16 bytes. This would be a breaking ABI
+ * change and would therefore have to wait for release 3.0. (TODO)
+ */
+
 class Error
 {
 public:
@@ -18,13 +36,7 @@ class Error
 	const std::string& msg() const noexcept { return _msg; }
 	explicit operator bool() const noexcept { return _type != Type::None; }
 
-	std::string location() const
-	{
-		if (!_file)
-			return {};
-		std::string file(_file);
-		return file.substr(file.find_last_of("/\\") + 1) + ":" + std::to_string(_line);
-	}
+	std::string location() const;
 
 	Error() = default;
 	Error(Type type, std::string msg = {}) : _msg(std::move(msg)), _type(type) {}
@@ -56,15 +68,6 @@ inline bool operator!=(Error::Type t, const Error& e) noexcept { return !(t == e
 #define ChecksumError(...) Error(__FILE__, __LINE__, Error::Checksum, std::string(__VA_ARGS__))
 #define UnsupportedError(...) Error(__FILE__, __LINE__, Error::Unsupported, std::string(__VA_ARGS__))
 
-inline std::string ToString(const Error& e)
-{
-	const char* name[] = {"", "FormatError", "ChecksumError", "Unsupported"};
-	std::string ret = name[static_cast<int>(e.type())];
-	if (!e.msg().empty())
-		ret += " (" + e.msg() + ")";
-	if (auto location = e.location(); !location.empty())
-		ret += " @ " + e.location();
-	return ret;
-}
+std::string ToString(const Error& e);
 
 }
diff --git a/core/src/GTIN.cpp b/core/src/GTIN.cpp
index 256855a030..5ee06a9de7 100644
--- a/core/src/GTIN.cpp
+++ b/core/src/GTIN.cpp
@@ -6,7 +6,7 @@
 
 #include "GTIN.h"
 
-#include "Result.h"
+#include "Barcode.h"
 
 #include <algorithm>
 #include <iomanip>
@@ -18,9 +18,9 @@ namespace ZXing::GTIN {
 
 struct CountryId
 {
-	int first;
-	int last;
-	const char *id;
+	uint16_t first;
+	uint16_t last;
+	const char id[3];
 };
 
 bool operator<(const CountryId& lhs, const CountryId& rhs)
@@ -32,9 +32,9 @@ bool operator<(const CountryId& lhs, const CountryId& rhs)
 // and https://en.wikipedia.org/wiki/List_of_GS1_country_codes
 static const CountryId COUNTRIES[] = {
 	// clang-format off
-	{1, 19, "US/CA"},
+	{1, 19, "US"},
 	{30, 39, "US"},
-	{60, 99, "US/CA"}, // Note 99 coupon identification
+	{60, 99, "US"}, // Note 99 coupon identification
 	{100, 139, "US"},
 	{300, 379, "FR"}, // France (and Monaco according to Wikipedia)
 	{380, 380, "BG"}, // Bulgaria
@@ -73,7 +73,7 @@ static const CountryId COUNTRIES[] = {
 	{531, 531, "MK"}, // North Macedonia
 	{535, 535, "MT"}, // Malta
 	{539, 539, "IE"}, // Ireland
-	{540, 549, "BE/LU"}, // Belgium & Luxembourg
+	{540, 549, "BE"}, // Belgium & Luxembourg
 	{560, 560, "PT"}, // Portugal
 	{569, 569, "IS"}, // Iceland
 	{570, 579, "DK"}, // Denmark (and Faroe Islands and Greenland according to Wikipedia)
@@ -194,17 +194,16 @@ std::string LookupCountryIdentifier(const std::string& GTIN, const BarcodeFormat
 	if (size == 8 && format == BarcodeFormat::EAN8 && prefix <= 99) // Restricted Circulation Numbers
 		return {};
 
-	const auto it = std::lower_bound(std::begin(COUNTRIES), std::end(COUNTRIES), CountryId{0, prefix, nullptr});
+	const auto it = std::lower_bound(std::begin(COUNTRIES), std::end(COUNTRIES), CountryId{0, narrow_cast<uint16_t>(prefix), ""});
 
 	return it != std::end(COUNTRIES) && prefix >= it->first && prefix <= it->last ? it->id : std::string();
 }
 
-std::string EanAddOn(const Result& result)
+std::string EanAddOn(const Barcode& barcode)
 {
-	if (!(BarcodeFormat::EAN13 | BarcodeFormat::UPCA | BarcodeFormat::UPCE | BarcodeFormat::EAN8)
-			.testFlag(result.format()))
+	if (!(BarcodeFormat::EAN13 | BarcodeFormat::UPCA | BarcodeFormat::UPCE | BarcodeFormat::EAN8).testFlag(barcode.format()))
 		return {};
-	auto txt = result.bytes().asString();
+	auto txt = barcode.bytes().asString();
 	auto pos = txt.find(' ');
 	return pos != std::string::npos ? std::string(txt.substr(pos + 1)) : std::string();
 }
diff --git a/core/src/GTIN.h b/core/src/GTIN.h
index d56b604e5f..9148844ff3 100644
--- a/core/src/GTIN.h
+++ b/core/src/GTIN.h
@@ -7,16 +7,13 @@
 
 #pragma once
 
+#include "Barcode.h"
 #include "BarcodeFormat.h"
 #include "ZXAlgorithms.h"
 
 #include <string>
 
-namespace ZXing {
-
-class Result;
-
-namespace GTIN {
+namespace ZXing::GTIN {
 
 template <typename T>
 T ComputeCheckDigit(const std::basic_string<T>& digits, bool skipTail = false)
@@ -47,10 +44,9 @@ bool IsCheckDigitValid(const std::basic_string<T>& s)
  */
 std::string LookupCountryIdentifier(const std::string& GTIN, const BarcodeFormat format = BarcodeFormat::None);
 
-std::string EanAddOn(const Result& result);
+std::string EanAddOn(const Barcode& barcode);
 
 std::string IssueNr(const std::string& ean2AddOn);
 std::string Price(const std::string& ean5AddOn);
 
-} // namespace GTIN
-} // namespace ZXing
+} // namespace ZXing::GTIN
diff --git a/core/src/GenericGFPoly.cpp b/core/src/GenericGFPoly.cpp
index 1ec9f84fd3..a624e487e2 100644
--- a/core/src/GenericGFPoly.cpp
+++ b/core/src/GenericGFPoly.cpp
@@ -19,18 +19,14 @@ namespace ZXing {
 int
 GenericGFPoly::evaluateAt(int a) const
 {
-	if (a == 0)
-		// Just return the x^0 coefficient
+	if (a == 0) // return the x^0 coefficient
 		return constant();
 
-	if (a == 1)
-		// Just the sum of the coefficients
-		return Reduce(_coefficients, 0, [](auto a, auto b) { return a ^ b; });
+	if (a == 1) // return the sum of the coefficients
+		return Reduce(_coefficients, 0, [](auto s, auto c) { return s ^ c; });
 
-	int result = _coefficients[0];
-	for (size_t i = 1; i < _coefficients.size(); ++i)
-		result = _field->multiply(a, result) ^ _coefficients[i];
-	return result;
+	return std::accumulate(_coefficients.begin(), _coefficients.end(), 0,
+						   [this, a](auto s, auto c) { return _field->multiply(a, s) ^ c; });
 }
 
 GenericGFPoly& GenericGFPoly::addOrSubtract(GenericGFPoly& other)
diff --git a/core/src/GlobalHistogramBinarizer.cpp b/core/src/GlobalHistogramBinarizer.cpp
index 44ca15810c..fb0b3ec26e 100644
--- a/core/src/GlobalHistogramBinarizer.cpp
+++ b/core/src/GlobalHistogramBinarizer.cpp
@@ -11,8 +11,6 @@
 
 #include <algorithm>
 #include <array>
-#include <cassert>
-#include <functional>
 #include <utility>
 
 namespace ZXing {
@@ -48,6 +46,8 @@ static void ThresholdSharpened(const ImageLineView in, int threshold, std::vecto
 
 static auto GenHistogram(const ImageLineView line)
 {
+	// This code causes about 20% of the total runtime on an AVX2 system for a EAN13 search on Lum input data.
+	// Trying to increase the performance by performing 2 or 4 "parallel" histograms helped nothing.
 	Histogram res = {};
 	for (auto pix : line)
 		res[pix >> LUMINANCE_SHIFT]++;
@@ -110,9 +110,9 @@ bool GlobalHistogramBinarizer::getPatternRow(int row, int rotation, PatternRow&
 	if (buffer.width() < 3)
 		return false; // special casing the code below for a width < 3 makes no sense
 
-#ifdef __AVX__
+#if defined(__AVX__) // or defined(__ARM_NEON)
 	// If we are extracting a column (instead of a row), we run into cache misses on every pixel access both
-	// during the histogram caluculation and during the sharpen+threshold operation. Additionally, if we
+	// during the histogram calculation and during the sharpen+threshold operation. Additionally, if we
 	// perform the ThresholdSharpened function on pixStride==1 data, the auto-vectorizer makes that part
 	// 8x faster on an AVX2 cpu which easily recovers the extra cost that we pay for the copying.
 	thread_local std::vector<uint8_t> line;
diff --git a/core/src/GridSampler.cpp b/core/src/GridSampler.cpp
index 8b5cf9b336..626ce025e3 100644
--- a/core/src/GridSampler.cpp
+++ b/core/src/GridSampler.cpp
@@ -56,7 +56,15 @@ DetectorResult SampleGrid(const BitMatrix& image, int width, int height, const R
 #ifdef PRINT_DEBUG
 				log(p, 3);
 #endif
+#if 0
+				int sum = 0;
+				for (int dy = -1; dy <= 1; ++dy)
+					for (int dx = -1; dx <= 1; ++dx)
+						sum += image.get(p + PointF(dx, dy));
+				if (sum >= 5)
+#else
 				if (image.get(p))
+#endif
 					res.set(x, y);
 			}
 	}
diff --git a/core/src/HRI.cpp b/core/src/HRI.cpp
index 9a72dc6b31..f264b608f8 100644
--- a/core/src/HRI.cpp
+++ b/core/src/HRI.cpp
@@ -10,27 +10,29 @@
 #include "ZXAlgorithms.h"
 
 #include <cmath>
-#include <sstream>
+#include <cstring>
+#include <string_view>
 
 namespace ZXing {
 
 struct AiInfo
 {
-	std::string_view aiPrefix;
-	int _fieldSize;	// if negative, the length is variable and abs(length) give the max size
+	const char aiPrefix[5];
+	int8_t _fieldSize;	// if negative, the length is variable and abs(length) give the max size
 
 	bool isVariableLength() const noexcept { return _fieldSize < 0; }
 	int fieldSize() const noexcept { return std::abs(_fieldSize); }
 	int aiSize() const
 	{
-		if ((aiPrefix[0] == '3' && Contains("1234569", aiPrefix[1])) || aiPrefix == "703" || aiPrefix == "723")
+		using namespace std::literals;
+		if ((aiPrefix[0] == '3' && Contains("1234569", aiPrefix[1])) || aiPrefix == "703"sv || aiPrefix == "723"sv)
 			return 4;
 		else
-			return Size(aiPrefix);
+			return strlen(aiPrefix);
 	}
 };
 
-// https://github.com/gs1/gs1-syntax-dictionary 2023-09-22
+// https://github.com/gs1/gs1-syntax-dictionary 2024-06-10
 static const AiInfo aiInfos[] = {
 //TWO_DIGIT_DATA_LENGTH
 	{ "00", 18 },
@@ -218,6 +220,16 @@ static const AiInfo aiInfos[] = {
 	{ "7240", -20 },
 	{ "7241", 2 },
 	{ "7242", -25 },
+	{ "7250", 8 },
+	{ "7251", 12 },
+	{ "7252", 1 },
+	{ "7253", -40 },
+	{ "7254", -40 },
+	{ "7255", -10 },
+	{ "7256", -90 },
+	{ "7257", -70 },
+	{ "7258", 3 },
+	{ "7259", -40 },
 
 	{ "8001", 14 },
 	{ "8002", -20 },
@@ -292,26 +304,20 @@ std::string HRIFromGS1(std::string_view gs1)
 	return res;
 }
 
-#if __cplusplus > 201703L
-std::ostream& operator<<(std::ostream& os, const char8_t* str)
-{
-	return os << reinterpret_cast<const char*>(str);
-}
-#endif
-
 std::string HRIFromISO15434(std::string_view str)
 {
 	// Use available unicode symbols to simulate sub- and superscript letters as specified in
 	// ISO/IEC 15434:2019(E) 6. Human readable representation
 
-	std::ostringstream oss;
+	std::string res;
+	res.reserve(str.size());
 
 	for (char c : str) {
 #if 1
 		if (0 <= c && c <= 0x20)
-			oss << "\xe2\x90" << char(0x80 + c); // Unicode Block “Control Pictures”: 0x2400
+			(res += "\xe2\x90") += char(0x80 + c); // Unicode Block “Control Pictures”: 0x2400
 		else
-			oss << c;
+			res += c;
 #else
 		switch (c) {
 		case 4: oss << u8"\u1d31\u1d52\u209c"; break; // EOT
@@ -324,7 +330,7 @@ std::string HRIFromISO15434(std::string_view str)
 #endif
 	}
 
-	return oss.str();
+	return res;
 }
 
 } // namespace ZXing
diff --git a/core/src/HybridBinarizer.cpp b/core/src/HybridBinarizer.cpp
index a74fbd2872..33562817a0 100644
--- a/core/src/HybridBinarizer.cpp
+++ b/core/src/HybridBinarizer.cpp
@@ -9,17 +9,19 @@
 #include "BitMatrix.h"
 #include "Matrix.h"
 
+#include <algorithm>
 #include <cstdint>
+#include <fstream>
 #include <memory>
-#include <mutex>
-#include <utility>
+
+#define USE_NEW_ALGORITHM
 
 namespace ZXing {
 
 // This class uses 5x5 blocks to compute local luminance, where each block is 8x8 pixels.
 // So this is the smallest dimension in each axis we can accept.
 static constexpr int BLOCK_SIZE = 8;
-static constexpr int MINIMUM_DIMENSION = BLOCK_SIZE * 5;
+static constexpr int WINDOW_SIZE = BLOCK_SIZE * (1 + 2 * 2);
 static constexpr int MIN_DYNAMIC_RANGE = 24;
 
 HybridBinarizer::HybridBinarizer(const ImageView& iv) : GlobalHistogramBinarizer(iv) {}
@@ -43,15 +45,34 @@ bool HybridBinarizer::getPatternRow(int row, int rotation, PatternRow& res) cons
 #endif
 }
 
+using T_t = uint8_t;
+
+/**
+* Applies a single threshold to a block of pixels.
+*/
+static void ThresholdBlock(const uint8_t* __restrict luminances, int xoffset, int yoffset, T_t threshold, int rowStride,
+						   BitMatrix& matrix)
+{
+	for (int y = yoffset; y < yoffset + BLOCK_SIZE; ++y) {
+		auto* src = luminances + y * rowStride + xoffset;
+		auto* const dstBegin = matrix.row(y).begin() + xoffset;
+		// TODO: fix pixelStride > 1 case
+		for (auto* dst = dstBegin; dst < dstBegin + BLOCK_SIZE; ++dst, ++src)
+			*dst = (*src <= threshold) * BitMatrix::SET_V;
+	}
+}
+
+#ifndef USE_NEW_ALGORITHM
+
 /**
 * Calculates a single black point for each block of pixels and saves it away.
 * See the following thread for a discussion of this algorithm:
 *  http://groups.google.com/group/zxing/browse_thread/thread/d06efa2c35a7ddc0
 */
-static Matrix<int> CalculateBlackPoints(const uint8_t* __restrict luminances, int subWidth, int subHeight, int width, int height,
+static Matrix<T_t> CalculateBlackPoints(const uint8_t* __restrict luminances, int subWidth, int subHeight, int width, int height,
 										int rowStride)
 {
-	Matrix<int>	blackPoints(subWidth, subHeight);
+	Matrix<T_t> blackPoints(subWidth, subHeight);
 
 	for (int y = 0; y < subHeight; y++) {
 		int yoffset = std::min(y * BLOCK_SIZE, height - BLOCK_SIZE);
@@ -112,32 +133,21 @@ static Matrix<int> CalculateBlackPoints(const uint8_t* __restrict luminances, in
 	return blackPoints;
 }
 
-
-/**
-* Applies a single threshold to a block of pixels.
-*/
-static void ThresholdBlock(const uint8_t* __restrict luminances, int xoffset, int yoffset, int threshold, int rowStride,
-						   BitMatrix& matrix)
-{
-	for (int y = yoffset; y < yoffset + BLOCK_SIZE; ++y) {
-		auto* src = luminances + y * rowStride + xoffset;
-		auto* const dstBegin = matrix.row(y).begin() + xoffset;
-		// TODO: fix pixelStride > 1 case
-		for (auto* dst = dstBegin; dst < dstBegin + BLOCK_SIZE; ++dst, ++src)
-			*dst = (*src <= threshold) * BitMatrix::SET_V;
-	}
-}
-
 /**
 * For each block in the image, calculate the average black point using a 5x5 grid
 * of the blocks around it. Also handles the corner cases (fractional blocks are computed based
 * on the last pixels in the row/column which are also used in the previous block).
 */
 static std::shared_ptr<BitMatrix> CalculateMatrix(const uint8_t* __restrict luminances, int subWidth, int subHeight, int width,
-												  int height, int rowStride, const Matrix<int>& blackPoints)
+												  int height, int rowStride, const Matrix<T_t>& blackPoints)
 {
 	auto matrix = std::make_shared<BitMatrix>(width, height);
 
+#ifndef NDEBUG
+	Matrix<uint8_t> out(width, height);
+	Matrix<uint8_t> out2(width, height);
+#endif
+
 	for (int y = 0; y < subHeight; y++) {
 		int yoffset = std::min(y * BLOCK_SIZE, height - BLOCK_SIZE);
 		for (int x = 0; x < subWidth; x++) {
@@ -152,22 +162,148 @@ static std::shared_ptr<BitMatrix> CalculateMatrix(const uint8_t* __restrict lumi
 			}
 			int average = sum / 25;
 			ThresholdBlock(luminances, xoffset, yoffset, average, rowStride, *matrix);
+
+#ifndef NDEBUG
+			for (int yy = 0; yy < 8; ++yy)
+				for (int xx = 0; xx < 8; ++xx) {
+					out.set(xoffset + xx, yoffset + yy, blackPoints(x, y));
+					out2.set(xoffset + xx, yoffset + yy, average);
+				}
+#endif
+		}
+	}
+
+#ifndef NDEBUG
+	std::ofstream file("thresholds.pnm");
+	file << "P5\n" << out.width() << ' ' << out.height() << "\n255\n";
+	file.write(reinterpret_cast<const char*>(out.data()), out.size());
+	std::ofstream file2("thresholds_avg.pnm");
+	file2 << "P5\n" << out.width() << ' ' << out.height() << "\n255\n";
+	file2.write(reinterpret_cast<const char*>(out2.data()), out2.size());
+#endif
+
+	return matrix;
+}
+
+#else
+
+// Subdivide the image in blocks of BLOCK_SIZE and calculate one treshold value per block as
+// (max - min > MIN_DYNAMIC_RANGE) ? (max + min) / 2 : 0
+static Matrix<T_t> BlockThresholds(const ImageView iv)
+{
+	int subWidth = (iv.width() + BLOCK_SIZE - 1) / BLOCK_SIZE; // ceil(width/BS)
+	int subHeight = (iv.height() + BLOCK_SIZE - 1) / BLOCK_SIZE; // ceil(height/BS)
+
+	Matrix<T_t> thresholds(subWidth, subHeight);
+
+	for (int y = 0; y < subHeight; y++) {
+		int y0 = std::min(y * BLOCK_SIZE, iv.height() - BLOCK_SIZE);
+		for (int x = 0; x < subWidth; x++) {
+			int x0 = std::min(x * BLOCK_SIZE, iv.width() - BLOCK_SIZE);
+			uint8_t min = 255;
+			uint8_t max = 0;
+			for (int yy = 0; yy < BLOCK_SIZE; yy++) {
+				auto line = iv.data(x0, y0 + yy);
+				for (int xx = 0; xx < BLOCK_SIZE; xx++)
+					UpdateMinMax(min, max, line[xx]);
+			}
+
+			thresholds(x, y) = (max - min > MIN_DYNAMIC_RANGE) ? (int(max) + min) / 2 : 0;
+		}
+	}
+
+	return thresholds;
+}
+
+// Apply gaussian-like smoothing filter over all non-zero thresholds and fill any remainig gaps with nearest neighbor
+static Matrix<T_t> SmoothThresholds(Matrix<T_t>&& in)
+{
+	Matrix<T_t> out(in.width(), in.height());
+
+	constexpr int R = WINDOW_SIZE / BLOCK_SIZE / 2;
+	for (int y = 0; y < in.height(); y++) {
+		for (int x = 0; x < in.width(); x++) {
+			int left = std::clamp(x, R, in.width() - R - 1);
+			int top = std::clamp(y, R, in.height() - R - 1);
+
+			int sum = in(x, y) * 2;
+			int n = (sum > 0) * 2;
+			auto add = [&](int x, int y) {
+				int t = in(x, y);
+				sum += t;
+				n += t > 0;
+			};
+
+			for (int dy = -R; dy <= R; ++dy)
+				for (int dx = -R; dx <= R; ++dx)
+					add(left + dx, top + dy);
+
+			out(x, y) = n > 0 ? sum / n : 0;
+		}
+	}
+
+	// flood fill any remaing gaps of (very large) no-contrast regions
+	auto last = out.begin() - 1;
+	for (auto* i = out.begin(); i != out.end(); ++i) {
+		if (*i) {
+			if (last != i - 1)
+				std::fill(last + 1, i, *i);
+			last = i;
 		}
 	}
+	std::fill(last + 1, out.end(), *(std::max(last, out.begin())));
+
+	return out;
+}
+
+static std::shared_ptr<BitMatrix> ThresholdImage(const ImageView iv, const Matrix<T_t>& thresholds)
+{
+	auto matrix = std::make_shared<BitMatrix>(iv.width(), iv.height());
+
+#ifndef NDEBUG
+	Matrix<uint8_t> out(iv.width(), iv.height());
+#endif
+
+	for (int y = 0; y < thresholds.height(); y++) {
+		int yoffset = std::min(y * BLOCK_SIZE, iv.height() - BLOCK_SIZE);
+		for (int x = 0; x < thresholds.width(); x++) {
+			int xoffset = std::min(x * BLOCK_SIZE, iv.width() - BLOCK_SIZE);
+			ThresholdBlock(iv.data(), xoffset, yoffset, thresholds(x, y), iv.rowStride(), *matrix);
+
+#ifndef NDEBUG
+			for (int yy = 0; yy < 8; ++yy)
+				for (int xx = 0; xx < 8; ++xx)
+					out.set(xoffset + xx, yoffset + yy, thresholds(x, y));
+#endif
+		}
+	}
+
+#ifndef NDEBUG
+	std::ofstream file("thresholds_new.pnm");
+	file << "P5\n" << out.width() << ' ' << out.height() << "\n255\n";
+	file.write(reinterpret_cast<const char*>(out.data()), out.size());
+#endif
 
 	return matrix;
 }
 
+#endif
+
 std::shared_ptr<const BitMatrix> HybridBinarizer::getBlackMatrix() const
 {
-	if (width() >= MINIMUM_DIMENSION && height() >= MINIMUM_DIMENSION) {
-		const uint8_t* luminances = _buffer.data(0, 0);
+	if (width() >= WINDOW_SIZE && height() >= WINDOW_SIZE) {
+#ifdef USE_NEW_ALGORITHM
+		auto thrs = SmoothThresholds(BlockThresholds(_buffer));
+		return ThresholdImage(_buffer, thrs);
+#else
+		const uint8_t* luminances = _buffer.data();
 		int subWidth = (width() + BLOCK_SIZE - 1) / BLOCK_SIZE; // ceil(width/BS)
 		int subHeight = (height() + BLOCK_SIZE - 1) / BLOCK_SIZE; // ceil(height/BS)
 		auto blackPoints =
 			CalculateBlackPoints(luminances, subWidth, subHeight, width(), height(), _buffer.rowStride());
 
 		return CalculateMatrix(luminances, subWidth, subHeight, width(), height(), _buffer.rowStride(), blackPoints);
+#endif
 	} else {
 		// If the image is too small, fall back to the global histogram approach.
 		return GlobalHistogramBinarizer::getBlackMatrix();
diff --git a/core/src/ImageView.h b/core/src/ImageView.h
index bee631b67a..4d145eb6b6 100644
--- a/core/src/ImageView.h
+++ b/core/src/ImageView.h
@@ -7,6 +7,9 @@
 
 #include <algorithm>
 #include <cstdint>
+#include <cstdio>
+#include <memory>
+#include <stdexcept>
 
 namespace ZXing {
 
@@ -14,12 +17,17 @@ enum class ImageFormat : uint32_t
 {
 	None = 0,
 	Lum  = 0x01000000,
+	LumA = 0x02000000,
 	RGB  = 0x03000102,
 	BGR  = 0x03020100,
-	RGBX = 0x04000102,
-	XRGB = 0x04010203,
-	BGRX = 0x04020100,
-	XBGR = 0x04030201,
+	RGBA = 0x04000102,
+	ARGB = 0x04010203,
+	BGRA = 0x04020100,
+	ABGR = 0x04030201,
+	RGBX [[deprecated("use RGBA")]] = RGBA,
+	XRGB [[deprecated("use ARGB")]] = ARGB,
+	BGRX [[deprecated("use BGRA")]] = BGRA,
+	XBGR [[deprecated("use ABGR")]] = ABGR,
 };
 
 constexpr inline int PixStride(ImageFormat format) { return (static_cast<uint32_t>(format) >> 3*8) & 0xFF; }
@@ -42,10 +50,14 @@ class ImageView
 {
 protected:
 	const uint8_t* _data = nullptr;
-	ImageFormat _format;
+	ImageFormat _format = ImageFormat::None;
 	int _width = 0, _height = 0, _pixStride = 0, _rowStride = 0;
 
 public:
+	/** ImageView default constructor creates a 'null' image view
+	 */
+	ImageView() = default;
+
 	/**
 	 * ImageView constructor
 	 *
@@ -63,7 +75,29 @@ class ImageView
 		  _height(height),
 		  _pixStride(pixStride ? pixStride : PixStride(format)),
 		  _rowStride(rowStride ? rowStride : width * _pixStride)
-	{}
+	{
+		// TODO: [[deprecated]] this check is to prevent exising code from suddenly throwing, remove in 3.0
+		if (_data == nullptr && _width == 0 && _height == 0 && rowStride == 0 && pixStride == 0) {
+			fprintf(stderr, "zxing-cpp deprecation warning: ImageView(nullptr, ...) will throw in the future, use ImageView()\n");
+			return;
+		}
+
+		if (_data == nullptr)
+			throw std::invalid_argument("Can not construct an ImageView from a NULL pointer");
+
+		if (_width <= 0 || _height <= 0)
+			throw std::invalid_argument("Neither width nor height of ImageView can be less or equal to 0");
+	}
+
+	/**
+	 * ImageView constructor with bounds checking
+	 */
+	ImageView(const uint8_t* data, int size, int width, int height, ImageFormat format, int rowStride = 0, int pixStride = 0)
+		: ImageView(data, width, height, format, rowStride, pixStride)
+	{
+		if (_rowStride < 0 || _pixStride < 0 || size < _height * _rowStride)
+			throw std::invalid_argument("ImageView parameters are inconsistent (out of bounds)");
+	}
 
 	int width() const { return _width; }
 	int height() const { return _height; }
@@ -71,12 +105,13 @@ class ImageView
 	int rowStride() const { return _rowStride; }
 	ImageFormat format() const { return _format; }
 
+	const uint8_t* data() const { return _data; }
 	const uint8_t* data(int x, int y) const { return _data + y * _rowStride + x * _pixStride; }
 
 	ImageView cropped(int left, int top, int width, int height) const
 	{
-		left   = std::max(0, left);
-		top    = std::max(0, top);
+		left   = std::clamp(left, 0, _width - 1);
+		top    = std::clamp(top, 0, _height - 1);
 		width  = width <= 0 ? (_width - left) : std::min(_width - left, width);
 		height = height <= 0 ? (_height - top) : std::min(_height - top, height);
 		return {data(left, top), width, height, _format, _rowStride, _pixStride};
@@ -99,5 +134,15 @@ class ImageView
 
 };
 
+class Image : public ImageView
+{
+	std::unique_ptr<uint8_t[]> _memory;
+	Image(std::unique_ptr<uint8_t[]>&& data, int w, int h, ImageFormat f) : ImageView(data.get(), w, h, f), _memory(std::move(data)) {}
+
+public:
+	Image() = default;
+	Image(int w, int h, ImageFormat f = ImageFormat::Lum) : Image(std::make_unique<uint8_t[]>(w * h * PixStride(f)), w, h, f) {}
+};
+
 } // ZXing
 
diff --git a/core/src/Matrix.h b/core/src/Matrix.h
index 36d4a0efe2..b6f8bc2150 100644
--- a/core/src/Matrix.h
+++ b/core/src/Matrix.h
@@ -40,7 +40,7 @@ class Matrix
 #endif
 	Matrix(int width, int height, value_t val = {}) : _width(width), _height(height), _data(_width * _height, val) {
 		if (width != 0 && Size(_data) / width != height)
-			throw std::invalid_argument("invalid size: width * height is too big");
+			throw std::invalid_argument("Invalid size: width * height is too big");
 	}
 
 	Matrix(Matrix&&) noexcept = default;
@@ -102,6 +102,14 @@ class Matrix
 		return _data.data() + _width * _height;
 	}
 
+	value_t* begin() {
+		return _data.data();
+	}
+
+	value_t* end() {
+		return _data.data() + _width * _height;
+	}
+
 	void clear(value_t value = {}) {
 		std::fill(_data.begin(), _data.end(), value);
 	}
diff --git a/core/src/MultiFormatReader.cpp b/core/src/MultiFormatReader.cpp
index 27e7f31311..fedc9e3a99 100644
--- a/core/src/MultiFormatReader.cpp
+++ b/core/src/MultiFormatReader.cpp
@@ -46,30 +46,32 @@ MultiFormatReader::MultiFormatReader(const ReaderOptions& opts) : _opts(opts)
 
 MultiFormatReader::~MultiFormatReader() = default;
 
-Result
-MultiFormatReader::read(const BinaryBitmap& image) const
+Barcode MultiFormatReader::read(const BinaryBitmap& image) const
 {
-	Result r;
+	Barcode r;
 	for (const auto& reader : _readers) {
 		r = reader->decode(image);
   		if (r.isValid())
 			return r;
 	}
-	return _opts.returnErrors() ? r : Result();
+	return _opts.returnErrors() ? r : Barcode();
 }
 
-Results MultiFormatReader::readMultiple(const BinaryBitmap& image, int maxSymbols) const
+Barcodes MultiFormatReader::readMultiple(const BinaryBitmap& image, int maxSymbols) const
 {
-	std::vector<Result> res;
+	Barcodes res;
 
 	for (const auto& reader : _readers) {
 		if (image.inverted() && !reader->supportsInversion)
 			continue;
 		auto r = reader->decode(image, maxSymbols);
 		if (!_opts.returnErrors()) {
-			//TODO: C++20 res.erase_if()
-			auto it = std::remove_if(res.begin(), res.end(), [](auto&& r) { return !r.isValid(); });
-			res.erase(it, res.end());
+#ifdef __cpp_lib_erase_if
+			std::erase_if(r, [](auto&& s) { return !s.isValid(); });
+#else
+			auto it = std::remove_if(r.begin(), r.end(), [](auto&& s) { return !s.isValid(); });
+			r.erase(it, r.end());
+#endif
 		}
 		maxSymbols -= Size(r);
 		res.insert(res.end(), std::move_iterator(r.begin()), std::move_iterator(r.end()));
@@ -77,8 +79,8 @@ Results MultiFormatReader::readMultiple(const BinaryBitmap& image, int maxSymbol
 			break;
 	}
 
-	// sort results based on their position on the image
-	std::sort(res.begin(), res.end(), [](const Result& l, const Result& r) {
+	// sort barcodes based on their position on the image
+	std::sort(res.begin(), res.end(), [](const Barcode& l, const Barcode& r) {
 		auto lp = l.position().topLeft();
 		auto rp = r.position().topLeft();
 		return lp.y < rp.y || (lp.y == rp.y && lp.x < rp.x);
diff --git a/core/src/MultiFormatReader.h b/core/src/MultiFormatReader.h
index fe7749b525..17e3229e7a 100644
--- a/core/src/MultiFormatReader.h
+++ b/core/src/MultiFormatReader.h
@@ -6,14 +6,13 @@
 
 #pragma once
 
-#include "Result.h"
+#include "Barcode.h"
 
 #include <vector>
 #include <memory>
 
 namespace ZXing {
 
-class Result;
 class Reader;
 class BinaryBitmap;
 class ReaderOptions;
@@ -25,10 +24,10 @@ class MultiFormatReader
 	explicit MultiFormatReader(ReaderOptions&& opts) = delete;
 	~MultiFormatReader();
 
-	Result read(const BinaryBitmap& image) const;
+	Barcode read(const BinaryBitmap& image) const;
 
 	// WARNING: this API is experimental and may change/disappear
-	Results readMultiple(const BinaryBitmap& image, int maxSymbols = 0xFF) const;
+	Barcodes readMultiple(const BinaryBitmap& image, int maxSymbols = 0xFF) const;
 
 private:
 	std::vector<std::unique_ptr<Reader>> _readers;
diff --git a/core/src/Pattern.h b/core/src/Pattern.h
index f4d377fc4c..891060b45e 100644
--- a/core/src/Pattern.h
+++ b/core/src/Pattern.h
@@ -15,7 +15,6 @@
 #include <cstddef>
 #include <cstdint>
 #include <limits>
-#include <numeric>
 #include <vector>
 
 namespace ZXing {
@@ -59,13 +58,13 @@ class PatternView
 		return _data[i];
 	}
 
-	int sum(int n = 0) const { return std::accumulate(_data, _data + (n == 0 ? _size : n), 0); }
+	int sum(int n = 0) const { return Reduce(_data, _data + (n == 0 ? _size : n)); }
 	int size() const { return _size; }
 
 	// index is the number of bars and spaces from the first bar to the current position
 	int index() const { return narrow_cast<int>(_data - _base) - 1; }
-	int pixelsInFront() const { return std::accumulate(_base, _data, 0); }
-	int pixelsTillEnd() const { return std::accumulate(_base, _data + _size, 0) - 1; }
+	int pixelsInFront() const { return Reduce(_base, _data); }
+	int pixelsTillEnd() const { return Reduce(_base, _data + _size) - 1; }
 	bool isAtFirstBar() const { return _data == _base + 1; }
 	bool isAtLastBar() const { return _data + _size == _end - 1; }
 	bool isValid(int n) const { return _data && _data >= _base && _data + n <= _end; }
@@ -139,7 +138,7 @@ struct BarAndSpace
 
 using BarAndSpaceI = BarAndSpace<PatternType>;
 
-template <int LEN, typename T, typename RT = T>
+template <int LEN, typename RT, typename T>
 constexpr auto BarAndSpaceSum(const T* view) noexcept
 {
 	BarAndSpace<RT> res;
@@ -163,22 +162,20 @@ struct FixedPattern
 	constexpr value_type operator[](int i) const noexcept { return _data[i]; }
 	constexpr const value_type* data() const noexcept { return _data; }
 	constexpr int size() const noexcept { return N; }
-	constexpr BarAndSpace<value_type> sums() const noexcept { return BarAndSpaceSum<N>(_data); }
+	constexpr BarAndSpace<value_type> sums() const noexcept { return BarAndSpaceSum<N, value_type>(_data); }
 };
 
 template <int N, int SUM>
 using FixedSparcePattern = FixedPattern<N, SUM, true>;
 
 template <bool E2E = false, int LEN, int SUM>
-float IsPattern(const PatternView& view, const FixedPattern<LEN, SUM, false>& pattern, int spaceInPixel = 0,
-				float minQuietZone = 0, float moduleSizeRef = 0)
+double IsPattern(const PatternView& view, const FixedPattern<LEN, SUM, false>& pattern, int spaceInPixel = 0,
+				double minQuietZone = 0, double moduleSizeRef = 0)
 {
 	if constexpr (E2E) {
-		using float_t = double;
-
-		auto widths = BarAndSpaceSum<LEN, PatternView::value_type, float_t>(view.data());
+		auto widths = BarAndSpaceSum<LEN, double>(view.data());
 		auto sums = pattern.sums();
-		BarAndSpace<float_t> modSize = {widths[0] / sums[0], widths[1] / sums[1]};
+		BarAndSpace<double> modSize = {widths[0] / sums[0], widths[1] / sums[1]};
 
 		auto [m, M] = std::minmax(modSize[0], modSize[1]);
 		if (M > 4 * m) // make sure module sizes of bars and spaces are not too far away from each other
@@ -187,21 +184,20 @@ float IsPattern(const PatternView& view, const FixedPattern<LEN, SUM, false>& pa
 		if (minQuietZone && spaceInPixel < minQuietZone * modSize.space)
 			return 0;
 
-		const BarAndSpace<float_t> thr = {modSize[0] * .75 + .5, modSize[1] / (2 + (LEN < 6)) + .5};
+		const BarAndSpace<double> thr = {modSize[0] * .75 + .5, modSize[1] / (2 + (LEN < 6)) + .5};
 
 		for (int x = 0; x < LEN; ++x)
 			if (std::abs(view[x] - pattern[x] * modSize[x]) > thr[x])
 				return 0;
 
-		const float_t moduleSize = (modSize[0] + modSize[1]) / 2;
-		return moduleSize;
+		return (modSize[0] + modSize[1]) / 2;
 	}
 
-	int width = view.sum(LEN);
+	double width = view.sum(LEN);
 	if (SUM > LEN && width < SUM)
 		return 0;
 
-	const float moduleSize = (float)width / SUM;
+	const auto moduleSize = width / SUM;
 
 	if (minQuietZone && spaceInPixel < minQuietZone * moduleSize - 1)
 		return 0;
@@ -211,7 +207,7 @@ float IsPattern(const PatternView& view, const FixedPattern<LEN, SUM, false>& pa
 
 	// the offset of 0.5 is to make the code less sensitive to quantization errors for small (near 1) module sizes.
 	// TODO: review once we have upsampling in the binarizer in place.
-	const float threshold = moduleSizeRef * (0.5f + E2E * 0.25f) + 0.5f;
+	const auto threshold = moduleSizeRef * (0.5 + E2E * 0.25) + 0.5;
 
 	for (int x = 0; x < LEN; ++x)
 		if (std::abs(view[x] - pattern[x] * moduleSizeRef) > threshold)
@@ -221,15 +217,15 @@ float IsPattern(const PatternView& view, const FixedPattern<LEN, SUM, false>& pa
 }
 
 template <bool RELAXED_THRESHOLD = false, int N, int SUM>
-float IsPattern(const PatternView& view, const FixedPattern<N, SUM, true>& pattern, int spaceInPixel = 0,
-				float minQuietZone = 0, float moduleSizeRef = 0)
+double IsPattern(const PatternView& view, const FixedPattern<N, SUM, true>& pattern, int spaceInPixel = 0,
+				 double minQuietZone = 0, double moduleSizeRef = 0)
 {
 	// pattern contains the indices with the bars/spaces that need to be equally wide
-	int width = 0;
+	double width = 0;
 	for (int x = 0; x < SUM; ++x)
 		width += view[pattern[x]];
 
-	const float moduleSize = (float)width / SUM;
+	const auto moduleSize = width / SUM;
 
 	if (minQuietZone && spaceInPixel < minQuietZone * moduleSize - 1)
 		return 0;
@@ -239,7 +235,7 @@ float IsPattern(const PatternView& view, const FixedPattern<N, SUM, true>& patte
 
 	// the offset of 0.5 is to make the code less sensitive to quantization errors for small (near 1) module sizes.
 	// TODO: review once we have upsampling in the binarizer in place.
-	const float threshold = moduleSizeRef * (0.5f + RELAXED_THRESHOLD * 0.25f) + 0.5f;
+	const auto threshold = moduleSizeRef * (0.5 + RELAXED_THRESHOLD * 0.25) + 0.5;
 
 	for (int x = 0; x < SUM; ++x)
 		if (std::abs(view[pattern[x]] - moduleSizeRef) > threshold)
@@ -249,8 +245,8 @@ float IsPattern(const PatternView& view, const FixedPattern<N, SUM, true>& patte
 }
 
 template <int N, int SUM, bool IS_SPARCE>
-bool IsRightGuard(const PatternView& view, const FixedPattern<N, SUM, IS_SPARCE>& pattern, float minQuietZone,
-				  float moduleSizeRef = 0.f)
+bool IsRightGuard(const PatternView& view, const FixedPattern<N, SUM, IS_SPARCE>& pattern, double minQuietZone,
+				  double moduleSizeRef = 0)
 {
 	int spaceInPixel = view.isAtLastBar() ? std::numeric_limits<int>::max() : *view.end();
 	return IsPattern(view, pattern, spaceInPixel, minQuietZone, moduleSizeRef) != 0;
@@ -274,7 +270,7 @@ PatternView FindLeftGuard(const PatternView& view, int minSize, Pred isGuard)
 
 template <int LEN, int SUM, bool IS_SPARCE>
 PatternView FindLeftGuard(const PatternView& view, int minSize, const FixedPattern<LEN, SUM, IS_SPARCE>& pattern,
-						  float minQuietZone)
+						  double minQuietZone)
 {
 	return FindLeftGuard<LEN>(view, std::max(minSize, LEN),
 							  [&pattern, minQuietZone](const PatternView& window, int spaceInPixel) {
@@ -282,15 +278,16 @@ PatternView FindLeftGuard(const PatternView& view, int minSize, const FixedPatte
 							  });
 }
 
-template <int LEN, int SUM>
-std::array<int, LEN - 2> NormalizedE2EPattern(const PatternView& view)
+template <int LEN>
+std::array<int, LEN - 2> NormalizedE2EPattern(const PatternView& view, int mods, bool reverse = false)
 {
-	float moduleSize = static_cast<float>(view.sum(LEN)) / SUM;
+	double moduleSize = static_cast<double>(view.sum(LEN)) / mods;
 	std::array<int, LEN - 2> e2e;
 
 	for (int i = 0; i < LEN - 2; i++) {
-		float v = (view[i] + view[i + 1]) / moduleSize;
-		e2e[i] = int(v + .5f);
+		int i_v = reverse ? LEN - 2 - i : i;
+		double v = (view[i_v] + view[i_v + 1]) / moduleSize;
+		e2e[i] = int(v + .5);
 	}
 
 	return e2e;
@@ -299,13 +296,14 @@ std::array<int, LEN - 2> NormalizedE2EPattern(const PatternView& view)
 template <int LEN, int SUM>
 std::array<int, LEN> NormalizedPattern(const PatternView& view)
 {
-	float moduleSize = static_cast<float>(view.sum(LEN)) / SUM;
+	double moduleSize = static_cast<double>(view.sum(LEN)) / SUM;
+#if 1
 	int err = SUM;
 	std::array<int, LEN> is;
-	std::array<float, LEN> rs;
+	std::array<double, LEN> rs;
 	for (int i = 0; i < LEN; i++) {
-		float v = view[i] / moduleSize;
-		is[i] = int(v + .5f);
+		double v = view[i] / moduleSize;
+		is[i] = int(v + .5);
 		rs[i] = v - is[i];
 		err -= is[i];
 	}
@@ -319,7 +317,25 @@ std::array<int, LEN> NormalizedPattern(const PatternView& view)
 		is[mi] += err;
 		rs[mi] -= err;
 	}
+#else
+	std::array<int, LEN> is, e2e;
+	int min_v = view[0], min_i = 0;
+
+	for (int i = 1; i < LEN; i++) {
+		double v = (view[i - 1] + view[i]) / moduleSize;
+		e2e[i] = int(v + .5);
+		if (view[i] < min_v) {
+			min_v = view[i];
+			min_i = i;
+		}
+	}
 
+	is[min_i] = 1;
+	for (int i = min_i + 1; i < LEN; ++i)
+		is[i] = e2e[i] - is[i - 1];
+	for (int i = min_i - 1; i >= 0; --i)
+		is[i] = e2e[i + 1] - is[i + 1];
+#endif
 	return is;
 }
 
diff --git a/core/src/Point.h b/core/src/Point.h
index 19e1366099..e1146f8056 100644
--- a/core/src/Point.h
+++ b/core/src/Point.h
@@ -6,7 +6,6 @@
 #pragma once
 
 #include <algorithm>
-#include <cassert>
 #include <cmath>
 
 namespace ZXing {
diff --git a/core/src/Quadrilateral.h b/core/src/Quadrilateral.h
index 3e339bb61c..7f557daf17 100644
--- a/core/src/Quadrilateral.h
+++ b/core/src/Quadrilateral.h
@@ -10,6 +10,7 @@
 
 #include <array>
 #include <cmath>
+#include <string>
 
 namespace ZXing {
 
@@ -152,7 +153,7 @@ bool HaveIntersectingBoundingBoxes(const Quadrilateral<PointT>& a, const Quadril
 template <typename PointT>
 Quadrilateral<PointT> Blend(const Quadrilateral<PointT>& a, const Quadrilateral<PointT>& b)
 {
-	auto dist2First = [c = a[0]](auto a, auto b) { return distance(a, c) < distance(b, c); };
+	auto dist2First = [r = a[0]](auto s, auto t) { return distance(s, r) < distance(t, r); };
 	// rotate points such that the the two topLeft points are closest to each other
 	auto offset = std::min_element(b.begin(), b.end(), dist2First) - b.begin();
 
@@ -163,5 +164,14 @@ Quadrilateral<PointT> Blend(const Quadrilateral<PointT>& a, const Quadrilateral<
 	return res;
 }
 
+template <typename T>
+std::string ToString(const Quadrilateral<PointT<T>>& points)
+{
+	std::string res;
+	for (const auto& p : points)
+		res += std::to_string(p.x) + "x" + std::to_string(p.y) + (&p == &points.back() ? "" : " ");
+	return res;
+}
+
 } // ZXing
 
diff --git a/core/src/ReadBarcode.cpp b/core/src/ReadBarcode.cpp
index 43269e0c6d..88c0ac2e20 100644
--- a/core/src/ReadBarcode.cpp
+++ b/core/src/ReadBarcode.cpp
@@ -5,12 +5,17 @@
 
 #include "ReadBarcode.h"
 
-#include "ReaderOptions.h"
+#if !defined(ZXING_READERS) && !defined(ZXING_WRITERS)
+#include "Version.h"
+#endif
+
+#ifdef ZXING_READERS
 #include "GlobalHistogramBinarizer.h"
 #include "HybridBinarizer.h"
 #include "MultiFormatReader.h"
 #include "Pattern.h"
 #include "ThresholdBinarizer.h"
+#endif
 
 #include <climits>
 #include <memory>
@@ -18,18 +23,14 @@
 
 namespace ZXing {
 
-class LumImage : public ImageView
-{
-	std::unique_ptr<uint8_t[]> _memory;
-	LumImage(std::unique_ptr<uint8_t[]>&& data, int w, int h)
-		: ImageView(data.get(), w, h, ImageFormat::Lum), _memory(std::move(data))
-	{}
+#ifdef ZXING_READERS
 
+class LumImage : public Image
+{
 public:
-	LumImage() : ImageView(nullptr, 0, 0, ImageFormat::Lum) {}
-	LumImage(int w, int h) : LumImage(std::make_unique<uint8_t[]>(w * h), w, h) {}
+	using Image::Image;
 
-	uint8_t* data() { return _memory.get(); }
+	uint8_t* data() { return const_cast<uint8_t*>(Image::data()); }
 };
 
 template<typename P>
@@ -84,6 +85,9 @@ class LumImagePyramid
 
 	LumImagePyramid(const ImageView& iv, int threshold, int factor)
 	{
+		if (factor < 2)
+			throw std::invalid_argument("Invalid ReaderOptions::downscaleFactor");
+
 		layers.push_back(iv);
 		// TODO: if only matrix codes were considered, then using std::min would be sufficient (see #425)
 		while (threshold > 0 && std::max(layers.back().width(), layers.back().height()) > threshold &&
@@ -104,7 +108,14 @@ ImageView SetupLumImageView(ImageView iv, LumImage& lum, const ReaderOptions& op
 		throw std::invalid_argument("Invalid image format");
 
 	if (opts.binarizer() == Binarizer::GlobalHistogram || opts.binarizer() == Binarizer::LocalAverage) {
-		if (iv.format() != ImageFormat::Lum) {
+		// manually spell out the 3 most common pixel formats to get at least gcc to vectorize the code
+		if (iv.format() == ImageFormat::RGB && iv.pixStride() == 3) {
+			lum = ExtractLum(iv, [](const uint8_t* src) { return RGBToLum(src[0], src[1], src[2]); });
+		} else if (iv.format() == ImageFormat::RGBA && iv.pixStride() == 4) {
+			lum = ExtractLum(iv, [](const uint8_t* src) { return RGBToLum(src[0], src[1], src[2]); });
+		} else if (iv.format() == ImageFormat::BGR && iv.pixStride() == 3) {
+			lum = ExtractLum(iv, [](const uint8_t* src) { return RGBToLum(src[2], src[1], src[0]); });
+		} else if (iv.format() != ImageFormat::Lum) {
 			lum = ExtractLum(iv, [r = RedIndex(iv.format()), g = GreenIndex(iv.format()), b = BlueIndex(iv.format())](
 									 const uint8_t* src) { return RGBToLum(src[r], src[g], src[b]); });
 		} else if (iv.pixStride() != 1) {
@@ -128,35 +139,38 @@ std::unique_ptr<BinaryBitmap> CreateBitmap(ZXing::Binarizer binarizer, const Ima
 	return {}; // silence gcc warning
 }
 
-Result ReadBarcode(const ImageView& _iv, const ReaderOptions& opts)
+Barcode ReadBarcode(const ImageView& _iv, const ReaderOptions& opts)
 {
 	return FirstOrDefault(ReadBarcodes(_iv, ReaderOptions(opts).setMaxNumberOfSymbols(1)));
 }
 
-Results ReadBarcodes(const ImageView& _iv, const ReaderOptions& opts)
+Barcodes ReadBarcodes(const ImageView& _iv, const ReaderOptions& opts)
 {
-	if (sizeof(PatternType) < 4 && opts.hasFormat(BarcodeFormat::LinearCodes) && (_iv.width() > 0xffff || _iv.height() > 0xffff))
-		throw std::invalid_argument("maximum image width/height is 65535");
+	if (sizeof(PatternType) < 4 && (_iv.width() > 0xffff || _iv.height() > 0xffff))
+		throw std::invalid_argument("Maximum image width/height is 65535");
+
+	if (!_iv.data() || _iv.width() * _iv.height() == 0)
+		throw std::invalid_argument("ImageView is null/empty");
 
 	LumImage lum;
 	ImageView iv = SetupLumImageView(_iv, lum, opts);
 	MultiFormatReader reader(opts);
 
 	if (opts.isPure())
-		return {reader.read(*CreateBitmap(opts.binarizer(), iv))};
+		return {reader.read(*CreateBitmap(opts.binarizer(), iv)).setReaderOptions(opts)};
 
 	std::unique_ptr<MultiFormatReader> closedReader;
-#ifdef ZXING_BUILD_EXPERIMENTAL_API
+#ifdef ZXING_EXPERIMENTAL_API
 	auto formatsBenefittingFromClosing = BarcodeFormat::Aztec | BarcodeFormat::DataMatrix | BarcodeFormat::QRCode | BarcodeFormat::MicroQRCode;
 	ReaderOptions closedOptions = opts;
-	if (opts.tryDenoise() && opts.hasFormat(formatsBenefittingFromClosing)) {
+	if (opts.tryDenoise() && opts.hasFormat(formatsBenefittingFromClosing) && _iv.height() >= 3) {
 		closedOptions.setFormats((opts.formats().empty() ? BarcodeFormat::Any : opts.formats()) & formatsBenefittingFromClosing);
 		closedReader = std::make_unique<MultiFormatReader>(closedOptions);
 	}
 #endif
 	LumImagePyramid pyramid(iv, opts.downscaleThreshold() * opts.tryDownscale(), opts.downscaleFactor());
 
-	Results results;
+	Barcodes res;
 	int maxSymbols = opts.maxNumberOfSymbols() ? opts.maxNumberOfSymbols() : INT_MAX;
 	for (auto&& iv : pyramid.layers) {
 		auto bitmap = CreateBitmap(opts.binarizer(), iv);
@@ -172,20 +186,34 @@ Results ReadBarcodes(const ImageView& _iv, const ReaderOptions& opts)
 				for (auto& r : rs) {
 					if (iv.width() != _iv.width())
 						r.setPosition(Scale(r.position(), _iv.width() / iv.width()));
-					if (!Contains(results, r)) {
+					if (!Contains(res, r)) {
 						r.setReaderOptions(opts);
 						r.setIsInverted(bitmap->inverted());
-						results.push_back(std::move(r));
+						res.push_back(std::move(r));
 						--maxSymbols;
 					}
 				}
 				if (maxSymbols <= 0)
-					return results;
+					return res;
 			}
 		}
 	}
 
-	return results;
+	return res;
+}
+
+#else // ZXING_READERS
+
+Barcode ReadBarcode(const ImageView&, const ReaderOptions&)
+{
+	throw std::runtime_error("This build of zxing-cpp does not support reading barcodes.");
+}
+
+Barcodes ReadBarcodes(const ImageView&, const ReaderOptions&)
+{
+	throw std::runtime_error("This build of zxing-cpp does not support reading barcodes.");
 }
 
+#endif // ZXING_READERS
+
 } // ZXing
diff --git a/core/src/ReadBarcode.h b/core/src/ReadBarcode.h
index 343ac8487b..d932398ad7 100644
--- a/core/src/ReadBarcode.h
+++ b/core/src/ReadBarcode.h
@@ -7,7 +7,7 @@
 
 #include "ReaderOptions.h"
 #include "ImageView.h"
-#include "Result.h"
+#include "Barcode.h"
 
 namespace ZXing {
 
@@ -16,18 +16,18 @@ namespace ZXing {
  *
  * @param image  view of the image data including layout and format
  * @param options  optional ReaderOptions to parameterize / speed up detection
- * @return #Result structure
+ * @return #Barcode structure
  */
-Result ReadBarcode(const ImageView& image, const ReaderOptions& options = {});
+Barcode ReadBarcode(const ImageView& image, const ReaderOptions& options = {});
 
 /**
  * Read barcodes from an ImageView
  *
  * @param image  view of the image data including layout and format
  * @param options  optional ReaderOptions to parameterize / speed up detection
- * @return #Results list of results found, may be empty
+ * @return #Barcodes  list of barcodes found, may be empty
  */
-Results ReadBarcodes(const ImageView& image, const ReaderOptions& options = {});
+Barcodes ReadBarcodes(const ImageView& image, const ReaderOptions& options = {});
 
 } // ZXing
 
diff --git a/core/src/Reader.h b/core/src/Reader.h
index 7ece21b56d..fdac2d02cf 100644
--- a/core/src/Reader.h
+++ b/core/src/Reader.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #include "ReaderOptions.h"
-#include "Result.h"
+#include "Barcode.h"
 
 namespace ZXing {
 
@@ -26,12 +26,12 @@ class Reader
 	explicit Reader(ReaderOptions&& opts) = delete;
 	virtual ~Reader() = default;
 
-	virtual Result decode(const BinaryBitmap& image) const = 0;
+	virtual Barcode decode(const BinaryBitmap& image) const = 0;
 
 	// WARNING: this API is experimental and may change/disappear
-	virtual Results decode(const BinaryBitmap& image, [[maybe_unused]] int maxSymbols) const {
+	virtual Barcodes decode(const BinaryBitmap& image, [[maybe_unused]] int maxSymbols) const {
 		auto res = decode(image);
-		return res.isValid() || (_opts.returnErrors() && res.format() != BarcodeFormat::None) ? Results{std::move(res)} : Results{};
+		return res.isValid() || (_opts.returnErrors() && res.format() != BarcodeFormat::None) ? Barcodes{std::move(res)} : Barcodes{};
 	}
 };
 
diff --git a/core/src/ReaderOptions.h b/core/src/ReaderOptions.h
index 3b4cabfa9e..97c1bb0b9e 100644
--- a/core/src/ReaderOptions.h
+++ b/core/src/ReaderOptions.h
@@ -63,7 +63,7 @@ class ReaderOptions
 	Binarizer _binarizer           : 2;
 	TextMode _textMode             : 3;
 	CharacterSet _characterSet     : 6;
-#ifdef ZXING_BUILD_EXPERIMENTAL_API
+#ifdef ZXING_EXPERIMENTAL_API
 	bool _tryDenoise               : 1;
 #endif
 
@@ -80,26 +80,26 @@ class ReaderOptions
 		  _tryInvert(1),
 		  _tryDownscale(1),
 		  _isPure(0),
-		  _tryCode39ExtendedMode(0),
+		  _tryCode39ExtendedMode(1),
 		  _validateCode39CheckSum(0),
 		  _validateITFCheckSum(0),
-		  _returnCodabarStartEnd(0),
+		  _returnCodabarStartEnd(1),
 		  _returnErrors(0),
 		  _downscaleFactor(3),
 		  _eanAddOnSymbol(EanAddOnSymbol::Ignore),
 		  _binarizer(Binarizer::LocalAverage),
 		  _textMode(TextMode::HRI),
 		  _characterSet(CharacterSet::Unknown)
-#ifdef ZXING_BUILD_EXPERIMENTAL_API
+#ifdef ZXING_EXPERIMENTAL_API
 		  ,
 		  _tryDenoise(0)
 #endif
 	{}
 
-#define ZX_PROPERTY(TYPE, GETTER, SETTER) \
+#define ZX_PROPERTY(TYPE, GETTER, SETTER, ...) \
 	TYPE GETTER() const noexcept { return _##GETTER; } \
-	ReaderOptions& SETTER(TYPE v)& { return (void)(_##GETTER = std::move(v)), *this; } \
-	ReaderOptions&& SETTER(TYPE v)&& { return (void)(_##GETTER = std::move(v)), std::move(*this); }
+	__VA_ARGS__ ReaderOptions& SETTER(TYPE v)& { return (void)(_##GETTER = std::move(v)), *this; } \
+	__VA_ARGS__ ReaderOptions&& SETTER(TYPE v)&& { return (void)(_##GETTER = std::move(v)), std::move(*this); }
 
 	/// Specify a set of BarcodeFormats that should be searched for, the default is all supported formats.
 	ZX_PROPERTY(BarcodeFormats, formats, setFormats)
@@ -116,7 +116,7 @@ class ReaderOptions
 	/// Also try detecting code in downscaled images (depending on image size).
 	ZX_PROPERTY(bool, tryDownscale, setTryDownscale)
 
-#ifdef ZXING_BUILD_EXPERIMENTAL_API
+#ifdef ZXING_EXPERIMENTAL_API
 	/// Also try detecting code after denoising (currently morphological closing filter for 2D symbologies only).
 	ZX_PROPERTY(bool, tryDenoise, setTryDenoise)
 #endif
@@ -141,25 +141,25 @@ class ReaderOptions
 	/// The maximum number of symbols (barcodes) to detect / look for in the image with ReadBarcodes
 	ZX_PROPERTY(uint8_t, maxNumberOfSymbols, setMaxNumberOfSymbols)
 
-	/// If true, the Code-39 reader will try to read extended mode.
+	/// Enable the heuristic to detect and decode "full ASCII"/extended Code39 symbols
 	ZX_PROPERTY(bool, tryCode39ExtendedMode, setTryCode39ExtendedMode)
 
-	/// Assume Code-39 codes employ a check digit and validate it.
-	ZX_PROPERTY(bool, validateCode39CheckSum, setValidateCode39CheckSum)
+	/// Deprecated / does nothing. The Code39 symbol has a valid checksum iff symbologyIdentifier()[2] is an odd digit
+	ZX_PROPERTY(bool, validateCode39CheckSum, setValidateCode39CheckSum, [[deprecated]])
 
-	/// Assume ITF codes employ a GS1 check digit and validate it.
-	ZX_PROPERTY(bool, validateITFCheckSum, setValidateITFCheckSum)
+	/// Deprecated / does nothing. The ITF symbol has a valid checksum iff symbologyIdentifier()[2] == '1'.
+	ZX_PROPERTY(bool, validateITFCheckSum, setValidateITFCheckSum, [[deprecated]])
 
-	/// If true, return the start and end chars in a Codabar barcode instead of stripping them.
-	ZX_PROPERTY(bool, returnCodabarStartEnd, setReturnCodabarStartEnd)
+	/// Deprecated / does nothing. Codabar start/stop characters are always returned.
+	ZX_PROPERTY(bool, returnCodabarStartEnd, setReturnCodabarStartEnd, [[deprecated]])
 
-	/// If true, return the barcodes with errors as well (e.g. checksum errors, see @Result::error())
+	/// If true, return the barcodes with errors as well (e.g. checksum errors, see @Barcode::error())
 	ZX_PROPERTY(bool, returnErrors, setReturnErrors)
 
 	/// Specify whether to ignore, read or require EAN-2/5 add-on symbols while scanning EAN/UPC codes
 	ZX_PROPERTY(EanAddOnSymbol, eanAddOnSymbol, setEanAddOnSymbol)
 
-	/// Specifies the TextMode that controls the return of the Result::text() function
+	/// Specifies the TextMode that controls the return of the Barcode::text() function
 	ZX_PROPERTY(TextMode, textMode, setTextMode)
 
 	/// Specifies fallback character set to use instead of auto-detecting it (when applicable)
diff --git a/core/src/RegressionLine.h b/core/src/RegressionLine.h
index dac602ee9f..13571e1d18 100644
--- a/core/src/RegressionLine.h
+++ b/core/src/RegressionLine.h
@@ -10,7 +10,6 @@
 
 #include <algorithm>
 #include <cmath>
-#include <numeric>
 #include <vector>
 
 #ifdef PRINT_DEBUG
@@ -30,7 +29,7 @@ class RegressionLine
 
 	template<typename T> bool evaluate(const PointT<T>* begin, const PointT<T>* end)
 	{
-		auto mean = std::accumulate(begin, end, PointF()) / std::distance(begin, end);
+		auto mean = Reduce(begin, end, PointF()) / std::distance(begin, end);
 		PointF::value_t sumXX = 0, sumYY = 0, sumXY = 0;
 		for (auto p = begin; p != end; ++p) {
 			auto d = *p - mean;
@@ -79,7 +78,7 @@ class RegressionLine
 	auto signedDistance(PointF p) const { return dot(normal(), p) - c; }
 	template <typename T> auto distance(PointT<T> p) const { return std::abs(signedDistance(PointF(p))); }
 	PointF project(PointF p) const { return p - signedDistance(p) * normal(); }
-	PointF centroid() const { return std::accumulate(_points.begin(), _points.end(), PointF()) / _points.size(); }
+	PointF centroid() const { return Reduce(_points) / _points.size(); }
 
 	void reset()
 	{
@@ -112,11 +111,18 @@ class RegressionLine
 			while (true) {
 				auto old_points_size = points.size();
 				// remove points that are further 'inside' than maxSignedDist or further 'outside' than 2 x maxSignedDist
+#ifdef __cpp_lib_erase_if
+				std::erase_if(points, [this, maxSignedDist](auto p) {
+					auto sd = this->signedDistance(p);
+					return sd > maxSignedDist || sd < -2 * maxSignedDist;
+				});
+#else
 				auto end = std::remove_if(points.begin(), points.end(), [this, maxSignedDist](auto p) {
 					auto sd = this->signedDistance(p);
 					return sd > maxSignedDist || sd < -2 * maxSignedDist;
 				});
 				points.erase(end, points.end());
+#endif
 				// if we threw away too many points, something is off with the line to begin with
 				if (points.size() < old_points_size / 2 || points.size() < 2)
 					return false;
@@ -124,6 +130,7 @@ class RegressionLine
 					break;
 #ifdef PRINT_DEBUG
 				printf("removed %zu points -> %zu remaining\n", old_points_size - points.size(), points.size());
+				fflush(stdout);
 #endif
 				ret = evaluate(points);
 			}
diff --git a/core/src/Result.h b/core/src/Result.h
index 30a180f48e..6022ec72a8 100644
--- a/core/src/Result.h
+++ b/core/src/Result.h
@@ -1,183 +1,10 @@
 /*
-* Copyright 2016 Nu-book Inc.
-* Copyright 2016 ZXing authors
-* Copyright 2020 Axel Waggershauser
+* Copyright 2024 Axel Waggershauser
 */
 // SPDX-License-Identifier: Apache-2.0
 
 #pragma once
 
-#include "BarcodeFormat.h"
-#include "ByteArray.h"
-#include "Content.h"
-#include "ReaderOptions.h"
-#include "Error.h"
-#include "Quadrilateral.h"
-#include "StructuredAppend.h"
+#include "Barcode.h"
 
-#include <string>
-#include <vector>
-
-namespace ZXing {
-
-class DecoderResult;
-class ImageView;
-
-using Position = QuadrilateralI;
-
-/**
- * @brief The Result class encapsulates the result of decoding a barcode within an image.
- */
-class Result
-{
-	void setIsInverted(bool v) { _isInverted = v; }
-	Result& setReaderOptions(const ReaderOptions& opts);
-
-	friend Result MergeStructuredAppendSequence(const std::vector<Result>& results);
-	friend std::vector<Result> ReadBarcodes(const ImageView&, const ReaderOptions&);
-	friend void IncrementLineCount(Result&);
-
-public:
-	Result() = default;
-
-	// linear symbology convenience constructor
-	Result(const std::string& text, int y, int xStart, int xStop, BarcodeFormat format, SymbologyIdentifier si, Error error = {},
-		   bool readerInit = false);
-
-	Result(DecoderResult&& decodeResult, Position&& position, BarcodeFormat format);
-
-	bool isValid() const;
-
-	const Error& error() const { return _error; }
-
-	BarcodeFormat format() const { return _format; }
-
-	/**
-	 * @brief bytes is the raw / standard content without any modifications like character set conversions
-	 */
-	const ByteArray& bytes() const;
-
-	/**
-	 * @brief bytesECI is the raw / standard content following the ECI protocol
-	 */
-	ByteArray bytesECI() const;
-
-	/**
-	 * @brief text returns the bytes() content rendered to unicode/utf8 text accoring to specified TextMode
-	 */
-	std::string text(TextMode mode) const;
-
-	/**
-	 * @brief text returns the bytes() content rendered to unicode/utf8 text accoring to the TextMode set in the ReaderOptions
-	 */
-	std::string text() const;
-
-	/**
-	 * @brief ecLevel returns the error correction level of the symbol (empty string if not applicable)
-	 */
-	std::string ecLevel() const;
-
-	/**
-	 * @brief contentType gives a hint to the type of content found (Text/Binary/GS1/etc.)
-	 */
-	ContentType contentType() const;
-
-	/**
-	 * @brief hasECI specifies wheter or not an ECI tag was found
-	 */
-	bool hasECI() const;
-
-	const Position& position() const { return _position; }
-	void setPosition(Position pos) { _position = pos; }
-
-	/**
-	 * @brief orientation of barcode in degree, see also Position::orientation()
-	 */
-	int orientation() const;
-
-	/**
-	 * @brief isMirrored is the symbol mirrored (currently only supported by QRCode and DataMatrix)
-	 */
-	bool isMirrored() const { return _isMirrored; }
-
-	/**
-	 * @brief isInverted is the symbol inverted / has reveresed reflectance (see ReaderOptions::tryInvert)
-	 */
-	bool isInverted() const { return _isInverted; }
-
-	/**
-	 * @brief symbologyIdentifier Symbology identifier "]cm" where "c" is symbology code character, "m" the modifier.
-	 */
-	std::string symbologyIdentifier() const;
-
-	/**
-	 * @brief sequenceSize number of symbols in a structured append sequence.
-	 *
-	 * If this is not part of a structured append sequence, the returned value is -1.
-	 * If it is a structured append symbol but the total number of symbols is unknown, the
-	 * returned value is 0 (see PDF417 if optional "Segment Count" not given).
-	 */
-	int sequenceSize() const;
-
-	/**
-	 * @brief sequenceIndex the 0-based index of this symbol in a structured append sequence.
-	 */
-	int sequenceIndex() const;
-
-	/**
-	 * @brief sequenceId id to check if a set of symbols belongs to the same structured append sequence.
-	 *
-	 * If the symbology does not support this feature, the returned value is empty (see MaxiCode).
-	 * For QR Code, this is the parity integer converted to a string.
-	 * For PDF417 and DataMatrix, this is the "fileId".
-	 */
-	std::string sequenceId() const;
-
-	bool isLastInSequence() const { return sequenceSize() == sequenceIndex() + 1; }
-	bool isPartOfSequence() const { return sequenceSize() > -1 && sequenceIndex() > -1; }
-
-	/**
-	 * @brief readerInit Set if Reader Initialisation/Programming symbol.
-	 */
-	bool readerInit() const { return _readerInit; }
-
-	/**
-	 * @brief lineCount How many lines have been detected with this code (applies only to linear symbologies)
-	 */
-	int lineCount() const { return _lineCount; }
-
-	/**
-	 * @brief version QRCode / DataMatrix / Aztec version or size.
-	 */
-	std::string version() const;
-
-	bool operator==(const Result& o) const;
-
-private:
-	Content _content;
-	Error _error;
-	Position _position;
-	ReaderOptions _readerOpts;
-	StructuredAppendInfo _sai;
-	BarcodeFormat _format = BarcodeFormat::None;
-	char _ecLevel[4] = {};
-	char _version[4] = {};
-	int _lineCount = 0;
-	bool _isMirrored = false;
-	bool _isInverted = false;
-	bool _readerInit = false;
-};
-
-using Results = std::vector<Result>;
-
-/**
- * @brief Merge a list of Results from one Structured Append sequence to a single result
- */
-Result MergeStructuredAppendSequence(const Results& results);
-
-/**
- * @brief Automatically merge all Structured Append sequences found in the given results
- */
-Results MergeStructuredAppendSequences(const Results& results);
-
-} // ZXing
+#pragma message("Header `Result.h` is deprecated, please include `Barcode.h` and use the new name `Barcode`.")
diff --git a/core/src/TextUtfEncoding.h b/core/src/TextUtfEncoding.h
index a1940f047b..4eeff813cb 100644
--- a/core/src/TextUtfEncoding.h
+++ b/core/src/TextUtfEncoding.h
@@ -10,7 +10,7 @@
 
 namespace ZXing::TextUtfEncoding {
 
-// The following functions are not required anymore after Result::text() now returns utf8 natively and the encoders accept utf8 as well.
+// The following functions are not required anymore after Barcode::text() now returns utf8 natively and the encoders accept utf8 as well.
 
 [[deprecated]] std::string ToUtf8(std::wstring_view str);
 [[deprecated]] std::string ToUtf8(std::wstring_view str, const bool angleEscape);
diff --git a/core/src/WriteBarcode.cpp b/core/src/WriteBarcode.cpp
new file mode 100644
index 0000000000..8b26843959
--- /dev/null
+++ b/core/src/WriteBarcode.cpp
@@ -0,0 +1,486 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ZXING_EXPERIMENTAL_API
+
+#include "WriteBarcode.h"
+#include "BitMatrix.h"
+
+#if !defined(ZXING_READERS) && !defined(ZXING_WRITERS)
+#include "Version.h"
+#endif
+
+#include <sstream>
+
+#ifdef ZXING_USE_ZINT
+
+#include <zint.h>
+
+#else
+
+struct zint_symbol {};
+
+#endif // ZXING_USE_ZINT
+
+namespace ZXing {
+
+struct CreatorOptions::Data
+{
+	BarcodeFormat format;
+	bool readerInit = false;
+	bool forceSquareDataMatrix = false;
+	std::string ecLevel;
+
+	// symbol size (qrcode, datamatrix, etc), map from I, 'WxH'
+	// structured_append (idx, cnt, ID)
+
+	mutable unique_zint_symbol zint;
+
+#ifndef __cpp_aggregate_paren_init
+	Data(BarcodeFormat f) : format(f) {}
+#endif
+};
+
+#define ZX_PROPERTY(TYPE, NAME) \
+	TYPE CreatorOptions::NAME() const noexcept { return d->NAME; } \
+	CreatorOptions& CreatorOptions::NAME(TYPE v)& { return d->NAME = std::move(v), *this; } \
+	CreatorOptions&& CreatorOptions::NAME(TYPE v)&& { return d->NAME = std::move(v), std::move(*this); }
+
+	ZX_PROPERTY(BarcodeFormat, format)
+	ZX_PROPERTY(bool, readerInit)
+	ZX_PROPERTY(bool, forceSquareDataMatrix)
+	ZX_PROPERTY(std::string, ecLevel)
+
+#undef ZX_PROPERTY
+
+CreatorOptions::CreatorOptions(BarcodeFormat format) : d(std::make_unique<Data>(format)) {}
+CreatorOptions::~CreatorOptions() = default;
+CreatorOptions::CreatorOptions(CreatorOptions&&) = default;
+CreatorOptions& CreatorOptions::operator=(CreatorOptions&&) = default;
+
+
+struct WriterOptions::Data
+{
+	int scale = 0;
+	int sizeHint = 0;
+	int rotate = 0;
+	bool withHRT = false;
+	bool withQuietZones = true;
+};
+
+#define ZX_PROPERTY(TYPE, NAME) \
+	TYPE WriterOptions::NAME() const noexcept { return d->NAME; } \
+	WriterOptions& WriterOptions::NAME(TYPE v)& { return d->NAME = std::move(v), *this; } \
+	WriterOptions&& WriterOptions::NAME(TYPE v)&& { return d->NAME = std::move(v), std::move(*this); }
+
+ZX_PROPERTY(int, scale)
+ZX_PROPERTY(int, sizeHint)
+ZX_PROPERTY(int, rotate)
+ZX_PROPERTY(bool, withHRT)
+ZX_PROPERTY(bool, withQuietZones)
+
+#undef ZX_PROPERTY
+
+WriterOptions::WriterOptions() : d(std::make_unique<Data>()) {}
+WriterOptions::~WriterOptions() = default;
+WriterOptions::WriterOptions(WriterOptions&&) = default;
+WriterOptions& WriterOptions::operator=(WriterOptions&&) = default;
+
+static bool IsLinearCode(BarcodeFormat format)
+{
+	return BarcodeFormats(BarcodeFormat::LinearCodes).testFlag(format);
+}
+
+static std::string ToSVG(ImageView iv)
+{
+	if (!iv.data())
+		return {};
+
+	// see https://stackoverflow.com/questions/10789059/create-qr-code-in-vector-image/60638350#60638350
+
+	std::ostringstream res;
+
+	res << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+		<< "<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" viewBox=\"0 0 " << iv.width() << " " << iv.height()
+		<< "\" stroke=\"none\">\n"
+		<< "<path d=\"";
+
+	for (int y = 0; y < iv.height(); ++y)
+		for (int x = 0; x < iv.width(); ++x)
+			if (*iv.data(x, y) == 0)
+				res << "M" << x << "," << y << "h1v1h-1z";
+
+	res << "\"/>\n</svg>";
+
+	return res.str();
+}
+
+static Image ToImage(BitMatrix bits, bool isLinearCode, const WriterOptions& opts)
+{
+	bits.flipAll();
+	auto symbol = Inflate(std::move(bits), opts.sizeHint(),
+						  isLinearCode ? std::clamp(opts.sizeHint() / 2, 50, 300) : opts.sizeHint(),
+						  opts.withQuietZones() ? 10 : 0);
+	auto bitmap = ToMatrix<uint8_t>(symbol);
+	auto iv = Image(symbol.width(), symbol.height());
+	std::memcpy(const_cast<uint8_t*>(iv.data()), bitmap.data(), iv.width() * iv.height());
+	return iv;
+}
+
+} // namespace ZXing
+
+
+#ifdef ZXING_WRITERS
+
+#ifdef ZXING_USE_ZINT
+#include "ECI.h"
+#include "ReadBarcode.h"
+
+#include <charconv>
+#include <zint.h>
+
+namespace ZXing {
+
+struct BarcodeFormatZXing2Zint
+{
+	BarcodeFormat zxing;
+	int zint;
+};
+
+static constexpr BarcodeFormatZXing2Zint barcodeFormatZXing2Zint[] = {
+	{BarcodeFormat::Aztec, BARCODE_AZTEC},
+	{BarcodeFormat::Codabar, BARCODE_CODABAR},
+	{BarcodeFormat::Code39, BARCODE_CODE39},
+	{BarcodeFormat::Code93, BARCODE_CODE93},
+	{BarcodeFormat::Code128, BARCODE_CODE128},
+	{BarcodeFormat::DataBar, BARCODE_DBAR_OMN},
+	{BarcodeFormat::DataBarExpanded, BARCODE_DBAR_EXP},
+	{BarcodeFormat::DataBarLimited, BARCODE_DBAR_LTD},
+	{BarcodeFormat::DataMatrix, BARCODE_DATAMATRIX},
+	{BarcodeFormat::DXFilmEdge, BARCODE_DXFILMEDGE},
+	{BarcodeFormat::EAN8, BARCODE_EANX},
+	{BarcodeFormat::EAN13, BARCODE_EANX},
+	{BarcodeFormat::ITF, BARCODE_C25INTER},
+	{BarcodeFormat::MaxiCode, BARCODE_MAXICODE},
+	{BarcodeFormat::MicroQRCode, BARCODE_MICROQR},
+	{BarcodeFormat::PDF417, BARCODE_PDF417},
+	{BarcodeFormat::QRCode, BARCODE_QRCODE},
+	{BarcodeFormat::RMQRCode, BARCODE_RMQR},
+	{BarcodeFormat::UPCA, BARCODE_UPCA},
+	{BarcodeFormat::UPCE, BARCODE_UPCE},
+};
+
+struct String2Int
+{
+	const char* str;
+	int val;
+};
+
+static int ParseECLevel(int symbology, std::string_view s)
+{
+	constexpr std::string_view EC_LABELS_QR[4] = {"L", "M", "Q", "H"};
+
+	int res = 0;
+	if (Contains({BARCODE_QRCODE, BARCODE_MICROQR, BARCODE_RMQR}, symbology))
+		if ((res = IndexOf(EC_LABELS_QR, s) != -1))
+			return res + 1;
+
+	if (std::from_chars(s.data(), s.data() + s.size() - (s.back() == '%'), res).ec != std::errc{})
+		throw std::invalid_argument("Invalid ecLevel: '" + std::string(s) + "'");
+
+	auto findClosestECLevel = [](const std::vector<int>& list, int val) {
+		int mIdx = -2, mAbs = 100;
+		for (int i = 0; i < Size(list); ++i)
+		if (int abs = std::abs(val - list[i]); abs < mAbs) {
+				mIdx = i;
+				mAbs = abs;
+		}
+		return mIdx + 1;
+	};
+
+	if (s.back()=='%'){
+		switch (symbology) {
+		case BARCODE_QRCODE:
+		case BARCODE_MICROQR:
+		case BARCODE_RMQR:
+			return findClosestECLevel({20, 37, 55, 65}, res);
+		case BARCODE_AZTEC:
+			return findClosestECLevel({10, 23, 26, 50}, res);
+		case BARCODE_PDF417:
+			// TODO: do something sensible with PDF417?
+		default:
+			return -1;
+		}
+	}
+
+	return res;
+};
+
+zint_symbol* CreatorOptions::zint() const
+{
+	auto& zint = d->zint;
+
+	if (!zint) {
+#ifdef PRINT_DEBUG
+		printf("zint version: %d, sizeof(zint_symbol): %ld\n", ZBarcode_Version(), sizeof(zint_symbol));
+#endif
+		zint.reset(ZBarcode_Create());
+
+		auto i = FindIf(barcodeFormatZXing2Zint, [zxing = format()](auto& v) { return v.zxing == zxing; });
+		if (i == std::end(barcodeFormatZXing2Zint))
+			throw std::invalid_argument("unsupported barcode format: " + ToString(format()));
+		zint->symbology = i->zint;
+
+		zint->scale = 0.5f;
+
+		if (!ecLevel().empty())
+			zint->option_1 = ParseECLevel(zint->symbology, ecLevel());
+	}
+
+	return zint.get();
+}
+
+#define CHECK(ZINT_CALL) \
+	if (int err = (ZINT_CALL); err >= ZINT_ERROR) \
+		throw std::invalid_argument(zint->errtxt);
+
+Barcode CreateBarcode(const void* data, int size, int mode, const CreatorOptions& opts)
+{
+	auto zint = opts.zint();
+
+	zint->input_mode = mode;
+	zint->output_options |= OUT_BUFFER_INTERMEDIATE | BARCODE_QUIET_ZONES;
+
+	if (mode == DATA_MODE && ZBarcode_Cap(zint->symbology, ZINT_CAP_ECI))
+		zint->eci = static_cast<int>(ECI::Binary);
+
+	CHECK(ZBarcode_Encode_and_Buffer(zint, (uint8_t*)data, size, 0));
+
+#ifdef PRINT_DEBUG
+	printf("create symbol with size: %dx%d\n", zint->width, zint->rows);
+#endif
+
+#ifdef ZXING_READERS
+	auto buffer = std::vector<uint8_t>(zint->bitmap_width * zint->bitmap_height);
+	std::transform(zint->bitmap, zint->bitmap + zint->bitmap_width * zint->bitmap_height, buffer.data(),
+				   [](unsigned char v) { return (v == '0') * 0xff; });
+
+	auto res = ReadBarcode({buffer.data(), zint->bitmap_width, zint->bitmap_height, ImageFormat::Lum},
+						   ReaderOptions().setFormats(opts.format()).setIsPure(true).setBinarizer(Binarizer::BoolCast));
+#else
+	//TODO: replace by proper construction from encoded data from within zint
+	auto res = Barcode(std::string((const char*)data, size), 0, 0, 0, opts.format(), {});
+#endif
+
+	auto bits = BitMatrix(zint->bitmap_width, zint->bitmap_height);
+	std::transform(zint->bitmap, zint->bitmap + zint->bitmap_width * zint->bitmap_height, bits.row(0).begin(),
+				   [](unsigned char v) { return (v == '1') * BitMatrix::SET_V; });
+	res.symbol(std::move(bits));
+	res.zint(std::move(opts.d->zint));
+
+	return res;
+}
+
+Barcode CreateBarcodeFromText(std::string_view contents, const CreatorOptions& opts)
+{
+	return CreateBarcode(contents.data(), contents.size(), UNICODE_MODE, opts);
+}
+
+#if __cplusplus > 201703L
+Barcode CreateBarcodeFromText(std::u8string_view contents, const CreatorOptions& opts)
+{
+	return CreateBarcode(contents.data(), contents.size(), UNICODE_MODE, opts);
+}
+#endif
+
+Barcode CreateBarcodeFromBytes(const void* data, int size, const CreatorOptions& opts)
+{
+	return CreateBarcode(data, size, DATA_MODE, opts);
+}
+
+// Writer ========================================================================
+
+struct SetCommonWriterOptions
+{
+	zint_symbol* zint;
+
+	SetCommonWriterOptions(zint_symbol* zint, const WriterOptions& opts) : zint(zint)
+	{
+		zint->show_hrt = opts.withHRT();
+
+		zint->output_options &= ~OUT_BUFFER_INTERMEDIATE;
+		zint->output_options |= opts.withQuietZones() ? BARCODE_QUIET_ZONES : BARCODE_NO_QUIET_ZONES;
+
+		if (opts.scale())
+			zint->scale = opts.scale() / 2.f;
+		else if (opts.sizeHint()) {
+			int size = std::max(zint->width, zint->rows);
+			zint->scale = std::max(1, int(float(opts.sizeHint()) / size)) / 2.f;
+		}
+	}
+
+	// reset the defaults such that consecutive write calls don't influence each other
+	~SetCommonWriterOptions() { zint->scale = 0.5f; }
+};
+
+} // ZXing
+
+#else // ZXING_USE_ZINT
+
+#include "MultiFormatWriter.h"
+#include "ReadBarcode.h"
+
+namespace ZXing {
+
+zint_symbol* CreatorOptions::zint() const { return nullptr; }
+
+static Barcode CreateBarcode(BitMatrix&& bits, const CreatorOptions& opts)
+{
+	auto img = ToMatrix<uint8_t>(bits);
+
+	auto res = ReadBarcode({img.data(), img.width(), img.height(), ImageFormat::Lum},
+						   ReaderOptions().setFormats(opts.format()).setIsPure(true).setBinarizer(Binarizer::BoolCast));
+	res.symbol(std::move(bits));
+	return res;
+}
+
+Barcode CreateBarcodeFromText(std::string_view contents, const CreatorOptions& opts)
+{
+	auto writer = MultiFormatWriter(opts.format()).setMargin(0);
+	if (!opts.ecLevel().empty())
+		writer.setEccLevel(std::stoi(opts.ecLevel()));
+	writer.setEncoding(CharacterSet::UTF8); // write UTF8 (ECI value 26) for maximum compatibility
+
+	return CreateBarcode(writer.encode(std::string(contents), 0, IsLinearCode(opts.format()) ? 50 : 0), opts);
+}
+
+#if __cplusplus > 201703L
+Barcode CreateBarcodeFromText(std::u8string_view contents, const CreatorOptions& opts)
+{
+	return CreateBarcodeFromText({reinterpret_cast<const char*>(contents.data()), contents.size()}, opts);
+}
+#endif
+
+Barcode CreateBarcodeFromBytes(const void* data, int size, const CreatorOptions& opts)
+{
+	std::wstring bytes;
+	for (uint8_t c : std::basic_string_view<uint8_t>((uint8_t*)data, size))
+		bytes.push_back(c);
+
+	auto writer = MultiFormatWriter(opts.format()).setMargin(0);
+	if (!opts.ecLevel().empty())
+		writer.setEccLevel(std::stoi(opts.ecLevel()));
+	writer.setEncoding(CharacterSet::BINARY);
+
+	return CreateBarcode(writer.encode(bytes, 0, IsLinearCode(opts.format()) ? 50 : 0), opts);
+}
+
+} // namespace ZXing
+
+#endif // ZXING_USE_ZINT
+
+#else // ZXING_WRITERS
+
+namespace ZXing {
+
+zint_symbol* CreatorOptions::zint() const { return nullptr; }
+
+Barcode CreateBarcodeFromText(std::string_view, const CreatorOptions&)
+{
+	throw std::runtime_error("This build of zxing-cpp does not support creating barcodes.");
+}
+
+#if __cplusplus > 201703L
+Barcode CreateBarcodeFromText(std::u8string_view, const CreatorOptions&)
+{
+	throw std::runtime_error("This build of zxing-cpp does not support creating barcodes.");
+}
+#endif
+
+Barcode CreateBarcodeFromBytes(const void*, int, const CreatorOptions&)
+{
+	throw std::runtime_error("This build of zxing-cpp does not support creating barcodes.");
+}
+
+} // namespace ZXing
+
+#endif // ZXING_WRITERS
+
+namespace ZXing {
+
+std::string WriteBarcodeToSVG(const Barcode& barcode, [[maybe_unused]] const WriterOptions& opts)
+{
+	auto zint = barcode.zint();
+
+	if (!zint)
+		return ToSVG(barcode.symbol());
+
+#if defined(ZXING_WRITERS) && defined(ZXING_USE_ZINT)
+	auto resetOnExit = SetCommonWriterOptions(zint, opts);
+
+	zint->output_options |= BARCODE_MEMORY_FILE;// | EMBED_VECTOR_FONT;
+	strcpy(zint->outfile, "null.svg");
+
+	CHECK(ZBarcode_Print(zint, opts.rotate()));
+
+	return std::string(reinterpret_cast<const char*>(zint->memfile), zint->memfile_size);
+#else
+	return {}; // unreachable code
+#endif
+}
+
+Image WriteBarcodeToImage(const Barcode& barcode, [[maybe_unused]] const WriterOptions& opts)
+{
+	auto zint = barcode.zint();
+
+	if (!zint)
+		return ToImage(barcode._symbol->copy(), IsLinearCode(barcode.format()), opts);
+
+#if defined(ZXING_WRITERS) && defined(ZXING_USE_ZINT)
+	auto resetOnExit = SetCommonWriterOptions(zint, opts);
+
+	CHECK(ZBarcode_Buffer(zint, opts.rotate()));
+
+#ifdef PRINT_DEBUG
+	printf("write symbol with size: %dx%d\n", zint->bitmap_width, zint->bitmap_height);
+#endif
+	auto iv = Image(zint->bitmap_width, zint->bitmap_height);
+	auto* src = zint->bitmap;
+	auto* dst = const_cast<uint8_t*>(iv.data());
+	for(int y = 0; y < iv.height(); ++y)
+		for(int x = 0, w = iv.width(); x < w; ++x, src += 3)
+			*dst++ = RGBToLum(src[0], src[1], src[2]);
+
+	return iv;
+#else
+	return {}; // unreachable code
+#endif
+}
+
+std::string WriteBarcodeToUtf8(const Barcode& barcode, [[maybe_unused]] const WriterOptions& options)
+{
+	auto iv = barcode.symbol();
+	if (!iv.data())
+		return {};
+
+	constexpr auto map = std::array{" ", "▀", "▄", "█"};
+	std::ostringstream res;
+	bool inverted = false; // TODO: take from WriterOptions
+
+	for (int y = 0; y < iv.height(); y += 2) {
+		for (int x = 0; x < iv.width(); ++x) {
+			int tp = bool(*iv.data(x, y)) ^ inverted;
+			int bt = (iv.height() == 1 && tp) || (y + 1 < iv.height() && (bool(*iv.data(x, y + 1)) ^ inverted));
+			res << map[tp | (bt << 1)];
+		}
+		res << '\n';
+	}
+
+	return res.str();
+}
+
+} // namespace ZXing
+
+#endif // ZXING_EXPERIMENTAL_API
diff --git a/core/src/WriteBarcode.h b/core/src/WriteBarcode.h
new file mode 100644
index 0000000000..6f149b2523
--- /dev/null
+++ b/core/src/WriteBarcode.h
@@ -0,0 +1,144 @@
+/*
+* Copyright 2022 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#ifdef ZXING_EXPERIMENTAL_API
+
+#include "Barcode.h"
+#include "ImageView.h"
+
+#include <memory>
+#include <string_view>
+
+extern "C" struct zint_symbol;
+
+namespace ZXing {
+
+class CreatorOptions
+{
+	struct Data;
+
+	std::unique_ptr<Data> d;
+
+	friend Barcode CreateBarcode(const void* data, int size, int mode, const CreatorOptions& options);
+
+public:
+	CreatorOptions(BarcodeFormat format);
+
+	~CreatorOptions();
+	CreatorOptions(CreatorOptions&&);
+	CreatorOptions& operator=(CreatorOptions&&);
+
+	zint_symbol* zint() const;
+
+#define ZX_PROPERTY(TYPE, NAME) \
+	TYPE NAME() const noexcept; \
+	CreatorOptions& NAME(TYPE v)&; \
+	CreatorOptions&& NAME(TYPE v)&&;
+
+	ZX_PROPERTY(BarcodeFormat, format)
+	ZX_PROPERTY(bool, readerInit)
+	ZX_PROPERTY(bool, forceSquareDataMatrix)
+	ZX_PROPERTY(std::string, ecLevel)
+
+#undef ZX_PROPERTY
+};
+
+/**
+ * Generate barcode from unicode text
+ *
+ * @param contents  UTF-8 string to encode into a barcode
+ * @param options  CreatorOptions (including BarcodeFormat)
+ * @return #Barcode  generated barcode
+ */
+Barcode CreateBarcodeFromText(std::string_view contents, const CreatorOptions& options);
+
+/**
+ * Generate barcode from raw binary data
+ *
+ * @param data  array of bytes to encode into a barcode
+ * @param size  size of byte array
+ * @param options  CreatorOptions (including BarcodeFormat)
+ * @return #Barcode  generated barcode
+ */
+Barcode CreateBarcodeFromBytes(const void* data, int size, const CreatorOptions& options);
+
+#if __cplusplus > 201703L
+Barcode CreateBarcodeFromText(std::u8string_view contents, const CreatorOptions& options);
+
+template <typename R>
+requires std::ranges::contiguous_range<R> && std::ranges::sized_range<R> && (sizeof(std::ranges::range_value_t<R>) == 1)
+Barcode CreateBarcodeFromBytes(const R& contents, const CreatorOptions& options)
+{
+	return CreateBarcodeFromBytes(std::ranges::data(contents), std::ranges::size(contents), options);
+}
+#else
+template <typename R>
+Barcode CreateBarcodeFromBytes(const R& contents, const CreatorOptions& options)
+{
+	return CreateBarcodeFromBytes(std::data(contents), std::size(contents), options);
+}
+#endif
+
+// =================================================================================
+
+class WriterOptions
+{
+	struct Data;
+
+	std::unique_ptr<Data> d;
+
+public:
+	WriterOptions();
+	~WriterOptions();
+	WriterOptions(WriterOptions&&);
+	WriterOptions& operator=(WriterOptions&&);
+
+#define ZX_PROPERTY(TYPE, NAME) \
+	TYPE NAME() const noexcept; \
+	WriterOptions& NAME(TYPE v)&; \
+	WriterOptions&& NAME(TYPE v)&&;
+
+	ZX_PROPERTY(int, scale)
+	ZX_PROPERTY(int, sizeHint)
+	ZX_PROPERTY(int, rotate)
+	ZX_PROPERTY(bool, withHRT)
+	ZX_PROPERTY(bool, withQuietZones)
+
+#undef ZX_PROPERTY
+};
+
+
+/**
+ * Write barcode symbol to SVG
+ *
+ * @param barcode  Barcode to write
+ * @param options  WriterOptions to parameterize rendering
+ * @return std::string  SVG representation of barcode symbol
+ */
+std::string WriteBarcodeToSVG(const Barcode& barcode, const WriterOptions& options = {});
+
+/**
+ * Write barcode symbol to a utf8 string using graphical characters (e.g. '▀')
+ *
+ * @param barcode  Barcode to write
+ * @param options  WriterOptions to parameterize rendering
+ * @return std::string  Utf8 string representation of barcode symbol
+ */
+std::string WriteBarcodeToUtf8(const Barcode& barcode, const WriterOptions& options = {});
+
+/**
+ * Write barcode symbol to Image (Bitmap)
+ *
+ * @param barcode  Barcode to write
+ * @param options  WriterOptions to parameterize rendering
+ * @return Image  Bitmap reprentation of barcode symbol
+ */
+Image WriteBarcodeToImage(const Barcode& barcode, const WriterOptions& options = {});
+
+} // ZXing
+
+#endif // ZXING_EXPERIMENTAL_API
diff --git a/core/src/ZXAlgorithms.h b/core/src/ZXAlgorithms.h
index 3965ab0746..66898363eb 100644
--- a/core/src/ZXAlgorithms.h
+++ b/core/src/ZXAlgorithms.h
@@ -47,14 +47,24 @@ inline bool Contains(const char* str, char c) {
 }
 
 template <template <typename...> typename C, typename... Ts>
-auto FirstOrDefault(C<Ts...>&& results)
+auto FirstOrDefault(C<Ts...>&& container)
 {
-	return results.empty() ? typename C<Ts...>::value_type() : std::move(results.front());
+	return container.empty() ? typename C<Ts...>::value_type() : std::move(container.front());
+}
+
+template <typename Iterator, typename Value = typename std::iterator_traits<Iterator>::value_type, typename Op = std::plus<Value>>
+Value Reduce(Iterator b, Iterator e, Value v = Value{}, Op op = {}) {
+	// std::reduce() first sounded like a better implementation because it is not implemented as a strict left-fold
+	// operation, meaning the order of the op-application is not specified. This sounded like an optimization opportunity
+	// but it turns out that for this use case it actually does not make a difference (falsepositives runtime). And
+	// when tested with a large std::vector<uint16_t> and proper autovectorization (e.g. clang++ -O2) it turns out that
+	// std::accumulate can be twice as fast as std::reduce.
+	return std::accumulate(b, e, v, op);
 }
 
 template <typename Container, typename Value = typename Container::value_type, typename Op = std::plus<Value>>
 Value Reduce(const Container& c, Value v = Value{}, Op op = {}) {
-	return std::accumulate(std::begin(c), std::end(c), v, op);
+	return Reduce(std::begin(c), std::end(c), v, op);
 }
 
 // see C++20 ssize
diff --git a/core/src/ZXConfig.h b/core/src/ZXConfig.h
index 4e735558f5..d00d3df942 100644
--- a/core/src/ZXConfig.h
+++ b/core/src/ZXConfig.h
@@ -9,7 +9,7 @@
 // in e.g. the ReedSolomonDecoder. It is disabled by default. It can be enabled by modifying the following define.
 // Note: The Apple clang compiler until XCode 8 does not support c++11's thread_local.
 // The alternative 'static' makes the code thread unsafe.
-#define ZX_THREAD_LOCAL // '' (nothing), 'thread_local' or 'static'
+#define ZX_THREAD_LOCAL thread_local // '' (nothing), 'thread_local' or 'static'
 
 // The Galoir Field abstractions used in Reed-Solomon error correction code can use more memory to eliminate a modulo
 // operation. This improves performance but might not be the best option if RAM is scarce. The effect is a few kB big.
diff --git a/core/src/ZXVersion.h b/core/src/ZXVersion.h
new file mode 100644
index 0000000000..e7abadb28e
--- /dev/null
+++ b/core/src/ZXVersion.h
@@ -0,0 +1,10 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "Version.h"
+
+#pragma message("Header `ZXVersion.h` is deprecated, please include `Version.h`.")
diff --git a/core/src/ZXingC.cpp b/core/src/ZXingC.cpp
new file mode 100644
index 0000000000..9f2d342ecf
--- /dev/null
+++ b/core/src/ZXingC.cpp
@@ -0,0 +1,430 @@
+/*
+* Copyright 2023 siiky
+* Copyright 2023 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ZXingC.h"
+
+#include "ZXingCpp.h"
+
+#if __has_include("Version.h")
+#include "Version.h"
+#else // this is mainly a workaround for a missing autogenerated Version.h in the XCode/CocoaPods corner
+#define ZXING_VERSION_STR "undefined"
+#endif
+
+#include <cstdlib>
+#include <exception>
+#include <string>
+#include <string_view>
+#include <utility>
+
+using namespace ZXing;
+
+static thread_local std::string lastErrorMsg;
+static Barcodes emptyBarcodes{}; // used to prevent new heap allocation for each empty result
+
+template<typename R, typename T> R transmute_cast(const T& v) noexcept
+{
+	static_assert(sizeof(T) == sizeof(R));
+	return *(const R*)(&v);
+}
+
+template<typename C, typename P = typename C::pointer>
+P copy(const C& c) noexcept
+{
+	auto ret = (P)malloc(c.size() + 1);
+	if (ret) {
+		memcpy(ret, c.data(), c.size());
+		ret[c.size()] = 0;
+	}
+	return ret;
+}
+
+static uint8_t* copy(const ByteArray& ba, int* len) noexcept
+{
+	// for convencience and as a safety measure, we NULL terminate even byte arrays
+	auto ret = copy(ba);
+	if (len)
+		*len = ret ? Size(ba) : 0;
+	return ret;
+}
+
+#define ZX_CHECK( GOOD, MSG ) \
+	if (!(GOOD)) { \
+		lastErrorMsg = MSG; \
+		return {}; \
+	}
+
+#define ZX_CATCH(...) \
+	catch (std::exception & e) { \
+		lastErrorMsg = e.what(); \
+	} catch (...) { \
+		lastErrorMsg = "Unknown error"; \
+	} \
+	return __VA_ARGS__;
+
+#define ZX_TRY(...) \
+	try { \
+		return __VA_ARGS__; \
+	} \
+	ZX_CATCH({})
+
+
+extern "C" {
+/*
+ * ZXing/ImageView.h
+ */
+
+ZXing_ImageView* ZXing_ImageView_new(const uint8_t* data, int width, int height, ZXing_ImageFormat format, int rowStride,
+									 int pixStride)
+{
+	ImageFormat cppformat = static_cast<ImageFormat>(format);
+	ZX_TRY(new ImageView(data, width, height, cppformat, rowStride, pixStride))
+}
+
+ZXing_ImageView* ZXing_ImageView_new_checked(const uint8_t* data, int size, int width, int height, ZXing_ImageFormat format,
+											 int rowStride, int pixStride)
+{
+	ImageFormat cppformat = static_cast<ImageFormat>(format);
+	ZX_TRY(new ImageView(data, size, width, height, cppformat, rowStride, pixStride))
+}
+
+void ZXing_ImageView_delete(ZXing_ImageView* iv)
+{
+	delete iv;
+}
+
+void ZXing_ImageView_crop(ZXing_ImageView* iv, int left, int top, int width, int height)
+{
+	*iv = iv->cropped(left, top, width, height);
+}
+
+void ZXing_ImageView_rotate(ZXing_ImageView* iv, int degree)
+{
+	*iv = iv->rotated(degree);
+}
+
+void ZXing_Image_delete(ZXing_Image* img)
+{
+	delete img;
+}
+
+const uint8_t* ZXing_Image_data(const ZXing_Image* img)
+{
+	return img->data();
+}
+
+int ZXing_Image_width(const ZXing_Image* img)
+{
+	return img->width();
+}
+
+int ZXing_Image_height(const ZXing_Image* img)
+{
+	return img->height();
+}
+
+ZXing_ImageFormat ZXing_Image_format(const ZXing_Image* img)
+{
+	return static_cast<ZXing_ImageFormat>(img->format());
+}
+
+/*
+ * ZXing/BarcodeFormat.h
+ */
+
+ZXing_BarcodeFormats ZXing_BarcodeFormatsFromString(const char* str)
+{
+	if (!str)
+		return {};
+	try {
+		return transmute_cast<ZXing_BarcodeFormats>(BarcodeFormatsFromString(str));
+	}
+	ZX_CATCH(ZXing_BarcodeFormat_Invalid)
+}
+
+ZXing_BarcodeFormat ZXing_BarcodeFormatFromString(const char* str)
+{
+	ZXing_BarcodeFormat res = ZXing_BarcodeFormatsFromString(str);
+	return BitHacks::CountBitsSet(res) == 1 ? res : ZXing_BarcodeFormat_Invalid;
+}
+
+char* ZXing_BarcodeFormatToString(ZXing_BarcodeFormat format)
+{
+	return copy(ToString(static_cast<BarcodeFormat>(format)));
+}
+
+/*
+ * ZXing/ZXingCpp.h
+ */
+
+
+#ifdef ZXING_EXPERIMENTAL_API
+ZXing_BarcodeFormats ZXing_SupportedBarcodeFormats(ZXing_Operation op)
+{
+	return transmute_cast<ZXing_BarcodeFormats>(SupportedBarcodeFormats(static_cast<Operation>(op)));
+}
+#endif
+
+/*
+ * ZXing/Barcode.h
+ */
+
+char* ZXing_ContentTypeToString(ZXing_ContentType type)
+{
+	return copy(ToString(static_cast<ContentType>(type)));
+}
+
+char* ZXing_PositionToString(ZXing_Position position)
+{
+	return copy(ToString(transmute_cast<Position>(position)));
+}
+
+
+bool ZXing_Barcode_isValid(const ZXing_Barcode* barcode)
+{
+	return barcode != NULL && barcode->isValid();
+}
+
+ZXing_ErrorType ZXing_Barcode_errorType(const ZXing_Barcode* barcode)
+{
+	return static_cast<ZXing_ErrorType>(barcode->error().type());
+}
+
+char* ZXing_Barcode_errorMsg(const ZXing_Barcode* barcode)
+{
+	return copy(ToString(barcode->error()));
+}
+
+uint8_t* ZXing_Barcode_bytes(const ZXing_Barcode* barcode, int* len)
+{
+	return copy(barcode->bytes(), len);
+}
+
+uint8_t* ZXing_Barcode_bytesECI(const ZXing_Barcode* barcode, int* len)
+{
+	return copy(barcode->bytesECI(), len);
+}
+
+#define ZX_GETTER(TYPE, GETTER, TRANS) \
+	TYPE ZXing_Barcode_##GETTER(const ZXing_Barcode* barcode) { return TRANS(barcode->GETTER()); }
+
+ZX_GETTER(ZXing_BarcodeFormat, format, static_cast<ZXing_BarcodeFormat>)
+ZX_GETTER(ZXing_ContentType, contentType, static_cast<ZXing_ContentType>)
+ZX_GETTER(char*, text, copy)
+ZX_GETTER(char*, ecLevel, copy)
+ZX_GETTER(char*, symbologyIdentifier, copy)
+ZX_GETTER(ZXing_Position, position, transmute_cast<ZXing_Position>)
+
+ZX_GETTER(int, orientation,)
+ZX_GETTER(bool, hasECI,)
+ZX_GETTER(bool, isInverted,)
+ZX_GETTER(bool, isMirrored,)
+ZX_GETTER(int, lineCount,)
+
+void ZXing_Barcode_delete(ZXing_Barcode* barcode)
+{
+	delete barcode;
+}
+
+void ZXing_Barcodes_delete(ZXing_Barcodes* barcodes)
+{
+	if (barcodes != &emptyBarcodes)
+		delete barcodes;
+}
+
+int ZXing_Barcodes_size(const ZXing_Barcodes* barcodes)
+{
+	return barcodes ? Size(*barcodes) : 0;
+}
+
+const ZXing_Barcode* ZXing_Barcodes_at(const ZXing_Barcodes* barcodes, int i)
+{
+	if (!barcodes || i < 0 || i >= Size(*barcodes))
+		return NULL;
+	return &(*barcodes)[i];
+}
+
+ZXing_Barcode* ZXing_Barcodes_move(ZXing_Barcodes* barcodes, int i)
+{
+	if (!barcodes || i < 0 || i >= Size(*barcodes))
+		return NULL;
+
+	ZX_TRY(new Barcode(std::move((*barcodes)[i])));
+}
+
+/*
+ * ZXing/ReaderOptions.h
+ */
+
+ZXing_ReaderOptions* ZXing_ReaderOptions_new()
+{
+	ZX_TRY(new ReaderOptions());
+}
+
+void ZXing_ReaderOptions_delete(ZXing_ReaderOptions* opts)
+{
+	delete opts;
+}
+
+#define ZX_PROPERTY(TYPE, GETTER, SETTER) \
+	TYPE ZXing_ReaderOptions_get##SETTER(const ZXing_ReaderOptions* opts) { return opts->GETTER(); } \
+	void ZXing_ReaderOptions_set##SETTER(ZXing_ReaderOptions* opts, TYPE val) { opts->set##SETTER(val); }
+
+ZX_PROPERTY(bool, tryHarder, TryHarder)
+ZX_PROPERTY(bool, tryRotate, TryRotate)
+ZX_PROPERTY(bool, tryInvert, TryInvert)
+ZX_PROPERTY(bool, tryDownscale, TryDownscale)
+ZX_PROPERTY(bool, isPure, IsPure)
+ZX_PROPERTY(bool, returnErrors, ReturnErrors)
+ZX_PROPERTY(int, minLineCount, MinLineCount)
+ZX_PROPERTY(int, maxNumberOfSymbols, MaxNumberOfSymbols)
+
+#undef ZX_PROPERTY
+
+void ZXing_ReaderOptions_setFormats(ZXing_ReaderOptions* opts, ZXing_BarcodeFormats formats)
+{
+	opts->setFormats(static_cast<BarcodeFormat>(formats));
+}
+
+ZXing_BarcodeFormats ZXing_ReaderOptions_getFormats(const ZXing_ReaderOptions* opts)
+{
+	auto v = opts->formats();
+	return transmute_cast<ZXing_BarcodeFormats>(v);
+}
+
+#define ZX_ENUM_PROPERTY(TYPE, GETTER, SETTER) \
+	ZXing_##TYPE ZXing_ReaderOptions_get##SETTER(const ZXing_ReaderOptions* opts) { return static_cast<ZXing_##TYPE>(opts->GETTER()); } \
+	void ZXing_ReaderOptions_set##SETTER(ZXing_ReaderOptions* opts, ZXing_##TYPE val) { opts->set##SETTER(static_cast<TYPE>(val)); }
+
+ZX_ENUM_PROPERTY(Binarizer, binarizer, Binarizer)
+ZX_ENUM_PROPERTY(EanAddOnSymbol, eanAddOnSymbol, EanAddOnSymbol)
+ZX_ENUM_PROPERTY(TextMode, textMode, TextMode)
+
+
+/*
+ * ZXing/ReadBarcode.h
+ */
+
+ZXing_Barcodes* ZXing_ReadBarcodes(const ZXing_ImageView* iv, const ZXing_ReaderOptions* opts)
+{
+	ZX_CHECK(iv, "ImageView param is NULL")
+	try {
+		auto res = ReadBarcodes(*iv, opts ? *opts : ReaderOptions{});
+		return res.empty() ? &emptyBarcodes : new Barcodes(std::move(res));
+	}
+	ZX_CATCH(NULL);
+}
+
+
+#ifdef ZXING_EXPERIMENTAL_API
+/*
+ * ZXing/WriteBarcode.h
+ */
+
+ZXing_CreatorOptions* ZXing_CreatorOptions_new(ZXing_BarcodeFormat format)
+{
+	ZX_TRY(new CreatorOptions(static_cast<BarcodeFormat>(format)));
+}
+
+void ZXing_CreatorOptions_delete(ZXing_CreatorOptions* opts)
+{
+	delete opts;
+}
+
+#define ZX_PROPERTY(TYPE, GETTER, SETTER) \
+	TYPE ZXing_CreatorOptions_get##SETTER(const ZXing_CreatorOptions* opts) { return opts->GETTER(); } \
+	void ZXing_CreatorOptions_set##SETTER(ZXing_CreatorOptions* opts, TYPE val) { opts->GETTER(val); }
+
+ZX_PROPERTY(bool, readerInit, ReaderInit)
+ZX_PROPERTY(bool, forceSquareDataMatrix, ForceSquareDataMatrix)
+
+#undef ZX_PROPERTY
+
+//ZX_PROPERTY(BarcodeFormat, format, Format)
+
+char* ZXing_CreatorOptions_getEcLevel(const ZXing_CreatorOptions* opts)
+{
+	return copy(opts->ecLevel());
+}
+
+void ZXing_CreatorOptions_setEcLevel(ZXing_CreatorOptions* opts, const char* val)
+{
+	opts->ecLevel(val);
+}
+
+
+ZXing_WriterOptions* ZXing_WriterOptions_new()
+{
+	ZX_TRY(new ZXing_WriterOptions());
+}
+
+void ZXing_WriterOptions_delete(ZXing_WriterOptions* opts)
+{
+	delete opts;
+}
+
+#define ZX_PROPERTY(TYPE, GETTER, SETTER) \
+	TYPE ZXing_WriterOptions_get##SETTER(const ZXing_WriterOptions* opts) { return opts->GETTER(); } \
+	void ZXing_WriterOptions_set##SETTER(ZXing_WriterOptions* opts, TYPE val) { opts->GETTER(val); }
+
+ZX_PROPERTY(int, scale, Scale)
+ZX_PROPERTY(int, sizeHint, SizeHint)
+ZX_PROPERTY(int, rotate, Rotate)
+ZX_PROPERTY(bool, withHRT, WithHRT)
+ZX_PROPERTY(bool, withQuietZones, WithQuietZones)
+
+#undef ZX_PROPERTY
+
+ZXing_Barcode* ZXing_CreateBarcodeFromText(const char* data, int size, const ZXing_CreatorOptions* opts)
+{
+	ZX_CHECK(data && opts, "Data and/or options param in CreateBarcodeFromText is NULL")
+	ZX_TRY(new Barcode(CreateBarcodeFromText({data, size ? static_cast<size_t>(size) : strlen(data)}, *opts));)
+}
+
+ZXing_Barcode* ZXing_CreateBarcodeFromBytes(const void* data, int size, const ZXing_CreatorOptions* opts)
+{
+	ZX_CHECK(data && size && opts, "Data and/or options param in CreateBarcodeFromBytes is NULL")
+	ZX_TRY(new Barcode(CreateBarcodeFromBytes(data, size, *opts)))
+}
+
+char* ZXing_WriteBarcodeToSVG(const ZXing_Barcode* barcode, const ZXing_WriterOptions* opts)
+{
+	ZX_CHECK(barcode, "Barcode param in WriteBarcodeToSVG is NULL")
+	ZX_TRY(copy(opts ? WriteBarcodeToSVG(*barcode, *opts) : WriteBarcodeToSVG(*barcode)))
+}
+
+ZXing_Image* ZXing_WriteBarcodeToImage(const ZXing_Barcode* barcode, const ZXing_WriterOptions* opts)
+{
+	ZX_CHECK(barcode, "Barcode param in WriteBarcodeToSVG is NULL")
+	ZX_TRY(new Image(opts ? WriteBarcodeToImage(*barcode, *opts) : WriteBarcodeToImage(*barcode)))
+}
+
+#endif
+
+/*
+ * ZXingC.h
+ */
+
+char* ZXing_LastErrorMsg()
+{
+	if (lastErrorMsg.empty())
+		return NULL;
+
+	return copy(std::exchange(lastErrorMsg, {}));
+}
+
+const char* ZXing_Version()
+{
+	return ZXING_VERSION_STR;
+}
+
+void ZXing_free(void* ptr)
+{
+	if (ptr != ZXing_Version())
+		free(ptr);
+}
+
+} // extern "C"
diff --git a/core/src/ZXingC.h b/core/src/ZXingC.h
new file mode 100644
index 0000000000..282f528574
--- /dev/null
+++ b/core/src/ZXingC.h
@@ -0,0 +1,323 @@
+/*
+* Copyright 2023 siiky
+* Copyright 2023 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef _ZXING_C_H
+#define _ZXING_C_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+
+#include "ZXingCpp.h"
+
+typedef ZXing::Barcode ZXing_Barcode;
+typedef ZXing::Barcodes ZXing_Barcodes;
+typedef ZXing::ImageView ZXing_ImageView;
+typedef ZXing::Image ZXing_Image;
+typedef ZXing::ReaderOptions ZXing_ReaderOptions;
+
+#ifdef ZXING_EXPERIMENTAL_API
+typedef ZXing::CreatorOptions ZXing_CreatorOptions;
+typedef ZXing::WriterOptions ZXing_WriterOptions;
+#endif
+
+extern "C"
+{
+#else
+
+typedef struct ZXing_Barcode ZXing_Barcode;
+typedef struct ZXing_Barcodes ZXing_Barcodes;
+typedef struct ZXing_ImageView ZXing_ImageView;
+typedef struct ZXing_Image ZXing_Image;
+typedef struct ZXing_ReaderOptions ZXing_ReaderOptions;
+typedef struct ZXing_CreatorOptions ZXing_CreatorOptions;
+typedef struct ZXing_WriterOptions ZXing_WriterOptions;
+
+#endif
+
+/*
+ * ZXing/ImageView.h
+ */
+
+typedef enum {
+	ZXing_ImageFormat_None = 0,
+	ZXing_ImageFormat_Lum = 0x01000000,
+	ZXing_ImageFormat_LumA = 0x02000000,
+	ZXing_ImageFormat_RGB = 0x03000102,
+	ZXing_ImageFormat_BGR = 0x03020100,
+	ZXing_ImageFormat_RGBA = 0x04000102,
+	ZXing_ImageFormat_ARGB = 0x04010203,
+	ZXing_ImageFormat_BGRA = 0x04020100,
+	ZXing_ImageFormat_ABGR = 0x04030201,
+} ZXing_ImageFormat;
+
+ZXing_ImageView* ZXing_ImageView_new(const uint8_t* data, int width, int height, ZXing_ImageFormat format, int rowStride,
+									 int pixStride);
+ZXing_ImageView* ZXing_ImageView_new_checked(const uint8_t* data, int size, int width, int height, ZXing_ImageFormat format,
+											 int rowStride, int pixStride);
+void ZXing_ImageView_delete(ZXing_ImageView* iv);
+
+void ZXing_ImageView_crop(ZXing_ImageView* iv, int left, int top, int width, int height);
+void ZXing_ImageView_rotate(ZXing_ImageView* iv, int degree);
+
+void ZXing_Image_delete(ZXing_Image* img);
+
+const uint8_t* ZXing_Image_data(const ZXing_Image* img);
+int ZXing_Image_width(const ZXing_Image* img);
+int ZXing_Image_height(const ZXing_Image* img);
+ZXing_ImageFormat ZXing_Image_format(const ZXing_Image* img);
+
+/*
+ * ZXing/BarcodeFormat.h
+ */
+
+typedef enum
+{
+	ZXing_BarcodeFormat_None = 0,
+	ZXing_BarcodeFormat_Aztec = (1 << 0),
+	ZXing_BarcodeFormat_Codabar = (1 << 1),
+	ZXing_BarcodeFormat_Code39 = (1 << 2),
+	ZXing_BarcodeFormat_Code93 = (1 << 3),
+	ZXing_BarcodeFormat_Code128 = (1 << 4),
+	ZXing_BarcodeFormat_DataBar = (1 << 5),
+	ZXing_BarcodeFormat_DataBarExpanded = (1 << 6),
+	ZXing_BarcodeFormat_DataMatrix = (1 << 7),
+	ZXing_BarcodeFormat_EAN8 = (1 << 8),
+	ZXing_BarcodeFormat_EAN13 = (1 << 9),
+	ZXing_BarcodeFormat_ITF = (1 << 10),
+	ZXing_BarcodeFormat_MaxiCode = (1 << 11),
+	ZXing_BarcodeFormat_PDF417 = (1 << 12),
+	ZXing_BarcodeFormat_QRCode = (1 << 13),
+	ZXing_BarcodeFormat_UPCA = (1 << 14),
+	ZXing_BarcodeFormat_UPCE = (1 << 15),
+	ZXing_BarcodeFormat_MicroQRCode = (1 << 16),
+	ZXing_BarcodeFormat_RMQRCode = (1 << 17),
+	ZXing_BarcodeFormat_DXFilmEdge = (1 << 18),
+	ZXing_BarcodeFormat_DataBarLimited = (1 << 19),
+
+	ZXing_BarcodeFormat_LinearCodes = ZXing_BarcodeFormat_Codabar | ZXing_BarcodeFormat_Code39 | ZXing_BarcodeFormat_Code93
+									  | ZXing_BarcodeFormat_Code128 | ZXing_BarcodeFormat_EAN8 | ZXing_BarcodeFormat_EAN13
+									  | ZXing_BarcodeFormat_ITF | ZXing_BarcodeFormat_DataBar | ZXing_BarcodeFormat_DataBarExpanded
+									  | ZXing_BarcodeFormat_DataBarLimited | ZXing_BarcodeFormat_DXFilmEdge | ZXing_BarcodeFormat_UPCA
+									  | ZXing_BarcodeFormat_UPCE,
+	ZXing_BarcodeFormat_MatrixCodes = ZXing_BarcodeFormat_Aztec | ZXing_BarcodeFormat_DataMatrix | ZXing_BarcodeFormat_MaxiCode
+									  | ZXing_BarcodeFormat_PDF417 | ZXing_BarcodeFormat_QRCode | ZXing_BarcodeFormat_MicroQRCode
+									  | ZXing_BarcodeFormat_RMQRCode,
+	ZXing_BarcodeFormat_Any = ZXing_BarcodeFormat_LinearCodes | ZXing_BarcodeFormat_MatrixCodes,
+
+	ZXing_BarcodeFormat_Invalid = 0xFFFFFFFFu /* return value when BarcodeFormatsFromString() throws */
+} ZXing_BarcodeFormat;
+
+typedef ZXing_BarcodeFormat ZXing_BarcodeFormats;
+
+ZXing_BarcodeFormats ZXing_BarcodeFormatsFromString(const char* str);
+ZXing_BarcodeFormat ZXing_BarcodeFormatFromString(const char* str);
+char* ZXing_BarcodeFormatToString(ZXing_BarcodeFormat format);
+
+/*
+ * ZXing/ZXingCpp.h
+ */
+
+#ifdef ZXING_EXPERIMENTAL_API
+
+typedef enum {
+	ZXing_Operation_Create,
+	ZXing_Operation_Read,
+	ZXing_Operation_CreateAndRead,
+	ZXing_Operation_CreateOrRead,
+} ZXing_Operation;
+
+ZXing_BarcodeFormats ZXing_SupportedBarcodeFormats(ZXing_Operation op);
+
+#endif
+
+/*
+ * ZXing/Barcode.h
+ */
+
+typedef enum
+{
+	ZXing_ContentType_Text,
+	ZXing_ContentType_Binary,
+	ZXing_ContentType_Mixed,
+	ZXing_ContentType_GS1,
+	ZXing_ContentType_ISO15434,
+	ZXing_ContentType_UnknownECI
+} ZXing_ContentType;
+
+typedef enum
+{
+	ZXing_ErrorType_None,
+	ZXing_ErrorType_Format,
+	ZXing_ErrorType_Checksum,
+	ZXing_ErrorType_Unsupported
+} ZXing_ErrorType;
+
+char* ZXing_ContentTypeToString(ZXing_ContentType type);
+
+typedef struct ZXing_PointI
+{
+	int x, y;
+} ZXing_PointI;
+
+typedef struct ZXing_Position
+{
+	ZXing_PointI topLeft, topRight, bottomRight, bottomLeft;
+} ZXing_Position;
+
+char* ZXing_PositionToString(ZXing_Position position);
+
+bool ZXing_Barcode_isValid(const ZXing_Barcode* barcode);
+ZXing_ErrorType ZXing_Barcode_errorType(const ZXing_Barcode* barcode);
+char* ZXing_Barcode_errorMsg(const ZXing_Barcode* barcode);
+ZXing_BarcodeFormat ZXing_Barcode_format(const ZXing_Barcode* barcode);
+ZXing_ContentType ZXing_Barcode_contentType(const ZXing_Barcode* barcode);
+uint8_t* ZXing_Barcode_bytes(const ZXing_Barcode* barcode, int* len);
+uint8_t* ZXing_Barcode_bytesECI(const ZXing_Barcode* barcode, int* len);
+char* ZXing_Barcode_text(const ZXing_Barcode* barcode);
+char* ZXing_Barcode_ecLevel(const ZXing_Barcode* barcode);
+char* ZXing_Barcode_symbologyIdentifier(const ZXing_Barcode* barcode);
+ZXing_Position ZXing_Barcode_position(const ZXing_Barcode* barcode);
+int ZXing_Barcode_orientation(const ZXing_Barcode* barcode);
+bool ZXing_Barcode_hasECI(const ZXing_Barcode* barcode);
+bool ZXing_Barcode_isInverted(const ZXing_Barcode* barcode);
+bool ZXing_Barcode_isMirrored(const ZXing_Barcode* barcode);
+int ZXing_Barcode_lineCount(const ZXing_Barcode* barcode);
+
+void ZXing_Barcode_delete(ZXing_Barcode* barcode);
+void ZXing_Barcodes_delete(ZXing_Barcodes* barcodes);
+
+int ZXing_Barcodes_size(const ZXing_Barcodes* barcodes);
+const ZXing_Barcode* ZXing_Barcodes_at(const ZXing_Barcodes* barcodes, int i);
+ZXing_Barcode* ZXing_Barcodes_move(ZXing_Barcodes* barcodes, int i);
+
+/*
+ * ZXing/ReaderOptions.h
+ */
+
+typedef enum
+{
+	ZXing_Binarizer_LocalAverage,
+	ZXing_Binarizer_GlobalHistogram,
+	ZXing_Binarizer_FixedThreshold,
+	ZXing_Binarizer_BoolCast,
+} ZXing_Binarizer;
+
+typedef enum
+{
+	ZXing_EanAddOnSymbol_Ignore,
+	ZXing_EanAddOnSymbol_Read,
+	ZXing_EanAddOnSymbol_Require,
+} ZXing_EanAddOnSymbol;
+
+typedef enum
+{
+	ZXing_TextMode_Plain,
+	ZXing_TextMode_ECI,
+	ZXing_TextMode_HRI,
+	ZXing_TextMode_Hex,
+	ZXing_TextMode_Escaped,
+} ZXing_TextMode;
+
+ZXing_ReaderOptions* ZXing_ReaderOptions_new();
+void ZXing_ReaderOptions_delete(ZXing_ReaderOptions* opts);
+
+void ZXing_ReaderOptions_setTryHarder(ZXing_ReaderOptions* opts, bool tryHarder);
+void ZXing_ReaderOptions_setTryRotate(ZXing_ReaderOptions* opts, bool tryRotate);
+void ZXing_ReaderOptions_setTryInvert(ZXing_ReaderOptions* opts, bool tryInvert);
+void ZXing_ReaderOptions_setTryDownscale(ZXing_ReaderOptions* opts, bool tryDownscale);
+void ZXing_ReaderOptions_setIsPure(ZXing_ReaderOptions* opts, bool isPure);
+void ZXing_ReaderOptions_setReturnErrors(ZXing_ReaderOptions* opts, bool returnErrors);
+void ZXing_ReaderOptions_setFormats(ZXing_ReaderOptions* opts, ZXing_BarcodeFormats formats);
+void ZXing_ReaderOptions_setBinarizer(ZXing_ReaderOptions* opts, ZXing_Binarizer binarizer);
+void ZXing_ReaderOptions_setEanAddOnSymbol(ZXing_ReaderOptions* opts, ZXing_EanAddOnSymbol eanAddOnSymbol);
+void ZXing_ReaderOptions_setTextMode(ZXing_ReaderOptions* opts, ZXing_TextMode textMode);
+void ZXing_ReaderOptions_setMinLineCount(ZXing_ReaderOptions* opts, int n);
+void ZXing_ReaderOptions_setMaxNumberOfSymbols(ZXing_ReaderOptions* opts, int n);
+
+bool ZXing_ReaderOptions_getTryHarder(const ZXing_ReaderOptions* opts);
+bool ZXing_ReaderOptions_getTryRotate(const ZXing_ReaderOptions* opts);
+bool ZXing_ReaderOptions_getTryInvert(const ZXing_ReaderOptions* opts);
+bool ZXing_ReaderOptions_getTryDownscale(const ZXing_ReaderOptions* opts);
+bool ZXing_ReaderOptions_getIsPure(const ZXing_ReaderOptions* opts);
+bool ZXing_ReaderOptions_getReturnErrors(const ZXing_ReaderOptions* opts);
+ZXing_BarcodeFormats ZXing_ReaderOptions_getFormats(const ZXing_ReaderOptions* opts);
+ZXing_Binarizer ZXing_ReaderOptions_getBinarizer(const ZXing_ReaderOptions* opts);
+ZXing_EanAddOnSymbol ZXing_ReaderOptions_getEanAddOnSymbol(const ZXing_ReaderOptions* opts);
+ZXing_TextMode ZXing_ReaderOptions_getTextMode(const ZXing_ReaderOptions* opts);
+int ZXing_ReaderOptions_getMinLineCount(const ZXing_ReaderOptions* opts);
+int ZXing_ReaderOptions_getMaxNumberOfSymbols(const ZXing_ReaderOptions* opts);
+
+/*
+ * ZXing/ReadBarcode.h
+ */
+
+/** Note: opts is optional, i.e. it can be NULL, which will imply default settings. */
+ZXing_Barcodes* ZXing_ReadBarcodes(const ZXing_ImageView* iv, const ZXing_ReaderOptions* opts);
+
+#ifdef ZXING_EXPERIMENTAL_API
+
+/*
+ * ZXing/WriteBarcode.h
+ */
+
+ZXing_CreatorOptions* ZXing_CreatorOptions_new(ZXing_BarcodeFormat format);
+void ZXing_CreatorOptions_delete(ZXing_CreatorOptions* opts);
+
+void ZXing_CreatorOptions_setFormat(ZXing_CreatorOptions* opts, ZXing_BarcodeFormat format);
+ZXing_BarcodeFormat ZXing_CreatorOptions_getFormat(const ZXing_CreatorOptions* opts);
+
+void ZXing_CreatorOptions_setReaderInit(ZXing_CreatorOptions* opts, bool readerInit);
+bool ZXing_CreatorOptions_getReaderInit(const ZXing_CreatorOptions* opts);
+
+void ZXing_CreatorOptions_setForceSquareDataMatrix(ZXing_CreatorOptions* opts, bool forceSquareDataMatrix);
+bool ZXing_CreatorOptions_getForceSquareDataMatrix(const ZXing_CreatorOptions* opts);
+
+void ZXing_CreatorOptions_setEcLevel(ZXing_CreatorOptions* opts, const char* ecLevel);
+char* ZXing_CreatorOptions_getEcLevel(const ZXing_CreatorOptions* opts);
+
+
+ZXing_WriterOptions* ZXing_WriterOptions_new();
+void ZXing_WriterOptions_delete(ZXing_WriterOptions* opts);
+
+void ZXing_WriterOptions_setScale(ZXing_WriterOptions* opts, int scale);
+int ZXing_WriterOptions_getScale(const ZXing_WriterOptions* opts);
+
+void ZXing_WriterOptions_setSizeHint(ZXing_WriterOptions* opts, int sizeHint);
+int ZXing_WriterOptions_getSizeHint(const ZXing_WriterOptions* opts);
+
+void ZXing_WriterOptions_setRotate(ZXing_WriterOptions* opts, int rotate);
+int ZXing_WriterOptions_getRotate(const ZXing_WriterOptions* opts);
+
+void ZXing_WriterOptions_setWithHRT(ZXing_WriterOptions* opts, bool withHRT);
+bool ZXing_WriterOptions_getWithHRT(const ZXing_WriterOptions* opts);
+
+void ZXing_WriterOptions_setWithQuietZones(ZXing_WriterOptions* opts, bool withQuietZones);
+bool ZXing_WriterOptions_getWithQuietZones(const ZXing_WriterOptions* opts);
+
+
+ZXing_Barcode* ZXing_CreateBarcodeFromText(const char* data, int size, const ZXing_CreatorOptions* opts);
+ZXing_Barcode* ZXing_CreateBarcodeFromBytes(const void* data, int size, const ZXing_CreatorOptions* opts);
+
+/** Note: opts is optional, i.e. it can be NULL, which will imply default settings. */
+char* ZXing_WriteBarcodeToSVG(const ZXing_Barcode* barcode, const ZXing_WriterOptions* opts);
+ZXing_Image* ZXing_WriteBarcodeToImage(const ZXing_Barcode* barcode, const ZXing_WriterOptions* opts);
+
+#endif /* ZXING_EXPERIMENTAL_API */
+
+/* ZXing_LastErrorMsg() returns NULL in case there is no last error and a copy of the string otherwise. */
+char* ZXing_LastErrorMsg();
+
+const char* ZXing_Version();
+
+void ZXing_free(void* ptr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _ZXING_C_H */
diff --git a/core/src/ZXingCpp.cpp b/core/src/ZXingCpp.cpp
new file mode 100644
index 0000000000..d5fa34609b
--- /dev/null
+++ b/core/src/ZXingCpp.cpp
@@ -0,0 +1,48 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ZXingCpp.h"
+
+#if __has_include("Version.h")
+#include "Version.h"
+#else // this is mainly a workaround for a missing autogenerated Version.h in the XCode/CocoaPods corner
+#define ZXING_VERSION_STR "undefined"
+#endif
+
+namespace ZXing {
+
+const std::string& Version()
+{
+	static std::string res = ZXING_VERSION_STR;
+	return res;
+}
+
+#ifdef ZXING_EXPERIMENTAL_API
+
+BarcodeFormats SupportedBarcodeFormats(Operation op)
+{
+	switch (op) {
+	case Operation::Read:
+#ifdef ZXING_READERS
+		return BarcodeFormat::Any;
+#else
+		return BarcodeFormat::None;
+#endif
+	case Operation::Create:
+#if defined(ZXING_WRITERS) && defined(ZXING_EXPERIMENTAL_API)
+		return BarcodeFormats(BarcodeFormat::Any).setFlag(BarcodeFormat::DXFilmEdge, false);
+#else
+		return BarcodeFormat::None;
+#endif
+	case Operation::CreateAndRead: return SupportedBarcodeFormats(Operation::Create) & SupportedBarcodeFormats(Operation::Read);
+	case Operation::CreateOrRead: return SupportedBarcodeFormats(Operation::Create) | SupportedBarcodeFormats(Operation::Read);
+	}
+
+	return {}; // unreachable code
+}
+
+#endif // ZXING_EXPERIMENTAL_API
+
+} // namespace ZXing
diff --git a/core/src/ZXingCpp.h b/core/src/ZXingCpp.h
new file mode 100644
index 0000000000..dd115823e0
--- /dev/null
+++ b/core/src/ZXingCpp.h
@@ -0,0 +1,30 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "BarcodeFormat.h"
+#include "ReadBarcode.h"
+#include "WriteBarcode.h"
+
+namespace ZXing {
+
+const std::string& Version();
+
+#ifdef ZXING_EXPERIMENTAL_API
+
+enum class Operation
+{
+	Create,
+	Read,
+	CreateAndRead,
+	CreateOrRead,
+};
+
+BarcodeFormats SupportedBarcodeFormats(Operation op = Operation::CreateOrRead);
+
+#endif // ZXING_EXPERIMENTAL_API
+
+} // namespace ZXing
diff --git a/core/src/aztec/AZDecoder.cpp b/core/src/aztec/AZDecoder.cpp
index 7ab6f6a84f..f38fbe3fef 100644
--- a/core/src/aztec/AZDecoder.cpp
+++ b/core/src/aztec/AZDecoder.cpp
@@ -10,11 +10,11 @@
 #include "AZDetectorResult.h"
 #include "BitArray.h"
 #include "BitMatrix.h"
-#include "CharacterSet.h"
 #include "DecoderResult.h"
 #include "GenericGF.h"
 #include "ReedSolomonDecoder.h"
 #include "ZXTestSupport.h"
+#include "ZXAlgorithms.h"
 
 #include <cctype>
 #include <cstring>
@@ -347,9 +347,24 @@ DecoderResult Decode(const BitArray& bits)
 	return DecoderResult(std::move(res)).setStructuredAppend(sai);
 }
 
+DecoderResult DecodeRune(const DetectorResult& detectorResult) {
+	Content res;
+	res.symbology = {'z', 'C', 0}; // Runes cannot have ECI
+
+	// Bizarrely, this is what it says to do in the spec
+	auto runeString = ToString(detectorResult.runeValue(), 3);
+	res.append(runeString);
+
+	return DecoderResult(std::move(res));
+}
+
 DecoderResult Decode(const DetectorResult& detectorResult)
 {
 	try {
+		if (detectorResult.nbLayers() == 0) {
+			// This is a rune - just return the rune value
+			return DecodeRune(detectorResult);
+		}
 		auto bits = CorrectBits(detectorResult, ExtractBits(detectorResult));
 		return Decode(bits);
 	} catch (Error e) {
diff --git a/core/src/aztec/AZDetector.cpp b/core/src/aztec/AZDetector.cpp
index 87915060aa..51975958d6 100644
--- a/core/src/aztec/AZDetector.cpp
+++ b/core/src/aztec/AZDetector.cpp
@@ -20,7 +20,6 @@
 #include "ZXAlgorithms.h"
 
 #include <algorithm>
-#include <cmath>
 #include <optional>
 #include <vector>
 
@@ -110,12 +109,17 @@ static std::optional<ConcentricPattern> LocateAztecCenter(const BitMatrix& image
 static std::vector<ConcentricPattern> FindPureFinderPattern(const BitMatrix& image)
 {
 	int left, top, width, height;
-	if (!image.findBoundingBox(left, top, width, height, 11)) // 11 is the size of an Aztec Rune, see ISO/IEC 24778:2008(E) Annex A
-		return {};
+	if (!image.findBoundingBox(left, top, width, height, 11)) {  // 11 is the size of an Aztec Rune, see ISO/IEC 24778:2008(E) Annex A
+		// Runes 68 and 223 have none of their bits set on the bottom row
+		if (image.findBoundingBox(left, top, width, height, 10) && (width == 11) && (height == 10))
+			height = 11;
+		else
+			return {};
+	}	
 
 	PointF p(left + width / 2, top + height / 2);
 	constexpr auto PATTERN = FixedPattern<7, 7>{1, 1, 1, 1, 1, 1, 1};
-	if (auto pattern = LocateConcentricPattern(image, PATTERN, p, width / 2))
+	if (auto pattern = LocateConcentricPattern(image, PATTERN, p, width))
 		return {*pattern};
 	else
 		return {};
@@ -210,7 +214,7 @@ static std::vector<ConcentricPattern> FindFinderPatterns(const BitMatrix& image,
 				++N;
 				log(p, 1);
 
-				auto pattern = LocateAztecCenter(image, p, Reduce(next));
+				auto pattern = LocateAztecCenter(image, p, next.sum());
 				if (pattern) {
 					log(*pattern, 3);
 					assert(image.get(*pattern));
@@ -262,9 +266,10 @@ static uint32_t SampleOrientationBits(const BitMatrix& image, const PerspectiveT
 	return bits;
 }
 
-static int ModeMessage(const BitMatrix& image, const PerspectiveTransform& mod2Pix, int radius)
+static int ModeMessage(const BitMatrix& image, const PerspectiveTransform& mod2Pix, int radius, bool& isRune)
 {
 	const bool compact = radius == 5;
+	isRune = false;
 
 	// read the bits between the corner bits along the 4 edges
 	uint64_t bits = 0;
@@ -292,7 +297,21 @@ static int ModeMessage(const BitMatrix& image, const PerspectiveTransform& mod2P
 		words[i] = narrow_cast<int>(bits & 0xF);
 		bits >>= 4;
 	}
-	if (!ReedSolomonDecode(GenericGF::AztecParam(), words, numECCodewords))
+
+	bool decodeResult = ReedSolomonDecode(GenericGF::AztecParam(), words, numECCodewords);
+
+	if ((!decodeResult) && compact) {
+		// Is this a Rune?
+		for (auto& word : words)
+			word ^= 0b1010;
+		
+		decodeResult = ReedSolomonDecode(GenericGF::AztecParam(), words, numECCodewords);
+
+		if (decodeResult)
+			isRune = true;
+	}
+
+	if (!decodeResult)
 		return -1;
 
 	int res = 0;
@@ -351,6 +370,7 @@ DetectorResults Detect(const BitMatrix& image, bool isPure, bool tryHarder, int
 		int mirror; // 0 or 1
 		int rotate; // [0..3]
 		int modeMessage = -1;
+		bool isRune = false;
 		[&]() {
 			// 24778:2008(E) 14.3.3 reads:
 			// In the outer layer of the Core Symbol, the 12 orientation bits at the corners are bitwise compared against the specified
@@ -370,7 +390,7 @@ DetectorResults Detect(const BitMatrix& image, bool isPure, bool tryHarder, int
 					rotate = FindRotation(bits, mirror);
 					if (rotate == -1)
 						continue;
-					modeMessage = ModeMessage(image, PerspectiveTransform(srcQuad, RotatedCorners(*fpQuad, rotate, mirror)), radius);
+					modeMessage = ModeMessage(image, PerspectiveTransform(srcQuad, RotatedCorners(*fpQuad, rotate, mirror)), radius, isRune);
 					if (modeMessage != -1)
 						return;
 				}
@@ -400,7 +420,9 @@ DetectorResults Detect(const BitMatrix& image, bool isPure, bool tryHarder, int
 		int nbLayers = 0;
 		int nbDataBlocks = 0;
 		bool readerInit = false;
-		ExtractParameters(modeMessage, radius == 5, nbLayers, nbDataBlocks, readerInit);
+		if (!isRune) {
+			ExtractParameters(modeMessage, radius == 5, nbLayers, nbDataBlocks, readerInit);
+		}
 
 		int dim = radius == 5 ? 4 * nbLayers + 11 : 4 * nbLayers + 2 * ((2 * nbLayers + 6) / 15) + 15;
 		double low = dim / 2.0 + srcQuad[0].x;
@@ -410,7 +432,7 @@ DetectorResults Detect(const BitMatrix& image, bool isPure, bool tryHarder, int
 		if (!bits.isValid())
 			continue;
 
-		res.emplace_back(std::move(bits), radius == 5, nbDataBlocks, nbLayers, readerInit, mirror != 0);
+		res.emplace_back(std::move(bits), radius == 5, nbDataBlocks, nbLayers, readerInit, mirror != 0, isRune ? modeMessage : -1);
 
 		if (Size(res) == maxSymbols)
 			break;
diff --git a/core/src/aztec/AZDetectorResult.h b/core/src/aztec/AZDetectorResult.h
index cd65e9daab..37e60a1554 100644
--- a/core/src/aztec/AZDetectorResult.h
+++ b/core/src/aztec/AZDetectorResult.h
@@ -19,6 +19,7 @@ class DetectorResult : public ZXing::DetectorResult
 	int _nbLayers = 0;
 	bool _readerInit = false;
 	bool _isMirrored = false;
+	int _runeValue = -1;
 
 	DetectorResult(const DetectorResult&) = delete;
 	DetectorResult& operator=(const DetectorResult&) = delete;
@@ -28,13 +29,14 @@ class DetectorResult : public ZXing::DetectorResult
 	DetectorResult(DetectorResult&&) noexcept = default;
 	DetectorResult& operator=(DetectorResult&&) noexcept = default;
 
-	DetectorResult(ZXing::DetectorResult&& result, bool isCompact, int nbDatablocks, int nbLayers, bool readerInit, bool isMirrored)
+	DetectorResult(ZXing::DetectorResult&& result, bool isCompact, int nbDatablocks, int nbLayers, bool readerInit, bool isMirrored, int runeValue)
 		: ZXing::DetectorResult{std::move(result)},
 		  _compact(isCompact),
 		  _nbDatablocks(nbDatablocks),
 		  _nbLayers(nbLayers),
 		  _readerInit(readerInit),
-		  _isMirrored(isMirrored)
+		  _isMirrored(isMirrored),
+		  _runeValue(runeValue)
 	{}
 
 	bool isCompact() const { return _compact; }
@@ -42,6 +44,9 @@ class DetectorResult : public ZXing::DetectorResult
 	int nbLayers() const { return _nbLayers; }
 	bool readerInit() const { return _readerInit; }
 	bool isMirrored() const { return _isMirrored; }
+
+	// Only meaningful is nbDatablocks == 0
+	int runeValue() const { return _runeValue; }
 };
 
 } // namespace ZXing::Aztec
diff --git a/core/src/aztec/AZEncoder.cpp b/core/src/aztec/AZEncoder.cpp
index f45eb000db..00b3108463 100644
--- a/core/src/aztec/AZEncoder.cpp
+++ b/core/src/aztec/AZEncoder.cpp
@@ -82,6 +82,19 @@ void GenerateModeMessage(bool compact, int layers, int messageSizeInWords, BitAr
 	}
 }
 
+ZXING_EXPORT_TEST_ONLY
+void GenerateRuneMessage(uint8_t word, BitArray& runeMessage)
+{
+	runeMessage = BitArray();
+	runeMessage.appendBits(word, 8);
+	GenerateCheckWords(runeMessage, 28, 4, runeMessage);
+	// Now flip every other bit
+
+	BitArray xorBits;
+	xorBits.appendBits(0xAAAAAAAA, 28);
+	runeMessage.bitwiseXOR(xorBits);
+}
+
 static void DrawModeMessage(BitMatrix& matrix, bool compact, int matrixSize, const BitArray& modeMessage)
 {
 	int center = matrixSize / 2;
@@ -176,7 +189,13 @@ Encoder::Encode(const std::string& data, int minECCPercent, int userSpecifiedLay
 	int totalBitsInLayer;
 	int wordSize;
 	BitArray stuffedBits;
-	if (userSpecifiedLayers != DEFAULT_AZTEC_LAYERS) {
+	if (userSpecifiedLayers == AZTEC_RUNE_LAYERS) {
+		compact = true;
+		layers = 0;
+		totalBitsInLayer = 0;
+		wordSize = 0;
+		stuffedBits = BitArray(0);
+	} else if (userSpecifiedLayers != DEFAULT_AZTEC_LAYERS) {
 		compact = userSpecifiedLayers < 0;
 		layers = std::abs(userSpecifiedLayers);
 		if (layers > (compact ? MAX_NB_BITS_COMPACT : MAX_NB_BITS)) {
@@ -225,13 +244,21 @@ Encoder::Encode(const std::string& data, int minECCPercent, int userSpecifiedLay
 			}
 		}
 	}
-	BitArray messageBits;
-	GenerateCheckWords(stuffedBits, totalBitsInLayer, wordSize, messageBits);
 
-	// generate mode message
-	int messageSizeInWords = stuffedBits.size() / wordSize;
+	BitArray messageBits;
 	BitArray modeMessage;
-	GenerateModeMessage(compact, layers, messageSizeInWords, modeMessage);
+	int messageSizeInWords;
+
+	if (layers == 0) {
+		// This is a rune, and messageBits should be empty
+		messageBits = BitArray(0);
+		messageSizeInWords = 0;
+		GenerateRuneMessage(data[0], modeMessage);
+	} else {
+		GenerateCheckWords(stuffedBits, totalBitsInLayer, wordSize, messageBits);
+		messageSizeInWords = stuffedBits.size() / wordSize;
+		GenerateModeMessage(compact, layers, messageSizeInWords, modeMessage);
+	}
 
 	// allocate symbol
 	int baseMatrixSize = (compact ? 11 : 14) + layers * 4; // not including alignment lines
diff --git a/core/src/aztec/AZEncoder.h b/core/src/aztec/AZEncoder.h
index 47311c0c90..b5cd7ff465 100644
--- a/core/src/aztec/AZEncoder.h
+++ b/core/src/aztec/AZEncoder.h
@@ -36,6 +36,7 @@ class Encoder
 public:
 	static const int DEFAULT_EC_PERCENT = 33; // default minimal percentage of error check words
 	static const int DEFAULT_AZTEC_LAYERS = 0;
+	static const int AZTEC_RUNE_LAYERS = 0xFF;
 
 	static EncodeResult Encode(const std::string& data, int minECCPercent, int userSpecifiedLayers);
 };
diff --git a/core/src/aztec/AZReader.cpp b/core/src/aztec/AZReader.cpp
index b9b36a7ba6..ade0979a5a 100644
--- a/core/src/aztec/AZReader.cpp
+++ b/core/src/aztec/AZReader.cpp
@@ -13,15 +13,13 @@
 #include "BinaryBitmap.h"
 #include "ReaderOptions.h"
 #include "DecoderResult.h"
-#include "Result.h"
+#include "Barcode.h"
 
-#include <memory>
 #include <utility>
 
 namespace ZXing::Aztec {
 
-Result
-Reader::decode(const BinaryBitmap& image) const
+Barcode Reader::decode(const BinaryBitmap& image) const
 {
 	auto binImg = image.getBitMatrix();
 	if (binImg == nullptr)
@@ -36,10 +34,10 @@ Reader::decode(const BinaryBitmap& image) const
 							.setIsMirrored(detectorResult.isMirrored())
 							.setVersionNumber(detectorResult.nbLayers());
 
-	return Result(std::move(decodeResult), std::move(detectorResult).position(), BarcodeFormat::Aztec);
+	return Barcode(std::move(decodeResult), std::move(detectorResult), BarcodeFormat::Aztec);
 }
 
-Results Reader::decode(const BinaryBitmap& image, int maxSymbols) const
+Barcodes Reader::decode(const BinaryBitmap& image, int maxSymbols) const
 {
 	auto binImg = image.getBitMatrix();
 	if (binImg == nullptr)
@@ -47,18 +45,18 @@ Results Reader::decode(const BinaryBitmap& image, int maxSymbols) const
 	
 	auto detRess = Detect(*binImg, _opts.isPure(), _opts.tryHarder(), maxSymbols);
 
-	Results results;
+	Barcodes baracodes;
 	for (auto&& detRes : detRess) {
 		auto decRes =
 			Decode(detRes).setReaderInit(detRes.readerInit()).setIsMirrored(detRes.isMirrored()).setVersionNumber(detRes.nbLayers());
 		if (decRes.isValid(_opts.returnErrors())) {
-			results.emplace_back(std::move(decRes), std::move(detRes).position(), BarcodeFormat::Aztec);
-			if (maxSymbols > 0 && Size(results) >= maxSymbols)
+			baracodes.emplace_back(std::move(decRes), std::move(detRes), BarcodeFormat::Aztec);
+			if (maxSymbols > 0 && Size(baracodes) >= maxSymbols)
 				break;
 		}
 	}
 
-	return results;
+	return baracodes;
 }
 
 } // namespace ZXing::Aztec
diff --git a/core/src/aztec/AZReader.h b/core/src/aztec/AZReader.h
index f94b3f92e8..3153d772f0 100644
--- a/core/src/aztec/AZReader.h
+++ b/core/src/aztec/AZReader.h
@@ -15,8 +15,8 @@ class Reader : public ZXing::Reader
 public:
 	using ZXing::Reader::Reader;
 
-	Result decode(const BinaryBitmap& image) const override;
-	Results decode(const BinaryBitmap& image, int maxSymbols) const override;
+	Barcode decode(const BinaryBitmap& image) const override;
+	Barcodes decode(const BinaryBitmap& image, int maxSymbols) const override;
 };
 
 } // namespace ZXing::Aztec
diff --git a/core/src/datamatrix/DMDecoder.cpp b/core/src/datamatrix/DMDecoder.cpp
index af3b9c5018..7bbf157ff2 100644
--- a/core/src/datamatrix/DMDecoder.cpp
+++ b/core/src/datamatrix/DMDecoder.cpp
@@ -8,7 +8,6 @@
 
 #include "BitMatrix.h"
 #include "BitSource.h"
-#include "CharacterSet.h"
 #include "DMBitLayout.h"
 #include "DMDataBlock.h"
 #include "DMVersion.h"
@@ -286,12 +285,18 @@ DecoderResult Decode(ByteArray&& bytes, const bool isDMRE)
 	int firstFNC1Position = 1;
 	Shift128 upperShift;
 
+	auto setError = [&error](Error&& e) {
+		// return only the first error but keep on decoding if possible
+		if (!error)
+			error = std::move(e);
+	};
+
 	// See ISO 16022:2006, 5.2.3 and Annex C, Table C.2
 	try {
 		while (!done && bits.available() >= 8) {
 			int oneByte = bits.readBits(8);
 			switch (oneByte) {
-			case 0: throw FormatError("invalid 0 code word");
+			case 0: setError(FormatError("invalid 0 code word")); break;
 			case 129: done = true; break; // Pad -> we are done, ignore the rest of the bits
 			case 230: DecodeC40OrTextSegment(bits, result, Mode::C40); break;
 			case 231: DecodeBase256Segment(bits, result); break;
@@ -308,13 +313,13 @@ DecoderResult Decode(ByteArray&& bytes, const bool isDMRE)
 				break;
 			case 233: // Structured Append
 				if (!firstCodeword) // Must be first ISO 16022:2006 5.6.1
-					throw FormatError("structured append tag must be first code word");
+					setError(FormatError("structured append tag must be first code word"));
 				ParseStructuredAppend(bits, sai);
 				firstFNC1Position = 5;
 				break;
 			case 234: // Reader Programming
 				if (!firstCodeword) // Must be first ISO 16022:2006 5.2.4.9
-					throw FormatError("reader programming tag must be first code word");
+					setError(FormatError("reader programming tag must be first code word"));
 				readerInit = true;
 				break;
 			case 235: upperShift.set = true; break; // Upper Shift (shift to Extended ASCII)
@@ -339,13 +344,14 @@ DecoderResult Decode(ByteArray&& bytes, const bool isDMRE)
 					// work around encoders that use unlatch to ASCII as last code word (ask upstream)
 					if (oneByte == 254 && bits.available() == 0)
 						break;
-					throw FormatError("invalid code word");
+					setError(FormatError("invalid code word"));
+					break;
 				}
 			}
 			firstCodeword = false;
 		}
 	} catch (Error e) {
-		error = std::move(e);
+		setError(std::move(e));
 	}
 
 	result.append(resultTrailer);
@@ -452,7 +458,7 @@ DecoderResult Decode(const BitMatrix& bits)
 	//TODO:
 	// * unify bit mirroring helper code with QRReader?
 	// * rectangular symbols with the a size of 8 x Y are not supported a.t.m.
-	if (auto mirroredRes = DoDecode(FlippedL(bits)); mirroredRes.isValid()) {
+	if (auto mirroredRes = DoDecode(FlippedL(bits)); mirroredRes.error().type() != Error::Checksum) {
 		mirroredRes.setIsMirrored(true);
 		return mirroredRes;
 	}
diff --git a/core/src/datamatrix/DMDetector.cpp b/core/src/datamatrix/DMDetector.cpp
index ce8d15fde6..24e287ede9 100644
--- a/core/src/datamatrix/DMDetector.cpp
+++ b/core/src/datamatrix/DMDetector.cpp
@@ -25,7 +25,6 @@
 #include <cmath>
 #include <cstdlib>
 #include <map>
-#include <numeric>
 #include <utility>
 #include <vector>
 
@@ -485,6 +484,35 @@ class DMRegressionLine : public RegressionLine
 
 		return lineLength / meanModSize;
 	}
+
+	bool truncateIfLShape()
+	{
+		auto lenThis = Size(_points);
+		auto lineAB = RegressionLine(_points.front(), _points.back());
+		if (lenThis < 16 || lineAB.distance(_points[lenThis / 2]) < 5)
+			return false;
+
+		auto maxP = _points.begin();
+		double maxD = 0.0;
+		for (auto p = _points.begin(); p != _points.end(); ++p) {
+			auto d = lineAB.distance(*p);
+			if (d > maxD) {
+				maxP = p;
+				maxD = d;
+			}
+		}
+
+		auto lenL = distance(_points.front(), *maxP) - 1;
+		auto lenB = distance(*maxP, _points.back()) - 1;
+		if (maxD < std::min(lenL, lenB) / 2)
+			return false;
+
+		setDirectionInward(_points.back() - *maxP);
+
+		_points.resize(std::distance(_points.begin(), maxP) - 1);
+
+		return true;
+	}
 };
 
 class EdgeTracer : public BitMatrixCursorF
@@ -711,6 +739,7 @@ static DetectorResult Scan(EdgeTracer& startTracer, std::array<DMRegressionLine,
 #endif
 
 		auto t = startTracer;
+		PointF up, right;
 
 		// follow left leg upwards
 		t.turnRight();
@@ -725,17 +754,19 @@ static DetectorResult Scan(EdgeTracer& startTracer, std::array<DMRegressionLine,
 		t.state = 1;
 		t.setDirection(tlTracer.right());
 		CHECK(t.traceLine(t.left(), lineL));
-		if (!lineL.isValid())
-			t.updateDirectionFromOrigin(tl);
-		auto up = t.back();
+
+		// check if lineL is L-shaped -> truncate the lower leg and set t to just before the corner
+		if (lineL.truncateIfLShape())
+			t.p = lineL.points().back();
+		t.updateDirectionFromOrigin(tl);
+		up = t.back();
 		CHECK(t.traceCorner(t.left(), bl));
 
 		// follow bottom leg right
 		t.state = 2;
 		CHECK(t.traceLine(t.left(), lineB));
-		if (!lineB.isValid())
-			t.updateDirectionFromOrigin(bl);
-		auto right = t.front();
+		t.updateDirectionFromOrigin(bl);
+		right = t.front();
 		CHECK(t.traceCorner(t.left(), br));
 
 		auto lenL = distance(tl, bl) - 1;
@@ -922,7 +953,7 @@ static DetectorResult DetectPure(const BitMatrix& image)
 	int bottom = top + height - 1;
 
 	// Now just read off the bits (this is a crop + subsample)
-	return {Deflate(image, dimT, dimR, top + modSizeX / 2, left + modSizeY / 2, modSize),
+	return {Deflate(image, dimT, dimR, top + modSizeY / 2, left + modSizeX / 2, modSize),
 			{{left, top}, {right, top}, {right, bottom}, {left, bottom}}};
 }
 
diff --git a/core/src/datamatrix/DMHighLevelEncoder.cpp b/core/src/datamatrix/DMHighLevelEncoder.cpp
index db0859347f..5e98282630 100644
--- a/core/src/datamatrix/DMHighLevelEncoder.cpp
+++ b/core/src/datamatrix/DMHighLevelEncoder.cpp
@@ -19,7 +19,6 @@
 #include <cstdint>
 #include <functional>
 #include <limits>
-#include <numeric>
 #include <stdexcept>
 #include <string>
 
@@ -32,10 +31,6 @@ static const uint8_t MACRO_06 = 237;
 static const uint8_t C40_UNLATCH = 254;
 static const uint8_t X12_UNLATCH = 254;
 
-static const std::wstring MACRO_05_HEADER = L"[)>\x1E""05\x1D";
-static const std::wstring MACRO_06_HEADER = L"[)>\x1E""06\x1D";
-static const std::wstring MACRO_TRAILER = L"\x1E\x04";
-
 enum
 {
 	ASCII_ENCODATION,
@@ -845,12 +840,13 @@ namespace Base256Encoder {
 
 } // Base256Encoder
 
-static bool StartsWith(const std::wstring& s, const std::wstring& ss)
+//TODO: c++20
+static bool StartsWith(std::wstring_view s, std::wstring_view ss)
 {
 	return s.length() > ss.length() && s.compare(0, ss.length(), ss) == 0;
 }
 
-static bool EndsWith(const std::wstring& s, const std::wstring& ss)
+static bool EndsWith(std::wstring_view s, std::wstring_view ss)
 {
 	return s.length() > ss.length() && s.compare(s.length() - ss.length(), ss.length(), ss) == 0;
 }
@@ -887,6 +883,10 @@ ByteArray Encode(const std::wstring& msg, CharacterSet charset, SymbolShape shap
 	context.setSymbolShape(shape);
 	context.setSizeConstraints(minWidth, minHeight, maxWidth, maxHeight);
 
+	constexpr std::wstring_view MACRO_05_HEADER = L"[)>\x1E""05\x1D";
+	constexpr std::wstring_view MACRO_06_HEADER = L"[)>\x1E""06\x1D";
+	constexpr std::wstring_view MACRO_TRAILER = L"\x1E\x04";
+
 	if (StartsWith(msg, MACRO_05_HEADER) && EndsWith(msg, MACRO_TRAILER)) {
 		context.addCodeword(MACRO_05);
 		context.setSkipAtEnd(2);
diff --git a/core/src/datamatrix/DMReader.cpp b/core/src/datamatrix/DMReader.cpp
index 313f39993e..1244c3d0db 100644
--- a/core/src/datamatrix/DMReader.cpp
+++ b/core/src/datamatrix/DMReader.cpp
@@ -12,13 +12,13 @@
 #include "ReaderOptions.h"
 #include "DecoderResult.h"
 #include "DetectorResult.h"
-#include "Result.h"
+#include "Barcode.h"
 
 #include <utility>
 
 namespace ZXing::DataMatrix {
 
-Result Reader::decode(const BinaryBitmap& image) const
+Barcode Reader::decode(const BinaryBitmap& image) const
 {
 #ifdef __cpp_impl_coroutine
 	return FirstOrDefault(decode(image, 1));
@@ -31,28 +31,28 @@ Result Reader::decode(const BinaryBitmap& image) const
 	if (!detectorResult.isValid())
 		return {};
 
-	return Result(Decode(detectorResult.bits()), std::move(detectorResult).position(), BarcodeFormat::DataMatrix);
+	return Barcode(Decode(detectorResult.bits()), std::move(detectorResult), BarcodeFormat::DataMatrix);
 #endif
 }
 
 #ifdef __cpp_impl_coroutine
-Results Reader::decode(const BinaryBitmap& image, int maxSymbols) const
+Barcodes Reader::decode(const BinaryBitmap& image, int maxSymbols) const
 {
 	auto binImg = image.getBitMatrix();
 	if (binImg == nullptr)
 		return {};
 
-	Results results;
+	Barcodes res;
 	for (auto&& detRes : Detect(*binImg, _opts.tryHarder(), _opts.tryRotate(), _opts.isPure())) {
 		auto decRes = Decode(detRes.bits());
 		if (decRes.isValid(_opts.returnErrors())) {
-			results.emplace_back(std::move(decRes), std::move(detRes).position(), BarcodeFormat::DataMatrix);
-			if (maxSymbols > 0 && Size(results) >= maxSymbols)
+			res.emplace_back(std::move(decRes), std::move(detRes), BarcodeFormat::DataMatrix);
+			if (maxSymbols > 0 && Size(res) >= maxSymbols)
 				break;
 		}
 	}
 
-	return results;
+	return res;
 }
 #endif
 } // namespace ZXing::DataMatrix
diff --git a/core/src/datamatrix/DMReader.h b/core/src/datamatrix/DMReader.h
index 62f67142e1..4022870de1 100644
--- a/core/src/datamatrix/DMReader.h
+++ b/core/src/datamatrix/DMReader.h
@@ -15,9 +15,9 @@ class Reader : public ZXing::Reader
 public:
 	using ZXing::Reader::Reader;
 
-	Result decode(const BinaryBitmap& image) const override;
+	Barcode decode(const BinaryBitmap& image) const override;
 #ifdef __cpp_impl_coroutine
-	Results decode(const BinaryBitmap& image, int maxSymbols) const override;
+	Barcodes decode(const BinaryBitmap& image, int maxSymbols) const override;
 #endif
 };
 
diff --git a/core/src/libzint/2of5.c b/core/src/libzint/2of5.c
new file mode 120000
index 0000000000..deb8da22f5
--- /dev/null
+++ b/core/src/libzint/2of5.c
@@ -0,0 +1 @@
+../../../zint/backend/2of5.c
\ No newline at end of file
diff --git a/core/src/libzint/aztec.c b/core/src/libzint/aztec.c
new file mode 120000
index 0000000000..a108e7b150
--- /dev/null
+++ b/core/src/libzint/aztec.c
@@ -0,0 +1 @@
+../../../zint/backend/aztec.c
\ No newline at end of file
diff --git a/core/src/libzint/aztec.h b/core/src/libzint/aztec.h
new file mode 120000
index 0000000000..841e0ffdba
--- /dev/null
+++ b/core/src/libzint/aztec.h
@@ -0,0 +1 @@
+../../../zint/backend/aztec.h
\ No newline at end of file
diff --git a/core/src/libzint/big5.h b/core/src/libzint/big5.h
new file mode 120000
index 0000000000..3d3671649d
--- /dev/null
+++ b/core/src/libzint/big5.h
@@ -0,0 +1 @@
+../../../zint/backend/big5.h
\ No newline at end of file
diff --git a/core/src/libzint/channel_precalcs.h b/core/src/libzint/channel_precalcs.h
new file mode 120000
index 0000000000..dbdcb49c37
--- /dev/null
+++ b/core/src/libzint/channel_precalcs.h
@@ -0,0 +1 @@
+../../../zint/backend/channel_precalcs.h
\ No newline at end of file
diff --git a/core/src/libzint/code.c b/core/src/libzint/code.c
new file mode 120000
index 0000000000..ae9c968fc1
--- /dev/null
+++ b/core/src/libzint/code.c
@@ -0,0 +1 @@
+../../../zint/backend/code.c
\ No newline at end of file
diff --git a/core/src/libzint/code128.c b/core/src/libzint/code128.c
new file mode 120000
index 0000000000..a3fa90e2fd
--- /dev/null
+++ b/core/src/libzint/code128.c
@@ -0,0 +1 @@
+../../../zint/backend/code128.c
\ No newline at end of file
diff --git a/core/src/libzint/code128.h b/core/src/libzint/code128.h
new file mode 120000
index 0000000000..a55244c2ab
--- /dev/null
+++ b/core/src/libzint/code128.h
@@ -0,0 +1 @@
+../../../zint/backend/code128.h
\ No newline at end of file
diff --git a/core/src/libzint/common.c b/core/src/libzint/common.c
new file mode 120000
index 0000000000..3f2a1108de
--- /dev/null
+++ b/core/src/libzint/common.c
@@ -0,0 +1 @@
+../../../zint/backend/common.c
\ No newline at end of file
diff --git a/core/src/libzint/common.h b/core/src/libzint/common.h
new file mode 120000
index 0000000000..d25e9beb7c
--- /dev/null
+++ b/core/src/libzint/common.h
@@ -0,0 +1 @@
+../../../zint/backend/common.h
\ No newline at end of file
diff --git a/core/src/libzint/dmatrix.c b/core/src/libzint/dmatrix.c
new file mode 120000
index 0000000000..b4b445559e
--- /dev/null
+++ b/core/src/libzint/dmatrix.c
@@ -0,0 +1 @@
+../../../zint/backend/dmatrix.c
\ No newline at end of file
diff --git a/core/src/libzint/dmatrix.h b/core/src/libzint/dmatrix.h
new file mode 120000
index 0000000000..cefaca1c6e
--- /dev/null
+++ b/core/src/libzint/dmatrix.h
@@ -0,0 +1 @@
+../../../zint/backend/dmatrix.h
\ No newline at end of file
diff --git a/core/src/libzint/dmatrix_trace.h b/core/src/libzint/dmatrix_trace.h
new file mode 120000
index 0000000000..ffe6939227
--- /dev/null
+++ b/core/src/libzint/dmatrix_trace.h
@@ -0,0 +1 @@
+../../../zint/backend/dmatrix_trace.h
\ No newline at end of file
diff --git a/core/src/libzint/dxfilmedge.c b/core/src/libzint/dxfilmedge.c
new file mode 120000
index 0000000000..21898339e5
--- /dev/null
+++ b/core/src/libzint/dxfilmedge.c
@@ -0,0 +1 @@
+../../../zint/backend/dxfilmedge.c
\ No newline at end of file
diff --git a/core/src/libzint/eci.c b/core/src/libzint/eci.c
new file mode 120000
index 0000000000..d43633ca8b
--- /dev/null
+++ b/core/src/libzint/eci.c
@@ -0,0 +1 @@
+../../../zint/backend/eci.c
\ No newline at end of file
diff --git a/core/src/libzint/eci.h b/core/src/libzint/eci.h
new file mode 120000
index 0000000000..fe57c0f5e9
--- /dev/null
+++ b/core/src/libzint/eci.h
@@ -0,0 +1 @@
+../../../zint/backend/eci.h
\ No newline at end of file
diff --git a/core/src/libzint/eci_sb.h b/core/src/libzint/eci_sb.h
new file mode 120000
index 0000000000..886b41d6e3
--- /dev/null
+++ b/core/src/libzint/eci_sb.h
@@ -0,0 +1 @@
+../../../zint/backend/eci_sb.h
\ No newline at end of file
diff --git a/core/src/libzint/filemem.c b/core/src/libzint/filemem.c
new file mode 120000
index 0000000000..ae6270e9e4
--- /dev/null
+++ b/core/src/libzint/filemem.c
@@ -0,0 +1 @@
+../../../zint/backend/filemem.c
\ No newline at end of file
diff --git a/core/src/libzint/filemem.h b/core/src/libzint/filemem.h
new file mode 120000
index 0000000000..cd1023f51d
--- /dev/null
+++ b/core/src/libzint/filemem.h
@@ -0,0 +1 @@
+../../../zint/backend/filemem.h
\ No newline at end of file
diff --git a/core/src/libzint/fonts/normal_woff2.h b/core/src/libzint/fonts/normal_woff2.h
new file mode 120000
index 0000000000..8454dbb4b1
--- /dev/null
+++ b/core/src/libzint/fonts/normal_woff2.h
@@ -0,0 +1 @@
+../../../../zint/backend/fonts/normal_woff2.h
\ No newline at end of file
diff --git a/core/src/libzint/fonts/upcean_woff2.h b/core/src/libzint/fonts/upcean_woff2.h
new file mode 120000
index 0000000000..fcbcd319cb
--- /dev/null
+++ b/core/src/libzint/fonts/upcean_woff2.h
@@ -0,0 +1 @@
+../../../../zint/backend/fonts/upcean_woff2.h
\ No newline at end of file
diff --git a/core/src/libzint/gb18030.h b/core/src/libzint/gb18030.h
new file mode 120000
index 0000000000..cb6e4e1b4c
--- /dev/null
+++ b/core/src/libzint/gb18030.h
@@ -0,0 +1 @@
+../../../zint/backend/gb18030.h
\ No newline at end of file
diff --git a/core/src/libzint/gb2312.h b/core/src/libzint/gb2312.h
new file mode 120000
index 0000000000..6c92b71ec4
--- /dev/null
+++ b/core/src/libzint/gb2312.h
@@ -0,0 +1 @@
+../../../zint/backend/gb2312.h
\ No newline at end of file
diff --git a/core/src/libzint/gbk.h b/core/src/libzint/gbk.h
new file mode 120000
index 0000000000..36c4daa918
--- /dev/null
+++ b/core/src/libzint/gbk.h
@@ -0,0 +1 @@
+../../../zint/backend/gbk.h
\ No newline at end of file
diff --git a/core/src/libzint/general_field.c b/core/src/libzint/general_field.c
new file mode 120000
index 0000000000..62c09e3511
--- /dev/null
+++ b/core/src/libzint/general_field.c
@@ -0,0 +1 @@
+../../../zint/backend/general_field.c
\ No newline at end of file
diff --git a/core/src/libzint/general_field.h b/core/src/libzint/general_field.h
new file mode 120000
index 0000000000..144c08536d
--- /dev/null
+++ b/core/src/libzint/general_field.h
@@ -0,0 +1 @@
+../../../zint/backend/general_field.h
\ No newline at end of file
diff --git a/core/src/libzint/gs1.c b/core/src/libzint/gs1.c
new file mode 120000
index 0000000000..3f0d779bb5
--- /dev/null
+++ b/core/src/libzint/gs1.c
@@ -0,0 +1 @@
+../../../zint/backend/gs1.c
\ No newline at end of file
diff --git a/core/src/libzint/gs1.h b/core/src/libzint/gs1.h
new file mode 120000
index 0000000000..3f2f32d4dc
--- /dev/null
+++ b/core/src/libzint/gs1.h
@@ -0,0 +1 @@
+../../../zint/backend/gs1.h
\ No newline at end of file
diff --git a/core/src/libzint/gs1_lint.h b/core/src/libzint/gs1_lint.h
new file mode 120000
index 0000000000..ceb3e9e0aa
--- /dev/null
+++ b/core/src/libzint/gs1_lint.h
@@ -0,0 +1 @@
+../../../zint/backend/gs1_lint.h
\ No newline at end of file
diff --git a/core/src/libzint/iso3166.h b/core/src/libzint/iso3166.h
new file mode 120000
index 0000000000..69632c0774
--- /dev/null
+++ b/core/src/libzint/iso3166.h
@@ -0,0 +1 @@
+../../../zint/backend/iso3166.h
\ No newline at end of file
diff --git a/core/src/libzint/iso4217.h b/core/src/libzint/iso4217.h
new file mode 120000
index 0000000000..581144e32e
--- /dev/null
+++ b/core/src/libzint/iso4217.h
@@ -0,0 +1 @@
+../../../zint/backend/iso4217.h
\ No newline at end of file
diff --git a/core/src/libzint/ksx1001.h b/core/src/libzint/ksx1001.h
new file mode 120000
index 0000000000..07b6011655
--- /dev/null
+++ b/core/src/libzint/ksx1001.h
@@ -0,0 +1 @@
+../../../zint/backend/ksx1001.h
\ No newline at end of file
diff --git a/core/src/libzint/large.c b/core/src/libzint/large.c
new file mode 120000
index 0000000000..18ac653b49
--- /dev/null
+++ b/core/src/libzint/large.c
@@ -0,0 +1 @@
+../../../zint/backend/large.c
\ No newline at end of file
diff --git a/core/src/libzint/large.h b/core/src/libzint/large.h
new file mode 120000
index 0000000000..86a04bb82d
--- /dev/null
+++ b/core/src/libzint/large.h
@@ -0,0 +1 @@
+../../../zint/backend/large.h
\ No newline at end of file
diff --git a/core/src/libzint/library.c b/core/src/libzint/library.c
new file mode 120000
index 0000000000..4e970c04b5
--- /dev/null
+++ b/core/src/libzint/library.c
@@ -0,0 +1 @@
+../../../zint/backend/library.c
\ No newline at end of file
diff --git a/core/src/libzint/maxicode.c b/core/src/libzint/maxicode.c
new file mode 120000
index 0000000000..4c2983c0d2
--- /dev/null
+++ b/core/src/libzint/maxicode.c
@@ -0,0 +1 @@
+../../../zint/backend/maxicode.c
\ No newline at end of file
diff --git a/core/src/libzint/maxicode.h b/core/src/libzint/maxicode.h
new file mode 120000
index 0000000000..33302d9147
--- /dev/null
+++ b/core/src/libzint/maxicode.h
@@ -0,0 +1 @@
+../../../zint/backend/maxicode.h
\ No newline at end of file
diff --git a/core/src/libzint/medical.c b/core/src/libzint/medical.c
new file mode 120000
index 0000000000..64507aed2c
--- /dev/null
+++ b/core/src/libzint/medical.c
@@ -0,0 +1 @@
+../../../zint/backend/medical.c
\ No newline at end of file
diff --git a/core/src/libzint/output.c b/core/src/libzint/output.c
new file mode 120000
index 0000000000..3db74e8f38
--- /dev/null
+++ b/core/src/libzint/output.c
@@ -0,0 +1 @@
+../../../zint/backend/output.c
\ No newline at end of file
diff --git a/core/src/libzint/output.h b/core/src/libzint/output.h
new file mode 120000
index 0000000000..294aceedf2
--- /dev/null
+++ b/core/src/libzint/output.h
@@ -0,0 +1 @@
+../../../zint/backend/output.h
\ No newline at end of file
diff --git a/core/src/libzint/pdf417.c b/core/src/libzint/pdf417.c
new file mode 120000
index 0000000000..12d217416a
--- /dev/null
+++ b/core/src/libzint/pdf417.c
@@ -0,0 +1 @@
+../../../zint/backend/pdf417.c
\ No newline at end of file
diff --git a/core/src/libzint/pdf417.h b/core/src/libzint/pdf417.h
new file mode 120000
index 0000000000..398bcd2d7f
--- /dev/null
+++ b/core/src/libzint/pdf417.h
@@ -0,0 +1 @@
+../../../zint/backend/pdf417.h
\ No newline at end of file
diff --git a/core/src/libzint/pdf417_tabs.h b/core/src/libzint/pdf417_tabs.h
new file mode 120000
index 0000000000..239b764616
--- /dev/null
+++ b/core/src/libzint/pdf417_tabs.h
@@ -0,0 +1 @@
+../../../zint/backend/pdf417_tabs.h
\ No newline at end of file
diff --git a/core/src/libzint/pdf417_trace.h b/core/src/libzint/pdf417_trace.h
new file mode 120000
index 0000000000..c0828c83ab
--- /dev/null
+++ b/core/src/libzint/pdf417_trace.h
@@ -0,0 +1 @@
+../../../zint/backend/pdf417_trace.h
\ No newline at end of file
diff --git a/core/src/libzint/qr.c b/core/src/libzint/qr.c
new file mode 120000
index 0000000000..c7b3f4c566
--- /dev/null
+++ b/core/src/libzint/qr.c
@@ -0,0 +1 @@
+../../../zint/backend/qr.c
\ No newline at end of file
diff --git a/core/src/libzint/qr.h b/core/src/libzint/qr.h
new file mode 120000
index 0000000000..27765a1686
--- /dev/null
+++ b/core/src/libzint/qr.h
@@ -0,0 +1 @@
+../../../zint/backend/qr.h
\ No newline at end of file
diff --git a/core/src/libzint/raster.c b/core/src/libzint/raster.c
new file mode 120000
index 0000000000..cd987d43ad
--- /dev/null
+++ b/core/src/libzint/raster.c
@@ -0,0 +1 @@
+../../../zint/backend/raster.c
\ No newline at end of file
diff --git a/core/src/libzint/raster_font.h b/core/src/libzint/raster_font.h
new file mode 120000
index 0000000000..b4d91dda12
--- /dev/null
+++ b/core/src/libzint/raster_font.h
@@ -0,0 +1 @@
+../../../zint/backend/raster_font.h
\ No newline at end of file
diff --git a/core/src/libzint/reedsol.c b/core/src/libzint/reedsol.c
new file mode 120000
index 0000000000..9661877ce3
--- /dev/null
+++ b/core/src/libzint/reedsol.c
@@ -0,0 +1 @@
+../../../zint/backend/reedsol.c
\ No newline at end of file
diff --git a/core/src/libzint/reedsol.h b/core/src/libzint/reedsol.h
new file mode 120000
index 0000000000..51dce9726c
--- /dev/null
+++ b/core/src/libzint/reedsol.h
@@ -0,0 +1 @@
+../../../zint/backend/reedsol.h
\ No newline at end of file
diff --git a/core/src/libzint/reedsol_logs.h b/core/src/libzint/reedsol_logs.h
new file mode 120000
index 0000000000..33e15a3419
--- /dev/null
+++ b/core/src/libzint/reedsol_logs.h
@@ -0,0 +1 @@
+../../../zint/backend/reedsol_logs.h
\ No newline at end of file
diff --git a/core/src/libzint/rss.c b/core/src/libzint/rss.c
new file mode 120000
index 0000000000..ec15132424
--- /dev/null
+++ b/core/src/libzint/rss.c
@@ -0,0 +1 @@
+../../../zint/backend/rss.c
\ No newline at end of file
diff --git a/core/src/libzint/rss.h b/core/src/libzint/rss.h
new file mode 120000
index 0000000000..e321989961
--- /dev/null
+++ b/core/src/libzint/rss.h
@@ -0,0 +1 @@
+../../../zint/backend/rss.h
\ No newline at end of file
diff --git a/core/src/libzint/sjis.h b/core/src/libzint/sjis.h
new file mode 120000
index 0000000000..6d5ee55acc
--- /dev/null
+++ b/core/src/libzint/sjis.h
@@ -0,0 +1 @@
+../../../zint/backend/sjis.h
\ No newline at end of file
diff --git a/core/src/libzint/stubs.c b/core/src/libzint/stubs.c
new file mode 100644
index 0000000000..dfe8914ce1
--- /dev/null
+++ b/core/src/libzint/stubs.c
@@ -0,0 +1,92 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+
+#include "common.h"
+
+#define STUB_PIXEL_PLOT(NAME) \
+	INTERNAL int NAME(struct zint_symbol* symbol, const unsigned char* pixelbuf) \
+	{ \
+		(void)symbol; \
+		(void)pixelbuf; \
+		return ZINT_ERROR_ENCODING_PROBLEM; \
+	}
+
+#define STUB_FUNC_CHAR(NAME) \
+	INTERNAL int NAME(struct zint_symbol* symbol, unsigned char source[], int length) \
+	{ \
+		(void)symbol; \
+		(void)source; \
+		(void)length; \
+		return ZINT_ERROR_ENCODING_PROBLEM; \
+	}
+
+#define STUB_FUNC_SEGS(NAME) \
+	INTERNAL int NAME(struct zint_symbol* symbol, struct zint_seg segs[], const int seg_count) \
+	{ \
+		(void)symbol; \
+		(void)segs; \
+		(void)seg_count; \
+		return ZINT_ERROR_ENCODING_PROBLEM; \
+	}
+
+STUB_PIXEL_PLOT(png_pixel_plot)
+STUB_PIXEL_PLOT(bmp_pixel_plot)
+STUB_PIXEL_PLOT(pcx_pixel_plot)
+STUB_PIXEL_PLOT(gif_pixel_plot)
+STUB_PIXEL_PLOT(tif_pixel_plot)
+
+INTERNAL int ps_plot(struct zint_symbol* symbol)
+{
+	(void)symbol;
+	return ZINT_ERROR_ENCODING_PROBLEM;
+}
+INTERNAL int emf_plot(struct zint_symbol* symbol, int rotate_angle)
+{
+	(void)symbol;
+	(void)rotate_angle;
+	return ZINT_ERROR_ENCODING_PROBLEM;
+}
+
+// STUB_FUNC_CHAR(pzn)
+// STUB_FUNC_CHAR(c25ind)
+// STUB_FUNC_CHAR(c25iata)
+// STUB_FUNC_CHAR(c25inter)
+// STUB_FUNC_CHAR(c25logic)
+// STUB_FUNC_CHAR(itf14)
+// STUB_FUNC_CHAR(dpleit)
+// STUB_FUNC_CHAR(dpident)
+// STUB_FUNC_CHAR(code11)
+STUB_FUNC_CHAR(msi_plessey)
+STUB_FUNC_CHAR(telepen)
+STUB_FUNC_CHAR(telepen_num)
+STUB_FUNC_CHAR(plessey)
+// STUB_FUNC_CHAR(pharma)
+STUB_FUNC_CHAR(flat)
+STUB_FUNC_CHAR(fim)
+// STUB_FUNC_CHAR(pharma_two)
+STUB_FUNC_CHAR(postnet)
+STUB_FUNC_CHAR(planet)
+STUB_FUNC_CHAR(usps_imail)
+STUB_FUNC_CHAR(rm4scc)
+STUB_FUNC_CHAR(auspost)
+STUB_FUNC_CHAR(code16k)
+STUB_FUNC_CHAR(composite)
+STUB_FUNC_CHAR(kix)
+// STUB_FUNC_CHAR(code32)
+STUB_FUNC_CHAR(daft)
+// STUB_FUNC_CHAR(nve18)
+STUB_FUNC_CHAR(koreapost)
+STUB_FUNC_CHAR(japanpost)
+STUB_FUNC_CHAR(code49)
+// STUB_FUNC_CHAR(channel)
+STUB_FUNC_SEGS(codeone)
+STUB_FUNC_SEGS(gridmatrix)
+STUB_FUNC_SEGS(hanxin)
+STUB_FUNC_SEGS(dotcode)
+STUB_FUNC_SEGS(codablockf)
+// STUB_FUNC_CHAR(vin)
+STUB_FUNC_CHAR(mailmark_2d)
+STUB_FUNC_CHAR(mailmark_4s)
+// STUB_FUNC_CHAR(upu_s10)
+STUB_FUNC_SEGS(ultra)
+// STUB_FUNC_CHAR(dpd)
+STUB_FUNC_CHAR(bc412)
diff --git a/core/src/libzint/svg.c b/core/src/libzint/svg.c
new file mode 120000
index 0000000000..fa7fa4d30b
--- /dev/null
+++ b/core/src/libzint/svg.c
@@ -0,0 +1 @@
+../../../zint/backend/svg.c
\ No newline at end of file
diff --git a/core/src/libzint/upcean.c b/core/src/libzint/upcean.c
new file mode 120000
index 0000000000..b554e9f67c
--- /dev/null
+++ b/core/src/libzint/upcean.c
@@ -0,0 +1 @@
+../../../zint/backend/upcean.c
\ No newline at end of file
diff --git a/core/src/libzint/vector.c b/core/src/libzint/vector.c
new file mode 120000
index 0000000000..7ed3081da6
--- /dev/null
+++ b/core/src/libzint/vector.c
@@ -0,0 +1 @@
+../../../zint/backend/vector.c
\ No newline at end of file
diff --git a/core/src/libzint/zfiletypes.h b/core/src/libzint/zfiletypes.h
new file mode 120000
index 0000000000..df4d2a7f4c
--- /dev/null
+++ b/core/src/libzint/zfiletypes.h
@@ -0,0 +1 @@
+../../../zint/backend/zfiletypes.h
\ No newline at end of file
diff --git a/core/src/libzint/zint.h b/core/src/libzint/zint.h
new file mode 120000
index 0000000000..cdc544328c
--- /dev/null
+++ b/core/src/libzint/zint.h
@@ -0,0 +1 @@
+../../../zint/backend/zint.h
\ No newline at end of file
diff --git a/core/src/libzint/zintconfig.h b/core/src/libzint/zintconfig.h
new file mode 120000
index 0000000000..4480044542
--- /dev/null
+++ b/core/src/libzint/zintconfig.h
@@ -0,0 +1 @@
+../../../zint/backend/zintconfig.h
\ No newline at end of file
diff --git a/core/src/maxicode/MCReader.cpp b/core/src/maxicode/MCReader.cpp
index 66f25aa3f8..c27023f6f2 100644
--- a/core/src/maxicode/MCReader.cpp
+++ b/core/src/maxicode/MCReader.cpp
@@ -8,11 +8,11 @@
 
 #include "BinaryBitmap.h"
 #include "BitMatrix.h"
-#include "ReaderOptions.h"
 #include "DecoderResult.h"
+#include "DetectorResult.h"
 #include "MCBitMatrixParser.h"
 #include "MCDecoder.h"
-#include "Result.h"
+#include "Barcode.h"
 
 namespace ZXing::MaxiCode {
 
@@ -44,8 +44,7 @@ static BitMatrix ExtractPureBits(const BitMatrix& image)
 	return result;
 }
 
-Result
-Reader::decode(const BinaryBitmap& image) const
+Barcode Reader::decode(const BinaryBitmap& image) const
 {
 	auto binImg = image.getBitMatrix();
 	if (binImg == nullptr)
@@ -61,7 +60,7 @@ Reader::decode(const BinaryBitmap& image) const
 	if (!decRes.isValid())
 		return {};
 
-	return Result(std::move(decRes), {}, BarcodeFormat::MaxiCode);
+	return Barcode(std::move(decRes), DetectorResult{}, BarcodeFormat::MaxiCode);
 }
 
 } // namespace ZXing::MaxiCode
diff --git a/core/src/maxicode/MCReader.h b/core/src/maxicode/MCReader.h
index f3cfd75a57..9307afc105 100644
--- a/core/src/maxicode/MCReader.h
+++ b/core/src/maxicode/MCReader.h
@@ -15,7 +15,7 @@ class Reader : public ZXing::Reader
 public:
 	using ZXing::Reader::Reader;
 
-	Result decode(const BinaryBitmap& image) const override;
+	Barcode decode(const BinaryBitmap& image) const override;
 };
 
 } // namespace ZXing::MaxiCode
diff --git a/core/src/oned/ODCodabarReader.cpp b/core/src/oned/ODCodabarReader.cpp
index 1d6121bc4c..d503b47d89 100644
--- a/core/src/oned/ODCodabarReader.cpp
+++ b/core/src/oned/ODCodabarReader.cpp
@@ -8,7 +8,7 @@
 #include "ODCodabarReader.h"
 
 #include "ReaderOptions.h"
-#include "Result.h"
+#include "Barcode.h"
 #include "ZXAlgorithms.h"
 
 #include <string>
@@ -45,8 +45,7 @@ bool IsLeftGuard(const PatternView& view, int spaceInPixel)
 		   Contains({0x1A, 0x29, 0x0B, 0x0E}, RowReader::NarrowWideBitPattern(view));
 }
 
-Result
-CodabarReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const
+Barcode CodabarReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const
 {
 	// minimal number of characters that must be present (including start, stop and checksum characters)
 	// absolute minimum would be 2 (meaning 0 'content'). everything below 4 produces too many false
@@ -92,7 +91,7 @@ CodabarReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<D
 	SymbologyIdentifier symbologyIdentifier = {'F', '0'};
 
 	int xStop = next.pixelsTillEnd();
-	return Result(txt, rowNumber, xStart, xStop, BarcodeFormat::Codabar, symbologyIdentifier);
+	return Barcode(txt, rowNumber, xStart, xStop, BarcodeFormat::Codabar, symbologyIdentifier);
 }
 
 } // namespace ZXing::OneD
diff --git a/core/src/oned/ODCodabarReader.h b/core/src/oned/ODCodabarReader.h
index 39634f9e4e..6960fbca8c 100644
--- a/core/src/oned/ODCodabarReader.h
+++ b/core/src/oned/ODCodabarReader.h
@@ -15,7 +15,7 @@ class CodabarReader : public RowReader
 public:
 	using RowReader::RowReader;
 
-	Result decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>& state) const override;
+	Barcode decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>& state) const override;
 };
 
 } // namespace ZXing::OneD
diff --git a/core/src/oned/ODCode128Reader.cpp b/core/src/oned/ODCode128Reader.cpp
index 9d0927eab6..bacb033694 100644
--- a/core/src/oned/ODCode128Reader.cpp
+++ b/core/src/oned/ODCode128Reader.cpp
@@ -7,15 +7,13 @@
 #include "ODCode128Reader.h"
 
 #include "ODCode128Patterns.h"
-#include "Result.h"
+#include "Barcode.h"
 #include "ZXAlgorithms.h"
 
 #include <array>
 #include <cstddef>
 #include <cstdint>
-#include <initializer_list>
 #include <string>
-#include <utility>
 #include <vector>
 
 namespace ZXing::OneD {
@@ -160,7 +158,7 @@ class Raw2TxtDecoder
 constexpr auto START_PATTERN_PREFIX = FixedPattern<3, 4>{2, 1, 1};
 constexpr int CHAR_LEN = 6;
 constexpr float QUIET_ZONE = 5;	// quiet zone spec is 10 modules, real world examples ignore that, see #138
-constexpr int CHAR_SUM = 11;
+constexpr int CHAR_MODS = 11;
 
 //TODO: make this a constexpr variable initialization
 static auto E2E_PATTERNS = [] {
@@ -177,12 +175,12 @@ static auto E2E_PATTERNS = [] {
 	return res;
 }();
 
-Result Code128Reader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const
+Barcode Code128Reader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const
 {
 	int minCharCount = 4; // start + payload + checksum + stop
 	auto decodePattern = [](const PatternView& view, bool start = false) {
 		// This is basically the reference algorithm from the specification
-		int code = IndexOf(E2E_PATTERNS, ToInt(NormalizedE2EPattern<CHAR_LEN, CHAR_SUM>(view)));
+		int code = IndexOf(E2E_PATTERNS, ToInt(NormalizedE2EPattern<CHAR_LEN>(view, CHAR_MODS)));
 		if (code == -1 && !start) // if the reference algo fails, give the original upstream version a try (required to decode a few samples)
 			code = DecodeDigit(view, Code128::CODE_PATTERNS, MAX_AVG_VARIANCE, MAX_INDIVIDUAL_VARIANCE);
 		return code;
@@ -240,8 +238,8 @@ Result Code128Reader::decodePattern(int rowNumber, PatternView& next, std::uniqu
 		error = ChecksumError();
 
 	int xStop = next.pixelsTillEnd();
-	return Result(raw2txt.text(), rowNumber, xStart, xStop, BarcodeFormat::Code128, raw2txt.symbologyIdentifier(), error,
-				  raw2txt.readerInit());
+	return Barcode(raw2txt.text(), rowNumber, xStart, xStop, BarcodeFormat::Code128, raw2txt.symbologyIdentifier(), error,
+				   raw2txt.readerInit());
 }
 
 } // namespace ZXing::OneD
diff --git a/core/src/oned/ODCode128Reader.h b/core/src/oned/ODCode128Reader.h
index 60526fa469..c5e4b4dc72 100644
--- a/core/src/oned/ODCode128Reader.h
+++ b/core/src/oned/ODCode128Reader.h
@@ -15,7 +15,7 @@ class Code128Reader : public RowReader
 public:
 	using RowReader::RowReader;
 
-	Result decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
+	Barcode decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
 };
 
 } // namespace ZXing::OneD
diff --git a/core/src/oned/ODCode128Writer.cpp b/core/src/oned/ODCode128Writer.cpp
index 8cc9b41d4a..1f7b583194 100644
--- a/core/src/oned/ODCode128Writer.cpp
+++ b/core/src/oned/ODCode128Writer.cpp
@@ -153,7 +153,7 @@ Code128Writer::encode(const std::wstring& contents, int width, int height) const
 		default:
 			if (c > 127) {
 				// support for FNC4 isn't implemented, no full Latin-1 character set available at the moment
-				throw std::invalid_argument(std::string("Bad character in input: ") + static_cast<char>(c));
+				throw std::invalid_argument("Bad character in input: " + ToUtf8(contents.substr(i, 1)));
 			}
 		}
 	}
diff --git a/core/src/oned/ODCode39Reader.cpp b/core/src/oned/ODCode39Reader.cpp
index ee3dc9da32..411a2dda76 100644
--- a/core/src/oned/ODCode39Reader.cpp
+++ b/core/src/oned/ODCode39Reader.cpp
@@ -7,8 +7,7 @@
 #include "ODCode39Reader.h"
 
 #include "ReaderOptions.h"
-#include "DecoderResult.h"
-#include "Result.h"
+#include "Barcode.h"
 #include "ZXAlgorithms.h"
 
 #include <array>
@@ -48,10 +47,9 @@ using CounterContainer = std::array<int, 9>;
 // each character has 5 bars and 4 spaces
 constexpr int CHAR_LEN = 9;
 
-/** Decode the extended string in place. Return false if FormatError occurred.
+/** Decode the full ASCII string. Return empty string if FormatError occurred.
  * ctrl is either "$%/+" for code39 or "abcd" for code93. */
-bool
-DecodeExtendedCode39AndCode93(std::string& encoded, const char ctrl[4])
+std::string DecodeCode39AndCode93FullASCII(std::string encoded, const char ctrl[4])
 {
 	auto out = encoded.begin();
 	for (auto in = encoded.cbegin(); in != encoded.cend(); ++in) {
@@ -59,7 +57,7 @@ DecodeExtendedCode39AndCode93(std::string& encoded, const char ctrl[4])
 		if (Contains(ctrl, c)) {
 			char next = *++in; // if in is one short of cend(), then next == 0
 			if (next < 'A' || next > 'Z')
-				return false;
+				return {};
 			if (c == ctrl[0])
 				c = next - 64; // $A to $Z map to control codes SH to SB
 			else if (c == ctrl[1])
@@ -72,10 +70,10 @@ DecodeExtendedCode39AndCode93(std::string& encoded, const char ctrl[4])
 		*out++ = c;
 	}
 	encoded.erase(out, encoded.end());
-	return true;
+	return encoded;
 }
 
-Result Code39Reader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<RowReader::DecodingState>&) const
+Barcode Code39Reader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<RowReader::DecodingState>&) const
 {
 	// minimal number of characters that must be present (including start, stop and checksum characters)
 	int minCharCount = _opts.validateCode39CheckSum() ? 4 : 3;
@@ -115,24 +113,30 @@ Result Code39Reader::decodePattern(int rowNumber, PatternView& next, std::unique
 	if (Size(txt) < minCharCount - 2 || !next.hasQuietZoneAfter(QUIET_ZONE_SCALE))
 		return {};
 
-	Error error;
-	if (_opts.validateCode39CheckSum()) {
-		auto checkDigit = txt.back();
-		txt.pop_back();
-		int checksum = TransformReduce(txt, 0, [](char c) { return IndexOf(ALPHABET, c); });
-		if (checkDigit != ALPHABET[checksum % 43])
-			error = ChecksumError();
-	}
+	auto lastChar = txt.back();
+	txt.pop_back();
+	int checksum = TransformReduce(txt, 0, [](char c) { return IndexOf(ALPHABET, c); });
+	bool hasValidCheckSum = lastChar == ALPHABET[checksum % 43];
+	if (!hasValidCheckSum)
+		txt.push_back(lastChar);
+
+	const char shiftChars[] = "$%/+";
+	auto fullASCII = _opts.tryCode39ExtendedMode() ? DecodeCode39AndCode93FullASCII(txt, shiftChars) : "";
+	bool hasFullASCII = !fullASCII.empty() && std::find_first_of(txt.begin(), txt.end(), shiftChars, shiftChars + 4) != txt.end();
+	if (hasFullASCII)
+		txt = fullASCII;
+
+	if (hasValidCheckSum)
+		txt.push_back(lastChar);
 
-	if (!error && _opts.tryCode39ExtendedMode() && !DecodeExtendedCode39AndCode93(txt, "$%/+"))
-		error = FormatError("Decoding extended Code39/Code93 failed");
+	Error error = _opts.validateCode39CheckSum() && !hasValidCheckSum ? ChecksumError() : Error();
 
 	// Symbology identifier modifiers ISO/IEC 16388:2007 Annex C Table C.1
-	constexpr const char symbologyModifiers[4] = { '0', '3' /*checksum*/, '4' /*extended*/, '7' /*checksum,extended*/ };
-	SymbologyIdentifier symbologyIdentifier = {'A', symbologyModifiers[(int)_opts.tryCode39ExtendedMode() * 2 + (int)_opts.validateCode39CheckSum()]};
+	constexpr const char symbologyModifiers[4] = { '0', '1' /*checksum*/, '4' /*full ASCII*/, '5' /*checksum + full ASCII*/ };
+	SymbologyIdentifier symbologyIdentifier = {'A', symbologyModifiers[(int)hasValidCheckSum + 2 * (int)hasFullASCII]};
 
 	int xStop = next.pixelsTillEnd();
-	return Result(std::move(txt), rowNumber, xStart, xStop, BarcodeFormat::Code39, symbologyIdentifier, error);
+	return {std::move(txt), rowNumber, xStart, xStop, BarcodeFormat::Code39, symbologyIdentifier, error};
 }
 
 } // namespace ZXing::OneD
diff --git a/core/src/oned/ODCode39Reader.h b/core/src/oned/ODCode39Reader.h
index 51b7139fe8..c8db8aff71 100644
--- a/core/src/oned/ODCode39Reader.h
+++ b/core/src/oned/ODCode39Reader.h
@@ -20,7 +20,7 @@ class Code39Reader : public RowReader
 	*/
 	using RowReader::RowReader;
 
-	Result decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
+	Barcode decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
 };
 
 } // namespace ZXing::OneD
diff --git a/core/src/oned/ODCode93Reader.cpp b/core/src/oned/ODCode93Reader.cpp
index cfeaa0db3f..969e951bf4 100644
--- a/core/src/oned/ODCode93Reader.cpp
+++ b/core/src/oned/ODCode93Reader.cpp
@@ -7,7 +7,7 @@
 
 #include "ODCode93Reader.h"
 
-#include "Result.h"
+#include "Barcode.h"
 #include "ZXAlgorithms.h"
 
 #include <array>
@@ -62,7 +62,7 @@ CheckChecksums(const std::string& result)
 }
 
 // forward declare here. see ODCode39Reader.cpp. Not put in header to not pollute the public facing API
-bool DecodeExtendedCode39AndCode93(std::string& encoded, const char ctrl[4]);
+std::string DecodeCode39AndCode93FullASCII(std::string encoded, const char ctrl[4]);
 
 constexpr int CHAR_LEN = 6;
 constexpr int CHAR_SUM = 9;
@@ -80,7 +80,7 @@ static bool IsStartGuard(const PatternView& window, int spaceInPixel)
 		   RowReader::OneToFourBitPattern<CHAR_LEN, CHAR_SUM>(window) == ASTERISK_ENCODING;
 }
 
-Result Code93Reader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const
+Barcode Code93Reader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const
 {
 	// minimal number of characters that must be present (including start, stop, checksum and 1 payload characters)
 	int minCharCount = 5;
@@ -121,14 +121,14 @@ Result Code93Reader::decodePattern(int rowNumber, PatternView& next, std::unique
 	// Remove checksum digits
 	txt.resize(txt.size() - 2);
 
-	if (!error && !DecodeExtendedCode39AndCode93(txt, "abcd"))
-		error = FormatError("Decoding extended Code39/Code93 failed");
+	if (!error && (txt = DecodeCode39AndCode93FullASCII(txt, "abcd")).empty())
+		error = FormatError("ASCII decoding of Code93 failed");
 
 	// Symbology identifier ISO/IEC 15424:2008 4.4.10 no modifiers
 	SymbologyIdentifier symbologyIdentifier = {'G', '0'};
 
 	int xStop = next.pixelsTillEnd();
-	return Result(txt, rowNumber, xStart, xStop, BarcodeFormat::Code93, symbologyIdentifier, error);
+	return Barcode(txt, rowNumber, xStart, xStop, BarcodeFormat::Code93, symbologyIdentifier, error);
 }
 
 } // namespace ZXing::OneD
diff --git a/core/src/oned/ODCode93Reader.h b/core/src/oned/ODCode93Reader.h
index b8ea6125d0..83692cdedd 100644
--- a/core/src/oned/ODCode93Reader.h
+++ b/core/src/oned/ODCode93Reader.h
@@ -15,7 +15,7 @@ class Code93Reader : public RowReader
 public:
 	using RowReader::RowReader;
 
-	Result decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
+	Barcode decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
 };
 
 } // namespace ZXing::OneD
diff --git a/core/src/oned/ODDXFilmEdgeReader.cpp b/core/src/oned/ODDXFilmEdgeReader.cpp
new file mode 100644
index 0000000000..7b197dd576
--- /dev/null
+++ b/core/src/oned/ODDXFilmEdgeReader.cpp
@@ -0,0 +1,225 @@
+/*
+ * Copyright 2023 Antoine Mérino
+ * Copyright 2023 Axel Waggershauser
+ */
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODDXFilmEdgeReader.h"
+
+#include "Barcode.h"
+
+#include <optional>
+#include <vector>
+
+namespace ZXing::OneD {
+
+namespace {
+
+// Detection is made from center outward.
+// We ensure the clock track is decoded before the data track to avoid false positives.
+// They are two version of a DX Edge codes : with and without frame number.
+// The clock track is longer if the DX code contains the frame number (more recent version)
+constexpr int CLOCK_LENGTH_FN = 31;
+constexpr int CLOCK_LENGTH_NO_FN = 23;
+
+// data track length, without the start and stop patterns
+constexpr int DATA_LENGTH_FN = 23;
+constexpr int DATA_LENGTH_NO_FN = 15;
+
+constexpr auto CLOCK_PATTERN_FN =
+	FixedPattern<25, CLOCK_LENGTH_FN>{5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3};
+constexpr auto CLOCK_PATTERN_NO_FN = FixedPattern<17, CLOCK_LENGTH_NO_FN>{5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3};
+constexpr auto DATA_START_PATTERN = FixedPattern<5, 5>{1, 1, 1, 1, 1};
+constexpr auto DATA_STOP_PATTERN = FixedPattern<3, 3>{1, 1, 1};
+
+template <int N, int SUM>
+bool IsPattern(PatternView& view, const FixedPattern<N, SUM>& pattern, float minQuietZone)
+{
+	view = view.subView(0, N);
+	return view.isValid() && IsPattern(view, pattern, view.isAtFirstBar() ? std::numeric_limits<int>::max() : view[-1], minQuietZone);
+}
+
+bool DistIsBelowThreshold(PointI a, PointI b, PointI threshold)
+{
+	return std::abs(a.x - b.x) < threshold.x && std::abs(a.y - b.y) < threshold.y;
+}
+
+// DX Film Edge clock track found on 35mm films.
+struct Clock
+{
+	bool hasFrameNr = false; // Clock track (thus data track) with frame number (longer version)
+	int rowNumber = 0;
+	int xStart = 0; // Beginning of the clock track on the X-axis, in pixels
+	int xStop = 0; // End of the clock track on the X-axis, in pixels
+
+	int dataLength() const { return hasFrameNr ? DATA_LENGTH_FN : DATA_LENGTH_NO_FN; }
+
+	float moduleSize() const { return float(xStop - xStart) / (hasFrameNr ? CLOCK_LENGTH_FN : CLOCK_LENGTH_NO_FN); }
+
+	bool isCloseTo(PointI p, int x) const { return DistIsBelowThreshold(p, {x, rowNumber}, PointI(moduleSize() * PointF{0.5, 4})); }
+
+	bool isCloseToStart(int x, int y) const { return isCloseTo({x, y}, xStart); }
+	bool isCloseToStop(int x, int y) const { return isCloseTo({x, y}, xStop); }
+};
+
+struct DXFEState : public RowReader::DecodingState
+{
+	int centerRow = 0;
+	std::vector<Clock> clocks;
+
+	// see if we a clock that starts near {x, y}
+	Clock* findClock(int x, int y)
+	{
+		auto i = FindIf(clocks, [start = PointI{x, y}](auto& v) { return v.isCloseToStart(start.x, start.y); });
+		return i != clocks.end() ? &(*i) : nullptr;
+	}
+
+	// add/update clock
+	void addClock(const Clock& clock)
+	{
+		if (Clock* i = findClock(clock.xStart, clock.rowNumber))
+			*i = clock;
+		else
+			clocks.push_back(clock);
+	}
+};
+
+std::optional<Clock> CheckForClock(int rowNumber, PatternView& view)
+{
+	Clock clock;
+
+	if (IsPattern(view, CLOCK_PATTERN_FN, 0.5)) // On FN versions, the decimal number can be really close to the clock
+		clock.hasFrameNr = true;
+	else if (IsPattern(view, CLOCK_PATTERN_NO_FN, 2.0))
+		clock.hasFrameNr = false;
+	else
+		return {};
+
+	clock.rowNumber = rowNumber;
+	clock.xStart = view.pixelsInFront();
+	clock.xStop = view.pixelsTillEnd();
+
+	return clock;
+}
+
+} // namespace
+
+Barcode DXFilmEdgeReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>& state) const
+{
+	if (!state) {
+		state.reset(new DXFEState);
+		static_cast<DXFEState*>(state.get())->centerRow = rowNumber;
+	}
+
+	auto dxState = static_cast<DXFEState*>(state.get());
+
+	// Only consider rows below the center row of the image
+	if (!_opts.tryRotate() && rowNumber < dxState->centerRow)
+		return {};
+
+	// Look for a pattern that is part of both the clock as well as the data track (ommitting the first bar)
+	constexpr auto Is4x1 = [](const PatternView& view, int spaceInPixel) {
+		// find min/max of 4 consecutive bars/spaces and make sure they are close together
+		auto [m, M] = std::minmax({view[1], view[2], view[3], view[4]});
+		return M <= m * 4 / 3 + 1 && spaceInPixel > m / 2;
+	};
+
+	// 12 is the minimum size of the data track (at least one product class bit + one parity bit)
+	next = FindLeftGuard<4>(next, 10, Is4x1);
+	if (!next.isValid())
+		return {};
+
+	// Check if the 4x1 pattern is part of a clock track
+	if (auto clock = CheckForClock(rowNumber, next)) {
+		dxState->addClock(*clock);
+		next.skipSymbol();
+		return {};
+	}
+
+	// Without at least one clock track, we stop here
+	if (dxState->clocks.empty())
+		return {};
+
+	constexpr float minDataQuietZone = 0.5;
+
+	if (!IsPattern(next, DATA_START_PATTERN, minDataQuietZone))
+		return {};
+
+	auto xStart = next.pixelsInFront();
+
+	// Only consider data tracks that are next to a clock track
+	auto clock = dxState->findClock(xStart, rowNumber);
+	if (!clock)
+		return {};
+
+	// Skip the data start pattern (black, white, black, white, black)
+	// The first signal bar is always white: this is the
+	// separation between the start pattern and the product number
+	next.skipSymbol();
+
+	// Read the data bits
+	BitArray dataBits;
+	while (next.isValid(1) && dataBits.size() < clock->dataLength()) {
+
+		int modules = int(next[0] / clock->moduleSize() + 0.5);
+		// even index means we are at a bar, otherwise at a space
+		dataBits.appendBits(next.index() % 2 == 0 ? 0xFFFFFFFF : 0x0, modules);
+
+		next.shift(1);
+	}
+
+	// Check the data track length
+	if (dataBits.size() != clock->dataLength())
+		return {};
+
+	next = next.subView(0, DATA_STOP_PATTERN.size());
+
+	// Check there is the Stop pattern at the end of the data track
+	if (!next.isValid() || !IsRightGuard(next, DATA_STOP_PATTERN, minDataQuietZone))
+		return {};
+
+	// The following bits are always white (=false), they are separators.
+	if (dataBits.get(0) || dataBits.get(8) || (clock->hasFrameNr ? (dataBits.get(20) || dataBits.get(22)) : dataBits.get(14)))
+		return {};
+
+	// Check the parity bit
+	auto signalSum = Reduce(dataBits.begin(), dataBits.end() - 2, 0);
+	auto parityBit = *(dataBits.end() - 2);
+	if (signalSum % 2 != (int)parityBit)
+		return {};
+
+	// Compute the DX 1 number (product number)
+	auto productNumber = ToInt(dataBits, 1, 7);
+	if (!productNumber)
+		return {};
+
+	// Compute the DX 2 number (generation number)
+	auto generationNumber = ToInt(dataBits, 9, 4);
+
+	// Generate the textual representation.
+	// Eg: 115-10/11A means: DX1 = 115, DX2 = 10, Frame number = 11A
+	std::string txt;
+	txt.reserve(10);
+	txt = std::to_string(productNumber) + "-" + std::to_string(generationNumber);
+	if (clock->hasFrameNr) {
+		auto frameNr = ToInt(dataBits, 13, 6);
+		txt += "/" + std::to_string(frameNr);
+		if (dataBits.get(19))
+			txt += "A";
+	}
+
+	auto xStop = next.pixelsTillEnd();
+
+	// The found data track must end near the clock track
+	if (!clock->isCloseToStop(xStop, rowNumber))
+		return {};
+
+	// Update the clock coordinates with the latest corresponding data track
+	// This may improve signal detection for next row iterations
+	clock->xStart = xStart;
+	clock->xStop = xStop;
+
+	return Barcode(txt, rowNumber, xStart, xStop, BarcodeFormat::DXFilmEdge, {});
+}
+
+} // namespace ZXing::OneD
diff --git a/core/src/oned/ODDXFilmEdgeReader.h b/core/src/oned/ODDXFilmEdgeReader.h
new file mode 100644
index 0000000000..999e42f75c
--- /dev/null
+++ b/core/src/oned/ODDXFilmEdgeReader.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2023 Antoine Mérino
+ */
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ODRowReader.h"
+
+namespace ZXing::OneD {
+
+/**
+ * <p>Implements decoding of the DX Edge Film code format, a type or barcode found on 35mm films.</p>
+ *
+ * <p>See <a href="https://en.wikipedia.org/wiki/DX_encoding">https://en.wikipedia.org/wiki/DX_encoding</a></p>
+ */
+
+class DXFilmEdgeReader : public RowReader
+{
+public:
+	using RowReader::RowReader;
+
+	Barcode decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
+};
+
+} // namespace ZXing::OneD
diff --git a/core/src/oned/ODDataBarCommon.cpp b/core/src/oned/ODDataBarCommon.cpp
index 937f350005..5c63800c47 100644
--- a/core/src/oned/ODDataBarCommon.cpp
+++ b/core/src/oned/ODDataBarCommon.cpp
@@ -4,6 +4,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "ODDataBarCommon.h"
+
 #include <cmath>
 
 namespace ZXing::OneD::DataBar {
@@ -35,7 +36,11 @@ static int combins(int n, int r)
 	return val;
 }
 
+#ifdef __cpp_lib_span
+int GetValue(const std::span<int> widths, int maxWidth, bool noNarrow)
+#else
 int GetValue(const Array4I& widths, int maxWidth, bool noNarrow)
+#endif
 {
 	int elements = Size(widths);
 	int n = Reduce(widths);
@@ -64,18 +69,19 @@ int GetValue(const Array4I& widths, int maxWidth, bool noNarrow)
 	return val;
 }
 
-template <typename T>
-struct OddEven
-{
-	T odd = {}, evn = {};
-	T& operator[](int i) { return i & 1 ? evn : odd; }
-};
-
 using Array4F = std::array<float, 4>;
 
 bool ReadDataCharacterRaw(const PatternView& view, int numModules, bool reversed, Array4I& oddPattern,
 						  Array4I& evnPattern)
 {
+#if 1
+	auto pattern = NormalizedPatternFromE2E<8>(view, numModules, reversed);
+	OddEven<Array4I&> res = {oddPattern, evnPattern};
+
+	for (int i = 0; i < Size(pattern); ++i)
+		res[i % 2][i / 2] = pattern[i];
+
+#else
 	OddEven<Array4I&> res = {oddPattern, evnPattern};
 	OddEven<Array4F> rem;
 
@@ -88,6 +94,7 @@ bool ReadDataCharacterRaw(const PatternView& view, int numModules, bool reversed
 		res[i % 2][i / 2] = int(v + .5f);
 		rem[i % 2][i / 2] = v - res[i % 2][i / 2];
 	}
+#endif
 
 	// DataBarExpanded data character is 17 modules wide
 	// DataBar outer   data character is 16 modules wide
diff --git a/core/src/oned/ODDataBarCommon.h b/core/src/oned/ODDataBarCommon.h
index f6fe301437..cb937ebb17 100644
--- a/core/src/oned/ODDataBarCommon.h
+++ b/core/src/oned/ODDataBarCommon.h
@@ -7,11 +7,15 @@
 
 #include "ODRowReader.h"
 #include "Pattern.h"
-#include "Result.h"
+#include "Barcode.h"
 
 #include <array>
 #include <cmath>
 
+#if __has_include(<span>) // c++20
+#include <span>
+#endif
+
 namespace ZXing::OneD::DataBar {
 
 inline bool IsFinder(int a, int b, int c, int d, int e)
@@ -110,23 +114,85 @@ struct PairHash
 constexpr int FULL_PAIR_SIZE = 8 + 5 + 8;
 constexpr int HALF_PAIR_SIZE = 8 + 5 + 2; // half has to be followed by a guard pattern
 
-template<typename T>
-int ParseFinderPattern(const PatternView& view, bool reversed, T l2rPattern, T r2lPattern)
+template<int N>
+int ParseFinderPattern(const PatternView& view, bool reversed, const std::array<std::array<int, 3>, N>& e2ePatterns)
 {
-	constexpr float MAX_AVG_VARIANCE        = 0.2f;
-	constexpr float MAX_INDIVIDUAL_VARIANCE = 0.45f;
-
-	int i = 1 + RowReader::DecodeDigit(view, reversed ? r2lPattern : l2rPattern, MAX_AVG_VARIANCE,
-									   MAX_INDIVIDUAL_VARIANCE, true);
+	const auto e2e = NormalizedE2EPattern<5>(view, 15, reversed);
+
+	int best_i, best_e = 3;
+	for (int i = 0; i < Size(e2ePatterns); ++i) {
+		int e = 0;
+		for (int j = 0; j < 3; ++j)
+			e += std::abs(e2ePatterns[i][j] - e2e[j]);
+		if (e < best_e) {
+			best_e = e;
+			best_i = i;
+		}
+	}
+	int i = best_e <= 1 ? 1 + best_i : 0;
 	return reversed ? -i : i;
 }
 
+template <typename T>
+struct OddEven
+{
+	T odd = {}, evn = {};
+	T& operator[](int i) { return i & 1 ? evn : odd; }
+};
+
 using Array4I = std::array<int, 4>;
 
+// elements() determines the element widths of an (n,k) character with
+// at least one even-numbered element that's just one module wide.
+// (Note: even-numbered elements - 2nd, 4th, 6th, etc., have odd indexes)
+// for DataBarLimited: LEN=14, mods=26/18
+template <int LEN>
+std::array<int, LEN> NormalizedPatternFromE2E(const PatternView& view, int mods, bool reversed = false)
+{
+	bool isExp = mods == 17; // elementsExp() with at least one odd-numbered element that's just one module wide
+	const auto e2e = NormalizedE2EPattern<LEN>(view, mods, reversed);
+	std::array<int, LEN> widths;
+
+	// derive element widths from normalized edge-to-similar-edge measurements
+	int barSum = widths[0] = isExp ? 8 : 1; // first assume 1st bar is 1 / 8
+	for (int i = 0; i < Size(e2e); i++) {
+		widths[i + 1] = e2e[i] - widths[i];
+		barSum += widths[i + 1];
+	}
+	widths.back() = mods - barSum; // last even element makes mods modules
+
+	// int minEven = widths[1];
+	// for (int i = 3; i < Size(widths); i += 2)
+	// 	minEven = std::min(minEven, widths[i]);
+	OddEven<int> min = {widths[0], widths[1]};
+	for (int i = 2; i < Size(widths); i++)
+		min[i] = std::min(min[i], widths[i]);
+
+	if (isExp && min[0] > 1) {
+		// minimum odd width is too big, readjust so minimum odd is 1
+		for (int i = 0; i < Size(widths); i += 2) {
+			widths[i] -= min[0] - 1;
+			widths[i + 1] += min[0] - 1;
+		}
+	} else if (!isExp && min[1] > 1) {
+		// minimum even width is too big, readjust so minimum even is 1
+		for (int i = 0; i < Size(widths); i += 2) {
+			widths[i] += min[1] - 1;
+			widths[i + 1] -= min[1] - 1;
+		}
+	}
+
+	return widths;
+}
+
 bool ReadDataCharacterRaw(const PatternView& view, int numModules, bool reversed, Array4I& oddPattern,
 						  Array4I& evnPattern);
 
+#ifdef __cpp_lib_span
+int GetValue(const std::span<int> widths, int maxWidth, bool noNarrow);
+#else
 int GetValue(const Array4I& widths, int maxWidth, bool noNarrow);
+#endif
 
 Position EstimatePosition(const Pair& first, const Pair& last);
 int EstimateLineCount(const Pair& first, const Pair& last);
diff --git a/core/src/oned/ODDataBarExpandedBitDecoder.cpp b/core/src/oned/ODDataBarExpandedBitDecoder.cpp
index aa0484769e..d467928fe9 100644
--- a/core/src/oned/ODDataBarExpandedBitDecoder.cpp
+++ b/core/src/oned/ODDataBarExpandedBitDecoder.cpp
@@ -11,8 +11,6 @@
 #include "Error.h"
 #include "GTIN.h"
 
-#include <cmath>
-
 namespace ZXing::OneD::DataBar {
 
 constexpr char GS = 29; // FNC1
@@ -214,34 +212,37 @@ static std::string DecodeAI013x0x1x(BitArrayView& bits, const char* aiPrefix, co
 
 std::string DecodeExpandedBits(const BitArray& _bits)
 {
-	auto bits = BitArrayView(_bits);
-	bits.readBits(1); // skip linkage bit
+	try {
+		auto bits = BitArrayView(_bits);
+		bits.readBits(1); // skip linkage bit
 
-	if (bits.peakBits(1) == 1)
-		return DecodeAI01AndOtherAIs(bits.skipBits(1));
+		if (bits.peakBits(1) == 1)
+			return DecodeAI01AndOtherAIs(bits.skipBits(1));
 
-	if (bits.peakBits(2) == 0)
-		return DecodeAnyAI(bits.skipBits(2));
+		if (bits.peakBits(2) == 0)
+			return DecodeAnyAI(bits.skipBits(2));
 
-	switch (bits.peakBits(4)) {
-	case 4: return DecodeAI013103(bits.skipBits(4));
-	case 5: return DecodeAI01320x(bits.skipBits(4));
-	}
+		switch (bits.peakBits(4)) {
+		case 4: return DecodeAI013103(bits.skipBits(4));
+		case 5: return DecodeAI01320x(bits.skipBits(4));
+		}
 
-	switch (bits.peakBits(5)) {
-	case 12: return DecodeAI0139yx(bits.skipBits(5), '2');
-	case 13: return DecodeAI0139yx(bits.skipBits(5), '3');
-	}
+		switch (bits.peakBits(5)) {
+		case 12: return DecodeAI0139yx(bits.skipBits(5), '2');
+		case 13: return DecodeAI0139yx(bits.skipBits(5), '3');
+		}
 
-	switch (bits.readBits(7)) {
-	case 56: return DecodeAI013x0x1x(bits, "310", "11");
-	case 57: return DecodeAI013x0x1x(bits, "320", "11");
-	case 58: return DecodeAI013x0x1x(bits, "310", "13");
-	case 59: return DecodeAI013x0x1x(bits, "320", "13");
-	case 60: return DecodeAI013x0x1x(bits, "310", "15");
-	case 61: return DecodeAI013x0x1x(bits, "320", "15");
-	case 62: return DecodeAI013x0x1x(bits, "310", "17");
-	case 63: return DecodeAI013x0x1x(bits, "320", "17");
+		switch (bits.readBits(7)) {
+		case 56: return DecodeAI013x0x1x(bits, "310", "11");
+		case 57: return DecodeAI013x0x1x(bits, "320", "11");
+		case 58: return DecodeAI013x0x1x(bits, "310", "13");
+		case 59: return DecodeAI013x0x1x(bits, "320", "13");
+		case 60: return DecodeAI013x0x1x(bits, "310", "15");
+		case 61: return DecodeAI013x0x1x(bits, "320", "15");
+		case 62: return DecodeAI013x0x1x(bits, "310", "17");
+		case 63: return DecodeAI013x0x1x(bits, "320", "17");
+		}
+	} catch (Error) {
 	}
 
 	return {};
diff --git a/core/src/oned/ODDataBarExpandedReader.cpp b/core/src/oned/ODDataBarExpandedReader.cpp
index 4054864625..19c63ba59d 100644
--- a/core/src/oned/ODDataBarExpandedReader.cpp
+++ b/core/src/oned/ODDataBarExpandedReader.cpp
@@ -9,9 +9,10 @@
 
 #include "BarcodeFormat.h"
 #include "DecoderResult.h"
+#include "DetectorResult.h"
 #include "ODDataBarCommon.h"
 #include "ODDataBarExpandedBitDecoder.h"
-#include "Result.h"
+#include "Barcode.h"
 
 #include <cmath>
 #include <map>
@@ -136,19 +137,16 @@ static const std::array<int, 7> VALID_HALF_PAIRS = {{-FINDER_A, FINDER_B, -FINDE
 
 static int ParseFinderPattern(const PatternView& view, Direction dir)
 {
-	static constexpr std::array<FixedPattern<5, 15>, 6> FINDER_PATTERNS = {{
-		{1, 8, 4, 1, 1}, // A
-		{3, 6, 4, 1, 1}, // B
-		{3, 4, 6, 1, 1}, // C
-		{3, 2, 8, 1, 1}, // D
-		{2, 6, 5, 1, 1}, // E
-		{2, 2, 9, 1, 1}, // F
+	static constexpr std::array<std::array<int, 3>, 6> e2ePatterns = {{
+		{9, 12, 5 }, // {1, 8, 4, 1, 1}, // A
+		{9, 10, 5 }, // {3, 6, 4, 1, 1}, // B
+		{7, 10, 7 }, // {3, 4, 6, 1, 1}, // C
+		{5, 10, 9 }, // {3, 2, 8, 1, 1}, // D
+		{8, 11, 6 }, // {2, 6, 5, 1, 1}, // E
+		{4, 11, 10}, // {2, 2, 9, 1, 1}, // F
 	}};
-	// TODO: c++20 constexpr inversion from FIND_PATTERN?
-	static constexpr std::array<FixedPattern<5, 15>, 6> REVERSED_FINDER_PATTERNS = {
-		{{1, 1, 4, 8, 1}, {1, 1, 4, 6, 3}, {1, 1, 6, 4, 3}, {1, 1, 8, 2, 3}, {1, 1, 5, 6, 2}, {1, 1, 9, 2, 2}}};
 
-	return ParseFinderPattern(view, dir == Direction::Left, FINDER_PATTERNS, REVERSED_FINDER_PATTERNS);
+	return ParseFinderPattern<6>(view, dir == Direction::Left, e2ePatterns);
 }
 
 static bool ChecksumIsValid(const Pairs& pairs)
@@ -330,8 +328,7 @@ struct DBERState : public RowReader::DecodingState
 	PairMap allPairs;
 };
 
-Result DataBarExpandedReader::decodePattern(int rowNumber, PatternView& view,
-											std::unique_ptr<RowReader::DecodingState>& state) const
+Barcode DataBarExpandedReader::decodePattern(int rowNumber, PatternView& view, std::unique_ptr<RowReader::DecodingState>& state) const
 {
 #if 0 // non-stacked version
 	auto pairs = ReadRowOfPairs<false>(view, rowNumber);
@@ -375,7 +372,7 @@ Result DataBarExpandedReader::decodePattern(int rowNumber, PatternView& view,
 	// Symbology identifier: ISO/IEC 24724:2011 Section 9 and GS1 General Specifications 5.1.3 Figure 5.1.3-2
 	return {DecoderResult(Content(ByteArray(txt), {'e', '0', 0, AIFlag::GS1}))
 				.setLineCount(EstimateLineCount(pairs.front(), pairs.back())),
-			EstimatePosition(pairs.front(), pairs.back()), BarcodeFormat::DataBarExpanded};
+			{{}, EstimatePosition(pairs.front(), pairs.back())}, BarcodeFormat::DataBarExpanded};
 }
 
 } // namespace ZXing::OneD
diff --git a/core/src/oned/ODDataBarExpandedReader.h b/core/src/oned/ODDataBarExpandedReader.h
index 65c523636c..f10ed77b77 100644
--- a/core/src/oned/ODDataBarExpandedReader.h
+++ b/core/src/oned/ODDataBarExpandedReader.h
@@ -19,7 +19,7 @@ class DataBarExpandedReader : public RowReader
 public:
 	using RowReader::RowReader;
 
-	Result decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>& state) const override;
+	Barcode decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>& state) const override;
 };
 
 } // namespace ZXing::OneD
diff --git a/core/src/oned/ODDataBarLimitedReader.cpp b/core/src/oned/ODDataBarLimitedReader.cpp
new file mode 100644
index 0000000000..db57feb024
--- /dev/null
+++ b/core/src/oned/ODDataBarLimitedReader.cpp
@@ -0,0 +1,166 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ODDataBarLimitedReader.h"
+
+#include "BarcodeFormat.h"
+#include "GTIN.h"
+#include "ODDataBarCommon.h"
+#include "Barcode.h"
+
+//#define PRINT_DEBUG
+#ifndef PRINT_DEBUG
+#define printf(...){}
+#define printv(...){}
+#else
+#define printv(fmt, ...) \
+for (auto v : __VA_ARGS__) \
+	printf(fmt, v);
+#endif
+
+namespace ZXing::OneD {
+
+using namespace DataBar;
+
+constexpr int CHAR_LEN = 14;
+constexpr int SYMBOL_LEN = 1 + 3 * CHAR_LEN + 2;
+
+static Character ReadDataCharacter(const PatternView& view)
+{
+	constexpr int G_SUM[] = {0, 183064, 820064, 1000776, 1491021, 1979845, 1996939};
+	constexpr int T_EVEN[] = {28, 728, 6454, 203, 2408, 1, 16632};
+	constexpr int ODD_SUM[] = {17, 13, 9, 15, 11, 19, 7};
+	constexpr int ODD_WIDEST[] = {6, 5, 3, 5, 4, 8, 1};
+
+	auto pattern = NormalizedPatternFromE2E<14>(view, 26);
+
+	int checkSum = 0;
+	for (auto it = pattern.rbegin(); it != pattern.rend(); ++it)
+		checkSum = 3 * checkSum + *it;
+
+	using Array7I = std::array<int, 7>;
+	Array7I oddPattern = {}, evnPattern = {};
+	OddEven<Array7I&> res = {oddPattern, evnPattern};
+
+	for (int i = 0; i < Size(pattern); ++i)
+		res[i % 2][i / 2] = pattern[i];
+
+	printf(" o: ");
+	printv("%d ", oddPattern);
+	printf(" e: ");
+	printv("%d ", evnPattern);
+
+	int group = IndexOf(ODD_SUM, Reduce(oddPattern));
+	if (group == -1)
+		return {};
+
+	int oddWidest = ODD_WIDEST[group];
+	int evnWidest = 9 - oddWidest;
+#ifndef __cpp_lib_span
+#pragma message("DataBarLimited not supported without std::span<> (c++20 feature)")
+	int vOdd = 0;
+	int vEvn = 0;
+#else
+	int vOdd = GetValue(oddPattern, oddWidest, false);
+	int vEvn = GetValue(evnPattern, evnWidest, true);
+#endif
+	int tEvn = T_EVEN[group];
+	int gSum = G_SUM[group];
+
+	return {vOdd * tEvn + vEvn + gSum, checkSum};
+}
+
+static std::string ConstructText(Character left, Character right)
+{
+	auto symVal = 2'013'571LL * left.value + right.value;
+
+	// Strip 2D linkage flag (GS1 Composite) if any (ISO/IEC 24724:2011 Section 6.2.3)
+	if (symVal >= 2'015'133'531'096LL) {
+		symVal -= 2'015'133'531'096LL;
+		assert(symVal <= 1'999'999'999'999LL); // 13 digits
+	}
+	auto txt = ToString(symVal, 13);
+	return "01" + txt + GTIN::ComputeCheckDigit(txt);
+}
+
+static inline bool Has26to18Ratio(int v26, int v18)
+{
+	return v26 + 1.5 * v26 / 26 > v18 / 18. * 26. && v26 - 1.5 * v26 / 26 < v18 / 18. * 26.;
+}
+
+std::array<int, 89> CheckChars = {
+	0b10'10101010'11100010, 0b10'10101010'01110010, 0b10'10101010'00111010, 0b10'10101001'01110010, 0b10'10101001'00111010,
+	0b10'10101000'10111010, 0b10'10100101'01110010, 0b10'10100101'00111010, 0b10'10100100'10111010, 0b10'10100010'10111010,
+	0b10'10010101'01110010, 0b10'10010101'00111010, 0b10'10010100'10111010, 0b10'10010010'10111010, 0b10'10001010'10111010,
+	0b10'01010101'01110010, 0b10'01010101'00111010, 0b10'01010100'10111010, 0b10'01010010'10111010, 0b10'01001010'10111010,
+	0b10'00101010'10111010, 0b10'10101011'01100010, 0b10'10101011'00110010, 0b10'10101011'00011010, 0b10'10101001'10110010,
+	0b10'10101001'10011010, 0b10'10101000'11011010, 0b10'10100101'10110010, 0b10'10100101'10011010, 0b10'10100100'11011010,
+	0b10'10100010'11011010, 0b10'10010101'10110010, 0b10'10010101'10011010, 0b10'10010100'11011010, 0b10'10010010'11011010,
+	0b10'10001010'11011010, 0b10'01010101'10110010, 0b10'01010101'10011010, 0b10'01010100'11011010, 0b10'01010010'11011010,
+	0b10'01001010'11011010, 0b10'00101010'11011010, 0b10'10101011'10100010, 0b10'10101011'10010010, 0b10'10101001'11010010,
+	0b10'10010101'11010010, 0b10'01010101'11010010, 0b10'10101101'01100010, 0b10'10101101'00110010, 0b10'10101101'00011010,
+	0b10'10101100'10110010, 0b10'10010110'10110010, 0b10'10010110'10011010, 0b10'10010110'01011010, 0b10'10010011'01011010,
+	0b10'10001011'01011010, 0b10'01010110'10110010, 0b10'01010110'10011010, 0b10'01001011'01011010, 0b10'10110101'01100010,
+	0b10'10110101'00110010, 0b10'10110101'00011010, 0b10'10110100'10110010, 0b10'10110100'10011010, 0b10'10110010'10110010,
+	0b10'01011010'10110010, 0b10'01011010'10011010, 0b10'01011010'01011010, 0b10'01011001'01011010, 0b10'01001101'01011010,
+	0b10'00101101'01011010, 0b10'11010101'01100010, 0b10'11010101'00110010, 0b10'11010101'00011010, 0b10'11010100'10110010,
+	0b10'11010100'10011010, 0b10'11010100'01011010, 0b10'11010010'10110010, 0b10'11010010'10011010, 0b10'11001010'10110010,
+	0b11'01010101'00110010, 0b11'01010101'00011010, 0b11'01010100'10110010, 0b11'01010100'10011010, 0b11'01010100'01011010,
+	0b11'01010010'10011010, 0b11'01010010'01011010, 0b11'01001010'10011010, 0b11'01010101'10010010,
+};
+
+Barcode DataBarLimitedReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<RowReader::DecodingState>&) const
+{
+	next = next.subView(-2, SYMBOL_LEN);
+	while (next.shift(2)) {
+		if (!IsGuard(next[27], next[43]))
+			continue;
+		auto spaceSize = (next[27] + next[43]) / 2;
+		if ((!next.isAtFirstBar() && next[-1] < spaceSize) || (!next.isAtLastBar() && next[SYMBOL_LEN] < 4 * spaceSize))
+			continue;
+		auto [mBar, MBar] = std::minmax({next[0], next[28], next[44]});
+		if (MBar > mBar * 4 / 3 + 1)
+			continue;
+
+		auto leftView = next.subView(1 + 0 * CHAR_LEN, CHAR_LEN);
+		auto checkView = next.subView(1 + 1 * CHAR_LEN, CHAR_LEN);
+		auto rightView = next.subView(1 + 2 * CHAR_LEN, CHAR_LEN);
+		auto leftWidth = leftView.sum();
+		auto checkWith = checkView.sum();
+		auto rightWidth = rightView.sum();
+		if (!Has26to18Ratio(leftWidth, checkWith) || !Has26to18Ratio(rightWidth, checkWith))
+			continue;
+
+		auto modSize = double(leftWidth + checkWith + rightWidth) / (26 + 18 + 26);
+		if ((!next.isAtFirstBar() && next[-1] < modSize) || (!next.isAtLastBar() && next[SYMBOL_LEN] < 5 * modSize))
+			continue;
+
+		auto checkCharPattern = ToInt(NormalizedPatternFromE2E<CHAR_LEN>(checkView, 18));
+		int checkSum = IndexOf(CheckChars, checkCharPattern);
+		if (checkSum == -1)
+			continue;
+
+		printf("%f - ", modSize);
+		printv("%d ", NormalizedPatternFromE2E<CHAR_LEN>(checkView, 18));
+
+		auto left = ReadDataCharacter(leftView);
+		auto right = ReadDataCharacter(rightView);
+
+		printf("- %d, %d, %d\n", checkSum, left.value, right.value);
+
+		if ((left.checksum + 20 * right.checksum) % 89 != checkSum)
+			continue;
+
+		return {ConstructText(left, right),    rowNumber, next.pixelsInFront(), next.pixelsTillEnd(),
+				BarcodeFormat::DataBarLimited, {'e', '0'}};
+	}
+
+	// guarantee progress (see loop in ODReader.cpp)
+	next = {};
+
+	return {};
+}
+
+} // namespace ZXing::OneD
diff --git a/core/src/oned/ODDataBarLimitedReader.h b/core/src/oned/ODDataBarLimitedReader.h
new file mode 100644
index 0000000000..e290406a6b
--- /dev/null
+++ b/core/src/oned/ODDataBarLimitedReader.h
@@ -0,0 +1,23 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "ODRowReader.h"
+
+namespace ZXing::OneD {
+
+/**
+* Decodes DataBarLimited sybmols. See ISO/IEC 24724:2011.
+*/
+class DataBarLimitedReader : public RowReader
+{
+public:
+	using RowReader::RowReader;
+
+	Barcode decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>& state) const override;
+};
+
+} // namespace ZXing::OneD
diff --git a/core/src/oned/ODDataBarReader.cpp b/core/src/oned/ODDataBarReader.cpp
index 8fb4264e2b..ec1a9b6611 100644
--- a/core/src/oned/ODDataBarReader.cpp
+++ b/core/src/oned/ODDataBarReader.cpp
@@ -9,9 +9,10 @@
 
 #include "BarcodeFormat.h"
 #include "DecoderResult.h"
+#include "DetectorResult.h"
 #include "GTIN.h"
 #include "ODDataBarCommon.h"
-#include "Result.h"
+#include "Barcode.h"
 
 #include <cmath>
 #include <unordered_set>
@@ -85,25 +86,19 @@ static Character ReadDataCharacter(const PatternView& view, bool outsideChar, bo
 
 int ParseFinderPattern(const PatternView& view, bool reversed)
 {
-	static constexpr std::array<FixedPattern<5, 15>, 10> FINDER_PATTERNS = {{
-		{3, 8, 2, 1, 1},
-		{3, 5, 5, 1, 1},
-		{3, 3, 7, 1, 1},
-		{3, 1, 9, 1, 1},
-		{2, 7, 4, 1, 1},
-		{2, 5, 6, 1, 1},
-		{2, 3, 8, 1, 1},
-		{1, 5, 7, 1, 1},
-		{1, 3, 9, 1, 1},
+	static constexpr std::array<std::array<int, 3>, 9> e2ePatterns = {{
+		{11, 10, 3 }, // {3, 8, 2, 1, 1}
+		{8 , 10, 6 }, // {3, 5, 5, 1, 1}
+		{6 , 10, 8 }, // {3, 3, 7, 1, 1}
+		{4 , 10, 10}, // {3, 1, 9, 1, 1}
+		{9 , 11, 5 }, // {2, 7, 4, 1, 1}
+		{7 , 11, 7 }, // {2, 5, 6, 1, 1}
+		{5 , 11, 9 }, // {2, 3, 8, 1, 1}
+		{6 , 11, 8 }, // {1, 5, 7, 1, 1}
+		{4 , 12, 10}, // {1, 3, 9, 1, 1}
 	}};
 
-	// TODO: c++20 constexpr inversion from FIND_PATTERN?
-	static constexpr std::array<FixedPattern<5, 15>, 10> REVERSED_FINDER_PATTERNS = {{
-		{1, 1, 2, 8, 3}, {1, 1, 5, 5, 3}, {1, 1, 7, 3, 3}, {1, 1, 9, 1, 3}, {1, 1, 4, 7, 2},
-		{1, 1, 6, 5, 2}, {1, 1, 8, 3, 2}, {1, 1, 7, 5, 1}, {1, 1, 9, 3, 1},
-	}};
-
-	return ParseFinderPattern(view, reversed, FINDER_PATTERNS, REVERSED_FINDER_PATTERNS);
+	return ParseFinderPattern<9>(view, reversed, e2ePatterns);
 }
 
 static Pair ReadPair(const PatternView& view, bool rightPair)
@@ -120,6 +115,16 @@ static Pair ReadPair(const PatternView& view, bool rightPair)
 	return {};
 }
 
+static long long Value(Pair leftPair, Pair rightPair)
+{
+	auto value = [](Pair p) { return 1597 * p.left.value + p.right.value; };
+	auto res = 4537077LL * value(leftPair) + value(rightPair);
+	if (res >= 10000000000000LL) { // Strip 2D linkage flag (GS1 Composite) if any (ISO/IEC 24724:2011 Section 5.2.3)
+		res -= 10000000000000LL;
+	}
+	return res;
+}
+
 static bool ChecksumIsValid(Pair leftPair, Pair rightPair)
 {
 	auto checksum = [](Pair p) { return p.left.checksum + 4 * p.right.checksum; };
@@ -129,18 +134,12 @@ static bool ChecksumIsValid(Pair leftPair, Pair rightPair)
 		b--;
 	if (b > 8)
 		b--;
-	return a == b;
+	return a == b && Value(leftPair, rightPair) <= 9999999999999LL; // 13 digits
 }
 
 static std::string ConstructText(Pair leftPair, Pair rightPair)
 {
-	auto value = [](Pair p) { return 1597 * p.left.value + p.right.value; };
-	auto res = 4537077LL * value(leftPair) + value(rightPair);
-	if (res >= 10000000000000LL) { // Strip 2D linkage flag (GS1 Composite) if any (ISO/IEC 24724:2011 Section 5.2.3)
-		res -= 10000000000000LL;
-		assert(res <= 9999999999999LL); // 13 digits
-	}
-	auto txt = ToString(res, 13);
+	auto txt = ToString(Value(leftPair, rightPair), 13);
 	return txt + GTIN::ComputeCheckDigit(txt);
 }
 
@@ -150,8 +149,7 @@ struct State : public RowReader::DecodingState
 	std::unordered_set<Pair, PairHash> rightPairs;
 };
 
-Result DataBarReader::decodePattern(int rowNumber, PatternView& next,
-									std::unique_ptr<RowReader::DecodingState>& state) const
+Barcode DataBarReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<RowReader::DecodingState>& state) const
 {
 #if 0 // non-stacked version
 	next = next.subView(-1, FULL_PAIR_SIZE + 1); // +1 reflects the guard pattern on the right, see IsRightPair());
@@ -195,9 +193,10 @@ Result DataBarReader::decodePattern(int rowNumber, PatternView& next,
 		for (const auto& rightPair : prevState->rightPairs)
 			if (ChecksumIsValid(leftPair, rightPair)) {
 				// Symbology identifier ISO/IEC 24724:2011 Section 9 and GS1 General Specifications 5.1.3 Figure 5.1.3-2
-				Result res{DecoderResult(Content(ByteArray(ConstructText(leftPair, rightPair)), {'e', '0'}))
-							   .setLineCount(EstimateLineCount(leftPair, rightPair)),
-						   EstimatePosition(leftPair, rightPair), BarcodeFormat::DataBar};
+				Barcode res{DecoderResult(Content(ByteArray(ConstructText(leftPair, rightPair)), {'e', '0'}))
+								.setLineCount(EstimateLineCount(leftPair, rightPair)),
+							{{}, EstimatePosition(leftPair, rightPair)},
+							BarcodeFormat::DataBar};
 
 				prevState->leftPairs.erase(leftPair);
 				prevState->rightPairs.erase(rightPair);
diff --git a/core/src/oned/ODDataBarReader.h b/core/src/oned/ODDataBarReader.h
index 0e64bb2f9a..81d7da44c9 100644
--- a/core/src/oned/ODDataBarReader.h
+++ b/core/src/oned/ODDataBarReader.h
@@ -19,7 +19,7 @@ class DataBarReader : public RowReader
 public:
 	using RowReader::RowReader;
 
-	Result decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>& state) const override;
+	Barcode decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>& state) const override;
 };
 
 } // namespace ZXing::OneD
diff --git a/core/src/oned/ODITFReader.cpp b/core/src/oned/ODITFReader.cpp
index 439a1933dd..5de056da30 100644
--- a/core/src/oned/ODITFReader.cpp
+++ b/core/src/oned/ODITFReader.cpp
@@ -8,76 +8,87 @@
 
 #include "ReaderOptions.h"
 #include "GTIN.h"
-#include "Result.h"
+#include "Barcode.h"
 #include "ZXAlgorithms.h"
 
-#include <array>
-
 namespace ZXing::OneD {
 
-constexpr auto START_PATTERN_ = FixedPattern<4, 4>{1, 1, 1, 1};
-constexpr auto STOP_PATTERN_1 = FixedPattern<3, 4>{2, 1, 1};
-constexpr auto STOP_PATTERN_2 = FixedPattern<3, 5>{3, 1, 1};
-
-Result ITFReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const
+Barcode ITFReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const
 {
-	const int minCharCount = 6;
-	const int minQuietZone = 10;
+	const int minCharCount = _opts.formats().count() == 1 ? 4 : 6; // if we are only looking for ITF, we accept shorter symbols
+	const int minQuietZone = 6; // spec requires 10
 
-	next = FindLeftGuard(next, 4 + minCharCount/2 + 3, START_PATTERN_, minQuietZone);
+	next = FindLeftGuard(next, 4 + minCharCount/2 + 3, FixedPattern<4, 4>{1, 1, 1, 1}, minQuietZone);
 	if (!next.isValid())
 		return {};
 
-	std::string txt;
-	txt.reserve(20);
+	// get threshold of first character pair
+	auto threshold = NarrowWideThreshold(next.subView(4, 10));
+	if (!threshold.isValid())
+		return {};
+	// check that each bar/space in the start pattern is < threshold
+	for (int i = 0; i < 4; ++i)
+		if (next[i] > threshold[i])
+			return {};
 
 	constexpr int weights[] = {1, 2, 4, 7, 0};
 	int xStart = next.pixelsInFront();
+	bool startsAtFirstBar = next.isAtFirstBar();
+
 	next = next.subView(4, 10);
 
+	std::string txt;
+	txt.reserve(20);
+
 	while (next.isValid()) {
-		const auto threshold = NarrowWideThreshold(next);
-		if (!threshold.isValid())
+		// look for end-of-symbol
+		if (next[3] > threshold.space * 3)
 			break;
 
 		BarAndSpace<int> digits, numWide;
+		bool bad = false;
 		for (int i = 0; i < 10; ++i) {
-			if (next[i] > threshold[i] * 2)
-				break;
+			bad |= next[i] > threshold[i] * 3 || next[i] < threshold[i] / 3;
 			numWide[i] += next[i] > threshold[i];
 			digits[i] += weights[i/2] * (next[i] > threshold[i]);
 		}
 
-		if (numWide.bar != 2 || numWide.space != 2)
+		if (bad || numWide.bar != 2 || numWide.space != 2)
 			break;
 
 		for (int i = 0; i < 2; ++i)
 			txt.push_back(ToDigit(digits[i] == 11 ? 0 : digits[i]));
 
+		// update threshold to support scanning slanted symbols (scanned non-perpendicular)
+		threshold = NarrowWideThreshold(next);
+
 		next.skipSymbol();
 	}
 
 	next = next.subView(0, 3);
 
-	if (Size(txt) < minCharCount || !next.isValid())
+	// Check stop pattern
+	if (!next.isValid() || !threshold.isValid()
+		|| next[0] < threshold[0] || next[1] > threshold[1] || next[2] > threshold[2])
 		return {};
 
-	if (!IsRightGuard(next, STOP_PATTERN_1, minQuietZone) && !IsRightGuard(next, STOP_PATTERN_2, minQuietZone))
+	// Check quiet zone size (full quiet zone or cropped on both ends)
+	if (!(next[3] > minQuietZone * (threshold.bar + threshold.space) / 3
+		  || (next.isAtLastBar() && startsAtFirstBar && std::max(xStart, (int)next[3]) < 2 * std::min(xStart, (int)next[3]) + 2)))
 		return {};
 
-	Error error;
-	if (_opts.validateITFCheckSum() && !GTIN::IsCheckDigitValid(txt))
-		error = ChecksumError();
+	// Check min length depending on whether the code covers the complete image or not
+	if (Size(txt) < (startsAtFirstBar && next.isAtLastBar() ? (minCharCount / 2) : minCharCount))
+		return {};
+
+	Error error = _opts.validateITFCheckSum() && !GTIN::IsCheckDigitValid(txt) ? ChecksumError() : Error();
 
 	// Symbology identifier ISO/IEC 16390:2007 Annex C Table C.1
-	// See also GS1 General Specifications 5.1.3 Figure 5.1.3-2
-	SymbologyIdentifier symbologyIdentifier = {'I', '0'}; // No check character validation
+	// See also GS1 General Specifications 5.1.2 Figure 5.1.2-2
+	SymbologyIdentifier symbologyIdentifier = {'I', GTIN::IsCheckDigitValid(txt) ? '1' : '0'};
 	
-	if (_opts.validateITFCheckSum() || (txt.size() == 14 && GTIN::IsCheckDigitValid(txt))) // If no hint test if valid ITF-14
-		symbologyIdentifier.modifier = '1'; // Modulo 10 symbol check character validated and transmitted
-
 	int xStop = next.pixelsTillEnd();
-	return Result(txt, rowNumber, xStart, xStop, BarcodeFormat::ITF, symbologyIdentifier, error);
+	return Barcode(txt, rowNumber, xStart, xStop, BarcodeFormat::ITF, symbologyIdentifier, error);
 }
 
 } // namespace ZXing::OneD
diff --git a/core/src/oned/ODITFReader.h b/core/src/oned/ODITFReader.h
index e71d0ea25e..4744851022 100644
--- a/core/src/oned/ODITFReader.h
+++ b/core/src/oned/ODITFReader.h
@@ -17,7 +17,7 @@ namespace ZXing::OneD {
 * At the moment it reads length >= 6. Not all lengths are scanned, especially shorter ones, to avoid false positives.
 * This in turn is due to a lack of required checksum function.</p>
 *
-* <p>The checksum is optional and is only checked if the validateITFCheckSum hint is given.</p>
+* <p>According to the specification, the modifier (3rd char) of the symbologyIdentifier is '1' iff the symbol has a valid checksum</p>
 *
 * <p><a href="http://en.wikipedia.org/wiki/Interleaved_2_of_5">http://en.wikipedia.org/wiki/Interleaved_2_of_5</a>
 * is a great reference for Interleaved 2 of 5 information.</p>
@@ -27,7 +27,7 @@ class ITFReader : public RowReader
 public:
 	using RowReader::RowReader;
 
-	Result decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
+	Barcode decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
 };
 
 } // namespace ZXing::OneD
diff --git a/core/src/oned/ODMultiUPCEANReader.cpp b/core/src/oned/ODMultiUPCEANReader.cpp
index 738268e01d..7dae62c5d3 100644
--- a/core/src/oned/ODMultiUPCEANReader.cpp
+++ b/core/src/oned/ODMultiUPCEANReader.cpp
@@ -12,7 +12,7 @@
 #include "ReaderOptions.h"
 #include "GTIN.h"
 #include "ODUPCEANCommon.h"
-#include "Result.h"
+#include "Barcode.h"
 
 #include <cmath>
 
@@ -262,7 +262,7 @@ static bool AddOn(PartialResult& res, PatternView begin, int digitCount)
 	return true;
 }
 
-Result MultiUPCEANReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<RowReader::DecodingState>&) const
+Barcode MultiUPCEANReader::decodePattern(int rowNumber, PatternView& next, std::unique_ptr<RowReader::DecodingState>&) const
 {
 	const int minSize = 3 + 6*4 + 6; // UPC-E
 
@@ -317,7 +317,7 @@ Result MultiUPCEANReader::decodePattern(int rowNumber, PatternView& next, std::u
 	if (_opts.eanAddOnSymbol() == EanAddOnSymbol::Require && !addOnRes.isValid())
 		return {};
 
-	return Result(res.txt, rowNumber, begin.pixelsInFront(), next.pixelsTillEnd(), res.format, symbologyIdentifier, error);
+	return Barcode(res.txt, rowNumber, begin.pixelsInFront(), next.pixelsTillEnd(), res.format, symbologyIdentifier, error);
 }
 
 } // namespace ZXing::OneD
diff --git a/core/src/oned/ODMultiUPCEANReader.h b/core/src/oned/ODMultiUPCEANReader.h
index 9ec795d51c..40ccba15a3 100644
--- a/core/src/oned/ODMultiUPCEANReader.h
+++ b/core/src/oned/ODMultiUPCEANReader.h
@@ -18,7 +18,7 @@ class MultiUPCEANReader : public RowReader
 public:
 	using RowReader::RowReader;
 
-	Result decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
+	Barcode decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>&) const override;
 };
 
 } // namespace ZXing::OneD
diff --git a/core/src/oned/ODReader.cpp b/core/src/oned/ODReader.cpp
index 07f6a62533..555ae308e0 100644
--- a/core/src/oned/ODReader.cpp
+++ b/core/src/oned/ODReader.cpp
@@ -14,10 +14,12 @@
 #include "ODCode39Reader.h"
 #include "ODCode93Reader.h"
 #include "ODDataBarExpandedReader.h"
+#include "ODDataBarLimitedReader.h"
 #include "ODDataBarReader.h"
+#include "ODDXFilmEdgeReader.h"
 #include "ODITFReader.h"
 #include "ODMultiUPCEANReader.h"
-#include "Result.h"
+#include "Barcode.h"
 
 #include <algorithm>
 #include <utility>
@@ -29,7 +31,7 @@
 
 namespace ZXing {
 
-void IncrementLineCount(Result& r)
+void IncrementLineCount(Barcode& r)
 {
 	++r._lineCount;
 }
@@ -61,6 +63,10 @@ Reader::Reader(const ReaderOptions& opts) : ZXing::Reader(opts)
 		_readers.emplace_back(new DataBarReader(opts));
 	if (formats.testFlags(BarcodeFormat::DataBarExpanded))
 		_readers.emplace_back(new DataBarExpandedReader(opts));
+	if (formats.testFlags(BarcodeFormat::DataBarLimited))
+		_readers.emplace_back(new DataBarLimitedReader(opts));
+	if (formats.testFlag(BarcodeFormat::DXFilmEdge))
+		_readers.emplace_back(new DXFilmEdgeReader(opts));
 }
 
 Reader::~Reader() = default;
@@ -74,10 +80,10 @@ Reader::~Reader() = default;
 * decided that moving up and down by about 1/16 of the image is pretty good; we try more of the
 * image if "trying harder".
 */
-static Results DoDecode(const std::vector<std::unique_ptr<RowReader>>& readers, const BinaryBitmap& image,
-						bool tryHarder, bool rotate, bool isPure, int maxSymbols, int minLineCount, bool returnErrors)
+static Barcodes DoDecode(const std::vector<std::unique_ptr<RowReader>>& readers, const BinaryBitmap& image, bool tryHarder,
+						 bool rotate, bool isPure, int maxSymbols, int minLineCount, bool returnErrors)
 {
-	Results res;
+	Barcodes res;
 
 	std::vector<std::unique_ptr<RowReader::DecodingState>> decodingState(readers.size());
 
@@ -96,6 +102,8 @@ static Results DoDecode(const std::vector<std::unique_ptr<RowReader>>& readers,
 
 	if (isPure)
 		minLineCount = 1;
+	else
+		minLineCount = std::min(minLineCount, height);
 	std::vector<int> checkRows;
 
 	PatternRow bars;
@@ -161,7 +169,7 @@ static Results DoDecode(const std::vector<std::unique_ptr<RowReader>>& readers,
 
 				PatternView next(bars);
 				do {
-					Result result = readers[r]->decodePattern(rowNumber, next, decodingState[r]);
+					Barcode result = readers[r]->decodePattern(rowNumber, next, decodingState[r]);
 					if (result.isValid() || (returnErrors && result.error())) {
 						IncrementLineCount(result);
 						if (upsideDown) {
@@ -198,7 +206,7 @@ static Results DoDecode(const std::vector<std::unique_ptr<RowReader>>& readers,
 								other.setPosition(points);
 								IncrementLineCount(other);
 								// clear the result, so we don't insert it again below
-								result = Result();
+								result = Barcode();
 								break;
 							}
 						}
@@ -215,7 +223,7 @@ static Results DoDecode(const std::vector<std::unique_ptr<RowReader>>& readers,
 							}
 						}
 
-						if (maxSymbols && Reduce(res, 0, [&](int s, const Result& r) {
+						if (maxSymbols && Reduce(res, 0, [&](int s, const Barcode& r) {
 											  return s + (r.lineCount() >= minLineCount);
 										  }) == maxSymbols) {
 							goto out;
@@ -231,18 +239,25 @@ static Results DoDecode(const std::vector<std::unique_ptr<RowReader>>& readers,
 
 out:
 	// remove all symbols with insufficient line count
+#ifdef __cpp_lib_erase_if
+	std::erase_if(res, [&](auto&& r) { return r.lineCount() < minLineCount; });
+#else
 	auto it = std::remove_if(res.begin(), res.end(), [&](auto&& r) { return r.lineCount() < minLineCount; });
 	res.erase(it, res.end());
+#endif
 
 	// if symbols overlap, remove the one with a lower line count
 	for (auto a = res.begin(); a != res.end(); ++a)
 		for (auto b = std::next(a); b != res.end(); ++b)
 			if (HaveIntersectingBoundingBoxes(a->position(), b->position()))
-				*(a->lineCount() < b->lineCount() ? a : b) = Result();
+				*(a->lineCount() < b->lineCount() ? a : b) = Barcode();
 
-	//TODO: C++20 res.erase_if()
+#ifdef __cpp_lib_erase_if
+	std::erase_if(res, [](auto&& r) { return r.format() == BarcodeFormat::None; });
+#else
 	it = std::remove_if(res.begin(), res.end(), [](auto&& r) { return r.format() == BarcodeFormat::None; });
 	res.erase(it, res.end());
+#endif
 
 #ifdef PRINT_DEBUG
 	SaveAsPBM(dbg, rotate ? "od-log-r.pnm" : "od-log.pnm");
@@ -251,8 +266,7 @@ static Results DoDecode(const std::vector<std::unique_ptr<RowReader>>& readers,
 	return res;
 }
 
-Result
-Reader::decode(const BinaryBitmap& image) const
+Barcode Reader::decode(const BinaryBitmap& image) const
 {
 	auto result =
 		DoDecode(_readers, image, _opts.tryHarder(), false, _opts.isPure(), 1, _opts.minLineCount(), _opts.returnErrors());
@@ -263,7 +277,7 @@ Reader::decode(const BinaryBitmap& image) const
 	return FirstOrDefault(std::move(result));
 }
 
-Results Reader::decode(const BinaryBitmap& image, int maxSymbols) const
+Barcodes Reader::decode(const BinaryBitmap& image, int maxSymbols) const
 {
 	auto resH = DoDecode(_readers, image, _opts.tryHarder(), false, _opts.isPure(), maxSymbols, _opts.minLineCount(),
 						 _opts.returnErrors());
diff --git a/core/src/oned/ODReader.h b/core/src/oned/ODReader.h
index 647452ddcf..99939cd82f 100644
--- a/core/src/oned/ODReader.h
+++ b/core/src/oned/ODReader.h
@@ -25,8 +25,8 @@ class Reader : public ZXing::Reader
 	explicit Reader(const ReaderOptions& opts);
 	~Reader() override;
 
-	Result decode(const BinaryBitmap& image) const override;
-	Results decode(const BinaryBitmap& image, int maxSymbols) const override;
+	Barcode decode(const BinaryBitmap& image) const override;
+	Barcodes decode(const BinaryBitmap& image, int maxSymbols) const override;
 
 private:
 	std::vector<std::unique_ptr<RowReader>> _readers;
diff --git a/core/src/oned/ODRowReader.cpp b/core/src/oned/ODRowReader.cpp
deleted file mode 100644
index c8454dbf4b..0000000000
--- a/core/src/oned/ODRowReader.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
-* Copyright 2020 Axel Waggershauser
-*/
-// SPDX-License-Identifier: Apache-2.0
-
-#include "ODRowReader.h"
-
-#include "BitArray.h"
-#include "Result.h"
-
-#include <memory>
-
-namespace ZXing::OneD {
-
-
-
-} // namespace ZXing::OneD
diff --git a/core/src/oned/ODRowReader.h b/core/src/oned/ODRowReader.h
index 7e3e2e932a..fe503cb0c1 100644
--- a/core/src/oned/ODRowReader.h
+++ b/core/src/oned/ODRowReader.h
@@ -9,7 +9,7 @@
 
 #include "BitArray.h"
 #include "Pattern.h"
-#include "Result.h"
+#include "Barcode.h"
 #include "ZXAlgorithms.h"
 
 #include <algorithm>
@@ -64,7 +64,7 @@ class RowReader
 
 	virtual ~RowReader() {}
 
-	virtual Result decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>& state) const = 0;
+	virtual Barcode decodePattern(int rowNumber, PatternView& next, std::unique_ptr<DecodingState>& state) const = 0;
 
 	/**
 	 * Determines how closely a set of observed counts of runs of black/white values matches a given
@@ -79,8 +79,8 @@ class RowReader
 	template <typename CP, typename PP>
 	static float PatternMatchVariance(const CP* counters, const PP* pattern, size_t length, float maxIndividualVariance)
 	{
-		int total = std::accumulate(counters, counters+length, 0);
-		int patternLength = std::accumulate(pattern, pattern+length, 0);
+		int total = Reduce(counters, counters + length, 0);
+		int patternLength = Reduce(pattern, pattern + length, 0);
 		if (total < patternLength) {
 			// If we don't even have one pixel per unit of bar width, assume this is too small
 			// to reliably match, so fail:
@@ -215,7 +215,7 @@ class RowReader
 };
 
 template<typename Range>
-Result DecodeSingleRow(const RowReader& reader, const Range& range)
+Barcode DecodeSingleRow(const RowReader& reader, const Range& range)
 {
 	PatternRow row;
 	GetPatternRow(range, row);
diff --git a/core/src/CustomData.h b/core/src/pdf417/CustomData.h
similarity index 100%
rename from core/src/CustomData.h
rename to core/src/pdf417/CustomData.h
diff --git a/core/src/pdf417/PDFCodewordDecoder.cpp b/core/src/pdf417/PDFCodewordDecoder.cpp
index 4b9d8c1094..73067052c9 100644
--- a/core/src/pdf417/PDFCodewordDecoder.cpp
+++ b/core/src/pdf417/PDFCodewordDecoder.cpp
@@ -23,241 +23,243 @@ static constexpr const int SYMBOL_COUNT = 2787;
 * The sorted table of all possible symbols. Extracted from the PDF417
 * specification. The index of a symbol in this table corresponds to the
 * index into the codeword table.
+* Note: stored in the table are only the 16 least significant bits (of 17),
+* each full symbol is preceded by a 1-bit, see getSymbol();
 */
-static constexpr const std::array<int, 2787> SYMBOL_TABLE = {
-	0x1025e, 0x1027a, 0x1029e, 0x102bc, 0x102f2, 0x102f4, 0x1032e, 0x1034e, 0x1035c, 0x10396, 0x103a6, 0x103ac,
-	0x10422, 0x10428, 0x10436, 0x10442, 0x10444, 0x10448, 0x10450, 0x1045e, 0x10466, 0x1046c, 0x1047a, 0x10482,
-	0x1049e, 0x104a0, 0x104bc, 0x104c6, 0x104d8, 0x104ee, 0x104f2, 0x104f4, 0x10504, 0x10508, 0x10510, 0x1051e,
-	0x10520, 0x1053c, 0x10540, 0x10578, 0x10586, 0x1058c, 0x10598, 0x105b0, 0x105be, 0x105ce, 0x105dc, 0x105e2,
-	0x105e4, 0x105e8, 0x105f6, 0x1062e, 0x1064e, 0x1065c, 0x1068e, 0x1069c, 0x106b8, 0x106de, 0x106fa, 0x10716,
-	0x10726, 0x1072c, 0x10746, 0x1074c, 0x10758, 0x1076e, 0x10792, 0x10794, 0x107a2, 0x107a4, 0x107a8, 0x107b6,
-	0x10822, 0x10828, 0x10842, 0x10848, 0x10850, 0x1085e, 0x10866, 0x1086c, 0x1087a, 0x10882, 0x10884, 0x10890,
-	0x1089e, 0x108a0, 0x108bc, 0x108c6, 0x108cc, 0x108d8, 0x108ee, 0x108f2, 0x108f4, 0x10902, 0x10908, 0x1091e,
-	0x10920, 0x1093c, 0x10940, 0x10978, 0x10986, 0x10998, 0x109b0, 0x109be, 0x109ce, 0x109dc, 0x109e2, 0x109e4,
-	0x109e8, 0x109f6, 0x10a08, 0x10a10, 0x10a1e, 0x10a20, 0x10a3c, 0x10a40, 0x10a78, 0x10af0, 0x10b06, 0x10b0c,
-	0x10b18, 0x10b30, 0x10b3e, 0x10b60, 0x10b7c, 0x10b8e, 0x10b9c, 0x10bb8, 0x10bc2, 0x10bc4, 0x10bc8, 0x10bd0,
-	0x10bde, 0x10be6, 0x10bec, 0x10c2e, 0x10c4e, 0x10c5c, 0x10c62, 0x10c64, 0x10c68, 0x10c76, 0x10c8e, 0x10c9c,
-	0x10cb8, 0x10cc2, 0x10cc4, 0x10cc8, 0x10cd0, 0x10cde, 0x10ce6, 0x10cec, 0x10cfa, 0x10d0e, 0x10d1c, 0x10d38,
-	0x10d70, 0x10d7e, 0x10d82, 0x10d84, 0x10d88, 0x10d90, 0x10d9e, 0x10da0, 0x10dbc, 0x10dc6, 0x10dcc, 0x10dd8,
-	0x10dee, 0x10df2, 0x10df4, 0x10e16, 0x10e26, 0x10e2c, 0x10e46, 0x10e58, 0x10e6e, 0x10e86, 0x10e8c, 0x10e98,
-	0x10eb0, 0x10ebe, 0x10ece, 0x10edc, 0x10f0a, 0x10f12, 0x10f14, 0x10f22, 0x10f28, 0x10f36, 0x10f42, 0x10f44,
-	0x10f48, 0x10f50, 0x10f5e, 0x10f66, 0x10f6c, 0x10fb2, 0x10fb4, 0x11022, 0x11028, 0x11042, 0x11048, 0x11050,
-	0x1105e, 0x1107a, 0x11082, 0x11084, 0x11090, 0x1109e, 0x110a0, 0x110bc, 0x110c6, 0x110cc, 0x110d8, 0x110ee,
-	0x110f2, 0x110f4, 0x11102, 0x1111e, 0x11120, 0x1113c, 0x11140, 0x11178, 0x11186, 0x11198, 0x111b0, 0x111be,
-	0x111ce, 0x111dc, 0x111e2, 0x111e4, 0x111e8, 0x111f6, 0x11208, 0x1121e, 0x11220, 0x11278, 0x112f0, 0x1130c,
-	0x11330, 0x1133e, 0x11360, 0x1137c, 0x1138e, 0x1139c, 0x113b8, 0x113c2, 0x113c8, 0x113d0, 0x113de, 0x113e6,
-	0x113ec, 0x11408, 0x11410, 0x1141e, 0x11420, 0x1143c, 0x11440, 0x11478, 0x114f0, 0x115e0, 0x1160c, 0x11618,
-	0x11630, 0x1163e, 0x11660, 0x1167c, 0x116c0, 0x116f8, 0x1171c, 0x11738, 0x11770, 0x1177e, 0x11782, 0x11784,
-	0x11788, 0x11790, 0x1179e, 0x117a0, 0x117bc, 0x117c6, 0x117cc, 0x117d8, 0x117ee, 0x1182e, 0x11834, 0x1184e,
-	0x1185c, 0x11862, 0x11864, 0x11868, 0x11876, 0x1188e, 0x1189c, 0x118b8, 0x118c2, 0x118c8, 0x118d0, 0x118de,
-	0x118e6, 0x118ec, 0x118fa, 0x1190e, 0x1191c, 0x11938, 0x11970, 0x1197e, 0x11982, 0x11984, 0x11990, 0x1199e,
-	0x119a0, 0x119bc, 0x119c6, 0x119cc, 0x119d8, 0x119ee, 0x119f2, 0x119f4, 0x11a0e, 0x11a1c, 0x11a38, 0x11a70,
-	0x11a7e, 0x11ae0, 0x11afc, 0x11b08, 0x11b10, 0x11b1e, 0x11b20, 0x11b3c, 0x11b40, 0x11b78, 0x11b8c, 0x11b98,
-	0x11bb0, 0x11bbe, 0x11bce, 0x11bdc, 0x11be2, 0x11be4, 0x11be8, 0x11bf6, 0x11c16, 0x11c26, 0x11c2c, 0x11c46,
-	0x11c4c, 0x11c58, 0x11c6e, 0x11c86, 0x11c98, 0x11cb0, 0x11cbe, 0x11cce, 0x11cdc, 0x11ce2, 0x11ce4, 0x11ce8,
-	0x11cf6, 0x11d06, 0x11d0c, 0x11d18, 0x11d30, 0x11d3e, 0x11d60, 0x11d7c, 0x11d8e, 0x11d9c, 0x11db8, 0x11dc4,
-	0x11dc8, 0x11dd0, 0x11dde, 0x11de6, 0x11dec, 0x11dfa, 0x11e0a, 0x11e12, 0x11e14, 0x11e22, 0x11e24, 0x11e28,
-	0x11e36, 0x11e42, 0x11e44, 0x11e50, 0x11e5e, 0x11e66, 0x11e6c, 0x11e82, 0x11e84, 0x11e88, 0x11e90, 0x11e9e,
-	0x11ea0, 0x11ebc, 0x11ec6, 0x11ecc, 0x11ed8, 0x11eee, 0x11f1a, 0x11f2e, 0x11f32, 0x11f34, 0x11f4e, 0x11f5c,
-	0x11f62, 0x11f64, 0x11f68, 0x11f76, 0x12048, 0x1205e, 0x12082, 0x12084, 0x12090, 0x1209e, 0x120a0, 0x120bc,
-	0x120d8, 0x120f2, 0x120f4, 0x12108, 0x1211e, 0x12120, 0x1213c, 0x12140, 0x12178, 0x12186, 0x12198, 0x121b0,
-	0x121be, 0x121e2, 0x121e4, 0x121e8, 0x121f6, 0x12204, 0x12210, 0x1221e, 0x12220, 0x12278, 0x122f0, 0x12306,
-	0x1230c, 0x12330, 0x1233e, 0x12360, 0x1237c, 0x1238e, 0x1239c, 0x123b8, 0x123c2, 0x123c8, 0x123d0, 0x123e6,
-	0x123ec, 0x1241e, 0x12420, 0x1243c, 0x124f0, 0x125e0, 0x12618, 0x1263e, 0x12660, 0x1267c, 0x126c0, 0x126f8,
-	0x12738, 0x12770, 0x1277e, 0x12782, 0x12784, 0x12790, 0x1279e, 0x127a0, 0x127bc, 0x127c6, 0x127cc, 0x127d8,
-	0x127ee, 0x12820, 0x1283c, 0x12840, 0x12878, 0x128f0, 0x129e0, 0x12bc0, 0x12c18, 0x12c30, 0x12c3e, 0x12c60,
-	0x12c7c, 0x12cc0, 0x12cf8, 0x12df0, 0x12e1c, 0x12e38, 0x12e70, 0x12e7e, 0x12ee0, 0x12efc, 0x12f04, 0x12f08,
-	0x12f10, 0x12f20, 0x12f3c, 0x12f40, 0x12f78, 0x12f86, 0x12f8c, 0x12f98, 0x12fb0, 0x12fbe, 0x12fce, 0x12fdc,
-	0x1302e, 0x1304e, 0x1305c, 0x13062, 0x13068, 0x1308e, 0x1309c, 0x130b8, 0x130c2, 0x130c8, 0x130d0, 0x130de,
-	0x130ec, 0x130fa, 0x1310e, 0x13138, 0x13170, 0x1317e, 0x13182, 0x13184, 0x13190, 0x1319e, 0x131a0, 0x131bc,
-	0x131c6, 0x131cc, 0x131d8, 0x131f2, 0x131f4, 0x1320e, 0x1321c, 0x13270, 0x1327e, 0x132e0, 0x132fc, 0x13308,
-	0x1331e, 0x13320, 0x1333c, 0x13340, 0x13378, 0x13386, 0x13398, 0x133b0, 0x133be, 0x133ce, 0x133dc, 0x133e2,
-	0x133e4, 0x133e8, 0x133f6, 0x1340e, 0x1341c, 0x13438, 0x13470, 0x1347e, 0x134e0, 0x134fc, 0x135c0, 0x135f8,
-	0x13608, 0x13610, 0x1361e, 0x13620, 0x1363c, 0x13640, 0x13678, 0x136f0, 0x1370c, 0x13718, 0x13730, 0x1373e,
-	0x13760, 0x1377c, 0x1379c, 0x137b8, 0x137c2, 0x137c4, 0x137c8, 0x137d0, 0x137de, 0x137e6, 0x137ec, 0x13816,
-	0x13826, 0x1382c, 0x13846, 0x1384c, 0x13858, 0x1386e, 0x13874, 0x13886, 0x13898, 0x138b0, 0x138be, 0x138ce,
-	0x138dc, 0x138e2, 0x138e4, 0x138e8, 0x13906, 0x1390c, 0x13930, 0x1393e, 0x13960, 0x1397c, 0x1398e, 0x1399c,
-	0x139b8, 0x139c8, 0x139d0, 0x139de, 0x139e6, 0x139ec, 0x139fa, 0x13a06, 0x13a0c, 0x13a18, 0x13a30, 0x13a3e,
-	0x13a60, 0x13a7c, 0x13ac0, 0x13af8, 0x13b0e, 0x13b1c, 0x13b38, 0x13b70, 0x13b7e, 0x13b88, 0x13b90, 0x13b9e,
-	0x13ba0, 0x13bbc, 0x13bcc, 0x13bd8, 0x13bee, 0x13bf2, 0x13bf4, 0x13c12, 0x13c14, 0x13c22, 0x13c24, 0x13c28,
-	0x13c36, 0x13c42, 0x13c48, 0x13c50, 0x13c5e, 0x13c66, 0x13c6c, 0x13c82, 0x13c84, 0x13c90, 0x13c9e, 0x13ca0,
-	0x13cbc, 0x13cc6, 0x13ccc, 0x13cd8, 0x13cee, 0x13d02, 0x13d04, 0x13d08, 0x13d10, 0x13d1e, 0x13d20, 0x13d3c,
-	0x13d40, 0x13d78, 0x13d86, 0x13d8c, 0x13d98, 0x13db0, 0x13dbe, 0x13dce, 0x13ddc, 0x13de4, 0x13de8, 0x13df6,
-	0x13e1a, 0x13e2e, 0x13e32, 0x13e34, 0x13e4e, 0x13e5c, 0x13e62, 0x13e64, 0x13e68, 0x13e76, 0x13e8e, 0x13e9c,
-	0x13eb8, 0x13ec2, 0x13ec4, 0x13ec8, 0x13ed0, 0x13ede, 0x13ee6, 0x13eec, 0x13f26, 0x13f2c, 0x13f3a, 0x13f46,
-	0x13f4c, 0x13f58, 0x13f6e, 0x13f72, 0x13f74, 0x14082, 0x1409e, 0x140a0, 0x140bc, 0x14104, 0x14108, 0x14110,
-	0x1411e, 0x14120, 0x1413c, 0x14140, 0x14178, 0x1418c, 0x14198, 0x141b0, 0x141be, 0x141e2, 0x141e4, 0x141e8,
-	0x14208, 0x14210, 0x1421e, 0x14220, 0x1423c, 0x14240, 0x14278, 0x142f0, 0x14306, 0x1430c, 0x14318, 0x14330,
-	0x1433e, 0x14360, 0x1437c, 0x1438e, 0x143c2, 0x143c4, 0x143c8, 0x143d0, 0x143e6, 0x143ec, 0x14408, 0x14410,
-	0x1441e, 0x14420, 0x1443c, 0x14440, 0x14478, 0x144f0, 0x145e0, 0x1460c, 0x14618, 0x14630, 0x1463e, 0x14660,
-	0x1467c, 0x146c0, 0x146f8, 0x1471c, 0x14738, 0x14770, 0x1477e, 0x14782, 0x14784, 0x14788, 0x14790, 0x147a0,
-	0x147bc, 0x147c6, 0x147cc, 0x147d8, 0x147ee, 0x14810, 0x14820, 0x1483c, 0x14840, 0x14878, 0x148f0, 0x149e0,
-	0x14bc0, 0x14c30, 0x14c3e, 0x14c60, 0x14c7c, 0x14cc0, 0x14cf8, 0x14df0, 0x14e38, 0x14e70, 0x14e7e, 0x14ee0,
-	0x14efc, 0x14f04, 0x14f08, 0x14f10, 0x14f1e, 0x14f20, 0x14f3c, 0x14f40, 0x14f78, 0x14f86, 0x14f8c, 0x14f98,
-	0x14fb0, 0x14fce, 0x14fdc, 0x15020, 0x15040, 0x15078, 0x150f0, 0x151e0, 0x153c0, 0x15860, 0x1587c, 0x158c0,
-	0x158f8, 0x159f0, 0x15be0, 0x15c70, 0x15c7e, 0x15ce0, 0x15cfc, 0x15dc0, 0x15df8, 0x15e08, 0x15e10, 0x15e20,
-	0x15e40, 0x15e78, 0x15ef0, 0x15f0c, 0x15f18, 0x15f30, 0x15f60, 0x15f7c, 0x15f8e, 0x15f9c, 0x15fb8, 0x1604e,
-	0x1605c, 0x1608e, 0x1609c, 0x160b8, 0x160c2, 0x160c4, 0x160c8, 0x160de, 0x1610e, 0x1611c, 0x16138, 0x16170,
-	0x1617e, 0x16184, 0x16188, 0x16190, 0x1619e, 0x161a0, 0x161bc, 0x161c6, 0x161cc, 0x161d8, 0x161f2, 0x161f4,
-	0x1620e, 0x1621c, 0x16238, 0x16270, 0x1627e, 0x162e0, 0x162fc, 0x16304, 0x16308, 0x16310, 0x1631e, 0x16320,
-	0x1633c, 0x16340, 0x16378, 0x16386, 0x1638c, 0x16398, 0x163b0, 0x163be, 0x163ce, 0x163dc, 0x163e2, 0x163e4,
-	0x163e8, 0x163f6, 0x1640e, 0x1641c, 0x16438, 0x16470, 0x1647e, 0x164e0, 0x164fc, 0x165c0, 0x165f8, 0x16610,
-	0x1661e, 0x16620, 0x1663c, 0x16640, 0x16678, 0x166f0, 0x16718, 0x16730, 0x1673e, 0x16760, 0x1677c, 0x1678e,
-	0x1679c, 0x167b8, 0x167c2, 0x167c4, 0x167c8, 0x167d0, 0x167de, 0x167e6, 0x167ec, 0x1681c, 0x16838, 0x16870,
-	0x168e0, 0x168fc, 0x169c0, 0x169f8, 0x16bf0, 0x16c10, 0x16c1e, 0x16c20, 0x16c3c, 0x16c40, 0x16c78, 0x16cf0,
-	0x16de0, 0x16e18, 0x16e30, 0x16e3e, 0x16e60, 0x16e7c, 0x16ec0, 0x16ef8, 0x16f1c, 0x16f38, 0x16f70, 0x16f7e,
-	0x16f84, 0x16f88, 0x16f90, 0x16f9e, 0x16fa0, 0x16fbc, 0x16fc6, 0x16fcc, 0x16fd8, 0x17026, 0x1702c, 0x17046,
-	0x1704c, 0x17058, 0x1706e, 0x17086, 0x1708c, 0x17098, 0x170b0, 0x170be, 0x170ce, 0x170dc, 0x170e8, 0x17106,
-	0x1710c, 0x17118, 0x17130, 0x1713e, 0x17160, 0x1717c, 0x1718e, 0x1719c, 0x171b8, 0x171c2, 0x171c4, 0x171c8,
-	0x171d0, 0x171de, 0x171e6, 0x171ec, 0x171fa, 0x17206, 0x1720c, 0x17218, 0x17230, 0x1723e, 0x17260, 0x1727c,
-	0x172c0, 0x172f8, 0x1730e, 0x1731c, 0x17338, 0x17370, 0x1737e, 0x17388, 0x17390, 0x1739e, 0x173a0, 0x173bc,
-	0x173cc, 0x173d8, 0x173ee, 0x173f2, 0x173f4, 0x1740c, 0x17418, 0x17430, 0x1743e, 0x17460, 0x1747c, 0x174c0,
-	0x174f8, 0x175f0, 0x1760e, 0x1761c, 0x17638, 0x17670, 0x1767e, 0x176e0, 0x176fc, 0x17708, 0x17710, 0x1771e,
-	0x17720, 0x1773c, 0x17740, 0x17778, 0x17798, 0x177b0, 0x177be, 0x177dc, 0x177e2, 0x177e4, 0x177e8, 0x17822,
-	0x17824, 0x17828, 0x17836, 0x17842, 0x17844, 0x17848, 0x17850, 0x1785e, 0x17866, 0x1786c, 0x17882, 0x17884,
-	0x17888, 0x17890, 0x1789e, 0x178a0, 0x178bc, 0x178c6, 0x178cc, 0x178d8, 0x178ee, 0x178f2, 0x178f4, 0x17902,
-	0x17904, 0x17908, 0x17910, 0x1791e, 0x17920, 0x1793c, 0x17940, 0x17978, 0x17986, 0x1798c, 0x17998, 0x179b0,
-	0x179be, 0x179ce, 0x179dc, 0x179e2, 0x179e4, 0x179e8, 0x179f6, 0x17a04, 0x17a08, 0x17a10, 0x17a1e, 0x17a20,
-	0x17a3c, 0x17a40, 0x17a78, 0x17af0, 0x17b06, 0x17b0c, 0x17b18, 0x17b30, 0x17b3e, 0x17b60, 0x17b7c, 0x17b8e,
-	0x17b9c, 0x17bb8, 0x17bc4, 0x17bc8, 0x17bd0, 0x17bde, 0x17be6, 0x17bec, 0x17c2e, 0x17c32, 0x17c34, 0x17c4e,
-	0x17c5c, 0x17c62, 0x17c64, 0x17c68, 0x17c76, 0x17c8e, 0x17c9c, 0x17cb8, 0x17cc2, 0x17cc4, 0x17cc8, 0x17cd0,
-	0x17cde, 0x17ce6, 0x17cec, 0x17d0e, 0x17d1c, 0x17d38, 0x17d70, 0x17d82, 0x17d84, 0x17d88, 0x17d90, 0x17d9e,
-	0x17da0, 0x17dbc, 0x17dc6, 0x17dcc, 0x17dd8, 0x17dee, 0x17e26, 0x17e2c, 0x17e3a, 0x17e46, 0x17e4c, 0x17e58,
-	0x17e6e, 0x17e72, 0x17e74, 0x17e86, 0x17e8c, 0x17e98, 0x17eb0, 0x17ece, 0x17edc, 0x17ee2, 0x17ee4, 0x17ee8,
-	0x17ef6, 0x1813a, 0x18172, 0x18174, 0x18216, 0x18226, 0x1823a, 0x1824c, 0x18258, 0x1826e, 0x18272, 0x18274,
-	0x18298, 0x182be, 0x182e2, 0x182e4, 0x182e8, 0x182f6, 0x1835e, 0x1837a, 0x183ae, 0x183d6, 0x18416, 0x18426,
-	0x1842c, 0x1843a, 0x18446, 0x18458, 0x1846e, 0x18472, 0x18474, 0x18486, 0x184b0, 0x184be, 0x184ce, 0x184dc,
-	0x184e2, 0x184e4, 0x184e8, 0x184f6, 0x18506, 0x1850c, 0x18518, 0x18530, 0x1853e, 0x18560, 0x1857c, 0x1858e,
-	0x1859c, 0x185b8, 0x185c2, 0x185c4, 0x185c8, 0x185d0, 0x185de, 0x185e6, 0x185ec, 0x185fa, 0x18612, 0x18614,
-	0x18622, 0x18628, 0x18636, 0x18642, 0x18650, 0x1865e, 0x1867a, 0x18682, 0x18684, 0x18688, 0x18690, 0x1869e,
-	0x186a0, 0x186bc, 0x186c6, 0x186cc, 0x186d8, 0x186ee, 0x186f2, 0x186f4, 0x1872e, 0x1874e, 0x1875c, 0x18796,
-	0x187a6, 0x187ac, 0x187d2, 0x187d4, 0x18826, 0x1882c, 0x1883a, 0x18846, 0x1884c, 0x18858, 0x1886e, 0x18872,
-	0x18874, 0x18886, 0x18898, 0x188b0, 0x188be, 0x188ce, 0x188dc, 0x188e2, 0x188e4, 0x188e8, 0x188f6, 0x1890c,
-	0x18930, 0x1893e, 0x18960, 0x1897c, 0x1898e, 0x189b8, 0x189c2, 0x189c8, 0x189d0, 0x189de, 0x189e6, 0x189ec,
-	0x189fa, 0x18a18, 0x18a30, 0x18a3e, 0x18a60, 0x18a7c, 0x18ac0, 0x18af8, 0x18b1c, 0x18b38, 0x18b70, 0x18b7e,
-	0x18b82, 0x18b84, 0x18b88, 0x18b90, 0x18b9e, 0x18ba0, 0x18bbc, 0x18bc6, 0x18bcc, 0x18bd8, 0x18bee, 0x18bf2,
-	0x18bf4, 0x18c22, 0x18c24, 0x18c28, 0x18c36, 0x18c42, 0x18c48, 0x18c50, 0x18c5e, 0x18c66, 0x18c7a, 0x18c82,
-	0x18c84, 0x18c90, 0x18c9e, 0x18ca0, 0x18cbc, 0x18ccc, 0x18cf2, 0x18cf4, 0x18d04, 0x18d08, 0x18d10, 0x18d1e,
-	0x18d20, 0x18d3c, 0x18d40, 0x18d78, 0x18d86, 0x18d98, 0x18dce, 0x18de2, 0x18de4, 0x18de8, 0x18e2e, 0x18e32,
-	0x18e34, 0x18e4e, 0x18e5c, 0x18e62, 0x18e64, 0x18e68, 0x18e8e, 0x18e9c, 0x18eb8, 0x18ec2, 0x18ec4, 0x18ec8,
-	0x18ed0, 0x18efa, 0x18f16, 0x18f26, 0x18f2c, 0x18f46, 0x18f4c, 0x18f58, 0x18f6e, 0x18f8a, 0x18f92, 0x18f94,
-	0x18fa2, 0x18fa4, 0x18fa8, 0x18fb6, 0x1902c, 0x1903a, 0x19046, 0x1904c, 0x19058, 0x19072, 0x19074, 0x19086,
-	0x19098, 0x190b0, 0x190be, 0x190ce, 0x190dc, 0x190e2, 0x190e8, 0x190f6, 0x19106, 0x1910c, 0x19130, 0x1913e,
-	0x19160, 0x1917c, 0x1918e, 0x1919c, 0x191b8, 0x191c2, 0x191c8, 0x191d0, 0x191de, 0x191e6, 0x191ec, 0x191fa,
-	0x19218, 0x1923e, 0x19260, 0x1927c, 0x192c0, 0x192f8, 0x19338, 0x19370, 0x1937e, 0x19382, 0x19384, 0x19390,
-	0x1939e, 0x193a0, 0x193bc, 0x193c6, 0x193cc, 0x193d8, 0x193ee, 0x193f2, 0x193f4, 0x19430, 0x1943e, 0x19460,
-	0x1947c, 0x194c0, 0x194f8, 0x195f0, 0x19638, 0x19670, 0x1967e, 0x196e0, 0x196fc, 0x19702, 0x19704, 0x19708,
-	0x19710, 0x19720, 0x1973c, 0x19740, 0x19778, 0x19786, 0x1978c, 0x19798, 0x197b0, 0x197be, 0x197ce, 0x197dc,
-	0x197e2, 0x197e4, 0x197e8, 0x19822, 0x19824, 0x19842, 0x19848, 0x19850, 0x1985e, 0x19866, 0x1987a, 0x19882,
-	0x19884, 0x19890, 0x1989e, 0x198a0, 0x198bc, 0x198cc, 0x198f2, 0x198f4, 0x19902, 0x19908, 0x1991e, 0x19920,
-	0x1993c, 0x19940, 0x19978, 0x19986, 0x19998, 0x199ce, 0x199e2, 0x199e4, 0x199e8, 0x19a08, 0x19a10, 0x19a1e,
-	0x19a20, 0x19a3c, 0x19a40, 0x19a78, 0x19af0, 0x19b18, 0x19b3e, 0x19b60, 0x19b9c, 0x19bc2, 0x19bc4, 0x19bc8,
-	0x19bd0, 0x19be6, 0x19c2e, 0x19c34, 0x19c4e, 0x19c5c, 0x19c62, 0x19c64, 0x19c68, 0x19c8e, 0x19c9c, 0x19cb8,
-	0x19cc2, 0x19cc8, 0x19cd0, 0x19ce6, 0x19cfa, 0x19d0e, 0x19d1c, 0x19d38, 0x19d70, 0x19d7e, 0x19d82, 0x19d84,
-	0x19d88, 0x19d90, 0x19da0, 0x19dcc, 0x19df2, 0x19df4, 0x19e16, 0x19e26, 0x19e2c, 0x19e46, 0x19e4c, 0x19e58,
-	0x19e74, 0x19e86, 0x19e8c, 0x19e98, 0x19eb0, 0x19ebe, 0x19ece, 0x19ee2, 0x19ee4, 0x19ee8, 0x19f0a, 0x19f12,
-	0x19f14, 0x19f22, 0x19f24, 0x19f28, 0x19f42, 0x19f44, 0x19f48, 0x19f50, 0x19f5e, 0x19f6c, 0x19f9a, 0x19fae,
-	0x19fb2, 0x19fb4, 0x1a046, 0x1a04c, 0x1a072, 0x1a074, 0x1a086, 0x1a08c, 0x1a098, 0x1a0b0, 0x1a0be, 0x1a0e2,
-	0x1a0e4, 0x1a0e8, 0x1a0f6, 0x1a106, 0x1a10c, 0x1a118, 0x1a130, 0x1a13e, 0x1a160, 0x1a17c, 0x1a18e, 0x1a19c,
-	0x1a1b8, 0x1a1c2, 0x1a1c4, 0x1a1c8, 0x1a1d0, 0x1a1de, 0x1a1e6, 0x1a1ec, 0x1a218, 0x1a230, 0x1a23e, 0x1a260,
-	0x1a27c, 0x1a2c0, 0x1a2f8, 0x1a31c, 0x1a338, 0x1a370, 0x1a37e, 0x1a382, 0x1a384, 0x1a388, 0x1a390, 0x1a39e,
-	0x1a3a0, 0x1a3bc, 0x1a3c6, 0x1a3cc, 0x1a3d8, 0x1a3ee, 0x1a3f2, 0x1a3f4, 0x1a418, 0x1a430, 0x1a43e, 0x1a460,
-	0x1a47c, 0x1a4c0, 0x1a4f8, 0x1a5f0, 0x1a61c, 0x1a638, 0x1a670, 0x1a67e, 0x1a6e0, 0x1a6fc, 0x1a702, 0x1a704,
-	0x1a708, 0x1a710, 0x1a71e, 0x1a720, 0x1a73c, 0x1a740, 0x1a778, 0x1a786, 0x1a78c, 0x1a798, 0x1a7b0, 0x1a7be,
-	0x1a7ce, 0x1a7dc, 0x1a7e2, 0x1a7e4, 0x1a7e8, 0x1a830, 0x1a860, 0x1a87c, 0x1a8c0, 0x1a8f8, 0x1a9f0, 0x1abe0,
-	0x1ac70, 0x1ac7e, 0x1ace0, 0x1acfc, 0x1adc0, 0x1adf8, 0x1ae04, 0x1ae08, 0x1ae10, 0x1ae20, 0x1ae3c, 0x1ae40,
-	0x1ae78, 0x1aef0, 0x1af06, 0x1af0c, 0x1af18, 0x1af30, 0x1af3e, 0x1af60, 0x1af7c, 0x1af8e, 0x1af9c, 0x1afb8,
-	0x1afc4, 0x1afc8, 0x1afd0, 0x1afde, 0x1b042, 0x1b05e, 0x1b07a, 0x1b082, 0x1b084, 0x1b088, 0x1b090, 0x1b09e,
-	0x1b0a0, 0x1b0bc, 0x1b0cc, 0x1b0f2, 0x1b0f4, 0x1b102, 0x1b104, 0x1b108, 0x1b110, 0x1b11e, 0x1b120, 0x1b13c,
-	0x1b140, 0x1b178, 0x1b186, 0x1b198, 0x1b1ce, 0x1b1e2, 0x1b1e4, 0x1b1e8, 0x1b204, 0x1b208, 0x1b210, 0x1b21e,
-	0x1b220, 0x1b23c, 0x1b240, 0x1b278, 0x1b2f0, 0x1b30c, 0x1b33e, 0x1b360, 0x1b39c, 0x1b3c2, 0x1b3c4, 0x1b3c8,
-	0x1b3d0, 0x1b3e6, 0x1b410, 0x1b41e, 0x1b420, 0x1b43c, 0x1b440, 0x1b478, 0x1b4f0, 0x1b5e0, 0x1b618, 0x1b660,
-	0x1b67c, 0x1b6c0, 0x1b738, 0x1b782, 0x1b784, 0x1b788, 0x1b790, 0x1b79e, 0x1b7a0, 0x1b7cc, 0x1b82e, 0x1b84e,
-	0x1b85c, 0x1b88e, 0x1b89c, 0x1b8b8, 0x1b8c2, 0x1b8c4, 0x1b8c8, 0x1b8d0, 0x1b8e6, 0x1b8fa, 0x1b90e, 0x1b91c,
-	0x1b938, 0x1b970, 0x1b97e, 0x1b982, 0x1b984, 0x1b988, 0x1b990, 0x1b99e, 0x1b9a0, 0x1b9cc, 0x1b9f2, 0x1b9f4,
-	0x1ba0e, 0x1ba1c, 0x1ba38, 0x1ba70, 0x1ba7e, 0x1bae0, 0x1bafc, 0x1bb08, 0x1bb10, 0x1bb20, 0x1bb3c, 0x1bb40,
-	0x1bb98, 0x1bbce, 0x1bbe2, 0x1bbe4, 0x1bbe8, 0x1bc16, 0x1bc26, 0x1bc2c, 0x1bc46, 0x1bc4c, 0x1bc58, 0x1bc72,
-	0x1bc74, 0x1bc86, 0x1bc8c, 0x1bc98, 0x1bcb0, 0x1bcbe, 0x1bcce, 0x1bce2, 0x1bce4, 0x1bce8, 0x1bd06, 0x1bd0c,
-	0x1bd18, 0x1bd30, 0x1bd3e, 0x1bd60, 0x1bd7c, 0x1bd9c, 0x1bdc2, 0x1bdc4, 0x1bdc8, 0x1bdd0, 0x1bde6, 0x1bdfa,
-	0x1be12, 0x1be14, 0x1be22, 0x1be24, 0x1be28, 0x1be42, 0x1be44, 0x1be48, 0x1be50, 0x1be5e, 0x1be66, 0x1be82,
-	0x1be84, 0x1be88, 0x1be90, 0x1be9e, 0x1bea0, 0x1bebc, 0x1becc, 0x1bef4, 0x1bf1a, 0x1bf2e, 0x1bf32, 0x1bf34,
-	0x1bf4e, 0x1bf5c, 0x1bf62, 0x1bf64, 0x1bf68, 0x1c09a, 0x1c0b2, 0x1c0b4, 0x1c11a, 0x1c132, 0x1c134, 0x1c162,
-	0x1c164, 0x1c168, 0x1c176, 0x1c1ba, 0x1c21a, 0x1c232, 0x1c234, 0x1c24e, 0x1c25c, 0x1c262, 0x1c264, 0x1c268,
-	0x1c276, 0x1c28e, 0x1c2c2, 0x1c2c4, 0x1c2c8, 0x1c2d0, 0x1c2de, 0x1c2e6, 0x1c2ec, 0x1c2fa, 0x1c316, 0x1c326,
-	0x1c33a, 0x1c346, 0x1c34c, 0x1c372, 0x1c374, 0x1c41a, 0x1c42e, 0x1c432, 0x1c434, 0x1c44e, 0x1c45c, 0x1c462,
-	0x1c464, 0x1c468, 0x1c476, 0x1c48e, 0x1c49c, 0x1c4b8, 0x1c4c2, 0x1c4c8, 0x1c4d0, 0x1c4de, 0x1c4e6, 0x1c4ec,
-	0x1c4fa, 0x1c51c, 0x1c538, 0x1c570, 0x1c57e, 0x1c582, 0x1c584, 0x1c588, 0x1c590, 0x1c59e, 0x1c5a0, 0x1c5bc,
-	0x1c5c6, 0x1c5cc, 0x1c5d8, 0x1c5ee, 0x1c5f2, 0x1c5f4, 0x1c616, 0x1c626, 0x1c62c, 0x1c63a, 0x1c646, 0x1c64c,
-	0x1c658, 0x1c66e, 0x1c672, 0x1c674, 0x1c686, 0x1c68c, 0x1c698, 0x1c6b0, 0x1c6be, 0x1c6ce, 0x1c6dc, 0x1c6e2,
-	0x1c6e4, 0x1c6e8, 0x1c712, 0x1c714, 0x1c722, 0x1c728, 0x1c736, 0x1c742, 0x1c744, 0x1c748, 0x1c750, 0x1c75e,
-	0x1c766, 0x1c76c, 0x1c77a, 0x1c7ae, 0x1c7d6, 0x1c7ea, 0x1c81a, 0x1c82e, 0x1c832, 0x1c834, 0x1c84e, 0x1c85c,
-	0x1c862, 0x1c864, 0x1c868, 0x1c876, 0x1c88e, 0x1c89c, 0x1c8b8, 0x1c8c2, 0x1c8c8, 0x1c8d0, 0x1c8de, 0x1c8e6,
-	0x1c8ec, 0x1c8fa, 0x1c90e, 0x1c938, 0x1c970, 0x1c97e, 0x1c982, 0x1c984, 0x1c990, 0x1c99e, 0x1c9a0, 0x1c9bc,
-	0x1c9c6, 0x1c9cc, 0x1c9d8, 0x1c9ee, 0x1c9f2, 0x1c9f4, 0x1ca38, 0x1ca70, 0x1ca7e, 0x1cae0, 0x1cafc, 0x1cb02,
-	0x1cb04, 0x1cb08, 0x1cb10, 0x1cb20, 0x1cb3c, 0x1cb40, 0x1cb78, 0x1cb86, 0x1cb8c, 0x1cb98, 0x1cbb0, 0x1cbbe,
-	0x1cbce, 0x1cbdc, 0x1cbe2, 0x1cbe4, 0x1cbe8, 0x1cbf6, 0x1cc16, 0x1cc26, 0x1cc2c, 0x1cc3a, 0x1cc46, 0x1cc58,
-	0x1cc72, 0x1cc74, 0x1cc86, 0x1ccb0, 0x1ccbe, 0x1ccce, 0x1cce2, 0x1cce4, 0x1cce8, 0x1cd06, 0x1cd0c, 0x1cd18,
-	0x1cd30, 0x1cd3e, 0x1cd60, 0x1cd7c, 0x1cd9c, 0x1cdc2, 0x1cdc4, 0x1cdc8, 0x1cdd0, 0x1cdde, 0x1cde6, 0x1cdfa,
-	0x1ce22, 0x1ce28, 0x1ce42, 0x1ce50, 0x1ce5e, 0x1ce66, 0x1ce7a, 0x1ce82, 0x1ce84, 0x1ce88, 0x1ce90, 0x1ce9e,
-	0x1cea0, 0x1cebc, 0x1cecc, 0x1cef2, 0x1cef4, 0x1cf2e, 0x1cf32, 0x1cf34, 0x1cf4e, 0x1cf5c, 0x1cf62, 0x1cf64,
-	0x1cf68, 0x1cf96, 0x1cfa6, 0x1cfac, 0x1cfca, 0x1cfd2, 0x1cfd4, 0x1d02e, 0x1d032, 0x1d034, 0x1d04e, 0x1d05c,
-	0x1d062, 0x1d064, 0x1d068, 0x1d076, 0x1d08e, 0x1d09c, 0x1d0b8, 0x1d0c2, 0x1d0c4, 0x1d0c8, 0x1d0d0, 0x1d0de,
-	0x1d0e6, 0x1d0ec, 0x1d0fa, 0x1d11c, 0x1d138, 0x1d170, 0x1d17e, 0x1d182, 0x1d184, 0x1d188, 0x1d190, 0x1d19e,
-	0x1d1a0, 0x1d1bc, 0x1d1c6, 0x1d1cc, 0x1d1d8, 0x1d1ee, 0x1d1f2, 0x1d1f4, 0x1d21c, 0x1d238, 0x1d270, 0x1d27e,
-	0x1d2e0, 0x1d2fc, 0x1d302, 0x1d304, 0x1d308, 0x1d310, 0x1d31e, 0x1d320, 0x1d33c, 0x1d340, 0x1d378, 0x1d386,
-	0x1d38c, 0x1d398, 0x1d3b0, 0x1d3be, 0x1d3ce, 0x1d3dc, 0x1d3e2, 0x1d3e4, 0x1d3e8, 0x1d3f6, 0x1d470, 0x1d47e,
-	0x1d4e0, 0x1d4fc, 0x1d5c0, 0x1d5f8, 0x1d604, 0x1d608, 0x1d610, 0x1d620, 0x1d640, 0x1d678, 0x1d6f0, 0x1d706,
-	0x1d70c, 0x1d718, 0x1d730, 0x1d73e, 0x1d760, 0x1d77c, 0x1d78e, 0x1d79c, 0x1d7b8, 0x1d7c2, 0x1d7c4, 0x1d7c8,
-	0x1d7d0, 0x1d7de, 0x1d7e6, 0x1d7ec, 0x1d826, 0x1d82c, 0x1d83a, 0x1d846, 0x1d84c, 0x1d858, 0x1d872, 0x1d874,
-	0x1d886, 0x1d88c, 0x1d898, 0x1d8b0, 0x1d8be, 0x1d8ce, 0x1d8e2, 0x1d8e4, 0x1d8e8, 0x1d8f6, 0x1d90c, 0x1d918,
-	0x1d930, 0x1d93e, 0x1d960, 0x1d97c, 0x1d99c, 0x1d9c2, 0x1d9c4, 0x1d9c8, 0x1d9d0, 0x1d9e6, 0x1d9fa, 0x1da0c,
-	0x1da18, 0x1da30, 0x1da3e, 0x1da60, 0x1da7c, 0x1dac0, 0x1daf8, 0x1db38, 0x1db82, 0x1db84, 0x1db88, 0x1db90,
-	0x1db9e, 0x1dba0, 0x1dbcc, 0x1dbf2, 0x1dbf4, 0x1dc22, 0x1dc42, 0x1dc44, 0x1dc48, 0x1dc50, 0x1dc5e, 0x1dc66,
-	0x1dc7a, 0x1dc82, 0x1dc84, 0x1dc88, 0x1dc90, 0x1dc9e, 0x1dca0, 0x1dcbc, 0x1dccc, 0x1dcf2, 0x1dcf4, 0x1dd04,
-	0x1dd08, 0x1dd10, 0x1dd1e, 0x1dd20, 0x1dd3c, 0x1dd40, 0x1dd78, 0x1dd86, 0x1dd98, 0x1ddce, 0x1dde2, 0x1dde4,
-	0x1dde8, 0x1de2e, 0x1de32, 0x1de34, 0x1de4e, 0x1de5c, 0x1de62, 0x1de64, 0x1de68, 0x1de8e, 0x1de9c, 0x1deb8,
-	0x1dec2, 0x1dec4, 0x1dec8, 0x1ded0, 0x1dee6, 0x1defa, 0x1df16, 0x1df26, 0x1df2c, 0x1df46, 0x1df4c, 0x1df58,
-	0x1df72, 0x1df74, 0x1df8a, 0x1df92, 0x1df94, 0x1dfa2, 0x1dfa4, 0x1dfa8, 0x1e08a, 0x1e092, 0x1e094, 0x1e0a2,
-	0x1e0a4, 0x1e0a8, 0x1e0b6, 0x1e0da, 0x1e10a, 0x1e112, 0x1e114, 0x1e122, 0x1e124, 0x1e128, 0x1e136, 0x1e142,
-	0x1e144, 0x1e148, 0x1e150, 0x1e166, 0x1e16c, 0x1e17a, 0x1e19a, 0x1e1b2, 0x1e1b4, 0x1e20a, 0x1e212, 0x1e214,
-	0x1e222, 0x1e224, 0x1e228, 0x1e236, 0x1e242, 0x1e248, 0x1e250, 0x1e25e, 0x1e266, 0x1e26c, 0x1e27a, 0x1e282,
-	0x1e284, 0x1e288, 0x1e290, 0x1e2a0, 0x1e2bc, 0x1e2c6, 0x1e2cc, 0x1e2d8, 0x1e2ee, 0x1e2f2, 0x1e2f4, 0x1e31a,
-	0x1e332, 0x1e334, 0x1e35c, 0x1e362, 0x1e364, 0x1e368, 0x1e3ba, 0x1e40a, 0x1e412, 0x1e414, 0x1e422, 0x1e428,
-	0x1e436, 0x1e442, 0x1e448, 0x1e450, 0x1e45e, 0x1e466, 0x1e46c, 0x1e47a, 0x1e482, 0x1e484, 0x1e490, 0x1e49e,
-	0x1e4a0, 0x1e4bc, 0x1e4c6, 0x1e4cc, 0x1e4d8, 0x1e4ee, 0x1e4f2, 0x1e4f4, 0x1e502, 0x1e504, 0x1e508, 0x1e510,
-	0x1e51e, 0x1e520, 0x1e53c, 0x1e540, 0x1e578, 0x1e586, 0x1e58c, 0x1e598, 0x1e5b0, 0x1e5be, 0x1e5ce, 0x1e5dc,
-	0x1e5e2, 0x1e5e4, 0x1e5e8, 0x1e5f6, 0x1e61a, 0x1e62e, 0x1e632, 0x1e634, 0x1e64e, 0x1e65c, 0x1e662, 0x1e668,
-	0x1e68e, 0x1e69c, 0x1e6b8, 0x1e6c2, 0x1e6c4, 0x1e6c8, 0x1e6d0, 0x1e6e6, 0x1e6fa, 0x1e716, 0x1e726, 0x1e72c,
-	0x1e73a, 0x1e746, 0x1e74c, 0x1e758, 0x1e772, 0x1e774, 0x1e792, 0x1e794, 0x1e7a2, 0x1e7a4, 0x1e7a8, 0x1e7b6,
-	0x1e812, 0x1e814, 0x1e822, 0x1e824, 0x1e828, 0x1e836, 0x1e842, 0x1e844, 0x1e848, 0x1e850, 0x1e85e, 0x1e866,
-	0x1e86c, 0x1e87a, 0x1e882, 0x1e884, 0x1e888, 0x1e890, 0x1e89e, 0x1e8a0, 0x1e8bc, 0x1e8c6, 0x1e8cc, 0x1e8d8,
-	0x1e8ee, 0x1e8f2, 0x1e8f4, 0x1e902, 0x1e904, 0x1e908, 0x1e910, 0x1e920, 0x1e93c, 0x1e940, 0x1e978, 0x1e986,
-	0x1e98c, 0x1e998, 0x1e9b0, 0x1e9be, 0x1e9ce, 0x1e9dc, 0x1e9e2, 0x1e9e4, 0x1e9e8, 0x1e9f6, 0x1ea04, 0x1ea08,
-	0x1ea10, 0x1ea20, 0x1ea40, 0x1ea78, 0x1eaf0, 0x1eb06, 0x1eb0c, 0x1eb18, 0x1eb30, 0x1eb3e, 0x1eb60, 0x1eb7c,
-	0x1eb8e, 0x1eb9c, 0x1ebb8, 0x1ebc2, 0x1ebc4, 0x1ebc8, 0x1ebd0, 0x1ebde, 0x1ebe6, 0x1ebec, 0x1ec1a, 0x1ec2e,
-	0x1ec32, 0x1ec34, 0x1ec4e, 0x1ec5c, 0x1ec62, 0x1ec64, 0x1ec68, 0x1ec8e, 0x1ec9c, 0x1ecb8, 0x1ecc2, 0x1ecc4,
-	0x1ecc8, 0x1ecd0, 0x1ece6, 0x1ecfa, 0x1ed0e, 0x1ed1c, 0x1ed38, 0x1ed70, 0x1ed7e, 0x1ed82, 0x1ed84, 0x1ed88,
-	0x1ed90, 0x1ed9e, 0x1eda0, 0x1edcc, 0x1edf2, 0x1edf4, 0x1ee16, 0x1ee26, 0x1ee2c, 0x1ee3a, 0x1ee46, 0x1ee4c,
-	0x1ee58, 0x1ee6e, 0x1ee72, 0x1ee74, 0x1ee86, 0x1ee8c, 0x1ee98, 0x1eeb0, 0x1eebe, 0x1eece, 0x1eedc, 0x1eee2,
-	0x1eee4, 0x1eee8, 0x1ef12, 0x1ef22, 0x1ef24, 0x1ef28, 0x1ef36, 0x1ef42, 0x1ef44, 0x1ef48, 0x1ef50, 0x1ef5e,
-	0x1ef66, 0x1ef6c, 0x1ef7a, 0x1efae, 0x1efb2, 0x1efb4, 0x1efd6, 0x1f096, 0x1f0a6, 0x1f0ac, 0x1f0ba, 0x1f0ca,
-	0x1f0d2, 0x1f0d4, 0x1f116, 0x1f126, 0x1f12c, 0x1f13a, 0x1f146, 0x1f14c, 0x1f158, 0x1f16e, 0x1f172, 0x1f174,
-	0x1f18a, 0x1f192, 0x1f194, 0x1f1a2, 0x1f1a4, 0x1f1a8, 0x1f1da, 0x1f216, 0x1f226, 0x1f22c, 0x1f23a, 0x1f246,
-	0x1f258, 0x1f26e, 0x1f272, 0x1f274, 0x1f286, 0x1f28c, 0x1f298, 0x1f2b0, 0x1f2be, 0x1f2ce, 0x1f2dc, 0x1f2e2,
-	0x1f2e4, 0x1f2e8, 0x1f2f6, 0x1f30a, 0x1f312, 0x1f314, 0x1f322, 0x1f328, 0x1f342, 0x1f344, 0x1f348, 0x1f350,
-	0x1f35e, 0x1f366, 0x1f37a, 0x1f39a, 0x1f3ae, 0x1f3b2, 0x1f3b4, 0x1f416, 0x1f426, 0x1f42c, 0x1f43a, 0x1f446,
-	0x1f44c, 0x1f458, 0x1f46e, 0x1f472, 0x1f474, 0x1f486, 0x1f48c, 0x1f498, 0x1f4b0, 0x1f4be, 0x1f4ce, 0x1f4dc,
-	0x1f4e2, 0x1f4e4, 0x1f4e8, 0x1f4f6, 0x1f506, 0x1f50c, 0x1f518, 0x1f530, 0x1f53e, 0x1f560, 0x1f57c, 0x1f58e,
-	0x1f59c, 0x1f5b8, 0x1f5c2, 0x1f5c4, 0x1f5c8, 0x1f5d0, 0x1f5de, 0x1f5e6, 0x1f5ec, 0x1f5fa, 0x1f60a, 0x1f612,
-	0x1f614, 0x1f622, 0x1f624, 0x1f628, 0x1f636, 0x1f642, 0x1f644, 0x1f648, 0x1f650, 0x1f65e, 0x1f666, 0x1f67a,
-	0x1f682, 0x1f684, 0x1f688, 0x1f690, 0x1f69e, 0x1f6a0, 0x1f6bc, 0x1f6cc, 0x1f6f2, 0x1f6f4, 0x1f71a, 0x1f72e,
-	0x1f732, 0x1f734, 0x1f74e, 0x1f75c, 0x1f762, 0x1f764, 0x1f768, 0x1f776, 0x1f796, 0x1f7a6, 0x1f7ac, 0x1f7ba,
-	0x1f7d2, 0x1f7d4, 0x1f89a, 0x1f8ae, 0x1f8b2, 0x1f8b4, 0x1f8d6, 0x1f8ea, 0x1f91a, 0x1f92e, 0x1f932, 0x1f934,
-	0x1f94e, 0x1f95c, 0x1f962, 0x1f964, 0x1f968, 0x1f976, 0x1f996, 0x1f9a6, 0x1f9ac, 0x1f9ba, 0x1f9ca, 0x1f9d2,
-	0x1f9d4, 0x1fa1a, 0x1fa2e, 0x1fa32, 0x1fa34, 0x1fa4e, 0x1fa5c, 0x1fa62, 0x1fa64, 0x1fa68, 0x1fa76, 0x1fa8e,
-	0x1fa9c, 0x1fab8, 0x1fac2, 0x1fac4, 0x1fac8, 0x1fad0, 0x1fade, 0x1fae6, 0x1faec, 0x1fb16, 0x1fb26, 0x1fb2c,
-	0x1fb3a, 0x1fb46, 0x1fb4c, 0x1fb58, 0x1fb6e, 0x1fb72, 0x1fb74, 0x1fb8a, 0x1fb92, 0x1fb94, 0x1fba2, 0x1fba4,
-	0x1fba8, 0x1fbb6, 0x1fbda
+static constexpr const std::array<uint16_t, 2787> SYMBOL_TABLE = {
+	0x025e, 0x027a, 0x029e, 0x02bc, 0x02f2, 0x02f4, 0x032e, 0x034e, 0x035c, 0x0396, 0x03a6, 0x03ac,
+	0x0422, 0x0428, 0x0436, 0x0442, 0x0444, 0x0448, 0x0450, 0x045e, 0x0466, 0x046c, 0x047a, 0x0482,
+	0x049e, 0x04a0, 0x04bc, 0x04c6, 0x04d8, 0x04ee, 0x04f2, 0x04f4, 0x0504, 0x0508, 0x0510, 0x051e,
+	0x0520, 0x053c, 0x0540, 0x0578, 0x0586, 0x058c, 0x0598, 0x05b0, 0x05be, 0x05ce, 0x05dc, 0x05e2,
+	0x05e4, 0x05e8, 0x05f6, 0x062e, 0x064e, 0x065c, 0x068e, 0x069c, 0x06b8, 0x06de, 0x06fa, 0x0716,
+	0x0726, 0x072c, 0x0746, 0x074c, 0x0758, 0x076e, 0x0792, 0x0794, 0x07a2, 0x07a4, 0x07a8, 0x07b6,
+	0x0822, 0x0828, 0x0842, 0x0848, 0x0850, 0x085e, 0x0866, 0x086c, 0x087a, 0x0882, 0x0884, 0x0890,
+	0x089e, 0x08a0, 0x08bc, 0x08c6, 0x08cc, 0x08d8, 0x08ee, 0x08f2, 0x08f4, 0x0902, 0x0908, 0x091e,
+	0x0920, 0x093c, 0x0940, 0x0978, 0x0986, 0x0998, 0x09b0, 0x09be, 0x09ce, 0x09dc, 0x09e2, 0x09e4,
+	0x09e8, 0x09f6, 0x0a08, 0x0a10, 0x0a1e, 0x0a20, 0x0a3c, 0x0a40, 0x0a78, 0x0af0, 0x0b06, 0x0b0c,
+	0x0b18, 0x0b30, 0x0b3e, 0x0b60, 0x0b7c, 0x0b8e, 0x0b9c, 0x0bb8, 0x0bc2, 0x0bc4, 0x0bc8, 0x0bd0,
+	0x0bde, 0x0be6, 0x0bec, 0x0c2e, 0x0c4e, 0x0c5c, 0x0c62, 0x0c64, 0x0c68, 0x0c76, 0x0c8e, 0x0c9c,
+	0x0cb8, 0x0cc2, 0x0cc4, 0x0cc8, 0x0cd0, 0x0cde, 0x0ce6, 0x0cec, 0x0cfa, 0x0d0e, 0x0d1c, 0x0d38,
+	0x0d70, 0x0d7e, 0x0d82, 0x0d84, 0x0d88, 0x0d90, 0x0d9e, 0x0da0, 0x0dbc, 0x0dc6, 0x0dcc, 0x0dd8,
+	0x0dee, 0x0df2, 0x0df4, 0x0e16, 0x0e26, 0x0e2c, 0x0e46, 0x0e58, 0x0e6e, 0x0e86, 0x0e8c, 0x0e98,
+	0x0eb0, 0x0ebe, 0x0ece, 0x0edc, 0x0f0a, 0x0f12, 0x0f14, 0x0f22, 0x0f28, 0x0f36, 0x0f42, 0x0f44,
+	0x0f48, 0x0f50, 0x0f5e, 0x0f66, 0x0f6c, 0x0fb2, 0x0fb4, 0x1022, 0x1028, 0x1042, 0x1048, 0x1050,
+	0x105e, 0x107a, 0x1082, 0x1084, 0x1090, 0x109e, 0x10a0, 0x10bc, 0x10c6, 0x10cc, 0x10d8, 0x10ee,
+	0x10f2, 0x10f4, 0x1102, 0x111e, 0x1120, 0x113c, 0x1140, 0x1178, 0x1186, 0x1198, 0x11b0, 0x11be,
+	0x11ce, 0x11dc, 0x11e2, 0x11e4, 0x11e8, 0x11f6, 0x1208, 0x121e, 0x1220, 0x1278, 0x12f0, 0x130c,
+	0x1330, 0x133e, 0x1360, 0x137c, 0x138e, 0x139c, 0x13b8, 0x13c2, 0x13c8, 0x13d0, 0x13de, 0x13e6,
+	0x13ec, 0x1408, 0x1410, 0x141e, 0x1420, 0x143c, 0x1440, 0x1478, 0x14f0, 0x15e0, 0x160c, 0x1618,
+	0x1630, 0x163e, 0x1660, 0x167c, 0x16c0, 0x16f8, 0x171c, 0x1738, 0x1770, 0x177e, 0x1782, 0x1784,
+	0x1788, 0x1790, 0x179e, 0x17a0, 0x17bc, 0x17c6, 0x17cc, 0x17d8, 0x17ee, 0x182e, 0x1834, 0x184e,
+	0x185c, 0x1862, 0x1864, 0x1868, 0x1876, 0x188e, 0x189c, 0x18b8, 0x18c2, 0x18c8, 0x18d0, 0x18de,
+	0x18e6, 0x18ec, 0x18fa, 0x190e, 0x191c, 0x1938, 0x1970, 0x197e, 0x1982, 0x1984, 0x1990, 0x199e,
+	0x19a0, 0x19bc, 0x19c6, 0x19cc, 0x19d8, 0x19ee, 0x19f2, 0x19f4, 0x1a0e, 0x1a1c, 0x1a38, 0x1a70,
+	0x1a7e, 0x1ae0, 0x1afc, 0x1b08, 0x1b10, 0x1b1e, 0x1b20, 0x1b3c, 0x1b40, 0x1b78, 0x1b8c, 0x1b98,
+	0x1bb0, 0x1bbe, 0x1bce, 0x1bdc, 0x1be2, 0x1be4, 0x1be8, 0x1bf6, 0x1c16, 0x1c26, 0x1c2c, 0x1c46,
+	0x1c4c, 0x1c58, 0x1c6e, 0x1c86, 0x1c98, 0x1cb0, 0x1cbe, 0x1cce, 0x1cdc, 0x1ce2, 0x1ce4, 0x1ce8,
+	0x1cf6, 0x1d06, 0x1d0c, 0x1d18, 0x1d30, 0x1d3e, 0x1d60, 0x1d7c, 0x1d8e, 0x1d9c, 0x1db8, 0x1dc4,
+	0x1dc8, 0x1dd0, 0x1dde, 0x1de6, 0x1dec, 0x1dfa, 0x1e0a, 0x1e12, 0x1e14, 0x1e22, 0x1e24, 0x1e28,
+	0x1e36, 0x1e42, 0x1e44, 0x1e50, 0x1e5e, 0x1e66, 0x1e6c, 0x1e82, 0x1e84, 0x1e88, 0x1e90, 0x1e9e,
+	0x1ea0, 0x1ebc, 0x1ec6, 0x1ecc, 0x1ed8, 0x1eee, 0x1f1a, 0x1f2e, 0x1f32, 0x1f34, 0x1f4e, 0x1f5c,
+	0x1f62, 0x1f64, 0x1f68, 0x1f76, 0x2048, 0x205e, 0x2082, 0x2084, 0x2090, 0x209e, 0x20a0, 0x20bc,
+	0x20d8, 0x20f2, 0x20f4, 0x2108, 0x211e, 0x2120, 0x213c, 0x2140, 0x2178, 0x2186, 0x2198, 0x21b0,
+	0x21be, 0x21e2, 0x21e4, 0x21e8, 0x21f6, 0x2204, 0x2210, 0x221e, 0x2220, 0x2278, 0x22f0, 0x2306,
+	0x230c, 0x2330, 0x233e, 0x2360, 0x237c, 0x238e, 0x239c, 0x23b8, 0x23c2, 0x23c8, 0x23d0, 0x23e6,
+	0x23ec, 0x241e, 0x2420, 0x243c, 0x24f0, 0x25e0, 0x2618, 0x263e, 0x2660, 0x267c, 0x26c0, 0x26f8,
+	0x2738, 0x2770, 0x277e, 0x2782, 0x2784, 0x2790, 0x279e, 0x27a0, 0x27bc, 0x27c6, 0x27cc, 0x27d8,
+	0x27ee, 0x2820, 0x283c, 0x2840, 0x2878, 0x28f0, 0x29e0, 0x2bc0, 0x2c18, 0x2c30, 0x2c3e, 0x2c60,
+	0x2c7c, 0x2cc0, 0x2cf8, 0x2df0, 0x2e1c, 0x2e38, 0x2e70, 0x2e7e, 0x2ee0, 0x2efc, 0x2f04, 0x2f08,
+	0x2f10, 0x2f20, 0x2f3c, 0x2f40, 0x2f78, 0x2f86, 0x2f8c, 0x2f98, 0x2fb0, 0x2fbe, 0x2fce, 0x2fdc,
+	0x302e, 0x304e, 0x305c, 0x3062, 0x3068, 0x308e, 0x309c, 0x30b8, 0x30c2, 0x30c8, 0x30d0, 0x30de,
+	0x30ec, 0x30fa, 0x310e, 0x3138, 0x3170, 0x317e, 0x3182, 0x3184, 0x3190, 0x319e, 0x31a0, 0x31bc,
+	0x31c6, 0x31cc, 0x31d8, 0x31f2, 0x31f4, 0x320e, 0x321c, 0x3270, 0x327e, 0x32e0, 0x32fc, 0x3308,
+	0x331e, 0x3320, 0x333c, 0x3340, 0x3378, 0x3386, 0x3398, 0x33b0, 0x33be, 0x33ce, 0x33dc, 0x33e2,
+	0x33e4, 0x33e8, 0x33f6, 0x340e, 0x341c, 0x3438, 0x3470, 0x347e, 0x34e0, 0x34fc, 0x35c0, 0x35f8,
+	0x3608, 0x3610, 0x361e, 0x3620, 0x363c, 0x3640, 0x3678, 0x36f0, 0x370c, 0x3718, 0x3730, 0x373e,
+	0x3760, 0x377c, 0x379c, 0x37b8, 0x37c2, 0x37c4, 0x37c8, 0x37d0, 0x37de, 0x37e6, 0x37ec, 0x3816,
+	0x3826, 0x382c, 0x3846, 0x384c, 0x3858, 0x386e, 0x3874, 0x3886, 0x3898, 0x38b0, 0x38be, 0x38ce,
+	0x38dc, 0x38e2, 0x38e4, 0x38e8, 0x3906, 0x390c, 0x3930, 0x393e, 0x3960, 0x397c, 0x398e, 0x399c,
+	0x39b8, 0x39c8, 0x39d0, 0x39de, 0x39e6, 0x39ec, 0x39fa, 0x3a06, 0x3a0c, 0x3a18, 0x3a30, 0x3a3e,
+	0x3a60, 0x3a7c, 0x3ac0, 0x3af8, 0x3b0e, 0x3b1c, 0x3b38, 0x3b70, 0x3b7e, 0x3b88, 0x3b90, 0x3b9e,
+	0x3ba0, 0x3bbc, 0x3bcc, 0x3bd8, 0x3bee, 0x3bf2, 0x3bf4, 0x3c12, 0x3c14, 0x3c22, 0x3c24, 0x3c28,
+	0x3c36, 0x3c42, 0x3c48, 0x3c50, 0x3c5e, 0x3c66, 0x3c6c, 0x3c82, 0x3c84, 0x3c90, 0x3c9e, 0x3ca0,
+	0x3cbc, 0x3cc6, 0x3ccc, 0x3cd8, 0x3cee, 0x3d02, 0x3d04, 0x3d08, 0x3d10, 0x3d1e, 0x3d20, 0x3d3c,
+	0x3d40, 0x3d78, 0x3d86, 0x3d8c, 0x3d98, 0x3db0, 0x3dbe, 0x3dce, 0x3ddc, 0x3de4, 0x3de8, 0x3df6,
+	0x3e1a, 0x3e2e, 0x3e32, 0x3e34, 0x3e4e, 0x3e5c, 0x3e62, 0x3e64, 0x3e68, 0x3e76, 0x3e8e, 0x3e9c,
+	0x3eb8, 0x3ec2, 0x3ec4, 0x3ec8, 0x3ed0, 0x3ede, 0x3ee6, 0x3eec, 0x3f26, 0x3f2c, 0x3f3a, 0x3f46,
+	0x3f4c, 0x3f58, 0x3f6e, 0x3f72, 0x3f74, 0x4082, 0x409e, 0x40a0, 0x40bc, 0x4104, 0x4108, 0x4110,
+	0x411e, 0x4120, 0x413c, 0x4140, 0x4178, 0x418c, 0x4198, 0x41b0, 0x41be, 0x41e2, 0x41e4, 0x41e8,
+	0x4208, 0x4210, 0x421e, 0x4220, 0x423c, 0x4240, 0x4278, 0x42f0, 0x4306, 0x430c, 0x4318, 0x4330,
+	0x433e, 0x4360, 0x437c, 0x438e, 0x43c2, 0x43c4, 0x43c8, 0x43d0, 0x43e6, 0x43ec, 0x4408, 0x4410,
+	0x441e, 0x4420, 0x443c, 0x4440, 0x4478, 0x44f0, 0x45e0, 0x460c, 0x4618, 0x4630, 0x463e, 0x4660,
+	0x467c, 0x46c0, 0x46f8, 0x471c, 0x4738, 0x4770, 0x477e, 0x4782, 0x4784, 0x4788, 0x4790, 0x47a0,
+	0x47bc, 0x47c6, 0x47cc, 0x47d8, 0x47ee, 0x4810, 0x4820, 0x483c, 0x4840, 0x4878, 0x48f0, 0x49e0,
+	0x4bc0, 0x4c30, 0x4c3e, 0x4c60, 0x4c7c, 0x4cc0, 0x4cf8, 0x4df0, 0x4e38, 0x4e70, 0x4e7e, 0x4ee0,
+	0x4efc, 0x4f04, 0x4f08, 0x4f10, 0x4f1e, 0x4f20, 0x4f3c, 0x4f40, 0x4f78, 0x4f86, 0x4f8c, 0x4f98,
+	0x4fb0, 0x4fce, 0x4fdc, 0x5020, 0x5040, 0x5078, 0x50f0, 0x51e0, 0x53c0, 0x5860, 0x587c, 0x58c0,
+	0x58f8, 0x59f0, 0x5be0, 0x5c70, 0x5c7e, 0x5ce0, 0x5cfc, 0x5dc0, 0x5df8, 0x5e08, 0x5e10, 0x5e20,
+	0x5e40, 0x5e78, 0x5ef0, 0x5f0c, 0x5f18, 0x5f30, 0x5f60, 0x5f7c, 0x5f8e, 0x5f9c, 0x5fb8, 0x604e,
+	0x605c, 0x608e, 0x609c, 0x60b8, 0x60c2, 0x60c4, 0x60c8, 0x60de, 0x610e, 0x611c, 0x6138, 0x6170,
+	0x617e, 0x6184, 0x6188, 0x6190, 0x619e, 0x61a0, 0x61bc, 0x61c6, 0x61cc, 0x61d8, 0x61f2, 0x61f4,
+	0x620e, 0x621c, 0x6238, 0x6270, 0x627e, 0x62e0, 0x62fc, 0x6304, 0x6308, 0x6310, 0x631e, 0x6320,
+	0x633c, 0x6340, 0x6378, 0x6386, 0x638c, 0x6398, 0x63b0, 0x63be, 0x63ce, 0x63dc, 0x63e2, 0x63e4,
+	0x63e8, 0x63f6, 0x640e, 0x641c, 0x6438, 0x6470, 0x647e, 0x64e0, 0x64fc, 0x65c0, 0x65f8, 0x6610,
+	0x661e, 0x6620, 0x663c, 0x6640, 0x6678, 0x66f0, 0x6718, 0x6730, 0x673e, 0x6760, 0x677c, 0x678e,
+	0x679c, 0x67b8, 0x67c2, 0x67c4, 0x67c8, 0x67d0, 0x67de, 0x67e6, 0x67ec, 0x681c, 0x6838, 0x6870,
+	0x68e0, 0x68fc, 0x69c0, 0x69f8, 0x6bf0, 0x6c10, 0x6c1e, 0x6c20, 0x6c3c, 0x6c40, 0x6c78, 0x6cf0,
+	0x6de0, 0x6e18, 0x6e30, 0x6e3e, 0x6e60, 0x6e7c, 0x6ec0, 0x6ef8, 0x6f1c, 0x6f38, 0x6f70, 0x6f7e,
+	0x6f84, 0x6f88, 0x6f90, 0x6f9e, 0x6fa0, 0x6fbc, 0x6fc6, 0x6fcc, 0x6fd8, 0x7026, 0x702c, 0x7046,
+	0x704c, 0x7058, 0x706e, 0x7086, 0x708c, 0x7098, 0x70b0, 0x70be, 0x70ce, 0x70dc, 0x70e8, 0x7106,
+	0x710c, 0x7118, 0x7130, 0x713e, 0x7160, 0x717c, 0x718e, 0x719c, 0x71b8, 0x71c2, 0x71c4, 0x71c8,
+	0x71d0, 0x71de, 0x71e6, 0x71ec, 0x71fa, 0x7206, 0x720c, 0x7218, 0x7230, 0x723e, 0x7260, 0x727c,
+	0x72c0, 0x72f8, 0x730e, 0x731c, 0x7338, 0x7370, 0x737e, 0x7388, 0x7390, 0x739e, 0x73a0, 0x73bc,
+	0x73cc, 0x73d8, 0x73ee, 0x73f2, 0x73f4, 0x740c, 0x7418, 0x7430, 0x743e, 0x7460, 0x747c, 0x74c0,
+	0x74f8, 0x75f0, 0x760e, 0x761c, 0x7638, 0x7670, 0x767e, 0x76e0, 0x76fc, 0x7708, 0x7710, 0x771e,
+	0x7720, 0x773c, 0x7740, 0x7778, 0x7798, 0x77b0, 0x77be, 0x77dc, 0x77e2, 0x77e4, 0x77e8, 0x7822,
+	0x7824, 0x7828, 0x7836, 0x7842, 0x7844, 0x7848, 0x7850, 0x785e, 0x7866, 0x786c, 0x7882, 0x7884,
+	0x7888, 0x7890, 0x789e, 0x78a0, 0x78bc, 0x78c6, 0x78cc, 0x78d8, 0x78ee, 0x78f2, 0x78f4, 0x7902,
+	0x7904, 0x7908, 0x7910, 0x791e, 0x7920, 0x793c, 0x7940, 0x7978, 0x7986, 0x798c, 0x7998, 0x79b0,
+	0x79be, 0x79ce, 0x79dc, 0x79e2, 0x79e4, 0x79e8, 0x79f6, 0x7a04, 0x7a08, 0x7a10, 0x7a1e, 0x7a20,
+	0x7a3c, 0x7a40, 0x7a78, 0x7af0, 0x7b06, 0x7b0c, 0x7b18, 0x7b30, 0x7b3e, 0x7b60, 0x7b7c, 0x7b8e,
+	0x7b9c, 0x7bb8, 0x7bc4, 0x7bc8, 0x7bd0, 0x7bde, 0x7be6, 0x7bec, 0x7c2e, 0x7c32, 0x7c34, 0x7c4e,
+	0x7c5c, 0x7c62, 0x7c64, 0x7c68, 0x7c76, 0x7c8e, 0x7c9c, 0x7cb8, 0x7cc2, 0x7cc4, 0x7cc8, 0x7cd0,
+	0x7cde, 0x7ce6, 0x7cec, 0x7d0e, 0x7d1c, 0x7d38, 0x7d70, 0x7d82, 0x7d84, 0x7d88, 0x7d90, 0x7d9e,
+	0x7da0, 0x7dbc, 0x7dc6, 0x7dcc, 0x7dd8, 0x7dee, 0x7e26, 0x7e2c, 0x7e3a, 0x7e46, 0x7e4c, 0x7e58,
+	0x7e6e, 0x7e72, 0x7e74, 0x7e86, 0x7e8c, 0x7e98, 0x7eb0, 0x7ece, 0x7edc, 0x7ee2, 0x7ee4, 0x7ee8,
+	0x7ef6, 0x813a, 0x8172, 0x8174, 0x8216, 0x8226, 0x823a, 0x824c, 0x8258, 0x826e, 0x8272, 0x8274,
+	0x8298, 0x82be, 0x82e2, 0x82e4, 0x82e8, 0x82f6, 0x835e, 0x837a, 0x83ae, 0x83d6, 0x8416, 0x8426,
+	0x842c, 0x843a, 0x8446, 0x8458, 0x846e, 0x8472, 0x8474, 0x8486, 0x84b0, 0x84be, 0x84ce, 0x84dc,
+	0x84e2, 0x84e4, 0x84e8, 0x84f6, 0x8506, 0x850c, 0x8518, 0x8530, 0x853e, 0x8560, 0x857c, 0x858e,
+	0x859c, 0x85b8, 0x85c2, 0x85c4, 0x85c8, 0x85d0, 0x85de, 0x85e6, 0x85ec, 0x85fa, 0x8612, 0x8614,
+	0x8622, 0x8628, 0x8636, 0x8642, 0x8650, 0x865e, 0x867a, 0x8682, 0x8684, 0x8688, 0x8690, 0x869e,
+	0x86a0, 0x86bc, 0x86c6, 0x86cc, 0x86d8, 0x86ee, 0x86f2, 0x86f4, 0x872e, 0x874e, 0x875c, 0x8796,
+	0x87a6, 0x87ac, 0x87d2, 0x87d4, 0x8826, 0x882c, 0x883a, 0x8846, 0x884c, 0x8858, 0x886e, 0x8872,
+	0x8874, 0x8886, 0x8898, 0x88b0, 0x88be, 0x88ce, 0x88dc, 0x88e2, 0x88e4, 0x88e8, 0x88f6, 0x890c,
+	0x8930, 0x893e, 0x8960, 0x897c, 0x898e, 0x89b8, 0x89c2, 0x89c8, 0x89d0, 0x89de, 0x89e6, 0x89ec,
+	0x89fa, 0x8a18, 0x8a30, 0x8a3e, 0x8a60, 0x8a7c, 0x8ac0, 0x8af8, 0x8b1c, 0x8b38, 0x8b70, 0x8b7e,
+	0x8b82, 0x8b84, 0x8b88, 0x8b90, 0x8b9e, 0x8ba0, 0x8bbc, 0x8bc6, 0x8bcc, 0x8bd8, 0x8bee, 0x8bf2,
+	0x8bf4, 0x8c22, 0x8c24, 0x8c28, 0x8c36, 0x8c42, 0x8c48, 0x8c50, 0x8c5e, 0x8c66, 0x8c7a, 0x8c82,
+	0x8c84, 0x8c90, 0x8c9e, 0x8ca0, 0x8cbc, 0x8ccc, 0x8cf2, 0x8cf4, 0x8d04, 0x8d08, 0x8d10, 0x8d1e,
+	0x8d20, 0x8d3c, 0x8d40, 0x8d78, 0x8d86, 0x8d98, 0x8dce, 0x8de2, 0x8de4, 0x8de8, 0x8e2e, 0x8e32,
+	0x8e34, 0x8e4e, 0x8e5c, 0x8e62, 0x8e64, 0x8e68, 0x8e8e, 0x8e9c, 0x8eb8, 0x8ec2, 0x8ec4, 0x8ec8,
+	0x8ed0, 0x8efa, 0x8f16, 0x8f26, 0x8f2c, 0x8f46, 0x8f4c, 0x8f58, 0x8f6e, 0x8f8a, 0x8f92, 0x8f94,
+	0x8fa2, 0x8fa4, 0x8fa8, 0x8fb6, 0x902c, 0x903a, 0x9046, 0x904c, 0x9058, 0x9072, 0x9074, 0x9086,
+	0x9098, 0x90b0, 0x90be, 0x90ce, 0x90dc, 0x90e2, 0x90e8, 0x90f6, 0x9106, 0x910c, 0x9130, 0x913e,
+	0x9160, 0x917c, 0x918e, 0x919c, 0x91b8, 0x91c2, 0x91c8, 0x91d0, 0x91de, 0x91e6, 0x91ec, 0x91fa,
+	0x9218, 0x923e, 0x9260, 0x927c, 0x92c0, 0x92f8, 0x9338, 0x9370, 0x937e, 0x9382, 0x9384, 0x9390,
+	0x939e, 0x93a0, 0x93bc, 0x93c6, 0x93cc, 0x93d8, 0x93ee, 0x93f2, 0x93f4, 0x9430, 0x943e, 0x9460,
+	0x947c, 0x94c0, 0x94f8, 0x95f0, 0x9638, 0x9670, 0x967e, 0x96e0, 0x96fc, 0x9702, 0x9704, 0x9708,
+	0x9710, 0x9720, 0x973c, 0x9740, 0x9778, 0x9786, 0x978c, 0x9798, 0x97b0, 0x97be, 0x97ce, 0x97dc,
+	0x97e2, 0x97e4, 0x97e8, 0x9822, 0x9824, 0x9842, 0x9848, 0x9850, 0x985e, 0x9866, 0x987a, 0x9882,
+	0x9884, 0x9890, 0x989e, 0x98a0, 0x98bc, 0x98cc, 0x98f2, 0x98f4, 0x9902, 0x9908, 0x991e, 0x9920,
+	0x993c, 0x9940, 0x9978, 0x9986, 0x9998, 0x99ce, 0x99e2, 0x99e4, 0x99e8, 0x9a08, 0x9a10, 0x9a1e,
+	0x9a20, 0x9a3c, 0x9a40, 0x9a78, 0x9af0, 0x9b18, 0x9b3e, 0x9b60, 0x9b9c, 0x9bc2, 0x9bc4, 0x9bc8,
+	0x9bd0, 0x9be6, 0x9c2e, 0x9c34, 0x9c4e, 0x9c5c, 0x9c62, 0x9c64, 0x9c68, 0x9c8e, 0x9c9c, 0x9cb8,
+	0x9cc2, 0x9cc8, 0x9cd0, 0x9ce6, 0x9cfa, 0x9d0e, 0x9d1c, 0x9d38, 0x9d70, 0x9d7e, 0x9d82, 0x9d84,
+	0x9d88, 0x9d90, 0x9da0, 0x9dcc, 0x9df2, 0x9df4, 0x9e16, 0x9e26, 0x9e2c, 0x9e46, 0x9e4c, 0x9e58,
+	0x9e74, 0x9e86, 0x9e8c, 0x9e98, 0x9eb0, 0x9ebe, 0x9ece, 0x9ee2, 0x9ee4, 0x9ee8, 0x9f0a, 0x9f12,
+	0x9f14, 0x9f22, 0x9f24, 0x9f28, 0x9f42, 0x9f44, 0x9f48, 0x9f50, 0x9f5e, 0x9f6c, 0x9f9a, 0x9fae,
+	0x9fb2, 0x9fb4, 0xa046, 0xa04c, 0xa072, 0xa074, 0xa086, 0xa08c, 0xa098, 0xa0b0, 0xa0be, 0xa0e2,
+	0xa0e4, 0xa0e8, 0xa0f6, 0xa106, 0xa10c, 0xa118, 0xa130, 0xa13e, 0xa160, 0xa17c, 0xa18e, 0xa19c,
+	0xa1b8, 0xa1c2, 0xa1c4, 0xa1c8, 0xa1d0, 0xa1de, 0xa1e6, 0xa1ec, 0xa218, 0xa230, 0xa23e, 0xa260,
+	0xa27c, 0xa2c0, 0xa2f8, 0xa31c, 0xa338, 0xa370, 0xa37e, 0xa382, 0xa384, 0xa388, 0xa390, 0xa39e,
+	0xa3a0, 0xa3bc, 0xa3c6, 0xa3cc, 0xa3d8, 0xa3ee, 0xa3f2, 0xa3f4, 0xa418, 0xa430, 0xa43e, 0xa460,
+	0xa47c, 0xa4c0, 0xa4f8, 0xa5f0, 0xa61c, 0xa638, 0xa670, 0xa67e, 0xa6e0, 0xa6fc, 0xa702, 0xa704,
+	0xa708, 0xa710, 0xa71e, 0xa720, 0xa73c, 0xa740, 0xa778, 0xa786, 0xa78c, 0xa798, 0xa7b0, 0xa7be,
+	0xa7ce, 0xa7dc, 0xa7e2, 0xa7e4, 0xa7e8, 0xa830, 0xa860, 0xa87c, 0xa8c0, 0xa8f8, 0xa9f0, 0xabe0,
+	0xac70, 0xac7e, 0xace0, 0xacfc, 0xadc0, 0xadf8, 0xae04, 0xae08, 0xae10, 0xae20, 0xae3c, 0xae40,
+	0xae78, 0xaef0, 0xaf06, 0xaf0c, 0xaf18, 0xaf30, 0xaf3e, 0xaf60, 0xaf7c, 0xaf8e, 0xaf9c, 0xafb8,
+	0xafc4, 0xafc8, 0xafd0, 0xafde, 0xb042, 0xb05e, 0xb07a, 0xb082, 0xb084, 0xb088, 0xb090, 0xb09e,
+	0xb0a0, 0xb0bc, 0xb0cc, 0xb0f2, 0xb0f4, 0xb102, 0xb104, 0xb108, 0xb110, 0xb11e, 0xb120, 0xb13c,
+	0xb140, 0xb178, 0xb186, 0xb198, 0xb1ce, 0xb1e2, 0xb1e4, 0xb1e8, 0xb204, 0xb208, 0xb210, 0xb21e,
+	0xb220, 0xb23c, 0xb240, 0xb278, 0xb2f0, 0xb30c, 0xb33e, 0xb360, 0xb39c, 0xb3c2, 0xb3c4, 0xb3c8,
+	0xb3d0, 0xb3e6, 0xb410, 0xb41e, 0xb420, 0xb43c, 0xb440, 0xb478, 0xb4f0, 0xb5e0, 0xb618, 0xb660,
+	0xb67c, 0xb6c0, 0xb738, 0xb782, 0xb784, 0xb788, 0xb790, 0xb79e, 0xb7a0, 0xb7cc, 0xb82e, 0xb84e,
+	0xb85c, 0xb88e, 0xb89c, 0xb8b8, 0xb8c2, 0xb8c4, 0xb8c8, 0xb8d0, 0xb8e6, 0xb8fa, 0xb90e, 0xb91c,
+	0xb938, 0xb970, 0xb97e, 0xb982, 0xb984, 0xb988, 0xb990, 0xb99e, 0xb9a0, 0xb9cc, 0xb9f2, 0xb9f4,
+	0xba0e, 0xba1c, 0xba38, 0xba70, 0xba7e, 0xbae0, 0xbafc, 0xbb08, 0xbb10, 0xbb20, 0xbb3c, 0xbb40,
+	0xbb98, 0xbbce, 0xbbe2, 0xbbe4, 0xbbe8, 0xbc16, 0xbc26, 0xbc2c, 0xbc46, 0xbc4c, 0xbc58, 0xbc72,
+	0xbc74, 0xbc86, 0xbc8c, 0xbc98, 0xbcb0, 0xbcbe, 0xbcce, 0xbce2, 0xbce4, 0xbce8, 0xbd06, 0xbd0c,
+	0xbd18, 0xbd30, 0xbd3e, 0xbd60, 0xbd7c, 0xbd9c, 0xbdc2, 0xbdc4, 0xbdc8, 0xbdd0, 0xbde6, 0xbdfa,
+	0xbe12, 0xbe14, 0xbe22, 0xbe24, 0xbe28, 0xbe42, 0xbe44, 0xbe48, 0xbe50, 0xbe5e, 0xbe66, 0xbe82,
+	0xbe84, 0xbe88, 0xbe90, 0xbe9e, 0xbea0, 0xbebc, 0xbecc, 0xbef4, 0xbf1a, 0xbf2e, 0xbf32, 0xbf34,
+	0xbf4e, 0xbf5c, 0xbf62, 0xbf64, 0xbf68, 0xc09a, 0xc0b2, 0xc0b4, 0xc11a, 0xc132, 0xc134, 0xc162,
+	0xc164, 0xc168, 0xc176, 0xc1ba, 0xc21a, 0xc232, 0xc234, 0xc24e, 0xc25c, 0xc262, 0xc264, 0xc268,
+	0xc276, 0xc28e, 0xc2c2, 0xc2c4, 0xc2c8, 0xc2d0, 0xc2de, 0xc2e6, 0xc2ec, 0xc2fa, 0xc316, 0xc326,
+	0xc33a, 0xc346, 0xc34c, 0xc372, 0xc374, 0xc41a, 0xc42e, 0xc432, 0xc434, 0xc44e, 0xc45c, 0xc462,
+	0xc464, 0xc468, 0xc476, 0xc48e, 0xc49c, 0xc4b8, 0xc4c2, 0xc4c8, 0xc4d0, 0xc4de, 0xc4e6, 0xc4ec,
+	0xc4fa, 0xc51c, 0xc538, 0xc570, 0xc57e, 0xc582, 0xc584, 0xc588, 0xc590, 0xc59e, 0xc5a0, 0xc5bc,
+	0xc5c6, 0xc5cc, 0xc5d8, 0xc5ee, 0xc5f2, 0xc5f4, 0xc616, 0xc626, 0xc62c, 0xc63a, 0xc646, 0xc64c,
+	0xc658, 0xc66e, 0xc672, 0xc674, 0xc686, 0xc68c, 0xc698, 0xc6b0, 0xc6be, 0xc6ce, 0xc6dc, 0xc6e2,
+	0xc6e4, 0xc6e8, 0xc712, 0xc714, 0xc722, 0xc728, 0xc736, 0xc742, 0xc744, 0xc748, 0xc750, 0xc75e,
+	0xc766, 0xc76c, 0xc77a, 0xc7ae, 0xc7d6, 0xc7ea, 0xc81a, 0xc82e, 0xc832, 0xc834, 0xc84e, 0xc85c,
+	0xc862, 0xc864, 0xc868, 0xc876, 0xc88e, 0xc89c, 0xc8b8, 0xc8c2, 0xc8c8, 0xc8d0, 0xc8de, 0xc8e6,
+	0xc8ec, 0xc8fa, 0xc90e, 0xc938, 0xc970, 0xc97e, 0xc982, 0xc984, 0xc990, 0xc99e, 0xc9a0, 0xc9bc,
+	0xc9c6, 0xc9cc, 0xc9d8, 0xc9ee, 0xc9f2, 0xc9f4, 0xca38, 0xca70, 0xca7e, 0xcae0, 0xcafc, 0xcb02,
+	0xcb04, 0xcb08, 0xcb10, 0xcb20, 0xcb3c, 0xcb40, 0xcb78, 0xcb86, 0xcb8c, 0xcb98, 0xcbb0, 0xcbbe,
+	0xcbce, 0xcbdc, 0xcbe2, 0xcbe4, 0xcbe8, 0xcbf6, 0xcc16, 0xcc26, 0xcc2c, 0xcc3a, 0xcc46, 0xcc58,
+	0xcc72, 0xcc74, 0xcc86, 0xccb0, 0xccbe, 0xccce, 0xcce2, 0xcce4, 0xcce8, 0xcd06, 0xcd0c, 0xcd18,
+	0xcd30, 0xcd3e, 0xcd60, 0xcd7c, 0xcd9c, 0xcdc2, 0xcdc4, 0xcdc8, 0xcdd0, 0xcdde, 0xcde6, 0xcdfa,
+	0xce22, 0xce28, 0xce42, 0xce50, 0xce5e, 0xce66, 0xce7a, 0xce82, 0xce84, 0xce88, 0xce90, 0xce9e,
+	0xcea0, 0xcebc, 0xcecc, 0xcef2, 0xcef4, 0xcf2e, 0xcf32, 0xcf34, 0xcf4e, 0xcf5c, 0xcf62, 0xcf64,
+	0xcf68, 0xcf96, 0xcfa6, 0xcfac, 0xcfca, 0xcfd2, 0xcfd4, 0xd02e, 0xd032, 0xd034, 0xd04e, 0xd05c,
+	0xd062, 0xd064, 0xd068, 0xd076, 0xd08e, 0xd09c, 0xd0b8, 0xd0c2, 0xd0c4, 0xd0c8, 0xd0d0, 0xd0de,
+	0xd0e6, 0xd0ec, 0xd0fa, 0xd11c, 0xd138, 0xd170, 0xd17e, 0xd182, 0xd184, 0xd188, 0xd190, 0xd19e,
+	0xd1a0, 0xd1bc, 0xd1c6, 0xd1cc, 0xd1d8, 0xd1ee, 0xd1f2, 0xd1f4, 0xd21c, 0xd238, 0xd270, 0xd27e,
+	0xd2e0, 0xd2fc, 0xd302, 0xd304, 0xd308, 0xd310, 0xd31e, 0xd320, 0xd33c, 0xd340, 0xd378, 0xd386,
+	0xd38c, 0xd398, 0xd3b0, 0xd3be, 0xd3ce, 0xd3dc, 0xd3e2, 0xd3e4, 0xd3e8, 0xd3f6, 0xd470, 0xd47e,
+	0xd4e0, 0xd4fc, 0xd5c0, 0xd5f8, 0xd604, 0xd608, 0xd610, 0xd620, 0xd640, 0xd678, 0xd6f0, 0xd706,
+	0xd70c, 0xd718, 0xd730, 0xd73e, 0xd760, 0xd77c, 0xd78e, 0xd79c, 0xd7b8, 0xd7c2, 0xd7c4, 0xd7c8,
+	0xd7d0, 0xd7de, 0xd7e6, 0xd7ec, 0xd826, 0xd82c, 0xd83a, 0xd846, 0xd84c, 0xd858, 0xd872, 0xd874,
+	0xd886, 0xd88c, 0xd898, 0xd8b0, 0xd8be, 0xd8ce, 0xd8e2, 0xd8e4, 0xd8e8, 0xd8f6, 0xd90c, 0xd918,
+	0xd930, 0xd93e, 0xd960, 0xd97c, 0xd99c, 0xd9c2, 0xd9c4, 0xd9c8, 0xd9d0, 0xd9e6, 0xd9fa, 0xda0c,
+	0xda18, 0xda30, 0xda3e, 0xda60, 0xda7c, 0xdac0, 0xdaf8, 0xdb38, 0xdb82, 0xdb84, 0xdb88, 0xdb90,
+	0xdb9e, 0xdba0, 0xdbcc, 0xdbf2, 0xdbf4, 0xdc22, 0xdc42, 0xdc44, 0xdc48, 0xdc50, 0xdc5e, 0xdc66,
+	0xdc7a, 0xdc82, 0xdc84, 0xdc88, 0xdc90, 0xdc9e, 0xdca0, 0xdcbc, 0xdccc, 0xdcf2, 0xdcf4, 0xdd04,
+	0xdd08, 0xdd10, 0xdd1e, 0xdd20, 0xdd3c, 0xdd40, 0xdd78, 0xdd86, 0xdd98, 0xddce, 0xdde2, 0xdde4,
+	0xdde8, 0xde2e, 0xde32, 0xde34, 0xde4e, 0xde5c, 0xde62, 0xde64, 0xde68, 0xde8e, 0xde9c, 0xdeb8,
+	0xdec2, 0xdec4, 0xdec8, 0xded0, 0xdee6, 0xdefa, 0xdf16, 0xdf26, 0xdf2c, 0xdf46, 0xdf4c, 0xdf58,
+	0xdf72, 0xdf74, 0xdf8a, 0xdf92, 0xdf94, 0xdfa2, 0xdfa4, 0xdfa8, 0xe08a, 0xe092, 0xe094, 0xe0a2,
+	0xe0a4, 0xe0a8, 0xe0b6, 0xe0da, 0xe10a, 0xe112, 0xe114, 0xe122, 0xe124, 0xe128, 0xe136, 0xe142,
+	0xe144, 0xe148, 0xe150, 0xe166, 0xe16c, 0xe17a, 0xe19a, 0xe1b2, 0xe1b4, 0xe20a, 0xe212, 0xe214,
+	0xe222, 0xe224, 0xe228, 0xe236, 0xe242, 0xe248, 0xe250, 0xe25e, 0xe266, 0xe26c, 0xe27a, 0xe282,
+	0xe284, 0xe288, 0xe290, 0xe2a0, 0xe2bc, 0xe2c6, 0xe2cc, 0xe2d8, 0xe2ee, 0xe2f2, 0xe2f4, 0xe31a,
+	0xe332, 0xe334, 0xe35c, 0xe362, 0xe364, 0xe368, 0xe3ba, 0xe40a, 0xe412, 0xe414, 0xe422, 0xe428,
+	0xe436, 0xe442, 0xe448, 0xe450, 0xe45e, 0xe466, 0xe46c, 0xe47a, 0xe482, 0xe484, 0xe490, 0xe49e,
+	0xe4a0, 0xe4bc, 0xe4c6, 0xe4cc, 0xe4d8, 0xe4ee, 0xe4f2, 0xe4f4, 0xe502, 0xe504, 0xe508, 0xe510,
+	0xe51e, 0xe520, 0xe53c, 0xe540, 0xe578, 0xe586, 0xe58c, 0xe598, 0xe5b0, 0xe5be, 0xe5ce, 0xe5dc,
+	0xe5e2, 0xe5e4, 0xe5e8, 0xe5f6, 0xe61a, 0xe62e, 0xe632, 0xe634, 0xe64e, 0xe65c, 0xe662, 0xe668,
+	0xe68e, 0xe69c, 0xe6b8, 0xe6c2, 0xe6c4, 0xe6c8, 0xe6d0, 0xe6e6, 0xe6fa, 0xe716, 0xe726, 0xe72c,
+	0xe73a, 0xe746, 0xe74c, 0xe758, 0xe772, 0xe774, 0xe792, 0xe794, 0xe7a2, 0xe7a4, 0xe7a8, 0xe7b6,
+	0xe812, 0xe814, 0xe822, 0xe824, 0xe828, 0xe836, 0xe842, 0xe844, 0xe848, 0xe850, 0xe85e, 0xe866,
+	0xe86c, 0xe87a, 0xe882, 0xe884, 0xe888, 0xe890, 0xe89e, 0xe8a0, 0xe8bc, 0xe8c6, 0xe8cc, 0xe8d8,
+	0xe8ee, 0xe8f2, 0xe8f4, 0xe902, 0xe904, 0xe908, 0xe910, 0xe920, 0xe93c, 0xe940, 0xe978, 0xe986,
+	0xe98c, 0xe998, 0xe9b0, 0xe9be, 0xe9ce, 0xe9dc, 0xe9e2, 0xe9e4, 0xe9e8, 0xe9f6, 0xea04, 0xea08,
+	0xea10, 0xea20, 0xea40, 0xea78, 0xeaf0, 0xeb06, 0xeb0c, 0xeb18, 0xeb30, 0xeb3e, 0xeb60, 0xeb7c,
+	0xeb8e, 0xeb9c, 0xebb8, 0xebc2, 0xebc4, 0xebc8, 0xebd0, 0xebde, 0xebe6, 0xebec, 0xec1a, 0xec2e,
+	0xec32, 0xec34, 0xec4e, 0xec5c, 0xec62, 0xec64, 0xec68, 0xec8e, 0xec9c, 0xecb8, 0xecc2, 0xecc4,
+	0xecc8, 0xecd0, 0xece6, 0xecfa, 0xed0e, 0xed1c, 0xed38, 0xed70, 0xed7e, 0xed82, 0xed84, 0xed88,
+	0xed90, 0xed9e, 0xeda0, 0xedcc, 0xedf2, 0xedf4, 0xee16, 0xee26, 0xee2c, 0xee3a, 0xee46, 0xee4c,
+	0xee58, 0xee6e, 0xee72, 0xee74, 0xee86, 0xee8c, 0xee98, 0xeeb0, 0xeebe, 0xeece, 0xeedc, 0xeee2,
+	0xeee4, 0xeee8, 0xef12, 0xef22, 0xef24, 0xef28, 0xef36, 0xef42, 0xef44, 0xef48, 0xef50, 0xef5e,
+	0xef66, 0xef6c, 0xef7a, 0xefae, 0xefb2, 0xefb4, 0xefd6, 0xf096, 0xf0a6, 0xf0ac, 0xf0ba, 0xf0ca,
+	0xf0d2, 0xf0d4, 0xf116, 0xf126, 0xf12c, 0xf13a, 0xf146, 0xf14c, 0xf158, 0xf16e, 0xf172, 0xf174,
+	0xf18a, 0xf192, 0xf194, 0xf1a2, 0xf1a4, 0xf1a8, 0xf1da, 0xf216, 0xf226, 0xf22c, 0xf23a, 0xf246,
+	0xf258, 0xf26e, 0xf272, 0xf274, 0xf286, 0xf28c, 0xf298, 0xf2b0, 0xf2be, 0xf2ce, 0xf2dc, 0xf2e2,
+	0xf2e4, 0xf2e8, 0xf2f6, 0xf30a, 0xf312, 0xf314, 0xf322, 0xf328, 0xf342, 0xf344, 0xf348, 0xf350,
+	0xf35e, 0xf366, 0xf37a, 0xf39a, 0xf3ae, 0xf3b2, 0xf3b4, 0xf416, 0xf426, 0xf42c, 0xf43a, 0xf446,
+	0xf44c, 0xf458, 0xf46e, 0xf472, 0xf474, 0xf486, 0xf48c, 0xf498, 0xf4b0, 0xf4be, 0xf4ce, 0xf4dc,
+	0xf4e2, 0xf4e4, 0xf4e8, 0xf4f6, 0xf506, 0xf50c, 0xf518, 0xf530, 0xf53e, 0xf560, 0xf57c, 0xf58e,
+	0xf59c, 0xf5b8, 0xf5c2, 0xf5c4, 0xf5c8, 0xf5d0, 0xf5de, 0xf5e6, 0xf5ec, 0xf5fa, 0xf60a, 0xf612,
+	0xf614, 0xf622, 0xf624, 0xf628, 0xf636, 0xf642, 0xf644, 0xf648, 0xf650, 0xf65e, 0xf666, 0xf67a,
+	0xf682, 0xf684, 0xf688, 0xf690, 0xf69e, 0xf6a0, 0xf6bc, 0xf6cc, 0xf6f2, 0xf6f4, 0xf71a, 0xf72e,
+	0xf732, 0xf734, 0xf74e, 0xf75c, 0xf762, 0xf764, 0xf768, 0xf776, 0xf796, 0xf7a6, 0xf7ac, 0xf7ba,
+	0xf7d2, 0xf7d4, 0xf89a, 0xf8ae, 0xf8b2, 0xf8b4, 0xf8d6, 0xf8ea, 0xf91a, 0xf92e, 0xf932, 0xf934,
+	0xf94e, 0xf95c, 0xf962, 0xf964, 0xf968, 0xf976, 0xf996, 0xf9a6, 0xf9ac, 0xf9ba, 0xf9ca, 0xf9d2,
+	0xf9d4, 0xfa1a, 0xfa2e, 0xfa32, 0xfa34, 0xfa4e, 0xfa5c, 0xfa62, 0xfa64, 0xfa68, 0xfa76, 0xfa8e,
+	0xfa9c, 0xfab8, 0xfac2, 0xfac4, 0xfac8, 0xfad0, 0xfade, 0xfae6, 0xfaec, 0xfb16, 0xfb26, 0xfb2c,
+	0xfb3a, 0xfb46, 0xfb4c, 0xfb58, 0xfb6e, 0xfb72, 0xfb74, 0xfb8a, 0xfb92, 0xfb94, 0xfba2, 0xfba4,
+	0xfba8, 0xfbb6, 0xfbda
 };
 
 /**
@@ -406,33 +408,8 @@ static constexpr const std::array<uint16_t, 2787> CODEWORD_TABLE = {
 	2105, 1202, 1199, 1196, 1211, 2061, 2057, 1576, 1543, 1540, 1484, 1481, 1478, 1491, 1700
 };
 
-
-using RatioTableType = std::array<std::array<float, CodewordDecoder::BARS_IN_MODULE>, SYMBOL_COUNT>;
 using ModuleBitCountType = std::array<int, CodewordDecoder::BARS_IN_MODULE>;
 
-static const RatioTableType& GetRatioTable()
-{
-	static constexpr RatioTableType table = []() constexpr {
-		RatioTableType table{};
-		for (int i = 0; i < SYMBOL_COUNT; i++) {
-			int currentSymbol = SYMBOL_TABLE[i];
-			int currentBit = currentSymbol & 0x1;
-			for (int j = 0; j < CodewordDecoder::BARS_IN_MODULE; j++) {
-				float size = 0.0f;
-				while ((currentSymbol & 0x1) == currentBit) {
-					size += 1.0f;
-					currentSymbol >>= 1;
-				}
-				currentBit = currentSymbol & 0x1;
-				table[i][CodewordDecoder::BARS_IN_MODULE - j - 1] = size / CodewordDecoder::MODULES_IN_CODEWORD;
-			}
-		}
-		return table;
-	}();
-
-	return table;
-}
-
 static ModuleBitCountType SampleBitCounts(const ModuleBitCountType& moduleBitCount)
 {
 	float bitCountSum = static_cast<float>(Reduce(moduleBitCount));
@@ -454,7 +431,6 @@ static ModuleBitCountType SampleBitCounts(const ModuleBitCountType& moduleBitCou
 	return result;
 }
 
-
 static int GetBitValue(const ModuleBitCountType& moduleBitCount)
 {
 	int result = 0;
@@ -470,9 +446,35 @@ static int GetDecodedCodewordValue(const ModuleBitCountType& moduleBitCount)
 	return CodewordDecoder::GetCodeword(decodedValue) == -1 ? -1 : decodedValue;
 }
 
+static constexpr int getSymbol(int idx)
+{
+	return SYMBOL_TABLE[idx] | 0x10000;
+}
+
 static int GetClosestDecodedValue(const ModuleBitCountType& moduleBitCount)
 {
-	static const RatioTableType& ratioTable = GetRatioTable();
+#if 1 // put 87kB on heap and calucate per process on first use -> 7% smaller binary
+	static const auto ratioTable = []() {
+		auto table = std::vector<std::array<float, CodewordDecoder::BARS_IN_MODULE>>(SYMBOL_COUNT);
+#else // put 87kB in .rodata shared by all processes and calcuate during compilation
+	static constexpr const auto ratioTable = []() constexpr {
+		auto table = std::array<std::array<float, CodewordDecoder::BARS_IN_MODULE>, SYMBOL_COUNT>();
+#endif
+		for (int i = 0; i < SYMBOL_COUNT; i++) {
+			int currentSymbol = getSymbol(i);
+			int currentBit = currentSymbol & 0x1;
+			for (int j = 0; j < CodewordDecoder::BARS_IN_MODULE; j++) {
+				int8_t size = 0;
+				while ((currentSymbol & 0x1) == currentBit) {
+					size += 1;
+					currentSymbol >>= 1;
+				}
+				currentBit = currentSymbol & 0x1;
+				table[i][CodewordDecoder::BARS_IN_MODULE - j - 1] = size / 17.f; // MODULES_IN_CODEWORD
+			}
+		}
+		return table;
+	}();
 
 	int bitCountSum = Reduce(moduleBitCount);
 	std::array<float, CodewordDecoder::BARS_IN_MODULE> bitCountRatios = {};
@@ -495,7 +497,7 @@ static int GetClosestDecodedValue(const ModuleBitCountType& moduleBitCount)
 		}
 		if (error < bestMatchError) {
 			bestMatchError = error;
-			bestMatch = SYMBOL_TABLE[j];
+			bestMatch = getSymbol(j);
 		}
 	}
 	return bestMatch;
@@ -518,7 +520,9 @@ CodewordDecoder::GetDecodedValue(const std::array<int, BARS_IN_MODULE>& moduleBi
 int
 CodewordDecoder::GetCodeword(int symbol)
 {
-	symbol &= 0x3FFFF;
+	if ((symbol & 0xFFFF0000) != 0x10000)
+		return -1;
+	symbol &= 0xFFFF;
 	auto it = std::lower_bound(SYMBOL_TABLE.begin(), SYMBOL_TABLE.end(), symbol);
 	if (it != SYMBOL_TABLE.end() && *it == symbol) {
 		return (CODEWORD_TABLE[it - SYMBOL_TABLE.begin()] - 1) % NUMBER_OF_CODEWORDS;
diff --git a/core/src/pdf417/PDFDecoderResultExtra.h b/core/src/pdf417/PDFDecoderResultExtra.h
index 8aaf60a253..13108a37af 100644
--- a/core/src/pdf417/PDFDecoderResultExtra.h
+++ b/core/src/pdf417/PDFDecoderResultExtra.h
@@ -33,6 +33,8 @@ class DecoderResultExtra : public CustomData
 
 public:
 
+	int approxSymbolWidth = -1;
+
 	int segmentIndex() const {
 		return _segmentIndex;
 	}
diff --git a/core/src/pdf417/PDFDetector.cpp b/core/src/pdf417/PDFDetector.cpp
index e09edf479f..8926823db9 100644
--- a/core/src/pdf417/PDFDetector.cpp
+++ b/core/src/pdf417/PDFDetector.cpp
@@ -25,11 +25,6 @@ static const int INDEXES_STOP_PATTERN[] = { 6, 2, 7, 3 };
 static const float MAX_AVG_VARIANCE = 0.42f;
 static const float MAX_INDIVIDUAL_VARIANCE = 0.8f;
 
-// B S B S B S B S Bar/Space pattern
-// 11111111 0 1 0 1 0 1 000
-static const std::vector<int> START_PATTERN = { 8, 1, 1, 1, 1, 1, 1, 3 };
-// 1111111 0 1 000 1 0 1 00 1
-static const std::vector<int> STOP_PATTERN = { 7, 1, 1, 3, 1, 1, 1, 2, 1 };
 static const int MAX_PIXEL_DRIFT = 3;
 static const int MAX_PATTERN_DRIFT = 5;
 // if we set the value too low, then we don't detect the correct height of the bar if the start patterns are damaged.
@@ -226,6 +221,12 @@ CopyToResult(std::array<Nullable<ResultPoint>, 8>& result, const std::array<Null
 */
 static std::array<Nullable<ResultPoint>, 8> FindVertices(const BitMatrix& matrix, int startRow, int startColumn)
 {
+	// B S B S B S B S Bar/Space pattern
+	// 11111111 0 1 0 1 0 1 000
+	static const std::vector<int> START_PATTERN = { 8, 1, 1, 1, 1, 1, 1, 3 };
+	// 1111111 0 1 000 1 0 1 00 1
+	static const std::vector<int> STOP_PATTERN = { 7, 1, 1, 3, 1, 1, 1, 2, 1 };
+
 	int width = matrix.width();
 	int height = matrix.height();
 
diff --git a/core/src/pdf417/PDFModulusPoly.cpp b/core/src/pdf417/PDFModulusPoly.cpp
index 9883775f77..bcd2a6b894 100644
--- a/core/src/pdf417/PDFModulusPoly.cpp
+++ b/core/src/pdf417/PDFModulusPoly.cpp
@@ -42,21 +42,14 @@ ModulusPoly::ModulusPoly(const ModulusGF& field, const std::vector<int>& coeffic
 int
 ModulusPoly::evaluateAt(int a) const
 {
-	if (a == 0) {
-		// Just return the x^0 coefficient
+	if (a == 0) // return the x^0 coefficient
 		return coefficient(0);
-	}
-	size_t size = _coefficients.size();
-	if (a == 1) {
-		// Just the sum of the coefficients
-		const auto op = [this](auto result, const auto coefficient){ return _field->add(result, coefficient);};
-		return std::accumulate(std::begin(_coefficients), std::end(_coefficients), int{}, op);
-	}
-	int result = _coefficients[0];
-	for (size_t i = 1; i < size; i++) {
-		result = _field->add(_field->multiply(a, result), _coefficients[i]);
-	}
-	return result;
+
+	if (a == 1) // return the sum of the coefficients
+		return Reduce(_coefficients, 0, [this](auto res, auto coef) { return _field->add(res, coef); });
+
+	return std::accumulate(_coefficients.begin(), _coefficients.end(), 0,
+						   [this, a](auto res, auto coef) { return _field->add(_field->multiply(a, res), coef); });
 }
 
 ModulusPoly
diff --git a/core/src/pdf417/PDFReader.cpp b/core/src/pdf417/PDFReader.cpp
index 27d943c5e0..a624daf3a3 100644
--- a/core/src/pdf417/PDFReader.cpp
+++ b/core/src/pdf417/PDFReader.cpp
@@ -9,9 +9,11 @@
 #include "PDFDetector.h"
 #include "PDFScanningDecoder.h"
 #include "PDFCodewordDecoder.h"
+#include "PDFDecoderResultExtra.h"
 #include "ReaderOptions.h"
 #include "DecoderResult.h"
-#include "Result.h"
+#include "DetectorResult.h"
+#include "Barcode.h"
 
 #include "BitMatrixCursor.h"
 #include "BinaryBitmap.h"
@@ -26,7 +28,7 @@
 
 #ifdef PRINT_DEBUG
 #include "BitMatrixIO.h"
-#include <iostream>
+#include <cstdio>
 #endif
 
 namespace ZXing {
@@ -63,7 +65,7 @@ static int GetMaxCodewordWidth(const std::array<Nullable<ResultPoint>, 8>& p)
 					std::max(GetMaxWidth(p[1], p[5]), GetMaxWidth(p[7], p[3]) * CodewordDecoder::MODULES_IN_CODEWORD / MODULES_IN_STOP_PATTERN));
 }
 
-static Results DoDecode(const BinaryBitmap& image, bool multiple, bool tryRotate, bool returnErrors)
+static Barcodes DoDecode(const BinaryBitmap& image, bool multiple, bool tryRotate, bool returnErrors)
 {
 	Detector::Result detectorResult = Detector::Detect(image, multiple, tryRotate);
 	if (detectorResult.points.empty())
@@ -78,20 +80,30 @@ static Results DoDecode(const BinaryBitmap& image, bool multiple, bool tryRotate
 		return p;
 	};
 
-	Results results;
+	Barcodes res;
 	for (const auto& points : detectorResult.points) {
 		DecoderResult decoderResult =
 			ScanningDecoder::Decode(*detectorResult.bits, points[4], points[5], points[6], points[7],
 									GetMinCodewordWidth(points), GetMaxCodewordWidth(points));
 		if (decoderResult.isValid(returnErrors)) {
-			auto point = [&](int i) { return rotate(PointI(points[i].value())); };
-			Result result(std::move(decoderResult), {point(0), point(2), point(3), point(1)}, BarcodeFormat::PDF417);
-			results.push_back(result);
+			auto point = [&](int i) {
+				auto meta = dynamic_cast<DecoderResultExtra*>(decoderResult.extra().get());
+				if (points[i].hasValue() || i < 2 || !meta)
+					return rotate(PointI(points[i].value()));
+				else {
+					auto p = rotate(PointI(points[i - 2].value()) + PointI(meta->approxSymbolWidth, 0));
+					p.x = std::clamp(p.x, 0, image.width() - 1);
+					p.y = std::clamp(p.y, 0, image.height() - 1);
+					return p;
+				}
+			};
+			res.emplace_back(std::move(decoderResult), DetectorResult{{}, {point(0), point(2), point(3), point(1)}},
+							 BarcodeFormat::PDF417);
 			if (!multiple)
-				return results;
+				return res;
 		}
 	}
-	return results;
+	return res;
 }
 
 // new implementation (only for isPure use case atm.)
@@ -254,7 +266,7 @@ std::vector<int> ReadCodeWords(BitMatrixCursor<POINT> topCur, SymbolInfo info)
 	return codeWords;
 }
 
-static Result DecodePure(const BinaryBitmap& image_)
+static Barcode DecodePure(const BinaryBitmap& image_)
 {
 	auto pimage = image_.getBitMatrix();
 	if (!pimage)
@@ -292,10 +304,10 @@ static Result DecodePure(const BinaryBitmap& image_)
 
 	auto res = DecodeCodewords(codeWords, NumECCodeWords(info.ecLevel));
 
-	return Result(std::move(res), {{left, top}, {right, top}, {right, bottom}, {left, bottom}}, BarcodeFormat::PDF417);
+	return Barcode(std::move(res), {{}, {{left, top}, {right, top}, {right, bottom}, {left, bottom}}}, BarcodeFormat::PDF417);
 }
 
-Result
+Barcode
 Reader::decode(const BinaryBitmap& image) const
 {
 	if (_opts.isPure()) {
@@ -305,11 +317,11 @@ Reader::decode(const BinaryBitmap& image) const
 		// This falls through and tries the non-pure code path if we have a checksum error. This approach is
 		// currently the best option to deal with 'aliased' input like e.g. 03-aliased.png
 	}
-	
+
 	return FirstOrDefault(DoDecode(image, false, _opts.tryRotate(), _opts.returnErrors()));
 }
 
-Results Reader::decode(const BinaryBitmap& image, [[maybe_unused]] int maxSymbols) const
+Barcodes Reader::decode(const BinaryBitmap& image, [[maybe_unused]] int maxSymbols) const
 {
 	return DoDecode(image, true, _opts.tryRotate(), _opts.returnErrors());
 }
diff --git a/core/src/pdf417/PDFReader.h b/core/src/pdf417/PDFReader.h
index 2a05012350..8bdabff347 100644
--- a/core/src/pdf417/PDFReader.h
+++ b/core/src/pdf417/PDFReader.h
@@ -22,8 +22,8 @@ class Reader : public ZXing::Reader
 public:
 	using ZXing::Reader::Reader;
 
-	Result decode(const BinaryBitmap& image) const override;
-	Results decode(const BinaryBitmap& image, int maxSymbols) const override;
+	Barcode decode(const BinaryBitmap& image) const override;
+	Barcodes decode(const BinaryBitmap& image, int maxSymbols) const override;
 };
 
 } // namespace ZXing::Pdf417
diff --git a/core/src/pdf417/PDFScanningDecoder.cpp b/core/src/pdf417/PDFScanningDecoder.cpp
index bd5eac8d9c..2fd4f1fcfe 100644
--- a/core/src/pdf417/PDFScanningDecoder.cpp
+++ b/core/src/pdf417/PDFScanningDecoder.cpp
@@ -13,6 +13,7 @@
 #include "PDFCodewordDecoder.h"
 #include "PDFDetectionResult.h"
 #include "PDFDecoder.h"
+#include "PDFDecoderResultExtra.h"
 #include "PDFModulusGF.h"
 #include "ZXAlgorithms.h"
 #include "ZXTestSupport.h"
@@ -127,7 +128,7 @@ static Nullable<Codeword> DetectCodeword(const BitMatrix& image, int minColumn,
 	}
 	// TODO implement check for width and correction of black and white bars
 	// use start (and maybe stop pattern) to determine if blackbars are wider than white bars. If so, adjust.
-	// should probably done only for codewords with a lot more than 17 bits. 
+	// should probably done only for codewords with a lot more than 17 bits.
 	// The following fixes 10-1.png, which has wide black bars and small white bars
 	//    for (int i = 0; i < moduleBitCount.length; i++) {
 	//      if (i % 2 == 0) {
@@ -674,7 +675,7 @@ static DecoderResult CreateDecoderResult(DetectionResult& detectionResult)
 
 // TODO don't pass in minCodewordWidth and maxCodewordWidth, pass in barcode columns for start and stop pattern
 // columns. That way width can be deducted from the pattern column.
-// This approach also allows detecting more details about the barcode, e.g. if a bar type (white or black) is wider 
+// This approach also allows detecting more details about the barcode, e.g. if a bar type (white or black) is wider
 // than it should be. This can happen if the scanner used a bad blackpoint.
 DecoderResult
 ScanningDecoder::Decode(const BitMatrix& image, const Nullable<ResultPoint>& imageTopLeft, const Nullable<ResultPoint>& imageBottomLeft,
@@ -685,7 +686,7 @@ ScanningDecoder::Decode(const BitMatrix& image, const Nullable<ResultPoint>& ima
 	if (!BoundingBox::Create(image.width(), image.height(), imageTopLeft, imageBottomLeft, imageTopRight, imageBottomRight, boundingBox)) {
 		return {};
 	}
-	
+
 	Nullable<DetectionResultColumn> leftRowIndicatorColumn, rightRowIndicatorColumn;
 	DetectionResult detectionResult;
 	for (int i = 0; i < 2; i++) {
@@ -739,7 +740,11 @@ ScanningDecoder::Decode(const BitMatrix& image, const Nullable<ResultPoint>& ima
 			}
 		}
 	}
-	return CreateDecoderResult(detectionResult);
+	auto res = CreateDecoderResult(detectionResult);
+	auto meta = dynamic_cast<DecoderResultExtra*>(res.extra().get());
+	if (meta)
+		meta->approxSymbolWidth = (detectionResult.barcodeColumnCount() + 2) * (minCodewordWidth + maxCodewordWidth) / 2;
+	return res;
 }
 
 } // Pdf417
diff --git a/core/src/ZXBigInteger.cpp b/core/src/pdf417/ZXBigInteger.cpp
similarity index 100%
rename from core/src/ZXBigInteger.cpp
rename to core/src/pdf417/ZXBigInteger.cpp
diff --git a/core/src/ZXBigInteger.h b/core/src/pdf417/ZXBigInteger.h
similarity index 100%
rename from core/src/ZXBigInteger.h
rename to core/src/pdf417/ZXBigInteger.h
diff --git a/core/src/ZXNullable.h b/core/src/pdf417/ZXNullable.h
similarity index 99%
rename from core/src/ZXNullable.h
rename to core/src/pdf417/ZXNullable.h
index 8d3a69ffa7..694087eb3d 100644
--- a/core/src/ZXNullable.h
+++ b/core/src/pdf417/ZXNullable.h
@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include <cstddef>
 #include <stdexcept>
 #include <utility>
 
diff --git a/core/src/qrcode/QRBitMatrixParser.cpp b/core/src/qrcode/QRBitMatrixParser.cpp
index 1aea0d9dfa..3cf4ee11dd 100644
--- a/core/src/qrcode/QRBitMatrixParser.cpp
+++ b/core/src/qrcode/QRBitMatrixParser.cpp
@@ -33,25 +33,7 @@ const Version* ReadVersion(const BitMatrix& bitMatrix, Type type)
 	case Type::Micro: return Version::Micro(number);
 	case Type::rMQR: return Version::rMQR(number);
 	case Type::Model1: return Version::Model1(number);
-	case Type::Model2: break;
-	}
-
-	const Version* version = Version::Model2(number);
-	if (!version || version->versionNumber() < 7)
-		return version;
-
-	int dimension = bitMatrix.height();
-
-	for (bool mirror : {false, true}) {
-		// Read top-right/bottom-left version info: 3 wide by 6 tall (depending on mirrored)
-		int versionBits = 0;
-		for (int y = 5; y >= 0; --y)
-			for (int x = dimension - 9; x >= dimension - 11; --x)
-				AppendBit(versionBits, getBit(bitMatrix, x, y, mirror));
-
-		version = Version::DecodeVersionInformation(versionBits);
-		if (version && version->dimension() == dimension)
-			return version;
+	case Type::Model2: return Version::Model2(number);
 	}
 
 	return nullptr;
diff --git a/core/src/qrcode/QRCodecMode.cpp b/core/src/qrcode/QRCodecMode.cpp
index 5020118a87..b0e546a013 100644
--- a/core/src/qrcode/QRCodecMode.cpp
+++ b/core/src/qrcode/QRCodecMode.cpp
@@ -12,7 +12,6 @@
 #include "ZXAlgorithms.h"
 
 #include <array>
-#include <stdexcept>
 
 namespace ZXing::QRCode {
 
diff --git a/core/src/qrcode/QRDecoder.cpp b/core/src/qrcode/QRDecoder.cpp
index 44ce4d41b5..6ec7d87ed4 100644
--- a/core/src/qrcode/QRDecoder.cpp
+++ b/core/src/qrcode/QRDecoder.cpp
@@ -306,7 +306,7 @@ DecoderResult DecodeBitStream(ByteArray&& bytes, const Version& version, ErrorCo
 			}
 			}
 		}
-	} catch (std::out_of_range& e) { // see BitSource::readBits
+	} catch (std::out_of_range&) { // see BitSource::readBits
 		error = FormatError("Truncated bit stream");
 	} catch (Error e) {
 		error = std::move(e);
@@ -346,24 +346,30 @@ DecoderResult Decode(const BitMatrix& bits)
 
 	// Count total number of data bytes
 	const auto op = [](auto totalBytes, const auto& dataBlock){ return totalBytes + dataBlock.numDataCodewords();};
-	const auto totalBytes = std::accumulate(std::begin(dataBlocks), std::end(dataBlocks), int{}, op);
+	const auto totalBytes = Reduce(dataBlocks, int{}, op);
 	ByteArray resultBytes(totalBytes);
 	auto resultIterator = resultBytes.begin();
 
 	// Error-correct and copy data blocks together into a stream of bytes
+	Error error;
 	for (auto& dataBlock : dataBlocks)
 	{
 		ByteArray& codewordBytes = dataBlock.codewords();
 		int numDataCodewords = dataBlock.numDataCodewords();
 
 		if (!CorrectErrors(codewordBytes, numDataCodewords))
-			return ChecksumError();
+			error = ChecksumError();
 
 		resultIterator = std::copy_n(codewordBytes.begin(), numDataCodewords, resultIterator);
 	}
 
 	// Decode the contents of that stream of bytes
-	return DecodeBitStream(std::move(resultBytes), version, formatInfo.ecLevel).setIsMirrored(formatInfo.isMirrored);
+	auto ret = DecodeBitStream(std::move(resultBytes), version, formatInfo.ecLevel)
+		.setDataMask(formatInfo.mask)
+		.setIsMirrored(formatInfo.isMirrored);
+	if (error)
+		ret.setError(error);
+	return ret;
 }
 
 } // namespace ZXing::QRCode
diff --git a/core/src/qrcode/QRDetector.cpp b/core/src/qrcode/QRDetector.cpp
index 7912962dee..37476843bc 100644
--- a/core/src/qrcode/QRDetector.cpp
+++ b/core/src/qrcode/QRDetector.cpp
@@ -44,7 +44,7 @@ PatternView FindPattern(const PatternView& view)
 	return FindLeftGuard<PATTERN.size()>(view, PATTERN.size(), [](const PatternView& view, int spaceInPixel) {
 		// perform a fast plausability test for 1:1:3:1:1 pattern
 		if (view[2] < 2 * std::max(view[0], view[4]) || view[2] < std::max(view[1], view[3]))
-			return 0.f;
+			return 0.;
 		return IsPattern<E2E>(view, PATTERN, spaceInPixel, 0.1); // the requires 4, here we accept almost 0
 	});
 }
@@ -79,7 +79,7 @@ std::vector<ConcentricPattern> FindFinderPatterns(const BitMatrix& image, bool t
 				log(p);
 				N++;
 				auto pattern = LocateConcentricPattern<E2E>(image, PATTERN, p,
-															Reduce(next) * 3); // 3 for very skewed samples
+															next.sum() * 3); // 3 for very skewed samples
 				if (pattern) {
 					log(*pattern, 3);
 					log(*pattern + PointF(.2, 0), 3);
@@ -683,6 +683,7 @@ DetectorResult SampleMQR(const BitMatrix& image, const ConcentricPattern& fp)
 
 	FormatInformation bestFI;
 	PerspectiveTransform bestPT;
+	BitMatrixCursorF cur(image, {}, {});
 
 	for (int i = 0; i < 4; ++i) {
 		auto mod2Pix = PerspectiveTransform(srcQuad, RotatedCorners(*fpQuad, i));
@@ -698,7 +699,7 @@ DetectorResult SampleMQR(const BitMatrix& image, const ConcentricPattern& fp)
 
 		int formatInfoBits = 0;
 		for (int i = 1; i <= 15; ++i)
-			AppendBit(formatInfoBits, image.get(mod2Pix(centered(FORMAT_INFO_COORDS[i]))));
+			AppendBit(formatInfoBits, cur.blackAt(mod2Pix(centered(FORMAT_INFO_COORDS[i]))));
 
 		auto fi = FormatInformation::DecodeMQR(formatInfoBits);
 		if (fi.hammingDistance < bestFI.hammingDistance) {
@@ -718,7 +719,7 @@ DetectorResult SampleMQR(const BitMatrix& image, const ConcentricPattern& fp)
 	for (int i = 0; i < dim; ++i) {
 		auto px = bestPT(centered(PointI{i, dim}));
 		auto py = bestPT(centered(PointI{dim, i}));
-		blackPixels += (image.isIn(px) && image.get(px)) + (image.isIn(py) && image.get(py));
+		blackPixels += cur.blackAt(px) && cur.blackAt(py);
 	}
 	if (blackPixels > 2 * dim / 3)
 		return {};
@@ -744,13 +745,13 @@ DetectorResult SampleRMQR(const BitMatrix& image, const ConcentricPattern& fp)
 
 	FormatInformation bestFI;
 	PerspectiveTransform bestPT;
+	BitMatrixCursorF cur(image, {}, {});
 
 	for (int i = 0; i < 4; ++i) {
 		auto mod2Pix = PerspectiveTransform(srcQuad, RotatedCorners(*fpQuad, i));
 
 		auto check = [&](int i, bool on) {
-			auto p = mod2Pix(centered(FORMAT_INFO_EDGE_COORDS[i]));
-			return image.isIn(p) && image.get(p) == on;
+			return cur.testAt(mod2Pix(centered(FORMAT_INFO_EDGE_COORDS[i]))) == BitMatrixCursorF::Value(on);
 		};
 
 		// check that we see top edge timing pattern modules
@@ -759,7 +760,7 @@ DetectorResult SampleRMQR(const BitMatrix& image, const ConcentricPattern& fp)
 
 		uint32_t formatInfoBits = 0;
 		for (int i = 0; i < Size(FORMAT_INFO_COORDS); ++i)
-			AppendBit(formatInfoBits, image.get(mod2Pix(centered(FORMAT_INFO_COORDS[i]))));
+			AppendBit(formatInfoBits, cur.blackAt(mod2Pix(centered(FORMAT_INFO_COORDS[i]))));
 
 		auto fi = FormatInformation::DecodeRMQR(formatInfoBits, 0 /*formatInfoBits2*/);
 		if (fi.hammingDistance < bestFI.hammingDistance) {
@@ -779,9 +780,9 @@ DetectorResult SampleRMQR(const BitMatrix& image, const ConcentricPattern& fp)
 		auto br = Center(b);
 		// rotate points such that topLeft of a is furthest away from b and topLeft of b is closest to a
 		auto dist2B = [c = br](auto a, auto b) { return distance(a, c) < distance(b, c); };
-		auto offsetA = std::max_element(a.begin(), a.end(), dist2B) - a.begin();
+		auto offsetA = narrow_cast<int>(std::max_element(a.begin(), a.end(), dist2B) - a.begin());
 		auto dist2A = [c = tl](auto a, auto b) { return distance(a, c) < distance(b, c); };
-		auto offsetB = std::min_element(b.begin(), b.end(), dist2A) - b.begin();
+		auto offsetB = narrow_cast<int>(std::min_element(b.begin(), b.end(), dist2A) - b.begin());
 
 		a = RotatedCorners(a, offsetA);
 		b = RotatedCorners(b, offsetB);
diff --git a/core/src/qrcode/QRFormatInformation.cpp b/core/src/qrcode/QRFormatInformation.cpp
index 85c88d766b..9eec6b81de 100644
--- a/core/src/qrcode/QRFormatInformation.cpp
+++ b/core/src/qrcode/QRFormatInformation.cpp
@@ -11,8 +11,6 @@
 #include "BitHacks.h"
 #include "ZXAlgorithms.h"
 
-#include <array>
-
 namespace ZXing::QRCode {
 
 static uint32_t MirrorBits(uint32_t bits)
diff --git a/core/src/qrcode/QRReader.cpp b/core/src/qrcode/QRReader.cpp
index e3bbda0307..6a4410efb0 100644
--- a/core/src/qrcode/QRReader.cpp
+++ b/core/src/qrcode/QRReader.cpp
@@ -15,13 +15,13 @@
 #include "LogMatrix.h"
 #include "QRDecoder.h"
 #include "QRDetector.h"
-#include "Result.h"
+#include "Barcode.h"
 
 #include <utility>
 
 namespace ZXing::QRCode {
 
-Result Reader::decode(const BinaryBitmap& image) const
+Barcode Reader::decode(const BinaryBitmap& image) const
 {
 #if 1
 	if (!_opts.isPure())
@@ -44,11 +44,11 @@ Result Reader::decode(const BinaryBitmap& image) const
 		return {};
 
 	auto decoderResult = Decode(detectorResult.bits());
-	auto position = detectorResult.position();
+	auto format = detectorResult.bits().width() != detectorResult.bits().height() ? BarcodeFormat::RMQRCode
+				  : detectorResult.bits().width() < 21                            ? BarcodeFormat::MicroQRCode
+																				  : BarcodeFormat::QRCode;
 
-	return Result(std::move(decoderResult), std::move(position),
-				  detectorResult.bits().width() != detectorResult.bits().height() ? BarcodeFormat::RMQRCode :
-				  detectorResult.bits().width() < 21 ? BarcodeFormat::MicroQRCode : BarcodeFormat::QRCode);
+	return Barcode(std::move(decoderResult), std::move(detectorResult), format);
 }
 
 void logFPSet(const FinderPatternSet& fps [[maybe_unused]])
@@ -67,7 +67,7 @@ void logFPSet(const FinderPatternSet& fps [[maybe_unused]])
 #endif
 }
 
-Results Reader::decode(const BinaryBitmap& image, int maxSymbols) const
+Barcodes Reader::decode(const BinaryBitmap& image, int maxSymbols) const
 {
 	auto binImg = image.getBitMatrix();
 	if (binImg == nullptr)
@@ -84,7 +84,7 @@ Results Reader::decode(const BinaryBitmap& image, int maxSymbols) const
 #endif
 
 	std::vector<ConcentricPattern> usedFPs;
-	Results results;
+	Barcodes res;
 	
 	if (_opts.hasFormat(BarcodeFormat::QRCode)) {
 		auto allFPSets = GenerateFinderPatternSets(allFPs);
@@ -97,22 +97,21 @@ Results Reader::decode(const BinaryBitmap& image, int maxSymbols) const
 			auto detectorResult = SampleQR(*binImg, fpSet);
 			if (detectorResult.isValid()) {
 				auto decoderResult = Decode(detectorResult.bits());
-				auto position = detectorResult.position();
 				if (decoderResult.isValid()) {
 					usedFPs.push_back(fpSet.bl);
 					usedFPs.push_back(fpSet.tl);
 					usedFPs.push_back(fpSet.tr);
 				}
 				if (decoderResult.isValid(_opts.returnErrors())) {
-					results.emplace_back(std::move(decoderResult), std::move(position), BarcodeFormat::QRCode);
-					if (maxSymbols && Size(results) == maxSymbols)
+					res.emplace_back(std::move(decoderResult), std::move(detectorResult), BarcodeFormat::QRCode);
+					if (maxSymbols && Size(res) == maxSymbols)
 						break;
 				}
 			}
 		}
 	}
 	
-	if (_opts.hasFormat(BarcodeFormat::MicroQRCode) && !(maxSymbols && Size(results) == maxSymbols)) {
+	if (_opts.hasFormat(BarcodeFormat::MicroQRCode) && !(maxSymbols && Size(res) == maxSymbols)) {
 		for (const auto& fp : allFPs) {
 			if (Contains(usedFPs, fp))
 				continue;
@@ -120,10 +119,9 @@ Results Reader::decode(const BinaryBitmap& image, int maxSymbols) const
 			auto detectorResult = SampleMQR(*binImg, fp);
 			if (detectorResult.isValid()) {
 				auto decoderResult = Decode(detectorResult.bits());
-				auto position = detectorResult.position();
 				if (decoderResult.isValid(_opts.returnErrors())) {
-					results.emplace_back(std::move(decoderResult), std::move(position), BarcodeFormat::MicroQRCode);
-					if (maxSymbols && Size(results) == maxSymbols)
+					res.emplace_back(std::move(decoderResult), std::move(detectorResult), BarcodeFormat::MicroQRCode);
+					if (maxSymbols && Size(res) == maxSymbols)
 						break;
 				}
 
@@ -131,7 +129,7 @@ Results Reader::decode(const BinaryBitmap& image, int maxSymbols) const
 		}
 	}
 	
-	if (_opts.hasFormat(BarcodeFormat::RMQRCode) && !(maxSymbols && Size(results) == maxSymbols)) {
+	if (_opts.hasFormat(BarcodeFormat::RMQRCode) && !(maxSymbols && Size(res) == maxSymbols)) {
 		// TODO proper
 		for (const auto& fp : allFPs) {
 			if (Contains(usedFPs, fp))
@@ -140,10 +138,9 @@ Results Reader::decode(const BinaryBitmap& image, int maxSymbols) const
 			auto detectorResult = SampleRMQR(*binImg, fp);
 			if (detectorResult.isValid()) {
 				auto decoderResult = Decode(detectorResult.bits());
-				auto position = detectorResult.position();
 				if (decoderResult.isValid(_opts.returnErrors())) {
-					results.emplace_back(std::move(decoderResult), std::move(position), BarcodeFormat::RMQRCode);
-					if (maxSymbols && Size(results) == maxSymbols)
+					res.emplace_back(std::move(decoderResult), std::move(detectorResult), BarcodeFormat::RMQRCode);
+					if (maxSymbols && Size(res) == maxSymbols)
 						break;
 				}
 
@@ -151,7 +148,7 @@ Results Reader::decode(const BinaryBitmap& image, int maxSymbols) const
 		}
 	}
 
-	return results;
+	return res;
 }
 
 } // namespace ZXing::QRCode
diff --git a/core/src/qrcode/QRReader.h b/core/src/qrcode/QRReader.h
index 22d514e254..6c85d882b9 100644
--- a/core/src/qrcode/QRReader.h
+++ b/core/src/qrcode/QRReader.h
@@ -15,8 +15,8 @@ class Reader : public ZXing::Reader
 public:
 	using ZXing::Reader::Reader;
 
-	Result decode(const BinaryBitmap& image) const override;
-	Results decode(const BinaryBitmap& image, int maxSymbols) const override;
+	Barcode decode(const BinaryBitmap& image) const override;
+	Barcodes decode(const BinaryBitmap& image, int maxSymbols) const override;
 };
 
 } // namespace ZXing::QRCode
diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt
index 9a492ca5eb..8f34e72019 100644
--- a/example/CMakeLists.txt
+++ b/example/CMakeLists.txt
@@ -2,7 +2,7 @@ zxing_add_package_stb()
 
 include (GNUInstallDirs)
 
-if (BUILD_WRITERS)
+if (ZXING_WRITERS)
     add_executable (ZXingWriter ZXingWriter.cpp)
 
     target_link_libraries (ZXingWriter ZXing::ZXing stb::stb)
@@ -12,7 +12,7 @@ if (BUILD_WRITERS)
     install(TARGETS ZXingWriter DESTINATION ${CMAKE_INSTALL_BINDIR})
 endif()
 
-if (BUILD_READERS)
+if (ZXING_READERS)
     add_executable (ZXingReader ZXingReader.cpp)
 
     target_link_libraries (ZXingReader ZXing::ZXing stb::stb)
@@ -30,7 +30,7 @@ endif()
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTORCC ON)
 
-if (BUILD_READERS)
+if (ZXING_READERS)
     if (TARGET Qt::Gui)
         add_executable (ZXingQtReader ZXingQtReader.cpp ZXingQtReader.h)
         target_link_libraries(ZXingQtReader ZXing::ZXing Qt::Gui)
@@ -51,7 +51,7 @@ if (BUILD_READERS)
     endif()
 endif()
 
-if (BUILD_WRITERS)
+if (ZXING_WRITERS)
     if (TARGET Qt::Gui)
         add_executable (ZXingQtWriter ZXingQtWriter.cpp)
         target_link_libraries(ZXingQtWriter ZXing::ZXing Qt::Gui)
diff --git a/example/ZXingOpenCV.cpp b/example/ZXingOpenCV.cpp
index 21411cf779..00a96124e1 100644
--- a/example/ZXingOpenCV.cpp
+++ b/example/ZXingOpenCV.cpp
@@ -21,9 +21,9 @@ int main()
 	else
 		while (waitKey(25) != 27) {
 			cap >> image;
-			auto results = ReadBarcodes(image);
-			for (auto& r : results)
-				DrawResult(image, r);
+			auto barcodes = ReadBarcodes(image);
+			for (auto& barcode : barcodes)
+				DrawBarcode(image, barcode);
 			imshow("Display window", image);
 		}
 
diff --git a/example/ZXingOpenCV.h b/example/ZXingOpenCV.h
index bd125c2aa2..626ab0c022 100644
--- a/example/ZXingOpenCV.h
+++ b/example/ZXingOpenCV.h
@@ -16,8 +16,9 @@ inline ZXing::ImageView ImageViewFromMat(const cv::Mat& image)
 	auto fmt = ImageFormat::None;
 	switch (image.channels()) {
 	case 1: fmt = ImageFormat::Lum; break;
+	case 2: fmt = ImageFormat::LumA; break;
 	case 3: fmt = ImageFormat::BGR; break;
-	case 4: fmt = ImageFormat::BGRX; break;
+	case 4: fmt = ImageFormat::BGRA; break;
 	}
 
 	if (image.depth() != CV_8U || fmt == ImageFormat::None)
@@ -26,19 +27,19 @@ inline ZXing::ImageView ImageViewFromMat(const cv::Mat& image)
 	return {image.data, image.cols, image.rows, fmt};
 }
 
-inline ZXing::Results ReadBarcodes(const cv::Mat& image, const ZXing::ReaderOptions& options = {})
+inline ZXing::Barcodes ReadBarcodes(const cv::Mat& image, const ZXing::ReaderOptions& options = {})
 {
 	return ZXing::ReadBarcodes(ImageViewFromMat(image), options);
 }
 
-inline void DrawResult(cv::Mat& img, ZXing::Result res)
+inline void DrawBarcode(cv::Mat& img, ZXing::Barcode barcode)
 {
-	auto pos = res.position();
+	auto pos = barcode.position();
 	auto zx2cv = [](ZXing::PointI p) { return cv::Point(p.x, p.y); };
 	auto contour = std::vector<cv::Point>{zx2cv(pos[0]), zx2cv(pos[1]), zx2cv(pos[2]), zx2cv(pos[3])};
 	const auto* pts = contour.data();
 	int npts = contour.size();
 
 	cv::polylines(img, &pts, &npts, 1, true, CV_RGB(0, 255, 0));
-	cv::putText(img, res.text(), zx2cv(pos[3]) + cv::Point(0, 20), cv::FONT_HERSHEY_DUPLEX, 0.5, CV_RGB(0, 255, 0));
+	cv::putText(img, barcode.text(), zx2cv(pos[3]) + cv::Point(0, 20), cv::FONT_HERSHEY_DUPLEX, 0.5, CV_RGB(0, 255, 0));
 }
diff --git a/example/ZXingQt5CamReader.qml b/example/ZXingQt5CamReader.qml
index 467bb18a63..0704c7b3a7 100644
--- a/example/ZXingQt5CamReader.qml
+++ b/example/ZXingQt5CamReader.qml
@@ -12,136 +12,138 @@ import QtMultimedia 5.12
 import ZXing 1.0
 
 Window {
-    visible: true
-    width: 640
-    height: 480
-    title: Qt.application.name
-
-    property var nullPoints: [Qt.point(0,0), Qt.point(0,0), Qt.point(0,0), Qt.point(0,0)]
-    property var points: nullPoints
-
-    Timer {
-        id: resetInfo
-        interval: 2000
-    }
-
-    BarcodeReader {
-        id: barcodeReader
-
-        formats: (linearSwitch.checked ? (ZXing.LinearCodes) : ZXing.None) | (matrixSwitch.checked ? (ZXing.MatrixCodes) : ZXing.None)
-        tryRotate: tryRotateSwitch.checked
-        tryHarder: tryHarderSwitch.checked
-        tryDownscale: tryDownscaleSwitch.checked
-
-        // callback with parameter 'result', called for every successfully processed frame
-        // onFoundBarcode: {}
-
-        // callback with parameter 'result', called for every processed frame
-        onNewResult: {
-            points = result.isValid
-                    ? [result.position.topLeft, result.position.topRight, result.position.bottomRight, result.position.bottomLeft]
-                    : nullPoints
-
-            if (result.isValid)
-                resetInfo.restart()
-
-            if (result.isValid || !resetInfo.running)
-                info.text = qsTr("Format: \t %1 \nText: \t %2 \nError: \t %3 \nTime: \t %4 ms").arg(result.formatName).arg(result.text).arg(result.status).arg(result.runTime)
-
-//            console.log(result)
-        }
-    }
-
-    Camera {
-        id: camera
-
-        captureMode: Camera.CaptureViewfinder
-        deviceId: QtMultimedia.availableCameras[camerasComboBox.currentIndex] ? QtMultimedia.availableCameras[camerasComboBox.currentIndex].deviceId : ""
-
-        onDeviceIdChanged: {
-            focus.focusMode = CameraFocus.FocusContinuous
-            focus.focusPointMode = CameraFocus.FocusPointAuto
-        }
-
-        onError: console.log("camera error:" + errorString)
-    }
-
-    ColumnLayout {
-        anchors.fill: parent
-
-        RowLayout {
-            Layout.fillWidth: true
-            Layout.fillHeight: false
-            visible: QtMultimedia.availableCameras.length > 1
-            Label {
-                text: qsTr("Camera: ")
-                Layout.fillWidth: false
-            }
-            ComboBox {
-                id: camerasComboBox
-                Layout.fillWidth: true
-                model: QtMultimedia.availableCameras
-                textRole: "displayName"
-                currentIndex: 0
-            }
-        }
-
-        VideoOutput {
-            id: videoOutput
-            Layout.fillHeight: true
-            Layout.fillWidth: true
-            filters: [barcodeReader]
-            source: camera
-            autoOrientation: true
-
-            Shape {
-                id: polygon
-                anchors.fill: parent
-                visible: points.length == 4
-                ShapePath {
-                    strokeWidth: 3
-                    strokeColor: "red"
-                    strokeStyle: ShapePath.SolidLine
-                    fillColor: "transparent"
-                    //TODO: really? I don't know qml...
-                    startX: videoOutput.mapPointToItem(points[3]).x
-                    startY: videoOutput.mapPointToItem(points[3]).y
-                    PathLine {
-                        x: videoOutput.mapPointToItem(points[0]).x
-                        y: videoOutput.mapPointToItem(points[0]).y
-                    }
-                    PathLine {
-                        x: videoOutput.mapPointToItem(points[1]).x
-                        y: videoOutput.mapPointToItem(points[1]).y
-                    }
-                    PathLine {
-                        x: videoOutput.mapPointToItem(points[2]).x
-                        y: videoOutput.mapPointToItem(points[2]).y
-                    }
-                    PathLine {
-                        x: videoOutput.mapPointToItem(points[3]).x
-                        y: videoOutput.mapPointToItem(points[3]).y
-                    }
-                }
-            }
-
-            Label {
-                id: info
-                color: "white"
-                padding: 10
-                background: Rectangle { color: "#80808080" }
-            }
-
-            ColumnLayout {
-                anchors.right: parent.right
-                anchors.bottom: parent.bottom
-
-                Switch {id: tryRotateSwitch; text: qsTr("Try Rotate"); checked: true }
-                Switch {id: tryHarderSwitch; text: qsTr("Try Harder"); checked: true }
-                Switch {id: tryDownscaleSwitch; text: qsTr("Try Downscale"); checked: true }
-                Switch {id: linearSwitch; text: qsTr("Linear Codes"); checked: true }
-                Switch {id: matrixSwitch; text: qsTr("Matrix Codes"); checked: true }
-            }
-        }
-    }
+	visible: true
+	width: 640
+	height: 480
+	title: Qt.application.name
+
+	property var nullPoints: [Qt.point(0,0), Qt.point(0,0), Qt.point(0,0), Qt.point(0,0)]
+	property var points: nullPoints
+
+	Timer {
+		id: resetInfo
+		interval: 1000
+	}
+
+	BarcodeReader {
+		id: barcodeReader
+
+		formats: (linearSwitch.checked ? (ZXing.LinearCodes) : ZXing.None) | (matrixSwitch.checked ? (ZXing.MatrixCodes) : ZXing.None)
+		tryRotate: tryRotateSwitch.checked
+		tryHarder: tryHarderSwitch.checked
+		tryInvert: tryInvertSwitch.checked
+		tryDownscale: tryDownscaleSwitch.checked
+		textMode: ZXing.HRI
+
+		// callback with parameter 'barcode', called for every successfully processed frame
+		onFoundBarcode: (barcode)=> {
+			points = [barcode.position.topLeft, barcode.position.topRight, barcode.position.bottomRight, barcode.position.bottomLeft]
+			info.text = qsTr("Format: \t %1 \nText: \t %2 \nType: \t %3 \nTime: \t %4 ms").arg(barcode.formatName).arg(barcode.text).arg(barcode.contentTypeName).arg(runTime)
+
+			resetInfo.restart()
+//			console.log(barcode)
+		}
+
+		// called for every processed frame where no barcode was detected
+		onFailedRead: ()=> {
+			points = nullPoints
+
+			if (!resetInfo.running)
+				info.text = "No barcode found (in %1 ms)".arg(runTime)
+		}
+	}
+
+	Camera {
+		id: camera
+
+		captureMode: Camera.CaptureViewfinder
+		deviceId: QtMultimedia.availableCameras[camerasComboBox.currentIndex] ? QtMultimedia.availableCameras[camerasComboBox.currentIndex].deviceId : ""
+
+		onDeviceIdChanged: {
+			focus.focusMode = CameraFocus.FocusContinuous
+			focus.focusPointMode = CameraFocus.FocusPointAuto
+		}
+
+		onError: console.log("camera error:" + errorString)
+	}
+
+	ColumnLayout {
+		anchors.fill: parent
+
+		RowLayout {
+			Layout.fillWidth: true
+			Layout.fillHeight: false
+			visible: QtMultimedia.availableCameras.length > 1
+			Label {
+				text: qsTr("Camera: ")
+				Layout.fillWidth: false
+			}
+			ComboBox {
+				id: camerasComboBox
+				Layout.fillWidth: true
+				model: QtMultimedia.availableCameras
+				textRole: "displayName"
+				currentIndex: 0
+			}
+		}
+
+		VideoOutput {
+			id: videoOutput
+			Layout.fillHeight: true
+			Layout.fillWidth: true
+			filters: [barcodeReader]
+			source: camera
+			autoOrientation: true
+
+			Shape {
+				id: polygon
+				anchors.fill: parent
+				visible: points.length == 4
+				ShapePath {
+					strokeWidth: 3
+					strokeColor: "red"
+					strokeStyle: ShapePath.SolidLine
+					fillColor: "transparent"
+					//TODO: really? I don't know qml...
+					startX: videoOutput.mapPointToItem(points[3]).x
+					startY: videoOutput.mapPointToItem(points[3]).y
+					PathLine {
+						x: videoOutput.mapPointToItem(points[0]).x
+						y: videoOutput.mapPointToItem(points[0]).y
+					}
+					PathLine {
+						x: videoOutput.mapPointToItem(points[1]).x
+						y: videoOutput.mapPointToItem(points[1]).y
+					}
+					PathLine {
+						x: videoOutput.mapPointToItem(points[2]).x
+						y: videoOutput.mapPointToItem(points[2]).y
+					}
+					PathLine {
+						x: videoOutput.mapPointToItem(points[3]).x
+						y: videoOutput.mapPointToItem(points[3]).y
+					}
+				}
+			}
+
+			Label {
+				id: info
+				color: "white"
+				padding: 10
+				background: Rectangle { color: "#80808080" }
+			}
+
+			ColumnLayout {
+				anchors.right: parent.right
+				anchors.bottom: parent.bottom
+
+				Switch {id: tryRotateSwitch; text: qsTr("Try Rotate"); checked: true }
+				Switch {id: tryHarderSwitch; text: qsTr("Try Harder"); checked: true }
+				Switch {id: tryInvertSwitch; text: qsTr("Try Invert"); checked: true }
+				Switch {id: tryDownscaleSwitch; text: qsTr("Try Downscale"); checked: true }
+				Switch {id: linearSwitch; text: qsTr("Linear Codes"); checked: true }
+				Switch {id: matrixSwitch; text: qsTr("Matrix Codes"); checked: true }
+			}
+		}
+	}
 }
diff --git a/example/ZXingQt6CamReader.qml b/example/ZXingQt6CamReader.qml
index ecb348e410..7eb85445f4 100644
--- a/example/ZXingQt6CamReader.qml
+++ b/example/ZXingQt6CamReader.qml
@@ -12,173 +12,175 @@ import QtMultimedia
 import ZXing
 
 Window {
-    visible: true
-    width: 640
-    height: 480
-    title: Qt.application.name
-
-    property var nullPoints: [Qt.point(0,0), Qt.point(0,0), Qt.point(0,0), Qt.point(0,0)]
-    property var points: nullPoints
-
-    Timer {
-        id: resetInfo
-        interval: 2000
-    }
-
-    BarcodeReader {
-        id: barcodeReader
-        videoSink: videoOutput.videoSink
-
-        formats: (linearSwitch.checked ? (ZXing.LinearCodes) : ZXing.None) | (matrixSwitch.checked ? (ZXing.MatrixCodes) : ZXing.None)
-        tryRotate: tryRotateSwitch.checked
-        tryHarder: tryHarderSwitch.checked
-        tryDownscale: tryDownscaleSwitch.checked
-
-        // callback with parameter 'result', called for every successfully processed frame
-        // onFoundBarcode: {}
-
-        // callback with parameter 'result', called for every processed frame
-        onNewResult: (result)=> {
-            points = result.isValid
-                    ? [result.position.topLeft, result.position.topRight, result.position.bottomRight, result.position.bottomLeft]
-                    : nullPoints
-
-            if (result.isValid)
-                resetInfo.restart()
-
-            if (result.isValid || !resetInfo.running)
-                info.text = qsTr("Format: \t %1 \nText: \t %2 \nError: \t %3 \nTime: \t %4 ms").arg(result.formatName).arg(result.text).arg(result.status).arg(result.runTime)
-
-//            console.log(result)
-        }
-    }
-
-    MediaDevices {
-        id: devices
-    }
-
-    Camera {
-        id: camera
-        cameraDevice: devices.videoInputs[camerasComboBox.currentIndex] ? devices.videoInputs[camerasComboBox.currentIndex] : devices.defaultVideoInput
-        focusMode: Camera.FocusModeAutoNear
-        onErrorOccurred: console.log("camera error:" + errorString)
-        active: true
-    }
-
-    CaptureSession {
-        id: captureSession
-        camera: camera
-        videoOutput: videoOutput
-    }
-
-    ColumnLayout {
-        anchors.fill: parent
-
-        RowLayout {
-            Layout.fillWidth: true
-            Layout.fillHeight: false
-            visible: devices.videoInputs.length > 1
-            Label {
-                text: qsTr("Camera: ")
-                Layout.fillWidth: false
-            }
-            ComboBox {
-                id: camerasComboBox
-                Layout.fillWidth: true
-                model: devices.videoInputs
-                textRole: "description"
-                currentIndex: 0
-            }
-        }
-
-        VideoOutput {
-            id: videoOutput
-            Layout.fillHeight: true
-            Layout.fillWidth: true
-
-            function mapPointToItem(point)
-            {
-                if (videoOutput.sourceRect.width === 0 || videoOutput.sourceRect.height === 0)
-                    return Qt.point(0, 0);
-
-                let dx = point.x;
-                let dy = point.y;
-
-                if ((videoOutput.orientation % 180) == 0)
-                {
-                    dx = dx * videoOutput.contentRect.width / videoOutput.sourceRect.width;
-                    dy = dy * videoOutput.contentRect.height / videoOutput.sourceRect.height;
-                }
-                else
-                {
-                    dx = dx * videoOutput.contentRect.height / videoOutput.sourceRect.height;
-                    dy = dx * videoOutput.contentRect.width / videoOutput.sourceRect.width;
-                }
-
-                switch ((videoOutput.orientation + 360) % 360)
-                {
-                    case 0:
-                    default:
-                        return Qt.point(videoOutput.contentRect.x + dx, videoOutput.contentRect.y + dy);
-                    case 90:
-                        return Qt.point(videoOutput.contentRect.x + dy, videoOutput.contentRect.y + videoOutput.contentRect.height - dx);
-                    case 180:
-                        return Qt.point(videoOutput.contentRect.x + videoOutput.contentRect.width - dx, videoOutput.contentRect.y + videoOutput.contentRect.height -dy);
-                    case 270:
-                        return Qt.point(videoOutput.contentRect.x + videoOutput.contentRect.width - dy, videoOutput.contentRect.y + dx);
-                }
-            }
-
-            Shape {
-                id: polygon
-                anchors.fill: parent
-                visible: control.points.length === 4
-
-                ShapePath {
-                    strokeWidth: 3
-                    strokeColor: "red"
-                    strokeStyle: ShapePath.SolidLine
-                    fillColor: "transparent"
-                    //TODO: really? I don't know qml...
-                    startX: videoOutput.mapPointToItem(points[3]).x
-                    startY: videoOutput.mapPointToItem(points[3]).y
-
-                    PathLine {
-                        x: videoOutput.mapPointToItem(points[0]).x
-                        y: videoOutput.mapPointToItem(points[0]).y
-                    }
-                    PathLine {
-                        x: videoOutput.mapPointToItem(points[1]).x
-                        y: videoOutput.mapPointToItem(points[1]).y
-                    }
-                    PathLine {
-                        x: videoOutput.mapPointToItem(points[2]).x
-                        y: videoOutput.mapPointToItem(points[2]).y
-                    }
-                    PathLine {
-                        x: videoOutput.mapPointToItem(points[3]).x
-                        y: videoOutput.mapPointToItem(points[3]).y
-                    }
-                }
-            }
-
-            Label {
-                id: info
-                color: "white"
-                padding: 10
-                background: Rectangle { color: "#80808080" }
-            }
-
-            ColumnLayout {
-                anchors.right: parent.right
-                anchors.bottom: parent.bottom
-
-                Switch {id: tryRotateSwitch; text: qsTr("Try Rotate"); checked: true }
-                Switch {id: tryHarderSwitch; text: qsTr("Try Harder"); checked: true }
-                Switch {id: tryDownscaleSwitch; text: qsTr("Try Downscale"); checked: true }
-                Switch {id: linearSwitch; text: qsTr("Linear Codes"); checked: true }
-                Switch {id: matrixSwitch; text: qsTr("Matrix Codes"); checked: true }
-            }
-        }
-    }
+	visible: true
+	width: 640
+	height: 480
+	title: Qt.application.name
+
+	property var nullPoints: [Qt.point(0,0), Qt.point(0,0), Qt.point(0,0), Qt.point(0,0)]
+	property var points: nullPoints
+
+	Timer {
+		id: resetInfo
+		interval: 1000
+	}
+
+	BarcodeReader {
+		id: barcodeReader
+		videoSink: videoOutput.videoSink
+
+		formats: (linearSwitch.checked ? (ZXing.LinearCodes) : ZXing.None) | (matrixSwitch.checked ? (ZXing.MatrixCodes) : ZXing.None)
+		tryRotate: tryRotateSwitch.checked
+		tryHarder: tryHarderSwitch.checked
+		tryInvert: tryInvertSwitch.checked
+		tryDownscale: tryDownscaleSwitch.checked
+		textMode: ZXing.TextMode.HRI
+
+		// callback with parameter 'barcode', called for every successfully processed frame
+		onFoundBarcode: (barcode)=> {
+			points = [barcode.position.topLeft, barcode.position.topRight, barcode.position.bottomRight, barcode.position.bottomLeft]
+			info.text = qsTr("Format: \t %1 \nText: \t %2 \nType: \t %3 \nTime: \t %4 ms").arg(barcode.formatName).arg(barcode.text).arg(barcode.contentTypeName).arg(runTime)
+
+			resetInfo.restart()
+//			console.log(barcode)
+		}
+
+		// called for every processed frame where no barcode was detected
+		onFailedRead: ()=> {
+			points = nullPoints
+
+			if (!resetInfo.running)
+				info.text = "No barcode found (in %1 ms)".arg(runTime)
+		}
+	}
+
+	MediaDevices {
+		id: devices
+	}
+
+	Camera {
+		id: camera
+		cameraDevice: devices.videoInputs[camerasComboBox.currentIndex] ? devices.videoInputs[camerasComboBox.currentIndex] : devices.defaultVideoInput
+		focusMode: Camera.FocusModeAutoNear
+		onErrorOccurred: console.log("camera error:" + errorString)
+		active: true
+	}
+
+	CaptureSession {
+		id: captureSession
+		camera: camera
+		videoOutput: videoOutput
+	}
+
+	ColumnLayout {
+		anchors.fill: parent
+
+		RowLayout {
+			Layout.fillWidth: true
+			Layout.fillHeight: false
+			visible: devices.videoInputs.length > 1
+			Label {
+				text: qsTr("Camera: ")
+				Layout.fillWidth: false
+			}
+			ComboBox {
+				id: camerasComboBox
+				Layout.fillWidth: true
+				model: devices.videoInputs
+				textRole: "description"
+				currentIndex: 0
+			}
+		}
+
+		VideoOutput {
+			id: videoOutput
+			Layout.fillHeight: true
+			Layout.fillWidth: true
+
+			function mapPointToItem(point)
+			{
+				if (videoOutput.sourceRect.width === 0 || videoOutput.sourceRect.height === 0)
+					return Qt.point(0, 0);
+
+				let dx = point.x;
+				let dy = point.y;
+
+				if ((videoOutput.orientation % 180) == 0)
+				{
+					dx = dx * videoOutput.contentRect.width / videoOutput.sourceRect.width;
+					dy = dy * videoOutput.contentRect.height / videoOutput.sourceRect.height;
+				}
+				else
+				{
+					dx = dx * videoOutput.contentRect.height / videoOutput.sourceRect.height;
+					dy = dx * videoOutput.contentRect.width / videoOutput.sourceRect.width;
+				}
+
+				switch ((videoOutput.orientation + 360) % 360)
+				{
+					case 0:
+					default:
+						return Qt.point(videoOutput.contentRect.x + dx, videoOutput.contentRect.y + dy);
+					case 90:
+						return Qt.point(videoOutput.contentRect.x + dy, videoOutput.contentRect.y + videoOutput.contentRect.height - dx);
+					case 180:
+						return Qt.point(videoOutput.contentRect.x + videoOutput.contentRect.width - dx, videoOutput.contentRect.y + videoOutput.contentRect.height -dy);
+					case 270:
+						return Qt.point(videoOutput.contentRect.x + videoOutput.contentRect.width - dy, videoOutput.contentRect.y + dx);
+				}
+			}
+
+			Shape {
+				id: polygon
+				anchors.fill: parent
+				visible: points.length === 4
+
+				ShapePath {
+					strokeWidth: 3
+					strokeColor: "red"
+					strokeStyle: ShapePath.SolidLine
+					fillColor: "transparent"
+					//TODO: really? I don't know qml...
+					startX: videoOutput.mapPointToItem(points[3]).x
+					startY: videoOutput.mapPointToItem(points[3]).y
+
+					PathLine {
+						x: videoOutput.mapPointToItem(points[0]).x
+						y: videoOutput.mapPointToItem(points[0]).y
+					}
+					PathLine {
+						x: videoOutput.mapPointToItem(points[1]).x
+						y: videoOutput.mapPointToItem(points[1]).y
+					}
+					PathLine {
+						x: videoOutput.mapPointToItem(points[2]).x
+						y: videoOutput.mapPointToItem(points[2]).y
+					}
+					PathLine {
+						x: videoOutput.mapPointToItem(points[3]).x
+						y: videoOutput.mapPointToItem(points[3]).y
+					}
+				}
+			}
+
+			Label {
+				id: info
+				color: "white"
+				padding: 10
+				background: Rectangle { color: "#80808080" }
+			}
+
+			ColumnLayout {
+				anchors.right: parent.right
+				anchors.bottom: parent.bottom
+
+				Switch {id: tryRotateSwitch; text: qsTr("Try Rotate"); checked: true }
+				Switch {id: tryHarderSwitch; text: qsTr("Try Harder"); checked: true }
+				Switch {id: tryInvertSwitch; text: qsTr("Try Invert"); checked: true }
+				Switch {id: tryDownscaleSwitch; text: qsTr("Try Downscale"); checked: true }
+				Switch {id: linearSwitch; text: qsTr("Linear Codes"); checked: true }
+				Switch {id: matrixSwitch; text: qsTr("Matrix Codes"); checked: true }
+			}
+		}
+	}
 }
diff --git a/example/ZXingQtReader.cpp b/example/ZXingQtReader.cpp
index fe04192160..2aba7dfddc 100644
--- a/example/ZXingQtReader.cpp
+++ b/example/ZXingQtReader.cpp
@@ -18,26 +18,27 @@ int main(int argc, char* argv[])
 
 	QString filePath = argv[1];
 
-	QImage fileImage = QImage(filePath);
+	QImage image = QImage(filePath);
 
-	if (fileImage.isNull()) {
+	if (image.isNull()) {
 		qDebug() << "Could not load the filename as an image:" << filePath;
 		return 1;
 	}
 
 	auto options = ReaderOptions()
-					 .setFormats(BarcodeFormat::Any)
-					 .setTryRotate(false)
+					 .setFormats(BarcodeFormat::MatrixCodes)
+					 .setTryInvert(false)
+					 .setTextMode(TextMode::HRI)
 					 .setMaxNumberOfSymbols(10);
 
-	auto results = ReadBarcodes(fileImage, options);
+	auto barcodes = ReadBarcodes(image, options);
 
-	for (auto& result : results) {
-		qDebug() << "Text:   " << result.text();
-		qDebug() << "Format: " << result.format();
-		qDebug() << "Content:" << result.contentType();
+	for (auto& barcode : barcodes) {
+		qDebug() << "Text:   " << barcode.text();
+		qDebug() << "Format: " << barcode.format();
+		qDebug() << "Content:" << barcode.contentType();
 		qDebug() << "";
 	}
 
-	return results.isEmpty() ? 1 : 0;
+	return barcodes.isEmpty() ? 1 : 0;
 }
diff --git a/example/ZXingQtReader.h b/example/ZXingQtReader.h
index 1c11c0f50c..629f44423b 100644
--- a/example/ZXingQtReader.h
+++ b/example/ZXingQtReader.h
@@ -52,16 +52,21 @@ enum class BarcodeFormat
 	UPCE            = (1 << 15), ///< UPC-E
 	MicroQRCode     = (1 << 16), ///< Micro QR Code
 	RMQRCode        = (1 << 17), ///< Rectangular Micro QR Code
+	DXFilmEdge      = (1 << 18), ///< DX Film Edge Barcode
+	DataBarLimited  = (1 << 19), ///< GS1 DataBar Limited
 
-	LinearCodes = Codabar | Code39 | Code93 | Code128 | EAN8 | EAN13 | ITF | DataBar | DataBarExpanded | UPCA | UPCE,
+	LinearCodes = Codabar | Code39 | Code93 | Code128 | EAN8 | EAN13 | ITF | DataBar | DataBarExpanded | DataBarLimited | DXFilmEdge | UPCA | UPCE,
 	MatrixCodes = Aztec | DataMatrix | MaxiCode | PDF417 | QRCode | MicroQRCode | RMQRCode,
 };
 
 enum class ContentType { Text, Binary, Mixed, GS1, ISO15434, UnknownECI };
 
+enum class TextMode { Plain, ECI, HRI, Hex, Escaped };
+
 #else
 using ZXing::BarcodeFormat;
 using ZXing::ContentType;
+using ZXing::TextMode;
 #endif
 
 using ZXing::ReaderOptions;
@@ -70,6 +75,7 @@ using ZXing::BarcodeFormats;
 
 Q_ENUM_NS(BarcodeFormat)
 Q_ENUM_NS(ContentType)
+Q_ENUM_NS(TextMode)
 
 template<typename T, typename = decltype(ZXing::ToString(T()))>
 QDebug operator<<(QDebug dbg, const T& v)
@@ -92,7 +98,7 @@ class Position : public ZXing::Quadrilateral<QPoint>
 	using Base::Base;
 };
 
-class Result : private ZXing::Result
+class Barcode : private ZXing::Barcode
 {
 	Q_GADGET
 
@@ -102,6 +108,7 @@ class Result : private ZXing::Result
 	Q_PROPERTY(QByteArray bytes READ bytes)
 	Q_PROPERTY(bool isValid READ isValid)
 	Q_PROPERTY(ContentType contentType READ contentType)
+	Q_PROPERTY(QString contentTypeName READ contentTypeName)
 	Q_PROPERTY(Position position READ position)
 
 	QString _text;
@@ -109,39 +116,40 @@ class Result : private ZXing::Result
 	Position _position;
 
 public:
-	Result() = default; // required for qmetatype machinery
+	Barcode() = default; // required for qmetatype machinery
 
-	explicit Result(ZXing::Result&& r) : ZXing::Result(std::move(r)) {
-		_text = QString::fromStdString(ZXing::Result::text());
-		_bytes = QByteArray(reinterpret_cast<const char*>(ZXing::Result::bytes().data()), Size(ZXing::Result::bytes()));
-		auto& pos = ZXing::Result::position();
+	explicit Barcode(ZXing::Barcode&& r) : ZXing::Barcode(std::move(r)) {
+		_text = QString::fromStdString(ZXing::Barcode::text());
+		_bytes = QByteArray(reinterpret_cast<const char*>(ZXing::Barcode::bytes().data()), Size(ZXing::Barcode::bytes()));
+		auto& pos = ZXing::Barcode::position();
 		auto qp = [&pos](int i) { return QPoint(pos[i].x, pos[i].y); };
 		_position = {qp(0), qp(1), qp(2), qp(3)};
 	}
 
-	using ZXing::Result::isValid;
+	using ZXing::Barcode::isValid;
 
-	BarcodeFormat format() const { return static_cast<BarcodeFormat>(ZXing::Result::format()); }
-	ContentType contentType() const { return static_cast<ContentType>(ZXing::Result::contentType()); }
-	QString formatName() const { return QString::fromStdString(ZXing::ToString(ZXing::Result::format())); }
+	BarcodeFormat format() const { return static_cast<BarcodeFormat>(ZXing::Barcode::format()); }
+	ContentType contentType() const { return static_cast<ContentType>(ZXing::Barcode::contentType()); }
+	QString formatName() const { return QString::fromStdString(ZXing::ToString(ZXing::Barcode::format())); }
+	QString contentTypeName() const { return QString::fromStdString(ZXing::ToString(ZXing::Barcode::contentType())); }
 	const QString& text() const { return _text; }
 	const QByteArray& bytes() const { return _bytes; }
 	const Position& position() const { return _position; }
-
-	// For debugging/development
-	int runTime = 0;
-	Q_PROPERTY(int runTime MEMBER runTime)
 };
 
-inline QList<Result> QListResults(ZXing::Results&& zxres)
+inline QList<Barcode> ZXBarcodesToQBarcodes(ZXing::Barcodes&& zxres)
 {
-	QList<Result> res;
+	QList<Barcode> res;
 	for (auto&& r : zxres)
-		res.push_back(Result(std::move(r)));
+#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
+		res.push_back(Barcode(std::move(r)));
+#else
+		res.emplace_back(std::move(r));
+#endif
 	return res;
 }
 
-inline QList<Result> ReadBarcodes(const QImage& img, const ReaderOptions& opts = {})
+inline QList<Barcode> ReadBarcodes(const QImage& img, const ReaderOptions& opts = {})
 {
 	using namespace ZXing;
 
@@ -150,34 +158,34 @@ inline QList<Result> ReadBarcodes(const QImage& img, const ReaderOptions& opts =
 		case QImage::Format_ARGB32:
 		case QImage::Format_RGB32:
 #if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
-			return ImageFormat::BGRX;
+			return ImageFormat::BGRA;
 #else
-			return ImageFormat::XRGB;
+			return ImageFormat::ARGB;
 #endif
 		case QImage::Format_RGB888: return ImageFormat::RGB;
 		case QImage::Format_RGBX8888:
-		case QImage::Format_RGBA8888: return ImageFormat::RGBX;
+		case QImage::Format_RGBA8888: return ImageFormat::RGBA;
 		case QImage::Format_Grayscale8: return ImageFormat::Lum;
 		default: return ImageFormat::None;
 		}
 	};
 
 	auto exec = [&](const QImage& img) {
-		return QListResults(ZXing::ReadBarcodes(
+		return ZXBarcodesToQBarcodes(ZXing::ReadBarcodes(
 			{img.bits(), img.width(), img.height(), ImgFmtFromQImg(img), static_cast<int>(img.bytesPerLine())}, opts));
 	};
 
 	return ImgFmtFromQImg(img) == ImageFormat::None ? exec(img.convertToFormat(QImage::Format_Grayscale8)) : exec(img);
 }
 
-inline Result ReadBarcode(const QImage& img, const ReaderOptions& opts = {})
+inline Barcode ReadBarcode(const QImage& img, const ReaderOptions& opts = {})
 {
 	auto res = ReadBarcodes(img, ReaderOptions(opts).setMaxNumberOfSymbols(1));
-	return !res.isEmpty() ? res.takeFirst() : Result();
+	return !res.isEmpty() ? res.takeFirst() : Barcode();
 }
 
 #ifdef QT_MULTIMEDIA_LIB
-inline QList<Result> ReadBarcodes(const QVideoFrame& frame, const ReaderOptions& opts = {})
+inline QList<Barcode> ReadBarcodes(const QVideoFrame& frame, const ReaderOptions& opts = {})
 {
 	using namespace ZXing;
 
@@ -198,9 +206,9 @@ inline QList<Result> ReadBarcodes(const QVideoFrame& frame, const ReaderOptions&
 	case FORMAT(ARGB32_Premultiplied, ARGB8888_Premultiplied):
 	case FORMAT(RGB32, RGBX8888):
 #if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
-		fmt = ImageFormat::BGRX;
+		fmt = ImageFormat::BGRA;
 #else
-		fmt = ImageFormat::XRGB;
+		fmt = ImageFormat::ARGB;
 #endif
 		break;
 
@@ -208,9 +216,9 @@ inline QList<Result> ReadBarcodes(const QVideoFrame& frame, const ReaderOptions&
 	case FORMAT(BGRA32_Premultiplied, BGRA8888_Premultiplied):
 	case FORMAT(BGR32, BGRX8888):
 #if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
-		fmt = ImageFormat::RGBX;
+		fmt = ImageFormat::RGBA;
 #else
-		fmt = ImageFormat::XBGR;
+		fmt = ImageFormat::ABGR;
 #endif
 		break;
 
@@ -249,9 +257,9 @@ inline QList<Result> ReadBarcodes(const QVideoFrame& frame, const ReaderOptions&
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 13, 0))
 	case FORMAT(ABGR32, ABGR8888):
 #if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
-		fmt = ImageFormat::RGBX;
+		fmt = ImageFormat::RGBA;
 #else
-		fmt = ImageFormat::XBGR;
+		fmt = ImageFormat::ABGR;
 #endif
 		break;
 #endif
@@ -273,7 +281,7 @@ inline QList<Result> ReadBarcodes(const QVideoFrame& frame, const ReaderOptions&
 		}
 		QScopeGuard unmap([&] { img.unmap(); });
 
-		return QListResults(ZXing::ReadBarcodes(
+		return ZXBarcodesToQBarcodes(ZXing::ReadBarcodes(
 			{img.bits(FIRST_PLANE) + pixOffset, img.width(), img.height(), fmt, img.bytesPerLine(FIRST_PLANE), pixStride}, opts));
 	}
 	else {
@@ -293,10 +301,10 @@ inline QList<Result> ReadBarcodes(const QVideoFrame& frame, const ReaderOptions&
 	}
 }
 
-inline Result ReadBarcode(const QVideoFrame& frame, const ReaderOptions& opts = {})
+inline Barcode ReadBarcode(const QVideoFrame& frame, const ReaderOptions& opts = {})
 {
 	auto res = ReadBarcodes(frame, ReaderOptions(opts).setMaxNumberOfSymbols(1));
-	return !res.isEmpty() ? res.takeFirst() : Result();
+	return !res.isEmpty() ? res.takeFirst() : Barcode();
 }
 
 #define ZQ_PROPERTY(Type, name, setter) \
@@ -347,29 +355,47 @@ class BarcodeReader : public QObject, private ReaderOptions
 	}
 	Q_SIGNAL void formatsChanged();
 
+	Q_PROPERTY(TextMode textMode READ textMode WRITE setTextMode NOTIFY textModeChanged)
+	TextMode textMode() const noexcept { return static_cast<TextMode>(ReaderOptions::textMode()); }
+	Q_SLOT void setTextMode(TextMode newVal)
+	{
+		if (textMode() != newVal) {
+			ReaderOptions::setTextMode(static_cast<ZXing::TextMode>(newVal));
+			emit textModeChanged();
+		}
+	}
+	Q_SIGNAL void textModeChanged();
+
 	ZQ_PROPERTY(bool, tryRotate, setTryRotate)
 	ZQ_PROPERTY(bool, tryHarder, setTryHarder)
+	ZQ_PROPERTY(bool, tryInvert, setTryInvert)
 	ZQ_PROPERTY(bool, tryDownscale, setTryDownscale)
+	ZQ_PROPERTY(bool, isPure, setIsPure)
+
+	// For debugging/development
+	int runTime = 0;
+	Q_PROPERTY(int runTime MEMBER runTime)
 
 public slots:
-	ZXingQt::Result process(const QVideoFrame& image)
+	ZXingQt::Barcode process(const QVideoFrame& image)
 	{
 		QElapsedTimer t;
 		t.start();
 
 		auto res = ReadBarcode(image, *this);
 
-		res.runTime = t.elapsed();
+		runTime = t.elapsed();
 
-		emit newResult(res);
 		if (res.isValid())
 			emit foundBarcode(res);
+		else
+			emit failedRead();
 		return res;
 	}
 
 signals:
-	void newResult(ZXingQt::Result result);
-	void foundBarcode(ZXingQt::Result result);
+	void failedRead();
+	void foundBarcode(ZXingQt::Barcode barcode);
 
 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
 public:
@@ -389,7 +415,7 @@ public slots:
 		_sink = sink;
 		connect(_sink, &QVideoSink::videoFrameChanged, this, &BarcodeReader::process);
 	}
-	Q_PROPERTY(QVideoSink* videoSink WRITE setVideoSink)
+	Q_PROPERTY(QVideoSink* videoSink MEMBER _sink WRITE setVideoSink)
 #endif
 
 };
@@ -423,7 +449,7 @@ inline QVideoFilterRunnable* BarcodeReader::createFilterRunnable()
 
 
 Q_DECLARE_METATYPE(ZXingQt::Position)
-Q_DECLARE_METATYPE(ZXingQt::Result)
+Q_DECLARE_METATYPE(ZXingQt::Barcode)
 
 #ifdef QT_QML_LIB
 
@@ -435,11 +461,12 @@ inline void registerQmlAndMetaTypes()
 {
 	qRegisterMetaType<ZXingQt::BarcodeFormat>("BarcodeFormat");
 	qRegisterMetaType<ZXingQt::ContentType>("ContentType");
+	qRegisterMetaType<ZXingQt::TextMode>("TextMode");
 
 	// supposedly the Q_DECLARE_METATYPE should be used with the overload without a custom name
 	// but then the qml side complains about "unregistered type"
 	qRegisterMetaType<ZXingQt::Position>("Position");
-	qRegisterMetaType<ZXingQt::Result>("Result");
+	qRegisterMetaType<ZXingQt::Barcode>("Barcode");
 
 	qmlRegisterUncreatableMetaObject(
 		ZXingQt::staticMetaObject, "ZXing", 1, 0, "ZXing", "Access to enums & flags only");
diff --git a/example/ZXingQtWriter.cpp b/example/ZXingQtWriter.cpp
index 047f182a7d..589b2b4afb 100644
--- a/example/ZXingQtWriter.cpp
+++ b/example/ZXingQtWriter.cpp
@@ -4,8 +4,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "BarcodeFormat.h"
+#ifdef ZXING_EXPERIMENTAL_API
+#include "WriteBarcode.h"
+#else
 #include "BitMatrix.h"
 #include "MultiFormatWriter.h"
+#endif
 
 #include <QDebug>
 #include <QImage>
@@ -16,10 +20,14 @@ QImage WriteBarcode(QStringView text, ZXing::BarcodeFormat format)
 {
 	using namespace ZXing;
 
+#ifdef ZXING_EXPERIMENTAL_API
+	auto barcode = CreateBarcodeFromText(text.toString().toStdString(), format);
+	auto bitmap = WriteBarcodeToImage(barcode);
+#else
 	auto writer = MultiFormatWriter(format);
 	auto matrix = writer.encode(text.toString().toStdString(), 0, 0);
 	auto bitmap = ToMatrix<uint8_t>(matrix);
-
+#endif
 	return QImage(bitmap.data(), bitmap.width(), bitmap.height(), bitmap.width(), QImage::Format::Format_Grayscale8).copy();
 }
 
diff --git a/example/ZXingReader.cpp b/example/ZXingReader.cpp
index 74682a9d2a..059c735e4e 100644
--- a/example/ZXingReader.cpp
+++ b/example/ZXingReader.cpp
@@ -4,9 +4,13 @@
 */
 // SPDX-License-Identifier: Apache-2.0
 
-#include "ReadBarcode.h"
 #include "GTIN.h"
-#include "ZXVersion.h"
+#include "ReadBarcode.h"
+#include "Version.h"
+
+#ifdef ZXING_EXPERIMENTAL_API
+#include "WriteBarcode.h"
+#endif
 
 #include <cctype>
 #include <chrono>
@@ -24,6 +28,17 @@
 
 using namespace ZXing;
 
+struct CLI
+{
+	std::vector<std::string> filePaths;
+	std::string outPath;
+	int forceChannels = 0;
+	int rotate = 0;
+	bool oneLine = false;
+	bool bytesOnly = false;
+	bool showSymbol = false;
+};
+
 static void PrintUsage(const char* exePath)
 {
 	std::cout << "Usage: " << exePath << " [options] <image file>...\n"
@@ -31,13 +46,19 @@ static void PrintUsage(const char* exePath)
 			  << "    -norotate  Don't try rotated image during detection (faster)\n"
 			  << "    -noinvert  Don't search for inverted codes during detection (faster)\n"
 			  << "    -noscale   Don't try downscaled images during detection (faster)\n"
-			  << "    -format <FORMAT[,...]>\n"
+			  << "    -formats <FORMAT[,...]>\n"
 			  << "               Only detect given format(s) (faster)\n"
+			  << "    -single    Stop after the first barcode is detected (faster)\n"
 			  << "    -ispure    Assume the image contains only a 'pure'/perfect code (faster)\n"
-			  << "    -errors    Include results with errors (like checksum error)\n"
+			  << "    -errors    Include barcodes with errors (like checksum error)\n"
+			  << "    -binarizer <local|global|fixed>\n"
+			  << "               Binarizer to be used for gray to binary conversion\n"
 			  << "    -mode <plain|eci|hri|escaped>\n"
 			  << "               Text mode used to render the raw byte content into text\n"
 			  << "    -1         Print only file name, content/error on one line per file/barcode (implies '-mode Escaped')\n"
+#ifdef ZXING_EXPERIMENTAL_API
+			  << "    -symbol    Print the detected symbol (if available)\n"
+#endif
 			  << "    -bytes     Write (only) the bytes content of the symbol(s) to stdout\n"
 			  << "    -pngout <file name>\n"
 			  << "               Write a copy of the input image with barcodes outlined by a green line\n"
@@ -51,18 +72,17 @@ static void PrintUsage(const char* exePath)
 	std::cout << "Formats can be lowercase, with or without '-', separated by ',' and/or '|'\n";
 }
 
-static bool ParseOptions(int argc, char* argv[], ReaderOptions& options, bool& oneLine, bool& bytesOnly,
-						 std::vector<std::string>& filePaths, std::string& outPath)
+static bool ParseOptions(int argc, char* argv[], ReaderOptions& options, CLI& cli)
 {
-#ifdef ZXING_BUILD_EXPERIMENTAL_API
+#ifdef ZXING_EXPERIMENTAL_API
 	options.setTryDenoise(true);
 #endif
 
 	for (int i = 1; i < argc; ++i) {
-		auto is = [&](const char* str) { return strncmp(argv[i], str, strlen(argv[i])) == 0; };
+		auto is = [&](const char* str) { return strlen(argv[i]) > 1 && strncmp(argv[i], str, strlen(argv[i])) == 0; };
 		if (is("-fast")) {
 			options.setTryHarder(false);
-#ifdef ZXING_BUILD_EXPERIMENTAL_API
+#ifdef ZXING_EXPERIMENTAL_API
 			options.setTryDenoise(false);
 #endif
 		} else if (is("-norotate")) {
@@ -71,12 +91,14 @@ static bool ParseOptions(int argc, char* argv[], ReaderOptions& options, bool& o
 			options.setTryInvert(false);
 		} else if (is("-noscale")) {
 			options.setTryDownscale(false);
+		} else if (is("-single")) {
+			options.setMaxNumberOfSymbols(1);
 		} else if (is("-ispure")) {
 			options.setIsPure(true);
 			options.setBinarizer(Binarizer::FixedThreshold);
 		} else if (is("-errors")) {
 			options.setReturnErrors(true);
-		} else if (is("-format")) {
+		} else if (is("-formats")) {
 			if (++i == argc)
 				return false;
 			try {
@@ -85,6 +107,17 @@ static bool ParseOptions(int argc, char* argv[], ReaderOptions& options, bool& o
 				std::cerr << e.what() << "\n";
 				return false;
 			}
+		} else if (is("-binarizer")) {
+			if (++i == argc)
+				return false;
+			else if (is("local"))
+				options.setBinarizer(Binarizer::LocalAverage);
+			else if (is("global"))
+				options.setBinarizer(Binarizer::GlobalHistogram);
+			else if (is("fixed"))
+				options.setBinarizer(Binarizer::FixedThreshold);
+			else
+				return false;
 		} else if (is("-mode")) {
 			if (++i == argc)
 				return false;
@@ -99,13 +132,23 @@ static bool ParseOptions(int argc, char* argv[], ReaderOptions& options, bool& o
 			else
 				return false;
 		} else if (is("-1")) {
-			oneLine = true;
+			cli.oneLine = true;
 		} else if (is("-bytes")) {
-			bytesOnly = true;
+			cli.bytesOnly = true;
+		} else if (is("-symbol")) {
+			cli.showSymbol = true;
 		} else if (is("-pngout")) {
 			if (++i == argc)
 				return false;
-			outPath = argv[i];
+			cli.outPath = argv[i];
+		} else if (is("-channels")) {
+			if (++i == argc)
+				return false;
+			cli.forceChannels = atoi(argv[i]);
+		} else if (is("-rotate")) {
+			if (++i == argc)
+				return false;
+			cli.rotate = atoi(argv[i]);
 		} else if (is("-help") || is("--help")) {
 			PrintUsage(argv[0]);
 			exit(0);
@@ -113,18 +156,11 @@ static bool ParseOptions(int argc, char* argv[], ReaderOptions& options, bool& o
 			std::cout << "ZXingReader " << ZXING_VERSION_STR << "\n";
 			exit(0);
 		} else {
-			filePaths.push_back(argv[i]);
+			cli.filePaths.push_back(argv[i]);
 		}
 	}
 
-	return !filePaths.empty();
-}
-
-std::ostream& operator<<(std::ostream& os, const Position& points)
-{
-	for (const auto& p : points)
-		os << p.x << "x" << p.y << " ";
-	return os;
+	return !cli.filePaths.empty();
 }
 
 void drawLine(const ImageView& iv, PointI a, PointI b, bool error)
@@ -152,128 +188,137 @@ void drawRect(const ImageView& image, const Position& pos, bool error)
 int main(int argc, char* argv[])
 {
 	ReaderOptions options;
-	std::vector<std::string> filePaths;
-	Results allResults;
-	std::string outPath;
-	bool oneLine = false;
-	bool bytesOnly = false;
+	CLI cli;
+	Barcodes allBarcodes;
 	int ret = 0;
 
 	options.setTextMode(TextMode::HRI);
 	options.setEanAddOnSymbol(EanAddOnSymbol::Read);
 
-	if (!ParseOptions(argc, argv, options, oneLine, bytesOnly, filePaths, outPath)) {
+	if (!ParseOptions(argc, argv, options, cli)) {
 		PrintUsage(argv[0]);
 		return -1;
 	}
 
-
 	std::cout.setf(std::ios::boolalpha);
 
-	for (const auto& filePath : filePaths) {
+	if (!cli.outPath.empty())
+		cli.forceChannels = 3; // the drawing code only works for RGB data
+
+	for (const auto& filePath : cli.filePaths) {
 		int width, height, channels;
-		std::unique_ptr<stbi_uc, void(*)(void*)> buffer(stbi_load(filePath.c_str(), &width, &height, &channels, 3), stbi_image_free);
+		std::unique_ptr<stbi_uc, void (*)(void*)> buffer(
+			filePath == "-" ? stbi_load_from_file(stdin, &width, &height, &channels, cli.forceChannels)
+							: stbi_load(filePath.c_str(), &width, &height, &channels, cli.forceChannels),
+			stbi_image_free);
 		if (buffer == nullptr) {
 			std::cerr << "Failed to read image: " << filePath << " (" << stbi_failure_reason() << ")" << "\n";
 			return -1;
 		}
+		channels = cli.forceChannels ? cli.forceChannels : channels;
 
-		ImageView image{buffer.get(), width, height, ImageFormat::RGB};
-		auto results = ReadBarcodes(image, options);
+		auto ImageFormatFromChannels = std::array{ImageFormat::None, ImageFormat::Lum, ImageFormat::LumA, ImageFormat::RGB, ImageFormat::RGBA};
+		ImageView image{buffer.get(), width, height, ImageFormatFromChannels.at(channels)};
+		auto barcodes = ReadBarcodes(image.rotated(cli.rotate), options);
 
 		// if we did not find anything, insert a dummy to produce some output for each file
-		if (results.empty())
-			results.emplace_back();
+		if (barcodes.empty())
+			barcodes.emplace_back();
 
-		allResults.insert(allResults.end(), results.begin(), results.end());
-		if (filePath == filePaths.back()) {
-			auto merged = MergeStructuredAppendSequences(allResults);
+		allBarcodes.insert(allBarcodes.end(), barcodes.begin(), barcodes.end());
+		if (filePath == cli.filePaths.back()) {
+			auto merged = MergeStructuredAppendSequences(allBarcodes);
 			// report all merged sequences as part of the last file to make the logic not overly complicated here
-			results.insert(results.end(), std::make_move_iterator(merged.begin()), std::make_move_iterator(merged.end()));
+			barcodes.insert(barcodes.end(), std::make_move_iterator(merged.begin()), std::make_move_iterator(merged.end()));
 		}
 
-		for (auto&& result : results) {
+		for (auto&& barcode : barcodes) {
 
-			if (!outPath.empty())
-				drawRect(image, result.position(), bool(result.error()));
+			if (!cli.outPath.empty())
+				drawRect(image, barcode.position(), bool(barcode.error()));
 
-			ret |= static_cast<int>(result.error().type());
+			ret |= static_cast<int>(barcode.error().type());
 
-			if (bytesOnly) {
-				std::cout.write(reinterpret_cast<const char*>(result.bytes().data()), result.bytes().size());
+			if (cli.bytesOnly) {
+				std::cout.write(reinterpret_cast<const char*>(barcode.bytes().data()), barcode.bytes().size());
 				continue;
 			}
 
-			if (oneLine) {
-				std::cout << filePath << " " << ToString(result.format());
-				if (result.isValid())
-					std::cout << " \"" << result.text(TextMode::Escaped) << "\"";
-				else if (result.error())
-					std::cout << " " << ToString(result.error());
+			if (cli.oneLine) {
+				std::cout << filePath << " " << ToString(barcode.format());
+				if (barcode.isValid())
+					std::cout << " \"" << barcode.text(TextMode::Escaped) << "\"";
+				else if (barcode.error())
+					std::cout << " " << ToString(barcode.error());
 				std::cout << "\n";
 				continue;
 			}
 
-			if (filePaths.size() > 1 || results.size() > 1) {
+			if (cli.filePaths.size() > 1 || barcodes.size() > 1) {
 				static bool firstFile = true;
 				if (!firstFile)
 					std::cout << "\n";
-				if (filePaths.size() > 1)
+				if (cli.filePaths.size() > 1)
 					std::cout << "File:       " << filePath << "\n";
 				firstFile = false;
 			}
 
-			if (result.format() == BarcodeFormat::None) {
+			if (barcode.format() == BarcodeFormat::None) {
 				std::cout << "No barcode found\n";
 				continue;
 			}
 
-			std::cout << "Text:       \"" << result.text() << "\"\n"
-					  << "Bytes:      " << ToHex(options.textMode() == TextMode::ECI ? result.bytesECI() : result.bytes()) << "\n"
-					  << "Format:     " << ToString(result.format()) << "\n"
-					  << "Identifier: " << result.symbologyIdentifier() << "\n"
-					  << "Content:    " << ToString(result.contentType()) << "\n"
-					  << "HasECI:     " << result.hasECI() << "\n"
-					  << "Position:   " << result.position() << "\n"
-					  << "Rotation:   " << result.orientation() << " deg\n"
-					  << "IsMirrored: " << result.isMirrored() << "\n"
-					  << "IsInverted: " << result.isInverted() << "\n";
+			std::cout << "Text:       \"" << barcode.text() << "\"\n"
+					  << "Bytes:      " << ToHex(options.textMode() == TextMode::ECI ? barcode.bytesECI() : barcode.bytes()) << "\n"
+					  << "Format:     " << ToString(barcode.format()) << "\n"
+					  << "Identifier: " << barcode.symbologyIdentifier() << "\n"
+					  << "Content:    " << ToString(barcode.contentType()) << "\n"
+					  << "HasECI:     " << barcode.hasECI() << "\n"
+					  << "Position:   " << ToString(barcode.position()) << "\n"
+					  << "Rotation:   " << barcode.orientation() << " deg\n"
+					  << "IsMirrored: " << barcode.isMirrored() << "\n"
+					  << "IsInverted: " << barcode.isInverted() << "\n";
 
 			auto printOptional = [](const char* key, const std::string& v) {
 				if (!v.empty())
 					std::cout << key << v << "\n";
 			};
 
-			printOptional("EC Level:   ", result.ecLevel());
-			printOptional("Version:    ", result.version());
-			printOptional("Error:      ", ToString(result.error()));
+			printOptional("EC Level:   ", barcode.ecLevel());
+			printOptional("Version:    ", barcode.version());
+			printOptional("Error:      ", ToString(barcode.error()));
 
-			if (result.lineCount())
-				std::cout << "Lines:      " << result.lineCount() << "\n";
+			if (barcode.lineCount())
+				std::cout << "Lines:      " << barcode.lineCount() << "\n";
 
 			if ((BarcodeFormat::EAN13 | BarcodeFormat::EAN8 | BarcodeFormat::UPCA | BarcodeFormat::UPCE)
-					.testFlag(result.format())) {
-				printOptional("Country:    ", GTIN::LookupCountryIdentifier(result.text(), result.format()));
-				printOptional("Add-On:     ", GTIN::EanAddOn(result));
-				printOptional("Price:      ", GTIN::Price(GTIN::EanAddOn(result)));
-				printOptional("Issue #:    ", GTIN::IssueNr(GTIN::EanAddOn(result)));
-			} else if (result.format() == BarcodeFormat::ITF && Size(result.bytes()) == 14) {
-				printOptional("Country:    ", GTIN::LookupCountryIdentifier(result.text(), result.format()));
+					.testFlag(barcode.format())) {
+				printOptional("Country:    ", GTIN::LookupCountryIdentifier(barcode.text(), barcode.format()));
+				printOptional("Add-On:     ", GTIN::EanAddOn(barcode));
+				printOptional("Price:      ", GTIN::Price(GTIN::EanAddOn(barcode)));
+				printOptional("Issue #:    ", GTIN::IssueNr(GTIN::EanAddOn(barcode)));
+			} else if (barcode.format() == BarcodeFormat::ITF && Size(barcode.bytes()) == 14) {
+				printOptional("Country:    ", GTIN::LookupCountryIdentifier(barcode.text(), barcode.format()));
 			}
 
-			if (result.isPartOfSequence())
-				std::cout << "Structured Append: symbol " << result.sequenceIndex() + 1 << " of "
-						  << result.sequenceSize() << " (parity/id: '" << result.sequenceId() << "')\n";
-			else if (result.sequenceSize() > 0)
-				std::cout << "Structured Append: merged result from " << result.sequenceSize() << " symbols (parity/id: '"
-						  << result.sequenceId() << "')\n";
+			if (barcode.isPartOfSequence())
+				std::cout << "Structured Append: symbol " << barcode.sequenceIndex() + 1 << " of "
+						  << barcode.sequenceSize() << " (parity/id: '" << barcode.sequenceId() << "')\n";
+			else if (barcode.sequenceSize() > 0)
+				std::cout << "Structured Append: merged result from " << barcode.sequenceSize() << " symbols (parity/id: '"
+						  << barcode.sequenceId() << "')\n";
 
-			if (result.readerInit())
+			if (barcode.readerInit())
 				std::cout << "Reader Initialisation/Programming\n";
+
+#ifdef ZXING_EXPERIMENTAL_API
+			if (cli.showSymbol && barcode.symbol().data())
+				std::cout << "Symbol:\n" << WriteBarcodeToUtf8(barcode);
+#endif
 		}
 
-		if (Size(filePaths) == 1 && !outPath.empty())
-			stbi_write_png(outPath.c_str(), image.width(), image.height(), 3, image.data(0, 0), image.rowStride());
+		if (Size(cli.filePaths) == 1 && !cli.outPath.empty())
+			stbi_write_png(cli.outPath.c_str(), image.width(), image.height(), 3, image.data(), image.rowStride());
 
 #ifdef NDEBUG
 		if (getenv("MEASURE_PERF")) {
diff --git a/example/ZXingWriter.cpp b/example/ZXingWriter.cpp
index 8258094b0a..25ec660e12 100644
--- a/example/ZXingWriter.cpp
+++ b/example/ZXingWriter.cpp
@@ -3,12 +3,15 @@
 */
 // SPDX-License-Identifier: Apache-2.0
 
-#include "BarcodeFormat.h"
+#ifdef ZXING_EXPERIMENTAL_API
+#include "WriteBarcode.h"
+#else
 #include "BitMatrix.h"
 #include "BitMatrixIO.h"
 #include "CharacterSet.h"
 #include "MultiFormatWriter.h"
-#include "ZXVersion.h"
+#endif
+#include "Version.h"
 
 #include <algorithm>
 #include <cctype>
@@ -25,17 +28,23 @@ using namespace ZXing;
 static void PrintUsage(const char* exePath)
 {
 	std::cout << "Usage: " << exePath
-			  << " [-size <width>x<height>] [-margin <margin>] [-encoding <encoding>] [-ecc <level>] <format> <text> <output>\n"
+			  << " [-size <width/height>] [-eclevel <level>] [-noqz] [-hrt] <format> <text> <output>\n"
 			  << "    -size      Size of generated image\n"
-			  << "    -margin    Margin around barcode\n"
-			  << "    -encoding  Encoding used to encode input text\n"
-			  << "    -ecc       Error correction level, [0-8]\n"
+//			  << "    -margin    Margin around barcode\n"
+//			  << "    -encoding  Encoding used to encode input text\n"
+			  << "    -eclevel   Error correction level, [0-8]\n"
 			  << "    -binary    Interpret <text> as a file name containing binary data\n"
+			  << "    -noqz      Print barcode witout quiet zone\n"
+			  << "    -hrt       Print human readable text below the barcode (if supported)\n"
 			  << "    -help      Print usage information\n"
 			  << "    -version   Print version information\n"
 			  << "\n"
 			  << "Supported formats are:\n";
+#ifdef ZXING_EXPERIMENTAL_API
+	for (auto f : BarcodeFormats::all())
+#else
 	for (auto f : BarcodeFormatsFromString("Aztec Codabar Code39 Code93 Code128 DataMatrix EAN8 EAN13 ITF PDF417 QRCode UPCA UPCE"))
+#endif
 		std::cout << "    " << ToString(f) << "\n";
 
 	std::cout << "Format can be lowercase letters, with or without '-'.\n"
@@ -54,8 +63,21 @@ static bool ParseSize(std::string str, int* width, int* height)
 	return false;
 }
 
-static bool ParseOptions(int argc, char* argv[], int* width, int* height, int* margin, CharacterSet* encoding,
-						 int* eccLevel, BarcodeFormat* format, std::string* text, std::string* filePath, bool* inputIsFile)
+struct CLI
+{
+	BarcodeFormat format;
+	int sizeHint = 0;
+	std::string input;
+	std::string outPath;
+	std::string ecLevel;
+	bool inputIsFile = false;
+	bool withHRT = false;
+	bool withQZ = true;
+	bool verbose = false;
+//	CharacterSet encoding = CharacterSet::Unknown;
+};
+
+static bool ParseOptions(int argc, char* argv[], CLI& cli)
 {
 	int nonOptArgCount = 0;
 	for (int i = 1; i < argc; ++i) {
@@ -63,24 +85,27 @@ static bool ParseOptions(int argc, char* argv[], int* width, int* height, int* m
 		if (is("-size")) {
 			if (++i == argc)
 				return false;
-			if (!ParseSize(argv[i], width, height)) {
-				std::cerr << "Invalid size specification: " << argv[i] << std::endl;
-				return false;
-			}
-		} else if (is("-margin")) {
-			if (++i == argc)
-				return false;
-			*margin = std::stoi(argv[i]);
-		} else if (is("-ecc")) {
-			if (++i == argc)
-				return false;
-			*eccLevel = std::stoi(argv[i]);
-		} else if (is("-encoding")) {
+			cli.sizeHint = std::stoi(argv[i]);
+		} else if (is("-eclevel")) {
 			if (++i == argc)
 				return false;
-			*encoding = CharacterSetFromString(argv[i]);
+			cli.ecLevel = argv[i];
+		// } else if (is("-margin")) {
+		// 	if (++i == argc)
+		// 		return false;
+		// 	cli.margin = std::stoi(argv[i]);
+		// } else if (is("-encoding")) {
+		// 	if (++i == argc)
+		// 		return false;
+		// 	cli.encoding = CharacterSetFromString(argv[i]);
 		} else if (is("-binary")) {
-			*inputIsFile = true;
+			cli.inputIsFile = true;
+		} else if (is("-hrt")) {
+			cli.withHRT = true;
+		} else if (is("-noqz")) {
+			cli.withQZ = false;
+		} else if (is("-verbose")) {
+			cli.verbose = true;
 		} else if (is("-help") || is("--help")) {
 			PrintUsage(argv[0]);
 			exit(0);
@@ -88,17 +113,17 @@ static bool ParseOptions(int argc, char* argv[], int* width, int* height, int* m
 			std::cout << "ZXingWriter " << ZXING_VERSION_STR << "\n";
 			exit(0);
 		} else if (nonOptArgCount == 0) {
-			*format = BarcodeFormatFromString(argv[i]);
-			if (*format == BarcodeFormat::None) {
+			cli.format = BarcodeFormatFromString(argv[i]);
+			if (cli.format == BarcodeFormat::None) {
 				std::cerr << "Unrecognized format: " << argv[i] << std::endl;
 				return false;
 			}
 			++nonOptArgCount;
 		} else if (nonOptArgCount == 1) {
-			*text = argv[i];
+			cli.input = argv[i];
 			++nonOptArgCount;
 		} else if (nonOptArgCount == 2) {
-			*filePath = argv[i];
+			cli.outPath = argv[i];
 			++nonOptArgCount;
 		} else {
 			return false;
@@ -118,55 +143,82 @@ static std::string GetExtension(const std::string& path)
 	return ext;
 }
 
-static std::string ReadFile(const std::string& fn)
+template <typename T = char>
+std::vector<T> ReadFile(const std::string& fn)
 {
-	std::ifstream ifs(fn, std::ios::binary);
-	return ifs ? std::string(std::istreambuf_iterator<char>(ifs), std::istreambuf_iterator<char>()) : std::string();
+	std::basic_ifstream<T> ifs(fn, std::ios::binary);
+	if (!ifs.good())
+		throw std::runtime_error("failed to open/read file " + fn);
+	return ifs ? std::vector(std::istreambuf_iterator<T>(ifs), std::istreambuf_iterator<T>()) : std::vector<T>();
 };
 
 int main(int argc, char* argv[])
 {
-	int width = 100, height = 100;
-	int margin = 10;
-	int eccLevel = -1;
-	bool inputIsFile = false;
-	CharacterSet encoding = CharacterSet::Unknown;
-	std::string input, filePath;
-	BarcodeFormat format;
+	CLI cli;
 
-	if (!ParseOptions(argc, argv, &width, &height, &margin, &encoding, &eccLevel, &format, &input, &filePath, &inputIsFile)) {
+	if (!ParseOptions(argc, argv, cli)) {
 		PrintUsage(argv[0]);
 		return -1;
 	}
 
 	try {
-		auto writer = MultiFormatWriter(format).setMargin(margin).setEncoding(encoding).setEccLevel(eccLevel);
+#ifdef ZXING_EXPERIMENTAL_API
+		auto cOpts = CreatorOptions(cli.format).ecLevel(cli.ecLevel);
+		auto barcode = cli.inputIsFile ? CreateBarcodeFromBytes(ReadFile(cli.input), cOpts) : CreateBarcodeFromText(cli.input, cOpts);
+
+		auto wOpts = WriterOptions().sizeHint(cli.sizeHint).withQuietZones(cli.withQZ).withHRT(cli.withHRT).rotate(0);
+		auto bitmap = WriteBarcodeToImage(barcode, wOpts);
+
+		if (cli.verbose) {
+			std::cout << "Text:       \"" << barcode.text() << "\"\n"
+					  << "Bytes:      " << ToHex(barcode.bytes()) << "\n"
+					  << "Format:     " << ToString(barcode.format()) << "\n"
+					  << "Identifier: " << barcode.symbologyIdentifier() << "\n"
+					  << "Content:    " << ToString(barcode.contentType()) << "\n"
+					  << "HasECI:     " << barcode.hasECI() << "\n"
+					  << "Position:   " << ToString(barcode.position()) << "\n"
+					  << "Rotation:   " << barcode.orientation() << " deg\n"
+					  << "IsMirrored: " << barcode.isMirrored() << "\n"
+					  << "IsInverted: " << barcode.isInverted() << "\n"
+					  << "ecLevel:    " << barcode.ecLevel() << "\n";
+			std::cout << WriteBarcodeToUtf8(barcode);
+		}
+#else
+		auto writer = MultiFormatWriter(cli.format).setMargin(cli.withQZ ? 10 : 0);
+		if (!cli.ecLevel.empty())
+			writer.setEccLevel(std::stoi(cli.ecLevel));
 
 		BitMatrix matrix;
-		if (inputIsFile) {
-			auto file = ReadFile(input);
+		if (cli.inputIsFile) {
+			auto file = ReadFile(cli.input);
 			std::wstring bytes;
 			for (uint8_t c : file)
 				bytes.push_back(c);
 			writer.setEncoding(CharacterSet::BINARY);
-			matrix = writer.encode(bytes, width, height);
+			matrix = writer.encode(bytes, cli.sizeHint, std::clamp(cli.sizeHint / 2, 50, 300));
 		} else {
-			matrix = writer.encode(input, width, height);
+			writer.setEncoding(CharacterSet::UTF8);
+			matrix = writer.encode(cli.input, cli.sizeHint, std::clamp(cli.sizeHint / 2, 50, 300));
 		}
 		auto bitmap = ToMatrix<uint8_t>(matrix);
+#endif
 
-		auto ext = GetExtension(filePath);
+		auto ext = GetExtension(cli.outPath);
 		int success = 0;
 		if (ext == "" || ext == "png") {
-			success = stbi_write_png(filePath.c_str(), bitmap.width(), bitmap.height(), 1, bitmap.data(), 0);
+			success = stbi_write_png(cli.outPath.c_str(), bitmap.width(), bitmap.height(), 1, bitmap.data(), 0);
 		} else if (ext == "jpg" || ext == "jpeg") {
-			success = stbi_write_jpg(filePath.c_str(), bitmap.width(), bitmap.height(), 1, bitmap.data(), 0);
+			success = stbi_write_jpg(cli.outPath.c_str(), bitmap.width(), bitmap.height(), 1, bitmap.data(), 0);
 		} else if (ext == "svg") {
-			success = (std::ofstream(filePath) << ToSVG(matrix)).good();
+#ifdef ZXING_EXPERIMENTAL_API
+			success = (std::ofstream(cli.outPath) << WriteBarcodeToSVG(barcode, wOpts)).good();
+#else
+			success = (std::ofstream(cli.outPath) << ToSVG(matrix)).good();
+#endif
 		}
 
 		if (!success) {
-			std::cerr << "Failed to write image: " << filePath << std::endl;
+			std::cerr << "Failed to write image: " << cli.outPath << std::endl;
 			return -1;
 		}
 	} catch (const std::exception& e) {
diff --git a/test/blackbox/BlackboxTestRunner.cpp b/test/blackbox/BlackboxTestRunner.cpp
index 7dd5234333..94bd072750 100644
--- a/test/blackbox/BlackboxTestRunner.cpp
+++ b/test/blackbox/BlackboxTestRunner.cpp
@@ -57,39 +57,39 @@ namespace {
 	};
 }
 
-// Helper for `compareResult()` - map `key` to Result property, converting value to std::string
-static std::string getResultValue(const Result& result, const std::string& key)
+// Helper for `compareResult()` - map `key` to Barcode property, converting value to std::string
+static std::string getBarcodeValue(const Barcode& barcode, const std::string& key)
 {
 	if (key == "contentType")
-		return ToString(result.contentType());
+		return ToString(barcode.contentType());
 	if (key == "ecLevel")
-		return result.ecLevel();
+		return barcode.ecLevel();
 	if (key == "orientation")
-		return std::to_string(result.orientation());
+		return std::to_string(barcode.orientation());
 	if (key == "symbologyIdentifier")
-		return result.symbologyIdentifier();
+		return barcode.symbologyIdentifier();
 	if (key == "sequenceSize")
-		return std::to_string(result.sequenceSize());
+		return std::to_string(barcode.sequenceSize());
 	if (key == "sequenceIndex")
-		return std::to_string(result.sequenceIndex());
+		return std::to_string(barcode.sequenceIndex());
 	if (key == "sequenceId")
-		return result.sequenceId();
+		return barcode.sequenceId();
 	if (key == "isLastInSequence")
-		return result.isLastInSequence() ? "true" : "false";
+		return barcode.isLastInSequence() ? "true" : "false";
 	if (key == "isPartOfSequence")
-		return result.isPartOfSequence() ? "true" : "false";
+		return barcode.isPartOfSequence() ? "true" : "false";
 	if (key == "isMirrored")
-		return result.isMirrored() ? "true" : "false";
+		return barcode.isMirrored() ? "true" : "false";
 	if (key == "isInverted")
-		return result.isInverted() ? "true" : "false";
+		return barcode.isInverted() ? "true" : "false";
 	if (key == "readerInit")
-		return result.readerInit() ? "true" : "false";
+		return barcode.readerInit() ? "true" : "false";
 
 	return fmt::format("***Unknown key '{}'***", key);
 }
 
 // Read ".result.txt" file contents `expected` with lines "key=value" and compare to `actual`
-static bool compareResult(const Result& result, const std::string& expected, std::string& actual)
+static bool compareResult(const Barcode& barcode, const std::string& expected, std::string& actual)
 {
 	bool ret = true;
 
@@ -108,7 +108,7 @@ static bool compareResult(const Result& result, const std::string& expected, std
 		}
 		std::string key = expectedLine.substr(0, equals);
 		std::string expectedValue = expectedLine.substr(equals + 1);
-		std::string actualValue = getResultValue(result, key);
+		std::string actualValue = getBarcodeValue(barcode, key);
 		if (actualValue != expectedValue) {
 			ret = false;
 			actualValue += " ***Mismatch***";
@@ -118,9 +118,9 @@ static bool compareResult(const Result& result, const std::string& expected, std
 	return ret;
 }
 
-static std::string checkResult(const fs::path& imgPath, std::string_view expectedFormat, const Result& result)
+static std::string checkResult(const fs::path& imgPath, std::string_view expectedFormat, const Barcode& barcode)
 {
-	if (auto format = ToString(result.format()); expectedFormat != format)
+	if (auto format = ToString(barcode.format()); expectedFormat != format)
 		return fmt::format("Format mismatch: expected '{}' but got '{}'", expectedFormat, format);
 
 	auto readFile = [imgPath](const char* ending) {
@@ -130,20 +130,20 @@ static std::string checkResult(const fs::path& imgPath, std::string_view expecte
 
 	if (auto expected = readFile(".result.txt")) {
 		std::string actual;
-		if (!compareResult(result, *expected, actual))
+		if (!compareResult(barcode, *expected, actual))
 			return fmt::format("Result mismatch: expected\n{} but got\n{}", *expected, actual);
 	}
 
 	if (auto expected = readFile(".txt")) {
 		expected = EscapeNonGraphical(*expected);
-		auto utf8Result = result.text(TextMode::Escaped);
+		auto utf8Result = barcode.text(TextMode::Escaped);
 		return utf8Result != *expected ? fmt::format("Content mismatch: expected '{}' but got '{}'", *expected, utf8Result) : "";
 	}
 
 	if (auto expected = readFile(".bin")) {
 		ByteArray binaryExpected(*expected);
-		return result.bytes() != binaryExpected
-				   ? fmt::format("Content mismatch: expected '{}' but got '{}'", ToHex(binaryExpected), ToHex(result.bytes()))
+		return barcode.bytes() != binaryExpected
+				   ? fmt::format("Content mismatch: expected '{}' but got '{}'", ToHex(binaryExpected), ToHex(barcode.bytes()))
 				   : "";
 	}
 
@@ -238,9 +238,9 @@ static void doRunTests(const fs::path& directory, std::string_view format, int t
 			if (opts.isPure())
 				opts.setBinarizer(Binarizer::FixedThreshold);
 			for (const auto& imgPath : imgPaths) {
-				auto result = ReadBarcode(ImageLoader::load(imgPath).rotated(test.rotation), opts);
-				if (result.isValid()) {
-					auto error = checkResult(imgPath, format, result);
+				auto barcode = ReadBarcode(ImageLoader::load(imgPath).rotated(test.rotation), opts);
+				if (barcode.isValid()) {
+					auto error = checkResult(imgPath, format, barcode);
 					if (!error.empty())
 						tc.misReadFiles[imgPath] = error;
 				} else {
@@ -257,16 +257,16 @@ static void doRunTests(const fs::path& directory, std::string_view format, int t
 	}
 }
 
-static Result readMultiple(const std::vector<fs::path>& imgPaths, std::string_view format)
+static Barcode readMultiple(const std::vector<fs::path>& imgPaths, std::string_view format)
 {
-	Results allResults;
+	Barcodes allBarcodes;
 	for (const auto& imgPath : imgPaths) {
-		auto results = ReadBarcodes(ImageLoader::load(imgPath),
-									ReaderOptions().setFormats(BarcodeFormatFromString(format)).setTryDownscale(false));
-		allResults.insert(allResults.end(), results.begin(), results.end());
+		auto barcodes = ReadBarcodes(ImageLoader::load(imgPath),
+									 ReaderOptions().setFormats(BarcodeFormatFromString(format)).setTryDownscale(false));
+		allBarcodes.insert(allBarcodes.end(), barcodes.begin(), barcodes.end());
 	}
 
-	return MergeStructuredAppendSequence(allResults);
+	return MergeStructuredAppendSequence(allBarcodes);
 }
 
 static void doRunStructuredAppendTest(const fs::path& directory, std::string_view format, int totalTests,
@@ -292,9 +292,9 @@ static void doRunStructuredAppendTest(const fs::path& directory, std::string_vie
 		auto startTime = std::chrono::steady_clock::now();
 
 		for (const auto& [testPath, testImgPaths] : imageGroups) {
-			auto result = readMultiple(testImgPaths, format);
-			if (result.isValid()) {
-				auto error = checkResult(testPath, format, result);
+			auto barcode = readMultiple(testImgPaths, format);
+			if (barcode.isValid()) {
+				auto error = checkResult(testPath, format, barcode);
 				if (!error.empty())
 					tc.misReadFiles[testPath] = error;
 			} else {
@@ -334,12 +334,16 @@ int runBlackBoxTests(const fs::path& testPathPrefix, const std::set<std::string>
 		auto startTime = std::chrono::steady_clock::now();
 
 		// clang-format off
-		runTests("aztec-1", "Aztec", 27, {
-			{ 26, 27, 0   },
-			{ 26, 27, 90  },
-			{ 26, 27, 180 },
-			{ 26, 27, 270 },
-			{ 25, 0, pure },
+
+		// Expected failures:
+		// abc-inverted.png (fast) - fast does not try inverted
+		// az-thick.png (pure)
+		runTests("aztec-1", "Aztec", 31, {
+			{ 30, 31, 0   },
+			{ 30, 31, 90  },
+			{ 30, 31, 180 },
+			{ 30, 31, 270 },
+			{ 29, 0, pure },
 		});
 
 		runTests("aztec-2", "Aztec", 22, {
@@ -364,11 +368,11 @@ int runBlackBoxTests(const fs::path& testPathPrefix, const std::set<std::string>
 			{  0, 13, 270 },
 		});
 
-		runTests("datamatrix-3", "DataMatrix", 20, {
-			{ 19, 20, 0   },
-			{  0, 20, 90  },
-			{  0, 20, 180 },
-			{  0, 20, 270 },
+		runTests("datamatrix-3", "DataMatrix", 21, {
+			{ 20, 21, 0   },
+			{  0, 21, 90  },
+			{  0, 21, 180 },
+			{  0, 21, 270 },
 		});
 
 		runTests("datamatrix-4", "DataMatrix", 21, {
@@ -379,6 +383,11 @@ int runBlackBoxTests(const fs::path& testPathPrefix, const std::set<std::string>
 			{ 19, 0, pure },
 		});
 
+		runTests("dxfilmedge-1", "DXFilmEdge", 3, {
+			{ 1, 3, 0 },
+			{ 0, 3, 180 },
+		});
+
 		runTests("codabar-1", "Codabar", 11, {
 			{ 11, 11, 0   },
 			{ 11, 11, 180 },
@@ -397,7 +406,7 @@ int runBlackBoxTests(const fs::path& testPathPrefix, const std::set<std::string>
 		runTests("code39-2", "Code39", 2, {
 			{ 2, 2, 0   },
 			{ 2, 2, 180 },
-		}, ReaderOptions().setTryCode39ExtendedMode(true));
+		});
 
 		runTests("code39-3", "Code39", 12, {
 			{ 12, 12, 0   },
@@ -424,10 +433,10 @@ int runBlackBoxTests(const fs::path& testPathPrefix, const std::set<std::string>
 			{ 2, 2, 180 },
 		});
 
-		runTests("ean8-1", "EAN-8", 8, {
-			{ 8, 8, 0   },
-			{ 8, 8, 180 },
-			{ 7, 0, pure },
+		runTests("ean8-1", "EAN-8", 9, {
+			{ 9, 9, 0   },
+			{ 9, 9, 180 },
+			{ 8, 0, pure },
 		});
 
 		runTests("ean13-1", "EAN-13", 32, {
@@ -447,7 +456,7 @@ int runBlackBoxTests(const fs::path& testPathPrefix, const std::set<std::string>
 
 		runTests("ean13-4", "EAN-13", 22, {
 			{ 6, 13, 0   },
-			{ 8, 13, 180 },
+			{ 7, 13, 180 },
 		});
 
 		runTests("ean13-extension-1", "EAN-13", 5, {
@@ -455,9 +464,9 @@ int runBlackBoxTests(const fs::path& testPathPrefix, const std::set<std::string>
 			{ 3, 5, 180 },
 		}, ReaderOptions().setEanAddOnSymbol(EanAddOnSymbol::Require));
 
-		runTests("itf-1", "ITF", 11, {
-			{ 10, 11, 0   },
-			{ 10, 11, 180 },
+		runTests("itf-1", "ITF", 14, {
+			{ 13, 14, 0   },
+			{ 13, 14, 180 },
 		});
 
 		runTests("itf-2", "ITF", 6, {
@@ -474,27 +483,27 @@ int runBlackBoxTests(const fs::path& testPathPrefix, const std::set<std::string>
 		});
 
 		runTests("upca-1", "UPC-A", 12, {
-			{  9, 12, 0   },
+			{ 10, 12, 0   },
 			{ 11, 12, 180 },
 		});
 
 		runTests("upca-2", "UPC-A", 36, {
 			{ 17, 22, 0   },
-			{ 16, 22, 180 },
+			{ 17, 22, 180 },
 		});
 
 		runTests("upca-3", "UPC-A", 21, {
-			{ 7, 10, 0   },
-			{ 8, 10, 180 },
+			{ 7, 11, 0   },
+			{ 8, 11, 180 },
 		});
 
 		runTests("upca-4", "UPC-A", 19, {
-			{ 8, 12, 0   },
-			{ 9, 12, 180 },
+			{ 8, 12, 0, 1, 0 },
+			{ 9, 12, 0, 1, 180 },
 		});
 
 		runTests("upca-5", "UPC-A", 32, {
-			{ 17, 20, 0   },
+			{ 18, 20, 0   },
 			{ 18, 20, 180 },
 		});
 
@@ -510,8 +519,8 @@ int runBlackBoxTests(const fs::path& testPathPrefix, const std::set<std::string>
 		});
 
 		runTests("upce-2", "UPC-E", 28, {
-			{ 17, 22, 0, 1, 0   },
-			{ 20, 22, 1, 1, 180 },
+			{ 18, 22, 0, 1, 0   },
+			{ 19, 22, 1, 1, 180 },
 		});
 
 		runTests("upce-3", "UPC-E", 11, {
@@ -524,9 +533,9 @@ int runBlackBoxTests(const fs::path& testPathPrefix, const std::set<std::string>
 			{ 6, 6, 180 },
 		});
 
-		runTests("rss14-2", "DataBar", 16, {
-			{ 8, 10, 0   },
-			{ 9, 10, 180 },
+		runTests("rss14-2", "DataBar", 14, {
+			{ 10, 11, 0   },
+			{ 10, 11, 180 },
 		});
 
 		runTests("rssexpanded-1", "DataBarExpanded", 34, {
@@ -557,6 +566,12 @@ int runBlackBoxTests(const fs::path& testPathPrefix, const std::set<std::string>
 			{ 2, 2, 180 },
 		});
 
+		runTests("databarltd-1", "DataBarLimited", 2, {
+			{ 2, 2, 0   },
+			{ 2, 2, 180 },
+			{ 2, 0, pure },
+		});
+
 		runTests("qrcode-1", "QRCode", 16, {
 			{ 16, 16, 0   },
 			{ 16, 16, 90  },
@@ -564,11 +579,11 @@ int runBlackBoxTests(const fs::path& testPathPrefix, const std::set<std::string>
 			{ 16, 16, 270 },
 		});
 
-		runTests("qrcode-2", "QRCode", 50, {
-			{ 46, 48, 0   },
-			{ 46, 48, 90  },
-			{ 46, 48, 180 },
-			{ 46, 48, 270 },
+		runTests("qrcode-2", "QRCode", 51, {
+			{ 45, 48, 0   },
+			{ 45, 48, 90  },
+			{ 45, 48, 180 },
+			{ 45, 48, 270 },
 			{ 22, 1, pure }, // the misread is the 'outer' symbol in 16.png
 		});
 
@@ -576,14 +591,14 @@ int runBlackBoxTests(const fs::path& testPathPrefix, const std::set<std::string>
 			{ 28, 28, 0   },
 			{ 28, 28, 90  },
 			{ 28, 28, 180 },
-			{ 27, 27, 270 },
+			{ 28, 28, 270 },
 		});
 
 		runTests("qrcode-4", "QRCode", 41, {
-			{ 29, 29, 0   },
-			{ 29, 29, 90  },
-			{ 29, 29, 180 },
-			{ 29, 29, 270 },
+			{ 31, 31, 0   },
+			{ 31, 31, 90  },
+			{ 31, 31, 180 },
+			{ 31, 31, 270 },
 		});
 
 		runTests("qrcode-5", "QRCode", 16, {
@@ -607,8 +622,8 @@ int runBlackBoxTests(const fs::path& testPathPrefix, const std::set<std::string>
 
 		runTests("microqrcode-1", "MicroQRCode", 16, {
 			{ 15, 15, 0   },
-			{ 15, 15, 90  },
-			{ 15, 15, 180 },
+			{ 14, 14, 90  },
+			{ 14, 14, 180 }, // ughs: 1 result is platform/compiler dependent (e.g. -march=core2 vs. haswell)
 			{ 15, 15, 270 },
 			{ 9, 0, pure },
 		});
diff --git a/test/blackbox/CMakeLists.txt b/test/blackbox/CMakeLists.txt
index b4badb6319..fa1c6225ca 100644
--- a/test/blackbox/CMakeLists.txt
+++ b/test/blackbox/CMakeLists.txt
@@ -1,7 +1,7 @@
 zxing_add_package_stb()
-zxing_add_package(fmt fmtlib https://github.com/fmtlib/fmt.git 10.0.0)
+zxing_add_package(fmt fmtlib https://github.com/fmtlib/fmt.git 11.1.1)
 
-if (BUILD_READERS)
+if (ZXING_READERS)
     add_executable (ReaderTest
         TestReaderMain.cpp
         ImageLoader.h
@@ -19,7 +19,7 @@ if (BUILD_READERS)
     add_test(NAME ReaderTest COMMAND ReaderTest ${CMAKE_CURRENT_SOURCE_DIR}/../samples)
 endif()
 
-if (BUILD_WRITERS)
+if (ZXING_WRITERS)
     add_executable (WriterTest TestWriterMain.cpp)
 
     target_link_libraries (WriterTest ZXing::ZXing stb::stb)
diff --git a/test/blackbox/ImageLoader.cpp b/test/blackbox/ImageLoader.cpp
index 1f1f073421..ca04196064 100644
--- a/test/blackbox/ImageLoader.cpp
+++ b/test/blackbox/ImageLoader.cpp
@@ -9,6 +9,7 @@
 #include "BinaryBitmap.h"
 #include "ImageView.h"
 
+#include <array>
 #include <map>
 #include <memory>
 #include <stdexcept>
@@ -23,22 +24,25 @@ class STBImage : public ImageView
 	std::unique_ptr<stbi_uc[], void (*)(void*)> _memory;
 
 public:
-	STBImage() : ImageView(nullptr, 0, 0, ImageFormat::None), _memory(nullptr, stbi_image_free) {}
+	STBImage() : ImageView(), _memory(nullptr, stbi_image_free) {}
 
 	void load(const fs::path& imgPath)
 	{
-		int width, height, colors;
-		_memory.reset(stbi_load(imgPath.string().c_str(), &width, &height, &colors, 3));
+		int width, height, channels;
+		_memory.reset(stbi_load(imgPath.string().c_str(), &width, &height, &channels, 0));
 		if (_memory == nullptr)
-			throw std::runtime_error("Failed to read image");
-#if 1
-		auto* img = _memory.get();
-		for (int i = 0; i < width * height; ++i )
-			img[i] = RGBToLum(img[3 * i + 0], img[3 * i + 1], img[3 * i + 2]);
-		ImageView::operator=({_memory.get(), width, height, ImageFormat::Lum});
-#else
-		ImageView::operator=({_memory.get(), width, height, ImageFormat::RGB});
-#endif
+			throw std::runtime_error("Failed to read image: " + imgPath.string() + " (" + stbi_failure_reason() + ")");
+
+		auto ImageFormatFromChannels = std::array{ImageFormat::None, ImageFormat::Lum, ImageFormat::LumA, ImageFormat::RGB, ImageFormat::RGBA};
+		ImageView::operator=({_memory.get(), width, height, ImageFormatFromChannels.at(channels)});
+
+		// preconvert from RGB -> Lum to do this only once instead of for each rotation
+		if (_format == ImageFormat::RGB) {
+			auto* img = _memory.get();
+			for (int i = 0; i < width * height; ++i)
+				img[i] = RGBToLum(img[3 * i + 0], img[3 * i + 1], img[3 * i + 2]);
+			ImageView::operator=({_memory.get(), width, height, ImageFormat::Lum});
+		}
 	}
 
 	operator bool() const { return _data; }
diff --git a/test/blackbox/TestReaderMain.cpp b/test/blackbox/TestReaderMain.cpp
index 5a69c6143c..9e3ec8d3e5 100644
--- a/test/blackbox/TestReaderMain.cpp
+++ b/test/blackbox/TestReaderMain.cpp
@@ -8,7 +8,6 @@
 #include "ImageLoader.h"
 #include "ReadBarcode.h"
 #include "ZXAlgorithms.h"
-#include "ZXFilesystem.h"
 
 #include <cstdlib>
 #include <cstring>
@@ -41,15 +40,15 @@ int main(int argc, char** argv)
 		int rotation = getEnv("ROTATION");
 
 		for (int i = 1; i < argc; ++i) {
-			Result result = ReadBarcode(ImageLoader::load(argv[i]).rotated(rotation), opts);
+			Barcode barcode = ReadBarcode(ImageLoader::load(argv[i]).rotated(rotation), opts);
 			std::cout << argv[i] << ": ";
-			if (result.isValid())
-				std::cout << ToString(result.format()) << ": " << result.text() << "\n";
+			if (barcode.isValid())
+				std::cout << ToString(barcode.format()) << ": " << barcode.text() << "\n";
 			else
 				std::cout << "FAILED\n";
-			if (result.isValid() && getenv("WRITE_TEXT")) {
+			if (barcode.isValid() && getenv("WRITE_TEXT")) {
 				std::ofstream f(fs::path(argv[i]).replace_extension(".txt"));
-				f << result.text();
+				f << barcode.text();
 			}
 		}
 		return 0;
diff --git a/test/blackbox/TestWriterMain.cpp b/test/blackbox/TestWriterMain.cpp
index 420f0bf6ca..78c6ee0b9e 100644
--- a/test/blackbox/TestWriterMain.cpp
+++ b/test/blackbox/TestWriterMain.cpp
@@ -5,7 +5,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "BitMatrix.h"
+#ifdef ZXING_EXPERIMENTAL_API
+#include "WriteBarcode.h"
+#else
 #include "MultiFormatWriter.h"
+#endif
 
 #include <vector>
 
@@ -15,11 +19,18 @@ using namespace std::literals;
 #define STB_IMAGE_WRITE_IMPLEMENTATION
 #include <stb_image_write.h>
 
+#ifdef ZXING_EXPERIMENTAL_API
+void savePng(ImageView iv, BarcodeFormat format)
+{
+	stbi_write_png((ToString(format) + ".png"s).c_str(), iv.width(), iv.height(), iv.pixStride(), iv.data(), iv.rowStride());
+}
+#else
 void savePng(const BitMatrix& matrix, BarcodeFormat format)
 {
 	auto bitmap = ToMatrix<uint8_t>(matrix);
 	stbi_write_png((ToString(format) + ".png"s).c_str(), bitmap.width(), bitmap.height(), 1, bitmap.data(), 0);
 }
+#endif
 
 int main()
 {
@@ -30,13 +41,17 @@ int main()
 		BarcodeFormat::PDF417,
 		BarcodeFormat::QRCode })
 	{
+#ifdef ZXING_EXPERIMENTAL_API
+		savePng(CreateBarcodeFromText(text, format).symbol(), format);
+#else
 		savePng(MultiFormatWriter(format).encode(text, 200, 200), format);
+#endif
 	}
 
 	text = "012345678901234567890123456789";
 	using FormatSpecs = std::vector<std::pair<BarcodeFormat, size_t>>;
 	for (const auto& [format, length] : FormatSpecs({
-		{BarcodeFormat::Codabar, 0},
+//		{BarcodeFormat::Codabar, 0},
 		{BarcodeFormat::Code39, 0},
 		{BarcodeFormat::Code93, 0},
 		{BarcodeFormat::Code128, 0},
@@ -47,6 +62,10 @@ int main()
 		{BarcodeFormat::UPCE, 7} }))
 	{
 		auto input = length > 0 ? text.substr(0, length) : text;
+#ifdef ZXING_EXPERIMENTAL_API
+		savePng(CreateBarcodeFromText(input, format).symbol(), format);
+#else
 		savePng(MultiFormatWriter(format).encode(input, 100, 100), format);
+#endif
 	}
 }
diff --git a/test/fuzz/CMakeLists.txt b/test/fuzz/CMakeLists.txt
index a5202f19a5..2c5d0db406 100644
--- a/test/fuzz/CMakeLists.txt
+++ b/test/fuzz/CMakeLists.txt
@@ -8,8 +8,8 @@ project (ZXingFuzz)
 set (CMAKE_CXX_STANDARD 20)
 set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -march=native -fsanitize=address,fuzzer")
 
-set (BUILD_WRITERS ON)
-set (BUILD_READERS ON)
+set (ZXING_WRITERS OLD)
+set (ZXING_READERS ON)
 
 add_definitions (-DZXING_BUILD_FOR_TEST)
 add_subdirectory (${CMAKE_CURRENT_SOURCE_DIR}/../../core ${CMAKE_BINARY_DIR}/ZXing)
diff --git a/test/fuzz/fuzzReadLinear.cpp b/test/fuzz/fuzzReadLinear.cpp
index 6f05c9d1c8..2ce0c4d44e 100644
--- a/test/fuzz/fuzzReadLinear.cpp
+++ b/test/fuzz/fuzzReadLinear.cpp
@@ -12,10 +12,11 @@
 #include "oned/ODCode128Reader.h"
 #include "oned/ODDataBarReader.h"
 #include "oned/ODDataBarExpandedReader.h"
+#include "oned/ODDXFilmEdgeReader.h"
 #include "oned/ODITFReader.h"
 #include "oned/ODCodabarReader.h"
 #include "ReaderOptions.h"
-#include "Result.h"
+#include "Barcode.h"
 
 using namespace ZXing;
 using namespace ZXing::OneD;
@@ -34,6 +35,7 @@ bool init()
 	readers.emplace_back(new CodabarReader(opts));
 	readers.emplace_back(new DataBarReader(opts));
 	readers.emplace_back(new DataBarExpandedReader(opts));
+	readers.emplace_back(new DXFilmEdgeReader(opts));
 	return true;
 }
 
diff --git a/test/samples/README b/test/samples/README
deleted file mode 100644
index 387f12d40c..0000000000
--- a/test/samples/README
+++ /dev/null
@@ -1 +0,0 @@
-Thanks to Enrique G-S for contributing many of the EAN-13 test images.
\ No newline at end of file
diff --git a/test/samples/aztec-1/rune-1.png b/test/samples/aztec-1/rune-1.png
new file mode 100644
index 0000000000..3fbb06cd88
Binary files /dev/null and b/test/samples/aztec-1/rune-1.png differ
diff --git a/test/samples/aztec-1/rune-1.result.txt b/test/samples/aztec-1/rune-1.result.txt
new file mode 100644
index 0000000000..2be1501c62
--- /dev/null
+++ b/test/samples/aztec-1/rune-1.result.txt
@@ -0,0 +1 @@
+symbologyIdentifier=]zC
\ No newline at end of file
diff --git a/test/samples/aztec-1/rune-1.txt b/test/samples/aztec-1/rune-1.txt
new file mode 100644
index 0000000000..0f3016682b
--- /dev/null
+++ b/test/samples/aztec-1/rune-1.txt
@@ -0,0 +1 @@
+001
\ No newline at end of file
diff --git a/test/samples/aztec-1/rune-223.png b/test/samples/aztec-1/rune-223.png
new file mode 100644
index 0000000000..784a0649c3
Binary files /dev/null and b/test/samples/aztec-1/rune-223.png differ
diff --git a/test/samples/aztec-1/rune-223.txt b/test/samples/aztec-1/rune-223.txt
new file mode 100644
index 0000000000..fca7fbef0e
--- /dev/null
+++ b/test/samples/aztec-1/rune-223.txt
@@ -0,0 +1 @@
+223
\ No newline at end of file
diff --git a/test/samples/aztec-1/rune-64.png b/test/samples/aztec-1/rune-64.png
new file mode 100644
index 0000000000..725929e449
Binary files /dev/null and b/test/samples/aztec-1/rune-64.png differ
diff --git a/test/samples/aztec-1/rune-64.txt b/test/samples/aztec-1/rune-64.txt
new file mode 100644
index 0000000000..06b7423029
--- /dev/null
+++ b/test/samples/aztec-1/rune-64.txt
@@ -0,0 +1 @@
+064
\ No newline at end of file
diff --git a/test/samples/aztec-1/rune-68.png b/test/samples/aztec-1/rune-68.png
new file mode 100644
index 0000000000..bb7086941f
Binary files /dev/null and b/test/samples/aztec-1/rune-68.png differ
diff --git a/test/samples/aztec-1/rune-68.txt b/test/samples/aztec-1/rune-68.txt
new file mode 100644
index 0000000000..9c93a7313c
--- /dev/null
+++ b/test/samples/aztec-1/rune-68.txt
@@ -0,0 +1 @@
+068
\ No newline at end of file
diff --git a/test/samples/codabar-1/01.txt b/test/samples/codabar-1/01.txt
index 6a537b5b36..e0a295b4cd 100644
--- a/test/samples/codabar-1/01.txt
+++ b/test/samples/codabar-1/01.txt
@@ -1 +1 @@
-1234567890
\ No newline at end of file
+A1234567890A
\ No newline at end of file
diff --git a/test/samples/codabar-1/02.txt b/test/samples/codabar-1/02.txt
index 6a537b5b36..e0a295b4cd 100644
--- a/test/samples/codabar-1/02.txt
+++ b/test/samples/codabar-1/02.txt
@@ -1 +1 @@
-1234567890
\ No newline at end of file
+A1234567890A
\ No newline at end of file
diff --git a/test/samples/codabar-1/03.txt b/test/samples/codabar-1/03.txt
index b8ec6e4ecb..bd6d644978 100644
--- a/test/samples/codabar-1/03.txt
+++ b/test/samples/codabar-1/03.txt
@@ -1 +1 @@
-294/586
\ No newline at end of file
+A294/586B
\ No newline at end of file
diff --git a/test/samples/codabar-1/04.txt b/test/samples/codabar-1/04.txt
index cf537db50e..3cca605e35 100644
--- a/test/samples/codabar-1/04.txt
+++ b/test/samples/codabar-1/04.txt
@@ -1 +1 @@
-123455
\ No newline at end of file
+A123455C
\ No newline at end of file
diff --git a/test/samples/codabar-1/09.txt b/test/samples/codabar-1/09.txt
index bd41cba781..8b064ef3eb 100644
--- a/test/samples/codabar-1/09.txt
+++ b/test/samples/codabar-1/09.txt
@@ -1 +1 @@
-12345
\ No newline at end of file
+A12345A
\ No newline at end of file
diff --git a/test/samples/codabar-1/10.txt b/test/samples/codabar-1/10.txt
index 4632e068d5..01ceaa7705 100644
--- a/test/samples/codabar-1/10.txt
+++ b/test/samples/codabar-1/10.txt
@@ -1 +1 @@
-123456
\ No newline at end of file
+A123456A
\ No newline at end of file
diff --git a/test/samples/codabar-1/11.txt b/test/samples/codabar-1/11.txt
index 675525a78d..3b0f5365b5 100644
--- a/test/samples/codabar-1/11.txt
+++ b/test/samples/codabar-1/11.txt
@@ -1 +1 @@
-3419500
\ No newline at end of file
+A3419500A
\ No newline at end of file
diff --git a/test/samples/codabar-1/12.txt b/test/samples/codabar-1/12.txt
index 8782ad7969..7a517b46dd 100644
--- a/test/samples/codabar-1/12.txt
+++ b/test/samples/codabar-1/12.txt
@@ -1 +1 @@
-31117013206375
\ No newline at end of file
+A31117013206375B
\ No newline at end of file
diff --git a/test/samples/codabar-1/13.txt b/test/samples/codabar-1/13.txt
index bd41cba781..872b3c4b62 100644
--- a/test/samples/codabar-1/13.txt
+++ b/test/samples/codabar-1/13.txt
@@ -1 +1 @@
-12345
\ No newline at end of file
+A12345B
\ No newline at end of file
diff --git a/test/samples/codabar-1/14.txt b/test/samples/codabar-1/14.txt
index 8782ad7969..8e8259ef91 100644
--- a/test/samples/codabar-1/14.txt
+++ b/test/samples/codabar-1/14.txt
@@ -1 +1 @@
-31117013206375
\ No newline at end of file
+A31117013206375A
\ No newline at end of file
diff --git a/test/samples/codabar-1/15.txt b/test/samples/codabar-1/15.txt
index 4d38188ff3..745114b8d1 100644
--- a/test/samples/codabar-1/15.txt
+++ b/test/samples/codabar-1/15.txt
@@ -1 +1 @@
-123456789012
\ No newline at end of file
+A123456789012A
\ No newline at end of file
diff --git a/test/samples/codabar-2/01.txt b/test/samples/codabar-2/01.txt
index a9dbc2e2b4..df315db396 100644
--- a/test/samples/codabar-2/01.txt
+++ b/test/samples/codabar-2/01.txt
@@ -1 +1 @@
-80125178+
\ No newline at end of file
+A80125178+B
\ No newline at end of file
diff --git a/test/samples/codabar-2/02.txt b/test/samples/codabar-2/02.txt
index a9dbc2e2b4..df315db396 100644
--- a/test/samples/codabar-2/02.txt
+++ b/test/samples/codabar-2/02.txt
@@ -1 +1 @@
-80125178+
\ No newline at end of file
+A80125178+B
\ No newline at end of file
diff --git a/test/samples/codabar-2/03.txt b/test/samples/codabar-2/03.txt
index f19eb7e7bc..cb586b0492 100644
--- a/test/samples/codabar-2/03.txt
+++ b/test/samples/codabar-2/03.txt
@@ -1 +1 @@
-0944416895273
\ No newline at end of file
+A0944416895273A
\ No newline at end of file
diff --git a/test/samples/databarltd-1/00.png b/test/samples/databarltd-1/00.png
new file mode 100644
index 0000000000..4247d7f7cb
Binary files /dev/null and b/test/samples/databarltd-1/00.png differ
diff --git a/test/samples/databarltd-1/00.txt b/test/samples/databarltd-1/00.txt
new file mode 100644
index 0000000000..1879fa375c
--- /dev/null
+++ b/test/samples/databarltd-1/00.txt
@@ -0,0 +1 @@
+0100000000000000
\ No newline at end of file
diff --git a/test/samples/databarltd-1/01.jpg b/test/samples/databarltd-1/01.jpg
new file mode 100644
index 0000000000..d1e3c7dcee
Binary files /dev/null and b/test/samples/databarltd-1/01.jpg differ
diff --git a/test/samples/databarltd-1/01.result.txt b/test/samples/databarltd-1/01.result.txt
new file mode 100644
index 0000000000..76dbad08fe
--- /dev/null
+++ b/test/samples/databarltd-1/01.result.txt
@@ -0,0 +1 @@
+symbologyIdentifier=]e0
diff --git a/test/samples/databarltd-1/01.txt b/test/samples/databarltd-1/01.txt
new file mode 100644
index 0000000000..b4c6e12149
--- /dev/null
+++ b/test/samples/databarltd-1/01.txt
@@ -0,0 +1 @@
+0100068510889102
\ No newline at end of file
diff --git a/test/samples/datamatrix-3/#749.png b/test/samples/datamatrix-3/#749.png
new file mode 100644
index 0000000000..a614a6405c
Binary files /dev/null and b/test/samples/datamatrix-3/#749.png differ
diff --git a/test/samples/datamatrix-3/#749.txt b/test/samples/datamatrix-3/#749.txt
new file mode 100644
index 0000000000..8edce441f6
--- /dev/null
+++ b/test/samples/datamatrix-3/#749.txt
@@ -0,0 +1 @@
+ABC123
\ No newline at end of file
diff --git a/test/samples/dxfilmedge-1/1.jpg b/test/samples/dxfilmedge-1/1.jpg
new file mode 100644
index 0000000000..9f34211716
Binary files /dev/null and b/test/samples/dxfilmedge-1/1.jpg differ
diff --git a/test/samples/dxfilmedge-1/1.txt b/test/samples/dxfilmedge-1/1.txt
new file mode 100644
index 0000000000..49f698075c
--- /dev/null
+++ b/test/samples/dxfilmedge-1/1.txt
@@ -0,0 +1 @@
+36-2/21
\ No newline at end of file
diff --git a/test/samples/dxfilmedge-1/2.png b/test/samples/dxfilmedge-1/2.png
new file mode 100644
index 0000000000..665f080a37
Binary files /dev/null and b/test/samples/dxfilmedge-1/2.png differ
diff --git a/test/samples/dxfilmedge-1/2.txt b/test/samples/dxfilmedge-1/2.txt
new file mode 100644
index 0000000000..a2b143407c
--- /dev/null
+++ b/test/samples/dxfilmedge-1/2.txt
@@ -0,0 +1 @@
+80-11/23
\ No newline at end of file
diff --git a/test/samples/dxfilmedge-1/3.jpg b/test/samples/dxfilmedge-1/3.jpg
new file mode 100644
index 0000000000..ce106b7804
Binary files /dev/null and b/test/samples/dxfilmedge-1/3.jpg differ
diff --git a/test/samples/dxfilmedge-1/3.txt b/test/samples/dxfilmedge-1/3.txt
new file mode 100644
index 0000000000..2c0e0b1b49
--- /dev/null
+++ b/test/samples/dxfilmedge-1/3.txt
@@ -0,0 +1 @@
+10-3
\ No newline at end of file
diff --git a/test/samples/ean8-1/single-line.png b/test/samples/ean8-1/single-line.png
new file mode 100644
index 0000000000..275c5bcbd0
Binary files /dev/null and b/test/samples/ean8-1/single-line.png differ
diff --git a/test/samples/ean8-1/single-line.txt b/test/samples/ean8-1/single-line.txt
new file mode 100644
index 0000000000..c1c1178167
--- /dev/null
+++ b/test/samples/ean8-1/single-line.txt
@@ -0,0 +1 @@
+12345670
\ No newline at end of file
diff --git a/test/samples/itf-1/#853.png b/test/samples/itf-1/#853.png
new file mode 100644
index 0000000000..50342a035a
Binary files /dev/null and b/test/samples/itf-1/#853.png differ
diff --git a/test/samples/itf-1/#853.txt b/test/samples/itf-1/#853.txt
new file mode 100644
index 0000000000..fc0a24477e
--- /dev/null
+++ b/test/samples/itf-1/#853.txt
@@ -0,0 +1 @@
+1515
\ No newline at end of file
diff --git a/test/samples/itf-1/1-slanted.png b/test/samples/itf-1/1-slanted.png
new file mode 100644
index 0000000000..f8018870d4
Binary files /dev/null and b/test/samples/itf-1/1-slanted.png differ
diff --git a/test/samples/itf-1/1-slanted.txt b/test/samples/itf-1/1-slanted.txt
new file mode 100644
index 0000000000..f17cae6f20
--- /dev/null
+++ b/test/samples/itf-1/1-slanted.txt
@@ -0,0 +1 @@
+30712345000010
\ No newline at end of file
diff --git a/test/samples/itf-1/with-tail.png b/test/samples/itf-1/with-tail.png
new file mode 100644
index 0000000000..8a8f0d497f
Binary files /dev/null and b/test/samples/itf-1/with-tail.png differ
diff --git a/test/samples/itf-1/with-tail.txt b/test/samples/itf-1/with-tail.txt
new file mode 100644
index 0000000000..5bcda57faf
--- /dev/null
+++ b/test/samples/itf-1/with-tail.txt
@@ -0,0 +1 @@
+00123456
\ No newline at end of file
diff --git a/test/samples/qrcode-2/#709.jpg b/test/samples/qrcode-2/#709.jpg
new file mode 100644
index 0000000000..1814946889
Binary files /dev/null and b/test/samples/qrcode-2/#709.jpg differ
diff --git a/test/samples/qrcode-2/#709.txt b/test/samples/qrcode-2/#709.txt
new file mode 100644
index 0000000000..064afa604a
--- /dev/null
+++ b/test/samples/qrcode-2/#709.txt
@@ -0,0 +1 @@
+https://u.wechat.com/ELaSWShWyTFQvXJkp9vCgFA
\ No newline at end of file
diff --git a/test/samples/rss14-2/0120358468019312.jpg b/test/samples/rss14-2/0120358468019312.jpg
new file mode 100644
index 0000000000..2bf3c5606d
Binary files /dev/null and b/test/samples/rss14-2/0120358468019312.jpg differ
diff --git a/test/samples/rss14-2/0120358468019312.txt b/test/samples/rss14-2/0120358468019312.txt
new file mode 100644
index 0000000000..3ccb913ae2
--- /dev/null
+++ b/test/samples/rss14-2/0120358468019312.txt
@@ -0,0 +1 @@
+20358468019312
\ No newline at end of file
diff --git a/test/samples/rss14-2/16.png b/test/samples/rss14-2/16.png
deleted file mode 100644
index e919782c68..0000000000
Binary files a/test/samples/rss14-2/16.png and /dev/null differ
diff --git a/test/samples/rss14-2/16.txt b/test/samples/rss14-2/16.txt
deleted file mode 100644
index adb4ff3445..0000000000
--- a/test/samples/rss14-2/16.txt
+++ /dev/null
@@ -1 +0,0 @@
-02001234567893
\ No newline at end of file
diff --git a/test/samples/rss14-2/17.png b/test/samples/rss14-2/17.png
deleted file mode 100644
index 253139db3e..0000000000
Binary files a/test/samples/rss14-2/17.png and /dev/null differ
diff --git a/test/samples/rss14-2/17.txt b/test/samples/rss14-2/17.txt
deleted file mode 100644
index adb4ff3445..0000000000
--- a/test/samples/rss14-2/17.txt
+++ /dev/null
@@ -1 +0,0 @@
-02001234567893
\ No newline at end of file
diff --git a/test/samples/rss14-2/18.png b/test/samples/rss14-2/18.png
deleted file mode 100644
index c7d76c9416..0000000000
Binary files a/test/samples/rss14-2/18.png and /dev/null differ
diff --git a/test/samples/rss14-2/18.txt b/test/samples/rss14-2/18.txt
deleted file mode 100644
index adb4ff3445..0000000000
--- a/test/samples/rss14-2/18.txt
+++ /dev/null
@@ -1 +0,0 @@
-02001234567893
\ No newline at end of file
diff --git a/test/unit/CMakeLists.txt b/test/unit/CMakeLists.txt
index 02d78d0f2c..f34a5117cd 100644
--- a/test/unit/CMakeLists.txt
+++ b/test/unit/CMakeLists.txt
@@ -1,4 +1,4 @@
-zxing_add_package(GTest googletest https://github.com/google/googletest.git release-1.11.0)
+zxing_add_package(GTest googletest https://github.com/google/googletest.git v1.15.2)
 
 if (GTest_POPULATED)
     # don't install gtest stuff on "make install"
@@ -10,73 +10,89 @@ if (MSVC)
     add_compile_options("$<$<CXX_COMPILER_ID:MSVC>:/utf-8>")
 endif()
 
-# Our executable
 add_executable (UnitTest
     BarcodeFormatTest.cpp
-    BitArrayUtility.h
     BitArrayUtility.cpp
-    PseudoRandom.h
+    BitArrayUtility.h
     BitHacksTest.cpp
     CharacterSetECITest.cpp
-    ContentTest.cpp
     ErrorTest.cpp
     GTINTest.cpp
+    PseudoRandom.h
+    SanitizerSupport.cpp
+    TextUtfEncodingTest.cpp
+    ZXAlgorithmsTest.cpp
+)
+
+if (ZXING_READERS)
+target_sources (UnitTest PRIVATE
     GS1Test.cpp
     PatternTest.cpp
-    ReedSolomonTest.cpp
-    SanitizerSupport.cpp
     TextDecoderTest.cpp
-    TextEncoderTest.cpp
-    TextUtfEncodingTest.cpp
     ThresholdBinarizerTest.cpp
-    ZXAlgorithmsTest.cpp
-    aztec/AZDetectorTest.cpp
     aztec/AZDecoderTest.cpp
-    aztec/AZEncoderTest.cpp
-    aztec/AZEncodeDecodeTest.cpp
-    aztec/AZHighLevelEncoderTest.cpp
+    aztec/AZDetectorTest.cpp
     datamatrix/DMDecodedBitStreamParserTest.cpp
-    datamatrix/DMEncodeDecodeTest.cpp
-    datamatrix/DMHighLevelEncodeTest.cpp
-    datamatrix/DMPlacementTest.cpp
-    datamatrix/DMSymbolInfoTest.cpp
-    datamatrix/DMWriterTest.cpp
     maxicode/MCDecoderTest.cpp
-    oned/ODCodaBarWriterTest.cpp
+    oned/ODCode128ReaderTest.cpp
     oned/ODCode39ExtendedModeTest.cpp
     oned/ODCode39ReaderTest.cpp
-    oned/ODCode39WriterTest.cpp
     oned/ODCode93ReaderTest.cpp
-    oned/ODCode93WriterTest.cpp
-    oned/ODCode128ReaderTest.cpp
-    oned/ODCode128WriterTest.cpp
-    oned/ODDataBarReaderTest.cpp
     oned/ODDataBarExpandedBitDecoderTest.cpp
-    oned/ODEAN8WriterTest.cpp
-    oned/ODEAN13WriterTest.cpp
-    oned/ODITFWriterTest.cpp
-    oned/ODUPCAWriterTest.cpp
-    oned/ODUPCEWriterTest.cpp
+    oned/ODDataBarReaderTest.cpp
+    pdf417/PDF417DecoderTest.cpp
+    pdf417/PDF417ErrorCorrectionTest.cpp
+    pdf417/PDF417ScanningDecoderTest.cpp
     qrcode/MQRDecoderTest.cpp
     qrcode/QRBitMatrixParserTest.cpp
     qrcode/QRDataMaskTest.cpp
     qrcode/QRDecodedBitStreamParserTest.cpp
-    qrcode/QREncoderTest.cpp
     qrcode/QRErrorCorrectionLevelTest.cpp
     qrcode/QRFormatInformationTest.cpp
     qrcode/QRModeTest.cpp
     qrcode/QRVersionTest.cpp
-    qrcode/QRWriterTest.cpp
     qrcode/RMQRDecoderTest.cpp
-    pdf417/PDF417DecoderTest.cpp
-    pdf417/PDF417ErrorCorrectionTest.cpp
+)
+endif()
+
+if (ZXING_WRITERS MATCHES "ON|OLD|BOTH")
+target_sources (UnitTest PRIVATE
+    aztec/AZEncoderTest.cpp
+    datamatrix/DMHighLevelEncodeTest.cpp
+    datamatrix/DMPlacementTest.cpp
+    datamatrix/DMSymbolInfoTest.cpp
+    datamatrix/DMWriterTest.cpp
+    oned/ODCode39WriterTest.cpp
+    oned/ODCode93WriterTest.cpp
+    oned/ODEAN13WriterTest.cpp
+    oned/ODEAN8WriterTest.cpp
+    oned/ODITFWriterTest.cpp
+    oned/ODUPCAWriterTest.cpp
+    oned/ODUPCEWriterTest.cpp
     pdf417/PDF417HighLevelEncoderTest.cpp
-    pdf417/PDF417ScanningDecoderTest.cpp
     pdf417/PDF417WriterTest.cpp
+    qrcode/QRWriterTest.cpp
 )
+endif()
+
+if (ZXING_READERS AND ZXING_WRITERS MATCHES "ON|OLD|BOTH")
+target_sources (UnitTest PRIVATE
+    ContentTest.cpp
+    ReedSolomonTest.cpp
+    TextEncoderTest.cpp
+    aztec/AZEncodeDecodeTest.cpp
+    aztec/AZHighLevelEncoderTest.cpp
+    datamatrix/DMEncodeDecodeTest.cpp
+    oned/ODCodaBarWriterTest.cpp
+    oned/ODCode128WriterTest.cpp
+    qrcode/QREncoderTest.cpp
+)
+endif()
 
 target_include_directories (UnitTest PRIVATE .)
 
 target_link_libraries (UnitTest ZXing::ZXing GTest::gtest_main GTest::gmock)
 
+#target_precompile_headers(UnitTest PRIVATE ${CMAKE_SOURCE_DIR}/core/src/ReadBarcode.h)
+
 add_test(NAME UnitTest COMMAND UnitTest)
diff --git a/test/unit/GS1Test.cpp b/test/unit/GS1Test.cpp
index 063ee182ec..a3f4389324 100644
--- a/test/unit/GS1Test.cpp
+++ b/test/unit/GS1Test.cpp
@@ -259,6 +259,12 @@ TEST(HRIFromGS1, Single)
 	// Too long
 	EXPECT_EQ(HRIFromGS1("7240123456789012345678901"), "");
 
+	// Fixed length
+	EXPECT_EQ(HRIFromGS1("72581/2"), "(7258)1/2");
+	// Incorrect lengths
+	EXPECT_EQ(HRIFromGS1("72581/10"), "");
+	EXPECT_EQ(HRIFromGS1("725812"), "");
+
 	// Max length
 	EXPECT_EQ(HRIFromGS1("80071234567890123456789012345678901234"), "(8007)1234567890123456789012345678901234");
 	EXPECT_EQ(HRIFromGS1("8007123456789012345678901234567890123"), "(8007)123456789012345678901234567890123");
diff --git a/test/unit/GTINTest.cpp b/test/unit/GTINTest.cpp
index 10f89909e9..9462ca37f7 100644
--- a/test/unit/GTINTest.cpp
+++ b/test/unit/GTINTest.cpp
@@ -5,9 +5,6 @@
 
 #include "GTIN.h"
 
-#include "Result.h"
-#include "oned/ODUPCEANCommon.h"
-
 #include "gtest/gtest.h"
 
 using namespace ZXing;
@@ -19,7 +16,7 @@ TEST(GTINTest, CountryIdentifierEAN13)
 	EXPECT_EQ(LookupCountryIdentifier("8413000065504"), "ES");
 	EXPECT_EQ(LookupCountryIdentifier("8413000065504 12"), "ES");
 	EXPECT_EQ(LookupCountryIdentifier("8413000065504 51299"), "ES");
-	EXPECT_EQ(LookupCountryIdentifier("5449000039231"), "BE/LU");
+	EXPECT_EQ(LookupCountryIdentifier("5449000039231"), "BE");
 	EXPECT_TRUE(LookupCountryIdentifier("9788430532674").empty()); // Bookland (ISBN)
 	EXPECT_EQ(LookupCountryIdentifier("8480017507990"), "ES");
 	EXPECT_EQ(LookupCountryIdentifier("3166298099809"), "FR");
@@ -51,9 +48,9 @@ TEST(GTINTest, CountryIdentifierEAN13)
 	EXPECT_EQ(LookupCountryIdentifier("0000902301465"), "US");
 	EXPECT_EQ(LookupCountryIdentifier("0001602301465"), "US"); // 0001-0009 US
 	EXPECT_EQ(LookupCountryIdentifier("0009602301461 12"), "US");
-	EXPECT_EQ(LookupCountryIdentifier("0016602301469"), "US/CA"); // 001-019 US/CA
-	EXPECT_EQ(LookupCountryIdentifier("0036602301467"), "US/CA");
-	EXPECT_EQ(LookupCountryIdentifier("0196602301468 51299"), "US/CA");
+	EXPECT_EQ(LookupCountryIdentifier("0016602301469"), "US"); // 001-019 US
+	EXPECT_EQ(LookupCountryIdentifier("0036602301467"), "US");
+	EXPECT_EQ(LookupCountryIdentifier("0196602301468 51299"), "US");
 	EXPECT_TRUE(LookupCountryIdentifier("0206602301464").empty()); // 020-029 Restricted Circulation Numbers
 	EXPECT_TRUE(LookupCountryIdentifier("0296602301465").empty());
 	EXPECT_EQ(LookupCountryIdentifier("0306602301461"), "US"); // 030-039 US
@@ -62,8 +59,8 @@ TEST(GTINTest, CountryIdentifierEAN13)
 	EXPECT_TRUE(LookupCountryIdentifier("0496602301469").empty());
 	EXPECT_TRUE(LookupCountryIdentifier("0506602301465").empty()); // 050-059 reserved for future use
 	EXPECT_TRUE(LookupCountryIdentifier("0596602301466").empty());
-	EXPECT_EQ(LookupCountryIdentifier("0606602301462"), "US/CA"); // 060-099 US/CA
-	EXPECT_EQ(LookupCountryIdentifier("0996602301464"), "US/CA");
+	EXPECT_EQ(LookupCountryIdentifier("0606602301462"), "US"); // 060-099 US
+	EXPECT_EQ(LookupCountryIdentifier("0996602301464"), "US");
 	EXPECT_EQ(LookupCountryIdentifier("1006602301469"), "US"); // 100-139 US
 	EXPECT_EQ(LookupCountryIdentifier("1396602301461"), "US");
 	EXPECT_TRUE(LookupCountryIdentifier("1406602301467").empty()); // 140-199 unassigned
@@ -102,23 +99,23 @@ TEST(GTINTest, CountryIdentifierEAN13)
 TEST(GTINTest, CountryIdentifierUPCA)
 {
 	// From test/samples/upca-*/
-	EXPECT_EQ(LookupCountryIdentifier("036602301467"), "US/CA"); // 001-019 US/CA
-	EXPECT_EQ(LookupCountryIdentifier("036602301467 12"), "US/CA"); // 001-019 US/CA
-	EXPECT_EQ(LookupCountryIdentifier("036602301467 51299"), "US/CA"); // 001-019 US/CA
-	EXPECT_EQ(LookupCountryIdentifier("070097025088"), "US/CA");
-	EXPECT_EQ(LookupCountryIdentifier("781735802045"), "US/CA"); // 060-099 US/CA
+	EXPECT_EQ(LookupCountryIdentifier("036602301467"), "US"); // 001-019 US/CA
+	EXPECT_EQ(LookupCountryIdentifier("036602301467 12"), "US"); // 001-019 US
+	EXPECT_EQ(LookupCountryIdentifier("036602301467 51299"), "US"); // 001-019 US
+	EXPECT_EQ(LookupCountryIdentifier("070097025088"), "US");
+	EXPECT_EQ(LookupCountryIdentifier("781735802045"), "US"); // 060-099 US
 	EXPECT_TRUE(LookupCountryIdentifier("456314319671").empty()); // 040-049 Restricted Circulation Numbers
 	EXPECT_TRUE(LookupCountryIdentifier("434704791429").empty());
-	EXPECT_EQ(LookupCountryIdentifier("752919460009"), "US/CA"); // 060-099 US/CA
-	EXPECT_EQ(LookupCountryIdentifier("606949762520"), "US/CA");
-	EXPECT_EQ(LookupCountryIdentifier("890444000335"), "US/CA");
-	EXPECT_EQ(LookupCountryIdentifier("181497000879"), "US/CA"); // 001-019 US/CA
-	EXPECT_EQ(LookupCountryIdentifier("012546619592"), "US/CA");
-	EXPECT_EQ(LookupCountryIdentifier("854818000116"), "US/CA"); // 060-099 US/CA
+	EXPECT_EQ(LookupCountryIdentifier("752919460009"), "US"); // 060-099 US
+	EXPECT_EQ(LookupCountryIdentifier("606949762520"), "US");
+	EXPECT_EQ(LookupCountryIdentifier("890444000335"), "US");
+	EXPECT_EQ(LookupCountryIdentifier("181497000879"), "US"); // 001-019 US
+	EXPECT_EQ(LookupCountryIdentifier("012546619592"), "US");
+	EXPECT_EQ(LookupCountryIdentifier("854818000116"), "US"); // 060-099 US
 	EXPECT_EQ(LookupCountryIdentifier("312547701310"), "US"); // 030-039 US
-	EXPECT_EQ(LookupCountryIdentifier("071831007995 19868"), "US/CA"); // 001-019 US/CA
-	EXPECT_EQ(LookupCountryIdentifier("027011006951 02601"), "US/CA");
-	EXPECT_EQ(LookupCountryIdentifier("024543136538 00"), "US/CA");
+	EXPECT_EQ(LookupCountryIdentifier("071831007995 19868"), "US"); // 001-019 US
+	EXPECT_EQ(LookupCountryIdentifier("027011006951 02601"), "US");
+	EXPECT_EQ(LookupCountryIdentifier("024543136538 00"), "US");
 
 	// Other
 	EXPECT_TRUE(LookupCountryIdentifier("000000001465").empty()); // 0000000 Restricted Circulation Numbers
@@ -130,9 +127,9 @@ TEST(GTINTest, CountryIdentifierUPCA)
 	EXPECT_EQ(LookupCountryIdentifier("000902301465"), "US");
 	EXPECT_EQ(LookupCountryIdentifier("001602301465"), "US"); // 0001-0009 US
 	EXPECT_EQ(LookupCountryIdentifier("009602301461 12"), "US");
-	EXPECT_EQ(LookupCountryIdentifier("016602301469"), "US/CA"); // 001-019 US/CA
-	EXPECT_EQ(LookupCountryIdentifier("036602301467"), "US/CA");
-	EXPECT_EQ(LookupCountryIdentifier("196602301468 51299"), "US/CA");
+	EXPECT_EQ(LookupCountryIdentifier("016602301469"), "US"); // 001-019 US
+	EXPECT_EQ(LookupCountryIdentifier("036602301467"), "US");
+	EXPECT_EQ(LookupCountryIdentifier("196602301468 51299"), "US");
 	EXPECT_TRUE(LookupCountryIdentifier("206602301464").empty()); // 020-029 Restricted Circulation Numbers
 	EXPECT_TRUE(LookupCountryIdentifier("296602301465").empty());
 	EXPECT_EQ(LookupCountryIdentifier("306602301461"), "US"); // 030-039 US
@@ -141,33 +138,33 @@ TEST(GTINTest, CountryIdentifierUPCA)
 	EXPECT_TRUE(LookupCountryIdentifier("496602301469").empty());
 	EXPECT_TRUE(LookupCountryIdentifier("506602301465").empty()); // 050-059 reserved for future use
 	EXPECT_TRUE(LookupCountryIdentifier("596602301466").empty());
-	EXPECT_EQ(LookupCountryIdentifier("606602301462"), "US/CA"); // 060-099 US/CA
-	EXPECT_EQ(LookupCountryIdentifier("996602301464"), "US/CA");
+	EXPECT_EQ(LookupCountryIdentifier("606602301462"), "US"); // 060-099 US
+	EXPECT_EQ(LookupCountryIdentifier("996602301464"), "US");
 }
 
 TEST(GTINTest, CountryIdentifierUPCE)
 {
 	// From test/samples/upce-*/
-	EXPECT_EQ(LookupCountryIdentifier("01234565"), "US/CA"); // 001-019 US/CA
-	EXPECT_EQ(LookupCountryIdentifier("01234565", BarcodeFormat::UPCE), "US/CA"); // 001-019 US/CA
+	EXPECT_EQ(LookupCountryIdentifier("01234565"), "US"); // 001-019 US
+	EXPECT_EQ(LookupCountryIdentifier("01234565", BarcodeFormat::UPCE), "US"); // 001-019 US
 	EXPECT_EQ(LookupCountryIdentifier("00123457"), "US"); // 0001-0009 US
 	EXPECT_EQ(LookupCountryIdentifier("00123457", BarcodeFormat::UPCE), "US"); // 0001-0009 US
-	EXPECT_EQ(LookupCountryIdentifier("05096893"), "US/CA"); // 001-019 US/CA
-	EXPECT_EQ(LookupCountryIdentifier("05096893", BarcodeFormat::UPCE), "US/CA"); // 001-019 US/CA
-	EXPECT_EQ(LookupCountryIdentifier("04963406 01"), "US/CA"); // 001-019 US/CA
-	EXPECT_EQ(LookupCountryIdentifier("04963406 01", BarcodeFormat::UPCE), "US/CA"); // 001-019 US/CA
+	EXPECT_EQ(LookupCountryIdentifier("05096893"), "US"); // 001-019 US
+	EXPECT_EQ(LookupCountryIdentifier("05096893", BarcodeFormat::UPCE), "US"); // 001-019 US
+	EXPECT_EQ(LookupCountryIdentifier("04963406 01"), "US"); // 001-019 US
+	EXPECT_EQ(LookupCountryIdentifier("04963406 01", BarcodeFormat::UPCE), "US"); // 001-019 US
 
 	// Other
 	// 0000000, 0000001-0000099 and 00001-00009 not possible for UPC-E
 	EXPECT_EQ(LookupCountryIdentifier("00021357"), "US"); // 0001-0009 US
 	EXPECT_EQ(LookupCountryIdentifier("00021357 01"), "US");
-	EXPECT_EQ(LookupCountryIdentifier("11621355"), "US/CA"); // 001-019 US/CA
+	EXPECT_EQ(LookupCountryIdentifier("11621355"), "US"); // 001-019 US
 	EXPECT_TRUE(LookupCountryIdentifier("22221111").empty()); // 020-029 Restricted Circulation Numbers
-	EXPECT_EQ(LookupCountryIdentifier("31621358"), "US"); // 030-039 US/CA
+	EXPECT_EQ(LookupCountryIdentifier("31621358"), "US"); // 030-039 US
 	EXPECT_TRUE(LookupCountryIdentifier("40621359").empty()); // 040-049 Restricted Circulation Numbers
 	EXPECT_TRUE(LookupCountryIdentifier("50621359").empty()); // 050-059 reserved for future use
-	EXPECT_EQ(LookupCountryIdentifier("61621358"), "US/CA"); // 060-099 US/CA
-	EXPECT_EQ(LookupCountryIdentifier("99621350"), "US/CA");
+	EXPECT_EQ(LookupCountryIdentifier("61621358"), "US"); // 060-099 US
+	EXPECT_EQ(LookupCountryIdentifier("99621350"), "US");
 }
 
 TEST(GTINTest, CountryIdentifierEAN8)
@@ -203,8 +200,8 @@ TEST(GTINTest, CountryIdentifierEAN8)
 TEST(GTINTest, CountryIdentifierGTIN14)
 {
 	// From test/samples/itf-*/
-	EXPECT_EQ(LookupCountryIdentifier("30712345000010"), "US/CA");
-	EXPECT_EQ(LookupCountryIdentifier("00012345678905"), "US/CA");
+	EXPECT_EQ(LookupCountryIdentifier("30712345000010"), "US");
+	EXPECT_EQ(LookupCountryIdentifier("00012345678905"), "US");
 
 	// Other
 	EXPECT_TRUE(LookupCountryIdentifier("12345678901231").empty()); // 200-299 Restricted Circulation Numbers
diff --git a/test/unit/TextUtfEncodingTest.cpp b/test/unit/TextUtfEncodingTest.cpp
index b406f6d098..e77d332e7a 100644
--- a/test/unit/TextUtfEncodingTest.cpp
+++ b/test/unit/TextUtfEncodingTest.cpp
@@ -6,7 +6,6 @@
 #include "Utf.h"
 
 #include "gtest/gtest.h"
-#include <vector>
 
 using namespace ZXing;
 
diff --git a/test/unit/ThresholdBinarizerTest.cpp b/test/unit/ThresholdBinarizerTest.cpp
index 0755696cf2..a92b0b6ef0 100644
--- a/test/unit/ThresholdBinarizerTest.cpp
+++ b/test/unit/ThresholdBinarizerTest.cpp
@@ -98,7 +98,7 @@ TEST(ThresholdBinarizerTest, PatternRowClear)
 	opts.setMinLineCount(1);
 	OneD::Reader reader(opts);
 
-	Result result = reader.decode(ThresholdBinarizer(getImageView(buf, bits), 0x7F));
-	EXPECT_TRUE(result.isValid());
-	EXPECT_EQ(result.text(TextMode::HRI), "(91)12345678901234567890123456789012345678901234567890123456789012345678");
+	auto barcode = reader.decode(ThresholdBinarizer(getImageView(buf, bits), 0x7F));
+	EXPECT_TRUE(barcode.isValid());
+	EXPECT_EQ(barcode.text(TextMode::HRI), "(91)12345678901234567890123456789012345678901234567890123456789012345678");
 }
diff --git a/test/unit/aztec/AZDecoderTest.cpp b/test/unit/aztec/AZDecoderTest.cpp
index beae00357c..2d85313e4a 100644
--- a/test/unit/aztec/AZDecoderTest.cpp
+++ b/test/unit/aztec/AZDecoderTest.cpp
@@ -25,7 +25,7 @@ using namespace ZXing;
 // Shorthand to call Decode()
 static DecoderResult parse(BitMatrix&& bits, bool compact, int nbDatablocks, int nbLayers)
 {
-	return Aztec::Decode({{std::move(bits), {}}, compact, nbDatablocks, nbLayers, false /*readerInit*/, false /*isMirrored*/});
+	return Aztec::Decode({{std::move(bits), {}}, compact, nbDatablocks, nbLayers, false /*readerInit*/, false /*isMirrored*/, 0 /*runeValue*/});
 }
 
 TEST(AZDecoderTest, AztecResult)
diff --git a/test/unit/aztec/AZDetectorTest.cpp b/test/unit/aztec/AZDetectorTest.cpp
index 242932f3b3..b58061e34e 100644
--- a/test/unit/aztec/AZDetectorTest.cpp
+++ b/test/unit/aztec/AZDetectorTest.cpp
@@ -426,3 +426,63 @@ TEST(AZDetectorTest, ReaderInitCompact)
 		EXPECT_EQ(r.nbLayers(), 1);
 	}
 }
+
+TEST(AZDetectorTest, Rune)
+{
+	{
+		auto r = Aztec::Detect(ParseBitMatrix(
+			"X X X   X   X   X   X \n"
+			"X X X X X X X X X X X \n"
+			"  X               X   \n"
+			"X X   X X X X X   X X \n"
+			"  X   X       X   X   \n"
+			"X X   X   X   X   X X \n"
+			"  X   X       X   X   \n"
+			"X X   X X X X X   X X \n"
+			"  X               X   \n"
+			"  X X X X X X X X X X \n"
+			"    X   X   X   X     \n"
+		), false /*isPure*/, false /*tryHarder*/);
+
+		EXPECT_TRUE(r.isValid());
+		EXPECT_EQ(r.nbDatablocks(), 0);
+		EXPECT_EQ(r.runeValue(), 0);
+	}
+	{
+		auto r = Aztec::Detect(ParseBitMatrix(
+			"X X X   X X     X   X \n"
+			"X X X X X X X X X X X \n"
+			"  X               X X \n"
+			"  X   X X X X X   X X \n"
+			"  X   X       X   X   \n"
+			"X X   X   X   X   X X \n"
+			"X X   X       X   X X \n"
+			"X X   X X X X X   X   \n"
+			"X X               X X \n"
+			"  X X X X X X X X X X \n"
+			"    X     X           \n"
+		), true /*isPure*/, false /*tryHarder*/);
+
+		EXPECT_TRUE(r.isValid());
+		EXPECT_EQ(r.nbDatablocks(), 0);
+		EXPECT_EQ(r.runeValue(), 25);
+	}
+	{
+		auto r = Aztec::Detect(ParseBitMatrix(
+			"X X             X   X \n"
+			"X X X X X X X X X X X \n"
+			"  X               X   \n"
+			"X X   X X X X X   X   \n"
+			"  X   X       X   X X \n"
+			"  X   X   X   X   X   \n"
+			"  X   X       X   X X \n"
+			"  X   X X X X X   X X \n"
+			"X X               X   \n"
+			"  X X X X X X X X X X \n"
+			"          X X         \n"
+		), true /*isPure*/, false /*tryHarder*/);
+
+		// This is just the core of a regular compact code, and not a valid rune
+		EXPECT_FALSE(r.isValid());
+	}
+}
\ No newline at end of file
diff --git a/test/unit/aztec/AZEncodeDecodeTest.cpp b/test/unit/aztec/AZEncodeDecodeTest.cpp
index e07824f97b..8e84fe1a1d 100644
--- a/test/unit/aztec/AZEncodeDecodeTest.cpp
+++ b/test/unit/aztec/AZEncodeDecodeTest.cpp
@@ -10,6 +10,7 @@
 #include "PseudoRandom.h"
 #include "TextEncoder.h"
 #include "aztec/AZDecoder.h"
+#include "aztec/AZDetector.h"
 #include "aztec/AZDetectorResult.h"
 #include "aztec/AZEncoder.h"
 #include "aztec/AZWriter.h"
@@ -35,7 +36,7 @@ namespace {
 	// Shorthand to call Decode()
 	static DecoderResult parse(BitMatrix&& bits, bool compact, int nbDatablocks, int nbLayers)
 	{
-		return Aztec::Decode({{std::move(bits), {}}, compact, nbDatablocks, nbLayers, false /*readerInit*/, false /*isMirrored*/});
+		return Aztec::Decode({{std::move(bits), {}}, compact, nbDatablocks, nbLayers, false /*readerInit*/, false /*isMirrored*/, 0 /*runeValue*/});
 	}
 
 	void TestEncodeDecode(const std::string& data, bool compact, int layers) {
@@ -228,3 +229,17 @@ TEST(AZEncodeDecodeTest, AztecWriter)
 							   Aztec::Encoder::DEFAULT_EC_PERCENT, Aztec::Encoder::DEFAULT_AZTEC_LAYERS);
 	EXPECT_EQ(matrix, aztec.matrix);
 }
+
+TEST(AZEncodeDecodeTest, RunePure)
+{
+	for(uint8_t word = 0; word < 255; word++) {
+		std::string data(1, word);
+		Aztec::EncodeResult aztec =
+			Aztec::Encoder::Encode(data, 0, Aztec::Encoder::AZTEC_RUNE_LAYERS);
+		
+		auto result = Aztec::Detect(aztec.matrix, true, false);
+		EXPECT_TRUE(result.isValid());
+		EXPECT_EQ(result.nbDatablocks(), 0);
+		EXPECT_EQ(result.runeValue(), word);
+	}
+}
\ No newline at end of file
diff --git a/test/unit/aztec/AZEncoderTest.cpp b/test/unit/aztec/AZEncoderTest.cpp
index 045f15e3f3..16374121cc 100644
--- a/test/unit/aztec/AZEncoderTest.cpp
+++ b/test/unit/aztec/AZEncoderTest.cpp
@@ -32,7 +32,11 @@ namespace {
 	}
 
 	std::string StripSpaces(std::string str) {
+#ifdef __cpp_lib_erase_if
+		std::erase_if(str, isspace);
+#else
 		str.erase(std::remove_if(str.begin(), str.end(), isspace), str.end());
+#endif
 		return str;
 	}
 
@@ -200,3 +204,52 @@ TEST(AZEncoderTest, BorderCompact4Case)
 	EXPECT_TRUE(aztec.compact);
 	EXPECT_EQ(aztec.layers, 4);
 }
+
+
+TEST(AZEncoderTest, Rune)
+{
+	{
+		Aztec::EncodeResult aztec = Aztec::Encoder::Encode("\x19", 0, Aztec::Encoder::AZTEC_RUNE_LAYERS);
+		
+		EXPECT_EQ(aztec.layers, 0);
+		EXPECT_EQ(aztec.matrix, ParseBitMatrix(
+			"X X X   X X     X   X \n"
+			"X X X X X X X X X X X \n"
+			"  X               X X \n"
+			"  X   X X X X X   X X \n"
+			"  X   X       X   X   \n"
+			"X X   X   X   X   X X \n"
+			"X X   X       X   X X \n"
+			"X X   X X X X X   X   \n"
+			"X X               X X \n"
+			"  X X X X X X X X X X \n"
+			"    X     X           \n"
+		));
+	}
+	{
+		Aztec::EncodeResult aztec = Aztec::Encoder::Encode("\xFF", 0, Aztec::Encoder::AZTEC_RUNE_LAYERS);
+		
+		EXPECT_EQ(aztec.layers, 0);
+		EXPECT_EQ(aztec.matrix, ParseBitMatrix(
+			"X X   X   X   X     X \n"
+			"X X X X X X X X X X X \n"
+			"  X               X X \n"
+			"X X   X X X X X   X X \n"
+			"X X   X       X   X X \n"
+			"  X   X   X   X   X X \n"
+			"  X   X       X   X   \n"
+			"X X   X X X X X   X X \n"
+			"X X               X   \n"
+			"  X X X X X X X X X X \n"
+			"    X X     X X X     \n"
+		));
+	}
+	{
+		Aztec::EncodeResult aztec = Aztec::Encoder::Encode("\x44", 0, Aztec::Encoder::AZTEC_RUNE_LAYERS);
+
+		std::cout << ToString(aztec.matrix, 'X', ' ', true);
+	}
+
+	
+	
+}
\ No newline at end of file
diff --git a/test/unit/aztec/AZHighLevelEncoderTest.cpp b/test/unit/aztec/AZHighLevelEncoderTest.cpp
index 78e86cbcc2..f42e242ff5 100644
--- a/test/unit/aztec/AZHighLevelEncoderTest.cpp
+++ b/test/unit/aztec/AZHighLevelEncoderTest.cpp
@@ -23,7 +23,11 @@ using namespace ZXing;
 
 namespace {
 	std::string StripSpaces(std::string str) {
+#ifdef __cpp_lib_erase_if
+		std::erase_if(str, isspace);
+#else
 		str.erase(std::remove_if(str.begin(), str.end(), isspace), str.end());
+#endif
 		return str;
 	}
 
diff --git a/test/unit/datamatrix/DMDecodedBitStreamParserTest.cpp b/test/unit/datamatrix/DMDecodedBitStreamParserTest.cpp
index 1e03a453dd..5c6c1bed41 100644
--- a/test/unit/datamatrix/DMDecodedBitStreamParserTest.cpp
+++ b/test/unit/datamatrix/DMDecodedBitStreamParserTest.cpp
@@ -204,9 +204,9 @@ TEST(DMDecodeTest, StructuredAppend)
 
 	// Structured Append "233" must be first ISO 16022:2006 5.6.1
 	EXPECT_FALSE(parse({50, 233, 42, 1, 1}).isValid());
-	EXPECT_EQ(info({50, 233, 42, 1, 1}).index, -1);
 
 	// ISO/IEC 16022:2006 5.6.2 sequence indicator example
+	EXPECT_TRUE(parse({233, 42, 1, 1, 50}).isValid());
 	EXPECT_EQ(info({233, 42, 1, 1, 50}).index, 2); // 1-based position 3 == index 2
 	EXPECT_EQ(info({233, 42, 1, 1, 50}).count, 7);
 	EXPECT_EQ(info({233, 42, 1, 1, 50}).id, "257");
@@ -247,18 +247,15 @@ TEST(DMDecodeTest, ReaderInit)
 	EXPECT_TRUE(parse({50}).isValid());
 
 	// Reader Programming "234" must be first ISO 16022:2006 5.2.4.9
-	EXPECT_FALSE(parse({50, 234}).readerInit());
 	EXPECT_FALSE(parse({50, 234}).isValid());
 
 	// Set
-	EXPECT_TRUE(parse({234, 50}).readerInit());
 	EXPECT_TRUE(parse({234, 50}).isValid());
+	EXPECT_TRUE(parse({234, 50}).readerInit());
 
-	EXPECT_FALSE(parse({235, 234, 50}).readerInit()); // Upper Shift first
 	EXPECT_FALSE(parse({235, 234, 50}).isValid());
 
 	// Can't be used with Structured Append "233"
 	EXPECT_TRUE(parse({233, 42, 1, 1, 50}).isValid()); // Null
-	EXPECT_FALSE(parse({233, 42, 1, 1, 234, 50}).readerInit());
 	EXPECT_FALSE(parse({233, 42, 1, 1, 234, 50}).isValid());
 }
diff --git a/test/unit/datamatrix/DMEncodeDecodeTest.cpp b/test/unit/datamatrix/DMEncodeDecodeTest.cpp
index da64b8c415..33f1587740 100644
--- a/test/unit/datamatrix/DMEncodeDecodeTest.cpp
+++ b/test/unit/datamatrix/DMEncodeDecodeTest.cpp
@@ -9,11 +9,6 @@
 #include "datamatrix/DMDecoder.h"
 #include "datamatrix/DMWriter.h"
 
-#include <algorithm>
-#ifndef NDEBUG
-#include <fstream>
-#endif
-
 #include "gtest/gtest.h"
 
 using namespace ZXing;
diff --git a/test/unit/oned/ODCodaBarWriterTest.cpp b/test/unit/oned/ODCodaBarWriterTest.cpp
index c49ca3d880..4e6c0ffc7a 100644
--- a/test/unit/oned/ODCodaBarWriterTest.cpp
+++ b/test/unit/oned/ODCodaBarWriterTest.cpp
@@ -7,7 +7,7 @@
 #include "oned/ODCodabarWriter.h"
 #include "BitMatrixIO.h"
 #include "ReaderOptions.h"
-#include "Result.h"
+#include "Barcode.h"
 #include "oned/ODCodabarReader.h"
 
 #include "gtest/gtest.h"
@@ -50,9 +50,9 @@ TEST(ODCodaBarWriterTest, FullCircle)
 {
 	std::string text = "A0123456789-$:/.+A";
 	auto matrix = CodabarWriter().encode(text, 0, 0);
-	auto opts = ReaderOptions().setReturnCodabarStartEnd(true);
+	auto opts = ReaderOptions();
 
-	Result res = OneD::DecodeSingleRow(CodabarReader(opts), matrix.row(0));
+	auto res = OneD::DecodeSingleRow(CodabarReader(opts), matrix.row(0));
 	EXPECT_EQ(text, res.text());
 }
 
diff --git a/test/unit/oned/ODCode128ReaderTest.cpp b/test/unit/oned/ODCode128ReaderTest.cpp
index 1c68d94357..a02b7f031f 100644
--- a/test/unit/oned/ODCode128ReaderTest.cpp
+++ b/test/unit/oned/ODCode128ReaderTest.cpp
@@ -6,7 +6,7 @@
 #include "oned/ODCode128Reader.h"
 
 #include "ReaderOptions.h"
-#include "Result.h"
+#include "Barcode.h"
 
 #include "gtest/gtest.h"
 
@@ -14,7 +14,7 @@ using namespace ZXing;
 using namespace ZXing::OneD;
 
 // Helper to call decodePattern()
-static Result parse(const int startPattern, PatternRow row)
+static Barcode parse(const int startPattern, PatternRow row)
 {
 	if (startPattern == 'A') {
 		row.insert(row.begin(), { 0, 2, 1, 1, 4, 1, 2 });
diff --git a/test/unit/oned/ODCode128WriterTest.cpp b/test/unit/oned/ODCode128WriterTest.cpp
index 7c7291b3bc..611d271e80 100644
--- a/test/unit/oned/ODCode128WriterTest.cpp
+++ b/test/unit/oned/ODCode128WriterTest.cpp
@@ -7,7 +7,7 @@
 #include "oned/ODCode128Writer.h"
 #include "BitMatrixIO.h"
 #include "ReaderOptions.h"
-#include "Result.h"
+#include "Barcode.h"
 #include "oned/ODCode128Reader.h"
 
 #include "gtest/gtest.h"
@@ -35,7 +35,7 @@ static std::string LineMatrixToString(const BitMatrix& matrix)
 	return result.substr(0, result.size() - 1);
 }
 
-static ZXing::Result Decode(const BitMatrix &matrix)
+static ZXing::Barcode Decode(const BitMatrix &matrix)
 {
 	ReaderOptions opts;
 	return DecodeSingleRow(Code128Reader(opts), matrix.row(0));
diff --git a/test/unit/oned/ODCode39ExtendedModeTest.cpp b/test/unit/oned/ODCode39ExtendedModeTest.cpp
index 589880a617..53b5a5da4c 100644
--- a/test/unit/oned/ODCode39ExtendedModeTest.cpp
+++ b/test/unit/oned/ODCode39ExtendedModeTest.cpp
@@ -7,7 +7,7 @@
 #include "BitArray.h"
 #include "BitArrayUtility.h"
 #include "ReaderOptions.h"
-#include "Result.h"
+#include "Barcode.h"
 #include "oned/ODCode39Reader.h"
 
 #include "gtest/gtest.h"
@@ -17,13 +17,13 @@ using namespace ZXing::OneD;
 
 static std::string Decode(std::string_view encoded)
 {
-	auto opts = ReaderOptions().setTryCode39ExtendedMode(true);
+	auto opts = ReaderOptions();
 	BitArray row = Utility::ParseBitArray(encoded, '1');
-	Result result = DecodeSingleRow(Code39Reader(opts), row.range());
+	auto result = DecodeSingleRow(Code39Reader(opts), row.range());
 	return result.text(TextMode::Plain);
 }
 
-TEST(ODCode39ExtendedModeTest, Decode)
+TEST(ODCode39FullASCIITest, Decode)
 {
 	EXPECT_EQ(Decode(
 		"00000100101101101010100100100101100101010110100100100101011010100101101001001001"
diff --git a/test/unit/oned/ODCode39ReaderTest.cpp b/test/unit/oned/ODCode39ReaderTest.cpp
index a8684a7682..42adc80a3f 100644
--- a/test/unit/oned/ODCode39ReaderTest.cpp
+++ b/test/unit/oned/ODCode39ReaderTest.cpp
@@ -6,7 +6,7 @@
 #include "oned/ODCode39Reader.h"
 
 #include "ReaderOptions.h"
-#include "Result.h"
+#include "Barcode.h"
 
 #include "gtest/gtest.h"
 
@@ -14,7 +14,7 @@ using namespace ZXing;
 using namespace ZXing::OneD;
 
 // Helper to call decodePattern()
-static Result parse(PatternRow row, ReaderOptions opts = {})
+static Barcode parse(PatternRow row, ReaderOptions opts = {})
 {
 	Code39Reader reader(opts);
 
@@ -38,34 +38,22 @@ TEST(ODCode39ReaderTest, SymbologyIdentifier)
 	{
 		// "A" with checksum
 		PatternRow row({ 2, 1, 1, 1, 1, 2, 1, 1, 2, 0, 2, 1, 1, 1, 1, 2, 1, 1, 2 });
-		auto result = parse(row, ReaderOptions().setValidateCode39CheckSum(true));
-		EXPECT_EQ(result.symbologyIdentifier(), "]A3");
-		EXPECT_EQ(result.text(), "A");
-
-		result = parse(row);
-		EXPECT_EQ(result.symbologyIdentifier(), "]A0");
+		auto result = parse(row);
+		EXPECT_EQ(result.symbologyIdentifier(), "]A1");
 		EXPECT_EQ(result.text(), "AA");
 	}
 	{
 		// Extended "a"
 		PatternRow row({ 1, 2, 1, 1, 1, 2, 1, 2, 1, 0, 2, 1, 1, 1, 1, 2, 1, 1, 2 });
-		auto result = parse(row, ReaderOptions().setTryCode39ExtendedMode(true));
+		auto result = parse(row);
 		EXPECT_EQ(result.symbologyIdentifier(), "]A4");
 		EXPECT_EQ(result.text(), "a");
-
-		result = parse(row);
-		EXPECT_EQ(result.symbologyIdentifier(), "]A0");
-		EXPECT_EQ(result.text(), "+A");
 	}
 	{
 		// Extended "a" with checksum
 		PatternRow row({ 1, 2, 1, 1, 1, 2, 1, 2, 1, 0, 2, 1, 1, 1, 1, 2, 1, 1, 2, 0, 2, 1, 1, 2, 1, 1, 2, 1, 1 });
-		auto result = parse(row, ReaderOptions().setTryCode39ExtendedMode(true).setValidateCode39CheckSum(true));
-		EXPECT_EQ(result.symbologyIdentifier(), "]A7");
-		EXPECT_EQ(result.text(), "a");
-
-		result = parse(row);
-		EXPECT_EQ(result.symbologyIdentifier(), "]A0");
-		EXPECT_EQ(result.text(), "+A8");
+		auto result = parse(row);
+		EXPECT_EQ(result.symbologyIdentifier(), "]A5");
+		EXPECT_EQ(result.text(), "a8");
 	}
 }
diff --git a/test/unit/oned/ODCode93ReaderTest.cpp b/test/unit/oned/ODCode93ReaderTest.cpp
index 58c09ea035..4839adbc36 100644
--- a/test/unit/oned/ODCode93ReaderTest.cpp
+++ b/test/unit/oned/ODCode93ReaderTest.cpp
@@ -8,7 +8,7 @@
 #include "BitArray.h"
 #include "BitArrayUtility.h"
 #include "ReaderOptions.h"
-#include "Result.h"
+#include "Barcode.h"
 
 #include "gtest/gtest.h"
 
diff --git a/test/unit/oned/ODDataBarReaderTest.cpp b/test/unit/oned/ODDataBarReaderTest.cpp
index cab6b36876..0c11dd3635 100644
--- a/test/unit/oned/ODDataBarReaderTest.cpp
+++ b/test/unit/oned/ODDataBarReaderTest.cpp
@@ -6,7 +6,7 @@
 #include "oned/ODDataBarReader.h"
 
 #include "ReaderOptions.h"
-#include "Result.h"
+#include "Barcode.h"
 
 #include "gtest/gtest.h"
 
@@ -14,7 +14,7 @@ using namespace ZXing;
 using namespace ZXing::OneD;
 
 // Helper to call decodePattern()
-static Result parse(PatternRow row, ReaderOptions opts = {})
+static Barcode parse(PatternRow row, ReaderOptions opts = {})
 {
 	DataBarReader reader(opts);
 
@@ -31,7 +31,7 @@ TEST(ODDataBarReaderTest, Composite)
 	{
 		// With 2D linkage flag (GS1 Composite) in checksum
 		PatternRow row = { 2, 3, 1, 2, 1, 2, 4, 1, 3, 3, 7, 1, 1, 3, 1, 2, 1, 1, 1, 4, 2, 4, 1, 1, 2, 3, 1, 1, 2, 1, 1, 2, 8, 3, 3, 2, 2, 1, 4, 1, 1, 2 };
-		Result result = parse(row);
+		auto result = parse(row);
 		EXPECT_TRUE(result.isValid());
 		EXPECT_EQ(result.text(), "01234567890128");
 	}
diff --git a/test/unit/qrcode/MQRDecoderTest.cpp b/test/unit/qrcode/MQRDecoderTest.cpp
index 25e7f700de..e173ff9251 100644
--- a/test/unit/qrcode/MQRDecoderTest.cpp
+++ b/test/unit/qrcode/MQRDecoderTest.cpp
@@ -96,7 +96,7 @@ TEST(MQRDecoderTest, MQRCodeM1Error4Bits)
 										  88, false);
 	const auto result = Decode(bitMatrix);
 	EXPECT_EQ(Error::Checksum, result.error());
-	EXPECT_TRUE(result.text().empty());
+	EXPECT_EQ(result.text(), L"6350");
 }
 
 TEST(MQRDecoderTest, MQRCodeM4)
diff --git a/test/unit/qrcode/QRModeTest.cpp b/test/unit/qrcode/QRModeTest.cpp
index 9b83b15e68..fb951175be 100644
--- a/test/unit/qrcode/QRModeTest.cpp
+++ b/test/unit/qrcode/QRModeTest.cpp
@@ -8,7 +8,6 @@
 #include "qrcode/QRVersion.h"
 #include "Error.h"
 
-#include <stdexcept>
 #include "gtest/gtest.h"
 
 using namespace ZXing;
diff --git a/test/unit/qrcode/RMQRDecoderTest.cpp b/test/unit/qrcode/RMQRDecoderTest.cpp
index 46c20664f0..2f995f59fb 100644
--- a/test/unit/qrcode/RMQRDecoderTest.cpp
+++ b/test/unit/qrcode/RMQRDecoderTest.cpp
@@ -46,8 +46,8 @@ TEST(RMQRDecoderTest, RMQRCodeR7x43MError6Bits)
 
 	const auto result = Decode(bitMatrix);
 	EXPECT_EQ(Error::Checksum, result.error());
-	EXPECT_TRUE(result.text().empty());
-	EXPECT_TRUE(result.content().text(TextMode::Plain).empty());
+	EXPECT_EQ(result.text(), L"LSZ2EFJ");
+	EXPECT_EQ(result.content().text(TextMode::Plain), "LSZ2EFJ");
 }
 
 TEST(RMQRDecoderTest, RMQRCodeR7x139H)
diff --git a/wrappers/android/README.md b/wrappers/android/README.md
index c324580e1d..0e10bb804d 100644
--- a/wrappers/android/README.md
+++ b/wrappers/android/README.md
@@ -2,11 +2,16 @@
 
 ## Install
 
-The easiest way to use the library is to fetch if from _mavenCentral_. Simply add
+The easiest way to use the library is to fetch if from _mavenCentral_. Simply add **one** of the following two lines
 ```gradle
 implementation("io.github.zxing-cpp:android:2.2.0")
+implementation("io.github.zxing-cpp:android:2.3.0-SNAPSHOT")
+```
+to your `build.gradle.kts` file in the `dependencies` section. To access the SNAPSHOT version, you also need to add a separate repositories entry in your `build.cradle.kts` file:
+
+```gradle
+maven { url = uri("https://s01.oss.sonatype.org/content/repositories/snapshots") }
 ```
-to your `build.gradle.kts` file in the `dependencies` section.
 
 ## Use
 
diff --git a/wrappers/android/app/src/main/java/zxingcpp/app/MainActivity.kt b/wrappers/android/app/src/main/java/zxingcpp/app/MainActivity.kt
index 2184b1be0d..18b196155d 100644
--- a/wrappers/android/app/src/main/java/zxingcpp/app/MainActivity.kt
+++ b/wrappers/android/app/src/main/java/zxingcpp/app/MainActivity.kt
@@ -1,18 +1,7 @@
 /*
 * Copyright 2021 Axel Waggershauser
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
 */
+// SPDX-License-Identifier: Apache-2.0
 
 package zxingcpp.app
 
@@ -31,9 +20,11 @@ import android.os.Build
 import android.os.Bundle
 import android.os.Environment
 import android.view.View
+import androidx.annotation.OptIn
 import androidx.appcompat.app.AppCompatActivity
 import androidx.camera.camera2.interop.Camera2CameraControl
 import androidx.camera.camera2.interop.CaptureRequestOptions
+import androidx.camera.camera2.interop.ExperimentalCamera2Interop
 import androidx.camera.core.AspectRatio
 import androidx.camera.core.CameraSelector
 import androidx.camera.core.ImageAnalysis
@@ -129,6 +120,7 @@ class MainActivity : AppCompatActivity() {
 		}
 	}
 
+	@OptIn(ExperimentalCamera2Interop::class)
 	private fun bindCameraUseCases() = binding.viewFinder.post {
 
 		val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
@@ -216,6 +208,8 @@ class MainActivity : AppCompatActivity() {
 						hints[DecodeHintType.POSSIBLE_FORMATS] = arrayListOf(BarcodeFormat.QR_CODE)
 					if (binding.tryHarder.isChecked)
 						hints[DecodeHintType.TRY_HARDER] = true
+					if (binding.tryInvert.isChecked)
+						hints[DecodeHintType.ALSO_INVERTED] = true
 
 					resultText = try {
 						val bitmap = BinaryBitmap(
diff --git a/wrappers/android/app/src/main/java/zxingcpp/app/PreviewOverlay.kt b/wrappers/android/app/src/main/java/zxingcpp/app/PreviewOverlay.kt
index 8a79cb117f..f073967836 100644
--- a/wrappers/android/app/src/main/java/zxingcpp/app/PreviewOverlay.kt
+++ b/wrappers/android/app/src/main/java/zxingcpp/app/PreviewOverlay.kt
@@ -1,21 +1,10 @@
 /*
 * Copyright 2022 Axel Waggershauser
 * Copyright 2022 Markus Fisch
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
 */
+// SPDX-License-Identifier: Apache-2.0
 
-package com.example.zxingcppdemo
+package zxingcpp.app
 
 import android.content.Context
 import android.graphics.Canvas
diff --git a/wrappers/android/app/src/main/res/layout-land/activity_camera.xml b/wrappers/android/app/src/main/res/layout-land/activity_camera.xml
index 50f1cb7c31..bc92485970 100644
--- a/wrappers/android/app/src/main/res/layout-land/activity_camera.xml
+++ b/wrappers/android/app/src/main/res/layout-land/activity_camera.xml
@@ -13,7 +13,7 @@
         android:layout_height="match_parent"
         app:scaleType="fitCenter" />
 
-    <com.example.zxingcppdemo.PreviewOverlay
+    <zxingcpp.app.PreviewOverlay
         android:id="@+id/overlay"
         android:layout_width="match_parent"
         android:layout_height="match_parent"/>
diff --git a/wrappers/android/app/src/main/res/layout/activity_camera.xml b/wrappers/android/app/src/main/res/layout/activity_camera.xml
index 41cb9b8fd1..765ff3dd0a 100644
--- a/wrappers/android/app/src/main/res/layout/activity_camera.xml
+++ b/wrappers/android/app/src/main/res/layout/activity_camera.xml
@@ -13,7 +13,7 @@
         android:layout_height="match_parent"
         app:scaleType="fitCenter" />
 
-    <com.example.zxingcppdemo.PreviewOverlay
+    <zxingcpp.app.PreviewOverlay
         android:id="@+id/overlay"
         android:layout_width="match_parent"
         android:layout_height="match_parent"/>
diff --git a/wrappers/android/gradle/libs.versions.toml b/wrappers/android/gradle/libs.versions.toml
index 2f72e440dc..e507208fa9 100644
--- a/wrappers/android/gradle/libs.versions.toml
+++ b/wrappers/android/gradle/libs.versions.toml
@@ -1,20 +1,17 @@
 [versions]
-androidCoreDesugaring = "2.0.3"
-androidGradlePlugin = "8.1.4"
-androidCompileSdk = "34"
+androidGradlePlugin = "8.7.3"
+androidCompileSdk = "35"
 androidMinSdk = "21"
-androidTargetSdk = "33"
-androidx-activity = "1.8.1"
-androidx-appcompat = "1.6.1"
-androidx-camera = "1.3.0"
-androidx-core = "1.12.0"
-androidx-constraintLayout = "2.1.4"
-android-material = "1.11.0-rc01"
+androidTargetSdk = "35"
+androidx-appcompat = "1.7.0"
+androidx-camera = "1.4.1"
+androidx-core = "1.15.0"
+androidx-constraintLayout = "2.2.0"
+android-material = "1.12.0"
 kotlin = "1.9.10"
-zxing-core = "3.5.2"
+zxing-core = "3.5.3"
 
 [libraries]
-androidx-activityktx = { module = "androidx.activity:activity-ktx", version.ref = "androidx-activity" }
 androidx-appcompat = { module = "androidx.appcompat:appcompat", version.ref = "androidx-appcompat" }
 androidx-camera-core = { module = "androidx.camera:camera-core", version.ref = "androidx-camera" }
 androidx-camera-camera2 = { module = "androidx.camera:camera-camera2", version.ref = "androidx-camera" }
diff --git a/wrappers/android/gradle/wrapper/gradle-wrapper.properties b/wrappers/android/gradle/wrapper/gradle-wrapper.properties
index ac72c34e8a..09523c0e54 100644
--- a/wrappers/android/gradle/wrapper/gradle-wrapper.properties
+++ b/wrappers/android/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
diff --git a/wrappers/android/zxingcpp/build.gradle.kts b/wrappers/android/zxingcpp/build.gradle.kts
index 7f1e43c99c..8cdb1d46c8 100644
--- a/wrappers/android/zxingcpp/build.gradle.kts
+++ b/wrappers/android/zxingcpp/build.gradle.kts
@@ -6,9 +6,9 @@ plugins {
 }
 
 android {
-    namespace = "zxingcpp"
-    // ndk version 25 is known to support c++20 (see #386)
-    // ndkVersion = "25.1.8937393"
+    namespace = "zxingcpp.lib" // used to be just zxingcpp but needs to contain a '.' in release builds
+    // ndk version 27 has sufficient c++20 support to enable all features (see #386)
+    // ndkVersion = "27.0.12077973"
 
     defaultConfig {
         compileSdk = libs.versions.androidCompileSdk.get().toInt()
@@ -16,16 +16,16 @@ android {
 
         ndk {
             // speed up build: compile only arm versions
-
-            //noinspection ChromeOsAbiSupport
-            abiFilters += "armeabi-v7a"
-
-            //noinspection ChromeOsAbiSupport
-            abiFilters += "arm64-v8a"
+            // abiFilters += listOf("armeabi-v7a", "arm64-v8a")
         }
         externalNativeBuild {
             cmake {
-                arguments("-DCMAKE_BUILD_TYPE=RelWithDebInfo")
+                arguments(
+                    "-DCMAKE_BUILD_TYPE=RelWithDebInfo",
+                    "-DANDROID_ARM_NEON=ON",
+                    "-DZXING_WRITERS=OFF",
+                    "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON" // This flag can be removed when NDK 28 is the default version
+                )
             }
         }
 
@@ -56,8 +56,9 @@ dependencies {
     implementation(libs.androidx.camera.core)
 }
 
+val publishSnapshot: String? by project
 group = "io.github.zxing-cpp"
-version = "2.2.0"
+version = "2.3.0" + if (publishSnapshot == "true") "-SNAPSHOT" else ""
 
 val javadocJar by tasks.registering(Jar::class) {
     archiveClassifier.set("javadoc")
@@ -107,7 +108,7 @@ publishing {
 
             val releasesRepoUrl = "https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/"
             val snapshotsRepoUrl = "https://s01.oss.sonatype.org/content/repositories/snapshots/"
-            setUrl(if (version.toString().endsWith("SNAPSHOT")) snapshotsRepoUrl else releasesRepoUrl)
+            setUrl(if (version.toString().endsWith("-SNAPSHOT")) snapshotsRepoUrl else releasesRepoUrl)
 
             credentials {
                 val ossrhUsername: String? by project
@@ -120,6 +121,10 @@ publishing {
 }
 
 signing {
+    setRequired {
+        // signing is required if the artifacts are to be published
+        gradle.taskGraph.allTasks.any { it is PublishToMavenRepository }
+    }
     val signingKey: String? by project
     val signingPassword: String? by project
     useInMemoryPgpKeys(signingKey, signingPassword)
diff --git a/wrappers/android/zxingcpp/src/main/AndroidManifest.xml b/wrappers/android/zxingcpp/src/main/AndroidManifest.xml
deleted file mode 100644
index 8072ee00db..0000000000
--- a/wrappers/android/zxingcpp/src/main/AndroidManifest.xml
+++ /dev/null
@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest />
diff --git a/wrappers/android/zxingcpp/src/main/cpp/CMakeLists.txt b/wrappers/android/zxingcpp/src/main/cpp/CMakeLists.txt
index f8b65ae02b..25d5c4dff5 100644
--- a/wrappers/android/zxingcpp/src/main/cpp/CMakeLists.txt
+++ b/wrappers/android/zxingcpp/src/main/cpp/CMakeLists.txt
@@ -5,8 +5,8 @@ project(ZXingCppAndroid)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-set(BUILD_READERS ON)
-set(BUILD_WRITERS OFF)
+set(ZXING_READERS ON)
+set(ZXING_WRITERS OFF)
 
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../../../../../../core ZXing EXCLUDE_FROM_ALL)
 
diff --git a/wrappers/android/zxingcpp/src/main/cpp/ZXingCpp.cpp b/wrappers/android/zxingcpp/src/main/cpp/ZXingCpp.cpp
index e8154aaa3d..54d7c39aa9 100644
--- a/wrappers/android/zxingcpp/src/main/cpp/ZXingCpp.cpp
+++ b/wrappers/android/zxingcpp/src/main/cpp/ZXingCpp.cpp
@@ -45,6 +45,8 @@ static const char* JavaBarcodeFormatName(BarcodeFormat format)
 	case BarcodeFormat::RMQRCode: return "RMQR_CODE";
 	case BarcodeFormat::DataBar: return "DATA_BAR";
 	case BarcodeFormat::DataBarExpanded: return "DATA_BAR_EXPANDED";
+	case BarcodeFormat::DataBarLimited: return "DATA_BAR_LIMITED";
+	case BarcodeFormat::DXFilmEdge: return "DX_FILM_EDGE";
 	case BarcodeFormat::UPCA: return "UPC_A";
 	case BarcodeFormat::UPCE: return "UPC_E";
 	default: throw std::invalid_argument("Invalid BarcodeFormat");
@@ -194,7 +196,7 @@ static jobject NewError(JNIEnv* env, const Error& error)
 	return env->NewObject(cls, midInit, NewEnum(env, JavaErrorTypeName(error.type()), "ErrorType"), C2JString(env, error.msg()));
 }
 
-static jobject NewResult(JNIEnv* env, const Result& result)
+static jobject NewResult(JNIEnv* env, const Barcode& result)
 {
 	jclass cls = env->FindClass(PACKAGE "Result");
 	jmethodID midInit = env->GetMethodID(
@@ -237,7 +239,7 @@ static jobject Read(JNIEnv *env, jobject thiz, ImageView image, const ReaderOpti
 {
 	try {
 		auto startTime = std::chrono::high_resolution_clock::now();
-		auto results = ReadBarcodes(image, opts);
+		auto barcodes = ReadBarcodes(image, opts);
 		auto duration = std::chrono::high_resolution_clock::now() - startTime;
 //		LOGD("time: %4d ms\n", (int)std::chrono::duration_cast<std::chrono::milliseconds>(duration).count());
 		auto time = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
@@ -246,10 +248,10 @@ static jobject Read(JNIEnv *env, jobject thiz, ImageView image, const ReaderOpti
 
 		jclass clsList = env->FindClass("java/util/ArrayList");
 		jobject objList = env->NewObject(clsList, env->GetMethodID(clsList, "<init>", "()V"));
-		if (!results.empty()) {
+		if (!barcodes.empty()) {
 			jmethodID midAdd = env->GetMethodID(clsList, "add", "(Ljava/lang/Object;)Z");
-			for (const auto& result: results)
-				env->CallBooleanMethod(objList, midAdd, NewResult(env, result));
+			for (const auto& barcode: barcodes)
+				env->CallBooleanMethod(objList, midAdd, NewResult(env, barcode));
 		}
 		return objList;
 	} catch (const std::exception& e) {
@@ -310,9 +312,6 @@ static ReaderOptions CreateReaderOptions(JNIEnv* env, jobject opts)
 		.setMinLineCount(GetIntField(env, cls, opts, "minLineCount"))
 		.setMaxNumberOfSymbols(GetIntField(env, cls, opts, "maxNumberOfSymbols"))
 		.setTryCode39ExtendedMode(GetBooleanField(env, cls, opts, "tryCode39ExtendedMode"))
-		.setValidateCode39CheckSum(GetBooleanField(env, cls, opts, "validateCode39CheckSum"))
-		.setValidateITFCheckSum(GetBooleanField(env, cls, opts, "validateITFCheckSum"))
-		.setReturnCodabarStartEnd(GetBooleanField(env, cls, opts, "returnCodabarStartEnd"))
 		.setReturnErrors(GetBooleanField(env, cls, opts, "returnErrors"))
 		.setEanAddOnSymbol(EanAddOnSymbolFromString(GetEnumField(env, cls, opts, "eanAddOnSymbol", "EanAddOnSymbol")))
 		.setTextMode(TextModeFromString(GetEnumField(env, cls, opts, "textMode", "TextMode")))
@@ -363,7 +362,7 @@ Java_zxingcpp_BarcodeReader_readBitmap(
 	ImageFormat fmt = ImageFormat::None;
 	switch (bmInfo.format) {
 	case ANDROID_BITMAP_FORMAT_A_8: fmt = ImageFormat::Lum; break;
-	case ANDROID_BITMAP_FORMAT_RGBA_8888: fmt = ImageFormat::RGBX; break;
+	case ANDROID_BITMAP_FORMAT_RGBA_8888: fmt = ImageFormat::RGBA; break;
 	default: return ThrowJavaException(env, "Unsupported image format in AndroidBitmap");
 	}
 
diff --git a/wrappers/android/zxingcpp/src/main/java/zxingcpp/BarcodeReader.kt b/wrappers/android/zxingcpp/src/main/java/zxingcpp/BarcodeReader.kt
index 2d330baa7b..b1872f9b51 100644
--- a/wrappers/android/zxingcpp/src/main/java/zxingcpp/BarcodeReader.kt
+++ b/wrappers/android/zxingcpp/src/main/java/zxingcpp/BarcodeReader.kt
@@ -1,18 +1,7 @@
 /*
 * Copyright 2021 Axel Waggershauser
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
 */
+// SPDX-License-Identifier: Apache-2.0
 
 package zxingcpp
 
@@ -39,8 +28,8 @@ public class BarcodeReader(public var options: Options = Options()) {
 	// Enumerates barcode formats known to this package.
 	// Note that this has to be kept synchronized with native (C++/JNI) side.
 	public enum class Format {
-		NONE, AZTEC, CODABAR, CODE_39, CODE_93, CODE_128, DATA_BAR, DATA_BAR_EXPANDED,
-		DATA_MATRIX, EAN_8, EAN_13, ITF, MAXICODE, PDF_417, QR_CODE, MICRO_QR_CODE, RMQR_CODE, UPC_A, UPC_E
+		NONE, AZTEC, CODABAR, CODE_39, CODE_93, CODE_128, DATA_BAR, DATA_BAR_EXPANDED, DATA_BAR_LIMITED,
+		DATA_MATRIX, DX_FILM_EDGE, EAN_8, EAN_13, ITF, MAXICODE, PDF_417, QR_CODE, MICRO_QR_CODE, RMQR_CODE, UPC_A, UPC_E
 	}
 
 	public enum class ContentType {
@@ -75,9 +64,12 @@ public class BarcodeReader(public var options: Options = Options()) {
 		var downscaleThreshold: Int = 500,
 		var minLineCount: Int = 2,
 		var maxNumberOfSymbols: Int = 0xff,
-		var tryCode39ExtendedMode: Boolean = false,
+		var tryCode39ExtendedMode: Boolean = true,
+		@Deprecated("See https://github.com/zxing-cpp/zxing-cpp/discussions/704")
 		var validateCode39CheckSum: Boolean = false,
+		@Deprecated("See https://github.com/zxing-cpp/zxing-cpp/discussions/704")
 		var validateITFCheckSum: Boolean = false,
+		@Deprecated("See https://github.com/zxing-cpp/zxing-cpp/discussions/704")
 		var returnCodabarStartEnd: Boolean = false,
 		var returnErrors: Boolean = false,
 		var eanAddOnSymbol: EanAddOnSymbol = EanAddOnSymbol.IGNORE,
diff --git a/wrappers/c/CMakeLists.txt b/wrappers/c/CMakeLists.txt
index 38a817e79e..8ecf07c4c9 100644
--- a/wrappers/c/CMakeLists.txt
+++ b/wrappers/c/CMakeLists.txt
@@ -1,7 +1,7 @@
 zxing_add_package_stb()
 
-if (BUILD_READERS)
-    add_executable (zxing-c-test zxing-c.cpp zxing-c-test.c)
-    target_link_libraries (zxing-c-test ZXing::ZXing stb::stb)
-    add_test(NAME zxing-c-test COMMAND zxing-c-test ${CMAKE_SOURCE_DIR}/test/samples/qrcode-1/1.png)
+if (ZXING_READERS)
+    add_executable (ZXingCTest ZXingCTest.c)
+    target_link_libraries (ZXingCTest ZXing::ZXing stb::stb)
+    add_test(NAME ZXingCTest COMMAND ZXingCTest ${CMAKE_SOURCE_DIR}/test/samples/qrcode-1/1.png)
 endif()
diff --git a/wrappers/c/README.md b/wrappers/c/README.md
index 550565ae71..aa0d8c1a94 100644
--- a/wrappers/c/README.md
+++ b/wrappers/c/README.md
@@ -1,46 +1,56 @@
 # C bindings for zxing-cpp
 
-This is a preview/proposal for a C-API to zxing-cpp. If this turns out to be useful and practical, it will most likely be merged into the library itself so that it will be trivially accessible for everyone. If you have any comments or feedback, please have a look at https://github.com/zxing-cpp/zxing-cpp/discussions/583.
+This is a preview/proposal for a C-API to zxing-cpp. If you have any comments or feedback, please have a look at https://github.com/zxing-cpp/zxing-cpp/discussions/583.
 
 ## Installation
 
-Probably the easiest way to play with the C-API is to either just modify the [zxing-c-test.c](https://github.com/zxing-cpp/zxing-cpp/blob/master/wrappers/c/zxing-c-test.c) file or copy the files [zxing-c.h](https://github.com/zxing-cpp/zxing-cpp/blob/master/wrappers/c/zxing-c.h) and [zxing-c.cpp](https://github.com/zxing-cpp/zxing-cpp/blob/master/wrappers/c/zxing-c.cpp) into your own project and link it to the standard zxing-cpp library.
+It is currently included in the default build to be trivially accessible for everyone.
+
+Probably the easiest way to play with the C-API is to just modify the [ZXingCTest.c](https://github.com/zxing-cpp/zxing-cpp/blob/master/wrappers/c/ZXingCTest.c) file.
 
 ## Usage
 
 The following is close to the most trivial use case scenario that is supported.
 
 ```c
-#include "zxing-c.h"
+#include "ZXing/ZXingC.h"
 
 int main(int argc, char** argv)
 {
 	int width, height;
 	unsigned char* data;
-	/* load your image data from somewhere. ImageFormat_Lum assumes grey scale image data. */
+	/* load your image data from somewhere. ZXing_ImageFormat_Lum assumes grey scale image data. */
+
+	ZXing_ImageView* iv = ZXing_ImageView_new(data, width, height, ZXing_ImageFormat_Lum, 0, 0);
 
-	zxing_ImageView* iv = zxing_ImageView_new(data, width, height, zxing_ImageFormat_Lum, 0, 0);
+	ZXing_ReaderOptions* opts = ZXing_ReaderOptions_new();
+	/* set ReaderOptions properties, if requried, e.g. */
+	ZXing_ReaderOptions_setFormats(ZXing_BarcodeFormat_QRCode | ZXing_BarcodeFromat_EAN13);
 
-	zxing_ReaderOptions* opts = zxing_ReaderOptions_new();
-	/* set ReaderOptions properties, if requried */
+	ZXing_Barcodes* barcodes = ZXing_ReadBarcodes(iv, opts);
 
-	zxing_Result* result = zxing_ReadBarcode(iv, opts);
+	ZXing_ImageView_delete(iv);
+	ZXing_ReaderOptions_delete(opts);
 
-	if (result) {
-		printf("Format     : %s\n", zxing_BarcodeFormatToString(zxing_Result_format(result)));
+	if (barcodes) {
+		for (int i = 0, n = ZXing_Barcodes_size(barcodes); i < n; ++i) {
+			const ZXing_Barcode* barcode = ZXing_Barcodes_at(barcodes, i);
 
-		const char* text = zxing_Result_text(result);
-		printf("Text       : %s\n", text);
-		free(text);
+			char* format = ZXing_BarcodeFormatToString(ZXing_Barcode_format(barcode));
+			printf("Format     : %s\n", format);
+			ZXing_free(format);
 
-		zxing_Result_delete(result);
+			char* text = ZXing_Barcode_text(barcode);
+			printf("Text       : %s\n", text);
+			ZXing_free(text);
+		}
+		ZXing_Barcodes_delete(barcodes);
 	} else {
-		printf("No barcode found\n");
+		char* error = ZXing_LastErrorMsg();
+		fprintf(stderr, "%s\n", error);
+		ZXing_free(error);
 	}
 
-	zxing_ImageView_delete(iv);
-	zxing_ReaderOptions_delete(opts);
-
 	return 0;
 }
 ```
diff --git a/wrappers/c/ZXingCTest.c b/wrappers/c/ZXingCTest.c
new file mode 100644
index 0000000000..161c6dd5a1
--- /dev/null
+++ b/wrappers/c/ZXingCTest.c
@@ -0,0 +1,134 @@
+/*
+* Copyright 2023 siiky
+* Copyright 2023 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#include "ZXingC.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define STB_IMAGE_IMPLEMENTATION
+#define STBI_NO_LINEAR // prevent dependency on -lm
+#define STBI_NO_HDR
+#include <stb_image.h>
+
+int usage(char* pname)
+{
+	fprintf(stderr, "ZXingCTest %s, usage: %s FILE [FORMATS]\n", ZXing_Version(), pname);
+	return 1;
+}
+
+bool parse_args(int argc, char** argv, char** filename, ZXing_BarcodeFormats* formats)
+{
+	if (argc < 2)
+		return false;
+	*filename = argv[1];
+	if (argc >= 3) {
+		*formats = ZXing_BarcodeFormatsFromString(argv[2]);
+		if (*formats == ZXing_BarcodeFormat_Invalid) {
+			fprintf(stderr, "%s\n", ZXing_LastErrorMsg());
+			return false;
+		}
+	}
+	return true;
+}
+
+void printF(const char* fmt, char* text)
+{
+	if (!text)
+		return;
+	if (*text)
+		printf(fmt, text);
+	ZXing_free(text);
+}
+
+#define CHECK(GOOD) \
+	if (!(GOOD)) { \
+		char* error = ZXing_LastErrorMsg(); \
+		fprintf(stderr, "CHECK(%s) failed: %s\n", #GOOD, error); \
+		ZXing_free(error); \
+		return 2; \
+	}
+
+int main(int argc, char** argv)
+{
+	int ret = 0;
+	char* filename = NULL;
+	ZXing_BarcodeFormats formats = ZXing_BarcodeFormat_None;
+
+	if (!parse_args(argc, argv, &filename, &formats))
+		return usage(argv[0]);
+
+	int width = 0;
+	int height = 0;
+	int channels = 0;
+	stbi_uc* data = stbi_load(filename, &width, &height, &channels, STBI_grey);
+
+	ZXing_ImageView* iv = NULL;
+	ZXing_Image* img = NULL;
+
+	if (data) {
+		iv = ZXing_ImageView_new(data, width, height, ZXing_ImageFormat_Lum, 0, 0);
+		CHECK(iv)
+	} else {
+		fprintf(stderr, "Could not read image '%s'\n", filename);
+#if defined(ZXING_EXPERIMENTAL_API) && defined(ZXING_WRITERS)
+		if (formats == ZXing_BarcodeFormat_Invalid)
+			return 2;
+		fprintf(stderr, "Using '%s' as text input to create barcode\n", filename);
+		ZXing_CreatorOptions* cOpts = ZXing_CreatorOptions_new(formats);
+		CHECK(cOpts)
+		ZXing_Barcode* barcode = ZXing_CreateBarcodeFromText(filename, 0, cOpts);
+		CHECK(barcode)
+		img = ZXing_WriteBarcodeToImage(barcode, NULL);
+		CHECK(img)
+		ZXing_CreatorOptions_delete(cOpts);
+		ZXing_Barcode_delete(barcode);
+#else
+		return 2;
+#endif
+	}
+
+	ZXing_ReaderOptions* opts = ZXing_ReaderOptions_new();
+	ZXing_ReaderOptions_setTextMode(opts, ZXing_TextMode_HRI);
+	ZXing_ReaderOptions_setEanAddOnSymbol(opts, ZXing_EanAddOnSymbol_Ignore);
+	ZXing_ReaderOptions_setFormats(opts, formats);
+	ZXing_ReaderOptions_setReturnErrors(opts, true);
+
+	ZXing_Barcodes* barcodes = ZXing_ReadBarcodes(iv ? iv : (ZXing_ImageView*)img, opts);
+	CHECK(barcodes)
+
+	ZXing_ImageView_delete(iv);
+	ZXing_Image_delete(img);
+	ZXing_ReaderOptions_delete(opts);
+	stbi_image_free(data);
+
+	for (int i = 0, n = ZXing_Barcodes_size(barcodes); i < n; ++i) {
+		const ZXing_Barcode* barcode = ZXing_Barcodes_at(barcodes, i);
+
+		printF("Text       : %s\n", ZXing_Barcode_text(barcode));
+		printF("BytesECI   : %s\n", (char*)ZXing_Barcode_bytesECI(barcode, NULL));
+		printF("Format     : %s\n", ZXing_BarcodeFormatToString(ZXing_Barcode_format(barcode)));
+		printF("Content    : %s\n", ZXing_ContentTypeToString(ZXing_Barcode_contentType(barcode)));
+		printF("Identifier : %s\n", ZXing_Barcode_symbologyIdentifier(barcode));
+		printf("HasECI     : %d\n", ZXing_Barcode_hasECI(barcode));
+		printF("EC Level   : %s\n", ZXing_Barcode_ecLevel(barcode));
+		printF("Error      : %s\n", ZXing_Barcode_errorMsg(barcode));
+		printF("Position   : %s\n", ZXing_PositionToString(ZXing_Barcode_position(barcode)));
+		printf("Rotation   : %d\n", ZXing_Barcode_orientation(barcode));
+		printf("IsMirrored : %d\n", ZXing_Barcode_isMirrored(barcode));
+		printf("IsInverted : %d\n", ZXing_Barcode_isInverted(barcode));
+
+		if (i < n-1)
+			printf("\n");
+	}
+
+	if (ZXing_Barcodes_size(barcodes) == 0)
+		printf("No barcode found\n");
+
+	ZXing_Barcodes_delete(barcodes);
+
+	return ret;
+}
diff --git a/wrappers/c/zxing-c-test.c b/wrappers/c/zxing-c-test.c
deleted file mode 100644
index 0497a1cadd..0000000000
--- a/wrappers/c/zxing-c-test.c
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
-* Copyright 2023 siiky
-* Copyright 2023 Axel Waggershauser
-*/
-// SPDX-License-Identifier: Apache-2.0
-
-#include "zxing-c.h"
-
-#define STB_IMAGE_IMPLEMENTATION
-#include <stb_image.h>
-
-int usage(char* pname)
-{
-	fprintf(stderr, "Usage: %s FILE [FORMATS]\n", pname);
-	return 1;
-}
-
-bool parse_args(int argc, char** argv, char** filename, zxing_BarcodeFormats* formats)
-{
-	if (argc < 2)
-		return false;
-	*filename = argv[1];
-	if (argc >= 3) {
-		*formats = zxing_BarcodeFormatsFromString(argv[2]);
-		if (*formats == zxing_BarcodeFormat_Invalid) {
-			fprintf(stderr, "Invalid barcode formats string '%s'\n", argv[2]);
-			return false;
-		}
-	}
-	return true;
-}
-
-void printF(const char* fmt, char* text)
-{
-	if (!text)
-		return;
-	if (*text)
-		printf(fmt, text);
-	free(text);
-}
-
-int main(int argc, char** argv)
-{
-	char* filename = NULL;
-	zxing_BarcodeFormats formats = zxing_BarcodeFormat_None;
-
-	if (!parse_args(argc, argv, &filename, &formats))
-		return usage(argv[0]);
-
-	int width = 0;
-	int height = 0;
-	int channels = 0;
-	stbi_uc* data = stbi_load(filename, &width, &height, &channels, STBI_grey);
-	if (!data)
-		return 2;
-
-	zxing_ReaderOptions* opts = zxing_ReaderOptions_new();
-	zxing_ReaderOptions_setTextMode(opts, zxing_TextMode_HRI);
-	zxing_ReaderOptions_setEanAddOnSymbol(opts, zxing_EanAddOnSymbol_Ignore);
-	zxing_ReaderOptions_setFormats(opts, formats);
-	zxing_ReaderOptions_setReturnErrors(opts, true);
-
-	zxing_ImageView* iv = zxing_ImageView_new(data, width, height, zxing_ImageFormat_Lum, 0, 0);
-
-	zxing_Results* results = zxing_ReadBarcodes(iv, opts);
-
-	if (results) {
-		for (int i = 0, n = zxing_Results_size(results); i < n; ++i) {
-			const zxing_Result* result = zxing_Results_at(results, i);
-
-			printF("Text       : %s\n", zxing_Result_text(result));
-			printF("Format     : %s\n", zxing_BarcodeFormatToString(zxing_Result_format(result)));
-			printF("Content    : %s\n", zxing_ContentTypeToString(zxing_Result_contentType(result)));
-			printF("Identifier : %s\n", zxing_Result_symbologyIdentifier(result));
-			printF("EC Level   : %s\n", zxing_Result_ecLevel(result));
-			printF("Error      : %s\n", zxing_Result_errorMsg(result));
-			printf("Rotation   : %d\n", zxing_Result_orientation(result));
-
-			if (i < n-1)
-				printf("\n");
-		}
-
-		zxing_Results_delete(results);
-	} else {
-		printf("No barcode found\n");
-	}
-
-	zxing_ImageView_delete(iv);
-	zxing_ReaderOptions_delete(opts);
-	stbi_image_free(data);
-
-	return 0;
-}
diff --git a/wrappers/c/zxing-c.cpp b/wrappers/c/zxing-c.cpp
deleted file mode 100644
index 00c09963fe..0000000000
--- a/wrappers/c/zxing-c.cpp
+++ /dev/null
@@ -1,246 +0,0 @@
-/*
-* Copyright 2023 siiky
-* Copyright 2023 Axel Waggershauser
-*/
-// SPDX-License-Identifier: Apache-2.0
-
-#include "zxing-c.h"
-
-#include "ReadBarcode.h"
-
-using namespace ZXing;
-
-char* copy(std::string_view sv)
-{
-	auto ret = (char*)malloc(sv.size() + 1);
-	if (ret) {
-		strncpy(ret, sv.data(), sv.size());
-		ret[sv.size()] = '\0';
-	}
-	return ret;
-}
-
-extern "C" {
-/*
- * ZXing/ImageView.h
- */
-
-zxing_ImageView* zxing_ImageView_new(const uint8_t* data, int width, int height, zxing_ImageFormat format, int rowStride,
-									 int pixStride)
-{
-	ImageFormat cppformat = static_cast<ImageFormat>(format);
-	return new ImageView(data, width, height, cppformat, rowStride, pixStride);
-}
-
-void zxing_ImageView_delete(zxing_ImageView* iv)
-{
-	delete iv;
-}
-
-/*
- * ZXing/BarcodeFormat.h
- */
-
-zxing_BarcodeFormats zxing_BarcodeFormatsFromString(const char* str)
-{
-	if (!str)
-		return {};
-	try {
-		auto format = BarcodeFormatsFromString(str);
-		return static_cast<zxing_BarcodeFormats>(*reinterpret_cast<BarcodeFormat*>(&format));
-	} catch (...) {
-		return zxing_BarcodeFormat_Invalid;
-	}
-}
-
-zxing_BarcodeFormat zxing_BarcodeFormatFromString(const char* str)
-{
-	zxing_BarcodeFormat res = zxing_BarcodeFormatsFromString(str);
-	return BitHacks::CountBitsSet(res) == 1 ? res : zxing_BarcodeFormat_Invalid;
-}
-
-char* zxing_BarcodeFormatToString(zxing_BarcodeFormat format)
-{
-	return copy(ToString(static_cast<BarcodeFormat>(format)));
-}
-
-/*
- * ZXing/ReaderOptions.h
- */
-
-zxing_ReaderOptions* zxing_ReaderOptions_new()
-{
-	return new ReaderOptions();
-}
-
-void zxing_ReaderOptions_delete(zxing_ReaderOptions* opts)
-{
-	delete opts;
-}
-
-void zxing_ReaderOptions_setTryHarder(zxing_ReaderOptions* opts, bool tryHarder)
-{
-	opts->setTryHarder(tryHarder);
-}
-
-void zxing_ReaderOptions_setTryRotate(zxing_ReaderOptions* opts, bool tryRotate)
-{
-	opts->setTryRotate(tryRotate);
-}
-
-void zxing_ReaderOptions_setTryInvert(zxing_ReaderOptions* opts, bool tryInvert)
-{
-	opts->setTryInvert(tryInvert);
-}
-
-void zxing_ReaderOptions_setTryDownscale(zxing_ReaderOptions* opts, bool tryDownscale)
-{
-	opts->setTryDownscale(tryDownscale);
-}
-
-void zxing_ReaderOptions_setIsPure(zxing_ReaderOptions* opts, bool isPure)
-{
-	opts->setIsPure(isPure);
-}
-
-void zxing_ReaderOptions_setReturnErrors(zxing_ReaderOptions* opts, bool returnErrors)
-{
-	opts->setReturnErrors(returnErrors);
-}
-
-void zxing_ReaderOptions_setFormats(zxing_ReaderOptions* opts, zxing_BarcodeFormats formats)
-{
-	opts->setFormats(static_cast<BarcodeFormat>(formats));
-}
-
-void zxing_ReaderOptions_setBinarizer(zxing_ReaderOptions* opts, zxing_Binarizer binarizer)
-{
-	opts->setBinarizer(static_cast<Binarizer>(binarizer));
-}
-
-void zxing_ReaderOptions_setEanAddOnSymbol(zxing_ReaderOptions* opts, zxing_EanAddOnSymbol eanAddOnSymbol)
-{
-	opts->setEanAddOnSymbol(static_cast<EanAddOnSymbol>(eanAddOnSymbol));
-}
-
-void zxing_ReaderOptions_setTextMode(zxing_ReaderOptions* opts, zxing_TextMode textMode)
-{
-	opts->setTextMode(static_cast<TextMode>(textMode));
-}
-
-void zxing_ReaderOptions_setMaxNumberOfSymbols(zxing_ReaderOptions* opts, int n)
-{
-	opts->setMaxNumberOfSymbols(n);
-}
-
-/*
- * ZXing/Result.h
- */
-
-char* zxing_ContentTypeToString(zxing_ContentType type)
-{
-	return copy(ToString(static_cast<ContentType>(type)));
-}
-
-bool zxing_Result_isValid(const zxing_Result* result)
-{
-	return result != NULL && result->isValid();
-}
-
-char* zxing_Result_errorMsg(const zxing_Result* result)
-{
-	return copy(ToString(result->error()));
-}
-
-zxing_BarcodeFormat zxing_Result_format(const zxing_Result* result)
-{
-	return static_cast<zxing_BarcodeFormat>(result->format());
-}
-
-zxing_ContentType zxing_Result_contentType(const zxing_Result* result)
-{
-	return static_cast<zxing_ContentType>(result->contentType());
-}
-
-uint8_t* zxing_Result_bytes(const zxing_Result* result, int* len)
-{
-	*len = Size(result->bytes());
-
-	auto ret = (uint8_t*)malloc(*len + 1);
-	if (ret)
-		memcpy(ret, result->bytes().data(), *len);
-	else
-		*len = 0;
-
-	return ret;
-}
-
-char* zxing_Result_text(const zxing_Result* result)
-{
-	return copy(result->text());
-}
-
-char* zxing_Result_ecLevel(const zxing_Result* result)
-{
-	return copy(result->ecLevel());
-}
-
-char* zxing_Result_symbologyIdentifier(const zxing_Result* result)
-{
-	return copy(result->symbologyIdentifier());
-}
-
-int zxing_Result_orientation(const zxing_Result* result)
-{
-	return result->orientation();
-}
-
-bool zxing_Result_isInverted(const zxing_Result* result)
-{
-	return result->isInverted();
-}
-
-bool zxing_Result_isMirrored(const zxing_Result* result)
-{
-	return result->isMirrored();
-}
-
-/*
- * ZXing/ReadBarcode.h
- */
-
-zxing_Result* zxing_ReadBarcode(const zxing_ImageView* iv, const zxing_ReaderOptions* opts)
-{
-	auto res = ReadBarcode(*iv, *opts);
-	return res.format() != BarcodeFormat::None ? new Result(std::move(res)) : NULL;
-}
-
-zxing_Results* zxing_ReadBarcodes(const zxing_ImageView* iv, const zxing_ReaderOptions* opts)
-{
-	auto res = ReadBarcodes(*iv, *opts);
-	return !res.empty() ? new Results(std::move(res)) : NULL;
-}
-
-void zxing_Result_delete(zxing_Result* result)
-{
-	delete result;
-}
-
-void zxing_Results_delete(zxing_Results* results)
-{
-	delete results;
-}
-
-int zxing_Results_size(const zxing_Results* results)
-{
-	return results ? Size(*results) : 0;
-}
-
-const zxing_Result* zxing_Results_at(const zxing_Results* results, int i)
-{
-	if (!results || i < 0 || i >= Size(*results))
-		return NULL;
-	return &(*results)[i];
-}
-
-} // extern "C"
diff --git a/wrappers/c/zxing-c.h b/wrappers/c/zxing-c.h
deleted file mode 100644
index 636dd433b4..0000000000
--- a/wrappers/c/zxing-c.h
+++ /dev/null
@@ -1,187 +0,0 @@
-/*
-* Copyright 2023 siiky
-* Copyright 2023 Axel Waggershauser
-*/
-// SPDX-License-Identifier: Apache-2.0
-
-#ifndef _ZXING_C_H
-#define _ZXING_C_H
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-
-#include "ReaderOptions.h"
-#include "ImageView.h"
-#include "Result.h"
-
-typedef ZXing::ImageView zxing_ImageView;
-typedef ZXing::ReaderOptions zxing_ReaderOptions;
-typedef ZXing::Result zxing_Result;
-typedef ZXing::Results zxing_Results;
-
-extern "C"
-{
-#else
-
-typedef struct zxing_ImageView zxing_ImageView;
-typedef struct zxing_ReaderOptions zxing_ReaderOptions;
-typedef struct zxing_Result zxing_Result;
-typedef struct zxing_Results zxing_Results;
-
-#endif
-
-/*
- * ZXing/ImageView.h
- */
-
-typedef enum
-{
-	zxing_ImageFormat_None = 0,
-	zxing_ImageFormat_Lum = 0x01000000,
-	zxing_ImageFormat_RGB = 0x03000102,
-	zxing_ImageFormat_BGR = 0x03020100,
-	zxing_ImageFormat_RGBX = 0x04000102,
-	zxing_ImageFormat_XRGB = 0x04010203,
-	zxing_ImageFormat_BGRX = 0x04020100,
-	zxing_ImageFormat_XBGR = 0x04030201,
-} zxing_ImageFormat;
-
-zxing_ImageView* zxing_ImageView_new(const uint8_t* data, int width, int height, zxing_ImageFormat format, int rowStride,
-									 int pixStride);
-void zxing_ImageView_delete(zxing_ImageView* iv);
-
-/*
- * ZXing/BarcodeFormat.h
- */
-
-typedef enum
-{
-	zxing_BarcodeFormat_None = 0,
-	zxing_BarcodeFormat_Aztec = (1 << 0),
-	zxing_BarcodeFormat_Codabar = (1 << 1),
-	zxing_BarcodeFormat_Code39 = (1 << 2),
-	zxing_BarcodeFormat_Code93 = (1 << 3),
-	zxing_BarcodeFormat_Code128 = (1 << 4),
-	zxing_BarcodeFormat_DataBar = (1 << 5),
-	zxing_BarcodeFormat_DataBarExpanded = (1 << 6),
-	zxing_BarcodeFormat_DataMatrix = (1 << 7),
-	zxing_BarcodeFormat_EAN8 = (1 << 8),
-	zxing_BarcodeFormat_EAN13 = (1 << 9),
-	zxing_BarcodeFormat_ITF = (1 << 10),
-	zxing_BarcodeFormat_MaxiCode = (1 << 11),
-	zxing_BarcodeFormat_PDF417 = (1 << 12),
-	zxing_BarcodeFormat_QRCode = (1 << 13),
-	zxing_BarcodeFormat_UPCA = (1 << 14),
-	zxing_BarcodeFormat_UPCE = (1 << 15),
-	zxing_BarcodeFormat_MicroQRCode = (1 << 16),
-	zxing_BarcodeFormat_RMQRCode = (1 << 17),
-
-	zxing_BarcodeFormat_LinearCodes = zxing_BarcodeFormat_Codabar | zxing_BarcodeFormat_Code39 | zxing_BarcodeFormat_Code93
-									  | zxing_BarcodeFormat_Code128 | zxing_BarcodeFormat_EAN8 | zxing_BarcodeFormat_EAN13
-									  | zxing_BarcodeFormat_ITF | zxing_BarcodeFormat_DataBar | zxing_BarcodeFormat_DataBarExpanded
-									  | zxing_BarcodeFormat_UPCA | zxing_BarcodeFormat_UPCE,
-	zxing_BarcodeFormat_MatrixCodes = zxing_BarcodeFormat_Aztec | zxing_BarcodeFormat_DataMatrix | zxing_BarcodeFormat_MaxiCode
-									  | zxing_BarcodeFormat_PDF417 | zxing_BarcodeFormat_QRCode | zxing_BarcodeFormat_MicroQRCode
-									  | zxing_BarcodeFormat_RMQRCode,
-	zxing_BarcodeFormat_Any = zxing_BarcodeFormat_LinearCodes | zxing_BarcodeFormat_MatrixCodes,
-
-	zxing_BarcodeFormat_Invalid = -1 /* return value when BarcodeFormatsFromString() throws */
-} zxing_BarcodeFormat;
-
-typedef zxing_BarcodeFormat zxing_BarcodeFormats;
-
-zxing_BarcodeFormats zxing_BarcodeFormatsFromString(const char* str);
-zxing_BarcodeFormat zxing_BarcodeFormatFromString(const char* str);
-char* zxing_BarcodeFormatToString(zxing_BarcodeFormat format);
-
-/*
- * ZXing/ReaderOptions.h
- */
-
-typedef enum
-{
-	zxing_Binarizer_LocalAverage,
-	zxing_Binarizer_GlobalHistogram,
-	zxing_Binarizer_FixedThreshold,
-	zxing_Binarizer_BoolCast,
-} zxing_Binarizer;
-
-typedef enum
-{
-	zxing_EanAddOnSymbol_Ignore,
-	zxing_EanAddOnSymbol_Read,
-	zxing_EanAddOnSymbol_Require,
-} zxing_EanAddOnSymbol;
-
-typedef enum
-{
-	zxing_TextMode_Plain,
-	zxing_TextMode_ECI,
-	zxing_TextMode_HRI,
-	zxing_TextMode_Hex,
-	zxing_TextMode_Escaped,
-} zxing_TextMode;
-
-zxing_ReaderOptions* zxing_ReaderOptions_new();
-void zxing_ReaderOptions_delete(zxing_ReaderOptions* opts);
-
-void zxing_ReaderOptions_setTryHarder(zxing_ReaderOptions* opts, bool tryHarder);
-void zxing_ReaderOptions_setTryRotate(zxing_ReaderOptions* opts, bool tryRotate);
-void zxing_ReaderOptions_setTryInvert(zxing_ReaderOptions* opts, bool tryInvert);
-void zxing_ReaderOptions_setTryDownscale(zxing_ReaderOptions* opts, bool tryDownscale);
-void zxing_ReaderOptions_setIsPure(zxing_ReaderOptions* opts, bool isPure);
-void zxing_ReaderOptions_setReturnErrors(zxing_ReaderOptions* opts, bool returnErrors);
-void zxing_ReaderOptions_setFormats(zxing_ReaderOptions* opts, zxing_BarcodeFormats formats);
-void zxing_ReaderOptions_setBinarizer(zxing_ReaderOptions* opts, zxing_Binarizer binarizer);
-void zxing_ReaderOptions_setEanAddOnSymbol(zxing_ReaderOptions* opts, zxing_EanAddOnSymbol eanAddOnSymbol);
-void zxing_ReaderOptions_setTextMode(zxing_ReaderOptions* opts, zxing_TextMode textMode);
-void zxing_ReaderOptions_setMaxNumberOfSymbols(zxing_ReaderOptions* opts, int n);
-
-/*
- * ZXing/Result.h
- */
-
-typedef enum
-{
-	zxing_ContentType_Text,
-	zxing_ContentType_Binary,
-	zxing_ContentType_Mixed,
-	zxing_ContentType_GS1,
-	zxing_ContentType_ISO15434,
-	zxing_ContentType_UnknownECI
-} zxing_ContentType;
-
-char* zxing_ContentTypeToString(zxing_ContentType type);
-
-bool zxing_Result_isValid(const zxing_Result* result);
-char* zxing_Result_errorMsg(const zxing_Result* result);
-zxing_BarcodeFormat zxing_Result_format(const zxing_Result* result);
-zxing_ContentType zxing_Result_contentType(const zxing_Result* result);
-uint8_t* zxing_Result_bytes(const zxing_Result* result, int* len);
-char* zxing_Result_text(const zxing_Result* result);
-char* zxing_Result_ecLevel(const zxing_Result* result);
-char* zxing_Result_symbologyIdentifier(const zxing_Result* result);
-int zxing_Result_orientation(const zxing_Result* result);
-bool zxing_Result_isInverted(const zxing_Result* result);
-bool zxing_Result_isMirrored(const zxing_Result* result);
-
-/*
- * ZXing/ReadBarcode.h
- */
-
-zxing_Result* zxing_ReadBarcode(const zxing_ImageView* iv, const zxing_ReaderOptions* opts);
-zxing_Results* zxing_ReadBarcodes(const zxing_ImageView* iv, const zxing_ReaderOptions* opts);
-
-void zxing_Result_delete(zxing_Result* result);
-void zxing_Results_delete(zxing_Results* results);
-
-int zxing_Results_size(const zxing_Results* results);
-const zxing_Result* zxing_Results_at(const zxing_Results* results, int i);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _ZXING_C_H */
diff --git a/wrappers/dotnet/.gitignore b/wrappers/dotnet/.gitignore
new file mode 100644
index 0000000000..0069337825
--- /dev/null
+++ b/wrappers/dotnet/.gitignore
@@ -0,0 +1,59 @@
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from `dotnet new gitignore`
+
+# hand selected runtime/dll files
+runtimes
+
+# dotenv files
+.env
+
+# User-specific files
+*.rsuser
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Mono auto generated files
+mono_crash.*
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+[Ww][Ii][Nn]32/
+[Aa][Rr][Mm]/
+[Aa][Rr][Mm]64/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+[Ll]ogs/
+
+# Visual Studio 2015/2017 cache/options directory
+.vs/
+
+# Visual Studio 2017 auto generated files
+Generated\ Files/
+
+# NuGet Packages
+*.nupkg
+# NuGet Symbol Packages
+*.snupkg
+# The packages folder can be ignored because of Package Restore
+**/[Pp]ackages/*
+# except build/, which is used as an MSBuild target.
+!**/[Pp]ackages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/[Pp]ackages/repositories.config
+# NuGet v3's project.json files produces more ignorable files
+*.nuget.props
+*.nuget.targets
diff --git a/wrappers/dotnet/README.md b/wrappers/dotnet/README.md
new file mode 100644
index 0000000000..f68d21566a
--- /dev/null
+++ b/wrappers/dotnet/README.md
@@ -0,0 +1,29 @@
+# ZXingCpp
+
+ZXingCpp is a .NET wrapper for [zxing-cpp](https://github.com/zxing-cpp/zxing-cpp).
+
+There is a NuGet package available: https://www.nuget.org/packages/ZXingCpp.
+
+## Usage
+
+See either the [ZXingCpp/README.md](ZXingCpp/README.md) or the [ZXingCpp.Demo](ZXingCpp.Demo) project.
+
+To run the `ZXingCpp.Demo` sample program, it is important that the dotnet runtime finds the native
+`ZXing[.dll|.so|.dylib]` in your path. E.g. on Linux a complete command line would look like this
+
+```sh
+LD_LIBRARY_PATH=<ZXing.so-path> dotnet run --project ZXingCpp.Demo -- ../../test/samples/multi-1/1.png
+```
+
+## Benchmarking
+
+To compare the performance of this .NET wrapper project with other available barcode scanner .NET libraries,
+I started the project [zxing-bench](https://github.com/axxel/zxing-bench). The README contains a few
+results to get an idea.
+
+## Release howto (for internal use)
+
+ * download `*-latest-exp-artifacts` from gha page and copy binaries to `runtimes`
+ * update `Version` in `ZXingCpp.csproj`
+ * `dotnet pack`
+ * `dotnet nuget push ZXingCpp/bin/Release/ZXingCpp.<version>.nupkg -s https://api.nuget.org/v3/index.json -k <api-key>`
diff --git a/wrappers/dotnet/ZXingCpp.DemoReader/Program.cs b/wrappers/dotnet/ZXingCpp.DemoReader/Program.cs
new file mode 100644
index 0000000000..7e9b672c5a
--- /dev/null
+++ b/wrappers/dotnet/ZXingCpp.DemoReader/Program.cs
@@ -0,0 +1,72 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+using System.Collections.Generic;
+using ImageMagick;
+using SkiaSharp;
+using ZXingCpp;
+
+public static class MagickImageBarcodeReader
+{
+	public static Barcode[] Read(MagickImage img, ReaderOptions? opts = null)
+	{
+		if (img.DetermineBitDepth() < 8)
+			img.SetBitDepth(8);
+		var bytes = img.ToByteArray(MagickFormat.Gray);
+		var iv = new ImageView(bytes, img.Width, img.Height, ImageFormat.Lum);
+		return BarcodeReader.Read(iv, opts);
+	}
+
+	public static Barcode[] From(this BarcodeReader reader, MagickImage img) => Read(img, reader);
+}
+
+public static class SkBitmapBarcodeReader
+{
+	public static Barcode[] Read(SKBitmap img, ReaderOptions? opts = null)
+	{
+		var format = img.Info.ColorType switch
+		{
+			SKColorType.Gray8 => ImageFormat.Lum,
+			SKColorType.Rgba8888 => ImageFormat.RGBA,
+			SKColorType.Bgra8888 => ImageFormat.BGRA,
+			_ => ImageFormat.None,
+		};
+		if (format == ImageFormat.None)
+		{
+			if (!img.CanCopyTo(SKColorType.Gray8))
+				throw new Exception("Incompatible SKColorType");
+			img = img.Copy(SKColorType.Gray8);
+			format = ImageFormat.Lum;
+		}
+		var iv = new ImageView(img.GetPixels(), img.Info.Width, img.Info.Height, format);
+		return BarcodeReader.Read(iv, opts);
+	}
+
+	public static Barcode[] From(this BarcodeReader reader, SKBitmap img) => Read(img, reader);
+}
+
+public class Program
+{
+	public static void Main(string[] args)
+	{
+#if false
+		var img = new MagickImage(args[0]);
+#else
+		var img = SKBitmap.Decode(args[0]);
+#endif
+		Console.WriteLine(img);
+
+		var readBarcodes = new BarcodeReader() {
+			TryInvert = false,
+			ReturnErrors = true,
+		};
+
+		if (args.Length >= 2)
+			readBarcodes.Formats = Barcode.FormatsFromString(args[1]);
+
+		foreach (var b in readBarcodes.From(img))
+			Console.WriteLine($"{b.Format} ({b.ContentType}): {b.Text} / [{string.Join(", ", b.Bytes)}] {b.ErrorMsg}");
+	}
+}
diff --git a/wrappers/dotnet/ZXingCpp.DemoReader/ZXingCpp.DemoReader.csproj b/wrappers/dotnet/ZXingCpp.DemoReader/ZXingCpp.DemoReader.csproj
new file mode 100644
index 0000000000..f6cbee8124
--- /dev/null
+++ b/wrappers/dotnet/ZXingCpp.DemoReader/ZXingCpp.DemoReader.csproj
@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="SkiaSharp" Version="2.88.7" ExcludeAssets="native" />
+    <!-- the following line was required to make dotnet install the missing *.so file on Linux -->
+    <!-- on another platform, you will need to remove the "ExludeAssets" property above -->
+    <PackageReference Include="SkiaSharp.NativeAssets.Linux.NoDependencies" Version="2.88.7" />
+    <PackageReference Include="Magick.NET-Q8-x64" Version="13.5.0" />
+    <ProjectReference Include="..\ZXingCpp\ZXingCpp.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/wrappers/dotnet/ZXingCpp.DemoWriter/Program.cs b/wrappers/dotnet/ZXingCpp.DemoWriter/Program.cs
new file mode 100644
index 0000000000..93f0e779f3
--- /dev/null
+++ b/wrappers/dotnet/ZXingCpp.DemoWriter/Program.cs
@@ -0,0 +1,43 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+using System.Collections.Generic;
+using SkiaSharp;
+using ZXingCpp;
+
+public static class SkBitmapBarcodeWriter
+{
+	public static SKBitmap Write(Barcode barcode, WriterOptions? opts = null)
+	{
+		var img = barcode.ToImage(opts);
+		var info = new SKImageInfo(img.Width, img.Height, SKColorType.Gray8);
+		var res = new SKBitmap();
+		res.InstallPixels(info, img.Data, img.Width, (IntPtr _, object _) => img.Dispose());
+		return res;
+	}
+
+	public static SKBitmap ToSKBitmap(this Barcode barcode, WriterOptions? opts = null) => Write(barcode, opts);
+}
+
+public class Program
+{
+	public static void Main(string[] args)
+	{
+		var (format, text, fn) = (args[0], args[1], args[2]);
+
+		var bc = new Barcode(text, Barcode.FormatFromString(format));
+
+		var img = bc.ToImage();
+		Console.WriteLine($"{img.Data}, {img.Width}, {img.Height}, {img.ToArray()}");
+
+		if (fn.EndsWith(".svg"))
+			File.WriteAllText(fn, bc.ToSVG());
+		else
+			using (SKBitmap skb = bc.ToSKBitmap(new WriterOptions(){Scale = 5})) {
+				skb.Encode(new SKFileWStream(args[2]), SKEncodedImageFormat.Png, 100);
+			}
+	}
+
+}
diff --git a/wrappers/dotnet/ZXingCpp.DemoWriter/ZXingCpp.DemoWriter.csproj b/wrappers/dotnet/ZXingCpp.DemoWriter/ZXingCpp.DemoWriter.csproj
new file mode 100644
index 0000000000..21e2ef3c49
--- /dev/null
+++ b/wrappers/dotnet/ZXingCpp.DemoWriter/ZXingCpp.DemoWriter.csproj
@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="SkiaSharp" Version="2.88.7" ExcludeAssets="native" />
+    <!-- the following line was required to make dotnet install the missing *.so file on Linux -->
+    <!-- on another platform, you will need to remove the "ExludeAssets" property above -->
+    <PackageReference Include="SkiaSharp.NativeAssets.Linux.NoDependencies" Version="2.88.7" />
+    <ProjectReference Include="..\ZXingCpp\ZXingCpp.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/wrappers/dotnet/ZXingCpp.Tests/UnitTest1.cs b/wrappers/dotnet/ZXingCpp.Tests/UnitTest1.cs
new file mode 100644
index 0000000000..73fc1a78af
--- /dev/null
+++ b/wrappers/dotnet/ZXingCpp.Tests/UnitTest1.cs
@@ -0,0 +1,80 @@
+using Xunit;
+using System.Text;
+using ZXingCpp;
+
+namespace ZXingCpp.Tests;
+
+public class UnitTest1
+{
+	[Fact]
+	public void ValidBarcodeFormatsParsing()
+	{
+		Assert.Equal(BarcodeFormats.QRCode, Barcode.FormatsFromString("qrcode"));
+		Assert.Equal(BarcodeFormats.LinearCodes, Barcode.FormatsFromString("linear_codes"));
+		Assert.Equal(BarcodeFormats.None, Barcode.FormatsFromString(""));
+	}
+
+	[Fact]
+	public void InvalidBarcodeFormatsParsing()
+	{
+		Assert.Throws<Exception>(() => Barcode.FormatsFromString("nope"));
+	}
+
+	[Fact]
+	public void InvalidImageView()
+	{
+		Assert.Throws<Exception>(() => new ImageView(new byte[0], 1, 1, ImageFormat.Lum));
+		Assert.Throws<Exception>(() => new ImageView(new byte[1], 1, 1, ImageFormat.Lum, 2));
+	}
+
+	[Fact]
+	public void Read()
+	{
+		var data = new List<byte>();
+		foreach (var v in "0000101000101101011110111101011011101010100111011100101000100101110010100000")
+			data.Add((byte)(v == '0' ? 255 : 0));
+
+		var iv = new ImageView(data.ToArray(), data.Count, 1, ImageFormat.Lum);
+		var br = new BarcodeReader() {
+			Binarizer = Binarizer.BoolCast,
+		};
+		var res = br.From(iv);
+
+		var expected = "96385074";
+
+		Assert.Single(res);
+		Assert.True(res[0].IsValid);
+		Assert.Equal(BarcodeFormats.EAN8, res[0].Format);
+		Assert.Equal(expected, res[0].Text);
+		Assert.Equal(Encoding.ASCII.GetBytes(expected), res[0].Bytes);
+		Assert.False(res[0].HasECI);
+		Assert.Equal(ContentType.Text, res[0].ContentType);
+		Assert.Equal(0, res[0].Orientation);
+		Assert.Equal(new PointI() { X = 4, Y = 0 }, res[0].Position.TopLeft);
+		Assert.Equal(1, res[0].LineCount);
+		Assert.False(res[0].IsMirrored);
+		Assert.False(res[0].IsInverted);
+		Assert.Equal(ErrorType.None, res[0].ErrorType);
+		Assert.Equal("", res[0].ErrorMsg);
+	}
+
+	[Fact]
+	public void Create()
+	{
+		var text = "hello";
+		var res = new Barcode(text, BarcodeFormats.DataMatrix);
+
+		Assert.True(res.IsValid);
+		Assert.Equal(BarcodeFormats.DataMatrix, res.Format);
+		Assert.Equal(text, res.Text);
+		Assert.Equal(Encoding.ASCII.GetBytes(text), res.Bytes);
+		Assert.False(res.HasECI);
+		Assert.Equal(ContentType.Text, res.ContentType);
+		Assert.Equal(0, res.Orientation);
+		Assert.False(res.IsMirrored);
+		Assert.False(res.IsInverted);
+		Assert.Equal(new PointI() { X = 1, Y = 1 }, res.Position.TopLeft);
+		Assert.Equal(ErrorType.None, res.ErrorType);
+		Assert.Equal("", res.ErrorMsg);
+	}
+}
\ No newline at end of file
diff --git a/wrappers/dotnet/ZXingCpp.Tests/ZXingCpp.Tests.csproj b/wrappers/dotnet/ZXingCpp.Tests/ZXingCpp.Tests.csproj
new file mode 100644
index 0000000000..94b01c23c4
--- /dev/null
+++ b/wrappers/dotnet/ZXingCpp.Tests/ZXingCpp.Tests.csproj
@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="6.0.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ZXingCpp\ZXingCpp.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/wrappers/dotnet/ZXingCpp/README.md b/wrappers/dotnet/ZXingCpp/README.md
new file mode 100644
index 0000000000..98194c3a37
--- /dev/null
+++ b/wrappers/dotnet/ZXingCpp/README.md
@@ -0,0 +1,108 @@
+# ZXingCpp
+
+ZXingCpp is a .NET wrapper for the C++ library [zxing-cpp](https://github.com/zxing-cpp/zxing-cpp).
+
+It is an open-source, multi-format linear/matrix barcode image processing library implemented in C++.
+It was originally ported from the Java ZXing library but has been developed further and now includes
+many improvements in terms of runtime and detection performance.
+
+
+## Usage Reading
+
+```cs
+using SkiaSharp;
+using ZXingCpp;
+
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        var img = SKBitmap.Decode(args[0]).Copy(SKColorType.Gray8);
+        var iv = new ImageView(img.GetPixels(), img.Info.Width, img.Info.Height, ImageFormat.Lum);
+
+        var readBarcodes = new BarcodeReader() {
+            Formats = args.Length > 1 ? Barcode.FormatsFromString(args[1]) : BarcodeFormats.Any,
+            TryInvert = false,
+            // see the ReaderOptions implementation for more available options
+        };
+
+        foreach (var b in readBarcodes.From(iv))
+            Console.WriteLine($"{b.Format} : {b.Text}");
+    }
+}
+```
+
+Executing this sample code from the command line would look like this:
+```sh
+dotnet run -- <image-file-name> [barcode-format-list]
+```
+
+See also the [ZXingCpp.DemoReader](https://github.com/zxing-cpp/zxing-cpp/blob/master/wrappers/dotnet/ZXingCpp.DemoReader/Program.cs)
+which shows the use of extension classes to support SkiaSharp and ImageMagick based input.
+
+The NuGet package includes the runtime/native c++ libraries for the x64 architecture on
+Windows, Linux and macOS. If something is not working out of the box or you need arm64 support
+then you need to build the `[lib]ZXing[.dll|.so|.dylib]` file yourself and make sure the .NET
+runtime find it (see e.g. the environment variables `LD_LIBRARY_PATH` on Linux or `PATH` on
+Windows).
+
+Note: This is an alpha release, meaning the API may still change slightly to potentially feel even
+more like a native C# library depending on community feedback.
+
+## Usage Writing
+
+```cs
+using ZXingCpp;
+
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        var barcode = new Barcode(args[1], Barcode.FormatFromString(args[0]));
+        File.WriteAllText(args[2], barcode.ToSVG());
+    }
+}
+```
+
+Executing this sample code from the command line would look like this:
+```sh
+dotnet run -- <barcode-format> <text> <out-svg-file-name>
+```
+
+For an example how to write a PNG file instead of a SVG file, have a look at the
+[ZXingCpp.DemoWriter](https://github.com/zxing-cpp/zxing-cpp/blob/master/wrappers/dotnet/ZXingCpp.DemoWriter/Program.cs).
+
+## Why ZXingCpp?
+
+There are a number of areas where ZXingCpp shines compared to other popular .NET barcode scanner libraries.
+The following comparison is with respect to the open source [ZXing.Net](https://www.nuget.org/packages/ZXing.Net)
+and the commercial [Dynamsoft](https://www.nuget.org/packages/Dynamsoft.DotNet.Barcode) projects.
+
+### Performance
+
+To compare the performance of ZXingCpp with the other two libraries, I started the project
+[zxing-bench](https://github.com/axxel/zxing-bench).
+The [README](https://github.com/axxel/zxing-bench/blob/main/dotnet/README.md) contains a few details but to get
+an idea: ZXingCpp is on average 2x-10x faster than Dynamsoft and 10x-50x faster than ZXing.Net.
+
+### Detection rate
+
+The benchmarking tool also showed that ZXingCpp has a superior detection rate compared to ZXing.Net while it is
+sometimes better sometimes worse than the commercial Dynamsoft package, depending on the sample type and the
+library configuration. The latter definitively supports more barcode formats compared to the two ZXing decendents.
+
+### Ease of use
+
+The sample program above shows the simplicitly of the API. The others are similar but seem a bit more
+complicated with regards to setting parameters.
+
+### Standards support
+
+ZXingCpp has full support for binary data and ECI handling and provides a standards conforming `bytesECI()`
+data that can be used to simulate a hardware/handheld barcode scanner. This seems not the case for ZXing.Net
+and is unclear for Dynamsoft.
+
+### License / costs
+
+ZXingCpp has the liberal Apache-2.0 license and is free to use in commercial applications. That said,
+I accept [donations](https://github.com/sponsors/axxel) and might be available for commercial consulting ;).
diff --git a/wrappers/dotnet/ZXingCpp/ZXingCpp.cs b/wrappers/dotnet/ZXingCpp/ZXingCpp.cs
new file mode 100644
index 0000000000..90eae5fed2
--- /dev/null
+++ b/wrappers/dotnet/ZXingCpp/ZXingCpp.cs
@@ -0,0 +1,511 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+namespace ZXingCpp {
+
+using System;
+using System.Runtime.InteropServices;
+using System.Collections.Generic;
+
+using static Dll;
+using BarcodeFormat = BarcodeFormats;
+
+internal class Dll
+{
+	private const string DllName = "ZXing";
+
+	[DllImport(DllName)] public static extern IntPtr ZXing_ReaderOptions_new();
+	[DllImport(DllName)] public static extern void ZXing_ReaderOptions_delete(IntPtr opts);
+
+	[DllImport(DllName)] public static extern void ZXing_ReaderOptions_setTryHarder(IntPtr opts, bool tryHarder);
+	[DllImport(DllName)] [return:MarshalAs(UnmanagedType.I1)] public static extern bool ZXing_ReaderOptions_getTryHarder(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_ReaderOptions_setTryRotate(IntPtr opts, bool tryRotate);
+	[DllImport(DllName)] [return:MarshalAs(UnmanagedType.I1)] public static extern bool ZXing_ReaderOptions_getTryRotate(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_ReaderOptions_setTryInvert(IntPtr opts, bool tryInvert);
+	[DllImport(DllName)] [return:MarshalAs(UnmanagedType.I1)] public static extern bool ZXing_ReaderOptions_getTryInvert(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_ReaderOptions_setTryDownscale(IntPtr opts, bool tryDownscale);
+	[DllImport(DllName)] [return:MarshalAs(UnmanagedType.I1)] public static extern bool ZXing_ReaderOptions_getTryDownscale(IntPtr opts);
+	[DllImport(DllName)] [return:MarshalAs(UnmanagedType.I1)] public static extern bool ZXing_ReaderOptions_getIsPure(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_ReaderOptions_setIsPure(IntPtr opts, bool isPure);
+	[DllImport(DllName)] public static extern void ZXing_ReaderOptions_setReturnErrors(IntPtr opts, bool returnErrors);
+	[DllImport(DllName)] [return:MarshalAs(UnmanagedType.I1)] public static extern bool ZXing_ReaderOptions_getReturnErrors(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_ReaderOptions_setFormats(IntPtr opts, BarcodeFormats formats);
+	[DllImport(DllName)] public static extern BarcodeFormats ZXing_ReaderOptions_getFormats(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_ReaderOptions_setBinarizer(IntPtr opts, Binarizer binarizer);
+	[DllImport(DllName)] public static extern Binarizer ZXing_ReaderOptions_getBinarizer(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_ReaderOptions_setEanAddOnSymbol(IntPtr opts, EanAddOnSymbol eanAddOnSymbol);
+	[DllImport(DllName)] public static extern EanAddOnSymbol ZXing_ReaderOptions_getEanAddOnSymbol(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_ReaderOptions_setTextMode(IntPtr opts, TextMode textMode);
+	[DllImport(DllName)] public static extern TextMode ZXing_ReaderOptions_getTextMode(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_ReaderOptions_setMinLineCount(IntPtr opts, int n);
+	[DllImport(DllName)] public static extern int ZXing_ReaderOptions_getMinLineCount(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_ReaderOptions_setMaxNumberOfSymbols(IntPtr opts, int n);
+	[DllImport(DllName)] public static extern int ZXing_ReaderOptions_getMaxNumberOfSymbols(IntPtr opts);
+
+	[DllImport(DllName)] public static extern IntPtr ZXing_PositionToString(Position position);
+	[DllImport(DllName)] public static extern BarcodeFormat ZXing_BarcodeFormatFromString(string str);
+	[DllImport(DllName)] public static extern BarcodeFormats ZXing_BarcodeFormatsFromString(string str);
+
+	[DllImport(DllName)] public static extern IntPtr ZXing_ImageView_new(IntPtr data, int width, int height, ImageFormat format, int rowStride, int pixStride);
+	[DllImport(DllName)] public static extern IntPtr ZXing_ImageView_new_checked(byte[] data, int size, int width, int height, ImageFormat format, int rowStride, int pixStride);
+	[DllImport(DllName)] public static extern void ZXing_ImageView_delete(IntPtr iv);
+
+	[DllImport(DllName)] public static extern void ZXing_Image_delete(IntPtr img);
+	[DllImport(DllName)] public static extern IntPtr ZXing_Image_data(IntPtr img);
+	[DllImport(DllName)] public static extern int ZXing_Image_width(IntPtr img);
+	[DllImport(DllName)] public static extern int ZXing_Image_height(IntPtr img);
+	[DllImport(DllName)] public static extern ImageFormat ZXing_Image_format(IntPtr img);
+
+	[DllImport(DllName)] public static extern IntPtr ZXing_ReadBarcodes(IntPtr iv, IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_Barcode_delete(IntPtr barcode);
+	[DllImport(DllName)] public static extern void ZXing_Barcodes_delete(IntPtr barcodes);
+	[DllImport(DllName)] public static extern int ZXing_Barcodes_size(IntPtr barcodes);
+	[DllImport(DllName)] public static extern IntPtr ZXing_Barcodes_move(IntPtr barcodes, int i);
+
+	[DllImport(DllName)] public static extern IntPtr ZXing_CreatorOptions_new(BarcodeFormat format);
+	[DllImport(DllName)] public static extern void ZXing_CreatorOptions_delete(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_CreatorOptions_setFormat(IntPtr opts, BarcodeFormat format);
+	[DllImport(DllName)] public static extern BarcodeFormat ZXing_CreatorOptions_getFormat(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_CreatorOptions_setReaderInit(IntPtr opts, bool readerInit);
+	[DllImport(DllName)] [return:MarshalAs(UnmanagedType.I1)] public static extern bool ZXing_CreatorOptions_getReaderInit(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_CreatorOptions_setForceSquareDataMatrix(IntPtr opts, bool forceSquareDataMatrix);
+	[DllImport(DllName)] [return:MarshalAs(UnmanagedType.I1)] public static extern bool ZXing_CreatorOptions_getForceSquareDataMatrix(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_CreatorOptions_setEcLevel(IntPtr opts, string ecLevel);
+	[DllImport(DllName)] public static extern IntPtr ZXing_CreatorOptions_getEcLevel(IntPtr opts);
+
+	[DllImport(DllName)] public static extern IntPtr ZXing_WriterOptions_new();
+	[DllImport(DllName)] public static extern void ZXing_WriterOptions_delete(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_WriterOptions_setScale(IntPtr opts, int scale);
+	[DllImport(DllName)] public static extern int ZXing_WriterOptions_getScale(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_WriterOptions_setSizeHint(IntPtr opts, int sizeHint);
+	[DllImport(DllName)] public static extern int ZXing_WriterOptions_getSizeHint(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_WriterOptions_setRotate(IntPtr opts, int rotate);
+	[DllImport(DllName)] public static extern int ZXing_WriterOptions_getRotate(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_WriterOptions_setWithHRT(IntPtr opts, bool withHRT);
+	[DllImport(DllName)] [return:MarshalAs(UnmanagedType.I1)] public static extern bool ZXing_WriterOptions_getWithHRT(IntPtr opts);
+	[DllImport(DllName)] public static extern void ZXing_WriterOptions_setWithQuietZones(IntPtr opts, bool withQuietZones);
+	[DllImport(DllName)] [return:MarshalAs(UnmanagedType.I1)] public static extern bool ZXing_WriterOptions_getWithQuietZones(IntPtr opts);
+
+	[DllImport(DllName)] public static extern IntPtr ZXing_CreateBarcodeFromText(string data, int size, IntPtr opts);
+	[DllImport(DllName)] public static extern IntPtr ZXing_CreateBarcodeFromBytes(byte[] data, int size, IntPtr opts);
+
+	[DllImport(DllName)] public static extern IntPtr ZXing_WriteBarcodeToSVG(IntPtr barcode, IntPtr opts);
+	[DllImport(DllName)] public static extern IntPtr ZXing_WriteBarcodeToImage(IntPtr barcode, IntPtr opts);
+
+	[DllImport(DllName)] [return:MarshalAs(UnmanagedType.I1)] public static extern bool ZXing_Barcode_isValid(IntPtr barcode);
+	[DllImport(DllName)] public static extern IntPtr ZXing_Barcode_errorMsg(IntPtr barcode);
+	[DllImport(DllName)] public static extern ErrorType ZXing_Barcode_errorType(IntPtr barcode);
+	[DllImport(DllName)] public static extern BarcodeFormat ZXing_Barcode_format(IntPtr barcode);
+	[DllImport(DllName)] public static extern ContentType ZXing_Barcode_contentType(IntPtr barcode);
+	[DllImport(DllName)] public static extern IntPtr ZXing_Barcode_bytes(IntPtr barcode, out int len);
+	[DllImport(DllName)] public static extern IntPtr ZXing_Barcode_bytesECI(IntPtr barcode, out int len);
+	[DllImport(DllName)] public static extern IntPtr ZXing_Barcode_text(IntPtr barcode);
+	[DllImport(DllName)] public static extern IntPtr ZXing_Barcode_ecLevel(IntPtr barcode);
+	[DllImport(DllName)] public static extern IntPtr ZXing_Barcode_symbologyIdentifier(IntPtr barcode);
+	[DllImport(DllName)] public static extern Position ZXing_Barcode_position(IntPtr barcode);
+	[DllImport(DllName)] public static extern int ZXing_Barcode_orientation(IntPtr barcode);
+	[DllImport(DllName)] [return:MarshalAs(UnmanagedType.I1)] public static extern bool ZXing_Barcode_hasECI(IntPtr barcode);
+	[DllImport(DllName)] [return:MarshalAs(UnmanagedType.I1)] public static extern bool ZXing_Barcode_isInverted(IntPtr barcode);
+	[DllImport(DllName)] [return:MarshalAs(UnmanagedType.I1)] public static extern bool ZXing_Barcode_isMirrored(IntPtr barcode);
+	[DllImport(DllName)] public static extern int ZXing_Barcode_lineCount(IntPtr barcode);
+
+	[DllImport(DllName)] public static extern void ZXing_free(IntPtr opts);
+	[DllImport(DllName)] public static extern IntPtr ZXing_LastErrorMsg();
+
+
+	public static IntPtr CheckError(IntPtr ptr, string? msg = null)
+	{
+		if (ptr == IntPtr.Zero)
+			throw new Exception(msg ?? MarshalAsString(ZXing_LastErrorMsg()));
+		return ptr;
+	}
+
+	public static string MarshalAsString(IntPtr ptr)
+	{
+		ptr = CheckError(ptr, "ZXing C-API returned a NULL char*.");
+		string res = Marshal.PtrToStringUTF8(ptr) ?? "";
+		ZXing_free(ptr);
+		return res;
+	}
+
+	public delegate IntPtr RetBytesFunc(IntPtr ptr, out int len);
+
+	public static byte[] MarshalAsBytes(RetBytesFunc func, IntPtr d)
+	{
+		IntPtr ptr = CheckError(func(d, out int len), "ZXing C-API returned a NULL byte*.");
+		byte[] res = new byte[len];
+		Marshal.Copy(ptr, res, 0, len);
+		ZXing_free(ptr);
+		return res;
+	}
+}
+
+[Flags]
+public enum BarcodeFormats
+{
+	None            = 0,         ///< Used as a return value if no valid barcode has been detected
+	Aztec           = (1 << 0),  ///< Aztec
+	Codabar         = (1 << 1),  ///< Codabar
+	Code39          = (1 << 2),  ///< Code39
+	Code93          = (1 << 3),  ///< Code93
+	Code128         = (1 << 4),  ///< Code128
+	DataBar         = (1 << 5),  ///< GS1 DataBar, formerly known as RSS 14
+	DataBarExpanded = (1 << 6),  ///< GS1 DataBar Expanded, formerly known as RSS EXPANDED
+	DataMatrix      = (1 << 7),  ///< DataMatrix
+	EAN8            = (1 << 8),  ///< EAN-8
+	EAN13           = (1 << 9),  ///< EAN-13
+	ITF             = (1 << 10), ///< ITF (Interleaved Two of Five)
+	MaxiCode        = (1 << 11), ///< MaxiCode
+	PDF417          = (1 << 12), ///< PDF417
+	QRCode          = (1 << 13), ///< QR Code
+	UPCA            = (1 << 14), ///< UPC-A
+	UPCE            = (1 << 15), ///< UPC-E
+	MicroQRCode     = (1 << 16), ///< Micro QR Code
+	RMQRCode        = (1 << 17), ///< Rectangular Micro QR Code
+	DXFilmEdge      = (1 << 18), ///< DX Film Edge Barcode
+	DataBarLimited  = (1 << 19), ///< GS1 DataBar Limited
+
+	LinearCodes = Codabar | Code39 | Code93 | Code128 | EAN8 | EAN13 | ITF | DataBar | DataBarExpanded | DataBarLimited | DXFilmEdge | UPCA | UPCE,
+	MatrixCodes = Aztec | DataMatrix | MaxiCode | PDF417 | QRCode | MicroQRCode | RMQRCode,
+	Any         = LinearCodes | MatrixCodes,
+};
+
+
+public enum Binarizer
+{
+	LocalAverage,    ///< T = average of neighboring pixels for matrix and GlobalHistogram for linear (HybridBinarizer)
+	GlobalHistogram, ///< T = valley between the 2 largest peaks in the histogram (per line in linear case)
+	FixedThreshold,  ///< T = 127
+	BoolCast,        ///< T = 0, fastest possible
+};
+
+public enum EanAddOnSymbol
+{
+	Ignore,  ///< Ignore any Add-On symbol during read/scan
+	Read,    ///< Read EAN-2/EAN-5 Add-On symbol if found
+	Require, ///< Require EAN-2/EAN-5 Add-On symbol to be present
+};
+
+public enum TextMode
+{
+	Plain,   ///< bytes() transcoded to unicode based on ECI info or guessed charset (the default mode prior to 2.0)
+	ECI,     ///< standard content following the ECI protocol with every character set ECI segment transcoded to unicode
+	HRI,     ///< Human Readable Interpretation (dependent on the ContentType)
+	Hex,     ///< bytes() transcoded to ASCII string of HEX values
+	Escaped, ///< Use the EscapeNonGraphical() function (e.g. ASCII 29 will be transcoded to "<GS>")
+};
+
+public enum ContentType { Text, Binary, Mixed, GS1, ISO15434, UnknownECI };
+
+public enum ErrorType { None, Format, Checksum, Unsupported };
+
+public enum ImageFormat {
+	None = 0,
+	Lum = 0x01000000,
+	LumA = 0x02000000,
+	RGB = 0x03000102,
+	BGR = 0x03020100,
+	RGBA = 0x04000102,
+	ARGB = 0x04010203,
+	BGRA = 0x04020100,
+	ABGR = 0x04030201,
+};
+
+public struct PointI
+{
+	public int X, Y;
+};
+
+public struct Position
+{
+	public PointI TopLeft, TopRight, BottomRight, BottomLeft;
+
+	public override string ToString() => MarshalAsString(ZXing_PositionToString(this));
+};
+
+public class ImageView
+{
+	internal IntPtr _d;
+
+	public ImageView(byte[] data, int width, int height, ImageFormat format, int rowStride = 0, int pixStride = 0)
+		=> _d = CheckError(ZXing_ImageView_new_checked(data, data.Length, width, height, format, rowStride, pixStride));
+
+	public ImageView(IntPtr data, int width, int height, ImageFormat format, int rowStride = 0, int pixStride = 0)
+		=> _d = CheckError(ZXing_ImageView_new(data, width, height, format, rowStride, pixStride));
+
+	~ImageView() => ZXing_ImageView_delete(_d);
+}
+
+public class Image : IDisposable
+{
+	internal IntPtr _d;
+
+	internal Image(IntPtr d) => _d = d;
+
+	~Image() => Dispose();
+
+	public void Dispose()
+	{
+		ZXing_Image_delete(_d);
+		_d = IntPtr.Zero;
+		GC.SuppressFinalize(this);
+	}
+
+	public IntPtr Data => ZXing_Image_data(_d);
+	public int Width => ZXing_Image_width(_d);
+	public int Height => ZXing_Image_height(_d);
+	public ImageFormat Format => ZXing_Image_format(_d);
+
+	public byte[] ToArray()
+	{
+		IntPtr ptr = ZXing_Image_data(_d);
+		if (ptr == IntPtr.Zero)
+			return new byte[0];
+
+		int len = Width * Height;
+		byte[] res = new byte[len];
+		Marshal.Copy(ptr, res, 0, len);
+		return res;
+	}
+}
+
+public class ReaderOptions
+{
+	internal IntPtr _d;
+
+	public ReaderOptions() => _d = CheckError(ZXing_ReaderOptions_new(), "Failed to create ReaderOptions.");
+
+	~ReaderOptions() => ZXing_ReaderOptions_delete(_d);
+
+	public bool TryHarder
+	{
+		get => ZXing_ReaderOptions_getTryHarder(_d);
+		set => ZXing_ReaderOptions_setTryHarder(_d, value);
+	}
+
+	public bool TryRotate
+	{
+		get => ZXing_ReaderOptions_getTryRotate(_d);
+		set => ZXing_ReaderOptions_setTryRotate(_d, value);
+	}
+
+	public bool TryInvert
+	{
+		get => ZXing_ReaderOptions_getTryInvert(_d);
+		set => ZXing_ReaderOptions_setTryInvert(_d, value);
+	}
+
+	public bool TryDownscale
+	{
+		get => ZXing_ReaderOptions_getTryDownscale(_d);
+		set => ZXing_ReaderOptions_setTryDownscale(_d, value);
+	}
+
+	public bool IsPure
+	{
+		get => ZXing_ReaderOptions_getIsPure(_d);
+		set => ZXing_ReaderOptions_setIsPure(_d, value);
+	}
+
+	public bool ReturnErrors
+	{
+		get => ZXing_ReaderOptions_getReturnErrors(_d);
+		set => ZXing_ReaderOptions_setReturnErrors(_d, value);
+	}
+
+	public BarcodeFormats Formats
+	{
+		get => ZXing_ReaderOptions_getFormats(_d);
+		set => ZXing_ReaderOptions_setFormats(_d, value);
+	}
+
+	public Binarizer Binarizer
+	{
+		get => ZXing_ReaderOptions_getBinarizer(_d);
+		set => ZXing_ReaderOptions_setBinarizer(_d, value);
+	}
+
+	public EanAddOnSymbol EanAddOnSymbol
+	{
+		get => ZXing_ReaderOptions_getEanAddOnSymbol(_d);
+		set => ZXing_ReaderOptions_setEanAddOnSymbol(_d, value);
+	}
+
+	public TextMode TextMode
+	{
+		get => ZXing_ReaderOptions_getTextMode(_d);
+		set => ZXing_ReaderOptions_setTextMode(_d, value);
+	}
+
+	public int MinLineCount
+	{
+		get => ZXing_ReaderOptions_getMinLineCount(_d);
+		set => ZXing_ReaderOptions_setMinLineCount(_d, value);
+	}
+
+	public int MaxNumberOfSymbols
+	{
+		get => ZXing_ReaderOptions_getMaxNumberOfSymbols(_d);
+		set => ZXing_ReaderOptions_setMaxNumberOfSymbols(_d, value);
+	}
+
+}
+
+public class CreatorOptions
+{
+	internal IntPtr _d;
+
+	public CreatorOptions(BarcodeFormat format)
+		=> _d = CheckError(ZXing_CreatorOptions_new(format), "Failed to create CreatorOptions.");
+
+	public static implicit operator CreatorOptions(BarcodeFormat f) => new CreatorOptions(f);
+
+	~CreatorOptions() => ZXing_CreatorOptions_delete(_d);
+
+	public bool ReaderInit
+	{
+		get => ZXing_CreatorOptions_getReaderInit(_d);
+		set => ZXing_CreatorOptions_setReaderInit(_d, value);
+	}
+
+	public bool ForceSquareDataMatrix
+	{
+		get => ZXing_CreatorOptions_getForceSquareDataMatrix(_d);
+		set => ZXing_CreatorOptions_setForceSquareDataMatrix(_d, value);
+	}
+
+	public String ECLevel
+	{
+		get => MarshalAsString(ZXing_CreatorOptions_getEcLevel(_d));
+		set => ZXing_CreatorOptions_setEcLevel(_d, value);
+	}
+
+}
+
+public class WriterOptions
+{
+	internal IntPtr _d;
+
+	public WriterOptions() => _d = CheckError(ZXing_WriterOptions_new(), "Failed to create WriterOptions.");
+
+	~WriterOptions() => ZXing_WriterOptions_delete(_d);
+
+	public int Scale
+	{
+		get => ZXing_WriterOptions_getScale(_d);
+		set => ZXing_WriterOptions_setScale(_d, value);
+	}
+
+	public int SizeHint
+	{
+		get => ZXing_WriterOptions_getSizeHint(_d);
+		set => ZXing_WriterOptions_setSizeHint(_d, value);
+	}
+
+	public int Rotate
+	{
+		get => ZXing_WriterOptions_getRotate(_d);
+		set => ZXing_WriterOptions_setRotate(_d, value);
+	}
+
+	public bool WithHRT
+	{
+		get => ZXing_WriterOptions_getWithHRT(_d);
+		set => ZXing_WriterOptions_setWithHRT(_d, value);
+	}
+
+	public bool WithQuietZones
+	{
+		get => ZXing_WriterOptions_getWithQuietZones(_d);
+		set => ZXing_WriterOptions_setWithQuietZones(_d, value);
+	}
+}
+
+public class Barcode
+{
+	internal IntPtr _d;
+
+	internal Barcode(IntPtr d) => _d = d;
+
+	~Barcode() => ZXing_Barcode_delete(_d);
+
+	public Barcode(string data, CreatorOptions opts)
+		=> _d = CheckError(ZXing_CreateBarcodeFromText(data, data.Length, opts._d));
+
+	public Barcode(byte[] data, CreatorOptions opts)
+		=> _d = CheckError(ZXing_CreateBarcodeFromBytes(data, data.Length, opts._d));
+
+	public bool IsValid => ZXing_Barcode_isValid(_d);
+	public BarcodeFormat Format => ZXing_Barcode_format(_d);
+	public ContentType ContentType => ZXing_Barcode_contentType(_d);
+	public string Text => MarshalAsString(ZXing_Barcode_text(_d));
+	public byte[] Bytes => MarshalAsBytes(ZXing_Barcode_bytes, _d);
+	public byte[] BytesECI => MarshalAsBytes(ZXing_Barcode_bytesECI, _d);
+	public string ECLevel => MarshalAsString(ZXing_Barcode_ecLevel(_d));
+	public string SymbologyIdentifier => MarshalAsString(ZXing_Barcode_symbologyIdentifier(_d));
+	public string ErrorMsg => MarshalAsString(ZXing_Barcode_errorMsg(_d));
+	public ErrorType ErrorType => ZXing_Barcode_errorType(_d);
+	public Position Position => ZXing_Barcode_position(_d);
+	public int Orientation => ZXing_Barcode_orientation(_d);
+	public bool HasECI => ZXing_Barcode_hasECI(_d);
+	public bool IsInverted => ZXing_Barcode_isInverted(_d);
+	public bool IsMirrored => ZXing_Barcode_isMirrored(_d);
+	public int LineCount => ZXing_Barcode_lineCount(_d);
+
+	public string ToSVG(WriterOptions? opts = null)
+		=> MarshalAsString(CheckError(ZXing_WriteBarcodeToSVG(_d, opts?._d ?? IntPtr.Zero)));
+
+	public Image ToImage(WriterOptions? opts = null)
+		=> new Image(CheckError(ZXing_WriteBarcodeToImage(_d, opts?._d ?? IntPtr.Zero)));
+
+	public static BarcodeFormat FormatFromString(string str)
+	{
+		var res = ZXing_BarcodeFormatFromString(str);
+		if ((int)res == -1) // see ZXing_BarcodeFormat_Invalid
+			throw new Exception(MarshalAsString(ZXing_LastErrorMsg()));
+		return res;
+	}
+
+	public static BarcodeFormats FormatsFromString(string str)
+	{
+		var res = ZXing_BarcodeFormatsFromString(str);
+		if ((int)res == -1) // see ZXing_BarcodeFormat_Invalid
+			throw new Exception(MarshalAsString(ZXing_LastErrorMsg()));
+		return res;
+	}
+}
+
+public class BarcodeReader : ReaderOptions
+{
+	public static Barcode[] Read(ImageView iv, ReaderOptions? opts = null)
+	{
+		var ptr = CheckError(ZXing_ReadBarcodes(iv._d, opts?._d ?? IntPtr.Zero));
+
+		// return static empty array if no Barcodes are found, avoiding any managed heap allocation
+		var res = Array.Empty<Barcode>();
+		var size = ZXing_Barcodes_size(ptr);
+		if (size > 0) {
+			res = new Barcode[size];
+			for (int i = 0; i < size; ++i)
+				res[i] = new Barcode(ZXing_Barcodes_move(ptr, i));
+		}
+
+		ZXing_Barcodes_delete(ptr);
+
+		return res;
+	}
+
+	public Barcode[] From(ImageView iv) => Read(iv, this);
+}
+
+public class BarcodeCreator : CreatorOptions
+{
+	public BarcodeCreator(BarcodeFormat format) : base(format) {}
+
+	public Barcode From(string data) => new Barcode(data, this);
+	public Barcode From(byte[] data) => new Barcode(data, this);
+}
+
+}
diff --git a/wrappers/dotnet/ZXingCpp/ZXingCpp.csproj b/wrappers/dotnet/ZXingCpp/ZXingCpp.csproj
new file mode 100644
index 0000000000..3db7fdd2a9
--- /dev/null
+++ b/wrappers/dotnet/ZXingCpp/ZXingCpp.csproj
@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.1</TargetFramework>
+    <!-- <ImplicitUsings>enable</ImplicitUsings> -->
+    <Nullable>enable</Nullable>
+
+    <PackageId>ZXingCpp</PackageId>
+    <Version>0.3.0-alpha</Version>
+    <Authors>Axel Waggershauser</Authors>
+    <Company>zxing-cpp</Company>
+    <Description>
+      ZXingCpp is a .NET wrapper for the C++ library zxing-cpp.
+      It is an open-source, multi-format linear/matrix barcode image processing library implemented in C++.
+      It was originally ported from the Java ZXing library but has been developed further and now includes
+      many improvements in terms of runtime and detection performance.</Description>
+    <PackageProjectUrl>https://github.com/zxing-cpp/zxing-cpp</PackageProjectUrl>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+    <PackageTags>Barcode;QRCode</PackageTags>
+    <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
+  </PropertyGroup>
+
+  <ItemGroup>
+      <None Include="README.md" Pack="true" PackagePath="README.md"/>
+      <None Include="../runtimes/ZXing.dll" Pack="true" PackagePath="runtimes/win-x64/native/" />
+      <None Include="../runtimes/libZXing.so" Pack="true" PackagePath="runtimes/linux-x64/native/" />
+      <None Include="../runtimes/libZXing.dylib" Pack="true" PackagePath="runtimes/osx-x64/native/" />
+  </ItemGroup>
+</Project>
+
+<!-- .NET Standard 2. (netstandard), see https://learn.microsoft.com/en-us/dotnet/standard/net-standard?tabs=net-standard-1-0#when-to-target-net80-vs-netstandard -->
+<!-- dotnet nuget push ZXingCpp/bin/Release/ZXingCpp.0.1.0-alpha.nupkg -s https://api.nuget.org/v3/index.json -k <api-key> -->
diff --git a/wrappers/dotnet/dotnet.sln b/wrappers/dotnet/dotnet.sln
new file mode 100644
index 0000000000..895c8d25ad
--- /dev/null
+++ b/wrappers/dotnet/dotnet.sln
@@ -0,0 +1,40 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31903.59
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ZXingCpp", "ZXingCpp\ZXingCpp.csproj", "{64E71DE2-C1C6-4FCF-B8A6-FFC6D1605ECD}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ZXingCpp.DemoReader", "ZXingCpp.DemoReader\ZXingCpp.DemoReader.csproj", "{05C626FE-A5CE-4263-9419-35E44F14DB93}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ZXingCpp.DemoWriter", "ZXingCpp.DemoWriter\ZXingCpp.DemoWriter.csproj", "{E82B81A1-E873-4C40-BF47-83D6971848CE}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ZXingCpp.Tests", "ZXingCpp.Tests\ZXingCpp.Tests.csproj", "{9D57E7B5-A24F-4F1D-8AF0-CED8FAE54B06}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{64E71DE2-C1C6-4FCF-B8A6-FFC6D1605ECD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{64E71DE2-C1C6-4FCF-B8A6-FFC6D1605ECD}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{64E71DE2-C1C6-4FCF-B8A6-FFC6D1605ECD}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{64E71DE2-C1C6-4FCF-B8A6-FFC6D1605ECD}.Release|Any CPU.Build.0 = Release|Any CPU
+		{05C626FE-A5CE-4263-9419-35E44F14DB93}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{05C626FE-A5CE-4263-9419-35E44F14DB93}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{05C626FE-A5CE-4263-9419-35E44F14DB93}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{05C626FE-A5CE-4263-9419-35E44F14DB93}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9D57E7B5-A24F-4F1D-8AF0-CED8FAE54B06}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9D57E7B5-A24F-4F1D-8AF0-CED8FAE54B06}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9D57E7B5-A24F-4F1D-8AF0-CED8FAE54B06}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9D57E7B5-A24F-4F1D-8AF0-CED8FAE54B06}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E82B81A1-E873-4C40-BF47-83D6971848CE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E82B81A1-E873-4C40-BF47-83D6971848CE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E82B81A1-E873-4C40-BF47-83D6971848CE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E82B81A1-E873-4C40-BF47-83D6971848CE}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal
diff --git a/wrappers/ios/Sources/Wrapper/Reader/ZXIBarcodeReader.h b/wrappers/ios/Sources/Wrapper/Reader/ZXIBarcodeReader.h
index 153abcdebb..144842c56a 100644
--- a/wrappers/ios/Sources/Wrapper/Reader/ZXIBarcodeReader.h
+++ b/wrappers/ios/Sources/Wrapper/Reader/ZXIBarcodeReader.h
@@ -16,13 +16,13 @@ NS_ASSUME_NONNULL_BEGIN
 -(instancetype)initWithOptions:(ZXIReaderOptions*)options;
 
 -(nullable NSArray<ZXIResult *> *)readCIImage:(nonnull CIImage *)image
-                                error:(NSError *__autoreleasing  _Nullable *)error;
+                                        error:(NSError *__autoreleasing  _Nullable *)error;
 
 -(nullable NSArray<ZXIResult *> *)readCGImage:(nonnull CGImageRef)image
-                                error:(NSError *__autoreleasing  _Nullable *)error;
+                                        error:(NSError *__autoreleasing  _Nullable *)error;
 
 -(nullable NSArray<ZXIResult *> *)readCVPixelBuffer:(nonnull CVPixelBufferRef)pixelBuffer
-                                      error:(NSError *__autoreleasing  _Nullable *)error;
+                                              error:(NSError *__autoreleasing  _Nullable *)error;
 
 @end
 
diff --git a/wrappers/ios/Sources/Wrapper/Reader/ZXIBarcodeReader.mm b/wrappers/ios/Sources/Wrapper/Reader/ZXIBarcodeReader.mm
index 4b21c81bf3..1c6ad8088e 100644
--- a/wrappers/ios/Sources/Wrapper/Reader/ZXIBarcodeReader.mm
+++ b/wrappers/ios/Sources/Wrapper/Reader/ZXIBarcodeReader.mm
@@ -5,7 +5,7 @@
 #import "ZXIBarcodeReader.h"
 #import "ReadBarcode.h"
 #import "ImageView.h"
-#import "Result.h"
+#import "Barcode.h"
 #import "GTIN.h"
 #import "ZXIFormatHelper.h"
 #import "ZXIPosition+Helper.h"
@@ -34,6 +34,10 @@
     }
 }
 
+@interface ZXIReaderOptions()
+@property(nonatomic) ZXing::ReaderOptions cppOpts;
+@end
+
 @interface ZXIBarcodeReader()
 @property (nonatomic, strong) CIContext* ciContext;
 @end
@@ -92,20 +96,19 @@ - (instancetype)initWithOptions:(ZXIReaderOptions*)options{
 
 - (NSArray<ZXIResult *> *)readCGImage:(nonnull CGImageRef)image
                                 error:(NSError *__autoreleasing _Nullable *)error {
-    CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);
     CGFloat cols = CGImageGetWidth(image);
     CGFloat rows = CGImageGetHeight(image);
     NSMutableData *data = [NSMutableData dataWithLength: cols * rows];
 
-
-    CGContextRef contextRef = CGBitmapContextCreate(
-                                                    data.mutableBytes,// Pointer to backing data
+    CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);
+    CGContextRef contextRef = CGBitmapContextCreate(data.mutableBytes,// Pointer to backing data
                                                     cols,                      // Width of bitmap
                                                     rows,                     // Height of bitmap
                                                     8,                          // Bits per component
                                                     cols,              // Bytes per row
                                                     colorSpace,                 // Colorspace
                                                     kCGBitmapByteOrderDefault); // Bitmap info flags
+    CGColorSpaceRelease(colorSpace);
     CGContextDrawImage(contextRef, CGRectMake(0, 0, cols, rows), image);
     CGContextRelease(contextRef);
 
@@ -117,28 +120,10 @@ - (instancetype)initWithOptions:(ZXIReaderOptions*)options{
     return [self readImageView:imageView error:error];
 }
 
-+ (ReaderOptions)ReaderOptionsFromZXIReaderOptions:(ZXIReaderOptions*)options {
-    BarcodeFormats formats;
-    for(NSNumber* flag in options.formats) {
-        formats.setFlag(BarcodeFormatFromZXIFormat((ZXIFormat)flag.integerValue));
-    }
-    ReaderOptions cppOpts = ReaderOptions()
-        .setFormats(formats)
-        .setTryRotate(options.tryRotate)
-        .setTryHarder(options.tryHarder)
-        .setTryInvert(options.tryInvert)
-        .setTryDownscale(options.tryDownscale)
-        .setTryCode39ExtendedMode(options.tryCode39ExtendedMode)
-        .setValidateCode39CheckSum(options.validateCode39CheckSum)
-        .setValidateITFCheckSum(options.validateITFCheckSum)
-        .setMaxNumberOfSymbols(options.maxNumberOfSymbols);
-    return cppOpts;
-}
-
 - (NSArray<ZXIResult*> *)readImageView:(ImageView)imageView
                                  error:(NSError *__autoreleasing _Nullable *)error {
     try {
-        Results results = ReadBarcodes(imageView, [ZXIBarcodeReader ReaderOptionsFromZXIReaderOptions:self.options]);
+        Barcodes results = ReadBarcodes(imageView, self.options.cppOpts);
         NSMutableArray* zxiResults = [NSMutableArray array];
         for (auto result: results) {
             [zxiResults addObject:
@@ -161,6 +146,9 @@ + (ReaderOptions)ReaderOptionsFromZXIReaderOptions:(ZXIReaderOptions*)options {
     } catch(std::exception &e) {
         SetNSError(error, ZXIReaderError, e.what());
         return nil;
+    } catch (...) {
+        SetNSError(error, ZXIReaderError, "An unknown error occurred");
+        return nil;
     }
 }
 
diff --git a/wrappers/ios/Sources/Wrapper/Reader/ZXIPosition+Helper.h b/wrappers/ios/Sources/Wrapper/Reader/ZXIPosition+Helper.h
index 93ec83b8d8..64e034922f 100644
--- a/wrappers/ios/Sources/Wrapper/Reader/ZXIPosition+Helper.h
+++ b/wrappers/ios/Sources/Wrapper/Reader/ZXIPosition+Helper.h
@@ -4,7 +4,7 @@
 
 #import <Foundation/Foundation.h>
 #import "ZXIPosition.h"
-#import "Result.h"
+#import "Barcode.h"
 
 NS_ASSUME_NONNULL_BEGIN
 
diff --git a/wrappers/ios/Sources/Wrapper/Reader/ZXIReaderOptions.h b/wrappers/ios/Sources/Wrapper/Reader/ZXIReaderOptions.h
index cae964c2ff..24aad5bf08 100644
--- a/wrappers/ios/Sources/Wrapper/Reader/ZXIReaderOptions.h
+++ b/wrappers/ios/Sources/Wrapper/Reader/ZXIReaderOptions.h
@@ -6,31 +6,46 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
+typedef NS_ENUM(NSInteger, ZXIBinarizer) {
+    ZXIBinarizerLocalAverage,
+    ZXIBinarizerGlobalHistogram,
+    ZXIBinarizerFixedThreshold,
+    ZXIBinarizerBoolCast
+};
+
+typedef NS_ENUM(NSInteger, ZXIEanAddOnSymbol) {
+    ZXIEanAddOnSymbolIgnore,
+    ZXIEanAddOnSymbolRead,
+    ZXIEanAddOnSymbolRequire
+};
+
+typedef NS_ENUM(NSInteger, ZXITextMode) {
+    ZXITextModePlain,
+    ZXITextModeECI,
+    ZXITextModeHRI,
+    ZXITextModeHex,
+    ZXITextModeEscaped
+};
+
 @interface ZXIReaderOptions : NSObject
-/// An array of ZXIFormat
 @property(nonatomic, strong) NSArray<NSNumber*> *formats;
 @property(nonatomic) BOOL tryHarder;
 @property(nonatomic) BOOL tryRotate;
 @property(nonatomic) BOOL tryInvert;
 @property(nonatomic) BOOL tryDownscale;
+@property(nonatomic) BOOL isPure;
+@property(nonatomic) ZXIBinarizer binarizer;
+@property(nonatomic) NSInteger downscaleFactor;
+@property(nonatomic) NSInteger downscaleThreshold;
+@property(nonatomic) NSInteger minLineCount;
+@property(nonatomic) NSInteger maxNumberOfSymbols;
 @property(nonatomic) BOOL tryCode39ExtendedMode;
 @property(nonatomic) BOOL validateCode39CheckSum;
 @property(nonatomic) BOOL validateITFCheckSum;
-@property(nonatomic) uint8_t downscaleFactor;
-@property(nonatomic) uint16_t downscaleThreshold;
-@property(nonatomic) NSInteger maxNumberOfSymbols;
-
-- (instancetype)initWithFormats:(NSArray<NSNumber*>*)formats
-					    tryHarder:(BOOL)tryHarder
-                        tryRotate:(BOOL)tryRotate
-                        tryInvert:(BOOL)tryInvert
-                     tryDownscale:(BOOL)tryDownscale
-            tryCode39ExtendedMode:(BOOL)tryCode39ExtendedMode
-           validateCode39CheckSum:(BOOL)validateCode39CheckSum
-              validateITFCheckSum:(BOOL)validateITFCheckSum
-                  downscaleFactor:(uint8_t)downscaleFactor
-               downscaleThreshold:(uint16_t)downscaleThreshold
-               maxNumberOfSymbols:(NSInteger)maxNumberOfSymbols;
+@property(nonatomic) BOOL returnCodabarStartEnd;
+@property(nonatomic) BOOL returnErrors;
+@property(nonatomic) ZXIEanAddOnSymbol eanAddOnSymbol;
+@property(nonatomic) ZXITextMode textMode;
 @end
 
 NS_ASSUME_NONNULL_END
diff --git a/wrappers/ios/Sources/Wrapper/Reader/ZXIReaderOptions.mm b/wrappers/ios/Sources/Wrapper/Reader/ZXIReaderOptions.mm
index 7cfc8f7901..1f837e788c 100644
--- a/wrappers/ios/Sources/Wrapper/Reader/ZXIReaderOptions.mm
+++ b/wrappers/ios/Sources/Wrapper/Reader/ZXIReaderOptions.mm
@@ -17,111 +17,212 @@ -(instancetype)init {
     return self;
 }
 
-- (instancetype)initWithFormats:(NSArray<NSNumber*>*)formats
-                        tryHarder:(BOOL)tryHarder
-                        tryRotate:(BOOL)tryRotate
-                        tryInvert:(BOOL)tryInvert
-                     tryDownscale:(BOOL)tryDownscale
-            tryCode39ExtendedMode:(BOOL)tryCode39ExtendedMode
-           validateCode39CheckSum:(BOOL)validateCode39CheckSum
-              validateITFCheckSum:(BOOL)validateITFCheckSum
-                  downscaleFactor:(uint8_t)downscaleFactor
-               downscaleThreshold:(uint16_t)downscaleThreshold
-               maxNumberOfSymbols:(NSInteger)maxNumberOfSymbols {
-    self = [super init];
-    self.cppOpts = ZXing::ReaderOptions();
-    self.tryHarder = tryHarder;
-    self.tryRotate = tryRotate;
-    self.tryInvert = tryInvert;
-    self.tryDownscale = tryDownscale;
-    self.tryCode39ExtendedMode = tryCode39ExtendedMode;
-    self.validateCode39CheckSum = validateCode39CheckSum;
-    self.validateITFCheckSum = validateITFCheckSum;
-    self.downscaleFactor = downscaleFactor;
-    self.downscaleThreshold = downscaleThreshold;
-    self.maxNumberOfSymbols = maxNumberOfSymbols;
-    self.formats = formats;
-    return self;
+-(BOOL)tryHarder {
+    return self.cppOpts.tryHarder();
 }
 
 -(void)setTryHarder:(BOOL)tryHarder {
-    self.cppOpts.setTryHarder(tryHarder);
+    self.cppOpts = self.cppOpts.setTryHarder(tryHarder);
+}
+
+-(BOOL)tryRotate {
+    return self.cppOpts.tryRotate();
 }
 
 -(void)setTryRotate:(BOOL)tryRotate {
-    self.cppOpts.setTryRotate(tryRotate);
+    self.cppOpts = self.cppOpts.setTryRotate(tryRotate);
+}
+
+-(BOOL)tryInvert {
+    return self.cppOpts.tryInvert();
 }
 
 -(void)setTryInvert:(BOOL)tryInvert {
-    self.cppOpts.setTryInvert(tryInvert);
+    self.cppOpts = self.cppOpts.setTryInvert(tryInvert);
+}
+
+-(BOOL)tryDownscale {
+    return self.cppOpts.tryDownscale();
 }
 
 -(void)setTryDownscale:(BOOL)tryDownscale {
-    self.cppOpts.setTryDownscale(tryDownscale);
+    self.cppOpts = self.cppOpts.setTryDownscale(tryDownscale);
 }
 
--(void)setTryCode39ExtendedMode:(BOOL)tryCode39ExtendedMode {
-    self.cppOpts.setTryCode39ExtendedMode(tryCode39ExtendedMode);
+-(BOOL)isPure {
+    return self.cppOpts.isPure();
 }
 
--(void)setValidateCode39CheckSum:(BOOL)validateCode39CheckSum {
-    self.cppOpts.setValidateCode39CheckSum(validateCode39CheckSum);
+-(void)setIsPure:(BOOL)isPure {
+    self.cppOpts = self.cppOpts.setIsPure(isPure);
 }
 
--(void)setValidateITFCheckSum:(BOOL)validateITFCheckSum {
-    self.cppOpts.setValidateITFCheckSum(validateITFCheckSum);
+-(ZXIBinarizer)binarizer {
+    switch (self.cppOpts.binarizer()) {
+        default:
+        case ZXing::Binarizer::LocalAverage:
+            return ZXIBinarizer::ZXIBinarizerLocalAverage;
+        case ZXing::Binarizer::GlobalHistogram:
+            return ZXIBinarizer::ZXIBinarizerGlobalHistogram;
+        case ZXing::Binarizer::FixedThreshold:
+            return ZXIBinarizer::ZXIBinarizerFixedThreshold;
+        case ZXing::Binarizer::BoolCast:
+            return ZXIBinarizer::ZXIBinarizerBoolCast;
+    }
 }
 
--(void)setDownscaleFactor:(uint8_t)downscaleFactor {
-    self.cppOpts.setDownscaleFactor(downscaleFactor);
+ZXing::Binarizer toNativeBinarizer(ZXIBinarizer binarizer) {
+    switch (binarizer) {
+        default:
+        case ZXIBinarizerLocalAverage:
+            return ZXing::Binarizer::LocalAverage;
+        case ZXIBinarizerGlobalHistogram:
+            return ZXing::Binarizer::GlobalHistogram;
+        case ZXIBinarizerFixedThreshold:
+            return ZXing::Binarizer::FixedThreshold;
+        case ZXIBinarizerBoolCast:
+            return ZXing::Binarizer::BoolCast;
+    }
 }
 
--(void)setDownscaleThreshold:(uint16_t)downscaleThreshold {
-    self.cppOpts.setDownscaleThreshold(downscaleThreshold);
+-(void)setBinarizer:(ZXIBinarizer)binarizer {
+    self.cppOpts = self.cppOpts.setBinarizer(toNativeBinarizer(binarizer));
 }
 
--(void)setMaxNumberOfSymbols:(NSInteger)maxNumberOfSymbols {
-    self.cppOpts.setMaxNumberOfSymbols(maxNumberOfSymbols);
+-(NSInteger)downscaleFactor {
+    return self.cppOpts.downscaleFactor();
 }
 
--(BOOL)tryHarder {
-    return self.cppOpts.tryHarder();
+-(void)setDownscaleFactor:(NSInteger)downscaleFactor {
+    self.cppOpts = self.cppOpts.setDownscaleFactor(downscaleFactor);
 }
 
--(BOOL)tryRotate {
-    return self.cppOpts.tryRotate();
+-(NSInteger)downscaleThreshold {
+    return self.cppOpts.downscaleThreshold();
 }
 
--(BOOL)tryInvert {
-    return self.cppOpts.tryInvert();
+-(void)setDownscaleThreshold:(NSInteger)downscaleThreshold {
+    self.cppOpts = self.cppOpts.setDownscaleThreshold(downscaleThreshold);
 }
 
--(BOOL)tryDownscale {
-    return self.cppOpts.tryDownscale();
+-(NSInteger)minLineCount {
+    return self.cppOpts.minLineCount();
+}
+
+-(void)setMinLineCount:(NSInteger)minLineCount {
+    self.cppOpts = self.cppOpts.setMinLineCount(minLineCount);
+}
+
+- (NSInteger)maxNumberOfSymbols {
+    return self.cppOpts.maxNumberOfSymbols();
+}
+
+-(void)setMaxNumberOfSymbols:(NSInteger)maxNumberOfSymbols {
+    self.cppOpts = self.cppOpts.setMaxNumberOfSymbols(maxNumberOfSymbols);
 }
 
 -(BOOL)tryCode39ExtendedMode {
     return self.cppOpts.tryCode39ExtendedMode();
 }
 
+-(void)setTryCode39ExtendedMode:(BOOL)tryCode39ExtendedMode {
+    self.cppOpts = self.cppOpts.setTryCode39ExtendedMode(tryCode39ExtendedMode);
+}
+
 -(BOOL)validateCode39CheckSum {
     return self.cppOpts.validateCode39CheckSum();
 }
 
+-(void)setValidateCode39CheckSum:(BOOL)validateCode39CheckSum {
+    self.cppOpts = self.cppOpts.setValidateCode39CheckSum(validateCode39CheckSum);
+}
+
 -(BOOL)validateITFCheckSum {
     return self.cppOpts.validateITFCheckSum();
 }
 
--(uint8_t)downscaleFactor {
-    return self.cppOpts.downscaleFactor();
+-(void)setValidateITFCheckSum:(BOOL)validateITFCheckSum {
+    self.cppOpts = self.cppOpts.setValidateITFCheckSum(validateITFCheckSum);
 }
 
--(uint16_t)downscaleThreshold {
-    return self.cppOpts.downscaleThreshold();
+-(BOOL)returnCodabarStartEnd {
+    return self.cppOpts.returnCodabarStartEnd();
 }
 
-- (NSInteger)maxNumberOfSymbols {
-    return self.cppOpts.maxNumberOfSymbols();
+-(void)setReturnCodabarStartEnd:(BOOL)returnCodabarStartEnd {
+    self.cppOpts = self.cppOpts.setReturnCodabarStartEnd(returnCodabarStartEnd);
+}
+
+-(BOOL)returnErrors {
+    return self.cppOpts.returnErrors();
+}
+
+-(void)setReturnErrors:(BOOL)returnErrors {
+    self.cppOpts = self.cppOpts.setReturnErrors(returnErrors);
+}
+
+-(ZXIEanAddOnSymbol)eanAddOnSymbol {
+    switch (self.cppOpts.eanAddOnSymbol()) {
+        default:
+        case ZXing::EanAddOnSymbol::Ignore:
+            return ZXIEanAddOnSymbol::ZXIEanAddOnSymbolIgnore;
+        case ZXing::EanAddOnSymbol::Read:
+            return ZXIEanAddOnSymbol::ZXIEanAddOnSymbolRead;
+        case ZXing::EanAddOnSymbol::Require:
+            return ZXIEanAddOnSymbol::ZXIEanAddOnSymbolRequire;
+    }
+}
+
+ZXing::EanAddOnSymbol toNativeEanAddOnSymbol(ZXIEanAddOnSymbol eanAddOnSymbol) {
+    switch (eanAddOnSymbol) {
+        default:
+        case ZXIEanAddOnSymbolIgnore:
+            return ZXing::EanAddOnSymbol::Ignore;
+        case ZXIEanAddOnSymbolRead:
+            return ZXing::EanAddOnSymbol::Read;
+        case ZXIEanAddOnSymbolRequire:
+            return ZXing::EanAddOnSymbol::Require;
+    }
+}
+
+-(void)setEanAddOnSymbol:(ZXIEanAddOnSymbol)eanAddOnSymbol {
+    self.cppOpts = self.cppOpts.setEanAddOnSymbol(toNativeEanAddOnSymbol(eanAddOnSymbol));
+}
+
+-(ZXITextMode)textMode {
+    switch (self.cppOpts.textMode()) {
+        default:
+        case ZXing::TextMode::Plain:
+            return ZXITextMode::ZXITextModePlain;
+        case ZXing::TextMode::ECI:
+            return ZXITextMode::ZXITextModeECI;
+        case ZXing::TextMode::HRI:
+            return ZXITextMode::ZXITextModeHRI;
+        case ZXing::TextMode::Hex:
+            return ZXITextMode::ZXITextModeHex;
+        case ZXing::TextMode::Escaped:
+            return ZXITextMode::ZXITextModeEscaped;
+    }
+}
+
+ZXing::TextMode toNativeTextMode(ZXITextMode mode) {
+    switch (mode) {
+        default:
+        case ZXITextModePlain:
+            return ZXing::TextMode::Plain;
+        case ZXITextModeECI:
+            return ZXing::TextMode::ECI;
+        case ZXITextModeHRI:
+            return ZXing::TextMode::HRI;
+        case ZXITextModeHex:
+            return ZXing::TextMode::Hex;
+        case ZXITextModeEscaped:
+            return ZXing::TextMode::Escaped;
+    }
+}
+
+-(void)setTextMode:(ZXITextMode)textMode {
+    self.cppOpts = self.cppOpts.setTextMode(toNativeTextMode(textMode));
 }
 
 @end
diff --git a/wrappers/ios/Sources/Wrapper/ZXIErrors.mm b/wrappers/ios/Sources/Wrapper/ZXIErrors.mm
index 6b88bcb1de..6ebfa20397 100644
--- a/wrappers/ios/Sources/Wrapper/ZXIErrors.mm
+++ b/wrappers/ios/Sources/Wrapper/ZXIErrors.mm
@@ -12,10 +12,10 @@ void SetNSError(NSError *__autoreleasing _Nullable* error,
     }
     NSString *errorDescription = @"Unknown C++ error";
     if (message && strlen(message) > 0) {
-        try {
-            errorDescription = [NSString stringWithUTF8String: message];
-        } catch (NSException *exception) {
-            errorDescription = @"Unknown ObjC error";
+        errorDescription = [NSString stringWithUTF8String: message];
+        if (errorDescription == nil) {
+            errorDescription = [NSString stringWithCString: message
+                                                  encoding: NSASCIIStringEncoding];
         }
     }
     NSDictionary *userInfo = @{ NSLocalizedDescriptionKey: errorDescription };
diff --git a/wrappers/ios/Sources/Wrapper/ZXIFormat.h b/wrappers/ios/Sources/Wrapper/ZXIFormat.h
index 0ba9bd8f6d..a80ae19240 100644
--- a/wrappers/ios/Sources/Wrapper/ZXIFormat.h
+++ b/wrappers/ios/Sources/Wrapper/ZXIFormat.h
@@ -7,8 +7,8 @@
 #define ZXIFormat_h
 
 typedef NS_ENUM(NSInteger, ZXIFormat) {
-    NONE, AZTEC, CODABAR, CODE_39, CODE_93, CODE_128, DATA_BAR, DATA_BAR_EXPANDED,
-    DATA_MATRIX, EAN_8, EAN_13, ITF, MAXICODE, PDF_417, QR_CODE, MICRO_QR_CODE, RMQR_CODE, UPC_A, UPC_E,
+    NONE, AZTEC, CODABAR, CODE_39, CODE_93, CODE_128, DATA_BAR, DATA_BAR_EXPANDED, DATA_BAR_LIMITED,
+    DATA_MATRIX, DX_FILM_EDGE, EAN_8, EAN_13, ITF, MAXICODE, PDF_417, QR_CODE, MICRO_QR_CODE, RMQR_CODE, UPC_A, UPC_E,
     LINEAR_CODES, MATRIX_CODES, ANY
 };
 
diff --git a/wrappers/ios/Sources/Wrapper/ZXIFormatHelper.mm b/wrappers/ios/Sources/Wrapper/ZXIFormatHelper.mm
index 487933f4e4..42b347043d 100644
--- a/wrappers/ios/Sources/Wrapper/ZXIFormatHelper.mm
+++ b/wrappers/ios/Sources/Wrapper/ZXIFormatHelper.mm
@@ -32,8 +32,12 @@
             return ZXing::BarcodeFormat::DataMatrix;
         case ZXIFormat::DATA_BAR_EXPANDED:
             return ZXing::BarcodeFormat::DataBarExpanded;
+        case ZXIFormat::DATA_BAR_LIMITED:
+            return ZXing::BarcodeFormat::DataBarLimited;
         case ZXIFormat::DATA_BAR:
             return ZXing::BarcodeFormat::DataBar;
+        case ZXIFormat::DX_FILM_EDGE:
+            return ZXing::BarcodeFormat::DXFilmEdge;
         case ZXIFormat::CODE_128:
             return ZXing::BarcodeFormat::Code128;
         case ZXIFormat::CODE_93:
@@ -73,8 +77,12 @@ ZXIFormat ZXIFormatFromBarcodeFormat(ZXing::BarcodeFormat format) {
             return ZXIFormat::DATA_BAR;
         case ZXing::BarcodeFormat::DataBarExpanded:
             return ZXIFormat::DATA_BAR_EXPANDED;
+        case ZXing::BarcodeFormat::DataBarLimited:
+            return ZXIFormat::DATA_BAR_LIMITED;
         case ZXing::BarcodeFormat::DataMatrix:
             return ZXIFormat::DATA_MATRIX;
+        case ZXing::BarcodeFormat::DXFilmEdge:
+            return ZXIFormat::DX_FILM_EDGE;
         case ZXing::BarcodeFormat::EAN8:
             return ZXIFormat::EAN_8;
         case ZXing::BarcodeFormat::EAN13:
diff --git a/wrappers/kn/.gitignore b/wrappers/kn/.gitignore
new file mode 100644
index 0000000000..cc4fca248e
--- /dev/null
+++ b/wrappers/kn/.gitignore
@@ -0,0 +1,44 @@
+.gradle
+build/
+!gradle/wrapper/gradle-wrapper.jar
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### IntelliJ IDEA ###
+.idea/modules.xml
+.idea/jarRepositories.xml
+.idea/compiler.xml
+.idea/libraries/
+*.iws
+*.iml
+*.ipr
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store
+
+local.properties
diff --git a/wrappers/kn/README.md b/wrappers/kn/README.md
new file mode 100644
index 0000000000..ef89751103
--- /dev/null
+++ b/wrappers/kn/README.md
@@ -0,0 +1,97 @@
+# ZXing-C++ Kotlin/Native Library
+
+## Install
+
+The easiest way to use the library is to fetch it from _mavenCentral_. Simply add
+
+```gradle
+implementation("io.github.zxing-cpp:kotlin-native:2.3.0-SNAPSHOT")
+```
+
+to your `build.gradle.kts` file in the `dependencies` section of `nativeMain` source set.
+To access the SNAPSHOT version, you also need to add a separate repositories entry in your build.cradle file:
+
+```gradle
+maven { url = uri("https://s01.oss.sonatype.org/content/repositories/snapshots") }
+```
+
+## Use
+
+### Reading
+
+A trivial use case looks like this:
+
+```kotlin
+import zxingcpp.BarcodeFormat
+import zxingcpp.BarcodeReader
+import zxingcpp.ImageFormat
+import zxingcpp.ImageView
+
+val data: ByteArray = ...    // the image data
+val width: Int = ...         // the image width
+val height: Int = ...        // the image height
+val format: ImageFormat = ImageFormat.Lum // ImageFormat.Lum assumes grey scale image data
+
+val image: ImageView = ImageView(data, width, height, format)
+val barcodeReader = BarcodeReader().apply {
+   formats = setOf(BarcodeFormat.EAN13, BarcodeFormat.QRCode)
+   tryHarder = true
+   maxNumberOfSymbols = 3
+   // more options, see documentation
+}
+
+barcodeReader.read(image).joinToString("\n") { barcode: Barcode ->
+   "${barcode.format} (${barcode.contentType}): ${barcode.text}"
+}
+```
+
+Here you have to load your image into memory by yourself and pass the decoded data to the constructor of `ImageView`.
+
+### Writing
+
+A trivial use case looks like this:
+
+```kotlin
+import zxingcpp.*
+
+val text: String = "Hello, World!"
+val format = BarcodeFormat.QRCode
+
+@OptIn(ExperimentalWriterApi::class)
+val cOpts = CreatorOptions(format) // more options, see documentation
+
+@OptIn(ExperimentalWriterApi::class)
+val barcode = Barcode(text, cOpts)
+// or
+@OptIn(ExperimentalWriterApi::class)
+val barcode2 = Barcode(text.encodeToByteArray(), format)
+
+@OptIn(ExperimentalWriterApi::class)
+val wOpts = WriterOptions().apply {
+   sizeHint = 400
+   // more options, see documentation
+}
+
+@OptIn(ExperimentalWriterApi::class)
+val svg: String = barcode.toSVG(wOpts)
+@OptIn(ExperimentalWriterApi::class)
+val image: Image = barcode.toImage(wOpts)
+```
+
+> Note: The Writer api is still experimental and may change in future versions.
+> You will have to opt-in `zxingcpp.ExperimentalWriterApi` to use it.
+
+## Build locally
+
+1. Install JDK, CMake and Android NDK(With `$ANDROID_NDK` correctly configured) and ensure their
+   executable binaries appear in `$PATH`.
+2. Prepare kotlin/native toolchain (You can easily do this by cloning
+   [K/N Toolchain Initializer](https://github.com/ISNing/kn-toolchain-initializer) and executing `gradle build`
+   so that kotlin will download toolchains needed into user's home dir.).
+3. Ensure there's `run_konan` available in `$PATH` or specify path of kotlin-native toolchain in `local.properties`
+   like `konan.dir=/home/user/.konan/kotlin-native-prebuilt-linux-x86_64-1.9.22`.
+4. Ensure there's `llvm-ar` available in `$PATH` for mingwX64 target building.
+
+And then you can build the project from the command line:
+
+	$ ./gradlew :assemble
diff --git a/wrappers/kn/build.gradle.kts b/wrappers/kn/build.gradle.kts
new file mode 100644
index 0000000000..5cbcff1d95
--- /dev/null
+++ b/wrappers/kn/build.gradle.kts
@@ -0,0 +1,219 @@
+import io.github.isning.gradle.plugins.cmake.params.CustomCMakeParams
+import io.github.isning.gradle.plugins.cmake.params.entries.CustomCMakeCacheEntries
+import io.github.isning.gradle.plugins.cmake.params.entries.asCMakeParams
+import io.github.isning.gradle.plugins.cmake.params.entries.platform.ModifiablePlatformEntriesImpl
+import io.github.isning.gradle.plugins.cmake.params.entries.plus
+import io.github.isning.gradle.plugins.cmake.params.plus
+import io.github.isning.gradle.plugins.kn.krossCompile.invoke
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
+import java.util.*
+
+plugins {
+    alias(libs.plugins.kotlinMultiplatform)
+    alias(libs.plugins.krossCompile)
+    `maven-publish`
+    signing
+}
+
+group = "io.github.zxing-cpp"
+version = "2.3.0-SNAPSHOT"
+
+Properties().apply {
+    rootProject.file("local.properties").takeIf { it.exists() && it.isFile }?.let { load(it.reader()) }
+}.onEach { (key, value) ->
+    if (key is String) ext[key] = value
+}
+
+val hostOs = System.getProperty("os.name")
+
+repositories {
+    mavenCentral()
+    google()
+}
+
+kotlin {
+    val androidTargets = {
+        listOf(
+            androidNativeArm32(),
+            androidNativeArm64(),
+            androidNativeX86(),
+            androidNativeX64(),
+        )
+    }
+    val appleTargets = {
+        listOf(
+            iosX64(),
+            iosArm64(),
+            iosSimulatorArm64(),
+            macosX64(),
+            macosArm64(),
+            watchosX64(),
+            watchosArm32(),
+            watchosArm64(),
+            watchosSimulatorArm64(),
+            tvosX64(),
+            tvosArm64(),
+            tvosSimulatorArm64(),
+        )
+    }
+    val linuxTargets = {
+        listOf(
+            linuxX64(),
+            linuxArm64(),
+        )
+    }
+    // TODO: Linking failed, keep up with https://youtrack.jetbrains.com/issue/KT-65671
+//    val windowsTargets = {
+//        listOf(
+//            mingwX64(),
+//        )
+//    }
+    val enabledTargetList = mutableListOf<KotlinNativeTarget>()
+    enabledTargetList.addAll(androidTargets())
+    enabledTargetList.addAll(linuxTargets())
+    // TODO: Linking failed, keep up with https://youtrack.jetbrains.com/issue/KT-65671
+//    enabledTargetList.addAll(windowsTargets())
+
+    if (hostOs == "Mac OS X") enabledTargetList.addAll(appleTargets())
+}
+
+krossCompile {
+    libraries {
+        val cmakeDir = project.layout.buildDirectory.dir("cmake").get().asFile.absolutePath
+        val zxingCpp by creating {
+            sourceDir = file("../../core").absolutePath
+            outputPath = ""
+            libraryArtifactNames = listOf("libZXing.a")
+
+            cinterop {
+                val buildDir = "$cmakeDir/{libraryName}/{targetName}"
+                packageName = "zxingcpp.cinterop"
+                includeDirs.from(buildDir)
+                headers = listOf("$sourceDir/src/ZXingC.h")
+                compilerOpts += "-DZXING_EXPERIMENTAL_API=ON"
+            }
+            cmake.apply {
+                val buildDir = "$cmakeDir/{projectName}/{targetName}"
+                configParams {
+                    this.buildDir = buildDir
+                }
+                configParams += (ModifiablePlatformEntriesImpl().apply {
+                    buildType = "Release"
+                    buildSharedLibs = false
+                } + CustomCMakeCacheEntries(
+                    mapOf(
+                        "ZXING_READERS" to "ON",
+                        "ZXING_WRITERS" to "NEW",
+                        "ZXING_EXPERIMENTAL_API" to "ON",
+                        "ZXING_USE_BUNDLED_ZINT" to "ON",
+                        "ZXING_C_API" to "ON",
+                    )
+                )).asCMakeParams
+                buildParams {
+                    this.buildDir = buildDir
+                    config = "Release"
+                }
+                buildParams += CustomCMakeParams(listOf("-j16"))
+            }
+
+            androidNativeX64.ndk()
+            androidNativeX86.ndk()
+            androidNativeArm32.ndk()
+            androidNativeArm64.ndk()
+
+            // TODO: Find a way to build linux targets with cxx20. Detail: https://github.com/zxing-cpp/zxing-cpp/pull/719#discussion_r1485701269
+            linuxX64.konan {
+                cmake {
+                    configParams += CustomCMakeCacheEntries(
+                        mapOf(
+                            "CMAKE_CXX_STANDARD" to "17",
+                        )
+                    ).asCMakeParams
+                }
+            }
+            linuxArm64.konan {
+                cmake {
+                    configParams += CustomCMakeCacheEntries(
+                        mapOf(
+                            "CMAKE_CXX_STANDARD" to "17",
+                        )
+                    ).asCMakeParams
+                }
+            }
+            // TODO: Linking failed, keep up with https://youtrack.jetbrains.com/issue/KT-65671
+//            mingwX64.konan()
+
+            if (hostOs == "Mac OS X") {
+                iosX64.xcode()
+                iosArm64.xcode()
+                iosSimulatorArm64.xcode()
+                macosX64.xcode()
+                macosArm64.xcode()
+                watchosX64.xcode()
+                watchosArm32.xcode()
+                watchosArm64.xcode()
+                watchosSimulatorArm64.xcode()
+                tvosX64.xcode()
+                tvosArm64.xcode()
+                tvosSimulatorArm64.xcode()
+            }
+        }
+    }
+}
+
+publishing {
+    publications.withType<MavenPublication>().all {
+        artifactId = artifactId.replace(project.name, "kotlin-native")
+            groupId = project.group.toString()
+            version = project.version.toString()
+
+            pom {
+                name = "zxing-cpp"
+                description = "Wrapper for zxing-cpp barcode image processing library"
+                url = "https://github.com/zxing-cpp/zxing-cpp"
+                licenses {
+                    license {
+                        name = "The Apache License, Version 2.0"
+                        url = "http://www.apache.org/licenses/LICENSE-2.0.txt"
+                    }
+                }
+                developers {
+                    developer {
+                        id = "zxing-cpp"
+                        name = "zxing-cpp community"
+                        email = "zxingcpp@gmail.com"
+                    }
+                }
+                scm {
+                    connection = "scm:git:git://github.com/zxing-cpp/zxing-cpp.git"
+                    developerConnection = "scm:git:git://github.com/zxing-cpp/zxing-cpp.git"
+                    url = "https://github.com/zxing-cpp/zxing-cpp"
+                }
+            }
+    }
+    repositories {
+        maven {
+            name = "sonatype"
+
+            val releasesRepoUrl = "https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/"
+            val snapshotsRepoUrl = "https://s01.oss.sonatype.org/content/repositories/snapshots/"
+            setUrl(if (version.toString().endsWith("SNAPSHOT")) snapshotsRepoUrl else releasesRepoUrl)
+
+            credentials {
+                val ossrhUsername: String? by project
+                val ossrhPassword: String? by project
+                username = ossrhUsername
+                password = ossrhPassword
+            }
+        }
+    }
+}
+
+signing {
+    val signingKey: String? by project
+    val signingPassword: String? by project
+    if (signingKey != null && signingPassword != null) {
+        useInMemoryPgpKeys(signingKey, signingPassword)
+        sign(publishing.publications)
+    }
+}
diff --git a/wrappers/kn/gradle.properties b/wrappers/kn/gradle.properties
new file mode 100644
index 0000000000..8aa580cdc6
--- /dev/null
+++ b/wrappers/kn/gradle.properties
@@ -0,0 +1,2 @@
+kotlin.code.style=official
+kotlin.mpp.enableCInteropCommonization=true
\ No newline at end of file
diff --git a/wrappers/kn/gradle/libs.versions.toml b/wrappers/kn/gradle/libs.versions.toml
new file mode 100644
index 0000000000..2ee2d1f984
--- /dev/null
+++ b/wrappers/kn/gradle/libs.versions.toml
@@ -0,0 +1,9 @@
+[versions]
+kotlin = "1.9.22"
+krossCompile = "0.1.9"
+
+[libraries]
+
+[plugins]
+kotlinMultiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
+krossCompile = { id = "io.github.isning.gradle.plugins.kn.krossCompile", version.ref = "krossCompile" }
diff --git a/wrappers/kn/gradle/wrapper/gradle-wrapper.jar b/wrappers/kn/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000000..249e5832f0
Binary files /dev/null and b/wrappers/kn/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/wrappers/kn/gradle/wrapper/gradle-wrapper.properties b/wrappers/kn/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000000..29d27311e5
--- /dev/null
+++ b/wrappers/kn/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
\ No newline at end of file
diff --git a/wrappers/kn/gradlew b/wrappers/kn/gradlew
new file mode 100755
index 0000000000..1b6c787337
--- /dev/null
+++ b/wrappers/kn/gradlew
@@ -0,0 +1,234 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+APP_NAME="Gradle"
+APP_BASE_NAME=${0##*/}
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"
diff --git a/wrappers/kn/gradlew.bat b/wrappers/kn/gradlew.bat
new file mode 100644
index 0000000000..107acd32c4
--- /dev/null
+++ b/wrappers/kn/gradlew.bat
@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/wrappers/kn/settings.gradle.kts b/wrappers/kn/settings.gradle.kts
new file mode 100644
index 0000000000..b6a233e3a2
--- /dev/null
+++ b/wrappers/kn/settings.gradle.kts
@@ -0,0 +1,20 @@
+pluginManagement {
+    repositories {
+        mavenLocal()
+        gradlePluginPortal()
+        google()
+        mavenCentral()
+    }
+}
+plugins {
+    id("org.gradle.toolchains.foojay-resolver-convention") version "0.5.0"
+}
+
+dependencyResolutionManagement {
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.name = "zxing-cpp"
diff --git a/wrappers/kn/src/nativeMain/kotlin/zxingcpp/Barcode.kt b/wrappers/kn/src/nativeMain/kotlin/zxingcpp/Barcode.kt
new file mode 100644
index 0000000000..9eda90c792
--- /dev/null
+++ b/wrappers/kn/src/nativeMain/kotlin/zxingcpp/Barcode.kt
@@ -0,0 +1,177 @@
+/*
+* Copyright 2024 ISNing
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+package zxingcpp
+
+import cnames.structs.ZXing_Barcode
+import cnames.structs.ZXing_Barcodes
+import kotlinx.cinterop.*
+import zxingcpp.cinterop.*
+import zxingcpp.cinterop.ZXing_ContentType.*
+import kotlin.experimental.ExperimentalNativeApi
+import kotlin.native.ref.createCleaner
+
+@OptIn(ExperimentalForeignApi::class)
+enum class ContentType(internal val cValue: ZXing_ContentType) {
+	Text(ZXing_ContentType_Text),
+	Binary(ZXing_ContentType_Binary),
+	Mixed(ZXing_ContentType_Mixed),
+	GS1(ZXing_ContentType_GS1),
+	ISO15434(ZXing_ContentType_ISO15434),
+	UnknownECI(ZXing_ContentType_UnknownECI);
+}
+
+@OptIn(ExperimentalForeignApi::class)
+fun ZXing_ContentType.toKObject(): ContentType {
+	return ContentType.entries.first { it.cValue == this }
+}
+
+data class PointI(
+	val x: Int,
+	val y: Int
+)
+
+@OptIn(ExperimentalForeignApi::class)
+fun ZXing_PointI.toKObject(): PointI = PointI(x, y)
+
+data class Position(
+	val topLeft: PointI,
+	val topRight: PointI,
+	val bottomRight: PointI,
+	val bottomLeft: PointI,
+)
+
+@OptIn(ExperimentalForeignApi::class)
+fun ZXing_Position.toKObject(): Position = Position(
+	topLeft.toKObject(),
+	topRight.toKObject(),
+	bottomRight.toKObject(),
+	bottomLeft.toKObject(),
+)
+
+class BarcodeConstructionException(message: String?) : Exception("Failed to construct barcode: $message")
+
+@OptIn(ExperimentalForeignApi::class)
+class Barcode(val cValue: CValuesRef<ZXing_Barcode>) {
+
+	@ExperimentalWriterApi
+	constructor(text: String, opts: CreatorOptions) : this(
+		ZXing_CreateBarcodeFromText(text, text.length, opts.cValue)
+			?: throw BarcodeConstructionException(ZXing_LastErrorMsg()?.toKStringNullPtrHandledAndFree())
+	)
+
+	@ExperimentalWriterApi
+	constructor(text: String, format: BarcodeFormat) : this(text, CreatorOptions(format))
+
+	@ExperimentalWriterApi
+	constructor(bytes: ByteArray, opts: CreatorOptions) : this(
+		ZXing_CreateBarcodeFromBytes(bytes.refTo(0), bytes.size, opts.cValue)
+			?: throw BarcodeConstructionException(ZXing_LastErrorMsg()?.toKStringNullPtrHandledAndFree())
+	)
+
+	@ExperimentalWriterApi
+	constructor(bytes: ByteArray, format: BarcodeFormat) : this(bytes, CreatorOptions(format))
+
+	val isValid: Boolean
+		get() = ZXing_Barcode_isValid(cValue)
+	val errorMsg: String? by lazy {
+		ZXing_Barcode_errorMsg(cValue)?.toKStringNullPtrHandledAndFree()
+	}
+	val format: BarcodeFormat by lazy {
+		ZXing_Barcode_format(cValue).parseIntoBarcodeFormat().first { it != BarcodeFormat.None }
+	}
+	val contentType: ContentType by lazy {
+		ZXing_Barcode_contentType(cValue).toKObject()
+	}
+
+	val bytes: ByteArray? by lazy {
+		memScoped {
+			val len = alloc<IntVar>()
+			(ZXing_Barcode_bytes(cValue, len.ptr)?.run {
+				readBytes(len.value).also { ZXing_free(this) }
+			} ?: throw OutOfMemoryError()).takeUnless { it.isEmpty() }
+		}
+	}
+
+	val bytesECI: ByteArray? by lazy {
+		memScoped {
+			val len = alloc<IntVar>()
+			(ZXing_Barcode_bytesECI(cValue, len.ptr)?.run {
+				readBytes(len.value).also { ZXing_free(this) }
+			} ?: throw OutOfMemoryError()).takeUnless { it.isEmpty() }
+		}
+	}
+
+	val text: String? by lazy {
+		ZXing_Barcode_text(cValue)?.toKStringNullPtrHandledAndFree()
+	}
+	val ecLevel: String? by lazy {
+		ZXing_Barcode_ecLevel(cValue)?.toKStringNullPtrHandledAndFree()
+	}
+	val symbologyIdentifier: String? by lazy {
+		ZXing_Barcode_symbologyIdentifier(cValue)?.toKStringNullPtrHandledAndFree()
+	}
+	val position: Position by lazy {
+		ZXing_Barcode_position(cValue).useContents { toKObject() }
+	}
+	val orientation: Int
+		get() = ZXing_Barcode_orientation(cValue)
+	val hasECI: Boolean
+		get() = ZXing_Barcode_hasECI(cValue)
+	val isInverted: Boolean
+		get() = ZXing_Barcode_isInverted(cValue)
+	val isMirrored: Boolean
+		get() = ZXing_Barcode_isMirrored(cValue)
+	val lineCount: Int
+		get() = ZXing_Barcode_lineCount(cValue)
+
+	@Suppress("unused")
+	@OptIn(ExperimentalNativeApi::class)
+	private val cleaner = createCleaner(cValue) { ZXing_Barcode_delete(it) }
+
+	override fun toString(): String {
+		return "Barcode(" +
+			"cValue=$cValue, " +
+			"bytes=${bytes?.contentToString()}, " +
+			"bytesECI=${bytesECI?.contentToString()}, " +
+			"lineCount=$lineCount, " +
+			"isMirrored=$isMirrored, " +
+			"isInverted=$isInverted, " +
+			"hasECI=$hasECI, " +
+			"orientation=$orientation, " +
+			"position=$position, " +
+			"symbologyIdentifier=$symbologyIdentifier, " +
+			"ecLevel=$ecLevel, " +
+			"text=$text, " +
+			"contentType=$contentType, " +
+			"format=$format, " +
+			"errorMsg=$errorMsg, " +
+			"isValid=$isValid" +
+			")"
+	}
+}
+
+@OptIn(ExperimentalForeignApi::class)
+@ExperimentalWriterApi
+fun Barcode.toSVG(opts: WriterOptions? = null): String = cValue.usePinned {
+	ZXing_WriteBarcodeToSVG(it.get(), opts?.cValue)?.toKStringNullPtrHandledAndFree()
+		?: throw BarcodeWritingException(ZXing_LastErrorMsg()?.toKStringNullPtrHandledAndFree())
+}
+
+@OptIn(ExperimentalForeignApi::class)
+@ExperimentalWriterApi
+fun Barcode.toImage(opts: WriterOptions? = null): Image = cValue.usePinned {
+	ZXing_WriteBarcodeToImage(it.get(), opts?.cValue)?.toKObject()
+		?: throw BarcodeWritingException(ZXing_LastErrorMsg()?.toKStringNullPtrHandledAndFree())
+}
+
+@OptIn(ExperimentalForeignApi::class)
+fun CValuesRef<ZXing_Barcode>.toKObject(): Barcode = Barcode(this)
+
+@OptIn(ExperimentalForeignApi::class)
+fun CValuesRef<ZXing_Barcodes>.toKObject(): List<Barcode> = mutableListOf<Barcode>().apply {
+	for (i in 0..<ZXing_Barcodes_size(this@toKObject))
+		ZXing_Barcodes_move(this@toKObject, i)?.toKObject()?.let { add(it) }
+}.toList()
diff --git a/wrappers/kn/src/nativeMain/kotlin/zxingcpp/BarcodeFormat.kt b/wrappers/kn/src/nativeMain/kotlin/zxingcpp/BarcodeFormat.kt
new file mode 100644
index 0000000000..d8aee576de
--- /dev/null
+++ b/wrappers/kn/src/nativeMain/kotlin/zxingcpp/BarcodeFormat.kt
@@ -0,0 +1,48 @@
+/*
+* Copyright 2024 ISNing
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+package zxingcpp
+
+import kotlinx.cinterop.ExperimentalForeignApi
+import zxingcpp.cinterop.*
+
+@OptIn(ExperimentalForeignApi::class)
+enum class BarcodeFormat(internal val rawValue: UInt) {
+	None(ZXing_BarcodeFormat_None),
+	Aztec(ZXing_BarcodeFormat_Aztec),
+	Codabar(ZXing_BarcodeFormat_Codabar),
+	Code39(ZXing_BarcodeFormat_Code39),
+	Code93(ZXing_BarcodeFormat_Code93),
+	Code128(ZXing_BarcodeFormat_Code128),
+	DataBar(ZXing_BarcodeFormat_DataBar),
+	DataBarExpanded(ZXing_BarcodeFormat_DataBarExpanded),
+	DataBarLimited(ZXing_BarcodeFormat_DataBarLimited),
+	DataMatrix(ZXing_BarcodeFormat_DataMatrix),
+	DXFilmEdge(ZXing_BarcodeFormat_DXFilmEdge),
+	EAN8(ZXing_BarcodeFormat_EAN8),
+	EAN13(ZXing_BarcodeFormat_EAN13),
+	ITF(ZXing_BarcodeFormat_ITF),
+	MaxiCode(ZXing_BarcodeFormat_MaxiCode),
+	PDF417(ZXing_BarcodeFormat_PDF417),
+	QRCode(ZXing_BarcodeFormat_QRCode),
+	MicroQrCode(ZXing_BarcodeFormat_MicroQRCode),
+	RMQRCode(ZXing_BarcodeFormat_RMQRCode),
+	UPCA(ZXing_BarcodeFormat_UPCA),
+	UPCE(ZXing_BarcodeFormat_UPCE),
+
+	LinearCodes(ZXing_BarcodeFormat_LinearCodes),
+	MatrixCodes(ZXing_BarcodeFormat_MatrixCodes),
+	Any(ZXing_BarcodeFormat_Any),
+
+	Invalid(ZXing_BarcodeFormat_Invalid),
+}
+
+@OptIn(ExperimentalForeignApi::class)
+fun ZXing_BarcodeFormat.parseIntoBarcodeFormat(): Set<BarcodeFormat> =
+	BarcodeFormat.entries.filter { this.or(it.rawValue) == this }.toSet()
+
+@OptIn(ExperimentalForeignApi::class)
+fun Iterable<BarcodeFormat>.toValue(): ZXing_BarcodeFormat =
+	this.map { it.rawValue }.reduce { acc, format -> acc.or(format) }
diff --git a/wrappers/kn/src/nativeMain/kotlin/zxingcpp/BarcodeReader.kt b/wrappers/kn/src/nativeMain/kotlin/zxingcpp/BarcodeReader.kt
new file mode 100644
index 0000000000..3483fc15fa
--- /dev/null
+++ b/wrappers/kn/src/nativeMain/kotlin/zxingcpp/BarcodeReader.kt
@@ -0,0 +1,126 @@
+/*
+* Copyright 2024 ISNing
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+package zxingcpp
+
+import cnames.structs.ZXing_ReaderOptions
+import kotlinx.cinterop.*
+import zxingcpp.cinterop.*
+import zxingcpp.cinterop.ZXing_Binarizer.*
+import zxingcpp.cinterop.ZXing_EanAddOnSymbol.*
+import zxingcpp.cinterop.ZXing_TextMode.*
+import kotlin.experimental.ExperimentalNativeApi
+import kotlin.native.ref.createCleaner
+
+
+@OptIn(ExperimentalForeignApi::class)
+internal fun CPointer<ByteVar>?.toKStringNullPtrHandledAndFree(): String? = (this ?: throw OutOfMemoryError()).run {
+	toKString().also { ZXing_free(this) }.ifEmpty { null }
+}
+
+
+@OptIn(ExperimentalForeignApi::class)
+class BarcodeReader : ReaderOptions() {
+	@Throws(BarcodeReadingException::class)
+	fun read(imageView: ImageView): List<Barcode> = Companion.read(imageView, this)
+
+	companion object {
+		@Throws(BarcodeReadingException::class)
+		fun read(imageView: ImageView, opts: ReaderOptions? = null): List<Barcode> =
+			ZXing_ReadBarcodes(imageView.cValue, opts?.cValue)?.let { cValues -> cValues.toKObject().also { ZXing_Barcodes_delete(cValues) } }
+				?: throw BarcodeReadingException(ZXing_LastErrorMsg()?.toKStringNullPtrHandledAndFree())
+	}
+}
+
+class BarcodeReadingException(message: String?) : Exception("Failed to read barcodes: $message")
+
+
+@OptIn(ExperimentalForeignApi::class)
+open class ReaderOptions {
+	var tryHarder: Boolean
+		get() = ZXing_ReaderOptions_getTryHarder(cValue)
+		set(value) = ZXing_ReaderOptions_setTryHarder(cValue, value)
+	var tryRotate: Boolean
+		get() = ZXing_ReaderOptions_getTryRotate(cValue)
+		set(value) = ZXing_ReaderOptions_setTryRotate(cValue, value)
+	var tryDownscale: Boolean
+		get() = ZXing_ReaderOptions_getTryDownscale(cValue)
+		set(value) = ZXing_ReaderOptions_setTryDownscale(cValue, value)
+	var tryInvert: Boolean
+		get() = ZXing_ReaderOptions_getTryInvert(cValue)
+		set(value) = ZXing_ReaderOptions_setTryInvert(cValue, value)
+	var isPure: Boolean
+		get() = ZXing_ReaderOptions_getIsPure(cValue)
+		set(value) = ZXing_ReaderOptions_setIsPure(cValue, value)
+	var returnErrors: Boolean
+		get() = ZXing_ReaderOptions_getReturnErrors(cValue)
+		set(value) = ZXing_ReaderOptions_setReturnErrors(cValue, value)
+	var binarizer: Binarizer
+		get() = Binarizer.fromCValue(ZXing_ReaderOptions_getBinarizer(cValue))
+		set(value) = ZXing_ReaderOptions_setBinarizer(cValue, value.cValue)
+	var formats: Set<BarcodeFormat>
+		get() = ZXing_ReaderOptions_getFormats(cValue).parseIntoBarcodeFormat()
+		set(value) = ZXing_ReaderOptions_setFormats(cValue, value.toValue())
+	var eanAddOnSymbol: EanAddOnSymbol
+		get() = EanAddOnSymbol.fromCValue(ZXing_ReaderOptions_getEanAddOnSymbol(cValue))
+		set(value) = ZXing_ReaderOptions_setEanAddOnSymbol(cValue, value.cValue)
+	var textMode: TextMode
+		get() = TextMode.fromCValue(ZXing_ReaderOptions_getTextMode(cValue))
+		set(value) = ZXing_ReaderOptions_setTextMode(cValue, value.cValue)
+	var minLineCount: Int
+		get() = ZXing_ReaderOptions_getMinLineCount(cValue)
+		set(value) = ZXing_ReaderOptions_setMinLineCount(cValue, value)
+	var maxNumberOfSymbols: Int
+		get() = ZXing_ReaderOptions_getMaxNumberOfSymbols(cValue)
+		set(value) = ZXing_ReaderOptions_setMaxNumberOfSymbols(cValue, value)
+
+	val cValue: CValuesRef<ZXing_ReaderOptions>? = ZXing_ReaderOptions_new()
+
+	@Suppress("unused")
+	@OptIn(ExperimentalNativeApi::class)
+	private val cleaner = createCleaner(cValue) { ZXing_ReaderOptions_delete(it) }
+}
+
+@OptIn(ExperimentalForeignApi::class)
+enum class Binarizer(internal val cValue: ZXing_Binarizer) {
+	LocalAverage(ZXing_Binarizer_LocalAverage),
+	GlobalHistogram(ZXing_Binarizer_GlobalHistogram),
+	FixedThreshold(ZXing_Binarizer_FixedThreshold),
+	BoolCast(ZXing_Binarizer_BoolCast);
+
+	companion object {
+		fun fromCValue(cValue: ZXing_Binarizer): Binarizer {
+			return entries.first { it.cValue == cValue }
+		}
+	}
+}
+
+@OptIn(ExperimentalForeignApi::class)
+enum class EanAddOnSymbol(internal val cValue: ZXing_EanAddOnSymbol) {
+	Ignore(ZXing_EanAddOnSymbol_Ignore),
+	Read(ZXing_EanAddOnSymbol_Read),
+	Require(ZXing_EanAddOnSymbol_Require);
+
+	companion object {
+		fun fromCValue(cValue: ZXing_EanAddOnSymbol): EanAddOnSymbol {
+			return entries.first { it.cValue == cValue }
+		}
+	}
+}
+
+@OptIn(ExperimentalForeignApi::class)
+enum class TextMode(internal val cValue: ZXing_TextMode) {
+	Plain(ZXing_TextMode_Plain),
+	ECI(ZXing_TextMode_ECI),
+	HRI(ZXing_TextMode_HRI),
+	Hex(ZXing_TextMode_Hex),
+	Escaped(ZXing_TextMode_Escaped);
+
+	companion object {
+		fun fromCValue(cValue: ZXing_TextMode): TextMode {
+			return entries.first { it.cValue == cValue }
+		}
+	}
+}
diff --git a/wrappers/kn/src/nativeMain/kotlin/zxingcpp/BarcodeWriter.kt b/wrappers/kn/src/nativeMain/kotlin/zxingcpp/BarcodeWriter.kt
new file mode 100644
index 0000000000..b7b432cf07
--- /dev/null
+++ b/wrappers/kn/src/nativeMain/kotlin/zxingcpp/BarcodeWriter.kt
@@ -0,0 +1,69 @@
+/*
+* Copyright 2024 ISNing
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+package zxingcpp
+
+import cnames.structs.ZXing_CreatorOptions
+import cnames.structs.ZXing_WriterOptions
+import kotlinx.cinterop.*
+import zxingcpp.cinterop.*
+import kotlin.experimental.ExperimentalNativeApi
+import kotlin.native.ref.createCleaner
+
+// TODO: Remove this annotation when the API is stable
+@RequiresOptIn(level = RequiresOptIn.Level.ERROR, message = "The Writer API is experimental and may change in the future.")
+@Retention(AnnotationRetention.BINARY)
+annotation class ExperimentalWriterApi
+
+class BarcodeWritingException(message: String?) : Exception("Failed to write barcode: $message")
+
+@ExperimentalWriterApi
+@OptIn(ExperimentalForeignApi::class)
+open class CreatorOptions(format: BarcodeFormat) {
+	var format: BarcodeFormat
+		get() = ZXing_CreatorOptions_getFormat(cValue).parseIntoBarcodeFormat().first()
+		set(value) = ZXing_CreatorOptions_setFormat(cValue, value.rawValue)
+	var readerInit: Boolean
+		get() = ZXing_CreatorOptions_getReaderInit(cValue)
+		set(value) = ZXing_CreatorOptions_setReaderInit(cValue, value)
+	var forceSquareDataMatrix: Boolean
+		get() = ZXing_CreatorOptions_getForceSquareDataMatrix(cValue)
+		set(value) = ZXing_CreatorOptions_setForceSquareDataMatrix(cValue, value)
+	var ecLevel: String
+		get() = ZXing_CreatorOptions_getEcLevel(cValue)?.toKStringNullPtrHandledAndFree() ?: ""
+		set(value) = ZXing_CreatorOptions_setEcLevel(cValue, value)
+
+	val cValue: CValuesRef<ZXing_CreatorOptions>? = ZXing_CreatorOptions_new(format.rawValue)
+
+	@Suppress("unused")
+	@OptIn(ExperimentalNativeApi::class)
+	private val cleaner = createCleaner(cValue) { ZXing_CreatorOptions_delete(it) }
+}
+
+@ExperimentalWriterApi
+@OptIn(ExperimentalForeignApi::class)
+open class WriterOptions {
+	var scale: Int
+		get() = ZXing_WriterOptions_getScale(cValue)
+		set(value) = ZXing_WriterOptions_setScale(cValue, value)
+	var sizeHint: Int
+		get() = ZXing_WriterOptions_getSizeHint(cValue)
+		set(value) = ZXing_WriterOptions_setSizeHint(cValue, value)
+	var rotate: Int
+		get() = ZXing_WriterOptions_getRotate(cValue)
+		set(value) = ZXing_WriterOptions_setRotate(cValue, value)
+	var withHRT: Boolean
+		get() = ZXing_WriterOptions_getWithHRT(cValue)
+		set(value) = ZXing_WriterOptions_setWithHRT(cValue, value)
+	var withQuietZones: Boolean
+		get() = ZXing_WriterOptions_getWithQuietZones(cValue)
+		set(value) = ZXing_WriterOptions_setWithQuietZones(cValue, value)
+
+	val cValue: CValuesRef<ZXing_WriterOptions>? = ZXing_WriterOptions_new()
+
+	@Suppress("unused")
+	@OptIn(ExperimentalNativeApi::class)
+	private val cleaner = createCleaner(cValue) { ZXing_WriterOptions_delete(it) }
+}
diff --git a/wrappers/kn/src/nativeMain/kotlin/zxingcpp/ImageView.kt b/wrappers/kn/src/nativeMain/kotlin/zxingcpp/ImageView.kt
new file mode 100644
index 0000000000..2f8fdb7f2c
--- /dev/null
+++ b/wrappers/kn/src/nativeMain/kotlin/zxingcpp/ImageView.kt
@@ -0,0 +1,87 @@
+/*
+* Copyright 2024 ISNing
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+package zxingcpp
+
+import cnames.structs.ZXing_Image
+import cnames.structs.ZXing_ImageView
+import kotlinx.cinterop.*
+import zxingcpp.cinterop.*
+import kotlin.experimental.ExperimentalNativeApi
+import kotlin.native.ref.createCleaner
+
+@OptIn(ExperimentalForeignApi::class)
+class ImageView(
+	val data: ByteArray,
+	val width: Int,
+	val height: Int,
+	val format: ImageFormat,
+	val rowStride: Int = 0,
+	val pixStride: Int = 0,
+) {
+	private val pinnedData = data.pin()
+	val cValue: CPointer<ZXing_ImageView>? =
+		ZXing_ImageView_new_checked(
+			pinnedData.addressOf(0).reinterpret(),
+			data.size,
+			width,
+			height,
+			format.cValue,
+			rowStride,
+			pixStride
+		)
+
+	@Suppress("unused")
+	@OptIn(ExperimentalNativeApi::class)
+	private val cValueCleaner = createCleaner(cValue) { ZXing_ImageView_delete(it) }
+
+	@Suppress("unused")
+	@OptIn(ExperimentalNativeApi::class)
+	private val pinnedDataCleaner = createCleaner(pinnedData) { it.unpin() }
+}
+
+
+@OptIn(ExperimentalForeignApi::class)
+enum class ImageFormat(internal val cValue: ZXing_ImageFormat) {
+	None(ZXing_ImageFormat_None),
+	Lum(ZXing_ImageFormat_Lum),
+	LumA(ZXing_ImageFormat_LumA),
+	RGB(ZXing_ImageFormat_RGB),
+	BGR(ZXing_ImageFormat_BGR),
+	RGBA(ZXing_ImageFormat_RGBA),
+	ARGB(ZXing_ImageFormat_ARGB),
+	BGRA(ZXing_ImageFormat_BGRA),
+	ABGR(ZXing_ImageFormat_ABGR)
+}
+
+@OptIn(ExperimentalForeignApi::class)
+fun ZXing_ImageFormat.parseIntoImageFormat(): ImageFormat? =
+	ImageFormat.entries.firstOrNull { it.cValue == this }
+
+@ExperimentalWriterApi
+@OptIn(ExperimentalForeignApi::class)
+class Image(val cValue: CValuesRef<ZXing_Image>) {
+	val data: ByteArray
+		get() = ZXing_Image_data(cValue)?.run {
+			readBytes(width * height).also { ZXing_free(this) }
+		}?.takeUnless { it.isEmpty() } ?: throw OutOfMemoryError()
+	val width: Int get() = ZXing_Image_width(cValue)
+	val height: Int get() = ZXing_Image_height(cValue)
+	val format: ImageFormat
+		get() = ZXing_Image_format(cValue).parseIntoImageFormat() ?: error(
+			"Unknown format ${ZXing_Image_format(cValue)} for image, " +
+				"this is an internal error, please report it to the library maintainers."
+		)
+
+	@Suppress("unused")
+	@OptIn(ExperimentalNativeApi::class)
+	val cValueCleaner = createCleaner(cValue) { ZXing_Image_delete(it) }
+
+	fun toImageView(): ImageView = ImageView(data, width, height, format)
+}
+
+@ExperimentalWriterApi
+@OptIn(ExperimentalForeignApi::class)
+fun CValuesRef<ZXing_Image>.toKObject(): Image = Image(this)
diff --git a/wrappers/kn/src/nativeTest/kotlin/Test.kt b/wrappers/kn/src/nativeTest/kotlin/Test.kt
new file mode 100644
index 0000000000..d13a6b2dcc
--- /dev/null
+++ b/wrappers/kn/src/nativeTest/kotlin/Test.kt
@@ -0,0 +1,83 @@
+/*
+* Copyright 2024 ISNing
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+import zxingcpp.*
+import kotlin.experimental.ExperimentalNativeApi
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+
+class BarcodeReaderTest {
+
+	@Test
+	@OptIn(ExperimentalNativeApi::class)
+	fun `read barcode`() {
+		val data = "0000101000101101011110111101011011101010100111011100101000100101110010100000".map {
+			if (it == '0') 255.toByte() else 0.toByte()
+		}
+
+		val iv = ImageView(data.toByteArray(), data.size, 1, ImageFormat.Lum)
+		val br = BarcodeReader().apply {
+			binarizer = Binarizer.BoolCast
+		}
+		val res = br.read(iv).firstOrNull()
+
+		val expected = "96385074"
+
+		assertNotNull(res)
+		assert(res.isValid)
+		assertEquals(BarcodeFormat.EAN8, res.format)
+		assertEquals(expected, res.text)
+		assertContentEquals(expected.encodeToByteArray(), res.bytes)
+		assert(!res.hasECI)
+		assertEquals(ContentType.Text, res.contentType)
+		assertEquals(0, res.orientation)
+		assertEquals(PointI(4, 0), res.position.topLeft)
+		assertEquals(1, res.lineCount)
+	}
+
+	@Test
+	@OptIn(ExperimentalNativeApi::class, ExperimentalWriterApi::class)
+	fun `create write and read barcode with text`() {
+		val text = "I have the best words."
+		val barcode = Barcode(text, BarcodeFormat.DataMatrix)
+		val image = barcode.toImage()
+
+		val res = BarcodeReader.read(image.toImageView()).firstOrNull()
+
+		assertNotNull(res)
+		assert(res.isValid)
+		assertEquals(BarcodeFormat.DataMatrix, res.format)
+		assertEquals(text, res.text)
+		assertContentEquals(text.encodeToByteArray(), res.bytes)
+		assert(!res.hasECI)
+		assertEquals(ContentType.Text, res.contentType)
+		assertEquals(0, res.orientation)
+		assertEquals(PointI(1, 1), res.position.topLeft)
+		assertEquals(0, res.lineCount)
+	}
+
+	@Test
+	@OptIn(ExperimentalNativeApi::class, ExperimentalWriterApi::class)
+	fun `create write and read barcode with bytes`() {
+		val text = "I have the best words."
+		val barcode = Barcode(text.encodeToByteArray(), BarcodeFormat.DataMatrix)
+		val image = barcode.toImage()
+
+		val res = BarcodeReader.read(image.toImageView()).firstOrNull()
+
+		assertNotNull(res)
+		assert(res.isValid)
+		assertEquals(BarcodeFormat.DataMatrix, res.format)
+		assertEquals(text, res.text)
+		assertContentEquals(text.encodeToByteArray(), res.bytes)
+		assert(res.hasECI)
+		assertEquals(ContentType.Binary, res.contentType)
+		assertEquals(0, res.orientation)
+		assertEquals(PointI(1, 1), res.position.topLeft)
+		assertEquals(0, res.lineCount)
+	}
+}
diff --git a/wrappers/python/CMakeLists.txt b/wrappers/python/CMakeLists.txt
index 5b2a41581f..74c9bc1ccd 100644
--- a/wrappers/python/CMakeLists.txt
+++ b/wrappers/python/CMakeLists.txt
@@ -1,42 +1,61 @@
-cmake_minimum_required(VERSION 3.15)
+cmake_minimum_required(VERSION 3.18)
 project(ZXingPython)
 
-set (pybind11_git_repo https://github.com/pybind/pybind11.git)
-set (pybind11_git_rev v2.10.4)
-
 # check if we are called from the top-level ZXing project
 get_directory_property(hasParent PARENT_DIRECTORY)
 if (NOT hasParent)
     # Build with C++20 by default (which enables position independent DataMatrix detection).
     set(CMAKE_CXX_STANDARD 20)
-    # Allow the fallback to earlier versions of the compiler does not support it.
+    set(CMAKE_CXX_EXTENSIONS OFF)
+    # Allow the fallback to earlier versions if the compiler does not support it.
     set(CMAKE_CXX_STANDARD_REQUIRED OFF)
 
     option (BUILD_SHARED_LIBS "Link python module to shared lib" OFF)
-    option (BUILD_WRITERS "Build with writer support (encoders)" ON)
-    option (BUILD_READERS "Build with reader support (decoders)" ON)
-    set(BUILD_DEPENDENCIES "AUTO")
-    if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/core)
-        add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/core ZXing EXCLUDE_FROM_ALL)
+    option (ZXING_READERS "Build with reader support (decoders)" ON)
+    set    (ZXING_WRITERS "NEW" CACHE STRING "Build with old and/or new writer (encoder) backend (OFF/ON/OLD/NEW)")
+    set    (ZXING_DEPENDENCIES "AUTO" CACHE STRING "Fetch from github or use locally installed (AUTO/GITHUB/LOCAL)")
+    option (ZXING_EXPERIMENTAL_API "Build with experimental API" ON)
+    option (ZXING_USE_BUNDLED_ZINT "Use the bundled libzint for barcode creation/generation" ON)
+
+    set(CORE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/core)
+    if(IS_SYMLINK ${CORE_PATH})
+        # This is needed because otherwise GCC resolves the symlink which causes paths to randomly
+        # be prefixed by /core or by /wrappers/python/core depending on include order.
+        set(CORE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../../core)
+    endif()
+
+    if(EXISTS ${CORE_PATH})
+        add_subdirectory(${CORE_PATH} ZXing EXCLUDE_FROM_ALL)
         include(${CMAKE_CURRENT_SOURCE_DIR}/zxing.cmake)
     else()
         message(FATAL_ERROR "Unable to locate zxing source code")
     endif()
 endif()
 
-zxing_add_package(pybind11 pybind11 ${pybind11_git_repo} ${pybind11_git_rev})
+find_package(Python3 COMPONENTS Interpreter Development.Module REQUIRED) # see https://github.com/pybind/pybind11/issues/4785
+set(PYBIND11_FINDPYTHON ON) # see https://github.com/pybind/pybind11/issues/4785
+zxing_add_package(pybind11 pybind11 https://github.com/pybind/pybind11.git v2.13.6)
 
 # build the python module
 pybind11_add_module(zxingcpp zxing.cpp)
 target_link_libraries(zxingcpp PRIVATE ZXing::ZXing)
 
-if (BUILD_READERS AND BUILD_WRITERS)
-    add_test(NAME PythonTest COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test.py -v)
+if (ZXING_READERS AND ZXING_WRITERS)
+    add_test(NAME PythonTest COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test.py -v)
     set_property(TEST PythonTest PROPERTY ENVIRONMENT PYTHONPATH=$<TARGET_FILE_DIR:zxingcpp>)
 endif()
 
+if (NOT DEFINED ZXING_PYTHON_INSTALL_BINDIR)
+    set(ZXING_PYTHON_INSTALL_BINDIR "${CMAKE_INSTALL_BINDIR}")
+endif()
+
+if (NOT DEFINED ZXING_PYTHON_INSTALL_LIBDIR)
+    set(ZXING_PYTHON_INSTALL_LIBDIR "${CMAKE_INSTALL_LIBDIR}")
+endif()
+
 install(TARGETS zxingcpp
     COMPONENT python
-    RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
-    LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
-    ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+    RUNTIME DESTINATION "${ZXING_PYTHON_INSTALL_BINDIR}"
+    LIBRARY DESTINATION "${ZXING_PYTHON_INSTALL_LIBDIR}"
+    ARCHIVE DESTINATION "${ZXING_PYTHON_INSTALL_LIBDIR}")
+
diff --git a/wrappers/python/README.md b/wrappers/python/README.md
index 2d7df24bc4..b9ec60f5cb 100644
--- a/wrappers/python/README.md
+++ b/wrappers/python/README.md
@@ -2,6 +2,7 @@
 
 [![PyPI](https://img.shields.io/pypi/v/zxing-cpp.svg)](https://pypi.org/project/zxing-cpp/)
 
+
 ## Installation
 
 ```bash
@@ -13,7 +14,14 @@ or
 python setup.py install
 ```
 
-[Note: To install via `setup.py` (or via `pip install` in case there is no pre-build wheel available for your platfor or python version), you need a suitable [build environment](https://github.com/zxing-cpp/zxing-cpp#build-instructions) including a c++ compiler.]
+**Note**: To enable position independent and multi-symbol DataMatrix detection, the library needs to be compiled with a c++20 compiler. Unfortunately some build environments (currently the 32-bit builds for Linux) used by `cibuildwheel` to generate the binary wheels that are published on [pypi.org](https://pypi.org/project/zxing-cpp/) don't include a c++20 compiler. Best chance to enable proper DataMatrix support in that case is by installing from source:
+
+```bash
+pip install zxing-cpp --no-binary zxing-cpp
+```
+
+In that case or if there is no pre-build wheel available for your platform or python version or if you use `setup.py` directly, a suitable [build environment](https://github.com/zxing-cpp/zxing-cpp#build-instructions) including a c++ compiler is required.
+
 
 ## Usage
 
@@ -21,15 +29,15 @@ python setup.py install
 import cv2, zxingcpp
 
 img = cv2.imread('test.png')
-results = zxingcpp.read_barcodes(img)
-for result in results:
+barcodes = zxingcpp.read_barcodes(img)
+for barcode in barcodes:
 	print('Found barcode:'
-		f'\n Text:    "{result.text}"'
-		f'\n Format:   {result.format}'
-		f'\n Content:  {result.content_type}'
-		f'\n Position: {result.position}')
-if len(results) == 0:
+		f'\n Text:    "{barcode.text}"'
+		f'\n Format:   {barcode.format}'
+		f'\n Content:  {barcode.content_type}'
+		f'\n Position: {barcode.position}')
+if len(barcodes) == 0:
 	print("Could not find any barcode.")
 ```
 
-To get a full list of available parameters for `read_barcodes` and `write_barcode` as well as the properties of the result objects, have a look at the `PYBIND11_MODULE` definition in [this c++ source file](https://github.com/zxing-cpp/zxing-cpp/blob/master/wrappers/python/zxing.cpp).
+To get a full list of available parameters for `read_barcodes` and `write_barcode` as well as the properties of the Barcode objects, have a look at the `PYBIND11_MODULE` definition in [this c++ source file](https://github.com/zxing-cpp/zxing-cpp/blob/master/wrappers/python/zxing.cpp).
diff --git a/wrappers/python/demo_reader.py b/wrappers/python/demo_reader.py
index 60a0a11fbb..9292073948 100644
--- a/wrappers/python/demo_reader.py
+++ b/wrappers/python/demo_reader.py
@@ -2,12 +2,12 @@
 from PIL import Image
 
 img = Image.open(sys.argv[1])
-results = zxingcpp.read_barcodes(img)
-for result in results:
+barcodes = zxingcpp.read_barcodes(img)
+for barcode in barcodes:
 	print('Found barcode:'
-		f'\n Text:    "{result.text}"'
-		f'\n Format:   {result.format}'
-		f'\n Content:  {result.content_type}'
-		f'\n Position: {result.position}')
-if len(results) == 0:
+		f'\n Text:    "{barcode.text}"'
+		f'\n Format:   {barcode.format}'
+		f'\n Content:  {barcode.content_type}'
+		f'\n Position: {barcode.position}')
+if len(barcodes) == 0:
 	print("Could not find any barcode.")
diff --git a/wrappers/python/demo_writer.py b/wrappers/python/demo_writer.py
index dfdf20c61e..f3ca456b1d 100644
--- a/wrappers/python/demo_writer.py
+++ b/wrappers/python/demo_writer.py
@@ -3,7 +3,20 @@
 from PIL import Image
 
 if len(sys.argv) < 3:
-	img = zxingcpp.write_barcode(zxingcpp.BarcodeFormat.QRCode, "I have the best words.", width=200, height=200)
+	format, content = zxingcpp.BarcodeFormat.QRCode, "I have the best words."
 else:
-	img = zxingcpp.write_barcode(zxingcpp.barcode_format_from_str(sys.argv[1]), sys.argv[2], width=200, height=200)
+	format, content = zxingcpp.barcode_format_from_str(sys.argv[1]), sys.argv[2]
+
+# old writer API
+img = zxingcpp.write_barcode(format, content, width=200, height=200)
 Image.fromarray(img).save("test.png")
+
+# new/experimental writer API
+# barcode = zxingcpp.create_barcode(content, format, ec_level = "50%")
+
+# img = barcode.to_image(size_hint = 500)
+# Image.fromarray(img).save("test.png")
+
+# svg = barcode.to_svg(with_hrt = True)
+# with open("test.svg", "w") as svg_file:
+# 	svg_file.write(svg)
diff --git a/wrappers/python/setup.py b/wrappers/python/setup.py
index f3c3b38c7d..d98aab2266 100644
--- a/wrappers/python/setup.py
+++ b/wrappers/python/setup.py
@@ -9,74 +9,74 @@
 
 # Adapted from here: https://github.com/pybind/cmake_example/blob/master/setup.py
 class CMakeExtension(Extension):
-    def __init__(self, name, sourcedir=''):
-        Extension.__init__(self, name, sources=[])
-        self.sourcedir = os.path.abspath(sourcedir)
+	def __init__(self, name, sourcedir=''):
+		Extension.__init__(self, name, sources=[])
+		self.sourcedir = os.path.abspath(sourcedir)
 
 
 class CMakeBuild(build_ext):
-    def build_extension(self, ext):
-        extdir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name)))
-        cmake_args = ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + extdir,
-                      '-DPYTHON_EXECUTABLE=' + sys.executable,
-                      '-DVERSION_INFO=' + self.distribution.get_version()]
+	def build_extension(self, ext):
+		extdir = os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name)))
+		cmake_args = ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + extdir,
+					  '-DPython3_EXECUTABLE=' + sys.executable,
+					  '-DVERSION_INFO=' + self.distribution.get_version()]
 
-        cfg = 'Debug' if self.debug else 'Release'
-        build_args = ['--config', cfg,
-                      '-j', '8']
+		cfg = 'Debug' if self.debug else 'Release'
+		build_args = ['--config', cfg,
+					  '-j', '8']
 
-        if platform.system() == "Windows":
-            cmake_args += ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}'.format(cfg.upper(), extdir)]
-            if sys.maxsize > 2**32:
-                cmake_args += ['-A', 'x64']
-            else:
-                cmake_args += ['-A', 'Win32']
-            build_args += ['--', '/m']
-        else:
-            cmake_args += ['-DCMAKE_BUILD_TYPE=' + cfg]
+		if platform.system() == "Windows":
+			cmake_args += ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}'.format(cfg.upper(), extdir)]
+			if sys.maxsize > 2**32:
+				cmake_args += ['-A', 'x64']
+			else:
+				cmake_args += ['-A', 'Win32']
+			build_args += ['--', '/m']
+		else:
+			cmake_args += ['-DCMAKE_BUILD_TYPE=' + cfg]
 
-        if not os.path.exists(self.build_temp):
-            os.makedirs(self.build_temp)
+		if not os.path.exists(self.build_temp):
+			os.makedirs(self.build_temp)
 
-        subprocess.check_call(['cmake', ext.sourcedir] + cmake_args, cwd=self.build_temp)
-        subprocess.check_call(['cmake', '--build', '.'] + build_args, cwd=self.build_temp)
+		subprocess.check_call(['cmake', ext.sourcedir] + cmake_args, cwd=self.build_temp)
+		subprocess.check_call(['cmake', '--build', '.'] + build_args, cwd=self.build_temp)
 
 
 with open("README.md", "r", encoding="utf-8") as fh:
-    long_description = fh.read()
+	long_description = fh.read()
 
 
 setup(
-    name='zxing-cpp',
-    # setuptools_scm cannot be used because of the structure of the project until the following issues are solved:
-    # https://github.com/pypa/setuptools_scm/issues/357
-    # https://github.com/pypa/pip/issues/7549
-    # Because pip works on a copy of current directory in a temporary directory, the temporary directory does not hold
-    # the .git directory of the repo, so that setuptools_scm cannot guess the current version.
-    # use_scm_version={
-    #     "root": "../..",
-    #     "version_scheme": "guess-next-dev",
-    #     "local_scheme": "no-local-version",
-    #     "tag_regex": "v?([0-9]+.[0-9]+.[0-9]+)",
-    # },
-    version='2.2.0',
-    description='Python bindings for the zxing-cpp barcode library',
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    author='ZXing-C++ Community',
-    author_email='zxingcpp@gmail.com',
-    url='https://github.com/zxing-cpp/zxing-cpp',
-    license='Apache License 2.0',
-    keywords=['barcode'],
-    classifiers=[
-        "Development Status :: 4 - Beta",
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: Apache Software License",
-        "Operating System :: OS Independent",
-        "Topic :: Multimedia :: Graphics",
-    ],
-    python_requires=">=3.6",
-    ext_modules=[CMakeExtension('zxingcpp')],
-    cmdclass=dict(build_ext=CMakeBuild),
-    zip_safe=False,
+	name='zxing-cpp',
+	# setuptools_scm cannot be used because of the structure of the project until the following issues are solved:
+	# https://github.com/pypa/setuptools_scm/issues/357
+	# https://github.com/pypa/pip/issues/7549
+	# Because pip works on a copy of current directory in a temporary directory, the temporary directory does not hold
+	# the .git directory of the repo, so that setuptools_scm cannot guess the current version.
+	# use_scm_version={
+	#     "root": "../..",
+	#     "version_scheme": "guess-next-dev",
+	#     "local_scheme": "no-local-version",
+	#     "tag_regex": "v?([0-9]+.[0-9]+.[0-9]+)",
+	# },
+	version='2.3.0',
+	description='Python bindings for the zxing-cpp barcode library',
+	long_description=long_description,
+	long_description_content_type="text/markdown",
+	author='ZXing-C++ Community',
+	author_email='zxingcpp@gmail.com',
+	url='https://github.com/zxing-cpp/zxing-cpp',
+	license='Apache License 2.0',
+	keywords=['barcode'],
+	classifiers=[
+		"Development Status :: 4 - Beta",
+		"Programming Language :: Python :: 3",
+		"License :: OSI Approved :: Apache Software License",
+		"Operating System :: OS Independent",
+		"Topic :: Multimedia :: Graphics",
+	],
+	python_requires=">=3.6",
+	ext_modules=[CMakeExtension('zxingcpp')],
+	cmdclass=dict(build_ext=CMakeBuild),
+	zip_safe=False,
 )
diff --git a/wrappers/python/test.py b/wrappers/python/test.py
index a086b24413..f3d1282a79 100644
--- a/wrappers/python/test.py
+++ b/wrappers/python/test.py
@@ -1,6 +1,7 @@
 import importlib.util
 import unittest
 import math
+import platform
 
 import zxingcpp
 
@@ -9,7 +10,7 @@
 has_cv2 = importlib.util.find_spec('cv2') is not None
 
 BF = zxingcpp.BarcodeFormat
-
+CT = zxingcpp.ContentType
 
 class TestFormat(unittest.TestCase):
 
@@ -26,6 +27,7 @@ def check_res(self, res, format, text):
 		self.assertEqual(res.text, text)
 		self.assertEqual(res.bytes, bytes(text, 'utf-8'))
 		self.assertEqual(res.orientation, 0)
+		self.assertEqual(res.content_type, CT.Text)
 
 	def test_write_read_cycle(self):
 		format = BF.QRCode
@@ -35,23 +37,32 @@ def test_write_read_cycle(self):
 		res = zxingcpp.read_barcode(img)
 		self.check_res(res, format, text)
 		self.assertEqual(res.symbology_identifier, "]Q1")
-		self.assertEqual(res.position.top_left.x, 4)
+		# self.assertEqual(res.position.top_left.x, 4)
 
 		res = zxingcpp.read_barcode(img, formats=format)
 		self.check_res(res, format, text)
 
+	@unittest.skipIf(not hasattr(zxingcpp, 'create_barcode'), "skipping test for new create_barcode API")
+	def test_create_write_read_cycle(self):
+		format = BF.DataMatrix
+		text = "I have the best words."
+		img = zxingcpp.create_barcode(text, format).to_image()
+
+		res = zxingcpp.read_barcode(img)
+		self.check_res(res, format, text)
+
 	def test_write_read_oned_cycle(self):
 		format = BF.Code128
 		text = "I have the best words."
-		height = 80
+		height = 50
 		width = 400
 		img = zxingcpp.write_barcode(format, text, width=width, height=height)
-		self.assertEqual(img.shape[0], height)
-		self.assertEqual(img.shape[1], width)
+		# self.assertEqual(img.shape[0], height)
+		# self.assertEqual(img.shape[1], width)
 
 		res = zxingcpp.read_barcode(img)
 		self.check_res(res, format, text)
-		self.assertEqual(res.position.top_left.x, 61)
+		# self.assertEqual(res.position.top_left.x, 61)
 
 	def test_write_read_multi_cycle(self):
 		format = BF.QRCode
@@ -61,6 +72,27 @@ def test_write_read_multi_cycle(self):
 		res = zxingcpp.read_barcodes(img)[0]
 		self.check_res(res, format, text)
 
+	def test_write_read_bytes_cycle(self):
+		format = BF.QRCode
+		text = b"\1\2\3\4"
+		img = zxingcpp.write_barcode(format, text)
+
+		res = zxingcpp.read_barcode(img)
+		self.assertTrue(res.valid)
+		self.assertEqual(res.bytes, text)
+		self.assertEqual(res.content_type, CT.Binary)
+
+	@unittest.skipIf(not hasattr(zxingcpp, 'create_barcode'), "skipping test for new create_barcode API")
+	def test_create_write_read_bytes_cycle(self):
+		format = BF.DataMatrix
+		text = b"\1\2\3\4"
+		img = zxingcpp.create_barcode(text, format).to_image()
+
+		res = zxingcpp.read_barcode(img)
+		self.assertTrue(res.valid)
+		self.assertEqual(res.bytes, text)
+		self.assertEqual(res.content_type, CT.Binary)
+
 	@staticmethod
 	def zeroes(shape):
 		return memoryview(b"0" * math.prod(shape)).cast("B", shape=shape)
@@ -88,7 +120,7 @@ def test_write_read_cycle_buffer(self):
 
 		self.check_res(zxingcpp.read_barcode(img), format, text)
 
-	@unittest.skipIf(not has_numpy, "need numpy for read/write tests")
+	@unittest.skipIf(not has_numpy or platform.system() == "Windows", "need numpy for read/write tests")
 	def test_write_read_cycle_numpy(self):
 		import numpy as np
 		format = BF.QRCode
@@ -97,7 +129,7 @@ def test_write_read_cycle_numpy(self):
 		img = np.array(img)
 
 		self.check_res(zxingcpp.read_barcode(img), format, text)
-		self.check_res(zxingcpp.read_barcode(img[5:40,5:40]), format, text)
+		self.check_res(zxingcpp.read_barcode(img[4:40,4:40]), format, text)
 
 	@unittest.skipIf(not has_pil, "need PIL for read/write tests")
 	def test_write_read_cycle_pil(self):
@@ -122,7 +154,7 @@ def test_write_read_cycle_cv2(self):
 		img = cv2.cvtColor(numpy.array(img), cv2.COLOR_GRAY2BGR )
 
 		self.check_res(zxingcpp.read_barcode(img), format, text)
-		self.check_res(zxingcpp.read_barcode(img[5:40,5:40,:]), format, text)
+		self.check_res(zxingcpp.read_barcode(img[4:40,4:40,:]), format, text)
 
 	def test_read_invalid_type(self):
 		self.assertRaisesRegex(
diff --git a/wrappers/python/zxing.cpp b/wrappers/python/zxing.cpp
index a83e1b36ea..4afbb4f18c 100644
--- a/wrappers/python/zxing.cpp
+++ b/wrappers/python/zxing.cpp
@@ -12,15 +12,18 @@
 #include "ZXAlgorithms.h"
 
 // Writer
+#ifdef ZXING_EXPERIMENTAL_API
+#include "WriteBarcode.h"
+#else
 #include "BitMatrix.h"
 #include "Matrix.h"
 #include "MultiFormatWriter.h"
+#include <cstring>
+#endif
 
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 #include <optional>
-#include <functional>
-#include <memory>
 #include <sstream>
 #include <vector>
 
@@ -63,7 +66,7 @@ auto read_barcodes_impl(py::object _image, const BarcodeFormats& formats, bool t
 				else if (mode == "RGB")
 					imgfmt = ImageFormat::RGB;
 				else if (mode == "RGBA")
-					imgfmt = ImageFormat::RGBX;
+					imgfmt = ImageFormat::RGBA;
 				else {
 					// Unsupported mode in ImageFormat. Let's do conversion to L mode with PIL.
 					_image = _image.attr("convert")("L");
@@ -142,27 +145,68 @@ auto read_barcodes_impl(py::object _image, const BarcodeFormats& formats, bool t
 	return ReadBarcodes({bytes, width, height, imgfmt, rowStride, pixStride}, opts);
 }
 
-std::optional<Result> read_barcode(py::object _image, const BarcodeFormats& formats, bool try_rotate, bool try_downscale,
-								   TextMode text_mode, Binarizer binarizer, bool is_pure, EanAddOnSymbol ean_add_on_symbol,
-								   bool return_errors)
+std::optional<Barcode> read_barcode(py::object _image, const BarcodeFormats& formats, bool try_rotate, bool try_downscale,
+									TextMode text_mode, Binarizer binarizer, bool is_pure, EanAddOnSymbol ean_add_on_symbol,
+									bool return_errors)
 {
 	auto res = read_barcodes_impl(_image, formats, try_rotate, try_downscale, text_mode, binarizer, is_pure, ean_add_on_symbol,
 								  return_errors, 1);
 	return res.empty() ? std::nullopt : std::optional(res.front());
 }
 
-Results read_barcodes(py::object _image, const BarcodeFormats& formats, bool try_rotate, bool try_downscale,
-					  TextMode text_mode, Binarizer binarizer, bool is_pure, EanAddOnSymbol ean_add_on_symbol, bool return_errors)
+Barcodes read_barcodes(py::object _image, const BarcodeFormats& formats, bool try_rotate, bool try_downscale, TextMode text_mode,
+					   Binarizer binarizer, bool is_pure, EanAddOnSymbol ean_add_on_symbol, bool return_errors)
 {
 	return read_barcodes_impl(_image, formats, try_rotate, try_downscale, text_mode, binarizer, is_pure, ean_add_on_symbol,
 							  return_errors);
 }
 
-Matrix<uint8_t> write_barcode(BarcodeFormat format, std::string text, int width, int height, int quiet_zone, int ec_level)
+#ifdef ZXING_EXPERIMENTAL_API
+Barcode create_barcode(py::object content, BarcodeFormat format, std::string ec_level)
+{
+	auto cOpts = CreatorOptions(format).ecLevel(ec_level);
+	auto data = py::cast<std::string>(content);
+
+	if (py::isinstance<py::str>(content))
+		return CreateBarcodeFromText(data, cOpts);
+	else if (py::isinstance<py::bytes>(content))
+		return CreateBarcodeFromBytes(data, cOpts);
+	else
+		throw py::type_error("Invalid input: only 'str' and 'bytes' supported.");
+}
+
+Image write_barcode_to_image(Barcode barcode, int size_hint, bool with_hrt, bool with_quiet_zones)
+{
+	return WriteBarcodeToImage(barcode, WriterOptions().sizeHint(size_hint).withHRT(with_hrt).withQuietZones(with_quiet_zones));
+}
+
+std::string write_barcode_to_svg(Barcode barcode, int size_hint, bool with_hrt, bool with_quiet_zones)
 {
-	auto writer = MultiFormatWriter(format).setEncoding(CharacterSet::UTF8).setMargin(quiet_zone).setEccLevel(ec_level);
-	auto bitmap = writer.encode(text, width, height);
-	return ToMatrix<uint8_t>(bitmap);
+	return WriteBarcodeToSVG(barcode, WriterOptions().sizeHint(size_hint).withHRT(with_hrt).withQuietZones(with_quiet_zones));
+}
+#endif
+
+Image write_barcode(BarcodeFormat format, py::object content, int width, int height, int quiet_zone, int ec_level)
+{
+#ifdef ZXING_EXPERIMENTAL_API
+	auto barcode = create_barcode(content, format, std::to_string(ec_level));
+	return write_barcode_to_image(barcode, std::max(width, height), false, quiet_zone != 0);
+#else
+	CharacterSet encoding [[maybe_unused]];
+	if (py::isinstance<py::str>(content))
+		encoding  = CharacterSet::UTF8;
+	else if (py::isinstance<py::bytes>(content))
+		encoding = CharacterSet::BINARY;
+	else
+		throw py::type_error("Invalid input: only 'str' and 'bytes' supported.");
+
+	auto writer = MultiFormatWriter(format).setEncoding(encoding).setMargin(quiet_zone).setEccLevel(ec_level);
+	auto bits = writer.encode(py::cast<std::string>(content), width, height);
+	auto bitmap = ToMatrix<uint8_t>(bits);
+	Image res(bitmap.width(), bitmap.height());
+	memcpy(const_cast<uint8_t*>(res.data()), bitmap.data(), bitmap.size());
+	return res;
+#endif
 }
 
 
@@ -191,6 +235,8 @@ PYBIND11_MODULE(zxingcpp, m)
 		.value("RMQRCode", BarcodeFormat::RMQRCode)
 		.value("DataBar", BarcodeFormat::DataBar)
 		.value("DataBarExpanded", BarcodeFormat::DataBarExpanded)
+		.value("DataBarLimited", BarcodeFormat::DataBarLimited)
+		.value("DXFilmEdge", BarcodeFormat::DXFilmEdge)
 		.value("UPCA", BarcodeFormat::UPCA)
 		.value("UPCE", BarcodeFormat::UPCE)
 		// use upper case 'NONE' because 'None' is a reserved identifier in python
@@ -243,16 +289,16 @@ PYBIND11_MODULE(zxingcpp, m)
 	py::class_<Position>(m, "Position", "The position of a decoded symbol")
 		.def_property_readonly("top_left", &Position::topLeft,
 			":return: coordinate of the symbol's top-left corner\n"
-			":rtype: zxing.Point")
+			":rtype: zxingcpp.Point")
 		.def_property_readonly("top_right", &Position::topRight,
 			":return: coordinate of the symbol's top-right corner\n"
-			":rtype: zxing.Point")
+			":rtype: zxingcpp.Point")
 		.def_property_readonly("bottom_left", &Position::bottomLeft,
 			":return: coordinate of the symbol's bottom-left corner\n"
-			":rtype: zxing.Point")
+			":rtype: zxingcpp.Point")
 		.def_property_readonly("bottom_right", &Position::bottomRight,
 			":return: coordinate of the symbol's bottom-right corner\n"
-			":rtype: zxing.Point")
+			":rtype: zxingcpp.Point")
 		.def("__str__", [](Position pos) {
 			std::ostringstream oss;
 			oss << pos;
@@ -267,57 +313,69 @@ PYBIND11_MODULE(zxingcpp, m)
 	py::class_<Error>(m, "Error", "Barcode reading error")
 		.def_property_readonly("type", &Error::type,
 		   ":return: Error type\n"
-		   ":rtype: zxing.ErrorType")
+		   ":rtype: zxingcpp.ErrorType")
 		.def_property_readonly("message", &Error::msg,
 			":return: Error message\n"
 			":rtype: str")
 		.def("__str__", [](Error e) { return ToString(e); });
-	py::class_<Result>(m, "Result", "Result of barcode reading")
-		.def_property_readonly("valid", &Result::isValid,
-			":return: whether or not result is valid (i.e. a symbol was found)\n"
+	py::class_<Barcode>(m, "Barcode", "The Barcode class")
+		.def_property_readonly("valid", &Barcode::isValid,
+			":return: whether or not barcode is valid (i.e. a symbol was found and decoded)\n"
 			":rtype: bool")
-		.def_property_readonly("text", [](const Result& res) { return res.text(); },
+		.def_property_readonly("text", [](const Barcode& res) { return res.text(); },
 			":return: text of the decoded symbol (see also TextMode parameter)\n"
 			":rtype: str")
-		.def_property_readonly("bytes", [](const Result& res) { return py::bytes(res.bytes().asString()); },
+		.def_property_readonly("bytes", [](const Barcode& res) { return py::bytes(res.bytes().asString()); },
 			":return: uninterpreted bytes of the decoded symbol\n"
 			":rtype: bytes")
-		.def_property_readonly("format", &Result::format,
+		.def_property_readonly("format", &Barcode::format,
 			":return: decoded symbol format\n"
-			":rtype: zxing.BarcodeFormat")
-		.def_property_readonly("symbology_identifier", &Result::symbologyIdentifier,
+			":rtype: zxingcpp.BarcodeFormat")
+		.def_property_readonly("symbology_identifier", &Barcode::symbologyIdentifier,
 			":return: decoded symbology idendifier\n"
 			":rtype: str")
-		.def_property_readonly("ec_level", &Result::ecLevel,
+		.def_property_readonly("ec_level", &Barcode::ecLevel,
 			":return: error correction level of the symbol (empty string if not applicable)\n"
 			":rtype: str")
-		.def_property_readonly("content_type", &Result::contentType,
+		.def_property_readonly("content_type", &Barcode::contentType,
 			":return: content type of symbol\n"
-			":rtype: zxing.ContentType")
-		.def_property_readonly("position", &Result::position,
+			":rtype: zxingcpp.ContentType")
+		.def_property_readonly("position", &Barcode::position,
 			":return: position of the decoded symbol\n"
-			":rtype: zxing.Position")
-		.def_property_readonly("orientation", &Result::orientation,
+			":rtype: zxingcpp.Position")
+		.def_property_readonly("orientation", &Barcode::orientation,
 			":return: orientation (in degree) of the decoded symbol\n"
 			":rtype: int")
 		.def_property_readonly(
-			"error", [](const Result& res) { return res.error() ? std::optional(res.error()) : std::nullopt; },
+			"error", [](const Barcode& res) { return res.error() ? std::optional(res.error()) : std::nullopt; },
 			":return: Error code or None\n"
-			":rtype: zxing.Error");
+			":rtype: zxingcpp.Error")
+#ifdef ZXING_EXPERIMENTAL_API
+		.def("to_image", &write_barcode_to_image,
+			  py::arg("size_hint") = 0,
+			  py::arg("with_hrt") = false,
+			  py::arg("with_quiet_zones") = true)
+		.def("to_svg", &write_barcode_to_svg,
+			  py::arg("size_hint") = 0,
+			  py::arg("with_hrt") = false,
+			  py::arg("with_quiet_zones") = true)
+#endif
+		;
+	m.attr("Result") = m.attr("Barcode"); // alias to deprecated name for the Barcode class
 	m.def("barcode_format_from_str", &BarcodeFormatFromString,
 		py::arg("str"),
 		"Convert string to BarcodeFormat\n\n"
 		":type str: str\n"
 		":param str: string representing barcode format\n"
 		":return: corresponding barcode format\n"
-		":rtype: zxing.BarcodeFormat");
+		":rtype: zxingcpp.BarcodeFormat");
 	m.def("barcode_formats_from_str", &BarcodeFormatsFromString,
 		py::arg("str"),
 		"Convert string to BarcodeFormats\n\n"
 		":type str: str\n"
 		":param str: string representing a list of barcodes formats\n"
 		":return: corresponding barcode formats\n"
-		":rtype: zxing.BarcodeFormats");
+		":rtype: zxingcpp.BarcodeFormats");
 	m.def("read_barcode", &read_barcode,
 		py::arg("image"),
 		py::arg("formats") = BarcodeFormats{},
@@ -343,7 +401,7 @@ PYBIND11_MODULE(zxingcpp, m)
 		":param try_downscale: if ``True`` (the default), decoder also scans downscaled versions of the input; \n"
 		"  if ``False``, it will only search in the resolution provided.\n"
 		":type text_mode: zxing.TextMode\n"
-		":param text_mode: specifies the TextMode that governs how the raw bytes content is transcoded to text in the Result.\n"
+		":param text_mode: specifies the TextMode that governs how the raw bytes content is transcoded to text.\n"
 		"  Defaults to :py:attr:`zxing.TextMode.HRI`."
 		":type binarizer: zxing.Binarizer\n"
 		":param binarizer: the binarizer used to convert image before decoding barcodes.\n"
@@ -355,10 +413,10 @@ PYBIND11_MODULE(zxingcpp, m)
 		":param ean_add_on_symbol: Specify whether to Ignore, Read or Require EAN-2/5 add-on symbols while scanning \n"
 		"  EAN/UPC codes. Default is ``Ignore``.\n"
 		":type return_errors: bool\n"
-		":param return_errors: Set to True to return the barcodes with errors as well (e.g. checksum errors); see ``Result.error``.\n"
+		":param return_errors: Set to True to return the barcodes with errors as well (e.g. checksum errors); see ``Barcode.error``.\n"
 		" Default is False."
-		":rtype: zxing.Result\n"
-		":return: a zxing result containing decoded symbol if found, None otherwise"
+		":rtype: zxingcpp.Barcode\n"
+		":return: a Barcode if found, None otherwise"
 	);
 	m.def("read_barcodes", &read_barcodes,
 		py::arg("image"),
@@ -385,7 +443,7 @@ PYBIND11_MODULE(zxingcpp, m)
 		":param try_downscale: if ``True`` (the default), decoder also scans downscaled versions of the input; \n"
 		"  if ``False``, it will only search in the resolution provided.\n"
 		":type text_mode: zxing.TextMode\n"
-		":param text_mode: specifies the TextMode that governs how the raw bytes content is transcoded to text in the Result.\n"
+		":param text_mode: specifies the TextMode that governs how the raw bytes content is transcoded to text.\n"
 		"  Defaults to :py:attr:`zxing.TextMode.HRI`."
 		":type binarizer: zxing.Binarizer\n"
 		":param binarizer: the binarizer used to convert image before decoding barcodes.\n"
@@ -397,30 +455,53 @@ PYBIND11_MODULE(zxingcpp, m)
 		":param ean_add_on_symbol: Specify whether to Ignore, Read or Require EAN-2/5 add-on symbols while scanning \n"
 		"  EAN/UPC codes. Default is ``Ignore``.\n"
 		":type return_errors: bool\n"
-		":param return_errors: Set to True to return the barcodes with errors as well (e.g. checksum errors); see ``Result.error``.\n"
+		":param return_errors: Set to True to return the barcodes with errors as well (e.g. checksum errors); see ``Barcode.error``.\n"
 		" Default is False.\n"
-		":rtype: zxing.Result\n"
-		":return: a list of zxing results containing decoded symbols, the list is empty if none is found"
+		":rtype: list[zxingcpp.Barcode]\n"
+		":return: a list of Barcodes, the list is empty if none is found"
 	);
-	py::class_<Matrix<uint8_t>>(m, "Bitmap", py::buffer_protocol())
+	py::class_<Image>(m, "Image", py::buffer_protocol())
 		.def_property_readonly(
 			"__array_interface__",
-			[](const Matrix<uint8_t>& m) {
+			[](const Image& m) {
 				return py::dict("version"_a = 3, "data"_a = m, "shape"_a = py::make_tuple(m.height(), m.width()), "typestr"_a = "|u1");
 			})
-		.def_property_readonly("shape", [](const Matrix<uint8_t>& m) { return py::make_tuple(m.height(), m.width()); })
-		.def_buffer([](const Matrix<uint8_t>& m) -> py::buffer_info {
+		.def_property_readonly("shape", [](const Image& m) { return py::make_tuple(m.height(), m.width()); })
+		.def_buffer([](const Image& m) -> py::buffer_info {
 			return {
 				const_cast<uint8_t*>(m.data()),                 // Pointer to buffer
 				sizeof(uint8_t),                                // Size of one scalar
 				py::format_descriptor<uint8_t>::format(),       // Python struct-style format descriptor
 				2,                                              // Number of dimensions
 				{m.height(), m.width()},                        // Buffer dimensions
-				{sizeof(uint8_t) * m.width(), sizeof(uint8_t)}, // Strides (in bytes) for each index
+				{m.rowStride(), m.pixStride()},                 // Strides (in bytes) for each index
 				true                                            // read-only
 			};
 		});
 
+#ifdef ZXING_EXPERIMENTAL_API
+	m.def("create_barcode", &create_barcode,
+		py::arg("content"),
+		py::arg("format"),
+		py::arg("ec_level") = ""
+	);
+
+	m.def("write_barcode_to_image", &write_barcode_to_image,
+		py::arg("barcode"),
+		py::arg("size_hint") = 0,
+		py::arg("with_hrt") = false,
+		py::arg("with_quiet_zones") = true
+	);
+
+	m.def("write_barcode_to_svg", &write_barcode_to_svg,
+		py::arg("barcode"),
+		py::arg("size_hint") = 0,
+		py::arg("with_hrt") = false,
+		py::arg("with_quiet_zones") = true
+	);
+#endif
+
+	m.attr("Bitmap") = m.attr("Image"); // alias to deprecated name for the Image class
 	m.def("write_barcode", &write_barcode,
 		py::arg("format"),
 		py::arg("text"),
@@ -431,8 +512,8 @@ PYBIND11_MODULE(zxingcpp, m)
 		"Write (encode) a text into a barcode and return 8-bit grayscale bitmap buffer\n\n"
 		":type format: zxing.BarcodeFormat\n"
 		":param format: format of the barcode to create\n"
-		":type text: str\n"
-		":param text: the text of barcode\n"
+		":type text: str|bytes\n"
+		":param text: the text/content of the barcode. A str is encoded as utf8 text and bytes as binary data\n"
 		":type width: int\n"
 		":param width: width (in pixels) of the barcode to create. If undefined (or set to 0), barcode will be\n"
 		"  created with the minimum possible width\n"
@@ -444,6 +525,6 @@ PYBIND11_MODULE(zxingcpp, m)
 		"  the minimum quiet zone of respective barcode is used."
 		":type ec_level: int\n"
 		":param ec_level: error correction level of the barcode (Used for Aztec, PDF417, and QRCode only).\n"
-		":rtype: zxing.Bitmap\n"
+		":rtype: zxingcpp.Bitmap\n"
 	);
 }
diff --git a/wrappers/rust/.gitignore b/wrappers/rust/.gitignore
new file mode 100644
index 0000000000..7268cb7913
--- /dev/null
+++ b/wrappers/rust/.gitignore
@@ -0,0 +1,4 @@
+target
+.idea
+.vscode
+Cargo.lock
diff --git a/wrappers/rust/Cargo.toml b/wrappers/rust/Cargo.toml
new file mode 100644
index 0000000000..b38be6ca58
--- /dev/null
+++ b/wrappers/rust/Cargo.toml
@@ -0,0 +1,39 @@
+[package]
+name = "zxing-cpp"
+version = "0.4.1"
+edition = "2021"
+# authors = ["Axel Waggershauser <zxingcpp@gmail.com>"]
+license = "Apache-2.0"
+description = "A rust wrapper for the zxing-cpp barcode library."
+repository = "https://github.com/zxing-cpp/zxing-cpp/"
+readme = "README.md"
+keywords = ["zxing", "barcode", "barcode_reader", "ffi"]
+categories = ["api-bindings", "computer-vision"]
+exclude = [
+    "core/**/*Writer*",
+    "core/**/*Encode*",
+]
+
+[lib]
+name = "zxingcpp"
+path = "src/lib.rs"
+
+[features]
+default = []
+image = ["dep:image"]
+bundled = []
+
+[dependencies]
+thiserror = "1.0"
+paste = "1.0"
+flagset = "0.4.4"
+image = {version = "0.24.8", optional = true}
+
+[dev-dependencies]
+cfg-if = "1.0"
+anyhow = "1.0"
+image = {version = "0.24.8"}
+
+[build-dependencies]
+cmake = {version = "0.1.50"}
+miette = {version = "5.10.0", features = ["fancy"]}
diff --git a/wrappers/rust/README.md b/wrappers/rust/README.md
new file mode 100644
index 0000000000..8c849b3704
--- /dev/null
+++ b/wrappers/rust/README.md
@@ -0,0 +1,70 @@
+# zxing-cpp
+
+zxing-cpp is a Rust wrapper for the C++ library [zxing-cpp](https://github.com/zxing-cpp/zxing-cpp).
+
+It is an open-source, multi-format linear/matrix barcode image processing library implemented in C++.
+It was originally ported from the Java ZXing Library but has been developed further and now includes
+many improvements in terms of runtime and detection performance.
+
+## Usage
+
+In your Cargo.toml:
+
+```toml
+[dependencies]
+# `bundled` causes cargo to compile and statically link an up to
+# date version of the c++ core library. This is the most convenient
+# and safe way to build the library.
+zxing-cpp = { version = "0.4.1", features = ["bundled", "image"] }
+```
+
+Simple example reading some barcodes from a jpg file:
+
+```rust
+use zxingcpp::BarcodeFormat;
+
+fn main() -> anyhow::Result<()> {
+	let image = image::open("some-image-file.jpg")?;
+
+	let read_barcodes = zxingcpp::read()
+		.formats(BarcodeFormat::QRCode | BarcodeFormat::LinearCodes)
+		.try_invert(false);
+
+	let barcodes = read_barcodes.from(&image)?;
+
+	for barcode in barcodes {
+		println!("{}: {}", barcode.format(), barcode.text());
+	}
+
+	Ok(())
+}
+```
+
+Simple example creating a barcode and writing it to a svg file:
+
+```rust
+fn main() -> anyhow::Result<()> {
+	let svg = zxingcpp::create(zxingcpp::BarcodeFormat::QRCode)
+		.from_str("https://github.com/zxing-cpp/zxing-cpp")?
+		.to_svg_with(&zxingcpp::write().scale(5))?;
+	std::fs::write("zxingcpp.svg", svg)?;
+	Ok(())
+}
+```
+
+Note: This should currently be considered a pre-release. The API may change slightly to be even more
+idiomatic rust depending on community feedback.
+
+## Optional Features
+
+zxing-cpp provides features that are behind [Cargo features](https://doc.rust-lang.org/cargo/reference/manifest.html#the-features-section).
+They are:
+
+* `bundled` uses a bundled version of the [zxing-cpp](https://github.com/zxing-cpp/zxing-cpp) c++ library.
+* [`image`](https://crates.io/crates/image) allows convenient/implicit conversion between `ImageView`/`Image` and`GreyImage`/`DynamicImage`.
+
+## Benchmarking
+
+To compare the performance of this Rust wrapper project with other available barcode scanner Rust libraries,
+I started the project [zxing-bench](https://github.com/axxel/zxing-bench). The README contains a few
+results to get an idea.
diff --git a/wrappers/rust/build.rs b/wrappers/rust/build.rs
new file mode 100644
index 0000000000..cf17c6c43a
--- /dev/null
+++ b/wrappers/rust/build.rs
@@ -0,0 +1,37 @@
+use std::env;
+
+fn main() -> miette::Result<()> {
+	if cfg!(feature = "bundled") {
+		// Builds the project in the directory located in `core`, installing it into $OUT_DIR
+		let mut dst = cmake::Config::new("core")
+			.define("BUILD_SHARED_LIBS", "OFF")
+			.define("ZXING_READERS", "ON")
+			.define("ZXING_WRITERS", "NEW")
+			.define("ZXING_EXPERIMENTAL_API", "ON")
+			.define("ZXING_C_API", "ON")
+			.define("ZXING_USE_BUNDLED_ZINT", "ON")
+			.define("CMAKE_CXX_STANDARD", "20")
+			.build();
+		dst.push("lib");
+		println!("cargo:rustc-link-search=native={}", dst.display());
+		println!("cargo:rustc-link-lib=static=ZXing");
+
+		if let Ok(target) = env::var("TARGET") {
+			if target.contains("apple") {
+				println!("cargo:rustc-link-lib=dylib=c++");
+			} else if target.contains("linux") {
+				println!("cargo:rustc-link-lib=dylib=stdc++");
+			}
+		}
+	} else if let Ok(lib_dir) = env::var("ZXING_CPP_LIB_DIR") {
+		println!("cargo:rustc-link-search=native={}", lib_dir);
+		println!("cargo:rustc-link-lib=dylib=ZXing");
+	} else {
+		// panic!("ZXing library not found. Use feature 'bundled' or set environment variabale ZXING_CPP_LIB_DIR.")
+	}
+
+	// manual bindings.rs generation:
+	// bindgen core/src/ZXingC.h -o src/bindings.rs --no-prepend-enum-name --merge-extern-blocks --use-core --no-doc-comments --no-layout-tests --with-derive-partialeq --allowlist-item "ZXing.*" -- -DZXING_EXPERIMENTAL_API
+
+	Ok(())
+}
diff --git a/wrappers/rust/core b/wrappers/rust/core
new file mode 120000
index 0000000000..58377d59e0
--- /dev/null
+++ b/wrappers/rust/core
@@ -0,0 +1 @@
+../../core/
\ No newline at end of file
diff --git a/wrappers/rust/examples/demo_reader.rs b/wrappers/rust/examples/demo_reader.rs
new file mode 100644
index 0000000000..e901353f45
--- /dev/null
+++ b/wrappers/rust/examples/demo_reader.rs
@@ -0,0 +1,52 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+use zxingcpp::*;
+
+fn main() -> anyhow::Result<()> {
+	let filename = std::env::args().nth(1).expect("no image file name provided");
+	let formats = std::env::args().nth(2);
+	let fast = std::env::args().nth(3).is_some();
+
+	let image = image::open(&filename)?;
+
+	#[cfg(not(feature = "image"))]
+	let lum_img = image.into_luma8();
+	#[cfg(not(feature = "image"))]
+	let iv = ImageView::from_slice(&lum_img, lum_img.width(), lum_img.height(), ImageFormat::Lum)?;
+
+	let formats = BarcodeFormats::from_str(formats.unwrap_or_default())?;
+	let read_barcodes = BarcodeReader::new()
+		.formats(formats)
+		.try_harder(!fast)
+		.try_invert(!fast)
+		.try_rotate(!fast)
+		.try_downscale(!fast)
+		.return_errors(true);
+
+	#[cfg(feature = "image")]
+	let barcodes = read_barcodes.from(&image)?;
+	#[cfg(not(feature = "image"))]
+	let barcodes = read_barcodes.from(iv)?;
+
+	if barcodes.is_empty() {
+		println!("No barcode found.");
+	} else {
+		for barcode in barcodes {
+			println!("Text:       {}", barcode.text());
+			println!("Bytes:      {:?}", barcode.bytes());
+			println!("Format:     {}", barcode.format());
+			println!("Content:    {}", barcode.content_type());
+			println!("Identifier: {}", barcode.symbology_identifier());
+			println!("EC Level:   {}", barcode.ec_level());
+			println!("Error:      {}", barcode.error());
+			println!("Rotation:   {}", barcode.orientation());
+			println!("Position:   {}", barcode.position());
+			println!();
+		}
+	}
+
+	Ok(())
+}
diff --git a/wrappers/rust/examples/demo_writer.rs b/wrappers/rust/examples/demo_writer.rs
new file mode 100644
index 0000000000..e714a537af
--- /dev/null
+++ b/wrappers/rust/examples/demo_writer.rs
@@ -0,0 +1,25 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+use image;
+use std::fs;
+use zxingcpp::*;
+
+fn main() -> anyhow::Result<()> {
+	let text = std::env::args().nth(1).expect("no input text provided");
+	let format = std::env::args().nth(2).expect("no format provided");
+	let filename = std::env::args().nth(3).expect("no output file name provided");
+
+	let create_barcode = create(BarcodeFormat::from_str(format)?);
+	let bc = create_barcode.from_str(text)?;
+
+	if filename.ends_with(".svg") {
+		fs::write(filename, bc.to_svg_with(&write().with_hrt(true))?).expect("Unable to write file");
+	} else {
+		image::GrayImage::from(&bc.to_image_with(&write().scale(4))?).save(filename)?;
+	}
+
+	Ok(())
+}
diff --git a/wrappers/rust/rustfmt.toml b/wrappers/rust/rustfmt.toml
new file mode 100644
index 0000000000..c0781a332f
--- /dev/null
+++ b/wrappers/rust/rustfmt.toml
@@ -0,0 +1,15 @@
+max_width = 135
+hard_tabs = true
+tab_spaces = 4
+newline_style = "Auto"
+use_small_heuristics = "Default"
+fn_call_width = 100
+attr_fn_like_width = 70
+struct_lit_width = 18
+struct_variant_width = 35
+array_width = 100
+chain_width = 100
+single_line_if_else_max_width = 70
+short_array_element_width_threshold = 10
+fn_params_layout = "Tall"
+edition = "2021"
diff --git a/wrappers/rust/src/bindings.rs b/wrappers/rust/src/bindings.rs
new file mode 100644
index 0000000000..009f0e69d2
--- /dev/null
+++ b/wrappers/rust/src/bindings.rs
@@ -0,0 +1,237 @@
+/* automatically generated by rust-bindgen 0.69.2 */
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ZXing_Barcode {
+	_unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ZXing_Barcodes {
+	_unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ZXing_ImageView {
+	_unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ZXing_Image {
+	_unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ZXing_ReaderOptions {
+	_unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ZXing_CreatorOptions {
+	_unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ZXing_WriterOptions {
+	_unused: [u8; 0],
+}
+pub const ZXing_ImageFormat_None: ZXing_ImageFormat = 0;
+pub const ZXing_ImageFormat_Lum: ZXing_ImageFormat = 16777216;
+pub const ZXing_ImageFormat_LumA: ZXing_ImageFormat = 33554432;
+pub const ZXing_ImageFormat_RGB: ZXing_ImageFormat = 50331906;
+pub const ZXing_ImageFormat_BGR: ZXing_ImageFormat = 50462976;
+pub const ZXing_ImageFormat_RGBA: ZXing_ImageFormat = 67109122;
+pub const ZXing_ImageFormat_ARGB: ZXing_ImageFormat = 67174915;
+pub const ZXing_ImageFormat_BGRA: ZXing_ImageFormat = 67240192;
+pub const ZXing_ImageFormat_ABGR: ZXing_ImageFormat = 67305985;
+pub type ZXing_ImageFormat = ::core::ffi::c_uint;
+pub const ZXing_BarcodeFormat_None: ZXing_BarcodeFormat = 0;
+pub const ZXing_BarcodeFormat_Aztec: ZXing_BarcodeFormat = 1;
+pub const ZXing_BarcodeFormat_Codabar: ZXing_BarcodeFormat = 2;
+pub const ZXing_BarcodeFormat_Code39: ZXing_BarcodeFormat = 4;
+pub const ZXing_BarcodeFormat_Code93: ZXing_BarcodeFormat = 8;
+pub const ZXing_BarcodeFormat_Code128: ZXing_BarcodeFormat = 16;
+pub const ZXing_BarcodeFormat_DataBar: ZXing_BarcodeFormat = 32;
+pub const ZXing_BarcodeFormat_DataBarExpanded: ZXing_BarcodeFormat = 64;
+pub const ZXing_BarcodeFormat_DataMatrix: ZXing_BarcodeFormat = 128;
+pub const ZXing_BarcodeFormat_EAN8: ZXing_BarcodeFormat = 256;
+pub const ZXing_BarcodeFormat_EAN13: ZXing_BarcodeFormat = 512;
+pub const ZXing_BarcodeFormat_ITF: ZXing_BarcodeFormat = 1024;
+pub const ZXing_BarcodeFormat_MaxiCode: ZXing_BarcodeFormat = 2048;
+pub const ZXing_BarcodeFormat_PDF417: ZXing_BarcodeFormat = 4096;
+pub const ZXing_BarcodeFormat_QRCode: ZXing_BarcodeFormat = 8192;
+pub const ZXing_BarcodeFormat_UPCA: ZXing_BarcodeFormat = 16384;
+pub const ZXing_BarcodeFormat_UPCE: ZXing_BarcodeFormat = 32768;
+pub const ZXing_BarcodeFormat_MicroQRCode: ZXing_BarcodeFormat = 65536;
+pub const ZXing_BarcodeFormat_RMQRCode: ZXing_BarcodeFormat = 131072;
+pub const ZXing_BarcodeFormat_DXFilmEdge: ZXing_BarcodeFormat = 262144;
+pub const ZXing_BarcodeFormat_DataBarLimited: ZXing_BarcodeFormat = 524288;
+pub const ZXing_BarcodeFormat_LinearCodes: ZXing_BarcodeFormat = 837502;
+pub const ZXing_BarcodeFormat_MatrixCodes: ZXing_BarcodeFormat = 211073;
+pub const ZXing_BarcodeFormat_Any: ZXing_BarcodeFormat = 1048575;
+pub const ZXing_BarcodeFormat_Invalid: ZXing_BarcodeFormat = 4294967295;
+pub type ZXing_BarcodeFormat = ::core::ffi::c_uint;
+pub use self::ZXing_BarcodeFormat as ZXing_BarcodeFormats;
+pub const ZXing_ContentType_Text: ZXing_ContentType = 0;
+pub const ZXing_ContentType_Binary: ZXing_ContentType = 1;
+pub const ZXing_ContentType_Mixed: ZXing_ContentType = 2;
+pub const ZXing_ContentType_GS1: ZXing_ContentType = 3;
+pub const ZXing_ContentType_ISO15434: ZXing_ContentType = 4;
+pub const ZXing_ContentType_UnknownECI: ZXing_ContentType = 5;
+pub type ZXing_ContentType = ::core::ffi::c_uint;
+pub const ZXing_ErrorType_None: ZXing_ErrorType = 0;
+pub const ZXing_ErrorType_Format: ZXing_ErrorType = 1;
+pub const ZXing_ErrorType_Checksum: ZXing_ErrorType = 2;
+pub const ZXing_ErrorType_Unsupported: ZXing_ErrorType = 3;
+pub type ZXing_ErrorType = ::core::ffi::c_uint;
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub struct ZXing_PointI {
+	pub x: ::core::ffi::c_int,
+	pub y: ::core::ffi::c_int,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub struct ZXing_Position {
+	pub topLeft: ZXing_PointI,
+	pub topRight: ZXing_PointI,
+	pub bottomRight: ZXing_PointI,
+	pub bottomLeft: ZXing_PointI,
+}
+pub const ZXing_Binarizer_LocalAverage: ZXing_Binarizer = 0;
+pub const ZXing_Binarizer_GlobalHistogram: ZXing_Binarizer = 1;
+pub const ZXing_Binarizer_FixedThreshold: ZXing_Binarizer = 2;
+pub const ZXing_Binarizer_BoolCast: ZXing_Binarizer = 3;
+pub type ZXing_Binarizer = ::core::ffi::c_uint;
+pub const ZXing_EanAddOnSymbol_Ignore: ZXing_EanAddOnSymbol = 0;
+pub const ZXing_EanAddOnSymbol_Read: ZXing_EanAddOnSymbol = 1;
+pub const ZXing_EanAddOnSymbol_Require: ZXing_EanAddOnSymbol = 2;
+pub type ZXing_EanAddOnSymbol = ::core::ffi::c_uint;
+pub const ZXing_TextMode_Plain: ZXing_TextMode = 0;
+pub const ZXing_TextMode_ECI: ZXing_TextMode = 1;
+pub const ZXing_TextMode_HRI: ZXing_TextMode = 2;
+pub const ZXing_TextMode_Hex: ZXing_TextMode = 3;
+pub const ZXing_TextMode_Escaped: ZXing_TextMode = 4;
+pub type ZXing_TextMode = ::core::ffi::c_uint;
+extern "C" {
+	pub fn ZXing_ImageView_new(
+		data: *const u8,
+		width: ::core::ffi::c_int,
+		height: ::core::ffi::c_int,
+		format: ZXing_ImageFormat,
+		rowStride: ::core::ffi::c_int,
+		pixStride: ::core::ffi::c_int,
+	) -> *mut ZXing_ImageView;
+	pub fn ZXing_ImageView_new_checked(
+		data: *const u8,
+		size: ::core::ffi::c_int,
+		width: ::core::ffi::c_int,
+		height: ::core::ffi::c_int,
+		format: ZXing_ImageFormat,
+		rowStride: ::core::ffi::c_int,
+		pixStride: ::core::ffi::c_int,
+	) -> *mut ZXing_ImageView;
+	pub fn ZXing_ImageView_delete(iv: *mut ZXing_ImageView);
+	pub fn ZXing_ImageView_crop(
+		iv: *mut ZXing_ImageView,
+		left: ::core::ffi::c_int,
+		top: ::core::ffi::c_int,
+		width: ::core::ffi::c_int,
+		height: ::core::ffi::c_int,
+	);
+	pub fn ZXing_ImageView_rotate(iv: *mut ZXing_ImageView, degree: ::core::ffi::c_int);
+	pub fn ZXing_Image_delete(img: *mut ZXing_Image);
+	pub fn ZXing_Image_data(img: *const ZXing_Image) -> *const u8;
+	pub fn ZXing_Image_width(img: *const ZXing_Image) -> ::core::ffi::c_int;
+	pub fn ZXing_Image_height(img: *const ZXing_Image) -> ::core::ffi::c_int;
+	pub fn ZXing_Image_format(img: *const ZXing_Image) -> ZXing_ImageFormat;
+	pub fn ZXing_BarcodeFormatsFromString(str_: *const ::core::ffi::c_char) -> ZXing_BarcodeFormats;
+	pub fn ZXing_BarcodeFormatFromString(str_: *const ::core::ffi::c_char) -> ZXing_BarcodeFormat;
+	pub fn ZXing_BarcodeFormatToString(format: ZXing_BarcodeFormat) -> *mut ::core::ffi::c_char;
+	pub fn ZXing_ContentTypeToString(type_: ZXing_ContentType) -> *mut ::core::ffi::c_char;
+	pub fn ZXing_PositionToString(position: ZXing_Position) -> *mut ::core::ffi::c_char;
+	pub fn ZXing_Barcode_isValid(barcode: *const ZXing_Barcode) -> bool;
+	pub fn ZXing_Barcode_errorType(barcode: *const ZXing_Barcode) -> ZXing_ErrorType;
+	pub fn ZXing_Barcode_errorMsg(barcode: *const ZXing_Barcode) -> *mut ::core::ffi::c_char;
+	pub fn ZXing_Barcode_format(barcode: *const ZXing_Barcode) -> ZXing_BarcodeFormat;
+	pub fn ZXing_Barcode_contentType(barcode: *const ZXing_Barcode) -> ZXing_ContentType;
+	pub fn ZXing_Barcode_bytes(barcode: *const ZXing_Barcode, len: *mut ::core::ffi::c_int) -> *mut u8;
+	pub fn ZXing_Barcode_bytesECI(barcode: *const ZXing_Barcode, len: *mut ::core::ffi::c_int) -> *mut u8;
+	pub fn ZXing_Barcode_text(barcode: *const ZXing_Barcode) -> *mut ::core::ffi::c_char;
+	pub fn ZXing_Barcode_ecLevel(barcode: *const ZXing_Barcode) -> *mut ::core::ffi::c_char;
+	pub fn ZXing_Barcode_symbologyIdentifier(barcode: *const ZXing_Barcode) -> *mut ::core::ffi::c_char;
+	pub fn ZXing_Barcode_position(barcode: *const ZXing_Barcode) -> ZXing_Position;
+	pub fn ZXing_Barcode_orientation(barcode: *const ZXing_Barcode) -> ::core::ffi::c_int;
+	pub fn ZXing_Barcode_hasECI(barcode: *const ZXing_Barcode) -> bool;
+	pub fn ZXing_Barcode_isInverted(barcode: *const ZXing_Barcode) -> bool;
+	pub fn ZXing_Barcode_isMirrored(barcode: *const ZXing_Barcode) -> bool;
+	pub fn ZXing_Barcode_lineCount(barcode: *const ZXing_Barcode) -> ::core::ffi::c_int;
+	pub fn ZXing_Barcode_delete(barcode: *mut ZXing_Barcode);
+	pub fn ZXing_Barcodes_delete(barcodes: *mut ZXing_Barcodes);
+	pub fn ZXing_Barcodes_size(barcodes: *const ZXing_Barcodes) -> ::core::ffi::c_int;
+	pub fn ZXing_Barcodes_at(barcodes: *const ZXing_Barcodes, i: ::core::ffi::c_int) -> *const ZXing_Barcode;
+	pub fn ZXing_Barcodes_move(barcodes: *mut ZXing_Barcodes, i: ::core::ffi::c_int) -> *mut ZXing_Barcode;
+	pub fn ZXing_ReaderOptions_new() -> *mut ZXing_ReaderOptions;
+	pub fn ZXing_ReaderOptions_delete(opts: *mut ZXing_ReaderOptions);
+	pub fn ZXing_ReaderOptions_setTryHarder(opts: *mut ZXing_ReaderOptions, tryHarder: bool);
+	pub fn ZXing_ReaderOptions_setTryRotate(opts: *mut ZXing_ReaderOptions, tryRotate: bool);
+	pub fn ZXing_ReaderOptions_setTryInvert(opts: *mut ZXing_ReaderOptions, tryInvert: bool);
+	pub fn ZXing_ReaderOptions_setTryDownscale(opts: *mut ZXing_ReaderOptions, tryDownscale: bool);
+	pub fn ZXing_ReaderOptions_setIsPure(opts: *mut ZXing_ReaderOptions, isPure: bool);
+	pub fn ZXing_ReaderOptions_setReturnErrors(opts: *mut ZXing_ReaderOptions, returnErrors: bool);
+	pub fn ZXing_ReaderOptions_setFormats(opts: *mut ZXing_ReaderOptions, formats: ZXing_BarcodeFormats);
+	pub fn ZXing_ReaderOptions_setBinarizer(opts: *mut ZXing_ReaderOptions, binarizer: ZXing_Binarizer);
+	pub fn ZXing_ReaderOptions_setEanAddOnSymbol(opts: *mut ZXing_ReaderOptions, eanAddOnSymbol: ZXing_EanAddOnSymbol);
+	pub fn ZXing_ReaderOptions_setTextMode(opts: *mut ZXing_ReaderOptions, textMode: ZXing_TextMode);
+	pub fn ZXing_ReaderOptions_setMinLineCount(opts: *mut ZXing_ReaderOptions, n: ::core::ffi::c_int);
+	pub fn ZXing_ReaderOptions_setMaxNumberOfSymbols(opts: *mut ZXing_ReaderOptions, n: ::core::ffi::c_int);
+	pub fn ZXing_ReaderOptions_getTryHarder(opts: *const ZXing_ReaderOptions) -> bool;
+	pub fn ZXing_ReaderOptions_getTryRotate(opts: *const ZXing_ReaderOptions) -> bool;
+	pub fn ZXing_ReaderOptions_getTryInvert(opts: *const ZXing_ReaderOptions) -> bool;
+	pub fn ZXing_ReaderOptions_getTryDownscale(opts: *const ZXing_ReaderOptions) -> bool;
+	pub fn ZXing_ReaderOptions_getIsPure(opts: *const ZXing_ReaderOptions) -> bool;
+	pub fn ZXing_ReaderOptions_getReturnErrors(opts: *const ZXing_ReaderOptions) -> bool;
+	pub fn ZXing_ReaderOptions_getFormats(opts: *const ZXing_ReaderOptions) -> ZXing_BarcodeFormats;
+	pub fn ZXing_ReaderOptions_getBinarizer(opts: *const ZXing_ReaderOptions) -> ZXing_Binarizer;
+	pub fn ZXing_ReaderOptions_getEanAddOnSymbol(opts: *const ZXing_ReaderOptions) -> ZXing_EanAddOnSymbol;
+	pub fn ZXing_ReaderOptions_getTextMode(opts: *const ZXing_ReaderOptions) -> ZXing_TextMode;
+	pub fn ZXing_ReaderOptions_getMinLineCount(opts: *const ZXing_ReaderOptions) -> ::core::ffi::c_int;
+	pub fn ZXing_ReaderOptions_getMaxNumberOfSymbols(opts: *const ZXing_ReaderOptions) -> ::core::ffi::c_int;
+	pub fn ZXing_ReadBarcodes(iv: *const ZXing_ImageView, opts: *const ZXing_ReaderOptions) -> *mut ZXing_Barcodes;
+	pub fn ZXing_CreatorOptions_new(format: ZXing_BarcodeFormat) -> *mut ZXing_CreatorOptions;
+	pub fn ZXing_CreatorOptions_delete(opts: *mut ZXing_CreatorOptions);
+	pub fn ZXing_CreatorOptions_setFormat(opts: *mut ZXing_CreatorOptions, format: ZXing_BarcodeFormat);
+	pub fn ZXing_CreatorOptions_getFormat(opts: *const ZXing_CreatorOptions) -> ZXing_BarcodeFormat;
+	pub fn ZXing_CreatorOptions_setReaderInit(opts: *mut ZXing_CreatorOptions, readerInit: bool);
+	pub fn ZXing_CreatorOptions_getReaderInit(opts: *const ZXing_CreatorOptions) -> bool;
+	pub fn ZXing_CreatorOptions_setForceSquareDataMatrix(opts: *mut ZXing_CreatorOptions, forceSquareDataMatrix: bool);
+	pub fn ZXing_CreatorOptions_getForceSquareDataMatrix(opts: *const ZXing_CreatorOptions) -> bool;
+	pub fn ZXing_CreatorOptions_setEcLevel(opts: *mut ZXing_CreatorOptions, ecLevel: *const ::core::ffi::c_char);
+	pub fn ZXing_CreatorOptions_getEcLevel(opts: *const ZXing_CreatorOptions) -> *mut ::core::ffi::c_char;
+	pub fn ZXing_WriterOptions_new() -> *mut ZXing_WriterOptions;
+	pub fn ZXing_WriterOptions_delete(opts: *mut ZXing_WriterOptions);
+	pub fn ZXing_WriterOptions_setScale(opts: *mut ZXing_WriterOptions, scale: ::core::ffi::c_int);
+	pub fn ZXing_WriterOptions_getScale(opts: *const ZXing_WriterOptions) -> ::core::ffi::c_int;
+	pub fn ZXing_WriterOptions_setSizeHint(opts: *mut ZXing_WriterOptions, sizeHint: ::core::ffi::c_int);
+	pub fn ZXing_WriterOptions_getSizeHint(opts: *const ZXing_WriterOptions) -> ::core::ffi::c_int;
+	pub fn ZXing_WriterOptions_setRotate(opts: *mut ZXing_WriterOptions, rotate: ::core::ffi::c_int);
+	pub fn ZXing_WriterOptions_getRotate(opts: *const ZXing_WriterOptions) -> ::core::ffi::c_int;
+	pub fn ZXing_WriterOptions_setWithHRT(opts: *mut ZXing_WriterOptions, withHRT: bool);
+	pub fn ZXing_WriterOptions_getWithHRT(opts: *const ZXing_WriterOptions) -> bool;
+	pub fn ZXing_WriterOptions_setWithQuietZones(opts: *mut ZXing_WriterOptions, withQuietZones: bool);
+	pub fn ZXing_WriterOptions_getWithQuietZones(opts: *const ZXing_WriterOptions) -> bool;
+	pub fn ZXing_CreateBarcodeFromText(
+		data: *const ::core::ffi::c_char,
+		size: ::core::ffi::c_int,
+		opts: *const ZXing_CreatorOptions,
+	) -> *mut ZXing_Barcode;
+	pub fn ZXing_CreateBarcodeFromBytes(
+		data: *const ::core::ffi::c_void,
+		size: ::core::ffi::c_int,
+		opts: *const ZXing_CreatorOptions,
+	) -> *mut ZXing_Barcode;
+	pub fn ZXing_WriteBarcodeToSVG(barcode: *const ZXing_Barcode, opts: *const ZXing_WriterOptions) -> *mut ::core::ffi::c_char;
+	pub fn ZXing_WriteBarcodeToImage(barcode: *const ZXing_Barcode, opts: *const ZXing_WriterOptions) -> *mut ZXing_Image;
+	pub fn ZXing_LastErrorMsg() -> *mut ::core::ffi::c_char;
+	pub fn ZXing_free(ptr: *mut ::core::ffi::c_void);
+}
diff --git a/wrappers/rust/src/lib.rs b/wrappers/rust/src/lib.rs
new file mode 100644
index 0000000000..26a234e640
--- /dev/null
+++ b/wrappers/rust/src/lib.rs
@@ -0,0 +1,579 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#![allow(unknown_lints)] // backward compatibility
+#![allow(unused_unsafe)]
+#![allow(clippy::useless_transmute)]
+#![allow(clippy::redundant_closure_call)]
+#![allow(clippy::missing_transmute_annotations)] // introduced in 1.79
+
+mod tests;
+
+#[allow(dead_code)]
+#[allow(non_camel_case_types)]
+#[allow(non_snake_case)]
+#[allow(non_upper_case_globals)]
+mod bindings {
+	include!("bindings.rs");
+}
+
+use bindings::*;
+
+use flagset::{flags, FlagSet};
+use paste::paste;
+use std::ffi::{c_char, c_int, c_uint, c_void, CStr, CString, NulError};
+use std::fmt::{Display, Formatter};
+use std::marker::PhantomData;
+use std::mem::transmute;
+use std::rc::Rc;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum Error {
+	#[error("{0}")]
+	InvalidInput(String),
+
+	#[error("NulError from CString::new")]
+	NulError(#[from] NulError),
+	//
+	// #[error("data store disconnected")]
+	// IOError(#[from] std::io::Error),
+	// #[error("the data for key `{0}` is not available")]
+	// Redaction(String),
+	// #[error("invalid header (expected {expected:?}, found {found:?})")]
+	// InvalidHeader {
+	//     expected: String,
+	//     found: String,
+	// },
+	// #[error("unknown data store error")]
+	// Unknown,
+}
+
+// see https://github.com/dtolnay/thiserror/issues/62
+impl From<std::convert::Infallible> for Error {
+	fn from(_: std::convert::Infallible) -> Self {
+		unreachable!()
+	}
+}
+
+fn c2r_str(str: *mut c_char) -> String {
+	let mut res = String::new();
+	if !str.is_null() {
+		unsafe { res = CStr::from_ptr(str).to_string_lossy().to_string() };
+		unsafe { ZXing_free(str as *mut c_void) };
+	}
+	res
+}
+
+fn c2r_vec(buf: *mut u8, len: c_int) -> Vec<u8> {
+	let mut res = Vec::<u8>::new();
+	if !buf.is_null() && len > 0 {
+		unsafe { res = std::slice::from_raw_parts(buf, len as usize).to_vec() };
+		unsafe { ZXing_free(buf as *mut c_void) };
+	}
+	res
+}
+
+fn last_error() -> Error {
+	match unsafe { ZXing_LastErrorMsg().as_mut() } {
+		None => panic!("Internal error: ZXing_LastErrorMsg() returned NULL"),
+		Some(error) => Error::InvalidInput(c2r_str(error)),
+	}
+}
+
+macro_rules! last_error_or {
+	($expr:expr) => {
+		match unsafe { ZXing_LastErrorMsg().as_mut() } {
+			None => Ok($expr),
+			Some(error) => Err(Error::InvalidInput(c2r_str(error))),
+		}
+	};
+}
+
+macro_rules! last_error_if_null_or {
+	($ptr:ident, $expr:expr) => {
+		match $ptr.is_null() {
+			true => Err(last_error()),
+			false => Ok($expr),
+		}
+	};
+}
+
+macro_rules! make_zxing_class {
+	($r_class:ident, $c_class:ident) => {
+		paste! {
+			pub struct $r_class(*mut $c_class);
+
+			impl Drop for $r_class {
+				fn drop(&mut self) {
+					unsafe { [<$c_class _delete>](self.0) }
+				}
+			}
+		}
+	};
+}
+
+macro_rules! make_zxing_class_with_default {
+	($r_class:ident, $c_class:ident) => {
+		make_zxing_class!($r_class, $c_class);
+		paste! {
+			impl $r_class {
+				pub fn new() -> Self {
+					unsafe { $r_class([<$c_class _new>]()) }
+				}
+			}
+
+			impl Default for $r_class {
+				fn default() -> Self {
+					Self::new()
+				}
+			}
+		}
+	};
+}
+
+macro_rules! getter {
+	($class:ident, $c_name:ident, $r_name:ident, $conv:expr, $type:ty) => {
+		pub fn $r_name(&self) -> $type {
+			paste! { unsafe { $conv([<ZXing_ $class _ $c_name>](self.0)) } }
+		}
+	};
+	($class:ident, $c_name:ident, $conv:expr, $type:ty) => {
+		paste! { getter! { $class, $c_name, [<$c_name:snake>], $conv, $type } }
+	};
+}
+
+macro_rules! property {
+	($class:ident, $c_name:ident, $r_name:ident, String) => {
+		pub fn $r_name(self, v: impl AsRef<str>) -> Self {
+			let cstr = CString::new(v.as_ref()).unwrap();
+			paste! { unsafe { [<ZXing_ $class _set $c_name>](self.0, cstr.as_ptr()) } };
+			self
+		}
+
+		paste! {
+			pub fn [<set_ $r_name>](&mut self, v : impl AsRef<str>) -> &mut Self {
+				let cstr = CString::new(v.as_ref()).unwrap();
+				unsafe { [<ZXing_ $class _set $c_name>](self.0, cstr.as_ptr()) };
+				self
+			}
+
+			pub fn [<get_ $r_name>](&self) -> String {
+				unsafe { c2r_str([<ZXing_ $class _get $c_name>](self.0)) }
+			}
+		}
+	};
+
+	($class:ident, $c_name:ident, $r_name:ident, $type:ty) => {
+		pub fn $r_name(self, v: impl Into<$type>) -> Self {
+			paste! { unsafe { [<ZXing_ $class _set $c_name>](self.0, transmute(v.into())) } };
+			self
+		}
+
+		paste! {
+			pub fn [<set_ $r_name>](&mut self, v : impl Into<$type>) -> &mut Self {
+				unsafe { [<ZXing_ $class _set $c_name>](self.0, transmute(v.into())) };
+				self
+			}
+
+			pub fn [<get_ $r_name>](&self) -> $type {
+				unsafe { transmute([<ZXing_ $class _get $c_name>](self.0)) }
+			}
+		}
+	};
+
+	($class:ident, $c_name:ident, $type:ty) => {
+		paste! { property! { $class, $c_name, [<$c_name:snake>], $type } }
+	};
+}
+
+macro_rules! make_zxing_enum {
+    ($name:ident { $($field:ident),* }) => {
+        #[repr(u32)]
+        #[derive(Debug, Copy, Clone, PartialEq)]
+        pub enum $name {
+            $($field = paste! { [<ZXing_ $name _ $field>] },)*
+        }
+    }
+}
+
+macro_rules! make_zxing_flags {
+    ($name:ident { $($field:ident),* }) => {
+        flags! {
+            #[repr(u32)]
+            pub enum $name: c_uint {
+                $($field = paste! { [<ZXing_ $name _ $field>] },)*
+            }
+        }
+    }
+}
+#[rustfmt::skip] // workaround for broken #[rustfmt::skip::macros(make_zxing_enum)]
+make_zxing_enum!(ImageFormat { Lum, LumA, RGB, BGR, RGBA, ARGB, BGRA, ABGR });
+#[rustfmt::skip]
+make_zxing_enum!(ContentType { Text, Binary, Mixed, GS1, ISO15434, UnknownECI });
+#[rustfmt::skip]
+make_zxing_enum!(Binarizer { LocalAverage, GlobalHistogram, FixedThreshold, BoolCast });
+#[rustfmt::skip]
+make_zxing_enum!(TextMode { Plain, ECI, HRI, Hex, Escaped });
+#[rustfmt::skip]
+make_zxing_enum!(EanAddOnSymbol { Ignore, Read, Require });
+
+#[rustfmt::skip]
+make_zxing_flags!(BarcodeFormat {
+	None, Aztec, Codabar, Code39, Code93, Code128, DataBar, DataBarExpanded, DataBarLimited, DataMatrix,
+	EAN8, EAN13, ITF, MaxiCode, PDF417, QRCode, UPCA, UPCE, MicroQRCode, RMQRCode, DXFilmEdge,
+	LinearCodes, MatrixCodes, Any
+});
+
+impl Display for BarcodeFormat {
+	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+		write!(f, "{}", unsafe { c2r_str(ZXing_BarcodeFormatToString(BarcodeFormats::from(*self).bits())) })
+	}
+}
+
+impl Display for ContentType {
+	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+		write!(f, "{}", unsafe { c2r_str(ZXing_ContentTypeToString(transmute(*self))) })
+	}
+}
+
+pub type BarcodeFormats = FlagSet<BarcodeFormat>;
+
+pub trait FromStr: Sized {
+	fn from_str(str: impl AsRef<str>) -> Result<Self, Error>;
+}
+
+impl FromStr for BarcodeFormat {
+	fn from_str(str: impl AsRef<str>) -> Result<BarcodeFormat, Error> {
+		let cstr = CString::new(str.as_ref())?;
+		let res = unsafe { BarcodeFormats::new_unchecked(ZXing_BarcodeFormatFromString(cstr.as_ptr())) };
+		match res.bits() {
+			u32::MAX => last_error_or!(BarcodeFormat::None),
+			_ => Ok(res.into_iter().last().unwrap()),
+		}
+	}
+}
+
+impl FromStr for BarcodeFormats {
+	fn from_str(str: impl AsRef<str>) -> Result<BarcodeFormats, Error> {
+		let cstr = CString::new(str.as_ref())?;
+		let res = unsafe { BarcodeFormats::new_unchecked(ZXing_BarcodeFormatsFromString(cstr.as_ptr())) };
+		match res.bits() {
+			u32::MAX => last_error_or!(BarcodeFormats::default()),
+			0 => Ok(BarcodeFormats::full()),
+			_ => Ok(res),
+		}
+	}
+}
+
+#[derive(Debug, PartialEq)]
+struct ImageViewOwner<'a>(*mut ZXing_ImageView, PhantomData<&'a u8>);
+
+impl Drop for ImageViewOwner<'_> {
+	fn drop(&mut self) {
+		unsafe { ZXing_ImageView_delete(self.0) }
+	}
+}
+#[derive(Debug, Clone, PartialEq)]
+pub struct ImageView<'a>(Rc<ImageViewOwner<'a>>);
+
+impl<'a> From<&'a ImageView<'a>> for ImageView<'a> {
+	fn from(img: &'a ImageView) -> Self {
+		img.clone()
+	}
+}
+
+impl<'a> ImageView<'a> {
+	fn try_into_int<T: TryInto<c_int>>(val: T) -> Result<c_int, Error> {
+		val.try_into().map_err(|_| Error::InvalidInput("Could not convert Integer into c_int.".to_string()))
+	}
+
+	/// Constructs an ImageView from a raw pointer and the width/height (in pixels)
+	/// and row_stride/pix_stride (in bytes).
+	///
+	/// # Safety
+	///
+	/// The memory gets accessed inside the c++ library at random places between
+	/// `ptr` and `ptr + height * row_stride` or `ptr + width * pix_stride`.
+	/// Note that both the stride values could be negative, e.g. if the image
+	/// view is rotated.
+	pub unsafe fn from_ptr<T: TryInto<c_int>, U: TryInto<c_int>>(
+		ptr: *const u8,
+		width: T,
+		height: T,
+		format: ImageFormat,
+		row_stride: U,
+		pix_stride: U,
+	) -> Result<Self, Error> {
+		let iv = ZXing_ImageView_new(
+			ptr,
+			Self::try_into_int(width)?,
+			Self::try_into_int(height)?,
+			format as ZXing_ImageFormat,
+			Self::try_into_int(row_stride)?,
+			Self::try_into_int(pix_stride)?,
+		);
+		last_error_if_null_or!(iv, ImageView(Rc::new(ImageViewOwner(iv, PhantomData))))
+	}
+
+	pub fn from_slice<T: TryInto<c_int>>(data: &'a [u8], width: T, height: T, format: ImageFormat) -> Result<Self, Error> {
+		unsafe {
+			let iv = ZXing_ImageView_new_checked(
+				data.as_ptr(),
+				data.len() as c_int,
+				Self::try_into_int(width)?,
+				Self::try_into_int(height)?,
+				format as ZXing_ImageFormat,
+				0,
+				0,
+			);
+			last_error_if_null_or!(iv, ImageView(Rc::new(ImageViewOwner(iv, PhantomData))))
+		}
+	}
+
+	pub fn cropped(self, left: i32, top: i32, width: i32, height: i32) -> Self {
+		unsafe { ZXing_ImageView_crop((self.0).0, left, top, width, height) }
+		self
+	}
+
+	pub fn rotated(self, degree: i32) -> Self {
+		unsafe { ZXing_ImageView_rotate((self.0).0, degree) }
+		self
+	}
+}
+
+#[cfg(feature = "image")]
+use image;
+
+#[cfg(feature = "image")]
+impl<'a> From<&'a image::GrayImage> for ImageView<'a> {
+	fn from(img: &'a image::GrayImage) -> Self {
+		ImageView::from_slice(img.as_ref(), img.width(), img.height(), ImageFormat::Lum).unwrap()
+	}
+}
+
+#[cfg(feature = "image")]
+impl<'a> TryFrom<&'a image::DynamicImage> for ImageView<'a> {
+	type Error = Error;
+
+	fn try_from(img: &'a image::DynamicImage) -> Result<Self, Error> {
+		let format = match img {
+			image::DynamicImage::ImageLuma8(_) => Some(ImageFormat::Lum),
+			image::DynamicImage::ImageLumaA8(_) => Some(ImageFormat::LumA),
+			image::DynamicImage::ImageRgb8(_) => Some(ImageFormat::RGB),
+			image::DynamicImage::ImageRgba8(_) => Some(ImageFormat::RGBA),
+			_ => None,
+		};
+		match format {
+			Some(format) => Ok(ImageView::from_slice(img.as_bytes(), img.width(), img.height(), format)?),
+			None => Err(Error::InvalidInput("Invalid image format (must be either luma8|lumaA8|rgb8|rgba8)".to_string())),
+		}
+	}
+}
+
+make_zxing_class!(Image, ZXing_Image);
+
+impl Image {
+	getter!(Image, width, transmute, i32);
+	getter!(Image, height, transmute, i32);
+	getter!(Image, format, transmute, ImageFormat);
+
+	pub fn data(&self) -> Vec<u8> {
+		let ptr = unsafe { ZXing_Image_data(self.0) };
+		if ptr.is_null() {
+			Vec::<u8>::new()
+		} else {
+			unsafe { std::slice::from_raw_parts(ptr, (self.width() * self.height()) as usize).to_vec() }
+		}
+	}
+}
+
+#[cfg(feature = "image")]
+impl From<&Image> for image::GrayImage {
+	fn from(img: &Image) -> image::GrayImage {
+		image::GrayImage::from_vec(img.width() as u32, img.height() as u32, img.data()).unwrap()
+	}
+}
+
+#[derive(Error, Debug, PartialEq)]
+pub enum BarcodeError {
+	#[error("")]
+	None(),
+
+	#[error("{0}")]
+	Checksum(String),
+
+	#[error("{0}")]
+	Format(String),
+
+	#[error("{0}")]
+	Unsupported(String),
+}
+
+pub type PointI = ZXing_PointI;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Position {
+	pub top_left: PointI,
+	pub top_right: PointI,
+	pub bottom_right: PointI,
+	pub bottom_left: PointI,
+}
+
+impl Display for PointI {
+	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+		write!(f, "{}x{}", self.x, self.y)
+	}
+}
+
+impl Display for Position {
+	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+		write!(f, "{}", unsafe {
+			c2r_str(ZXing_PositionToString(*(self as *const Position as *const ZXing_Position)))
+		})
+	}
+}
+
+make_zxing_class!(Barcode, ZXing_Barcode);
+
+impl Barcode {
+	getter!(Barcode, isValid, transmute, bool);
+	getter!(Barcode, format, (|f| BarcodeFormats::new(f).unwrap().into_iter().last().unwrap()), BarcodeFormat);
+	getter!(Barcode, contentType, transmute, ContentType);
+	getter!(Barcode, text, c2r_str, String);
+	getter!(Barcode, ecLevel, c2r_str, String);
+	getter!(Barcode, symbologyIdentifier, c2r_str, String);
+	getter!(Barcode, position, transmute, Position);
+	getter!(Barcode, orientation, transmute, i32);
+	getter!(Barcode, hasECI, has_eci, transmute, bool);
+	getter!(Barcode, isInverted, transmute, bool);
+	getter!(Barcode, isMirrored, transmute, bool);
+	getter!(Barcode, lineCount, transmute, i32);
+
+	pub fn bytes(&self) -> Vec<u8> {
+		let mut len: c_int = 0;
+		unsafe { c2r_vec(ZXing_Barcode_bytes(self.0, &mut len), len) }
+	}
+	pub fn bytes_eci(&self) -> Vec<u8> {
+		let mut len: c_int = 0;
+		unsafe { c2r_vec(ZXing_Barcode_bytesECI(self.0, &mut len), len) }
+	}
+
+	pub fn error(&self) -> BarcodeError {
+		let error_type = unsafe { ZXing_Barcode_errorType(self.0) };
+		let error_msg = unsafe { c2r_str(ZXing_Barcode_errorMsg(self.0)) };
+		#[allow(non_upper_case_globals)]
+		match error_type {
+			ZXing_ErrorType_None => BarcodeError::None(),
+			ZXing_ErrorType_Format => BarcodeError::Format(error_msg),
+			ZXing_ErrorType_Checksum => BarcodeError::Checksum(error_msg),
+			ZXing_ErrorType_Unsupported => BarcodeError::Unsupported(error_msg),
+			_ => panic!("Internal error: invalid ZXing_ErrorType"),
+		}
+	}
+
+	pub fn to_svg_with(&self, opts: &BarcodeWriter) -> Result<String, Error> {
+		let str = unsafe { ZXing_WriteBarcodeToSVG(self.0, opts.0) };
+		last_error_if_null_or!(str, c2r_str(str))
+	}
+
+	pub fn to_svg(&self) -> Result<String, Error> {
+		self.to_svg_with(&BarcodeWriter::default())
+	}
+
+	pub fn to_image_with(&self, opts: &BarcodeWriter) -> Result<Image, Error> {
+		let img = unsafe { ZXing_WriteBarcodeToImage(self.0, opts.0) };
+		last_error_if_null_or!(img, Image(img))
+	}
+
+	pub fn to_image(&self) -> Result<Image, Error> {
+		self.to_image_with(&BarcodeWriter::default())
+	}
+}
+
+make_zxing_class_with_default!(BarcodeReader, ZXing_ReaderOptions);
+
+impl BarcodeReader {
+	property!(ReaderOptions, TryHarder, bool);
+	property!(ReaderOptions, TryRotate, bool);
+	property!(ReaderOptions, TryInvert, bool);
+	property!(ReaderOptions, TryDownscale, bool);
+	property!(ReaderOptions, IsPure, bool);
+	property!(ReaderOptions, ReturnErrors, bool);
+	property!(ReaderOptions, Formats, BarcodeFormats);
+	property!(ReaderOptions, TextMode, TextMode);
+	property!(ReaderOptions, Binarizer, Binarizer);
+	property!(ReaderOptions, EanAddOnSymbol, EanAddOnSymbol);
+	property!(ReaderOptions, MaxNumberOfSymbols, i32);
+	property!(ReaderOptions, MinLineCount, i32);
+
+	pub fn from<'a, IV>(&self, image: IV) -> Result<Vec<Barcode>, Error>
+	where
+		IV: TryInto<ImageView<'a>>,
+		IV::Error: Into<Error>,
+	{
+		let iv_: ImageView = image.try_into().map_err(Into::into)?;
+		unsafe {
+			let results = ZXing_ReadBarcodes((iv_.0).0, self.0);
+			if !results.is_null() {
+				let size = ZXing_Barcodes_size(results);
+				let mut vec = Vec::<Barcode>::with_capacity(size as usize);
+				for i in 0..size {
+					vec.push(Barcode(ZXing_Barcodes_move(results, i)));
+				}
+				ZXing_Barcodes_delete(results);
+				Ok(vec)
+			} else {
+				Err(last_error())
+			}
+		}
+	}
+}
+
+make_zxing_class!(BarcodeCreator, ZXing_CreatorOptions);
+
+impl BarcodeCreator {
+	pub fn new(format: BarcodeFormat) -> Self {
+		unsafe { BarcodeCreator(ZXing_CreatorOptions_new(BarcodeFormats::from(format).bits())) }
+	}
+
+	property!(CreatorOptions, ReaderInit, bool);
+	property!(CreatorOptions, ForceSquareDataMatrix, bool);
+	property!(CreatorOptions, EcLevel, String);
+
+	pub fn from_str(&self, str: impl AsRef<str>) -> Result<Barcode, Error> {
+		let cstr = CString::new(str.as_ref())?;
+		let bc = unsafe { ZXing_CreateBarcodeFromText(cstr.as_ptr(), 0, self.0) };
+		last_error_if_null_or!(bc, Barcode(bc))
+	}
+
+	pub fn from_slice(&self, data: impl AsRef<[u8]>) -> Result<Barcode, Error> {
+		let data = data.as_ref();
+		let bc = unsafe { ZXing_CreateBarcodeFromBytes(data.as_ptr() as *const c_void, data.len() as i32, self.0) };
+		last_error_if_null_or!(bc, Barcode(bc))
+	}
+}
+
+make_zxing_class_with_default!(BarcodeWriter, ZXing_WriterOptions);
+
+impl BarcodeWriter {
+	property!(WriterOptions, Scale, i32);
+	property!(WriterOptions, SizeHint, i32);
+	property!(WriterOptions, Rotate, i32);
+	property!(WriterOptions, WithHRT, with_hrt, bool);
+	property!(WriterOptions, WithQuietZones, bool);
+}
+
+pub fn read() -> BarcodeReader {
+	BarcodeReader::default()
+}
+
+pub fn create(format: BarcodeFormat) -> BarcodeCreator {
+	BarcodeCreator::new(format)
+}
+
+pub fn write() -> BarcodeWriter {
+	BarcodeWriter::default()
+}
diff --git a/wrappers/rust/src/tests.rs b/wrappers/rust/src/tests.rs
new file mode 100644
index 0000000000..ec7c695f9a
--- /dev/null
+++ b/wrappers/rust/src/tests.rs
@@ -0,0 +1,101 @@
+/*
+* Copyright 2024 Axel Waggershauser
+*/
+// SPDX-License-Identifier: Apache-2.0
+
+#[cfg(test)]
+mod tests {
+	use crate::*;
+
+	#[test]
+	fn barcode_formats_from_str_valid() {
+		let formats = BarcodeFormats::from_str("qrcode,linearcodes").unwrap();
+		assert_eq!(formats, BarcodeFormat::QRCode | BarcodeFormat::LinearCodes);
+	}
+
+	#[test]
+	fn barcode_reader_new() {
+		let mut o1 = BarcodeReader::new();
+		assert_eq!(o1.get_formats(), BarcodeFormat::None);
+		assert_eq!(o1.get_try_harder(), true);
+		o1.set_formats(BarcodeFormat::EAN8);
+		assert_eq!(o1.get_formats(), BarcodeFormat::EAN8);
+		o1.set_try_harder(false);
+		assert_eq!(o1.get_try_harder(), false);
+
+		o1 = BarcodeReader::new().is_pure(true).text_mode(TextMode::Hex);
+		assert_eq!(o1.get_formats(), BarcodeFormat::None);
+		assert_eq!(o1.get_try_harder(), true);
+		assert_eq!(o1.get_is_pure(), true);
+		assert_eq!(o1.get_text_mode(), TextMode::Hex);
+	}
+
+	#[test]
+	fn barcode_creator_new() {
+		let mut o1 = BarcodeCreator::new(BarcodeFormat::QRCode);
+		assert_eq!(o1.get_reader_init(), false);
+		o1.set_reader_init(true);
+		assert_eq!(o1.get_reader_init(), true);
+	}
+
+	#[test]
+	#[should_panic]
+	fn barcode_formats_from_str_invalid() {
+		let _ = BarcodeFormats::from_str("qrcoder").unwrap();
+	}
+
+	#[test]
+	fn create_from_str() {
+		let str = "123456";
+		let res = create(BarcodeFormat::QRCode).ec_level("Q").from_str(str).unwrap();
+
+		assert_eq!(res.is_valid(), true);
+		assert_eq!(res.format(), BarcodeFormat::QRCode);
+		assert_eq!(res.text(), str);
+		assert_eq!(res.bytes(), str.as_bytes());
+		assert_eq!(res.has_eci(), false);
+		assert_eq!(res.content_type(), ContentType::Text);
+		assert!(matches!(res.error(), BarcodeError::None()));
+		assert_eq!(res.error().to_string(), "");
+	}
+
+	#[test]
+	fn create_from_slice() {
+		let data = [1, 2, 3, 4, 5];
+		let res = create(BarcodeFormat::QRCode).reader_init(true).from_slice(&data).unwrap();
+
+		assert_eq!(res.is_valid(), true);
+		assert_eq!(res.format(), BarcodeFormat::QRCode);
+		assert_eq!(res.bytes(), data);
+		assert_eq!(res.has_eci(), true);
+		// assert_eq!(res.reader_init(), true); // TODO
+		assert_eq!(res.content_type(), ContentType::Binary);
+		assert!(matches!(res.error(), BarcodeError::None()));
+		assert_eq!(res.error().to_string(), "");
+	}
+
+	#[test]
+	fn read_pure() {
+		let mut data = Vec::<u8>::new();
+		for v in "0000101000101101011110111101011011101010100111011100101000100101110010100000".chars() {
+			data.push(if v == '0' { 255 } else { 0 });
+		}
+		let iv = ImageView::from_slice(&data, data.len(), 1, ImageFormat::Lum).unwrap();
+		let res = read().binarizer(Binarizer::BoolCast).from(&iv).unwrap();
+
+		let expected = "96385074";
+
+		assert_eq!(res.len(), 1);
+		assert_eq!(res[0].is_valid(), true);
+		assert_eq!(res[0].format(), BarcodeFormat::EAN8);
+		assert_eq!(res[0].text(), expected);
+		assert_eq!(res[0].bytes(), expected.as_bytes());
+		assert_eq!(res[0].has_eci(), false);
+		assert_eq!(res[0].content_type(), ContentType::Text);
+		assert_eq!(res[0].orientation(), 0);
+		assert_eq!(res[0].position().top_left, PointI { x: 4, y: 0 });
+		assert_eq!(res[0].line_count(), 1);
+		assert!(matches!(res[0].error(), BarcodeError::None()));
+		assert_eq!(res[0].error().to_string(), "");
+	}
+}
diff --git a/wrappers/wasm/BarcodeReader.cpp b/wrappers/wasm/BarcodeReader.cpp
index a023368850..ba28908608 100644
--- a/wrappers/wasm/BarcodeReader.cpp
+++ b/wrappers/wasm/BarcodeReader.cpp
@@ -39,22 +39,22 @@ std::vector<ReadResult> readBarcodes(ImageView iv, bool tryHarder, const std::st
 		opts.setMaxNumberOfSymbols(maxSymbols);
 //		opts.setReturnErrors(maxSymbols > 1);
 
-		auto results = ReadBarcodes(iv, opts);
+		auto barcodes = ReadBarcodes(iv, opts);
 
 		std::vector<ReadResult> readResults{};
-		readResults.reserve(results.size());
+		readResults.reserve(barcodes.size());
 
 		thread_local const emscripten::val Uint8Array = emscripten::val::global("Uint8Array");
 
-		for (auto&& result : results) {
-			const ByteArray& bytes = result.bytes();
+		for (auto&& barcode : barcodes) {
+			const ByteArray& bytes = barcode.bytes();
 			readResults.push_back({
-				ToString(result.format()),
-				result.text(),
+				ToString(barcode.format()),
+				barcode.text(),
 				Uint8Array.new_(emscripten::typed_memory_view(bytes.size(), bytes.data())),
-				ToString(result.error()),
-				result.position(),
-				result.symbologyIdentifier()
+				ToString(barcode.error()),
+				barcode.position(),
+				barcode.symbologyIdentifier()
 			});
 		}
 
@@ -86,7 +86,7 @@ ReadResult readBarcodeFromImage(int bufferPtr, int bufferLength, bool tryHarder,
 
 std::vector<ReadResult> readBarcodesFromPixmap(int bufferPtr, int imgWidth, int imgHeight, bool tryHarder, std::string format, int maxSymbols)
 {
-	return readBarcodes({reinterpret_cast<uint8_t*>(bufferPtr), imgWidth, imgHeight, ImageFormat::RGBX}, tryHarder, format, maxSymbols);
+	return readBarcodes({reinterpret_cast<uint8_t*>(bufferPtr), imgWidth, imgHeight, ImageFormat::RGBA}, tryHarder, format, maxSymbols);
 }
 
 ReadResult readBarcodeFromPixmap(int bufferPtr, int imgWidth, int imgHeight, bool tryHarder, std::string format)
diff --git a/wrappers/wasm/CMakeLists.txt b/wrappers/wasm/CMakeLists.txt
index 0bc692da05..205f28fcae 100644
--- a/wrappers/wasm/CMakeLists.txt
+++ b/wrappers/wasm/CMakeLists.txt
@@ -7,10 +7,20 @@ zxing_add_package_stb()
 
 set (CMAKE_CXX_STANDARD 20)
 
-option (BUILD_WRITERS "Build with writer support (encoders)" ON)
-option (BUILD_READERS "Build with reader support (decoders)" ON)
+option (ZXING_WRITERS "Build with writer support (encoders)" ON)
+option (ZXING_READERS "Build with reader support (decoders)" ON)
+set    (ZXING_EMSCRIPTEN_ENVIRONMENT "web" CACHE STRING "Optimize build for given emscripten runtime environment (web/node/shell/worker)")
 
-set(BUILD_EMSCRIPTEN_ENVIRONMENT "web" CACHE STRING "Optimize build for given emscripten runtime environment (web/node/shell/worker)")
+# provide backward compatibility for deprecated BUILD_... options
+if (DEFINED BUILD_READERS)
+    set (ZXING_READERS ${BUILD_READERS})
+endif()
+if (DEFINED BUILD_WRITERS)
+    set (ZXING_WRITERS ${BUILD_WRITERS})
+endif()
+if (DEFINED BUILD_EMSCRIPTEN_ENVIRONMENT)
+    set (ZXING_EMSCRIPTEN_ENVIRONMENT ${BUILD_EMSCRIPTEN_ENVIRONMENT})
+endif()
 
 if (NOT CMAKE_BUILD_TYPE)
     set (CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build." FORCE)
@@ -20,21 +30,21 @@ add_definitions ("-s DISABLE_EXCEPTION_CATCHING=0")
 
 add_subdirectory (${CMAKE_CURRENT_SOURCE_DIR}/../../core ${CMAKE_BINARY_DIR}/ZXing)
 
-set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --bind -s ENVIRONMENT=${BUILD_EMSCRIPTEN_ENVIRONMENT} -s DISABLE_EXCEPTION_CATCHING=0 -s FILESYSTEM=0 -s MODULARIZE=1 -s EXPORT_NAME=ZXing -s EXPORTED_FUNCTIONS=\"['_malloc', '_free']\" -s ALLOW_MEMORY_GROWTH=1")
+set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --bind -s ENVIRONMENT=${ZXING_EMSCRIPTEN_ENVIRONMENT} -s DISABLE_EXCEPTION_CATCHING=0 -s FILESYSTEM=0 -s MODULARIZE=1 -s EXPORT_NAME=ZXing -s EXPORTED_FUNCTIONS=\"['_malloc', '_free']\" -s ALLOW_MEMORY_GROWTH=1")
 
-if (BUILD_READERS AND BUILD_WRITERS)
+if (ZXING_READERS AND ZXING_WRITERS)
     add_executable (zxing BarcodeReader.cpp BarcodeWriter.cpp)
     target_link_libraries (zxing ZXing::ZXing stb::stb)
 endif()
 
-if (BUILD_READERS)
+if (ZXING_READERS)
     configure_file(demo_cam_reader.html demo_cam_reader.html COPYONLY)
     configure_file(demo_reader.html demo_reader.html COPYONLY)
     add_executable (zxing_reader BarcodeReader.cpp)
     target_link_libraries (zxing_reader ZXing::ZXing stb::stb)
 endif()
 
-if (BUILD_WRITERS)
+if (ZXING_WRITERS)
     configure_file(demo_writer.html demo_writer.html COPYONLY)
     add_executable (zxing_writer BarcodeWriter.cpp )
     target_link_libraries (zxing_writer ZXing::ZXing stb::stb)
diff --git a/wrappers/wasm/demo_cam_reader.html b/wrappers/wasm/demo_cam_reader.html
index 1040a142df..1b693c9c4d 100644
--- a/wrappers/wasm/demo_cam_reader.html
+++ b/wrappers/wasm/demo_cam_reader.html
@@ -16,8 +16,8 @@ <h2>zxing-cpp/wasm live demo</h2>
 
 	Camera:
 	<select id="cameraSelector">
-		<option value="front">Front Camera</option>
-		<option value="back">Back Camera</option>
+		<option value="user">Front Camera</option>
+		<option value="environment">Back Camera</option>
 	</select>
 	&nbsp;&nbsp;
 
@@ -32,6 +32,8 @@ <h2>zxing-cpp/wasm live demo</h2>
 		<option value="DataMatrix">DataMatrix</option>
 		<option value="DataBar">DataBar</option>
 		<option value="DataBarExpanded">DataBarExpanded</option>
+		<option value="DataBarLimited">DataBarLimited</option>
+		<option value="DXFilmEdge">DXFilmEdge</option>
 		<option value="EAN8">EAN-8</option>
 		<option value="EAN13">EAN-13</option>
 		<option value="ITF">ITF</option>
@@ -130,6 +132,9 @@ <h2>zxing-cpp/wasm live demo</h2>
 		};
 
 		const updateVideoStream = function (deviceId) {
+			// To ensure the camera switch, it is advisable to free up the media resources
+			if (video.srcObject) video.srcObject.getTracks().forEach(track => track.stop());
+
 			navigator.mediaDevices
 				.getUserMedia({ video: { facingMode: deviceId }, audio: false })
 				.then(function (stream) {
diff --git a/wrappers/wasm/demo_reader.html b/wrappers/wasm/demo_reader.html
index fadc566a3c..f51bc3bed8 100644
--- a/wrappers/wasm/demo_reader.html
+++ b/wrappers/wasm/demo_reader.html
@@ -116,6 +116,8 @@ <h2>zxing-cpp/wasm reader demo</h2>
 			<option value="DataMatrix">DataMatrix</option>
 			<option value="DataBar">DataBar</option>
 			<option value="DataBarExpanded">DataBarExpanded</option>
+			<option value="DataBarLimited">DataBarLimited</option>
+			<option value="DXFilmEdge">DXFilmEdge</option>
 			<option value="EAN8">EAN-8</option>
 			<option value="EAN13">EAN-13</option>
 			<option value="ITF">ITF</option>
diff --git a/wrappers/winrt/BarcodeReader.cpp b/wrappers/winrt/BarcodeReader.cpp
index b3186024c1..6f074a982c 100644
--- a/wrappers/winrt/BarcodeReader.cpp
+++ b/wrappers/winrt/BarcodeReader.cpp
@@ -98,6 +98,10 @@ BarcodeFormat BarcodeReader::ConvertRuntimeToNative(BarcodeType type)
 		return BarcodeFormat::DataBar;
 	case BarcodeType::RSS_EXPANDED:
 		return BarcodeFormat::DataBarExpanded;
+	case BarcodeType::DATA_BAR_LIMITED:
+		return BarcodeFormat::DataBarLimited;
+	case BarcodeType::DX_FILM_EDGE:
+		return BarcodeFormat::DXFilmEdge;
 	case BarcodeType::UPC_A:
 		return BarcodeFormat::UPCA;
 	case BarcodeType::UPC_E:
@@ -143,6 +147,10 @@ BarcodeType BarcodeReader::ConvertNativeToRuntime(BarcodeFormat format)
 		return BarcodeType::RSS_14;
 	case BarcodeFormat::DataBarExpanded:
 		return BarcodeType::RSS_EXPANDED;
+	case BarcodeFormat::DataBarLimited:
+		return BarcodeType::DATA_BAR_LIMITED;
+	case BarcodeFormat::DXFilmEdge:
+		return BarcodeType::DX_FILM_EDGE;
 	case BarcodeFormat::UPCA:
 		return BarcodeType::UPC_A;
 	case BarcodeFormat::UPCE:
@@ -180,8 +188,8 @@ BarcodeReader::Read(SoftwareBitmap^ bitmap, int cropWidth, int cropHeight)
 			switch (bitmap->BitmapPixelFormat)
 			{
 			case BitmapPixelFormat::Gray8: fmt = ImageFormat::Lum; break;
-			case BitmapPixelFormat::Bgra8: fmt = ImageFormat::BGRX; break;
-			case BitmapPixelFormat::Rgba8: fmt = ImageFormat::RGBX; break;
+			case BitmapPixelFormat::Bgra8: fmt = ImageFormat::BGRA; break;
+			case BitmapPixelFormat::Rgba8: fmt = ImageFormat::RGBA; break;
 			default:
 				throw std::runtime_error("Unsupported BitmapPixelFormat");
 			}
@@ -189,9 +197,9 @@ BarcodeReader::Read(SoftwareBitmap^ bitmap, int cropWidth, int cropHeight)
 			auto img = ImageView(inBytes, bitmap->PixelWidth, bitmap->PixelHeight, fmt, inBuffer->GetPlaneDescription(0).Stride)
 						   .cropped(cropLeft, cropTop, cropWidth, cropHeight);
 
-			auto result = ReadBarcode(img, *m_opts);
-			if (result.isValid()) {
-				return ref new ReadResult(ToPlatformString(ZXing::ToString(result.format())), ToPlatformString(result.text()), ConvertNativeToRuntime(result.format()));
+			auto barcode = ReadBarcode(img, *m_opts);
+			if (barcode.isValid()) {
+				return ref new ReadResult(ToPlatformString(ZXing::ToString(barcode.format())), ToPlatformString(barcode.text()), ConvertNativeToRuntime(barcode.format()));
 			}
 		} else {
 			throw std::runtime_error("Failed to read bitmap's data");
diff --git a/wrappers/winrt/BarcodeReader.h b/wrappers/winrt/BarcodeReader.h
index 16e8352130..c8d1a48c74 100644
--- a/wrappers/winrt/BarcodeReader.h
+++ b/wrappers/winrt/BarcodeReader.h
@@ -19,6 +19,7 @@ public enum class BarcodeType : int {
 	CODE_93,
 	CODE_128,
 	DATA_MATRIX,
+	DX_FILM_EDGE,
 	EAN_8,
 	EAN_13,
 	ITF,
@@ -29,6 +30,7 @@ public enum class BarcodeType : int {
 	RMQR_CODE,
 	RSS_14,
 	RSS_EXPANDED,
+	DATA_BAR_LIMITED,
 	UPC_A,
 	UPC_E
 };
diff --git a/zint b/zint
new file mode 160000
index 0000000000..7a9fdd6cd0
--- /dev/null
+++ b/zint
@@ -0,0 +1 @@
+Subproject commit 7a9fdd6cd00cd5bfd0082705d934c13ef84f25e1
diff --git a/zxing-cpp.podspec b/zxing-cpp.podspec
index 4db8ff0c6e..ed26746ebc 100644
--- a/zxing-cpp.podspec
+++ b/zxing-cpp.podspec
@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name = 'zxing-cpp'
-  s.version = '2.2.0'
+  s.version = '2.3.0'
   s.summary = 'C++ port of ZXing'
   s.homepage = 'https://github.com/zxing-cpp/zxing-cpp'
   s.author = 'axxel'
@@ -16,6 +16,7 @@ Pod::Spec.new do |s|
   s.module_name = 'ZXingCpp'
   s.platform = :ios, '11.0'
   s.library = ['c++']
+  s.compiler_flags = '-DZXING_READERS'
   s.pod_target_xcconfig = {
     'CLANG_CXX_LANGUAGE_STANDARD' => 'c++20'
   }
@@ -24,6 +25,7 @@ Pod::Spec.new do |s|
 
   s.subspec 'Core' do |ss|
     ss.source_files = 'core/src/**/*.{h,c,cpp}'
+    ss.exclude_files = [ 'core/src/libzint/**' ]
     ss.private_header_files = 'core/src/**/*.h'
   end
 
diff --git a/zxing.cmake b/zxing.cmake
index 1eb55faaf3..2e9a4f53fe 100644
--- a/zxing.cmake
+++ b/zxing.cmake
@@ -2,10 +2,10 @@
 macro(zxing_add_package_stb)
     unset (STB_FOUND CACHE)
 
-    if (BUILD_DEPENDENCIES STREQUAL "AUTO")
+    if (ZXING_DEPENDENCIES STREQUAL "AUTO")
         find_package(PkgConfig)
         pkg_check_modules (STB IMPORTED_TARGET stb)
-    elseif (BUILD_DEPENDENCIES STREQUAL "LOCAL")
+    elseif (ZXING_DEPENDENCIES STREQUAL "LOCAL")
         find_package(PkgConfig REQUIRED)
         pkg_check_modules (STB REQUIRED IMPORTED_TARGET stb)
     endif()
@@ -25,9 +25,9 @@ endmacro()
 macro(zxing_add_package name depname git_repo git_rev)
     unset(${name}_FOUND CACHE) # see https://github.com/zxing-cpp/zxing-cpp/commit/8db14eeead45e0f1961532f55061d5e4dd0f78be#commitcomment-66464026
 
-    if (BUILD_DEPENDENCIES STREQUAL "AUTO")
+    if (ZXING_DEPENDENCIES STREQUAL "AUTO")
         find_package (${name} CONFIG)
-    elseif (BUILD_DEPENDENCIES STREQUAL "LOCAL")
+    elseif (ZXING_DEPENDENCIES STREQUAL "LOCAL")
         find_package (${name} REQUIRED CONFIG)
     endif()
 
@@ -41,6 +41,8 @@ macro(zxing_add_package name depname git_repo git_rev)
             set (gtest_force_shared_crt ON CACHE BOOL "" FORCE)
         endif()
         #FetchContent_MakeAvailable (${depname})
+        # TODO: reqire cmake 3.28 and pass EXCLUDE_FROM_ALL to FetchContent_Declare instead of calling FetchContent_Populate below.
+        #       This would fix a warning but cmake 3.28 is not in Debian bookworm but at least in Ubuntu 24.04 (LTS)
         FetchContent_GetProperties(${depname})
         if(NOT ${depname}_POPULATED)
             FetchContent_Populate(${depname})