awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
exaloop avatar

exaloop/codon

0
View on GitHub↗
docs.exaloop.io↗

Codon

Codon is an LLVM-based Python compiler and statically typed implementation that translates source code into optimized machine instructions. It functions as a high-performance numerical backend and a GPU computing framework designed to remove runtime overhead.

The project implements a compiled alternative to NumPy, translating array logic directly into machine code. It differentiates itself by generating specialized hardware kernels for graphics processors and utilizing static type inference to enable aggressive machine-code optimization.

The system provides capabilities for parallel workload execution through native multithreading and high-performance numerical computing. It also includes an interoperability layer to import and integrate existing Python packages into the compiled environment.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Features

  • LLVM-Based Compilers - Uses the LLVM toolchain to compile Python source code into optimized machine instructions.
  • Compiled Numerical Backends - Provides a high-performance numerical backend that implements array operations via direct machine-code translation.
  • Compiled Hardware Kernels - Executes specialized functions on graphics hardware by compiling them into optimized hardware kernels.
  • GPU Kernel Code Generators - Translates high-level functions into specialized hardware instructions for execution on graphics processors.
  • Multithreaded Runtime Support - Provides a system-level threading model to distribute computational workloads across multiple CPU cores.
  • Execution Performance Optimizers - Translates Python source code into optimized machine code to bypass interpreted execution overhead.
  • LLVM-Based Implementations - Translates Python source code into optimized machine instructions using the LLVM toolchain.
  • Source Code Compilers - Translates Python source code into optimized machine code to maximize execution speed.
  • Static Type Inference - Uses static type inference during compilation to remove runtime overhead and optimize machine code.
  • Native Array Backends - Implements a high-performance array backend that translates array logic directly into machine code.
  • GPU-Accelerated Computation - Offloads heavy processing tasks to the graphics processor to accelerate intensive operations.
  • High-Performance Scientific Computing - Provides a high-performance environment for numerical computing using multidimensional arrays and optimized primitives.
  • Vectorized Array Operations - Performs mathematical operations using a compiled implementation of vectorized array tools.
  • Hardware-Threaded Loop Distribution - Distributes loop iterations across physical hardware threads to maximize CPU throughput.
  • Compiled Runtime Integrations - Allows the execution of existing Python libraries within the compiled environment to share common logic.
  • Foreign Function Interfaces - Ships a low-level interoperability layer for exchanging data and calling external libraries.
  • Statically Typed Implementations - Uses static type inference to remove runtime overhead and enable aggressive machine-code optimization.
  • Language Interoperability Layers - Combines compiled high-performance code with external Python libraries through an interoperability layer.
  • External Library Interoperability - Enables the import of external Python packages into the compiled environment via an interoperability layer.
  • Parallel Task Execution - Distributes computational tasks across multiple CPU threads to reduce total execution time.
  • Parallel Programming Frameworks - High-performance Python compiler targeting native machine code.
16,803 stars·604 forks·Python·Apache-2.0·15 views

Star history

Star history chart for exaloop/codonStar history chart for exaloop/codon

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Projects sharing features with Codon

These projects share indexed features with Codon. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • arrayfire/arrayfirearrayfire avatar

    arrayfire/arrayfire

    4,888View on GitHub↗

    ArrayFire is a hardware-agnostic compute framework and JIT-compiled tensor engine designed for high-performance numerical computing. It serves as a GPU numerical computing library and parallel signal processing toolkit that abstracts hardware backends, allowing the same codebase to execute across various GPU architectures and CPUs. The project distinguishes itself through a JIT engine that uses expression compilation to fuse operations and minimize memory overhead. It employs a deferred execution graph to optimize computation chains and provides interoperability primitives to share data and e

    C++arrayfirecc-plus-plus
    View on GitHub↗4,888
  • juliagpu/cuda.jlJuliaGPU avatar

    JuliaGPU/CUDA.jl

    1,409View on GitHub↗

    CUDA.jl provides a programming interface for executing custom kernels and performing parallel array computing directly on NVIDIA graphics hardware using the Julia language. It serves as a framework for compiling and scheduling user-defined functions across multiple processing cores, enabling high-performance data processing and task synchronization. The library distinguishes itself through a custom compiler backend that translates high-level language functions into hardware-specific machine code. It manages complex hardware interactions through asynchronous stream scheduling, unified memory m

    Juliacudagpuhacktoberfest
    View on GitHub↗1,409
  • c3lang/c3cc3lang avatar

    c3lang/c3c

    5,147View on GitHub↗

    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 inte

    C3c3compilerlanguage
    View on GitHub↗5,147
  • apple/swiftapple avatar

    apple/swift

    70,119View on GitHub↗

    Swift is a general purpose, compiled systems programming language designed for building high-performance software. It is a strongly typed language that focuses on memory safety and type safety to prevent runtime errors. The language is designed for native code integration, allowing it to interoperate with C and Objective-C libraries to leverage existing system functions and high-performance APIs. The project covers broad capabilities in type-safe application development and cross-platform toolchain engineering. It includes infrastructure for automated language validation, compiler performanc

    Swift
    View on GitHub↗70,119
Compare all 30 related projects→

Frequently asked questions

What does exaloop/codon do?

Codon is an LLVM-based Python compiler and statically typed implementation that translates source code into optimized machine instructions. It functions as a high-performance numerical backend and a GPU computing framework designed to remove runtime overhead.

What are the main features of exaloop/codon?

The main features of exaloop/codon are: LLVM-Based Compilers, Compiled Numerical Backends, Compiled Hardware Kernels, GPU Kernel Code Generators, Multithreaded Runtime Support, Execution Performance Optimizers, LLVM-Based Implementations, Source Code Compilers.

Which projects share features with exaloop/codon?

Projects with overlapping indexed features include: arrayfire/arrayfire — ArrayFire is a hardware-agnostic compute framework and JIT-compiled tensor engine designed for high-performance… juliagpu/cuda.jl — CUDA.jl provides a programming interface for executing custom kernels and performing parallel array computing directly… c3lang/c3c — c3c is the compiler for the C3 programming language, transforming source code into executable binaries, static… dotnet/fsharp — F# is a strongly typed, functional programming language and compiler for the .NET ecosystem. It transforms functional… apple/swift — Swift is a general purpose, compiled systems programming language designed for building high-performance software. It… ponylang/ponyc — Pony is an open-source, actor-model, capabilities-secure, high performance programming language.