odin-lang/Odin

Features

• High-Performance Systems Programming - Designed for high-performance systems programming with precise control over memory layout and hardware utilization.
• Custom Memory Allocators - Supports custom allocator interfaces for precise control over memory allocation strategies.
• Manual Memory Management Utilities - Provides explicit allocation procedures and custom allocators for precise resource management.
• Enforced Result Handling - Ensures return values from critical procedures are explicitly handled to prevent silent failures.
• Union Types - Supports discriminated unions (sum types) that track the active member via a tag for safe runtime switching.
• Discriminated Unions - Implements discriminated unions that use internal tags for safe runtime type switching.
• Polymorphic Logic - Enables the creation of functions and types that work with multiple data types using explicit type parameters.
• Foreign Function Interfaces - Implements a comprehensive foreign function interface for importing libraries and assembly files.
• Multiple Return Values - Supports multiple return values from procedures using both named and unnamed variables.
• Parametric Polymorphism - Provides a parametric polymorphism engine for creating generic procedures and data structures.
• Systems and Performance Languages - A compiled language specifically designed for high-performance systems development and low-level memory control.
• Statically Typed Languages - Enforces type constraints at compile time while supporting parametric polymorphism and discriminated unions.
• Type Conversion and Casting - Implements explicit type casting and bit-cast transmutes for low-level memory manipulation.
• Generic Data Structures - Allows the definition of reusable data structures that operate across multiple types using explicit or implicit parameters.
• Automated Test Runners - Ships a built-in multi-threaded test runner that executes procedures across multiple packages.
• Memory Layouts - Enables efficient data packing using bit fields and specific record layouts for cache-efficient processing.
• Data Locality Optimizers - Supports organizing records as arrays of structures or structures of arrays to maximize hardware acceleration.
• Conditional Compilation - Supports conditional compilation based on constant expressions to handle platform-specific code.
• Asset Embedding - Embeds static resources and string hashes directly into the compiled program binary.
• Game Development Engines - Supports game engine development through high-performance data structures and memory-aligned records for cache efficiency.
• Binary Asset Embedding - Allows embedding file contents and directory structures directly into the executable binary during compilation.
• Deferred Execution - Provides a deferred execution mechanism to run cleanup code automatically upon exiting a scope.
• Calling Conventions - Provides low-level control over calling conventions to ensure compatibility with foreign system binaries.
• Implicit Context Passing - Uses implicit context passing to modify library behavior like logging and allocation without global state.
• Runtime Introspection - Stores type and module metadata in the binary for runtime examination of the program structure.
• Type Narrowing Assertion - Provides runtime type assertions to convert union or abstract types into concrete forms.
• Standard Library Implementations - Includes a standard library providing core and vendor-provided packages for common systems programming tasks.
• Cross-Platform Development - Provides tools and strategies for building portable software that functions across multiple operating systems and platforms.
• Implicit Context Management - Implements implicit context management to intercept and modify behaviors like logging and allocation.
• Memory Alignment Utilities - Ensures data structures are aligned and packed in memory to reduce waste and speed up parallel processing.
• Bit-Packed Storage - Provides bit-packed records and specialized fields to minimize memory footprint and optimize hardware alignment.
• Zero-Overhead Abstractions - Compiles high-level features into efficient machine code to minimize execution overhead and maximize hardware utilization.
• Built-in Testing Frameworks - Ships a built-in multi-threaded testing framework with memory leak detection and timeout management.
• Memory Leak Detection - Integrates memory allocation monitoring during tests to detect and report memory leaks.
• Test Execution Timeouts - Includes test timeout management to terminate tests that run too long or enter infinite loops.
• Code Examples - Comprehensive demonstration of language features.

Star history