Tapirscan 1.3.0

Breaking API changes in every binding. scan returns decoded values and
their locations; inspect returns the detailed report. Native consumers must
rebuild for ABI 6. See the migration guide.

Application API

• scan returns values, barcodes (text, format, polygon and rectangle) and
  best. inspect adds timing, unread regions and diagnostics, replacing the
  debug option. The unfinished result flag is removed; it was set on nearly
  every scan and gave no useful signal.
• The extended-budget scan option is removed: it did not change results in
  Medium, High or Very High.
• Supplement policies are lowercase like the modes: "ignore", "read" and
  "require".
• Per-call formats override the scanner's formats in every binding. Rectangles
  are integers in every binding. Python and JavaScript errors share the same
  code names.
• The free best() function and direct iteration, indexing and len on Python
  and Rust results are removed; use result.best and result.barcodes.
• JavaScript adds tapirscan/browser: scan files, images, video frames, canvases
  and bitmaps in a bundled worker. Construction is synchronous, scans return
  promises, and server rendering is supported. Next.js and Vite production builds
  bundle the worker and WASM; Vite 6/7 development servers need one
  configuration line.
• C, C++ and Java share the scanner, options and result model of the other
  bindings. One native library contains all four effort modes. ABI 6 provides
  caller-owned error details, typed access and on-demand JSON. C scanner options
  have an explicit initializer; C++ rejects temporary image buffers.
• Rust mode features only add modes: all four are default features, and
  smaller builds disable the defaults and list their modes.
• Data Matrix, PDF417, Aztec and MaxiCode report reader_initialization as
  false when the symbol has no reader-initialization flag; other formats leave it
  unavailable.
• Java accepts MemorySegment pixels without copying. Python wheels bundle the
  native library. Rust barcodes implement serde Serialize. JavaScript and
  Python expose typed format identifiers.
• JavaScript adds experimental Turbo presets 2, 4, 8 and 16 for faster
  1D scanning, including Retail, in both the core and the browser entry. They may change in minor releases; see
  Turbo presets.

Scanner behavior

• Linear barcodes are localized by bar-segment voting, and areas grown along the
  bars merge duplicate reads of one label; separate labels with equal values stay
  separate.
• New recovery passes target low contrast, camera shake, defocus and small print
  on retail labels. High and Very High read EAN-8 and UPC-E in the retail scan;
  Very High adds subpixel recovery for small EAN-13 symbols.
• QR Code and Aztec add recovery passes for difficult symbols.
• On the maintainer's development image sets these changes found more barcodes
  with fewer duplicates; they are not a published benchmark.
• Reads, geometry, ordering and latency can differ from 1.2.2. Higher effort
  does not guarantee more reads on every image.

Known issues

• A linear barcode decoded along a slightly diagonal scanline can get an outline
  tilted by a few degrees, extending a few pixels past the bars at two corners.
  Decoded values are unaffected.

Packaging

• All implemented linear and 2D formats are supported, with documented
  variant limitations.
• Packages include the complete MIT and Apache 2.0 license texts, correcting the
  license files in the 1.2.2 artifacts.

Install: npm install tapirscan · pip install tapirscan · cargo add tapirscan. Try it in the live demo.

Tapirscan 1.2.2

• Public low now uses the original Turbo policy across all bindings; higher
  effort modes remain available. Low prioritizes speed and can miss difficult
  symbols; Medium remains the default API mode. The previous Low is
  TS-Low Classic in the demo. Experimental Turbo tiers remain demo-only.

• Demo cards pause without disappearing; More scanners controls visibility.
  Basic ZXing and ZXing-JS readers are separate optional comparisons.

• Speed up Medium, High and Very High recovery crops with pixel-identical integer interpolation and cached rows; retain existing APIs and scan behavior.

• Recover fuller barcode display outlines with bounded profile agreement when strict bar tracing fails, including high-resolution photos.

• Measure high-resolution linear barcode extents with adaptive cross-section spacing and outer-edge priority under the existing sample budget.

• Measure full visible linear-bar extents and reconcile competing interpretations through connected source-bar footprints.

• Reconcile crossing linear reads through distributed source-bar ownership while preserving earlier duplicate proofs.

• Suppress weak ITF interpretations when supported retail reads demonstrably occupy the same bars.

• Follow changing bar widths when consolidating folded linear observations.

• Reuse well-resolved EAN8/UPC-E coverage before enlarged detail rescans, while
  retaining recovery for small or weakly supported symbols.

• Recover additional strongly sheared retail labels with bounded sparse envelope fits.

• Consolidate more warped linear observations using continuous ink and paper evidence,
  while preserving separate equal-value labels and existing work limits.

• Specialize exact RGB/RGBA luminance conversion and borrow packed grayscale inputs
  for additional format readers.

• Preserve unchanged generated package and adapter inputs during refresh; serialize
  supported package builds and provide experimental WASM assets outside release identities.

• Clarify candidate scanning, mode budgets and frame reconciliation; reuse retail
  conversion storage and remove fixed sampling-list heap allocations.

• Support Chromium comparisons and retained public outputs for labeled experiments.

• Make release WASM identities independent of checkout paths.

• Maintain production algorithms directly in core/src with explicit effort-mode
  features; preserve original recipes and sources under historical/.

