Odin: A Practical Guide to Low-Level Programming

Design, Build and Optimize Systems Software in Odin

Introduction

1. What This Book Is
2. What This Book Is Not
3. Who This Book Is For
4. Prerequisites
5. How to Read This Book
6. Technical Conventions
7. Acknowledging the Ecosystem
8. What You Will Know After This Book

Chapter 1: Why Odin? The Design Philosophy

1. The State of Systems Programming in 2026
2. What Odin Is and Is Not
3. Data-Oriented Design as First-Class Concern
4. The Pragmatist’s Manifesto: Simplicity Over Power
5. Comparison Landscape: C, C++, Rust, Go, Zig
6. The Odin Promise

Chapter 2: Setting Up the Development Environment

1. Installing the Odin Compiler
2. Building from Source
3. Your First Program: Hellope World
4. The odin Command: Build, Run, Test, Check
5. Editor and Language Server Setup with OLS
6. Project Structure and Collections
7. Verifying Your Setup

Chapter 3: Language Fundamentals: Declarations, Types and Values

1. Statements, Expressions and Automatic Semicolon Insertion
2. Variables: Declaration, Initialization and Zeroing
3. Constants and Compile-Time Expressions
4. Primitive Types: Integers, Floats, Booleans, Runes
5. Distinct Types vs Aliases: Type Identity Matters
6. Literals: Numbers, Strings and the Underscore Convention
7. Summary

Chapter 4: Procedures: Functions with Intent

1. Declaring and Calling Procedures
2. Parameters, Named Results and Multiple Return Values
3. Calling Conventions: odin, c, contextless and Beyond
4. Variadic Procedures and Type Safety
5. Defer and Scope-Guaranteed Cleanup
6. Tail Calls and Recursion
7. Summary

Chapter 5: Control Flow Without Hidden Complexity

1. Range-Based For Loops
2. If Statements and Ternary Expressions
3. Switch: Exhaustive, No Fallthrough, Pattern-Match-Free
4. The or Family: or_return, or_else, or_break, or_continue
5. The When Statement: Compile-Time Branching
6. Why No Goto and No Exceptions
7. Summary

Chapter 6: Composite Types: Structs, Unions, Enums and Bit Sets

1. Structs: Layout, Alignment, Padding and #packed
2. Unions and #raw_union: Tagged vs Untagged
3. Enums and Enumerated Arrays
4. Bit Sets: Type-Safe Flag Management
5. Fields, Tags and the Using Statement
6. Aggregate Initialization and Partial Initialization
7. Summary

Chapter 7: Memory Layout: From Bytes to Caches

1. How the Compiler Lays Out Types
2. Alignment, Packing and ABI Requirements
3. Measuring Size and Offset with sizeof and alignof
4. Cache Lines, Prefetching and Data Locality
5. Struct Layout Optimization Techniques
6. Matching C Layouts: Foreign Interop and Hardware Formats
7. Summary

Chapter 8: Arrays, Slices and Dynamic Arrays

1. Fixed Arrays: Stack-Bound and Sized
2. Slices: Pointers with Length
3. Dynamic Arrays: Growth, Allocation and Ownership
4. Slice Operations: Append, Delete and Copy
5. Array Arithmetic and Component-Wise Operations
6. When to Use Each Array Type
7. Summary

Chapter 9: Maps and String Handling

1. The Map Type: Hash Table Semantics
2. Map Keys: What Is Allowed
3. Strings as Pointer Plus Length
4. UTF-8, Runes and Character Encoding
5. C Strings and Interop with External APIs
6. String Interning and Pooling
7. Summary

Chapter 10: Pointers, Memory Addresses and Ownership

1. Single Pointers: ^T Semantics
2. Multi-Pointers: [^]T for Typed Untyped-Length Access
3. Rawptr and Type Erasure
4. Pointer Arithmetic and Unsafe Access
5. Memory Ownership: The Programmer’s Responsibility
6. Common Pointer Mistakes and Corruption Patterns
7. Summary

Chapter 11: The Context System and Memory Allocators

1. What the Context Is and How It Flows
2. Context Fields: Allocators, Logger, RNG and More
3. new, make, free and delete
4. The Temporary Allocator: Arena-Style Allocation
5. Tracking Allocator: Debugging Memory Issues
6. Custom Allocators and Context Overrides
7. Summary

Chapter 12: Parametric Polymorphism: Generic Procedures and Types

1. Explicit vs Implicit Parametric Polymorphism
2. Where Clauses and Type Constraints
3. Parametric Structs: Generic Data Structures
4. Type Inference and Its Limits
5. Type-Specific Code Paths (No Overloading)
6. Comparison with Rust Traits and C++ Templates
7. Summary

Chapter 13: Data-Oriented Design with Odin

1. What Data-Oriented Design Means
2. AoS vs SoA vs AoSoA: Memory Layouts for Performance
3. The #soa Modifier: Odin’s Struct of Arrays
4. SIMD Vectors: Native Support and Swizzling
5. Matrix and Quaternion Types
6. Designing Cache-Friendly Data Structures
7. Summary

