Unsafe Package

Advanced ~40 min read

The unsafe package provides low-level operations that bypass Go's type safety. While powerful for optimization and system programming, it requires extreme care. Learn when to use unsafe, how to use it correctly, and understand the risks involved.

⚠️ Critical Warning:

Unsafe code bypasses Go's type safety
Can cause crashes, data corruption, and security issues
Not protected by Go's compatibility promise
Should be used only when absolutely necessary
Requires thorough testing and documentation

What is the Unsafe Package?

The unsafe package provides operations that step around Go's type safety. It's used for low-level programming, performance optimization, and interfacing with non-Go code.

Unsafe Package Functions:

Sizeof(x) - Returns size of x in bytes
Alignof(x) - Returns alignment of x
Offsetof(x.f) - Returns offset of field f in struct x
Pointer - Generic pointer type

Pointer Operations

Unsafe pointers allow arbitrary pointer arithmetic and type conversions:

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	fmt.Println("Unsafe Package - Pointer Operations")
	fmt.Println("====================================\n")

// Example 1: Basic pointer operations
	fmt.Println("1. Basic pointer operations:")
	x := 42
	ptr := unsafe.Pointer(&x)
	fmt.Printf("   Value: %d\n", x)
	fmt.Printf("   Pointer: %p\n", ptr)
	fmt.Printf("   Pointer size: %d bytes\n\n", unsafe.Sizeof(ptr))

// Example 2: Converting between pointer types
	fmt.Println("2. Converting pointer types:")
	var f float64 = 3.14
	floatPtr := &f

// Convert *float64 to unsafe.Pointer to *int64
	intPtr := (*int64)(unsafe.Pointer(floatPtr))
	fmt.Printf("   Float value: %f\n", *floatPtr)
	fmt.Printf("   As int64: %d (raw bits)\n\n", *intPtr)

// Example 3: Pointer arithmetic (dangerous!)
	fmt.Println("3. Pointer arithmetic:")
	arr := [5]int{10, 20, 30, 40, 50}

// Get pointer to first element
	firstPtr := unsafe.Pointer(&arr[0])
	fmt.Printf("   Array: %v\n", arr)
	fmt.Printf("   First element: %d\n", *(*int)(firstPtr))

// Move pointer to second element (add size of int)
	secondPtr := unsafe.Pointer(uintptr(firstPtr) + unsafe.Sizeof(arr[0]))
	fmt.Printf("   Second element: %d\n", *(*int)(secondPtr))

// Move to third element
	thirdPtr := unsafe.Pointer(uintptr(firstPtr) + 2*unsafe.Sizeof(arr[0]))
	fmt.Printf("   Third element: %d\n\n", *(*int)(thirdPtr))

// Example 4: uintptr conversions
	fmt.Println("4. uintptr conversions:")
	y := 100
	yPtr := unsafe.Pointer(&y)

// Convert to uintptr (integer representation)
	addr := uintptr(yPtr)
	fmt.Printf("   Address as uintptr: 0x%x\n", addr)

// Convert back to pointer
	backPtr := unsafe.Pointer(addr)
	fmt.Printf("   Value via converted pointer: %d\n\n", *(*int)(backPtr))

// Example 5: Pointer to slice element
	fmt.Println("5. Slice element pointer:")
	slice := []string{"Go", "is", "awesome"}

// Get pointer to first element
	elemPtr := unsafe.Pointer(&slice[0])
	fmt.Printf("   Slice: %v\n", slice)
	fmt.Printf("   First element via pointer: %s\n\n", *(*string)(elemPtr))

fmt.Println("⚠️  WARNING: Unsafe pointer operations:")
	fmt.Println("  • Bypass Go's type safety")
	fmt.Println("  • Can cause crashes if misused")
	fmt.Println("  • Not protected by garbage collector")
	fmt.Println("  • Use only when absolutely necessary")
	fmt.Println("  • Prefer safe alternatives when possible")
}

Output

Click Run to execute your code

Pointer Conversion Rules:

*T → unsafe.Pointer → *U
unsafe.Pointer → uintptr (for arithmetic)
uintptr → unsafe.Pointer (back to pointer)
Never store uintptr - GC won't track it

Type Conversions