• Separate profile sampling, decoding, observation association, retry planning and
  physical identity/conflict resolution into concrete stages.

• Assemble native results on typed data, including supplements, ordering and unread
  regions. JSON serialization is limited to outputs and optional diagnostics.

Packages: npm install tapirscan@1.2.2, pip install tapirscan==1.2.2, and Rust tapirscan = "1.2.2".

Python 3.10+ wheels: macOS 11+ (Apple Silicon and Intel), Linux manylinux_2_28 (x86_64 and ARM64), and Windows x64. Wheel-only Python distribution.

EAN13, UPCA, EAN8 and UPCE remain supported; other formats remain experimental. Medium and ignored supplements remain the API defaults. Native ABI 4 is unchanged.

Try the demo · Low and Low Classic

Tapirscan 1.2.1

Tapirscan 1.2.1 enables retail formats (EAN13, UPCA, EAN8 and UPCE) by default across the public bindings. Select EAN13 explicitly to retain EAN13-only behavior.

• Medium shares EAN/UPC decoding work, with bounded short-code recovery. EAN8-only uses the same recovery as retail selection.
• Medium effort and ignored supplements remain the defaults. Native ABI 4 is unchanged.
• Release builds fetch each pinned recipe’s dependencies and reproduce its source paths across build machines.

Python wheels support macOS 11+ (arm64 and x86_64), Linux manylinux_2_28 (aarch64 and x86_64), and Windows x64.

Retail formats are supported; formats outside this group remain experimental.

Demo · Changelog

Tapirscan 1.2.0

Breaking changes: this early-library minor release intentionally changes the
application APIs. Existing callers should follow the migration guide below.

• Mark all retail formats (EAN13, UPCA, EAN8 and UPCE) as supported. Formats
  outside the retail group remain experimental.
• Unify JavaScript, Python and standalone Rust around scan results with decoded
  instances, undecoded proposal geometry and truthful work-limit status.
• Replace finish-candidates booleans with a format-independent extended-budget flag
  while retaining the concise best selection helper. Align Rust metadata absence and bounds.
• See migration for intentional breaking changes. Native
  ABI 4 and pinned decoding recipes are unchanged.
• Rust supports scan(image) with defaults and scan_with_options(image, options)
  for explicit settings. best remains the selection helper across bindings.

Python wheels: macOS 11+ (arm64 and x86_64), Linux manylinux_2_28 (aarch64 and x86_64), Windows x64.

Retail formats EAN13, UPCA, EAN8 and UPCE are supported; other formats remain experimental.

Tapirscan 1.1.0

Tapirscan 1.1.0

Try the live demo · Python guide · JavaScript guide

Highlights

• One-shot and reusable Python/JavaScript scanners with immutable results, source-image polygons, payload metadata and optional diagnostics.
• Improved QR, Common1D and retail decoding, with source-pixel evidence to consolidate duplicate observations while preserving separate products.
• Optional per-scan finish_candidates=True (Python) / finishCandidates: true (JavaScript) lets EAN13/UPC-A candidates continue beyond shared frame budgets. It is off by default; per-candidate effort and other limits remain.
• Optional Ignore, Read and Require policies for EAN/UPC supplements. Supplement text is separate from the main barcode payload.
• Python supports Pillow, NumPy, PyTorch and explicit pixel buffers, including optional OpenCV BGR input.
• JavaScript includes TypeScript declarations, configurable WASM loading and Worker/camera examples.

Install

pip install tapirscan==1.1.0
npm install tapirscan@1.1.0

Python requires 3.10+. Wheels bundle all four native modes for macOS 11+ ARM64 and Intel, Linux glibc 2.28+ ARM64 and x86-64, and Windows x64. JavaScript requires WebAssembly SIMD; Node 20+ is supported.

EAN13/UPC-A is the primary reader. Additional formats remain experimental. Support values rank reader evidence; they are not comparable confidence probabilities across formats. Continuation does not guarantee exhaustive scanning.

See the changelog for details. Release assets contain the validated npm tarball, five platform wheels and SHA-256 checksums.

Tapirscan 1.0.0

Tapirscan’s first public release brings orientation-aware barcode scanning to browser, Node.js and native applications, with four effort modes and a shared Rust core.

Try the interactive demo, compare it with ZXing and ZBar, or scan your own images locally in your browser.

• Python and JavaScript/TypeScript APIs offer direct scanning and reusable scanners.
• Python wheels bundle all four native decoders for macOS Apple Silicon and Intel, Linux x86_64 and ARM64 (glibc 2.28+), and Windows x64.
• The npm package includes the WASM modules and TypeScript declarations.
• Rust, C, C++ and Java bindings are available in the repository.
• EAN-13 is the primary validated format. Additional formats remain experimental; see the format documentation before migrating other use cases.
• MIT licensed, copyright Florian Nick. Development and AI attribution are documented in the README and development story.

npm install tapirscan
pip install tapirscan

For Python image loading, install the image library you use, for example pip install tapirscan pillow.

Start with the JavaScript/TypeScript guide or Python guide. Both include migration information and the API reference.

The release artifacts were built and tested by GitHub Actions from this release commit. Python supports 3.10+; the Node.js API supports Node 20+. The Python release contains platform wheels, not a source distribution. Windows ARM64 and musl-based Linux distributions are not included in this wheel set.