Chapter 14: Error Handling: Explicit by Design

1. Why No Exceptions: Design Rationale
2. Multiple Return Values for Success and Error
3. The or_return Pattern
4. Custom Error Types and Discriminated Unions
5. Error Propagation Strategies
6. Comparison with Go and Rust Approaches
7. Summary

Chapter 15: Packages and the Module System

1. Packages: Directories as Units of Compilation
2. Import Names and Aliases
3. Visibility: @(private), #+private and Export Control
4. Core, Vendor and User Collections
5. Foreign Import and Foreign Blocks
6. Structuring Large Projects
7. Summary

Chapter 16: Foreign Function Interface: Calling C and the OS

1. Foreign Import: Linking to Libraries
2. Foreign Blocks: Declaring External Symbols
3. Type Mapping: Odin Types to C Types
4. Calling Conventions and ABI Details
5. String Interop: string vs cstring
6. Working with System Libraries: Windows, POSIX, macOS
7. Summary

Chapter 17: File I/O, Networking and the Operating System

1. The New core:os v2: Design and API
2. File Operations: Open, Read, Write, Seek
3. Paths, Directories and Environment
4. Networking with core:net: Sockets and DNS
5. Non-Blocking I/O with core:nbio
6. Resource Lifetimes and Cleanup
7. Summary

Chapter 18: Concurrency and Threading

1. Threads and the Operating System
2. Creating and Managing Threads
3. Thread Pools and Task Queues
4. Mutexes, Read-Write Locks and Semaphores
5. Atomic Operations and Lock-Free Programming
6. Context in a Multi-Threaded World
7. Summary

Chapter 19: Runtime Type Information and Reflection

1. Typeid: Runtime Type Identifiers
2. The Reflect Package: Inspecting Types
3. Field Tags and Metadata
4. Any Type and Type Erasure
5. Use Cases: Serialization, Debugging and Tooling
6. The Cost of RTTI
7. Summary

Chapter 20: Inline Assembly and Intrinsics

1. Intrinsics: Compiler-Hinted Operations
2. SIMD Operations in core:simd
3. The New Inline Asm Template System
4. Writing Portable Assembly
5. When to Use Assembly vs High-Level Code
6. Profiling Assembly Output
7. Summary

Chapter 21: Project 1 - A Command-Line Binary File Parser

1. Requirements and Design Decisions
2. Defining the File Format with Odin Types
3. Parsing Logic and Error Handling
4. Command-Line Argument Processing with core:flags
5. Testing with Synthetic Input Files
6. Packaging and Distribution
7. Summary

Chapter 22: Project 2 - A Custom Memory Allocator

1. Allocator Requirements and Interface
2. Implementing an Arena Allocator
3. Implementing a Pool Allocator for Fixed-Size Objects
4. Integration with the Context System
5. Performance Measurement and Comparison
6. Debugging and Validation
7. Summary

Chapter 23: Project 3 - A Data-Oriented Physics Simulation

1. Simulation Requirements and Data Model
2. Implementing SoA Particle Storage
3. SIMD-Accelerated Force Calculations
4. Fixed Time-Step Integration Loop
5. Performance Analysis and Optimization
6. Visualization Options
7. Summary

Chapter 24: Project 4 - A Multithreaded Job System

1. Design Requirements and Threat Model
2. Thread Pool Implementation
3. Work Queue and Scheduling
4. Thread-Local Storage and Context Management
5. Synchronization and Correctness Guarantees
6. Testing for Races and Deadlocks
7. Summary

Chapter 25: Project 5 - A TCP Networking Service

1. Service Requirements and Architecture
2. Socket Programming with core:net
3. Connection Handling and Event Loop
4. Handling Multiple Concurrent Connections
5. Protocol Design and Message Framing
6. Resource Management and Graceful Shutdown
7. Security Considerations
8. Performance and Scaling
9. Summary

Chapter 26: Build Systems, Optimization and Tooling

1. The Odin Build System
2. Performance Optimization
3. Profiling Tools
4. Debugging
5. Production Deployment
6. Summary

Chapter 27: Testing, Debugging and Quality Assurance

1. Odin’s Built-in Testing Framework
2. Property-Based Testing
3. Testing Patterns and Best Practices
4. Advanced Debugging Techniques
5. Static Analysis and Code Quality
6. Continuous Quality
7. Summary

Conclusion

1. What Makes Odin Unique
2. Skills You Gained
3. Next Steps
4. The Future of Odin
5. Final Thoughts

Appendix A: Language Quick Reference

1. Literals
2. Types
3. Procedures
4. Control Flow
5. Operators
6. Memory
7. Meta Operators
8. Attributes

Appendix B: Compiler and Tool Reference

1. odin build
2. odinfmt
3. Odin Language Server (OLS)
4. Testing
5. Useful Commands

Glossary

References