Unsafe allows zero-copy conversions between compatible types:

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	fmt.Println("Unsafe Type Conversions")
	fmt.Println("=======================\n")

// Example 1: Float to int conversion (reinterpret bits)
	fmt.Println("1. Float to int bit conversion:")
	f := float32(3.14)
	fmt.Printf("   Float32: %f\n", f)

// Reinterpret float32 bits as uint32
	bits := *(*uint32)(unsafe.Pointer(&f))
	fmt.Printf("   As uint32 bits: 0x%08x\n", bits)
	fmt.Printf("   Binary: %032b\n\n", bits)

// Example 2: String to byte slice (zero-copy)
	fmt.Println("2. String to []byte (zero-copy):")
	str := "Hello, unsafe!"

// Normal conversion (copies)
	normalBytes := []byte(str)
	fmt.Printf("   Normal conversion: %v\n", normalBytes)

// Unsafe conversion (no copy, dangerous!)
	type StringHeader struct {
		Data uintptr
		Len  int
	}
	type SliceHeader struct {
		Data uintptr
		Len  int
		Cap  int
	}

strHeader := (*StringHeader)(unsafe.Pointer(&str))
	sliceHeader := SliceHeader{
		Data: strHeader.Data,
		Len:  strHeader.Len,
		Cap:  strHeader.Len,
	}
	unsafeBytes := *(*[]byte)(unsafe.Pointer(&sliceHeader))
	fmt.Printf("   Unsafe conversion: %v\n", unsafeBytes)
	fmt.Printf("   ⚠️  Warning: Don't modify this slice!\n\n")

// Example 3: Byte slice to string (zero-copy)
	fmt.Println("3. []byte to string (zero-copy):")
	bytes := []byte("Unsafe string")

// Normal conversion (copies)
	normalStr := string(bytes)
	fmt.Printf("   Normal: %s\n", normalStr)

// Unsafe conversion (no copy)
	sliceHdr := (*SliceHeader)(unsafe.Pointer(&bytes))
	strHdr := StringHeader{
		Data: sliceHdr.Data,
		Len:  sliceHdr.Len,
	}
	unsafeStr := *(*string)(unsafe.Pointer(&strHdr))
	fmt.Printf("   Unsafe: %s\n", unsafeStr)
	fmt.Printf("   ⚠️  Warning: Slice must not be modified!\n\n")

// Example 4: Interface to concrete type
	fmt.Println("4. Interface to concrete type:")
	var i interface{} = int64(42)

// Type assertion (safe)
	if val, ok := i.(int64); ok {
		fmt.Printf("   Type assertion: %d\n", val)
	}

// Unsafe conversion (bypasses type check)
	type iface struct {
		typ  uintptr
		data unsafe.Pointer
	}
	ifacePtr := (*iface)(unsafe.Pointer(&i))
	unsafeVal := *(*int64)(ifacePtr.data)
	fmt.Printf("   Unsafe conversion: %d\n", unsafeVal)
	fmt.Printf("   ⚠️  Warning: No type safety!\n\n")

// Example 5: Struct field access by offset
	fmt.Println("5. Struct field access by offset:")
	type Person struct {
		Name string
		Age  int
		City string
	}

p := Person{"Alice", 30, "NYC"}
	fmt.Printf("   Person: %+v\n", p)

// Access Age field by offset
	ageOffset := unsafe.Offsetof(p.Age)
	agePtr := (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&p)) + ageOffset))
	fmt.Printf("   Age via offset: %d\n", *agePtr)

// Modify via pointer
	*agePtr = 31
	fmt.Printf("   Modified: %+v\n\n", p)

fmt.Println("Conversion Safety Rules:")
	fmt.Println("  ✓ Only convert when you know exact memory layout")
	fmt.Println("  ✓ Never modify string bytes")
	fmt.Println("  ✓ Be careful with slice/string zero-copy")
	fmt.Println("  ✓ Understand alignment requirements")
	fmt.Println("  ✓ Test thoroughly on target platforms")
}

Output

Click Run to execute your code

Zero-Copy Conversions:

String ↔ []byte without copying
Reinterpret bits (float ↔ int)
Struct type conversions
Interface to concrete type

Memory Operations

