Apache Arrow JS

Apache Arrow JS is the JavaScript and TypeScript implementation of the Apache Arrow columnar memory specification, letting Node.js and browser applications read, write, and operate on Arrow-formatted data without the serialization overhead of JSON or row-oriented formats. It exposes a Table/Vector/RecordBatch API that mirrors native JS Arrays while backing them with typed-array buffers laid out for cache efficiency and SIMD-friendly access.

Because Arrow is a cross-language spec shared with the C++, Python (pandas), Rust, and Java implementations, apache-arrow lets a JS app exchange data with those ecosystems over the IPC/Feather format or via Arrow Flight without re-encoding. It supports reading Arrow files from disk, from fetch() streams, or from multiple split buffers, and building tables directly from JS arrays or typed arrays.

The package is published in multiple compiled targets (combined es2015/CommonJS/ESM/UMD by default, or standalone @apache-arrow/* builds) so consumers can pick exactly the module format and JS target their toolchain needs without pulling in unnecessary polyfills.

What You Get

• A Table/RecordBatch/Vector API that behaves like native JS Arrays while storing data in typed-array-backed columnar buffers
• Zero-copy readers for Arrow IPC (streaming and file format), including tables split across multiple buffers or backed by a fetch() stream
• tableFromArrays and vectorFromArray/makeVector helpers to build Arrow data structures directly from plain JS arrays and typed arrays
• Full type system coverage — ints, floats, decimals, dates/times, dictionaries, lists, structs, and unions — with a visitor-pattern dispatch layer for operating generically across types
• A arrow2csv CLI binary for converting Arrow files to CSV from the command line
• Multiple published build targets (apache-arrow combined bundle, or standalone @apache-arrow/es5-cjs, @apache-arrow/esnext-esm, etc.) to control exactly what ships to node_modules

Common Use Cases

• Loading Arrow/Feather files produced by a Python (pandas) or Rust pipeline directly into a JS analytics dashboard without re-serializing to JSON
• Streaming large columnar datasets to the browser over fetch() for in-browser visualization tools like Perspective or Vega
• Building JS-side Arrow tables from application data (arrays of numbers, dates, strings) to hand off to a WASM or native Arrow consumer
• Interchanging data between JS services and other Arrow-based systems (Spark, Arrow Flight servers, DuckDB) with no format conversion cost
• Converting Arrow files to CSV in build/ops scripts using the bundled arrow2csv CLI

Under The Hood

Architecture The codebase separates concerns cleanly across data.ts (raw typed-array buffers and null bitmaps), vector.ts (the user-facing columnar accessor), table.ts/recordbatch.ts (row-group containers), schema.ts/type.ts (the Arrow type system), and ipc/ (binary reader/writer for the Arrow IPC wire format, generated from FlatBuffers schemas under src/fb). Cross-cutting operations (get/set/indexOf/iterate/compare) are implemented once as Visitor subclasses in src/visitor/ and dispatched generically over any Arrow type via getVisitFn, rather than being hand-written per type — a pattern that keeps type-specific logic centralized and makes adding new Arrow types a matter of adding visit methods, not touching every consumer. Table and Vector are defined as TypeScript interfaces merged with runtime classes so the same object exposes both a rich static type (TType/TArray/TValue) and imperative runtime behavior. Tech Stack Written entirely in TypeScript and compiled with a Gulp + esbuild/Rollup pipeline into multiple module targets (CJS/ESM/UMD across es5/es2015/esnext), with FlatBuffers (flatbuffers package) generating the binary IPC schema bindings and tslib/json-with-bigint as the only non-dev runtime dependencies, keeping the published package’s own dependency footprint minimal. google-closure-compiler and gulp-terser handle minification for the browser bundles, and typedoc generates the public API reference site. Code Quality The repo carries a large unit-test suite under test/unit (covering builders, IPC readers/writers, tables, vectors, and record batches) run via Jest with ts-jest/@swc-node, plus a test:bundle step that exercises the compiled output itself, not just source. Linting runs through ESLint with typescript-eslint and eslint-plugin-unicorn/eslint-plugin-jest, and GitHub Actions workflows (test.yaml, rc.yaml, release.yaml) gate merges and drive the Apache release-candidate process. Being an ASF project, contributions also go through pre-commit hooks and Apache license-header checks. API Design The public API is deliberately Array-like — Vector#get, iteration via for...of, and .toArray() — so JS developers can work with columnar Arrow data using idioms they already know, while helpers like tableFromIPC, tableFromArrays, and vectorFromArray cover the common construction paths with a single import each. Dictionary encoding, typed builders, and the full Arrow type system are available for advanced cases without being required for the basic read/build workflows shown in the README’s cookbook.