# What Are the 128-Bit Integer Types in absl::numeric?

> Explore absl::int128 and absl::uint128, Abseil's 128-bit integer types. Learn how to use these powerful types in absl::numeric for enhanced data handling.

- Repository: [Abseil/abseil-cpp](https://github.com/abseil/abseil-cpp)
- Tags: deep-dive
- Published: 2026-07-12

---

**Abseil’s `absl::numeric` module defines exactly two 128-bit integer types—`absl::int128` (signed) and `absl::uint128` (unsigned)—which are declared in [`absl/numeric/int128.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/numeric/int128.h) and implemented in `absl/numeric/int128.cc`.**

The Abseil C++ library extends the standard type system with portable 128-bit integer arithmetic. These types fill a critical gap for applications requiring precision beyond 64 bits, offering consistent cross-platform behavior that the C++ standard library does not yet provide.

## The 128-Bit Integer Types Defined

### absl::int128 (Signed)

**`absl::int128`** is a signed 128-bit integer type capable of representing values from $-2^{127}$ to $2^{127}-1$. It is defined as a class type in [`absl/numeric/int128.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/numeric/int128.h) and supports standard arithmetic operators (`+`, `-`, `*`, `/`, `%`) as well as bitwise operations. The type provides explicit constructors to convert from standard integer types and literals, ensuring type safety during initialization.

### absl::uint128 (Unsigned)

**`absl::uint128`** is the unsigned variant, representing values from $0$ to $2^{128}-1$. Like its signed counterpart, it is defined in [`absl/numeric/int128.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/numeric/int128.h) and implements the full suite of arithmetic and bitwise operators. Both types are designed to interact seamlessly with standard C++ integers through explicit conversion operators, preventing accidental narrowing.

## Source File Locations and Implementation

According to the Abseil source code, the 128-bit integer implementation is organized across the following files:

- **[`absl/numeric/int128.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/numeric/int128.h)**: Contains the class declarations for `absl::int128` and `absl::uint128`, operator overloads, type traits, and inline utility functions.
- **`absl/numeric/int128.cc`**: Houses the implementation of complex arithmetic operations, string conversion routines, and platform-specific optimizations.
- **`absl/numeric/int128_test.cc`**: Comprehensive unit tests validating arithmetic correctness, edge cases, and type conversions.
- **`absl/numeric/int128_stream_test.cc`**: Tests for stream insertion (`operator<<`) and extraction (`operator>>`) functionality, confirming compatibility with standard I/O streams.

## Practical Usage Examples

The following example demonstrates initialization, arithmetic, and string conversion of 128-bit integers:

```cpp
#include "absl/numeric/int128.h"
#include "absl/strings/str_cat.h"
#include <iostream>

int main() {
  // Initialize using bit shifts to create large values
  absl::int128 signed_val = absl::int128(1) << 100;    // 2^100
  absl::uint128 unsigned_val = absl::uint128(1) << 120; // 2^120

  // Perform arithmetic operations
  absl::int128 sum = signed_val + absl::int128(42);
  absl::uint128 product = unsigned_val * absl::uint128(3);

  // Convert to string for output (requires absl/strings/str_cat.h)
  std::cout << "Signed: " << absl::StrCat(signed_val) << "\n";
  std::cout << "Sum: " << absl::StrCat(sum) << "\n";
  std::cout << "Product: " << absl::StrCat(product) << "\n";

  return 0;
}

```

## Clarification on Non-Standard Bit Widths

Abseil does **not** provide 28-bit integer types or other unusual bit-width integers (such as `int28_t` or `uint28_t`). The `absl::numeric` namespace focuses exclusively on the 128-bit extensions alongside standard `<cstdint>` types. If your application requires 28-bit specific logic, you must implement custom masking or use arbitrary-precision arithmetic libraries.

## Summary

- Abseil provides **two** 128-bit integer types: **`absl::int128`** (signed) and **`absl::uint128`** (unsigned).
- Both types are defined in **[`absl/numeric/int128.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/numeric/int128.h)** and implemented in **`absl/numeric/int128.cc`**.
- The library includes comprehensive test coverage in `int128_test.cc` and `int128_stream_test.cc`.
- Use **`absl::StrCat()`** (from [`absl/strings/str_cat.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/strings/str_cat.h)) to convert 128-bit values to strings for logging or output.
- **No** 28-bit or other non-standard fixed-width integers exist in the `absl::numeric` module.

## Frequently Asked Questions

### What header file defines absl::int128 and absl::uint128?

Both types are defined in **[`absl/numeric/int128.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/numeric/int128.h)**. You must include this header to use the 128-bit integer types, and for string conversion functions, you should also include [`absl/strings/str_cat.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/strings/str_cat.h).

### Does absl::numeric provide 28-bit integer types?

**No.** The Abseil numeric library does not define 28-bit integer types (such as `int28_t` or `uint28_t`). The only extended-width integers provided are the 128-bit types. For other bit widths, use standard fixed-width types from `<cstdint>` or implement custom logic.

### How do I output absl::int128 values to std::cout?

You can use **`absl::StrCat()`** from [`absl/strings/str_cat.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/strings/str_cat.h) to convert the value to a string, or rely on the stream insertion operator (`operator<<`) which is defined in [`absl/numeric/int128.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/numeric/int128.h) and tested in `absl/numeric/int128_stream_test.cc`.

### Are absl::int128 operations portable across 32-bit and 64-bit platforms?

**Yes.** Abseil implements software fallbacks for 128-bit arithmetic operations when hardware support is unavailable, ensuring identical behavior on 32-bit, 64-bit, and mixed architectures.