> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Dart BigInt `BigInt` is a built-in Dart class representing an arbitrarily large integer. Unlike the standard `int` type, which is constrained to a 64-bit two's complement representation (ranging from -2^63 to 2^63 - 1), `BigInt` can store integer values of any size, limited only by the available system memory. ## Instantiation Because Dart's numeric literals are parsed as 64-bit integers by the compiler, instantiating a `BigInt` that exceeds the 64-bit limit requires parsing from a `String`. Using `BigInt.from()` with a numeric literal that exceeds the 64-bit limit results in a compile-time error. ```dart theme={"dark"} // Recommended: Parsing from a string prevents 64-bit overflow errors BigInt largeBase10 = BigInt.parse('922337203685477580899999'); // Automatically detects and parses hexadecimal if prefixed with '0x' BigInt largeHex = BigInt.parse('0x1fffffffffffff123456789'); // Parsing without a prefix requires explicitly specifying the radix BigInt explicitHex = BigInt.parse('1fffffffffffff123456789', radix: 16); BigInt binaryValue = BigInt.parse('101010', radix: 2); // Converting from an existing 64-bit int or double BigInt fromNativeInt = BigInt.from(42); // Pre-defined constants BigInt zero = BigInt.zero; BigInt one = BigInt.one; BigInt two = BigInt.two; ``` ## Operators `BigInt` overloads standard arithmetic, relational, and bitwise operators. This allows instances to be manipulated using the same syntax as native `int` types. ```dart theme={"dark"} BigInt a = BigInt.parse('100000000000000000000'); BigInt b = BigInt.from(5); // Arithmetic BigInt sum = a + b; BigInt difference = a - b; BigInt product = a * b; BigInt quotient = a ~/ b; // Truncating integer division, returns BigInt double floatQuotient = a / b; // Standard division, returns double BigInt modulo = a % b; // Bitwise BigInt shifted = a << 2; BigInt bitwiseAnd = a & b; // Relational bool isGreater = a > b; ``` *Note: The standard division operator (`/`) is fully supported between `BigInt` instances, but it evaluates to a `double`. To maintain arbitrary precision and return a `BigInt`, use the truncating division operator (`~/`).* ## Key Properties and Methods `BigInt` provides several properties and methods for mathematical operations and state inspection. ```dart theme={"dark"} BigInt val = BigInt.parse('256'); // Inspection bool isEven = val.isEven; bool isNegative = val.isNegative; int sign = val.sign; // Returns -1, 0, or 1 int bits = val.bitLength; // Minimum number of bits required to store the value // Mathematical operations BigInt power = val.pow(3); BigInt greatestCommonDivisor = val.gcd(BigInt.from(128)); // Downcasting int nativeInt = val.toInt(); // Truncates if value exceeds 64 bits double nativeDouble = val.toDouble(); // Loses precision if value exceeds 53 bits ``` ## Technical Characteristics * **Immutability:** Instances of `BigInt` are strictly immutable. All arithmetic and bitwise operations allocate and return a new `BigInt` instance in memory. * **Performance Overhead:** Because `BigInt` utilizes software-based arbitrary-precision arithmetic rather than hardware-level CPU instructions, operations are significantly slower and consume more memory than native `int` operations. * **Web Compilation:** When compiled to the web via `dart2js` or `dartdevc` (DDC), Dart's `BigInt` uses a custom Dart implementation (a class backed by arrays of smaller integers) to guarantee consistent semantics with the Dart VM. It does not map to the native JavaScript `BigInt` type. Native JS BigInts are instead accessed via JS interop (e.g., `JSBigInt`).

Tired of Poor Dart Skills? Fix That With Deep Grasping! Learn More