Why Choose odin-lang?

TL;DR

Odin is a modern systems programming language designed as a practical replacement for C. It keeps what makes C powerful manual memory management, predictable data layouts, no hidden runtime, and close-to-the-metal control while removing many of the historical pain points. There are no header/source splits, no textual include system, no preprocessor macros, fewer implicit conversions, clearer type semantics, built-in testing, and a simpler compilation model. It also avoids the complexity explosion of C++ by deliberately leaving out features like operator overloading, template metaprogramming, exceptions, and large abstraction frameworks.

On top of that, Odin ships with a solid standard library and practical vendor bindings for real-world systems work: graphics APIs, windowing libraries, audio, networking, physics, compression, scripting, and more. It doesn’t try to be everything for everyone. It doesn’t come with a massive ecosystem or a package manager-driven workflow. It’s intentionally small, explicit, and focused. If you want control without fighting 1970s design decisions and without inheriting C++’s cathedral of complexity Odin is worth a serious look.

Problems with C

What is bad about C though?

What Odin solves compared to C:

• No header/source split
• Real module system (no textual includes)
• No preprocessor macros
• Stronger type system (distinct types, strong enums)
• Built-in dynamic arrays and maps
• defer for cleanup
• Multiple return values
• Clearer pointer and slice semantics
• Fewer implicit conversions
• No strict-aliasing traps
• Better compile-time features (without macros)
• Faster, simpler full-program compilation
• Built-in testing support
• Explicit over implicit design philosophy
• Smaller mental surface area than C++

What Odin Deliberately Does Not Have

• No garbage collector
• No hidden runtime
• No exceptions
• No RAII or destructor system
• No operator overloading
• No implicit overloading
• No template metaprogramming
• No classes or inheritance hierarchy
• No macro preprocessor
• No built-in package manager
• No versioned dependency resolver
• No cargo-style ecosystem
• No build system DSL

Overloading exists, but only through explicit overload sets that you define manually.

Included Libraries (Practical Value)

• Cross-platform OS abstraction layer
• Built-in allocator system (general, arena, pool, etc.)
• String and UTF-8 utilities
• File I/O and filesystem helpers
• Time and date utilities
• Logging and formatting library
• JSON encoder / decoder
• Command-line parsing helpers
• Math library (vectors, matrices, etc.)
• SIMD support
• Reflection / runtime type info
• Plus a lot more…

Core libraries

Core I/O and Utilities

bufio, bytes, io, log, fmt, strconv, strings, slice, sort, heap
Low-level building blocks for buffered I/O, formatting, string manipulation, parsing, and common data handling. These are the day-to-day tools for writing CLI tools, servers, and engine utilities.

Containers and Data Structures

container (avl, rbtree, queue, priority_queue, small_array, pool, etc.), table A collection of fundamental data structures implemented in a systems-oriented way. Designed for performance and control rather than abstraction-heavy convenience.

Compression and Archiving

compress (gzip, zlib, shoco), xar
Compression algorithms and archive helpers for working with packed data formats. Useful for tooling, asset pipelines, and network transfer.

Cryptography

crypto (aes, chacha20, sha2, sha3, ed25519, x25519, hkdf, hmac, etc.)
A broad set of modern cryptographic primitives and hash functions. Suitable for secure networking, authentication, and data integrity tasks.

Encoding and Serialization

encoding (json, cbor, csv, xml, base64, uuid, varint, ini, etc.)
Parsers and encoders for common data formats and text encodings. Lets you move structured data in and out of programs without external dependencies.

Image Processing

image (bmp, jpeg, png, tga, qoi, netpbm)
Image loading and writing support for common formats. Useful for tools, asset conversion, and lightweight graphics pipelines.

Math and Numerics

math (big, bits, cmplx, fixed, linalg, noise, rand)
Core numeric utilities, linear algebra, random number generation, and noise functions. Intended for simulations, graphics, and game logic.

Memory Management

mem (tlsf, virtual)
Low-level memory utilities and allocators. Gives fine-grained control over allocation strategies for engines and performance-critical systems.

