> ## 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.
# Swift UInt64
`UInt64` is a value type in Swift representing a 64-bit unsigned integer. It stores non-negative whole numbers using exactly 8 bytes of memory, providing a fixed-width numeric representation that remains strictly 64 bits wide regardless of the underlying platform's architecture (unlike `UInt`, which scales to the platform's word size).
Because it is an unsigned type, it allocates all 64 bits to the magnitude of the number, omitting the sign bit. This yields the following mathematical bounds:
* **Minimum Value:** `0`
* **Maximum Value:** `18,446,744,073,709,551,615` ($2^{64} - 1$)
## Syntax and Initialization
You can instantiate a `UInt64` using integer literals, explicit type annotation, or by converting from other numeric types. Swift does not implicitly convert between integer types, so typecasting is strictly required when mixing `UInt64` with types like `Int` or `UInt32`.
```swift theme={"dark"}
// Explicit type annotation
let defaultZero: UInt64 = 0
let hexLiteral: UInt64 = 0xFFFFFFFFFFFFFFFF
// Accessing static boundary properties
let absoluteMin = UInt64.min // 0
let absoluteMax = UInt64.max // 18446744073709551615
// Explicit conversion from a signed integer
let standardInt: Int = 2048
let convertedUInt64 = UInt64(standardInt)
// Explicit conversion from a smaller unsigned integer
let smallUInt: UInt8 = 255
let expandedUInt64 = UInt64(smallUInt)
```
## Overflow and Underflow Behavior
By default, Swift prevents integer overflow and underflow. If an arithmetic operation on a `UInt64` results in a value outside its 64-bit bounds, the program will trigger a runtime trap.
To intentionally allow wrapping behavior at the bit level, Swift provides masking arithmetic operators (`&+`, `&-`, `&*`).
```swift theme={"dark"}
var boundaryValue = UInt64.max
// Standard addition causes a runtime crash (Overflow)
// boundaryValue += 1
// Masking addition wraps the 64-bit integer back to 0
let wrappedValue = boundaryValue &+ 1
var zeroValue = UInt64.min
// Masking subtraction wraps the 64-bit integer to UInt64.max
let underflowValue = zeroValue &- 1
```
## Protocol Conformances
Under the hood, `UInt64` is implemented as a struct. It conforms to a robust hierarchy of Swift standard library protocols, dictating its capabilities:
* **`FixedWidthInteger` & `BinaryInteger`**: Guarantees a specific bit width, enabling bitwise operations (`~`, `&`, `|`, `^`, `<<`, `>>`) and providing access to properties like `leadingZeroBitCount` and `nonzeroBitCount`.
* **`UnsignedInteger`**: Semantically enforces the lack of a sign bit.
* **`Hashable` & `Equatable`**: Allows `UInt64` to be compared for equality (`==`, `!=`) and used as keys in `Dictionary` or elements in `Set`.
* **`Comparable`**: Enables relational operators (`<`, `>`, `<=`, `>=`).
* **`Codable`**: Provides out-of-the-box support for serialization and deserialization (e.g., JSON encoding).
```swift theme={"dark"}
let bitwiseTarget: UInt64 = 0b1010_1010
let shifted = bitwiseTarget << 2 // 0b10_1010_1000
let zeroCount = bitwiseTarget.leadingZeroBitCount // 56
```
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