Direct memory manipulation for layout and performance:

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	fmt.Println("Unsafe Memory Operations")
	fmt.Println("=========================\n")

// Example 1: Memory size and alignment
	fmt.Println("1. Size and alignment:")

var b bool
	var i8 int8
	var i16 int16
	var i32 int32
	var i64 int64
	var f32 float32
	var f64 float64
	var ptr *int

fmt.Printf("   bool:    size=%d align=%d\n", unsafe.Sizeof(b), unsafe.Alignof(b))
	fmt.Printf("   int8:    size=%d align=%d\n", unsafe.Sizeof(i8), unsafe.Alignof(i8))
	fmt.Printf("   int16:   size=%d align=%d\n", unsafe.Sizeof(i16), unsafe.Alignof(i16))
	fmt.Printf("   int32:   size=%d align=%d\n", unsafe.Sizeof(i32), unsafe.Alignof(i32))
	fmt.Printf("   int64:   size=%d align=%d\n", unsafe.Sizeof(i64), unsafe.Alignof(i64))
	fmt.Printf("   float32: size=%d align=%d\n", unsafe.Sizeof(f32), unsafe.Alignof(f32))
	fmt.Printf("   float64: size=%d align=%d\n", unsafe.Sizeof(f64), unsafe.Alignof(f64))
	fmt.Printf("   pointer: size=%d align=%d\n\n", unsafe.Sizeof(ptr), unsafe.Alignof(ptr))

// Example 2: Struct layout and padding
	fmt.Println("2. Struct layout and padding:")

type BadLayout struct {
		a bool  // 1 byte
		b int64 // 8 bytes (7 bytes padding before)
		c bool  // 1 byte (7 bytes padding after)
	}

type GoodLayout struct {
		b int64 // 8 bytes
		a bool  // 1 byte
		c bool  // 1 byte (6 bytes padding after)
	}

bad := BadLayout{}
	good := GoodLayout{}

fmt.Printf("   BadLayout:  size=%d\n", unsafe.Sizeof(bad))
	fmt.Printf("   GoodLayout: size=%d\n", unsafe.Sizeof(good))
	fmt.Printf("   Savings: %d bytes\n\n", unsafe.Sizeof(bad)-unsafe.Sizeof(good))

// Example 3: Direct memory manipulation
	fmt.Println("3. Direct memory write:")

var x int64 = 0
	fmt.Printf("   Before: %d\n", x)

// Write directly to memory
	ptr := unsafe.Pointer(&x)
	*(*int64)(ptr) = 42
	fmt.Printf("   After:  %d\n\n", x)

// Example 4: Array to slice conversion
	fmt.Println("4. Array to slice (zero-copy):")

arr := [5]int{1, 2, 3, 4, 5}
	fmt.Printf("   Array: %v\n", arr)

// Normal conversion (copies)
	normalSlice := arr[:]
	fmt.Printf("   Normal slice: %v\n", normalSlice)

// Unsafe conversion (no copy, shares memory)
	type SliceHeader struct {
		Data uintptr
		Len  int
		Cap  int
	}

sliceHeader := SliceHeader{
		Data: uintptr(unsafe.Pointer(&arr[0])),
		Len:  len(arr),
		Cap:  len(arr),
	}
	unsafeSlice := *(*[]int)(unsafe.Pointer(&sliceHeader))
	fmt.Printf("   Unsafe slice: %v\n", unsafeSlice)

// Modify through unsafe slice
	unsafeSlice[0] = 99
	fmt.Printf("   Array after modify: %v\n\n", arr)

// Example 5: Memory clearing
	fmt.Println("5. Fast memory clearing:")

data := make([]byte, 1000)
	for i := range data {
		data[i] = byte(i % 256)
	}
	fmt.Printf("   First 10 bytes before: %v\n", data[:10])

// Clear using unsafe (faster for large slices)
	if len(data) > 0 {
		ptr := unsafe.Pointer(&data[0])
		for i := 0; i < len(data); i++ {
			*(*byte)(unsafe.Pointer(uintptr(ptr) + uintptr(i))) = 0
		}
	}
	fmt.Printf("   First 10 bytes after:  %v\n\n", data[:10])