Networking and Async I/O

net, nbio, netpbm, tls
Networking primitives and non-blocking I/O support. Designed for building servers, tools, and multiplayer systems.

Operating System Interfaces

os, path, filepath, slashpath, sys (windows, linux, darwin, posix, etc.)
Cross-platform OS abstractions plus direct platform bindings. Lets you write portable systems code while still accessing native APIs.

Reflection and Metaprogramming

reflect, ast, parser, tokenizer, doc-format
Tools for inspecting types and working with Odin source code itself. Useful for tooling, code generation, and analysis.

Concurrency and Synchronization

sync, chan, thread Primitives for threading, channels, and synchronization. Supports explicit concurrency without hidden runtime systems.

Text and Unicode

text (edit, i18n, match), unicode, utf8, utf16, regex
Unicode handling, text processing, and regular expressions. Designed for correctness in modern UTF-aware systems.

Terminal and Debugging

terminal (ansi), debug (trace, pe), prof (spall), valgrind
Debugging, profiling, and terminal control utilities. Useful for tool developers and performance tuning.

Testing

Built-in testing support integrated with the language toolchain.

Compiler and Tooling Internals

odin (ast, parser, tokenizer), info
Internal packages used by the Odin compiler and tooling ecosystem. Exposed for advanced tooling and language-level experimentation.

Vendor Bindings Included in the repo

Physics

box2d – 2D rigid body physics engine.

Graphics / Rendering

OpenGL (gl) – Cross-platform graphics API.
vulkan – Low-level explicit graphics API.
wgpu – Modern GPU abstraction layer.
directx – Windows graphics umbrella bindings.
d3d11 – Direct3D 11 API.
d3d12 – Direct3D 12 API.
d3d_compiler – HLSL shader compiler interface.
dxc – Modern DirectX shader compiler.
dxgi – Swapchain and adapter interface.
Metal – Apple low-level GPU API.
MetalKit – Helper framework for Metal.
QuartzCore – Apple rendering layer framework.
CoreVideo – Apple video/timing framework.
OpenEXRCore – HDR image format support.

Windowing / Platform

glfw – Cross-platform windowing and input.
sdl2 – Multimedia and input library.
sdl3 – Next-generation SDL.
x11 – Linux X Window System bindings.
xlib – X11 C interface bindings.
windows – Win32 API bindings.
darwin – macOS system bindings.

Audio

miniaudio – Lightweight audio playback/recording.
portmidi – MIDI I/O support.
XAudio2 – Windows audio engine.
vorbis – Ogg Vorbis audio decoding.
mixer (SDL2) – SDL audio mixing extension.

Networking

ENet – Reliable UDP networking.
net (SDL2) – SDL networking helpers.
curl – HTTP and network transfer library.
ggpo – Rollback networking for games.

UI / 2D

nanovg – Immediate mode 2D vector renderer.
microui – Minimal immediate-mode GUI.
fontstash – Lightweight font rendering.
kb_text_shape – Text shaping utilities.

Scripting

lua (5.4) – Embedded Lua scripting language.

Compression

zlib – General-purpose compression.
lz4 – Fast compression algorithm.
compress – Compression helpers.

Text / Markdown

commonmark – Markdown parser implementation.

3D Assets

cgltf – Lightweight glTF model loader.

Images / Fonts (stb + SDL)

stb_easy_font – Simple debug font rendering.
stb_image – Image loading.
stb_rect_pack – Rectangle packing utility.
stb_truetype – TrueType font parsing.
image (SDL2) – SDL image extension.
image (SDL3) – SDL3 image extension.
ttf (SDL2) – SDL TrueType font support.
ttf (SDL3) – SDL3 TrueType font support.

Glue

glfwglue – GLFW integration helpers.
sdl2glue – SDL2 integration helpers.
sdl3glue – SDL3 integration helpers.

Input

GameInput – Windows modern input API.

AI disclaimer: I used AI as a research tool while writing this, similar to consulting documentation or reference material. It did not write the article itself. The perspective, structure, and voice are entirely my own. Also because I’m lazy XD