awesome-repositories.com
Blog
awesome-repositories.com

Entdecke die besten Open-Source-Repositories mit KI-gestützter Suche.

EntdeckenKuratierte SuchenOpen-Source-AlternativenSelf-hosted SoftwareBlogSitemap
ProjektÜber unsRanking-MethodikPresseMCP-Server
RechtlichesDatenschutzAGB
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

21 Repos

Awesome GitHub RepositoriesCompiler Optimizations

Techniques used by compilers to improve the execution speed and efficiency of generated code.

Distinct from Tool Use and Function Calling: None of the candidates address compiler-level function inlining.

Explore 21 awesome GitHub repositories matching software engineering & architecture · Compiler Optimizations. Refine with filters or upvote what's useful.

Awesome Compiler Optimizations GitHub Repositories

Finde die besten Repos mit KI.Wir suchen mit KI nach den am besten passenden Repositories.
  • tailwindcss/tailwindcssAvatar von tailwindcss

    tailwindcss/tailwindcss

    95,631Auf GitHub ansehen↗

    Tailwind CSS is a utility-first CSS framework and design system framework used to build custom user interfaces. It provides a set of low-level utility classes that are applied directly in HTML, allowing for the creation of custom web designs without writing traditional custom CSS files. The framework functions as a PostCSS plugin and a responsive web design tool. It utilizes a mobile-first system of modifiers to create layouts that adapt to different screen sizes and establishes consistent visual languages through a centralized configuration of colors, spacing, and typography. The system sup

    Features a JIT engine that scans files to generate only the CSS rules actually used in the markup.

    TypeScript
    Auf GitHub ansehen↗95,631
  • jetbrains/compose-multiplatformAvatar von JetBrains

    JetBrains/compose-multiplatform

    19,131Auf GitHub ansehen↗

    Compose Multiplatform is a declarative user interface framework that enables the development of native graphical interfaces across desktop, mobile, and web platforms using a single Kotlin codebase. It functions as a multiplatform library that allows developers to share both application logic and UI components while maintaining access to platform-specific features through abstraction layers. The framework utilizes a reactive state management system that automatically tracks data mutations to trigger granular interface updates. By employing a cross-platform rendering engine based on a hardware-

    Transforms functional UI code into efficient imperative instructions to optimize state tracking and execution.

    Kotlinandroidawtcompose
    Auf GitHub ansehen↗19,131
  • xiaolincoder/cs-baseAvatar von xiaolincoder

    xiaolincoder/CS-Base

    18,024Auf GitHub ansehen↗

    CS-Base is a comprehensive educational platform and technical repository designed to support software engineers in mastering backend architecture, artificial intelligence engineering, and career development. It functions as a centralized knowledge hub that combines illustrated theoretical tutorials with practical, project-based learning to bridge the gap between foundational computer science concepts and professional industry requirements. The project distinguishes itself by integrating a robust career mentorship framework with advanced AI engineering resources. It provides users with tools f

    Details compiler optimization techniques including function inlining for performance.

    ccppgolang
    Auf GitHub ansehen↗18,024
  • dotnet/coreclrAvatar von dotnet

    dotnet/coreclr

    12,764Auf GitHub ansehen↗

    CoreCLR is a runtime environment that manages the execution, memory, and basic types for applications built on the .NET platform. It serves as a managed execution environment that handles low-level system interactions and provides primitive data types for high-level application code. The project functions as a JIT compilation engine and a garbage collected runtime. It translates intermediate language into machine code at runtime for execution on specific hardware and automatically reclaims unused memory to prevent leaks. The system covers broad capability areas including managed code executi

    Balances startup speed and steady-state performance by recompiling frequently used methods with aggressive optimizations.

    Auf GitHub ansehen↗12,764
  • numba/numbaAvatar von numba

    numba/numba

    10,918Auf GitHub ansehen↗

    Numba ist ein Just-in-Time-Compiler, der hochsprachliche Python-Funktionen zur Laufzeit in optimierten Maschinencode übersetzt. Durch die Nutzung der LLVM-Compiler-Infrastruktur bietet es ein Framework zur Beschleunigung numerischer Datenverarbeitung und mathematischer Berechnungen, was Leistungsniveaus ermöglicht, die mit statisch kompilierten Sprachen vergleichbar sind. Das Projekt zeichnet sich durch seine Fähigkeit zur typinferenzbasierten Spezialisierung aus, die Maschinenbefehle generiert, welche auf die während der Ausführung verwendeten Datentypen zugeschnitten sind. Es verwendet eine Lazy-Compilation-Pipeline, die die Übersetzung bis zum Moment des Aufrufs verzögert, wodurch der Start-Overhead minimiert und eine konsistente Leistung über verschiedene Prozessorarchitekturen und Betriebssysteme hinweg beibehalten wird. Über die reine Kompilierung hinaus bietet das Toolkit umfassende Unterstützung für Hardwarebeschleunigung durch die Verteilung iterativer Operationen und Array-Ausdrücke auf mehrere CPU-Kerne und Grafikprozessoren. Es nutzt Vektorisierungs- und Parallelisierungsstrategien, um den Durchsatz für große numerische Datensätze zu maximieren, wodurch Entwickler spezialisierte Hardware direkt aus Standardcode ansprechen können.

    Defers the translation of functions into machine code until the moment of first invocation to minimize startup overhead and optimize execution paths.

    Pythoncompilercudallvm
    Auf GitHub ansehen↗10,918
  • chakra-core/chakracoreAvatar von chakra-core

    chakra-core/ChakraCore

    9,242Auf GitHub ansehen↗

    ChakraCore is an embeddable JavaScript engine and high-performance scripting runtime. It provides a just-in-time compiler that converts JavaScript source code into optimized machine code during runtime to increase execution speed and throughput. The engine utilizes a multi-tiered compilation pipeline and tiered machine code generation to balance startup time with execution speed. Memory is managed via a concurrent garbage collector that reclaims unreachable objects on background threads to minimize application pauses. The project provides capabilities for embedded JavaScript execution and au

    Uses a multi-tiered compilation strategy to balance initial startup time with steady-state execution speed.

    JavaScriptchakrachakracorecplusplus
    Auf GitHub ansehen↗9,242
  • minimac/magicAvatar von miniMAC

    miniMAC/magic

    8,601Auf GitHub ansehen↗

    Magic ist eine CSS-Animationsbibliothek und ein Framework für visuelle Effekte, das eine Sammlung vordefinierter Bewegungsstile zum Bewegen, Rotieren und Transformieren von Web-Elementen bereitstellt. Es dient als Build-Time-CSS-Optimierer, der nur die spezifischen Animationsstile kompiliert, die in einem Projekt verwendet werden, um die endgültige Stylesheet-Größe zu minimieren. Das Framework ermöglicht die Entwicklung interaktiver Benutzeroberflächen, indem es erlaubt, Animationen programmatisch durch Skripte, Hover-Events oder Zeitverzögerungen auszulösen. Es nutzt ein System aus Timing- und Bewegungsklassen, um die Dauer und Geschwindigkeit visueller Übergänge zu verwalten. Das Projekt deckt das visuelle Frontend-Styling und das Animationsmanagement ab, mit Fokus auf die Anwendung von Bewegungseffekten und die Optimierung der Web-Performance durch angepasste Animations-Bundles.

    Includes an engine that generates a minimal CSS stylesheet by scanning source files for used animation classes.

    SCSS
    Auf GitHub ansehen↗8,601
  • google/closure-compilerAvatar von google

    google/closure-compiler

    7,663Auf GitHub ansehen↗

    This project is a JavaScript optimizer, minifier, module bundler, transpiler, and static analysis tool. It provides a compilation pipeline designed to shrink file sizes and improve runtime performance. The system utilizes a multi-pass compilation process to perform dead code elimination, global name mangling, and static type inference. It identifies unreachable functions and unused variables to reduce the final output size and detects potential runtime errors without executing the code. The tool manages assets through dependency resolution, code chunking, and bundle management. It ensures co

    Applies advanced compilation techniques to reduce processing overhead and improve execution speed.

    JavaScript
    Auf GitHub ansehen↗7,663
  • nvidia/warpAvatar von NVIDIA

    NVIDIA/warp

    6,233Auf GitHub ansehen↗

    Warp is a Python framework that JIT-compiles Python functions into CUDA kernels for GPU-accelerated parallel computation, with built-in automatic differentiation and multi-framework array interoperability. At its core, it provides a GPU kernel compilation system that enables writing and executing custom GPU kernels directly from Python, while supporting automatic gradient computation through those kernels for integration with machine learning pipelines. The framework also includes tile-based cooperative computing, where thread blocks partition into tiles for shared-memory and tensor-core opera

    Selects the optimization level applied to GPU kernels, trading compile time for execution speed.

    Pythoncudadifferentiable-programminggpu
    Auf GitHub ansehen↗6,233
  • nvidia/isaac-gr00tAvatar von NVIDIA

    NVIDIA/Isaac-GR00T

    6,222Auf GitHub ansehen↗

    Applies link-time optimization to select the best GPU kernels for a given configuration without manual tuning.

    Jupyter Notebook
    Auf GitHub ansehen↗6,222
  • pytorch/torchtuneAvatar von pytorch

    pytorch/torchtune

    5,774Auf GitHub ansehen↗

    Torchtune is a PyTorch-native library for fine-tuning, aligning, and quantizing large language models. It provides a configurable training pipeline orchestrated through YAML recipes, with CLI overrides and component swapping, distributed training via FSDP2, memory optimizations, and parameter-efficient fine-tuning methods like LoRA, DoRA, and QLoRA. The library distinguishes itself through its YAML-driven configuration system that defines all training parameters and instantiates components from config files, with full CLI override capability for any field or component at launch time. It suppo

    Fuses the optimizer step into the backward pass to eliminate gradient buffers and reduce memory for stateful optimizers.

    Python
    Auf GitHub ansehen↗5,774
  • meta-pytorch/torchtuneAvatar von meta-pytorch

    meta-pytorch/torchtune

    5,774Auf GitHub ansehen↗

    Torchtune is a PyTorch-native library for fine-tuning, aligning, and quantizing large language models. It provides a config-driven system for instantiating components, orchestrating distributed training, and managing parameter-efficient fine-tuning with quantization support, all through YAML-based configurations and command-line overrides. The library distinguishes itself through its comprehensive post-training workflow orchestration, combining supervised fine-tuning, preference optimization (DPO, PPO, GRPO), knowledge distillation, and quantization-aware training in a single configurable pip

    Fuses optimizer updates into the backward pass to eliminate gradient buffer memory during training.

    Python
    Auf GitHub ansehen↗5,774
  • tile-ai/tilelangAvatar von tile-ai

    tile-ai/tilelang

    5,226Auf GitHub ansehen↗

    TileLang is a Python-embedded domain-specific language compiler that JIT-compiles and autotunes GPU kernels. It uses a tile-based DSL, automatic software pipelining, and parallel autotuning to generate optimized GPU kernels at runtime. It supports tensor core operations with Pythonic syntax, automatic memory management, and thread mapping. The compiler searches over tile sizes, thread counts, and scheduling policies, compiling and benchmarking candidates in parallel to find the fastest kernel. It also caches compiled binaries and tuning results to disk for reuse across sessions. TileLang inc

    Allows customization of the compiler pass pipeline to fine-tune generated kernel code.

    Python
    Auf GitHub ansehen↗5,226
  • c3lang/c3cAvatar von c3lang

    c3lang/c3c

    5,147Auf GitHub ansehen↗

    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

    Forces or prevents function inlining and disables sanitizer instrumentation for specific functions.

    C3c3compilerlanguage
    Auf GitHub ansehen↗5,147
  • obfuscator-llvm/obfuscatorAvatar von obfuscator-llvm

    obfuscator-llvm/obfuscator

    4,359Auf GitHub ansehen↗

    Dieses Projekt ist ein LLVM-Obfuscator-Compiler und Maschinencode-Obfuscator, der entwickelt wurde, um C++-Anwendungen vor Dekompilierung und statischer Analyse zu schützen. Es fungiert als LLVM-Pass-Framework, das eine Zwischenrepräsentation in komplexen Maschinencode transformiert, um das Reverse Engineering der Programmlogik zu verhindern. Das Tool implementiert Härtungsmaßnahmen für die Binärsicherheit und Anti-Reverse-Engineering-Maßnahmen zum Schutz geistigen Eigentums. Dies wird erreicht, indem die Kompilierungspipeline modifiziert wird, um den ursprünglichen Kontrollfluss und die Datenstrukturen zu verbergen. Der Transformationsprozess umfasst die Kontrollfluss-Abflachung, die Injektion undurchsichtiger Prädikate und die Befehlssubstitution. Es erschwert die Binärdatei weiter durch das Einfügen von Dead Code und die Modifikation von Maschinenbefehlen, während die ursprüngliche Ausführungssemantik beibehalten wird.

    Utilizes a framework of transformation passes to modify the optimization pipeline for code obfuscation.

    Auf GitHub ansehen↗4,359
  • phpdocumentor/phpdocumentorAvatar von phpDocumentor

    phpDocumentor/phpDocumentor

    4,332Auf GitHub ansehen↗

    phpDocumentor is a PHP API documentation generator and source code analyzer that transforms PHP files and DocBlocks into structured HTML API references. It functions as a static site generator and an automatic documentation tool designed to synchronize technical documentation with code changes. The project distinguishes itself by acting as a UML diagram generator, producing class and architectural graphs via PlantUML based on source analysis. It also supports technical manual authoring, rendering hand-written guides in Markdown and ReStructuredText alongside the automatically generated API re

    Runs specific business rules or transformations on extracted source data during the compilation process.

    PHPdocblockdocblocksgraphviz
    Auf GitHub ansehen↗4,332
  • pytorch/executorchAvatar von pytorch

    pytorch/executorch

    4,296Auf GitHub ansehen↗

    ExecuTorch is a lightweight C++ runtime for deploying PyTorch models on mobile, embedded, and edge hardware. It provides an ahead-of-time compilation pipeline that exports, quantizes, and lowers model graphs into compact serialized programs, then executes them through a minimal runtime with hardware acceleration and on-device large language model inference capabilities. The project distinguishes itself through a hardware accelerator delegate system that partitions model subgraphs and offloads computation to specialized backends including NPUs, GPUs, and DSPs from Apple, Arm, Intel, MediaTek,

    Ships a custom pass system for applying user-defined transformations to model graphs during compilation.

    Pythondeep-learningembeddedgpu
    Auf GitHub ansehen↗4,296
  • clean-css/clean-cssAvatar von clean-css

    clean-css/clean-css

    4,201Auf GitHub ansehen↗

    Clean-CSS ist ein Node.js CSS-Optimizer, der als Minifier, Bundler und Post-Prozessor fungiert. Er wurde entwickelt, um das Gesamtvolumen von Stylesheets durch das Entfernen von Leerzeichen, Kommentaren und redundantem Code zu verringern. Das Projekt bietet eine Pipeline zum Anwenden benutzerdefinierter Transformationen und Browser-Kompatibilitätsanpassungen. Es ermöglicht die programmatische Modifikation von CSS-Regeln und -Werten durch ein Plugin-System und die Verwendung benutzerdefinierter Optimierungs-Plugins. Das Tool deckt ein breites Spektrum an Asset-Optimierungsfunktionen ab, einschließlich Stylesheet-Bündelung, Inlining von Import-Regeln und Rebasen relativer URLs. Es unterstützt zudem die Generierung von Source-Maps für das Debugging und anpassbare Ausgabeformatierung für die Verschönerung.

    Provides selectable optimization levels to control the aggressiveness of CSS code reduction.

    JavaScript
    Auf GitHub ansehen↗4,201
  • iree-org/ireeAvatar von iree-org

    iree-org/iree

    3,819Auf GitHub ansehen↗

    IREE is an MLIR-based compiler toolchain and runtime designed to translate machine learning models from various frameworks into optimized binaries for execution across diverse hardware targets. It provides a unified pipeline to ingest models from PyTorch, TensorFlow, JAX, and ONNX, lowering them into a common intermediate representation for deployment on CPUs, GPUs, and bare-metal embedded systems. The project distinguishes itself through a bytecode virtual machine and a hardware abstraction layer that decouple high-level model logic from specific hardware instruction sets. It supports sophis

    Adjusts LLVM optimization levels for generated code to isolate bugs or identify race conditions.

    C++compilercudajax
    Auf GitHub ansehen↗3,819
  • symfony/framework-bundleAvatar von symfony

    symfony/framework-bundle

    3,568Auf GitHub ansehen↗

    This project serves as the core integration layer for building full-stack web applications in PHP. It provides a unified foundation by connecting essential infrastructure components, including a dependency injection container, an event dispatcher, and a request routing engine. The framework operates through a kernel-based request lifecycle that transforms incoming HTTP requests into responses via prioritized middleware stages. The system distinguishes itself through a highly modular architecture that relies on configuration-driven service wiring and metadata-driven attribute mapping. During t

    Performs compiler-pass service optimization to analyze and transform the dependency graph for efficient service resolution.

    PHPcomponentphpsymfony
    Auf GitHub ansehen↗3,568