fmt.Println("Memory Safety Rules:")
	fmt.Println("  ⚠️  Pointer arithmetic is dangerous")
	fmt.Println("  ⚠️  Respect alignment requirements")
	fmt.Println("  ⚠️  Don't create invalid pointers")
	fmt.Println("  ⚠️  GC doesn't track unsafe pointers")
	fmt.Println("  ⚠️  Can cause data races")
	fmt.Println("  ⚠️  Platform-dependent behavior")
}

Output

Click Run to execute your code

Type	Size (bytes)	Alignment
bool	1	1
int8, uint8	1	1
int16, uint16	2	2
int32, uint32, float32	4	4
int64, uint64, float64	8	8
pointer	8 (64-bit)	8

Struct Field Access

Access struct fields by offset for optimization:

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	fmt.Println("Unsafe Struct Operations")
	fmt.Println("=========================\n")

// Example 1: Field offsets
	fmt.Println("1. Struct field offsets:")

type Person struct {
		Name   string
		Age    int
		Height float64
		Active bool
	}

p := Person{}

fmt.Printf("   Struct size: %d bytes\n", unsafe.Sizeof(p))
	fmt.Printf("   Name offset:   %d\n", unsafe.Offsetof(p.Name))
	fmt.Printf("   Age offset:    %d\n", unsafe.Offsetof(p.Age))
	fmt.Printf("   Height offset: %d\n", unsafe.Offsetof(p.Height))
	fmt.Printf("   Active offset: %d\n\n", unsafe.Offsetof(p.Active))

// Example 2: Direct field access by offset
	fmt.Println("2. Access fields by offset:")

person := Person{
		Name:   "Alice",
		Age:    30,
		Height: 5.6,
		Active: true,
	}

fmt.Printf("   Original: %+v\n", person)

// Access Age field using offset
	basePtr := unsafe.Pointer(&person)
	ageOffset := unsafe.Offsetof(person.Age)
	agePtr := (*int)(unsafe.Pointer(uintptr(basePtr) + ageOffset))

fmt.Printf("   Age via offset: %d\n", *agePtr)

// Modify via pointer
	*agePtr = 31
	fmt.Printf("   Modified: %+v\n\n", person)

// Example 3: Struct field iteration
	fmt.Println("3. Iterate struct fields (conceptual):")

type Point struct {
		X int
		Y int
		Z int
	}

pt := Point{10, 20, 30}
	fmt.Printf("   Point: %+v\n", pt)

// Access each int field
	ptPtr := unsafe.Pointer(&pt)
	for i := 0; i < 3; i++ {
		fieldPtr := (*int)(unsafe.Pointer(uintptr(ptPtr) + uintptr(i)*unsafe.Sizeof(pt.X)))
		fmt.Printf("   Field %d: %d\n", i, *fieldPtr)
	}
	fmt.Println()

// Example 4: Packed vs unpacked structs
	fmt.Println("4. Struct packing:")

type Unpacked struct {
		a bool  // 1 byte + 7 padding
		b int64 // 8 bytes
		c bool  // 1 byte + 7 padding
		d int64 // 8 bytes
	}

type Packed struct {
		b int64 // 8 bytes
		d int64 // 8 bytes
		a bool  // 1 byte
		c bool  // 1 byte + 6 padding
	}

fmt.Printf("   Unpacked size: %d bytes\n", unsafe.Sizeof(Unpacked{}))
	fmt.Printf("   Packed size:   %d bytes\n", unsafe.Sizeof(Packed{}))
	fmt.Printf("   Space saved:   %d bytes\n\n",
		unsafe.Sizeof(Unpacked{})-unsafe.Sizeof(Packed{}))

// Example 5: Embedding and offsets
	fmt.Println("5. Embedded struct offsets:")

type Address struct {
		Street string
		City   string
	}

type Employee struct {
		Name    string
		Address // Embedded
		Salary  int
	}

emp := Employee{}

fmt.Printf("   Employee size: %d bytes\n", unsafe.Sizeof(emp))
	fmt.Printf("   Name offset:    %d\n", unsafe.Offsetof(emp.Name))
	fmt.Printf("   Address offset: %d\n", unsafe.Offsetof(emp.Address))
	fmt.Printf("   Street offset:  %d\n", unsafe.Offsetof(emp.Street))
	fmt.Printf("   City offset:    %d\n", unsafe.Offsetof(emp.City))
	fmt.Printf("   Salary offset:  %d\n\n", unsafe.Offsetof(emp.Salary))

