> ## 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.
# Go int64
`int64` is a built-in, statically typed, signed integer data type in Go that occupies exactly 64 bits (8 bytes) of memory, guaranteeing a fixed size regardless of the underlying hardware architecture or operating system.
Unlike the architecture-dependent `int` type, whose size is statically determined at compile time to be either 32 or 64 bits based on the target architecture (`GOARCH`), `int64` provides strict deterministic memory allocation.
## Technical Specifications
* **Memory Footprint:** 64 bits (8 bytes)
* **Encoding:** Two's complement representation
* **Sign Bit:** The Most Significant Bit (MSB) determines the sign (0 for positive, 1 for negative)
* **Minimum Value:** $-2^{63}$ (-9,223,372,036,854,775,808)
* **Maximum Value:** $2^{63}-1$ (9,223,372,036,854,775,807)
* **Zero Value:** `0`
## Syntax and Initialization
You can declare an `int64` using standard variable declaration, short variable declaration with explicit type conversion, or the `new` keyword.
```go theme={"dark"}
package main
import "fmt"
func main() {
// Standard declaration (initialized to zero value)
var a int64
// Declaration with initialization
var b int64 = 9223372036854775807
// Short declaration using explicit type conversion
c := int64(-9223372036854775808)
// Pointer to an int64
d := new(int64)
fmt.Println(a, b, c, *d)
}
```
## Boundary Constants
The standard library's `math` package provides predefined untyped constants for the absolute boundaries of an `int64`.
```go theme={"dark"}
package main
import (
"fmt"
"math"
)
func main() {
var min int64 = math.MinInt64
var max int64 = math.MaxInt64
fmt.Printf("Min: %d, Max: %d\n", min, max)
}
```
## Strict Type Resolution and Conversion
Go's type system does not support implicit type coercion. The compiler treats `int64` as a fundamentally distinct type from `int`, `int32`, or `uint64`, even if the underlying architecture is 64-bit (where `int` and `int64` share the same memory footprint).
Operations mixing `int64` with other numeric types require explicit type conversion.
```go theme={"dark"}
package main
import "fmt"
func main() {
var archInt int = 42
var fixedInt int64 = 100
// INVALID: Mismatched types
// result := archInt + fixedInt
// VALID: Explicit type conversion to int64
result := int64(archInt) + fixedInt
// VALID: Explicit type conversion to int
result2 := archInt + int(fixedInt)
fmt.Println(result, result2)
}
```
## Overflow Behavior
If an arithmetic operation exceeds the maximum or minimum bounds of `int64`, Go silently wraps around using two's complement arithmetic. It does not panic or throw an overflow exception at runtime.
```go theme={"dark"}
package main
import (
"fmt"
"math"
)
func main() {
var max int64 = math.MaxInt64
fmt.Println(max) // 9223372036854775807
// Silent overflow wraps to the minimum value
overflow := max + 1
fmt.Println(overflow) // -9223372036854775808
}
```
Tired of Poor Go Skills? Fix That With Deep Grasping!
Learn More