Vorherige12Nächste
  1. Home
  2. Software Engineering & Architecture
  3. Compiler Optimizations

Unter-Tags erkunden

  • GPU Kernel Optimization Levels2 Sub-TagsSelecting compiler optimization levels specifically for GPU kernel code to balance compile time and execution speed. **Distinct from Compiler Optimizations:** Distinct from general Compiler Optimizations: focuses on per-kernel optimization level selection for GPU code, not CPU binary optimization.
  • Just-in-Time Compilation Pipelines1 Sub-TagMechanisms that defer the translation of high-level code into machine instructions until runtime to optimize execution paths. **Distinct from Compiler Optimizations:** Distinct from general Compiler Optimizations: specifically focuses on the runtime, lazy translation of code rather than static optimization passes.
  • Pass Pipeline Customization1 Sub-TagToggling individual compiler optimization, synchronization, and inlining passes to fine-tune generated kernel code. **Distinct from Compiler Optimizations:** More specific than Compiler Optimizations: allows selective enabling/disabling of passes, not just the set of optimizations.
  • Tiered CompilationMulti-stage compilation strategies that balance startup latency with steady-state peak performance. **Distinct from Compiler Optimizations:** Specifically addresses the strategy of re-compiling hot methods, distinct from general static compiler optimizations.