// Example 6: Zero-copy struct conversion
	fmt.Println("6. Struct type conversion:")

type Point2D struct {
		X float64
		Y float64
	}

type Vector2D struct {
		X float64
		Y float64
	}

point := Point2D{3.0, 4.0}
	fmt.Printf("   Point2D: %+v\n", point)

// Convert to Vector2D (same layout)
	vectorPtr := (*Vector2D)(unsafe.Pointer(&point))
	fmt.Printf("   As Vector2D: %+v\n", *vectorPtr)
	fmt.Printf("   ⚠️  Only safe if layouts match exactly!\n\n")

fmt.Println("Struct Safety Rules:")
	fmt.Println("  ✓ Use Offsetof() for field access")
	fmt.Println("  ✓ Understand struct padding")
	fmt.Println("  ✓ Order fields by size (largest first)")
	fmt.Println("  ✓ Be careful with embedded structs")
	fmt.Println("  ✓ Only convert structs with identical layouts")
	fmt.Println("  ✓ Alignment matters!")
}

Output

Click Run to execute your code

Struct Packing Tips:

Order fields by size (largest first)
Group related fields together
Use Sizeof() to check total size
Use Offsetof() to verify layout
Consider cache line alignment (64 bytes)

Performance Optimization

Benchmark unsafe vs safe operations:

package main

import (
	"fmt"
	"time"
	"unsafe"
)

// StringHeader represents string internal structure
type StringHeader struct {
	Data uintptr
	Len  int
}

// SliceHeader represents slice internal structure
type SliceHeader struct {
	Data uintptr
	Len  int
	Cap  int
}

// Safe string to bytes conversion (copies)
func safeStringToBytes(s string) []byte {
	return []byte(s)
}

// Unsafe string to bytes conversion (zero-copy)
func unsafeStringToBytes(s string) []byte {
	strHeader := (*StringHeader)(unsafe.Pointer(&s))
	sliceHeader := SliceHeader{
		Data: strHeader.Data,
		Len:  strHeader.Len,
		Cap:  strHeader.Len,
	}
	return *(*[]byte)(unsafe.Pointer(&sliceHeader))
}

// Safe bytes to string conversion (copies)
func safeBytesToString(b []byte) string {
	return string(b)
}

// Unsafe bytes to string conversion (zero-copy)
func unsafeBytesToString(b []byte) string {
	sliceHeader := (*SliceHeader)(unsafe.Pointer(&b))
	strHeader := StringHeader{
		Data: sliceHeader.Data,
		Len:  sliceHeader.Len,
	}
	return *(*string)(unsafe.Pointer(&strHeader))
}

