> ## 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 int
In Go, `int` is a built-in, signed integer data type whose memory footprint is architecture-dependent. It resolves to 32 bits (4 bytes) on 32-bit systems and 64 bits (8 bytes) on 64-bit systems.
## Technical Specifications
* **Zero Value:** `0`
* **Size:** Evaluated via `unsafe.Sizeof(int(0))`, yielding `4` or `8` depending on the target compilation architecture (`GOARCH`).
* **Range (32-bit):** -2³¹ to 2³¹-1 (-2,147,483,648 to 2,147,483,647)
* **Range (64-bit):** -2⁶³ to 2⁶³-1 (-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807)
## Syntax and Type Inference
When declaring an untyped integer literal, the Go compiler automatically infers the underlying type as `int`.
```go theme={"dark"}
// Explicit declaration
var a int = 10
// Short variable declaration (type inferred as int)
b := 20
// Zero-value initialization
var c int // c is initialized to 0
```
## Type Identity and Strict Typing
In Go's type system, `int` is a distinct, named type. It is **not** an alias for `int32` or `int64`. Because Go enforces strict typing and lacks implicit type coercion, you cannot assign an `int` to a variable of type `int32` or `int64` without an explicit conversion, even if the underlying architecture guarantees identical bit widths.
```go theme={"dark"}
var x int = 100
var y int64 = 100
// INVALID: Cannot use x (type int) as type int64 in assignment
// y = x
// VALID: Requires explicit type conversion
y = int64(x)
```
## Memory Alignment
The alignment guarantee for `int` matches its size. Evaluated via `unsafe.Alignof(int(0))`, it aligns to a 4-byte boundary on 32-bit architectures and an 8-byte boundary on 64-bit architectures. This behavior directly impacts struct padding when `int` fields are interleaved with smaller data types like `bool` or `int8`.
Tired of Poor Go Skills? Fix That With Deep Grasping!
Learn More
