BigDecimal.js

BigInt based BigDecimal implementation for Node.js 10.4 and above, and for browsers that support native BigInt (Chrome 67+, Firefox 68+, Safari 14+). This implementation is inspired from java BigDecimal class. This implementation is faster than popular big decimal libraries for most operations. See benchmarks results part below for comparison of each operation.

Advantages of this library

• Faster than other BigDecimal libraries because of native BigInt
• Simple API that is almost same with Java's BigDecimal
• No dependencies
• Well tested
• Includes type definition file

Disadvantages

• This library's minified version is about 5 times larger than big.js's minified version. So the library is not small.

Installation

npm install bigdecimal.js
Copy

Usage

• The example usage is given below:

// Single unified constructor for multiple values
const { Big } = require('bigdecimal.js');

// Construct from a string and clone it
const x = Big('1.1111111111111111111111');
const y = new Big(x); // you can also use 'new'

const z = x.add(y);
console.log(z.toString()); // 2.2222222222222222222222

// You can also construct from a number or BigInt:
const u = Big(1.1);
const v = Big(2n);

console.log(u.toString()); // 1.1
console.log(v.toString()); // 2
Copy

You can use MathContext to set precision and rounding mode for a specific operation:

const { Big, MC, RoundingMode } = require('bigdecimal.js');

const x = Big('1');
const y = Big('3');

// MC is MathContext constructor that can be used with or without `new`
const res1 = x.divideWithMathContext(y, MC(3)); 
console.log(res1.toString()); // 0.333

const res2 = x.divideWithMathContext(y, new MC(3, RoundingMode.UP));
console.log(res2.toString()); // 0.334

try {
    x.divide(y);
    // throws since full precision is requested but it is not possible
} catch (e) {
    console.log(e); // RangeError: Non-terminating decimal expansion; no exact representable decimal result.
}
Copy

Browser usage

The library is pure JavaScript with zero runtime dependencies and uses native BigInt, so it runs in the browser with no polyfills. The only requirement is a browser with BigInt support (Chrome 67+, Firefox 68+, Safari 14+).

With a bundler (Vite, webpack, esbuild, Rollup) just import it as usual:

import { Big } from 'bigdecimal.js';
Copy

Without a bundler, import the ESM build straight from a CDN:

<script type="module">
  import { Big } from 'https://esm.sh/bigdecimal.js';
  console.log(Big('0.1').add(Big('0.2')).toString()); // 0.3
</script>
Copy

Or use the minified UMD bundle, which exposes a global BigDecimalJS:

<script src="https://cdn.jsdelivr.net/npm/bigdecimal.js/lib/bigdecimal.umd.min.js"></script>
<script>
  const { Big } = BigDecimalJS;
  console.log(Big('0.1').add(Big('0.2')).toString()); // 0.3
</script>
Copy

Documentation

• API Documentation

Testing

• Install dependencies: npm i
• Compile: npm run compile
• Run tests: npm test

Running Benchmarks

There is a benchmark suite that compares

• This library
• big.js
• bigdecimal
• bignumber.js
• decimal.js

To run the benchmark run npm install and then npm run benchmark.

Benchmark Results

Benchmarked against big.js, bigdecimal (GWT-based), bignumber.js and decimal.js.

• Test Machine:

  • Apple M1
  • 8 GB Ram
  • macOS 26.3
  • Node.js 24

• Update Date: July 10th 2026

• Library versions used:

  • big.js 7.0.1
  • (this library) bigdecimal.js 1.5.1
  • bigdecimal 0.6.1
  • bignumber.js: 11.1.5
  • decimal.js: 10.6.0

• Each operation is run with a fixed set of decimal numbers composed of both simple and complex numbers.

• Micro benchmark framework used is benchmark. Check out benchmarks folder for source code of benchmarks.

• Numbers are operations per second (higher is better). In each row the fastest library is bold, and the Fastest column names the winner with how many times faster it is than the runner-up. A - means the library has no equivalent operation.

bigdecimal.js is the fastest in 23 of 27 operations. It trails decimal.js on remainder/divideToIntegralValue, and big.js on round/setScale.

Other engines: Bun (JavaScriptCore)

The table above is measured on Node.js, i.e. V8. Because bigdecimal.js builds on native BigInt, relative results depend on the engine's BigInt implementation. Running the same suite on the same machine under Bun 1.3.14 (JavaScriptCore, the engine of Safari), bigdecimal.js is the fastest in 22 of 27 operations, and its absolute throughput is often higher than on V8 — for example ToString reaches 18.3M ops/sec (10.7M on V8), NumberValue 5.7M (760K on V8) and Divide 50K (40K on V8).

Operations where the outcome differs on JavaScriptCore:

To reproduce, run the suite with Bun: bun benchmarks/index.js.