func main() {
	fmt.Println("Unsafe Performance Comparisons")
	fmt.Println("===============================\n")

// Benchmark 1: String to bytes conversion
	fmt.Println("1. String to []byte conversion:")
	testStr := "Hello, World! This is a test string for performance comparison."
	iterations := 10000000

// Safe version
	start := time.Now()
	for i := 0; i < iterations; i++ {
		_ = safeStringToBytes(testStr)
	}
	safeDuration := time.Since(start)

// Unsafe version
	start = time.Now()
	for i := 0; i < iterations; i++ {
		_ = unsafeStringToBytes(testStr)
	}
	unsafeDuration := time.Since(start)

fmt.Printf("   Safe:   %v\n", safeDuration)
	fmt.Printf("   Unsafe: %v\n", unsafeDuration)
	fmt.Printf("   Speedup: %.2fx\n\n", float64(safeDuration)/float64(unsafeDuration))

// Benchmark 2: Bytes to string conversion
	fmt.Println("2. []byte to string conversion:")
	testBytes := []byte("Hello, World! This is a test string for performance comparison.")

// Safe version
	start = time.Now()
	for i := 0; i < iterations; i++ {
		_ = safeBytesToString(testBytes)
	}
	safeDuration = time.Since(start)

// Unsafe version
	start = time.Now()
	for i := 0; i < iterations; i++ {
		_ = unsafeBytesToString(testBytes)
	}
	unsafeDuration = time.Since(start)

fmt.Printf("   Safe:   %v\n", safeDuration)
	fmt.Printf("   Unsafe: %v\n", unsafeDuration)
	fmt.Printf("   Speedup: %.2fx\n\n", float64(safeDuration)/float64(unsafeDuration))

// Benchmark 3: Struct field access
	fmt.Println("3. Struct field access:")

type Data struct {
		A int
		B int
		C int
		D int
	}

data := Data{1, 2, 3, 4}
	sum := 0

// Normal access
	start = time.Now()
	for i := 0; i < iterations; i++ {
		sum = data.A + data.B + data.C + data.D
	}
	normalDuration := time.Since(start)

// Unsafe access
	start = time.Now()
	basePtr := unsafe.Pointer(&data)
	for i := 0; i < iterations; i++ {
		sum = *(*int)(basePtr) +
			*(*int)(unsafe.Pointer(uintptr(basePtr) + unsafe.Sizeof(data.A))) +
			*(*int)(unsafe.Pointer(uintptr(basePtr) + 2*unsafe.Sizeof(data.A))) +
			*(*int)(unsafe.Pointer(uintptr(basePtr) + 3*unsafe.Sizeof(data.A)))
	}
	unsafeDuration = time.Since(start)

fmt.Printf("   Normal: %v (sum=%d)\n", normalDuration, sum)
	fmt.Printf("   Unsafe: %v (sum=%d)\n", unsafeDuration, sum)
	fmt.Printf("   Difference: %.2fx\n\n", float64(normalDuration)/float64(unsafeDuration))

// Memory usage comparison
	fmt.Println("4. Memory usage:")

type LargeStruct struct {
		Data [1000]byte
	}

// Safe copy
	original := LargeStruct{}
	copy := original

// Unsafe pointer (no copy)
	ptr := &original

fmt.Printf("   Original size: %d bytes\n", unsafe.Sizeof(original))
	fmt.Printf("   Copy size:     %d bytes (duplicated)\n", unsafe.Sizeof(copy))
	fmt.Printf("   Pointer size:  %d bytes (no duplication)\n", unsafe.Sizeof(ptr))
	fmt.Printf("   Memory saved:  %d bytes\n\n", unsafe.Sizeof(copy)-unsafe.Sizeof(ptr))

fmt.Println("Performance Guidelines:")
	fmt.Println("  ✓ Unsafe is faster but dangerous")
	fmt.Println("  ✓ Use for hot paths only")
	fmt.Println("  ✓ Profile before optimizing")
	fmt.Println("  ✓ Measure actual gains")
	fmt.Println("  ✓ Consider maintainability cost")
	fmt.Println("  ✓ Document unsafe code clearly")

fmt.Println("\nWhen to use unsafe:")
	fmt.Println("  • Zero-copy string/byte conversions")
	fmt.Println("  • Low-level system programming")
	fmt.Println("  • Performance-critical code")
	fmt.Println("  • Interop with C libraries")

fmt.Println("\nWhen NOT to use unsafe:")
	fmt.Println("  • Regular application code")
	fmt.Println("  • When safe alternatives exist")
	fmt.Println("  • Without thorough testing")
	fmt.Println("  • In public APIs")
}

Output

Click Run to execute your code

When to Use Unsafe:

✓ Zero-copy string/byte conversions in hot paths
✓ Low-level system programming
✓ Interfacing with C libraries
✓ Performance-critical code (after profiling)
✓ Implementing data structures

When NOT to Use Unsafe:

❌ Regular application code
❌ Without profiling first
❌ In public APIs
❌ When safe alternatives exist
❌ Without thorough testing

Common Mistakes

1. Storing uintptr instead of unsafe.Pointer

// ❌ Wrong - GC won't track uintptr
type Bad struct {
    ptr uintptr // Can become invalid!
}

// ✅ Correct - GC tracks unsafe.Pointer
type Good struct {
    ptr unsafe.Pointer
}

2. Modifying string bytes

