c3lang/c3c

Features

• LLVM-Based Compilers - Transforms source code into executable binaries and libraries using an LLVM backend for cross-platform target generation.
• Source Code Compilers - Transforms source files into executable binaries, static libraries, or dynamic libraries using an LLVM backend.
• Error Management - Implements a zero-overhead result-based system to track and manage operation failures without exception overhead.
• Memory Allocators - Implements general memory allocation for arrays and lists using either the heap or temporary pools.
• Dynamic Collections - Ships heap-allocated collections that support dynamic growth and element insertion.
• Contiguous Fixed Arrays - Implements fixed-length arrays that maintain a contiguous memory layout and prevent decay into pointers.
• Enumeration Types - Implements enumerated types with underlying integer values and isolated namespaces.
• Enum Definitions - Supports the definition of enums with arbitrary underlying types and gaps, maintaining compatibility with C-style enumerations.
• Sum Type Associations - Attaches specific data values to enumeration members to create rich sum types.
• SIMD-Accelerated Arithmetic - Executes arithmetic and bitwise operations across all elements of a vector using SIMD hardware instructions.
• First-Class Vector Types - Implements first-class vector types that map directly to hardware processor instructions for parallel data processing.
• SIMD-Based Data Parallelism - Executes parallel arithmetic and logical operations on hardware-backed vectors to maximize computational throughput.
• Source Compilation Tools - Transforms source files into executable binaries, static libraries, or dynamic libraries using an LLVM backend.
• ABI-Compatible Compilers - Ensures full ABI compatibility with C and C++ to share functions without the need for special types or wrappers.
• Module Organization - Uses a combination of modules and interfaces to manage code namespacing and encapsulation.
• Conditional Compilation - C3 uses compile-time evaluation to enable or disable code blocks based on predefined conditions.
• Hardware-Level Performance Tuning - Provides SIMD vector support and inline assembly to program hardware directly for maximum speed.
• Dynamic Memory Allocation - Provides standard library utilities for allocating contiguous memory for slices on the heap.
• Custom Memory Allocators - C3 manages memory allocation, alignment, and virtual memory mapping through custom allocators and pools.
• Pluggable Memory Allocators - Allows the injection of specific allocator instances into functions to control data residence.
• Scoped Memory Pools - Manages temporary allocations within regions that are automatically freed upon exiting a defined block.
• Manual Memory Management - C3 allocates objects on the stack or heap for varying data lifespans.
• Access Modifiers - Restricts access to declarations using public, private, and file-local scopes, as well as friend modules.
• Anonymous Functions - Defines lambdas without a name for use as arguments to other functions, supporting type inference.
• C ABI Compatibility - Produces binaries fully compatible with the C application binary interface for seamless integration with C and C++ libraries.
• Compile-Time Expression Evaluation - C3 computes values and executes logic during the compilation phase to optimize runtime performance.
• Conditional Scope Cleanup - Schedules code to run at the end of a scope with specialized variants for success or failure.
• Deferred Execution - Schedules blocks of code to run automatically at the end of a scope for resource cleanup.
• Deferred Resource Management - Defers execution of cleanup code to ensure resources are released regardless of the exit path.
• Design-by-Contract Systems - Defines preconditions and postconditions for functions to ensure correct behavior and aid debugging.
• Dynamic Message Passing - Provides a message-passing system to query and invoke functionality dynamically at runtime.
• Fault-Based Error Representation - Uses optional types and fault constants to represent the success or failure of an operation.
• Fixed-Width Integer Implementations - Provides integer types with guaranteed bit-widths across different target architectures.
• Default Arguments - Supports default values and named arguments to allow callers to specify only required parameters.
• Generic Programming - Uses generic modules and struct subtyping to create reusable components and extendable code.
• Generic Types - Implements reusable components through generic modules and ad hoc generics.
• Gradual Contract Enforcement - Defines runtime and compile-time constraints through gradual contracts to ensure software correctness.
• Interface and Any Types - Implements interface and any types to enable dynamic method invocation and runtime polymorphism.
• Interface Contract Implementations - Provides interface contracts with optional methods and supports dynamic invocation for polymorphic calls.
• Module Systems - Provides a complete module system for organizing code, managing visibility, and handling dependencies across a project.
• Generics & Templates - Creates templates using generic modules to allow a single implementation to work for multiple types.
• Dynamic Dispatch - Enables runtime polymorphism by associating type identifiers with method pointers for dynamic invocation.
• Metaprogramming & Macros - C3 generates code using macros that function like standard functions or use type information.
• Custom Macro Definitions - C3 creates reusable code snippets that return values or manipulate expressions during compilation.
• Deferred Macro Evaluations - C3 evaluates expressions and generates code during compilation using deferred evaluation and trailing blocks.
• Macro Expansion Engines - C3 generates code using macros with support for immediate evaluation and type-checked preconditions.
• Semantic Macro Systems - Generates code at compile time using a structured system that operates on the internal language representation.
• Type Definitions - Groups multiple named values of different types into a single structure with configurable alignment.
• Compile-Time Introspection - Accesses type metadata and member offsets during compilation to automate code generation and validation.
• Native C Interoperability - Implements interfaces for calling C and C++ functions directly from the codebase.
• C Function Bindings - Provides mechanisms to map and export functions as C-compatible bindings for use in external environments.
• Module Importing - Implements a module system that loads functions and types from external namespaces, including recursive sub-module imports.
• Module Organization Systems - Organizes code into a hierarchical module system that supports implicit sub-module imports.
• Native C Interoperability - Maintains full ABI compatibility with C and C++ to allow seamless integration of existing native libraries.
• Primitive Types - Provides a standard set of signed and unsigned integers, floating-point numbers, and booleans as core language types.
• Keyword Argument Usage - Allows calling functions by specifying parameter names, improving clarity in signatures.
• Standard Libraries - Provides a comprehensive set of portable utility modules, including dynamic containers and strings, as part of the core language toolset.
• Runtime Polymorphism - Pairs pointers with type identifiers in a single object to enable runtime property queries and behavioral switching.
• Scope-Exit Tasks - Executes code at the end of a scope to release resources regardless of the exit path.
• Scope Termination Hooks - Runs a specific block of code automatically when the current execution scope terminates.
• Slices and Sequence Referencing - Provides built-in slice types and range-based subscripting to manage contiguous sequences of data.
• Software Contract Systems - Defines pre-conditions and post-conditions as assertions to validate inputs and outputs during execution.
• Multi-Target Compilers - Transforms source code into executable binaries for diverse platforms and architectures including Windows, Android, and WebAssembly.
• Standard Library Collections - Provides a standard library of fundamental data structures including lists, maps, sets, and queues.
• Strong Type Definitions - Creates distinct types based on existing ones to prevent implicit conversion and enable the attachment of custom methods.
• Internal Symbol Visibility - Restricts symbol visibility using attributes to make functions and variables private to a module or local to a file.
• Zero-Overhead Error Processing - Processes runtime errors using a mechanism that avoids the performance cost of traditional exceptions.
• Multi-Dimensional Arrays - Supports the creation of fixed-size arrays with multiple dimensions, including irregular array structures.
• Vector Operations - Executes element-wise arithmetics and swizzling on numerical vectors using SIMD implementations.
• Error Handling - Provides native language constructs to represent and propagate error states throughout a program.
• Error Handling Patterns - Manages failures using a type system where errors are explicit return values, supported by try/catch blocks.
• Monadic Error Handling - Tracks operation failures using a zero-overhead system of optional types and fault constants instead of exceptions.
• Exception-Equivalent Result Types - Implements an error handling system that combines the efficiency of result types with the usability of exceptions.
• Zero-Overhead Failure Types - Uses optionals and zero-overhead error types to manage failure states without sacrificing performance.
• Flow Typing - Handles failures using optional result types with flow typing for automatic unwrapping.
• Error Propagation Systems - Uses optional return types and specialized operators to propagate faults or provide default values.
• Memory Manipulation - C3 performs volatile and unaligned load and store operations to interact with hardware.
• Optional Value Types - Provides mechanisms to declare, check, and extract values from optional types, including default fallbacks.
• Result-Type Integration - Integrates optional values into the type system as result types to represent operation success or failure.
• Sentinel Value Replacement - Wraps return values with results or excuses to replace sentinel values like null.
• Value Unwrapping - Extracts the inner value of an optional or returns the associated excuse to the caller.
• Compile-Time Metaprogramming - C3 runs logic, loops, and conditional statements during compilation to fold constants and generate code.
• Error-Excuse Return Types - Returns results or error excuses using optional types to enable efficient function chaining.
• Build and Dependency Management - Downloads missing dependencies into the correct directory and adds new requirements via command line tools.
• Reflection - Inspects type information at both compile time and runtime to support generic functions.
• Reflection and Metadata - Attaches compile-time tags to types and variables to manage reflection information.
• Attribute Reflection - C3 retrieves attributes and tags from types or members at compile time using reflection.
• Member - C3 retrieves associated methods and generates runtime getters via member reflection.
• Runtime Reflection - Provides access to basic type information during program execution.
• SIMD ABI Optimizations - Passes vectors as arrays in function calls to maintain binary compatibility with C libraries.
• Documentation Generators - Produces navigable documentation by extracting comments and contracts written directly within the source code.
• Collection Iteration - Implements required length and indexing operators to enable a type to be used within a foreach loop.
• Initializer Splatting - Employs the splat operator to provide default values to struct initializers.
• Array View Creation - Produces views into fixed or variable arrays using range syntax and inclusive indices.
• Collection Range Slicing - Provides a view into an underlying array or vector with built-in length tracking and range checking.
• Numeric Type Promotions - Implements automatic numeric type promotions and widening to ensure compatibility between different numeric types.
• Operation Type Unification - Determines the resulting type of binary operations by promoting operands to a common unified type.
• Metadata Association - Links static values to enum members, allowing metadata to be retrieved directly from the enum instance.
• Symbol-to-Enum Conversions - Provides explicit casts and conversion methods to transform enum members into their underlying integer ordinals.
• Endianness and Range Control - Controls bit-level data layout for big-endian and little-endian storage and overlapping ranges.
• Pointer Access Restrictions - Controls whether pointer arguments can be read from, written to, or both.
• Struct Defaulting - Uses a splat operator to provide default values for struct members while allowing specific overrides.
• Variadic Argument Splatting - Expands arrays or slices into a function's typed variable arguments using a splat operator.
• Compile-Time Capability Checks - C3 checks if identifiers or operations are defined at compile time to conditionally execute code.
• Optional-to-C Mappings - Converts optional types to C-compatible signatures using fault codes and reference pointers to return results.
• External Program Output Injection - C3 runs an external command during compilation and inserts the output into the source code.
• Enumerated Constants - Enables the creation of named constant groups that do not imply sequential ordinal mapping.
• Non-Sequential Constants - Creates named integer constants with custom values to maintain compatibility with non-sequential C enums.
• Concurrent Task Groups - Coordinates parallel execution and result collection through the use of thread groups.
• Thread-Safe Communication Channels - Provides thread-safe communication channels for synchronizing data between concurrent execution units.
• Declaration Filtering - C3 includes or excludes top-level functions, variables, or struct members based on compile-time constant expressions.
• Package Distribution - Cleans, builds, and bundles a target into a final package intended for delivery to end users.
• Multithreading Primitives - Implements concurrent execution using threads, thread pools, and communication channels.
• Binary-Embedded File Systems - C3 includes external files as binary data or text directly into the compiled binary.
• Operating Systems & Systems Programming - Provides access to OS-specific APIs for Windows, Linux, and macOS to manage system processes.
• Allocation Metadata Tracking - Monitors the temporary allocator to detect use-after-scope bugs where short-lived data is stored in long-lived structures.
• File I/O Management - Provides primitives for reading, writing, and managing files, including memory-mapped I/O operations.
• Inline Assembly Interfaces - Allows the insertion of low-level assembly code directly into the source via strings or blocks.
• Low-Level System Operations - Interfaces directly with the operating system via syscalls and retrieves high-resolution hardware cycle counters.
• Data Endianness - Performs input and output operations using little-endian byte ordering for specific data formats.
• Memory Alignment Attributes - Allows the creation of types with specific byte alignments using the @align attribute.
• Runtime Safety Validators - Provides a safe mode that injects runtime checks to mitigate undefined behavior.
• Musl libc Targeting - Supports compilation specifically for the musl libc implementation on Linux using dedicated compiler flags.
• Stack Overflow Protections - Provides compiler-level flags to cap the maximum size of stack objects to prevent stack overflow crashes.
• Architecture and ABI Configuration - Sets CPU features and architecture-specific ABI flags to support cross-platform compilation.
• Binary Asset Embedding - Includes external files into the compiled binary as constant byte arrays.
• Build Coordination - Coordinates compilation and dependency linking via a project configuration file.
• Inline Member Inheritance - Enables structures to inherit functionality from parent types via inline member declarations.
• Object Member Access - Provides a unified dot operator for accessing members of both direct objects and pointers.
• Macro Block Captures - C3 defines macros that accept a trailing block of code to implement custom control flow.
• Splat Initializers - Populates struct or array initializers using elements of another collection via a splat operator.
• Collection Iteration Modes - Provides flexible looping through arrays, slices, or vectors by copy, by reference, or in reverse order.
• Compile-Time Correctness Verification - C3 checks if a type, identifier, or expression is valid and defined during compilation.
• Dynamic Identifier Resolution - C3 converts compile-time strings into corresponding variables or function calls to execute dynamic identifiers.
• Expression Stringification - C3 turns code expressions or macro parameters into literal strings for logging, debugging, or code generation.
• Type Determination - C3 retrieves the type of an expression at compile time without executing it or causing side effects.
• Compile-Time Assertions - C3 validates conditions during compilation and triggers an error if the requirement is not met.
• Conditional Declaration Inclusion - C3 conditionally includes declarations in the compilation based on constant values and macro folding.
• Compile-Time Formatting - C3 generates strings during compilation using a simplified formatting macro.
• Compile-Time Script Integration - C3 runs a script during the compilation process and integrates the output directly into the source code.
• Compile-Time Type Property Queries - Accesses type metadata such as size, alignment, and kind during the compilation process.
• Compound Literals - Creates anonymous structures or arrays on the fly with optional type inference for concise value passing.
• Constant Sets - Allows the creation of named sets of constants of any type as a flexible alternative to ordinal enums.
• Declaration Attributes - Uses predefined attributes to control memory alignment, calling conventions, and symbol visibility.
• Default Variable Initialization - Prevents undefined behavior by automatically setting local variables to zero by default.
• Documentation Contracts - Uses specialized block comments to embed contract-based metadata parsed by the compiler for correctness checking.
• Documentation Generation - Produces HTML documentation directly from source code by extracting comments and contracts.
• Dynamic Strings - Provides a dynamic string builder for flexible runtime manipulation without requiring manual memory allocation.
• Indexing and Slicing - Enables safe array access and iteration through the use of slices and foreach loops.
• Evaluation Order Control - Executes binary expressions from left to right and call arguments in parameter order for predictability.
• Expression-Based Switch Cases - Evaluates boolean expressions within case statements to function as an enhanced if-else chain.
• Fault Referencing - Allows functions to reference the expected return faults of another function within their own fault declarations.
• Literal Type Defaults - Employs bi-directional type checking to determine the correct type for numeric constants and perform safe widening.
• Argument Unpacking - Unpacks slices, arrays, or structs into individual function parameters using a splat operator.
• Calling Convention Configuration - Specifies calling conventions, marks functions as naked to omit prologues, and defines entry points.
• Type Constraint Mapping - Enforces specific requirements on type parameters via contracts to ensure compatibility.
• Type Parameter Inference - Automatically determines generic type arguments from left to right during assignment.
• Collection Protocol Implementations - Enables foreach iteration on custom types by implementing and annotating length and indexing methods.
• Label-Based Control Flows - Replaces goto statements with labeled break and continue for structured jumping.
• Variadic Template Arguments - Implements strict type checking for functions that accept a variable number of arguments.
• Compile-Time Functional Operations - C3 processes arrays using compile-time macros for zipping, reducing, filtering, and summing.
• Operator Overloading - Allows defining custom behavior for built-in language operators to create expressive code for mathematical types.
• Hygienic Macro Systems - C3 produces code at compile time using a system that supports lazy evaluation and implicit scope capture.
• Non-Capturing Lambdas - Supports lambdas that do not capture state, simplifying the lifetime model while providing functional capabilities.
• Struct Subtyping - Implements specialized versions of structures by inlining base structures to allow subtype passing.
• Implicit Narrowing Prevention - Prevents data loss and ambiguity by disallowing implicit type conversions that narrow the data type.
• Initialization Enforcement - Prevents types from being declared without an explicit or zero initialization via specific attributes.
• Vector Type Bindings - Passes SIMD vectors as arrays to ensure binary compatibility with graphical and numerical C libraries.
• FFI Type Aliasing - Assigns external names to user-defined types via attributes to maintain compatibility with C foreign function interfaces.
• Test Execution - Marks specific functions as tests to be executed by the compiler on request.
• Code Generation from Strings - C3 converts strings containing expressions into executable values during the compilation process.
• Mathematical Computing Utilities - Provides standard library support for complex numbers, matrices, vectors, and big integers.
• Conditional Imports - Prevents the compiler from checking imports if a module activation condition is evaluated as false.
• Module Aliasing - Allows the creation of short custom names for modules to improve code organization.
• Recursive Imports - Automatically loads a module and all its sub-modules so their contents are directly available.
• Swizzle Indexing - Implements shorthand labels like xyzw for concise rearrangement and selection of vector components.
• Operator Overloading - Implements standard mathematical and bitwise operators for user-defined types.
• Operator Overloading for Indexing - Implements indexing, reference retrieval, and assignment operators to allow custom types to be accessed like arrays.
• Parameter Access Constraints - Restricts function parameters to read-only or write-only access to prevent unintended modifications of data.
• Structural Type Equivalences - Provides an opt-in typing system where compatibility is determined by the data structure rather than explicit declarations.
• Function Signature Enforcement - Validates pre-conditions and post-conditions through static analysis and runtime asserts.
• Pure Functions - Allows marking functions as having no side effects to enable compiler optimizations based on state.
• Enum Reflection - Provides runtime inspection and metadata retrieval for enumeration constants.
• Return Value Enforcement Attributes - Enforces that function return values must not be silently discarded through compiler-level specifications.
• Runtime Assertion Validation - Validates pre-conditions and post-conditions via assertions to trigger a diagnostic report upon failure.
• Runtime Type Detection - Retrieves type identifiers from objects during execution to enable runtime polymorphism.
• Emscripten Support - Provides integrated support for compiling source code to the web using the Emscripten toolchain.
• Source Code Documentation - Embeds descriptive text and formal contracts directly into the source code using special delimiters.
• Source Library Packaging - Bundles source files and linked libraries into a distributable format with a manifest for managing dependencies.
• Libc Customization - Allows developers to specify a custom libc implementation through compiler flags to replace the default standard library.
• State Machine Switch Control - Jumps to subsequent cases or specific labeled cases using a dedicated keyword for state machines.
• Static Contract Analysis - Inlines function requirements at the caller site to catch violations during compilation.
• Struct Composition - Enables a form of inheritance and composition by embedding structs within other structs.
• Subarray Slicing - Uses slices to handle contiguous segments of arrays and supports bulk assignment.
• Substruct Conversions - Allows the implicit use of substruct pointers or values in place of their parent structs.
• Symbol Linkage Control - Sets external names for symbols and marks them for export to ensure visibility during the linking process.
• Exported Symbols - Marks functions and globals for linker visibility to enable the construction of dependency graphs.
• Tagged Unions - C3 defines a type that can hold one of several different members in the same memory location.
• Type Aliasing - Defines alternative names for types, functions, and variables to simplify complex signatures.
• Type-Associated Macros - C3 defines macros as methods on a specific type to be called via dot notation.
• Type Conversion and Casting - Manages the conversion of pointers via void types and enforces explicit casts for vector transformations.
• Type Identifier Conversions - Implicitly converts constant type identifiers to usable types for macros and assignments.
• Type Member Introspection - Retrieves a comprehensive list of all members within a struct or union via type properties.
• Type Methods - Enables functions to be associated with any type, including built-in types, for dot-syntax invocation.
• Generic Method Implementations - Adds functions to generic types that apply to all instantiations or specific concrete types.
• Undefined Behavior Detection - Prints an error trace and aborts execution when undefined operations occur during debug builds.
• Logical Operation Evaluation - C3 evaluates logical AND and OR operations at compile time without type-checking unnecessary branches.
• Labeled Scope Breaks - Uses labels on conditional or loop statements to break or continue execution at a specific outer scope.
• Vector Masking and Reduction - Implements vector reduction to single values and mask-based rearrangement of multiple vectors.
• Vector Swizzling - Provides named swizzle notation for accessing and reassigning specific elements within vectors.
• Wasm Module Configuration - Enables the definition of freestanding WebAssembly targets and the support for named modules via attributes.
• Bit-Range Field Accessors - Provides specialized get and set methods to modify specific bit-range values within a bitstruct.
• Vector - Provides built-in methods for computing dot products, cross products, and vector normalization.
• Cryptographic Operations - Implements standard encryption and decryption algorithms to protect data and verify identities.
• Data Hashing Utilities - Generates checksums and hashes using SHA, CRC, and BLAKE to verify the integrity of data buffers.
• Runtime Bounds Checking - Inserts automatic runtime bounds and value checks during debug builds to identify bugs early.
• Cryptographic Hash Computations - Computes secure cryptographic hashes using algorithms including SHA3, Blake3, and Argon2.
• String-to-Code Conversion - C3 transforms compile-time strings into active code, variables, or functions for dynamic code generation.
• Compiler Optimizations - Forces or prevents function inlining and disables sanitizer instrumentation for specific functions.
• Kernel Object Contract Enforcements - Adds pre-conditions and post-conditions to functions to assist in static analysis.
• Cross-Platform Abstractions - Supplies a standard library with dynamic containers and strings to enable portable development across platforms.
• Design by Contract - Uses a specific syntax to declare documentation and contract blocks distinct from standard comments.
• Jump Table Optimizations - Forces the implementation of switch statements as jump tables to achieve high-performance dispatch.
• Optional-Argument Dispatch - Runs a function only when all optional arguments contain values, otherwise returning the first excuse.
• Try-Macro Propagation - Conditionally assigns a value from an optional result and returns the fault if the operation fails via a try macro.
• Identifier-to-Type Resolutions - Allows the creation of usable types from strings or type identifiers during compilation.
• Library Dependency Managers - Detects and compiles required dependent libraries automatically when a target library is linked to a project.
• Relational Operator Overloading - Implements equality and ordering operators to enable custom types to be compared using relational syntax.
• Memory Alignment Utilities - Defines memory alignment for types via typedef to safely reference members within packed structures.
• Bit-Packed Storage - Allows precise control over memory layout by storing fields in specific bit ranges.
• Bit-Range Field Mapping - Maps integer and boolean fields to specific bit ranges within a backing type.
• Bitstruct Definitions - Uses bitstructs to provide precise control over the bit-level layout of data.
• Code Annotations - Marks symbols as deprecated, unused, or mandatory to trigger specific compiler warnings.
• Operator Precedence Management - Determines the order of operation for arithmetic, bitwise, and relational operators.
• Interface-Based Polymorphic Collections - Maintains collections of values implementing specific interfaces for runtime polymorphic programming.
• Volatile Register Access - C3 executes volatile loads and stores to prevent the compiler from optimizing away memory accesses.
• Compile-Time Data Slicing - C3 executes slicing operations on arrays, strings, and constant slices during compilation.
• Compile-Time String Concatenation - C3 joins strings and type names together at compile time using a dedicated concatenation operator.
• Compile-Time String Manipulation - C3 modifies strings during compilation using macros for case conversion and text replacement.
• String Transformations - C3 transforms strings into different casings during compilation to automate code generation.
• Grouped Parallel Execution - Enables enqueuing multiple tasks for concurrent execution and collecting their results using thread groups.
• Runtime Safety Toggling - Switches between a safe mode with runtime checks and a fast mode that omits them.
• Sanitizer Integrations - Connects with external sanitizers to detect memory corruption and race conditions during execution.
• Memory Leak Detection - Tracks memory usage and reports unfreed allocations to ensure no leaks occur within a specific code scope.
• General Bug Detection - Inserts bounds and value checks during debug builds to catch memory and logic errors.
• Unit Testing - Executes specific code blocks using testing macros to identify failures through descriptive error messages.

Star history