# c3lang/c3c

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/c3lang-c3c).**

5,147 stars · 339 forks · C3 · mit

## Links

- GitHub: https://github.com/c3lang/c3c
- Homepage: https://c3-lang.org
- awesome-repositories: https://awesome-repositories.com/repository/c3lang-c3c.md

## Topics

`c3` `compiler` `language`

## Description

c3c is the compiler for the C3 programming language, transforming source code into executable binaries, static libraries, or dynamic libraries using an LLVM backend. It implements a system based on result-based error handling, scoped memory pooling, and a semantic macro system.

The compiler provides first-class support for hardware-backed SIMD vectors that map directly to processor instructions and enables runtime polymorphism through interface-based dynamic dispatch.

The project covers a broad set of low-level capabilities, including manual and pooled memory management, inline assembly integration, and a comprehensive metaprogramming suite featuring compile-time execution and reflection. It maintains full ABI compatibility with C and C++ and supports multi-target cross-compilation for platforms such as WebAssembly, Linux Musl, and Android.

Integrated toolchain features include a project build coordinator, automated SDK fetching, and a built-in HTML documentation generator that extracts contracts and comments directly from the source.

## Tags

### Programming Languages & Runtimes

- [LLVM-Based Compilers](https://awesome-repositories.com/f/programming-languages-runtimes/llvm-based-compilers.md) — Transforms source code into executable binaries and libraries using an LLVM backend for cross-platform target generation.
- [Source Code Compilers](https://awesome-repositories.com/f/programming-languages-runtimes/source-code-compilers.md) — Transforms source files into executable binaries, static libraries, or dynamic libraries using an LLVM backend. ([source](https://c3-lang.org/build-your-project/build-commands/))
- [Access Modifiers](https://awesome-repositories.com/f/programming-languages-runtimes/access-modifiers.md) — Restricts access to declarations using public, private, and file-local scopes, as well as friend modules. ([source](https://c3-lang.org/blog/archive/2023/))
- [Anonymous Functions](https://awesome-repositories.com/f/programming-languages-runtimes/anonymous-functions.md) — Defines lambdas without a name for use as arguments to other functions, supporting type inference. ([source](https://c3-lang.org/language-fundamentals/functions/))
- [C ABI Compatibility](https://awesome-repositories.com/f/programming-languages-runtimes/c-abi-compatibility.md) — Produces binaries fully compatible with the C application binary interface for seamless integration with C and C++ libraries. ([source](https://c3-lang.org/getting-started/design-goals/))
- [Compile-Time Expression Evaluation](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-expression-evaluation.md) — C3 computes values and executes logic during the compilation phase to optimize runtime performance. ([source](https://c3-lang.org/blog/archive/2021/))
- [Conditional Scope Cleanup](https://awesome-repositories.com/f/programming-languages-runtimes/conditional-scope-cleanup.md) — Schedules code to run at the end of a scope with specialized variants for success or failure. ([source](https://c3-lang.org/all/))
- [Deferred Execution](https://awesome-repositories.com/f/programming-languages-runtimes/deferred-execution.md) — Schedules blocks of code to run automatically at the end of a scope for resource cleanup. ([source](https://cdn.jsdelivr.net/gh/c3lang/c3c@master/README.md))
- [Deferred Resource Management](https://awesome-repositories.com/f/programming-languages-runtimes/deferred-resource-management.md) — Defers execution of cleanup code to ensure resources are released regardless of the exit path. ([source](https://c3-lang.org/getting-started/introduction/))
- [Design-by-Contract Systems](https://awesome-repositories.com/f/programming-languages-runtimes/design-by-contract-systems.md) — Defines preconditions and postconditions for functions to ensure correct behavior and aid debugging. ([source](https://c3-lang.org/blog/archive/2021/))
- [Dynamic Message Passing](https://awesome-repositories.com/f/programming-languages-runtimes/dynamic-message-passing.md) — Provides a message-passing system to query and invoke functionality dynamically at runtime. ([source](https://c3-lang.org/all/))
- [Fault-Based Error Representation](https://awesome-repositories.com/f/programming-languages-runtimes/fault-based-error-representation.md) — Uses optional types and fault constants to represent the success or failure of an operation. ([source](https://c3-lang.org/faq/allfeatures/))
- [Fixed-Width Integer Implementations](https://awesome-repositories.com/f/programming-languages-runtimes/fixed-width-integer-implementations.md) — Provides integer types with guaranteed bit-widths across different target architectures. ([source](https://c3-lang.org/c-to-c3/a-guide-for-c-programmers/))
- [Default Arguments](https://awesome-repositories.com/f/programming-languages-runtimes/function-argument-passing/default-arguments.md) — Supports default values and named arguments to allow callers to specify only required parameters. ([source](https://c3-lang.org/language-fundamentals/functions/))
- [Generic Programming](https://awesome-repositories.com/f/programming-languages-runtimes/generic-programming.md) — Uses generic modules and struct subtyping to create reusable components and extendable code. ([source](https://c3-lang.org/getting-started/introduction/))
- [Generic Types](https://awesome-repositories.com/f/programming-languages-runtimes/generic-types.md) — Implements reusable components through generic modules and ad hoc generics. ([source](https://c3-lang.org/all/))
- [Gradual Contract Enforcement](https://awesome-repositories.com/f/programming-languages-runtimes/gradual-contract-enforcement.md) — Defines runtime and compile-time constraints through gradual contracts to ensure software correctness. ([source](https://c3-lang.org))
- [Interface and Any Types](https://awesome-repositories.com/f/programming-languages-runtimes/interface-and-any-types.md) — Implements interface and any types to enable dynamic method invocation and runtime polymorphism. ([source](https://c3-lang.org/faq/allfeatures/))
- [Interface Contract Implementations](https://awesome-repositories.com/f/programming-languages-runtimes/interface-contract-implementations.md) — Provides interface contracts with optional methods and supports dynamic invocation for polymorphic calls. ([source](https://c3-lang.org/language-common/attributes/))
- [Module Systems](https://awesome-repositories.com/f/programming-languages-runtimes/language-ecosystems-tooling/module-management/module-systems.md) — Provides a complete module system for organizing code, managing visibility, and handling dependencies across a project. ([source](https://c3-lang.org/blog/archive/2021/))
- [Generics & Templates](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/generics-templates.md) — Creates templates using generic modules to allow a single implementation to work for multiple types. ([source](https://c3-lang.org/blog/archive/2021/))
- [Dynamic Dispatch](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/language-extensions/dynamic-dispatch.md) — Enables runtime polymorphism by associating type identifiers with method pointers for dynamic invocation.
- [Metaprogramming & Macros](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/metaprogramming-macros.md) — C3 generates code using macros that function like standard functions or use type information. ([source](https://c3-lang.org/getting-started/introduction/))
- [Custom Macro Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/metaprogramming-macros/custom-macro-definitions.md) — C3 creates reusable code snippets that return values or manipulate expressions during compilation. ([source](https://c3-lang.org/generic-programming/macros/))
- [Deferred Macro Evaluations](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/metaprogramming-macros/deferred-macro-evaluations.md) — C3 evaluates expressions and generates code during compilation using deferred evaluation and trailing blocks. ([source](https://c3-lang.org))
- [Macro Expansion Engines](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/metaprogramming-macros/hygienic-macro-systems/macro-expansion-engines.md) — C3 generates code using macros with support for immediate evaluation and type-checked preconditions. ([source](https://c3-lang.org/language-overview/examples/))
- [Semantic Macro Systems](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/metaprogramming-macros/hygienic-macro-systems/semantic-macro-systems.md) — Generates code at compile time using a structured system that operates on the internal language representation.
- [Type Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions.md) — Groups multiple named values of different types into a single structure with configurable alignment. ([source](https://c3-lang.org/language-common/structs-and-unions/))
- [Compile-Time Introspection](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations/compile-time-type-inference/compile-time-introspection.md) — Accesses type metadata and member offsets during compilation to automate code generation and validation. ([source](https://c3-lang.org/generic-programming/compiletime/))
- [Native C Interoperability](https://awesome-repositories.com/f/programming-languages-runtimes/language-interoperability/native-c-interoperability.md) — Implements interfaces for calling C and C++ functions directly from the codebase. ([source](https://cdn.jsdelivr.net/gh/c3lang/c3c@master/README.md))
- [C Function Bindings](https://awesome-repositories.com/f/programming-languages-runtimes/language-interoperability/native-c-interoperability/c-function-bindings.md) — Provides mechanisms to map and export functions as C-compatible bindings for use in external environments. ([source](https://c3-lang.org/language-common/cinterop/))
- [Module Importing](https://awesome-repositories.com/f/programming-languages-runtimes/module-importing.md) — Implements a module system that loads functions and types from external namespaces, including recursive sub-module imports. ([source](https://c3-lang.org/getting-started/hello-world/))
- [Module Organization Systems](https://awesome-repositories.com/f/programming-languages-runtimes/module-organization-systems.md) — Organizes code into a hierarchical module system that supports implicit sub-module imports. ([source](https://c3-lang.org))
- [Native C Interoperability](https://awesome-repositories.com/f/programming-languages-runtimes/native-c-interoperability.md) — Maintains full ABI compatibility with C and C++ to allow seamless integration of existing native libraries. ([source](https://c3-lang.org))
- [Primitive Types](https://awesome-repositories.com/f/programming-languages-runtimes/primitive-types.md) — Provides a standard set of signed and unsigned integers, floating-point numbers, and booleans as core language types. ([source](https://c3-lang.org/language-fundamentals/basic-types-and-values/))
- [Keyword Argument Usage](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/function-utilities/argument-collectors/keyword-argument-constraints/keyword-argument-usage.md) — Allows calling functions by specifying parameter names, improving clarity in signatures. ([source](https://c3-lang.org/faq/allfeatures/))
- [Standard Libraries](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/standard-libraries.md) — Provides a comprehensive set of portable utility modules, including dynamic containers and strings, as part of the core language toolset. ([source](https://c3-lang.org/getting-started/design-goals/))
- [Runtime Polymorphism](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-polymorphism.md) — Pairs pointers with type identifiers in a single object to enable runtime property queries and behavioral switching. ([source](https://c3-lang.org/generic-programming/anyinterfaces/))
- [Scope-Exit Tasks](https://awesome-repositories.com/f/programming-languages-runtimes/scope-exit-tasks.md) — Executes code at the end of a scope to release resources regardless of the exit path. ([source](https://c3-lang.org/language-common/defer/))
- [Scope Termination Hooks](https://awesome-repositories.com/f/programming-languages-runtimes/scope-termination-hooks.md) — Runs a specific block of code automatically when the current execution scope terminates. ([source](https://c3-lang.org/blog/archive/2020/))
- [Slices and Sequence Referencing](https://awesome-repositories.com/f/programming-languages-runtimes/slices-and-sequence-referencing.md) — Provides built-in slice types and range-based subscripting to manage contiguous sequences of data. ([source](https://c3-lang.org/faq/allfeatures/))
- [Software Contract Systems](https://awesome-repositories.com/f/programming-languages-runtimes/software-contract-systems.md) — Defines pre-conditions and post-conditions as assertions to validate inputs and outputs during execution. ([source](https://c3-lang.org/language-overview/examples/))
- [Multi-Target Compilers](https://awesome-repositories.com/f/programming-languages-runtimes/source-code-compilers/multi-target-compilers.md) — Transforms source code into executable binaries for diverse platforms and architectures including Windows, Android, and WebAssembly. ([source](https://c3-lang.org/blog/))
- [Standard Library Collections](https://awesome-repositories.com/f/programming-languages-runtimes/standard-library-collections.md) — Provides a standard library of fundamental data structures including lists, maps, sets, and queues. ([source](https://c3-lang.org/standard-library/docs.html))
- [Strong Type Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/strong-type-definitions.md) — Creates distinct types based on existing ones to prevent implicit conversion and enable the attachment of custom methods. ([source](https://c3-lang.org/c-to-c3/a-guide-for-c-programmers/))
- [Internal Symbol Visibility](https://awesome-repositories.com/f/programming-languages-runtimes/symbolic-identifiers/exported-symbols/internal-symbol-visibility.md) — Restricts symbol visibility using attributes to make functions and variables private to a module or local to a file. ([source](https://c3-lang.org/language-common/attributes/))
- [Zero-Overhead Error Processing](https://awesome-repositories.com/f/programming-languages-runtimes/zero-overhead-error-processing.md) — Processes runtime errors using a mechanism that avoids the performance cost of traditional exceptions. ([source](https://c3-lang.org/getting-started/design-goals/))
- [Architecture and ABI Configuration](https://awesome-repositories.com/f/programming-languages-runtimes/architecture-and-abi-configuration.md) — Sets CPU features and architecture-specific ABI flags to support cross-platform compilation. ([source](https://c3-lang.org/blog/archive/2025/))
- [Binary Asset Embedding](https://awesome-repositories.com/f/programming-languages-runtimes/binary-asset-embedding.md) — Includes external files into the compiled binary as constant byte arrays. ([source](https://c3-lang.org/all/))
- [Build Coordination](https://awesome-repositories.com/f/programming-languages-runtimes/build-coordination.md) — Coordinates compilation and dependency linking via a project configuration file. ([source](https://c3-lang.org/all/))
- [Inline Member Inheritance](https://awesome-repositories.com/f/programming-languages-runtimes/class-inheritance/inline-member-inheritance.md) — Enables structures to inherit functionality from parent types via inline member declarations. ([source](https://c3-lang.org/blog/archive/2025/))
- [Object Member Access](https://awesome-repositories.com/f/programming-languages-runtimes/class-member-access/object-member-access.md) — Provides a unified dot operator for accessing members of both direct objects and pointers. ([source](https://c3-lang.org/c-to-c3/a-guide-for-c-programmers/))
- [Macro Block Captures](https://awesome-repositories.com/f/programming-languages-runtimes/code-block-captures/macro-block-captures.md) — C3 defines macros that accept a trailing block of code to implement custom control flow. ([source](https://c3-lang.org/generic-programming/macros/))
- [Splat Initializers](https://awesome-repositories.com/f/programming-languages-runtimes/collection-expressions/splat-initializers.md) — Populates struct or array initializers using elements of another collection via a splat operator. ([source](https://c3-lang.org/blog/archive/2024/))
- [Collection Iteration Modes](https://awesome-repositories.com/f/programming-languages-runtimes/collection-iteration-modes.md) — Provides flexible looping through arrays, slices, or vectors by copy, by reference, or in reverse order. ([source](https://c3-lang.org/language-common/arrays/))
- [Compile-Time Correctness Verification](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-correctness-verification.md) — C3 checks if a type, identifier, or expression is valid and defined during compilation. ([source](https://c3-lang.org/generic-programming/compiletime/))
- [Dynamic Identifier Resolution](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-expression-evaluation/dynamic-identifier-resolution.md) — C3 converts compile-time strings into corresponding variables or function calls to execute dynamic identifiers. ([source](https://c3-lang.org/generic-programming/reflection/))
- [Expression Stringification](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-expression-evaluation/expression-stringification.md) — C3 turns code expressions or macro parameters into literal strings for logging, debugging, or code generation. ([source](https://c3-lang.org/generic-programming/reflection/))
- [Type Determination](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-expression-evaluation/type-determination.md) — C3 retrieves the type of an expression at compile time without executing it or causing side effects. ([source](https://c3-lang.org/generic-programming/compiletime/))
- [Compile-Time Assertions](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-expressions/compile-time-conditional-branching/compile-time-assertions.md) — C3 validates conditions during compilation and triggers an error if the requirement is not met. ([source](https://c3-lang.org/generic-programming/compiletime/))
- [Conditional Declaration Inclusion](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-expressions/compile-time-conditional-branching/conditional-declaration-inclusion.md) — C3 conditionally includes declarations in the compilation based on constant values and macro folding. ([source](https://c3-lang.org/language-common/attributes/))
- [Compile-Time Formatting](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-formatting.md) — C3 generates strings during compilation using a simplified formatting macro. ([source](https://c3-lang.org/blog/archive/2025/))
- [Compile-Time Script Integration](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-script-integration.md) — C3 runs a script during the compilation process and integrates the output directly into the source code. ([source](https://c3-lang.org/generic-programming/compiletime/))
- [Compile-Time Type Property Queries](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-type-property-queries.md) — Accesses type metadata such as size, alignment, and kind during the compilation process. ([source](https://c3-lang.org/language-overview/types/))
- [Compound Literals](https://awesome-repositories.com/f/programming-languages-runtimes/compound-data-structures/compound-literals.md) — Creates anonymous structures or arrays on the fly with optional type inference for concise value passing. ([source](https://c3-lang.org/language-fundamentals/expressions/))
- [Constant Sets](https://awesome-repositories.com/f/programming-languages-runtimes/constant-sets.md) — Allows the creation of named sets of constants of any type as a flexible alternative to ordinal enums. ([source](https://c3-lang.org/blog/))
- [Declaration Attributes](https://awesome-repositories.com/f/programming-languages-runtimes/declaration-attributes.md) — Uses predefined attributes to control memory alignment, calling conventions, and symbol visibility. ([source](https://c3-lang.org/implementation-details/grammar/))
- [Default Variable Initialization](https://awesome-repositories.com/f/programming-languages-runtimes/default-variable-initialization.md) — Prevents undefined behavior by automatically setting local variables to zero by default. ([source](https://c3-lang.org/language-fundamentals/variables/))
- [Documentation Contracts](https://awesome-repositories.com/f/programming-languages-runtimes/documentation-contracts.md) — Uses specialized block comments to embed contract-based metadata parsed by the compiler for correctness checking. ([source](https://c3-lang.org/implementation-details/specification/))
- [Documentation Generation](https://awesome-repositories.com/f/programming-languages-runtimes/documentation-generation.md) — Produces HTML documentation directly from source code by extracting comments and contracts. ([source](https://c3-lang.org/blog/))
- [Dynamic Strings](https://awesome-repositories.com/f/programming-languages-runtimes/dynamic-strings.md) — Provides a dynamic string builder for flexible runtime manipulation without requiring manual memory allocation. ([source](https://c3-lang.org/language-common/strings/))
- [Indexing and Slicing](https://awesome-repositories.com/f/programming-languages-runtimes/dynamic-strings/string-slices/indexing-and-slicing.md) — Enables safe array access and iteration through the use of slices and foreach loops. ([source](https://c3-lang.org/getting-started/design-goals/))
- [Evaluation Order Control](https://awesome-repositories.com/f/programming-languages-runtimes/evaluation-order-control.md) — Executes binary expressions from left to right and call arguments in parameter order for predictability. ([source](https://c3-lang.org/language-fundamentals/expressions/))
- [Expression-Based Switch Cases](https://awesome-repositories.com/f/programming-languages-runtimes/expression-based-switch-cases.md) — Evaluates boolean expressions within case statements to function as an enhanced if-else chain. ([source](https://c3-lang.org/language-fundamentals/statements/))
- [Fault Referencing](https://awesome-repositories.com/f/programming-languages-runtimes/fault-referencing.md) — Allows functions to reference the expected return faults of another function within their own fault declarations. ([source](https://c3-lang.org/blog/archive/2025/))
- [Literal Type Defaults](https://awesome-repositories.com/f/programming-languages-runtimes/fixed-width-integer-implementations/integer-literal-definitions/literal-type-defaults.md) — Employs bi-directional type checking to determine the correct type for numeric constants and perform safe widening. ([source](https://c3-lang.org/blog/archive/2020/))
- [Argument Unpacking](https://awesome-repositories.com/f/programming-languages-runtimes/function-argument-passing/argument-unpacking.md) — Unpacks slices, arrays, or structs into individual function parameters using a splat operator. ([source](https://c3-lang.org/language-fundamentals/functions/))
- [Calling Convention Configuration](https://awesome-repositories.com/f/programming-languages-runtimes/generator-functions/function-execution-models/calling-convention-configuration.md) — Specifies calling conventions, marks functions as naked to omit prologues, and defines entry points. ([source](https://c3-lang.org/language-common/attributes/))
- [Type Constraint Mapping](https://awesome-repositories.com/f/programming-languages-runtimes/generic-types/type-constraint-mapping.md) — Enforces specific requirements on type parameters via contracts to ensure compatibility. ([source](https://c3-lang.org/generic-programming/generics/))
- [Type Parameter Inference](https://awesome-repositories.com/f/programming-languages-runtimes/generic-types/type-parameter-inference.md) — Automatically determines generic type arguments from left to right during assignment. ([source](https://c3-lang.org/blog/archive/2025/))
- [Collection Protocol Implementations](https://awesome-repositories.com/f/programming-languages-runtimes/iteration-protocols/collection-protocol-implementations.md) — Enables foreach iteration on custom types by implementing and annotating length and indexing methods. ([source](https://c3-lang.org/language-common/arrays/))
- [Label-Based Control Flows](https://awesome-repositories.com/f/programming-languages-runtimes/label-based-control-flows.md) — Replaces goto statements with labeled break and continue for structured jumping. ([source](https://c3-lang.org/c-to-c3/a-guide-for-c-programmers/))
- [Variadic Template Arguments](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/generics-templates/variadic-template-arguments.md) — Implements strict type checking for functions that accept a variable number of arguments. ([source](https://c3-lang.org/blog/archive/2021/))
- [Compile-Time Functional Operations](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/array-operations/compile-time-functional-operations.md) — C3 processes arrays using compile-time macros for zipping, reducing, filtering, and summing. ([source](https://c3-lang.org/blog/archive/2025/))
- [Operator Overloading](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/core-conceptual-frameworks/programming-language-concepts/method-definitions/operator-overloading.md) — Allows defining custom behavior for built-in language operators to create expressive code for mathematical types. ([source](https://c3-lang.org))
- [Hygienic Macro Systems](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/metaprogramming-macros/hygienic-macro-systems.md) — C3 produces code at compile time using a system that supports lazy evaluation and implicit scope capture. ([source](https://c3-lang.org/blog/archive/2020/))
- [Non-Capturing Lambdas](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations/polymorphic-logic/generic-lambda-expressions/lambda-capture-and-invocation-patterns/non-capturing-lambdas.md) — Supports lambdas that do not capture state, simplifying the lifetime model while providing functional capabilities. ([source](https://c3-lang.org/faq/allfeatures/))
- [Struct Subtyping](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations/polymorphic-logic/higher-rank-polymorphism/subtyping-checks/struct-subtyping.md) — Implements specialized versions of structures by inlining base structures to allow subtype passing. ([source](https://c3-lang.org/language-common/structs-and-unions/))
- [Implicit Narrowing Prevention](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-definitions/variable-type-declarations/type-narrowing/implicit-narrowing-prevention.md) — Prevents data loss and ambiguity by disallowing implicit type conversions that narrow the data type. ([source](https://c3-lang.org/c-to-c3/a-guide-for-c-programmers/))
- [Initialization Enforcement](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-safety/type-integrity-enforcement/initialization-enforcement.md) — Prevents types from being declared without an explicit or zero initialization via specific attributes. ([source](https://c3-lang.org/blog/))
- [Vector Type Bindings](https://awesome-repositories.com/f/programming-languages-runtimes/language-interoperability/foreign-function-interfaces/c-bindings/vector-type-bindings.md) — Passes SIMD vectors as arrays to ensure binary compatibility with graphical and numerical C libraries. ([source](https://c3-lang.org/blog/archive/2025/))
- [FFI Type Aliasing](https://awesome-repositories.com/f/programming-languages-runtimes/language-interoperability/foreign-function-interfaces/ffi-type-definitions/rust-c-type-mappings/ffi-type-aliasing.md) — Assigns external names to user-defined types via attributes to maintain compatibility with C foreign function interfaces. ([source](https://c3-lang.org/language-fundamentals/naming/))
- [Test Execution](https://awesome-repositories.com/f/programming-languages-runtimes/language-interoperability/interoperability/typescript-execution/test-execution.md) — Marks specific functions as tests to be executed by the compiler on request. ([source](https://c3-lang.org/faq/allfeatures/))
- [Code Generation from Strings](https://awesome-repositories.com/f/programming-languages-runtimes/literal-string-compilations/code-generation-from-strings.md) — C3 converts strings containing expressions into executable values during the compilation process. ([source](https://c3-lang.org/blog/))
- [Mathematical Computing Utilities](https://awesome-repositories.com/f/programming-languages-runtimes/mathematical-computing-utilities.md) — Provides standard library support for complex numbers, matrices, vectors, and big integers. ([source](https://c3-lang.org/standard-library/docs.html))
- [Conditional Imports](https://awesome-repositories.com/f/programming-languages-runtimes/module-importing/conditional-imports.md) — Prevents the compiler from checking imports if a module activation condition is evaluated as false. ([source](https://c3-lang.org/blog/archive/2025/))
- [Module Aliasing](https://awesome-repositories.com/f/programming-languages-runtimes/module-importing/configuration-module-imports/module-aliasing.md) — Allows the creation of short custom names for modules to improve code organization. ([source](https://c3-lang.org/blog/archive/2025/))
- [Recursive Imports](https://awesome-repositories.com/f/programming-languages-runtimes/module-importing/recursive-imports.md) — Automatically loads a module and all its sub-modules so their contents are directly available. ([source](https://c3-lang.org/blog/archive/2024/))
- [Swizzle Indexing](https://awesome-repositories.com/f/programming-languages-runtimes/multidimensional-arrays/advanced-array-indexing/swizzle-indexing.md) — Implements shorthand labels like xyzw for concise rearrangement and selection of vector components. ([source](https://c3-lang.org/blog/archive/2024/))
- [Operator Overloading](https://awesome-repositories.com/f/programming-languages-runtimes/operator-overloading.md) — Implements standard mathematical and bitwise operators for user-defined types. ([source](https://c3-lang.org/generic-programming/operator-overloading/))
- [Operator Overloading for Indexing](https://awesome-repositories.com/f/programming-languages-runtimes/operator-overloading-for-indexing.md) — Implements indexing, reference retrieval, and assignment operators to allow custom types to be accessed like arrays. ([source](https://c3-lang.org/generic-programming/operator-overloading/))
- [Parameter Access Constraints](https://awesome-repositories.com/f/programming-languages-runtimes/parameter-access-constraints.md) — Restricts function parameters to read-only or write-only access to prevent unintended modifications of data. ([source](https://c3-lang.org/language-fundamentals/functions/))
- [Structural Type Equivalences](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/structural-type-equivalences.md) — Provides an opt-in typing system where compatibility is determined by the data structure rather than explicit declarations. ([source](https://c3-lang.org/blog/archive/2021/))
- [Function Signature Enforcement](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/functional/generic-function-definitions/function-signature-enforcement.md) — Validates pre-conditions and post-conditions through static analysis and runtime asserts. ([source](https://c3-lang.org/language-common/contracts/))
- [Pure Functions](https://awesome-repositories.com/f/programming-languages-runtimes/pure-functions.md) — Allows marking functions as having no side effects to enable compiler optimizations based on state. ([source](https://c3-lang.org/language-common/contracts/))
- [Enum Reflection](https://awesome-repositories.com/f/programming-languages-runtimes/reflection-apis/enum-reflection.md) — Provides runtime inspection and metadata retrieval for enumeration constants. ([source](https://c3-lang.org/language-overview/examples/))
- [Return Value Enforcement Attributes](https://awesome-repositories.com/f/programming-languages-runtimes/return-value-enforcement-attributes.md) — Enforces that function return values must not be silently discarded through compiler-level specifications. ([source](https://c3-lang.org/language-common/attributes/))
- [Runtime Assertion Validation](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-assertion-validation.md) — Validates pre-conditions and post-conditions via assertions to trigger a diagnostic report upon failure. ([source](https://c3-lang.org/misc-advanced/debugging/))
- [Runtime Type Detection](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtimes/type-definition-systems/runtime-type-dispatching/runtime-type-detection.md) — Retrieves type identifiers from objects during execution to enable runtime polymorphism. ([source](https://c3-lang.org/generic-programming/reflection/))
- [Emscripten Support](https://awesome-repositories.com/f/programming-languages-runtimes/source-code-compilers/multi-target-compilers/emscripten-support.md) — Provides integrated support for compiling source code to the web using the Emscripten toolchain. ([source](https://c3-lang.org/blog/archive/2026/))
- [Source Code Documentation](https://awesome-repositories.com/f/programming-languages-runtimes/source-code-documentation.md) — Embeds descriptive text and formal contracts directly into the source code using special delimiters. ([source](https://c3-lang.org/language-fundamentals/comments/))
- [Source Library Packaging](https://awesome-repositories.com/f/programming-languages-runtimes/source-library-packaging.md) — Bundles source files and linked libraries into a distributable format with a manifest for managing dependencies. ([source](https://c3-lang.org/misc-advanced/library-packaging/))
- [Libc Customization](https://awesome-repositories.com/f/programming-languages-runtimes/standard-library-implementations/libc-customization.md) — Allows developers to specify a custom libc implementation through compiler flags to replace the default standard library. ([source](https://c3-lang.org/blog/))
- [State Machine Switch Control](https://awesome-repositories.com/f/programming-languages-runtimes/state-machine-switch-control.md) — Jumps to subsequent cases or specific labeled cases using a dedicated keyword for state machines. ([source](https://c3-lang.org/language-fundamentals/statements/))
- [Static Contract Analysis](https://awesome-repositories.com/f/programming-languages-runtimes/static-contract-analysis.md) — Inlines function requirements at the caller site to catch violations during compilation. ([source](https://c3-lang.org/blog/archive/2025/))
- [Struct Composition](https://awesome-repositories.com/f/programming-languages-runtimes/struct-composition.md) — Enables a form of inheritance and composition by embedding structs within other structs. ([source](https://c3-lang.org/blog/archive/2021/))
- [Subarray Slicing](https://awesome-repositories.com/f/programming-languages-runtimes/subarray-slicing.md) — Uses slices to handle contiguous segments of arrays and supports bulk assignment. ([source](https://c3-lang.org/blog/archive/2021/))
- [Substruct Conversions](https://awesome-repositories.com/f/programming-languages-runtimes/substruct-conversions.md) — Allows the implicit use of substruct pointers or values in place of their parent structs. ([source](https://c3-lang.org/language-rules/conversion/))
- [Symbol Linkage Control](https://awesome-repositories.com/f/programming-languages-runtimes/symbol-linkage-control.md) — Sets external names for symbols and marks them for export to ensure visibility during the linking process. ([source](https://c3-lang.org/language-common/attributes/))
- [Exported Symbols](https://awesome-repositories.com/f/programming-languages-runtimes/symbolic-identifiers/exported-symbols.md) — Marks functions and globals for linker visibility to enable the construction of dependency graphs. ([source](https://c3-lang.org/blog/archive/2023/))
- [Tagged Unions](https://awesome-repositories.com/f/programming-languages-runtimes/tagged-unions.md) — C3 defines a type that can hold one of several different members in the same memory location. ([source](https://c3-lang.org/language-common/structs-and-unions/))
- [Type Aliasing](https://awesome-repositories.com/f/programming-languages-runtimes/type-aliasing.md) — Defines alternative names for types, functions, and variables to simplify complex signatures. ([source](https://c3-lang.org/c-to-c3/a-guide-for-c-programmers/))
- [Type-Associated Macros](https://awesome-repositories.com/f/programming-languages-runtimes/type-associated-macros.md) — C3 defines macros as methods on a specific type to be called via dot notation. ([source](https://c3-lang.org/generic-programming/macros/))
- [Type Conversion and Casting](https://awesome-repositories.com/f/programming-languages-runtimes/type-conversion-and-casting.md) — Manages the conversion of pointers via void types and enforces explicit casts for vector transformations. ([source](https://c3-lang.org/language-rules/conversion/))
- [Type Identifier Conversions](https://awesome-repositories.com/f/programming-languages-runtimes/type-identifier-conversions.md) — Implicitly converts constant type identifiers to usable types for macros and assignments. ([source](https://c3-lang.org/blog/archive/2025/))
- [Type Member Introspection](https://awesome-repositories.com/f/programming-languages-runtimes/type-member-introspection.md) — Retrieves a comprehensive list of all members within a struct or union via type properties. ([source](https://c3-lang.org/language-common/structs-and-unions/))
- [Type Methods](https://awesome-repositories.com/f/programming-languages-runtimes/type-methods.md) — Enables functions to be associated with any type, including built-in types, for dot-syntax invocation. ([source](https://c3-lang.org/faq/allfeatures/))
- [Generic Method Implementations](https://awesome-repositories.com/f/programming-languages-runtimes/type-methods/generic-method-implementations.md) — Adds functions to generic types that apply to all instantiations or specific concrete types. ([source](https://c3-lang.org/generic-programming/generics/))
- [Undefined Behavior Detection](https://awesome-repositories.com/f/programming-languages-runtimes/undefined-behavior-detection.md) — Prints an error trace and aborts execution when undefined operations occur during debug builds. ([source](https://c3-lang.org/language-rules/undefined-behaviour/))
- [Logical Operation Evaluation](https://awesome-repositories.com/f/programming-languages-runtimes/undefined-behavior-detection/integer-overflow-detections/compile-time/logical-operation-evaluation.md) — C3 evaluates logical AND and OR operations at compile time without type-checking unnecessary branches. ([source](https://c3-lang.org/blog/archive/2024/))
- [Labeled Scope Breaks](https://awesome-repositories.com/f/programming-languages-runtimes/variable-scope-controls/scope-guards/labeled-scope-breaks.md) — Uses labels on conditional or loop statements to break or continue execution at a specific outer scope. ([source](https://c3-lang.org/language-fundamentals/statements/))
- [Vector Masking and Reduction](https://awesome-repositories.com/f/programming-languages-runtimes/vector-masking-and-reduction.md) — Implements vector reduction to single values and mask-based rearrangement of multiple vectors. ([source](https://c3-lang.org/misc-advanced/builtins/))
- [Vector Swizzling](https://awesome-repositories.com/f/programming-languages-runtimes/vector-swizzling.md) — Provides named swizzle notation for accessing and reassigning specific elements within vectors. ([source](https://c3-lang.org/language-common/vectors/))
- [Wasm Module Configuration](https://awesome-repositories.com/f/programming-languages-runtimes/webassembly-module-structural-definitions/wasm-module-configuration.md) — Enables the definition of freestanding WebAssembly targets and the support for named modules via attributes. ([source](https://c3-lang.org/blog/archive/2024/))

### Software Engineering & Architecture

- [Error Management](https://awesome-repositories.com/f/software-engineering-architecture/error-handling/error-management.md) — Implements a zero-overhead result-based system to track and manage operation failures without exception overhead. ([source](https://cdn.jsdelivr.net/gh/c3lang/c3c@master/README.md))
- [Error Handling](https://awesome-repositories.com/f/software-engineering-architecture/error-handling.md) — Provides native language constructs to represent and propagate error states throughout a program. ([source](https://c3-lang.org/blog/archive/2021/))
- [Error Handling Patterns](https://awesome-repositories.com/f/software-engineering-architecture/error-handling-patterns.md) — Manages failures using a type system where errors are explicit return values, supported by try/catch blocks. ([source](https://c3-lang.org/blog/archive/2020/))
- [Monadic Error Handling](https://awesome-repositories.com/f/software-engineering-architecture/error-handling-strategies/monadic-error-handling.md) — Tracks operation failures using a zero-overhead system of optional types and fault constants instead of exceptions.
- [Exception-Equivalent Result Types](https://awesome-repositories.com/f/software-engineering-architecture/error-handling-strategies/monadic-error-handling/exception-equivalent-result-types.md) — Implements an error handling system that combines the efficiency of result types with the usability of exceptions. ([source](https://c3-lang.org))
- [Zero-Overhead Failure Types](https://awesome-repositories.com/f/software-engineering-architecture/error-handling-strategies/monadic-error-handling/failure-value-handlers/zero-overhead-failure-types.md) — Uses optionals and zero-overhead error types to manage failure states without sacrificing performance. ([source](https://c3-lang.org/getting-started/introduction/))
- [Flow Typing](https://awesome-repositories.com/f/software-engineering-architecture/error-handling-strategies/monadic-error-handling/generalized-error-handling-for-custom-types/flow-typing.md) — Handles failures using optional result types with flow typing for automatic unwrapping. ([source](https://c3-lang.org/language-overview/examples/))
- [Error Propagation Systems](https://awesome-repositories.com/f/software-engineering-architecture/error-propagation-systems.md) — Uses optional return types and specialized operators to propagate faults or provide default values. ([source](https://c3-lang.org/faq/allfeatures/))
- [Memory Manipulation](https://awesome-repositories.com/f/software-engineering-architecture/integer-arithmetic/pointer-arithmetic/memory-manipulation.md) — C3 performs volatile and unaligned load and store operations to interact with hardware. ([source](https://c3-lang.org/blog/))
- [Optional Value Types](https://awesome-repositories.com/f/software-engineering-architecture/optional-value-types.md) — Provides mechanisms to declare, check, and extract values from optional types, including default fallbacks. ([source](https://c3-lang.org/blog/))
- [Result-Type Integration](https://awesome-repositories.com/f/software-engineering-architecture/optional-value-types/result-type-integration.md) — Integrates optional values into the type system as result types to represent operation success or failure. ([source](https://c3-lang.org/blog/archive/2022/))
- [Sentinel Value Replacement](https://awesome-repositories.com/f/software-engineering-architecture/optional-value-types/sentinel-value-replacement.md) — Wraps return values with results or excuses to replace sentinel values like null. ([source](https://c3-lang.org/language-common/optionals-essential/))
- [Value Unwrapping](https://awesome-repositories.com/f/software-engineering-architecture/optional-value-types/value-unwrapping.md) — Extracts the inner value of an optional or returns the associated excuse to the caller. ([source](https://c3-lang.org/language-common/optionals-essential/))
- [Compile-Time Metaprogramming](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/abstraction-domain-modeling/compile-time-architectural-patterns/compile-time-metaprogramming.md) — C3 runs logic, loops, and conditional statements during compilation to fold constants and generate code. ([source](https://c3-lang.org/faq/allfeatures/))
- [Error-Excuse Return Types](https://awesome-repositories.com/f/software-engineering-architecture/typescript-type-definitions/return-type-annotations/optional-return-types/error-excuse-return-types.md) — Returns results or error excuses using optional types to enable efficient function chaining. ([source](https://c3-lang.org/language-fundamentals/functions/))
- [String-to-Code Conversion](https://awesome-repositories.com/f/software-engineering-architecture/compile-time-code-generation/string-to-code-conversion.md) — C3 transforms compile-time strings into active code, variables, or functions for dynamic code generation. ([source](https://c3-lang.org/generic-programming/compiletime/))
- [Compiler Optimizations](https://awesome-repositories.com/f/software-engineering-architecture/compiler-optimizations.md) — Forces or prevents function inlining and disables sanitizer instrumentation for specific functions. ([source](https://c3-lang.org/language-common/attributes/))
- [Kernel Object Contract Enforcements](https://awesome-repositories.com/f/software-engineering-architecture/concurrent-object-access/kernel-object-contract-enforcements.md) — Adds pre-conditions and post-conditions to functions to assist in static analysis. ([source](https://c3-lang.org/all/))
- [Cross-Platform Abstractions](https://awesome-repositories.com/f/software-engineering-architecture/cross-platform-abstractions.md) — Supplies a standard library with dynamic containers and strings to enable portable development across platforms. ([source](https://c3-lang.org/getting-started/introduction/))
- [Design by Contract](https://awesome-repositories.com/f/software-engineering-architecture/design-by-contract.md) — Uses a specific syntax to declare documentation and contract blocks distinct from standard comments. ([source](https://c3-lang.org/blog/archive/2024/))
- [Jump Table Optimizations](https://awesome-repositories.com/f/software-engineering-architecture/dispatch-tables/jump-table-optimizations.md) — Forces the implementation of switch statements as jump tables to achieve high-performance dispatch. ([source](https://c3-lang.org/language-fundamentals/statements/))
- [Optional-Argument Dispatch](https://awesome-repositories.com/f/software-engineering-architecture/dynamic-task-scheduling/runtime-invokers/conditional-function-dispatch/optional-argument-dispatch.md) — Runs a function only when all optional arguments contain values, otherwise returning the first excuse. ([source](https://c3-lang.org/language-common/optionals-essential/))
- [Try-Macro Propagation](https://awesome-repositories.com/f/software-engineering-architecture/error-handling-strategies/monadic-error-handling/try-macro-propagation.md) — Conditionally assigns a value from an optional result and returns the fault if the operation fails via a try macro. ([source](https://c3-lang.org/blog/archive/2025/))
- [Identifier-to-Type Resolutions](https://awesome-repositories.com/f/software-engineering-architecture/generic-type-definitions/generic-type-resolution/identifier-to-type-resolutions.md) — Allows the creation of usable types from strings or type identifiers during compilation. ([source](https://c3-lang.org/generic-programming/reflection/))
- [Library Dependency Managers](https://awesome-repositories.com/f/software-engineering-architecture/library-compatibility-managers/library-dependency-managers.md) — Detects and compiles required dependent libraries automatically when a target library is linked to a project. ([source](https://c3-lang.org/misc-advanced/library-packaging/))
- [Relational Operator Overloading](https://awesome-repositories.com/f/software-engineering-architecture/logical-comparison-operators/decimal-comparison-operators/relational-operator-overloading.md) — Implements equality and ordering operators to enable custom types to be compared using relational syntax. ([source](https://c3-lang.org/generic-programming/operator-overloading/))
- [Memory Alignment Utilities](https://awesome-repositories.com/f/software-engineering-architecture/memory-alignment-utilities.md) — Defines memory alignment for types via typedef to safely reference members within packed structures. ([source](https://c3-lang.org/blog/))
- [Bit-Packed Storage](https://awesome-repositories.com/f/software-engineering-architecture/memory-layout-optimizations/bit-packed-storage.md) — Allows precise control over memory layout by storing fields in specific bit ranges. ([source](https://c3-lang.org/all/))
- [Bit-Range Field Mapping](https://awesome-repositories.com/f/software-engineering-architecture/memory-layout-optimizations/bit-packed-storage/bit-range-field-mapping.md) — Maps integer and boolean fields to specific bit ranges within a backing type. ([source](https://c3-lang.org/language-common/bitstructs/))
- [Bitstruct Definitions](https://awesome-repositories.com/f/software-engineering-architecture/memory-layout-optimizations/bit-packed-storage/bitstruct-definitions.md) — Uses bitstructs to provide precise control over the bit-level layout of data. ([source](https://c3-lang.org/faq/allfeatures/))
- [Code Annotations](https://awesome-repositories.com/f/software-engineering-architecture/metadata-attachments/code-annotations.md) — Marks symbols as deprecated, unused, or mandatory to trigger specific compiler warnings. ([source](https://c3-lang.org/language-common/attributes/))
- [Operator Precedence Management](https://awesome-repositories.com/f/software-engineering-architecture/operator-precedence-management.md) — Determines the order of operation for arithmetic, bitwise, and relational operators. ([source](https://c3-lang.org/language-rules/precedence/))
- [Interface-Based Polymorphic Collections](https://awesome-repositories.com/f/software-engineering-architecture/polymorphism-patterns/interface-based-polymorphic-collections.md) — Maintains collections of values implementing specific interfaces for runtime polymorphic programming. ([source](https://c3-lang.org/blog/archive/2025/))
- [Volatile Register Access](https://awesome-repositories.com/f/software-engineering-architecture/shared-memory-management/memory-access-profilers/volatile-register-access.md) — C3 executes volatile loads and stores to prevent the compiler from optimizing away memory accesses. ([source](https://c3-lang.org/blog/archive/2026/))
- [Compile-Time Data Slicing](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/abstraction-domain-modeling/compile-time-architectural-patterns/compile-time-metaprogramming/compile-time-data-slicing.md) — C3 executes slicing operations on arrays, strings, and constant slices during compilation. ([source](https://c3-lang.org/blog/archive/2024/))
- [Compile-Time String Concatenation](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/abstraction-domain-modeling/compile-time-architectural-patterns/compile-time-metaprogramming/compile-time-string-concatenation.md) — C3 joins strings and type names together at compile time using a dedicated concatenation operator. ([source](https://c3-lang.org/blog/archive/2024/))
- [Compile-Time String Manipulation](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/abstraction-domain-modeling/compile-time-architectural-patterns/compile-time-metaprogramming/compile-time-string-manipulation.md) — C3 modifies strings during compilation using macros for case conversion and text replacement. ([source](https://c3-lang.org/blog/archive/2025/))
- [String Transformations](https://awesome-repositories.com/f/software-engineering-architecture/software-architecture/architectural-patterns/abstraction-domain-modeling/compile-time-architectural-patterns/compile-time-metaprogramming/string-transformations.md) — C3 transforms strings into different casings during compilation to automate code generation. ([source](https://c3-lang.org/blog/))
- [Grouped Parallel Execution](https://awesome-repositories.com/f/software-engineering-architecture/task-scheduling/parallel-task-executors/grouped-parallel-execution.md) — Enables enqueuing multiple tasks for concurrent execution and collecting their results using thread groups. ([source](https://c3-lang.org/blog/archive/2026/))
- [Runtime Safety Toggling](https://awesome-repositories.com/f/software-engineering-architecture/training-mode-configurators/safety-mode-configurators/runtime-safety-toggling.md) — Switches between a safe mode with runtime checks and a fast mode that omits them. ([source](https://c3-lang.org/faq/allfeatures/))

### Part of an Awesome List

- [Memory Allocators](https://awesome-repositories.com/f/awesome-lists/devtools/memory-allocators.md) — Implements general memory allocation for arrays and lists using either the heap or temporary pools. ([source](https://c3-lang.org/blog/archive/2023/))
- [Build and Dependency Management](https://awesome-repositories.com/f/awesome-lists/devtools/build-and-dependency-management.md) — Downloads missing dependencies into the correct directory and adds new requirements via command line tools. ([source](https://c3-lang.org/blog/archive/2024/))
- [Reflection](https://awesome-repositories.com/f/awesome-lists/devtools/reflection.md) — Inspects type information at both compile time and runtime to support generic functions. ([source](https://c3-lang.org))
- [Reflection and Metadata](https://awesome-repositories.com/f/awesome-lists/devtools/reflection-and-metadata.md) — Attaches compile-time tags to types and variables to manage reflection information. ([source](https://c3-lang.org/language-common/attributes/))
- [Attribute Reflection](https://awesome-repositories.com/f/awesome-lists/devtools/reflection-and-metadata/attribute-reflection.md) — C3 retrieves attributes and tags from types or members at compile time using reflection. ([source](https://c3-lang.org/blog/archive/2026/))
- [Member](https://awesome-repositories.com/f/awesome-lists/devtools/reflection/member.md) — C3 retrieves associated methods and generates runtime getters via member reflection. ([source](https://c3-lang.org/blog/archive/2024/))
- [Runtime Reflection](https://awesome-repositories.com/f/awesome-lists/devtools/runtime-reflection.md) — Provides access to basic type information during program execution. ([source](https://c3-lang.org/faq/allfeatures/))
- [SIMD ABI Optimizations](https://awesome-repositories.com/f/awesome-lists/devtools/simd-optimization/simd-abi-optimizations.md) — Passes vectors as arrays in function calls to maintain binary compatibility with C libraries. ([source](https://c3-lang.org/blog/))

### Data & Databases

- [Dynamic Collections](https://awesome-repositories.com/f/data-databases/append-only-storage-engines/dynamic-collections.md) — Ships heap-allocated collections that support dynamic growth and element insertion. ([source](https://c3-lang.org/language-common/arrays/))
- [Contiguous Fixed Arrays](https://awesome-repositories.com/f/data-databases/contiguous-fixed-arrays.md) — Implements fixed-length arrays that maintain a contiguous memory layout and prevent decay into pointers. ([source](https://c3-lang.org/language-common/arrays/))
- [Enumeration Types](https://awesome-repositories.com/f/data-databases/data-governance-modeling/data-modeling-schemas/data-schemas/enumeration-types.md) — Implements enumerated types with underlying integer values and isolated namespaces. ([source](https://c3-lang.org/language-common/enums/))
- [Enum Definitions](https://awesome-repositories.com/f/data-databases/enum-definitions.md) — Supports the definition of enums with arbitrary underlying types and gaps, maintaining compatibility with C-style enumerations. ([source](https://c3-lang.org/blog/archive/2025/))
- [Sum Type Associations](https://awesome-repositories.com/f/data-databases/maximum-value-calculators/associated-value-comparators/sum-type-associations.md) — Attaches specific data values to enumeration members to create rich sum types. ([source](https://c3-lang.org/blog/archive/2021/))
- [SIMD-Accelerated Arithmetic](https://awesome-repositories.com/f/data-databases/vectorized-arithmetic/simd-accelerated-arithmetic.md) — Executes arithmetic and bitwise operations across all elements of a vector using SIMD hardware instructions. ([source](https://c3-lang.org/language-common/vectors/))
- [First-Class Vector Types](https://awesome-repositories.com/f/data-databases/vectorized-arithmetic/simd-accelerated-arithmetic/first-class-vector-types.md) — Implements first-class vector types that map directly to hardware processor instructions for parallel data processing.
- [SIMD-Based Data Parallelism](https://awesome-repositories.com/f/data-databases/vectorized-arithmetic/simd-accelerated-arithmetic/simd-based-data-parallelism.md) — Executes parallel arithmetic and logical operations on hardware-backed vectors to maximize computational throughput. ([source](https://c3-lang.org/language-fundamentals/basic-types-and-values/))
- [Collection Iteration](https://awesome-repositories.com/f/data-databases/collection-iterators/collection-iteration.md) — Implements required length and indexing operators to enable a type to be used within a foreach loop. ([source](https://c3-lang.org/generic-programming/operator-overloading/))
- [Initializer Splatting](https://awesome-repositories.com/f/data-databases/data-mapping/struct-hydrators/row-to-struct-mappers/initializer-splatting.md) — Employs the splat operator to provide default values to struct initializers. ([source](https://c3-lang.org/blog/archive/2025/))
- [Array View Creation](https://awesome-repositories.com/f/data-databases/data-processing-pipelines/data-transformation/array-tensor-manipulation/array-filtering/array-view-creation.md) — Produces views into fixed or variable arrays using range syntax and inclusive indices. ([source](https://c3-lang.org/language-common/arrays/))
- [Collection Range Slicing](https://awesome-repositories.com/f/data-databases/data-querying/table-item-filters/numeric-range-filters/numeric-range-constraints/range-representations/text-range-definitions/data-range-selection/range-data-extraction/collection-range-slicing.md) — Provides a view into an underlying array or vector with built-in length tracking and range checking. ([source](https://c3-lang.org/language-fundamentals/basic-types-and-values/))
- [Numeric Type Promotions](https://awesome-repositories.com/f/data-databases/data-type-mappings/type-conversion-utilities/numeric-type-promotions.md) — Implements automatic numeric type promotions and widening to ensure compatibility between different numeric types. ([source](https://c3-lang.org/language-rules/conversion/))
- [Operation Type Unification](https://awesome-repositories.com/f/data-databases/data-type-mappings/type-conversion-utilities/numeric-type-promotions/operation-type-unification.md) — Determines the resulting type of binary operations by promoting operands to a common unified type. ([source](https://c3-lang.org/language-rules/conversion/))
- [Metadata Association](https://awesome-repositories.com/f/data-databases/enum-definitions/metadata-association.md) — Links static values to enum members, allowing metadata to be retrieved directly from the enum instance. ([source](https://c3-lang.org/language-common/enums/))
- [Symbol-to-Enum Conversions](https://awesome-repositories.com/f/data-databases/enum-definitions/symbol-to-enum-conversions.md) — Provides explicit casts and conversion methods to transform enum members into their underlying integer ordinals. ([source](https://c3-lang.org/language-common/enums/))
- [Endianness and Range Control](https://awesome-repositories.com/f/data-databases/memory-layouts/endianness-and-range-control.md) — Controls bit-level data layout for big-endian and little-endian storage and overlapping ranges. ([source](https://c3-lang.org/language-common/attributes/))
- [Pointer Access Restrictions](https://awesome-repositories.com/f/data-databases/null-value-representations/null-pointer-constants/pointer-access-restrictions.md) — Controls whether pointer arguments can be read from, written to, or both. ([source](https://c3-lang.org/language-common/contracts/))
- [Struct Defaulting](https://awesome-repositories.com/f/data-databases/tuple-data-structures/splat-unpacking/struct-defaulting.md) — Uses a splat operator to provide default values for struct members while allowing specific overrides. ([source](https://c3-lang.org/blog/))
- [Variadic Argument Splatting](https://awesome-repositories.com/f/data-databases/tuple-data-structures/splat-unpacking/variadic-argument-splatting.md) — Expands arrays or slices into a function's typed variable arguments using a splat operator. ([source](https://c3-lang.org/faq/allfeatures/))
- [Compile-Time Capability Checks](https://awesome-repositories.com/f/data-databases/type-inspection-tools/compile-time-capability-checks.md) — C3 checks if identifiers or operations are defined at compile time to conditionally execute code. ([source](https://c3-lang.org/generic-programming/reflection/))
- [Optional-to-C Mappings](https://awesome-repositories.com/f/data-databases/type-mapping-frameworks/script-to-native-type-mappings/native-type-mappings/rust-c-type-mappings/optional-to-c-mappings.md) — Converts optional types to C-compatible signatures using fault codes and reference pointers to return results. ([source](https://c3-lang.org/language-common/optionals-essential/))

### Development Tools & Productivity

- [Source Compilation Tools](https://awesome-repositories.com/f/development-tools-productivity/compilers-toolchains/source-compilation-tools.md) — Transforms source files into executable binaries, static libraries, or dynamic libraries using an LLVM backend. ([source](https://cdn.jsdelivr.net/gh/c3lang/c3c@master/README.md))
- [ABI-Compatible Compilers](https://awesome-repositories.com/f/development-tools-productivity/native-compilation/abi-compatible-compilers.md) — Ensures full ABI compatibility with C and C++ to share functions without the need for special types or wrappers. ([source](https://c3-lang.org/all/))
- [Module Organization](https://awesome-repositories.com/f/development-tools-productivity/node-js-dependency-managers/module-organization.md) — Uses a combination of modules and interfaces to manage code namespacing and encapsulation. ([source](https://c3-lang.org/getting-started/introduction/))
- [External Program Output Injection](https://awesome-repositories.com/f/development-tools-productivity/external-program-output-injection.md) — C3 runs an external command during compilation and inserts the output into the source code. ([source](https://c3-lang.org/language-fundamentals/modules/))
- [Enumerated Constants](https://awesome-repositories.com/f/development-tools-productivity/predefined-constants/geometric-constants/enumerated-constants.md) — Enables the creation of named constant groups that do not imply sequential ordinal mapping. ([source](https://c3-lang.org/blog/archive/2026/))
- [Non-Sequential Constants](https://awesome-repositories.com/f/development-tools-productivity/predefined-constants/geometric-constants/non-sequential-constants.md) — Creates named integer constants with custom values to maintain compatibility with non-sequential C enums. ([source](https://c3-lang.org/language-common/enums/))
- [Concurrent Task Groups](https://awesome-repositories.com/f/development-tools-productivity/thread-managers/execution-thread-coordinators/concurrent-task-groups.md) — Coordinates parallel execution and result collection through the use of thread groups. ([source](https://c3-lang.org/blog/))
- [Thread-Safe Communication Channels](https://awesome-repositories.com/f/development-tools-productivity/thread-managers/thread-safe-communication-channels.md) — Provides thread-safe communication channels for synchronizing data between concurrent execution units. ([source](https://c3-lang.org/blog/archive/2026/))

### DevOps & Infrastructure

- [Conditional Compilation](https://awesome-repositories.com/f/devops-infrastructure/cicd-pipeline-automation/core-build-engines/build-tooling/build-configuration-governance/platform-specific-source-resolution/conditional-compilation.md) — C3 uses compile-time evaluation to enable or disable code blocks based on predefined conditions. ([source](https://c3-lang.org/generic-programming/macros/))
- [Declaration Filtering](https://awesome-repositories.com/f/devops-infrastructure/cicd-pipeline-automation/core-build-engines/build-tooling/build-configuration-governance/platform-specific-source-resolution/conditional-compilation/declaration-filtering.md) — C3 includes or excludes top-level functions, variables, or struct members based on compile-time constant expressions. ([source](https://c3-lang.org/generic-programming/compiletime/))
- [Package Distribution](https://awesome-repositories.com/f/devops-infrastructure/package-distribution.md) — Cleans, builds, and bundles a target into a final package intended for delivery to end users. ([source](https://c3-lang.org/build-your-project/build-commands/))

### Operating Systems & Systems Programming

- [Hardware-Level Performance Tuning](https://awesome-repositories.com/f/operating-systems-systems-programming/hardware-level-performance-tuning.md) — Provides SIMD vector support and inline assembly to program hardware directly for maximum speed. ([source](https://c3-lang.org/getting-started/introduction/))
- [Dynamic Memory Allocation](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation.md) — Provides standard library utilities for allocating contiguous memory for slices on the heap. ([source](https://c3-lang.org/language-common/arrays/))
- [Custom Memory Allocators](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/custom-memory-allocators.md) — C3 manages memory allocation, alignment, and virtual memory mapping through custom allocators and pools. ([source](https://c3-lang.org/standard-library/docs.html))
- [Pluggable Memory Allocators](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/custom-memory-allocators/managed-memory-allocators/pluggable-memory-allocators.md) — Allows the injection of specific allocator instances into functions to control data residence. ([source](https://c3-lang.org/language-common/memory/))
- [Scoped Memory Pools](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/dynamic-memory-allocation/custom-memory-allocators/memory-object-pools/scoped-memory-pools.md) — Manages temporary allocations within regions that are automatically freed upon exiting a defined block.
- [Manual Memory Management](https://awesome-repositories.com/f/operating-systems-systems-programming/manual-memory-management.md) — C3 allocates objects on the stack or heap for varying data lifespans. ([source](https://c3-lang.org/language-common/memory/))
- [Operating Systems & Systems Programming](https://awesome-repositories.com/f/operating-systems-systems-programming.md) — Provides access to OS-specific APIs for Windows, Linux, and macOS to manage system processes. ([source](https://c3-lang.org/standard-library/docs.html))
- [Allocation Metadata Tracking](https://awesome-repositories.com/f/operating-systems-systems-programming/allocation-metadata-tracking.md) — Monitors the temporary allocator to detect use-after-scope bugs where short-lived data is stored in long-lived structures. ([source](https://c3-lang.org/misc-advanced/debugging/))
- [File I/O Management](https://awesome-repositories.com/f/operating-systems-systems-programming/file-i-o-management.md) — Provides primitives for reading, writing, and managing files, including memory-mapped I/O operations. ([source](https://c3-lang.org/standard-library/docs.html))
- [Inline Assembly Interfaces](https://awesome-repositories.com/f/operating-systems-systems-programming/inline-assembly-interfaces.md) — Allows the insertion of low-level assembly code directly into the source via strings or blocks. ([source](https://c3-lang.org))
- [Low-Level System Operations](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/memory-management/allocation-strategies/memory-allocation-libraries/low-level-system-operations.md) — Interfaces directly with the operating system via syscalls and retrieves high-resolution hardware cycle counters. ([source](https://c3-lang.org/misc-advanced/builtins/))
- [Data Endianness](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/system-programming-primitives/system-programming/data-endianness.md) — Performs input and output operations using little-endian byte ordering for specific data formats. ([source](https://c3-lang.org/blog/archive/2025/))
- [Memory Alignment Attributes](https://awesome-repositories.com/f/operating-systems-systems-programming/memory-alignment-attributes.md) — Allows the creation of types with specific byte alignments using the @align attribute. ([source](https://c3-lang.org/blog/archive/2025/))
- [Runtime Safety Validators](https://awesome-repositories.com/f/operating-systems-systems-programming/memory-safety-diagnostics/runtime-safety-validators.md) — Provides a safe mode that injects runtime checks to mitigate undefined behavior. ([source](https://cdn.jsdelivr.net/gh/c3lang/c3c@master/README.md))
- [Musl libc Targeting](https://awesome-repositories.com/f/operating-systems-systems-programming/platform-development-integration/platform-sdks/linux-sdks/linux-build-targets/musl-libc-targeting.md) — Supports compilation specifically for the musl libc implementation on Linux using dedicated compiler flags. ([source](https://c3-lang.org/blog/archive/2025/))
- [Stack Overflow Protections](https://awesome-repositories.com/f/operating-systems-systems-programming/stack-overflow-protections.md) — Provides compiler-level flags to cap the maximum size of stack objects to prevent stack overflow crashes. ([source](https://c3-lang.org/blog/archive/2025/))

### Scientific & Mathematical Computing

- [Multi-Dimensional Arrays](https://awesome-repositories.com/f/scientific-mathematical-computing/multi-dimensional-arrays.md) — Supports the creation of fixed-size arrays with multiple dimensions, including irregular array structures. ([source](https://c3-lang.org/language-common/arrays/))
- [Vector Operations](https://awesome-repositories.com/f/scientific-mathematical-computing/vector-operations.md) — Executes element-wise arithmetics and swizzling on numerical vectors using SIMD implementations. ([source](https://c3-lang.org/all/))
- [Bit-Range Field Accessors](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/algorithms-and-complexity/algorithms/bit-manipulation-techniques/bit-range-manipulators/bit-range-field-accessors.md) — Provides specialized get and set methods to modify specific bit-range values within a bitstruct. ([source](https://c3-lang.org/blog/archive/2025/))
- [Vector](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/computational-geometry/geometric-operations/vector.md) — Provides built-in methods for computing dot products, cross products, and vector normalization. ([source](https://c3-lang.org/language-common/vectors/))

### Content Management & Publishing

- [Documentation Generators](https://awesome-repositories.com/f/content-management-publishing/content-management-systems/content-architecture-modeling/documentation-tooling/generation-publishing/documentation-generators.md) — Produces navigable documentation by extracting comments and contracts written directly within the source code. ([source](https://c3-lang.org/build-your-project/build-commands/))

### Education & Learning Resources

- [Multithreading Primitives](https://awesome-repositories.com/f/education-learning-resources/multithreading-primitives.md) — Implements concurrent execution using threads, thread pools, and communication channels. ([source](https://c3-lang.org/standard-library/docs.html))

### Hardware & IoT

- [Binary-Embedded File Systems](https://awesome-repositories.com/f/hardware-iot/binary-embedded-file-systems.md) — C3 includes external files as binary data or text directly into the compiled binary. ([source](https://c3-lang.org/faq/allfeatures/))

### Security & Cryptography

- [Cryptographic Operations](https://awesome-repositories.com/f/security-cryptography/cryptographic-operations.md) — Implements standard encryption and decryption algorithms to protect data and verify identities. ([source](https://c3-lang.org/standard-library/docs.html))
- [Data Hashing Utilities](https://awesome-repositories.com/f/security-cryptography/data-hashing-utilities.md) — Generates checksums and hashes using SHA, CRC, and BLAKE to verify the integrity of data buffers. ([source](https://c3-lang.org/standard-library/docs.html))
- [Runtime Bounds Checking](https://awesome-repositories.com/f/security-cryptography/memory-bounds-checking/runtime-bounds-checking.md) — Inserts automatic runtime bounds and value checks during debug builds to identify bugs early. ([source](https://c3-lang.org))
- [Cryptographic Hash Computations](https://awesome-repositories.com/f/security-cryptography/security/cryptography-and-secrets/cryptographic-primitives-management/cryptographic-hash-computations.md) — Computes secure cryptographic hashes using algorithms including SHA3, Blake3, and Argon2. ([source](https://c3-lang.org/blog/archive/2026/))

### System Administration & Monitoring

- [Sanitizer Integrations](https://awesome-repositories.com/f/system-administration-monitoring/memory-usage-analyzers/memory-usage-analyzers/memory-integrity-auditors/sanitizer-integrations.md) — Connects with external sanitizers to detect memory corruption and race conditions during execution. ([source](https://c3-lang.org/misc-advanced/debugging/))

### Testing & Quality Assurance

- [Memory Leak Detection](https://awesome-repositories.com/f/testing-quality-assurance/debugging-diagnostics/memory-leak-detection.md) — Tracks memory usage and reports unfreed allocations to ensure no leaks occur within a specific code scope. ([source](https://c3-lang.org/misc-advanced/debugging/))
- [General Bug Detection](https://awesome-repositories.com/f/testing-quality-assurance/general-bug-detection.md) — Inserts bounds and value checks during debug builds to catch memory and logic errors. ([source](http://www.c3-lang.org/))
- [Unit Testing](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/unit/unit-testing.md) — Executes specific code blocks using testing macros to identify failures through descriptive error messages. ([source](https://c3-lang.org/build-your-project/build-commands/))