// ❌ Wrong - strings are immutable
s := "hello"
bytes := *(*[]byte)(unsafe.Pointer(&s))
bytes[0] = 'H' // Undefined behavior!

// ✅ Correct - create new string
bytes := []byte(s)
bytes[0] = 'H'
s = string(bytes)

3. Ignoring alignment requirements

// ❌ Wrong - may cause crash on some platforms
bytes := []byte{1, 2, 3, 4, 5, 6, 7, 8}
ptr := (*int64)(unsafe.Pointer(&bytes[1])) // Misaligned!

// ✅ Correct - ensure proper alignment
ptr := (*int64)(unsafe.Pointer(&bytes[0])) // Aligned

Exercise: Zero-Copy String Builder

Task: Build a string builder using unsafe for zero-copy operations.

Requirements:

Append strings without copying
Convert to final string efficiently
Handle edge cases safely
Benchmark against strings.Builder

Show Solution

package main

import (
    "fmt"
    "strings"
    "time"
    "unsafe"
)

// StringHeader for unsafe string operations
type StringHeader struct {
    Data uintptr
    Len  int
}

// SliceHeader for unsafe slice operations
type SliceHeader struct {
    Data uintptr
    Len  int
    Cap  int
}

// UnsafeBuilder builds strings using unsafe operations
type UnsafeBuilder struct {
    buf []byte
}

// NewUnsafeBuilder creates a new builder
func NewUnsafeBuilder(capacity int) *UnsafeBuilder {
    return &UnsafeBuilder{
        buf: make([]byte, 0, capacity),
    }
}

// Append adds a string without copying
func (b *UnsafeBuilder) Append(s string) {
    // Convert string to []byte without copying
    strHeader := (*StringHeader)(unsafe.Pointer(&s))
    bytes := *(*[]byte)(unsafe.Pointer(&SliceHeader{
        Data: strHeader.Data,
        Len:  strHeader.Len,
        Cap:  strHeader.Len,
    }))
    
    // Append to buffer
    b.buf = append(b.buf, bytes...)
}

// String returns the final string
func (b *UnsafeBuilder) String() string {
    // Convert []byte to string without copying
    sliceHeader := (*SliceHeader)(unsafe.Pointer(&b.buf))
    return *(*string)(unsafe.Pointer(&StringHeader{
        Data: sliceHeader.Data,
        Len:  sliceHeader.Len,
    }))
}

func main() {
    // Test correctness
    fmt.Println("Testing UnsafeBuilder:")
    builder := NewUnsafeBuilder(100)
    builder.Append("Hello, ")
    builder.Append("unsafe ")
    builder.Append("world!")
    result := builder.String()
    fmt.Printf("Result: %s\n\n", result)
    
    // Benchmark
    iterations := 100000
    parts := []string{"Hello, ", "this ", "is ", "a ", "test!"}
    
    // strings.Builder
    start := time.Now()
    for i := 0; i < iterations; i++ {
        var sb strings.Builder
        for _, p := range parts {
            sb.WriteString(p)
        }
        _ = sb.String()
    }
    safeDuration := time.Since(start)
    
    // UnsafeBuilder
    start = time.Now()
    for i := 0; i < iterations; i++ {
        ub := NewUnsafeBuilder(50)
        for _, p := range parts {
            ub.Append(p)
        }
        _ = ub.String()
    }
    unsafeDuration := time.Since(start)
    
    fmt.Println("Benchmark results:")
    fmt.Printf("strings.Builder: %v\n", safeDuration)
    fmt.Printf("UnsafeBuilder:   %v\n", unsafeDuration)
    fmt.Printf("Speedup:         %.2fx\n", float64(safeDuration)/float64(unsafeDuration))
}

Summary

unsafe package bypasses Go's type safety
Sizeof() returns size in bytes
Alignof() returns alignment requirement
Offsetof() returns field offset in struct
unsafe.Pointer is a generic pointer type
uintptr for pointer arithmetic (temporary only)
Zero-copy conversions possible
Struct packing reduces memory usage
Performance gains in critical paths
Use sparingly and document thoroughly

What's Next?

You've learned the unsafe package! While powerful, remember that with great power comes great responsibility. Next, you'll explore compiler and linker flags to optimize your Go builds, control compilation, and fine-tune performance.