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
·

18 Repos

Awesome GitHub RepositoriesIntermediate Representations

Generation of target-neutral intermediate formats that can be optimized for various machine-code back-ends.

Distinct from Machine Code Generation: Distinct from Machine Code Generation: focuses on the creation of the intermediate representation rather than the final emission of native instructions.

Explore 18 awesome GitHub repositories matching programming languages & runtimes · Intermediate Representations. Refine with filters or upvote what's useful.

Awesome Intermediate Representations GitHub Repositories

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

    google/protobuf

    71,412Auf GitHub ansehen↗

    Protocol Buffers is a binary serialization framework used to encode structured information into compact payloads to reduce network bandwidth and storage. It functions as a cross-language data interchange standard that enables different platforms and languages to exchange structured data using a shared schema. The project includes an interface definition language compiler that transforms schema definitions into type-safe source code for multiple target programming languages. This mechanism decouples data structures from specific language memory layouts and ensures consistent data handling acro

    Uses a common definition format to decouple data structures from specific language memory layouts.

    C++
    Auf GitHub ansehen↗71,412
  • chrismaltby/gb-studioAvatar von chrismaltby

    chrismaltby/gb-studio

    9,315Auf GitHub ansehen↗

    GB Studio is a visual integrated development environment and game engine for creating 8-bit games for Game Boy hardware. It functions as a retro hardware ROM compiler that transpiles graphical logic into native Z80 assembly and binary images compatible with original handhelds and emulators. The project serves as a cross-platform build tool, generating both native hardware ROMs and web-compatible builds from a single project source. It utilizes a drag-and-drop interface for game logic and scene design, allowing for the creation of game mechanics and asset placement without writing low-level ma

    Translates project source files into a portable intermediate representation before generating final machine code for target platforms.

    TypeScript
    Auf GitHub ansehen↗9,315
  • red/redAvatar von red

    red/red

    6,009Auf GitHub ansehen↗

    Red is a programming language with a native compiler that translates high-level source code into standalone executables for Windows, macOS, and Linux without external runtime dependencies. It combines a cross-platform GUI development framework that renders native operating system widgets from a single codebase with a reactive data binding system that automatically synchronizes UI state with data sources. The language also includes an embedded DSL and parsing engine based on PEG grammar rules for defining and processing domain-specific languages within the language itself. The project distingu

    Translates high-level Red code into a C-like intermediate representation before generating native machine code.

    Red
    Auf GitHub ansehen↗6,009
  • microsoft/mmdnnAvatar von Microsoft

    Microsoft/MMdnn

    5,804Auf GitHub ansehen↗

    MMdnn ist ein Deep-Learning-Modellkonverter und -Migrator, der darauf ausgelegt ist, neuronale Netzwerkarchitekturen und Gewichte zwischen verschiedenen Frameworks wie TensorFlow, PyTorch und Keras zu übersetzen. Es nutzt eine standardisierte Zwischenrepräsentation, um Netzwerkstrukturen und Gewichte von spezifischen Framework-Implementierungen zu entkoppeln, was die Transformation vortrainierter Modelle über verschiedene Umgebungen hinweg ermöglicht. Das Projekt zeichnet sich dadurch aus, dass es aus seinen Zwischenrepräsentationen nativen Python-Rekonstruktionscode generiert, wodurch Modelle in Zielumgebungen neu aufgebaut und feinabgestimmt werden können. Es enthält zudem spezialisierte Tools für das Deployment auf Mobilgeräten, die Deep-Learning-Modelle in mobile Formate wie CoreML und TensorFlow Lite umwandeln. Das System bietet ein breiteres Spektrum an Funktionen, darunter die Visualisierung neuronaler Netzwerkarchitekturen zur Untersuchung von Graphstrukturen und Metadaten sowie die Ausführung von Modellinferenzen, um zu validieren, dass konvertierte Modelle ihr ursprüngliches Verhalten und ihre Genauigkeit beibehalten. Zusätzliche Dienstprogramme verwalten das Abrufen vortrainierter Gewichte aus Remote-Repositories und das Zusammenstellen bereitstellbarer Modell-Checkpoints.

    Generates native framework architecture and weight files from intermediate model representations via Python code snippets.

    Python
    Auf GitHub ansehen↗5,804
  • chai2010/go-ast-bookAvatar von chai2010

    chai2010/go-ast-book

    5,510Auf GitHub ansehen↗

    go-ast-book ist eine Sammlung technischer Bildungsressourcen zur Analyse abstrakter Syntaxbäume (AST), Compiler-Entwicklung und statischer Code-Verifizierung. Es bietet Anleitungen und Handbücher zum Parsen, Traversieren und Analysieren von Go-Quellcode, um semantische Informationen zu extrahieren. Das Projekt dient als Referenz für den Bau von Compiler-Frontends und deckt die Übersetzung von High-Level-Code in Zwischenrepräsentationen und Single Static Assignment (SSA) Formen ab. Es bietet zudem Anleitungen zur Nutzung dieser Techniken für die Entwicklung von Sprach-Tooling und statischer Code-Analyse. Die Ressourcen decken ein breites Spektrum an statischen Analysefähigkeiten ab, einschließlich lexikalischer Tokenisierung, strukturellem Parsen von Ausdrücken und Deklarationen sowie Koordinaten-Tracking für Quelldateien. Zudem werden semantische Analyseprozesse wie Identifier-Auflösung, Typprüfung und Kontrollflussanalyse für Nebenläufigkeit und Deferred Execution detailliert beschrieben.

    Details the transformation of high-level syntax trees into single static assignment form for optimized execution.

    Go
    Auf GitHub ansehen↗5,510
  • rust-gpu/rust-cudaAvatar von Rust-GPU

    Rust-GPU/rust-cuda

    5,245Auf GitHub ansehen↗

    rust-cuda ist ein GPU-Programmier-Framework und Device-Compiler, der die Entwicklung und Ausführung von High-Performance-Kernels auf NVIDIA-Hardware mit Rust ermöglicht. Es bietet einen Driver-Wrapper zur Verwaltung von Device-Speicherallokation und Kernel-Launching und fungiert effektiv als System zum Schreiben von GPU-Compute-Logik, ohne auf C++ angewiesen zu sein. Das Projekt enthält eine Compute-Bibliothek mit hardwareoptimierten Primitiven für neuronale Netzwerkbeschleunigung und hardwarebeschleunigtes Raytracing. Es nutzt eine Compilation-Toolchain, die Quellcode in eine Low-Level-Zwischendarstellung für die Ausführung auf Grafikprozessoren übersetzt. Das Framework deckt Device-Ressourcenmanagement, Kernel-Entwicklung und die Simulation hochpräziser Integer-Operationen ab. Zudem unterstützt es Device-seitige Zufallszahlengenerierung und zielspezifische Compute-Optimierungen. Vorkonfigurierte Container-Images sind verfügbar, um die Bereitstellung der Compiler-Toolchain und der Entwicklungsumgebung über verschiedene Hardware-Architekturen hinweg zu vereinfachen.

    Compiles Rust source code into a PTX-based intermediate representation for GPU execution.

    Rustcudacuda-kernelscuda-programming
    Auf GitHub ansehen↗5,245
  • microsoft/bosquelanguageAvatar von microsoft

    microsoft/BosqueLanguage

    5,215Auf GitHub ansehen↗

    Bosque ist eine experimentelle Programmiersprache und Entwicklungsplattform, die für maschinengestützte Softwarekonstruktion entwickelt wurde. Sie kombiniert funktionale Programmiersemantik mit imperativer Syntax, um logische Korrektheit und Laufzeitsicherheit zu erzwingen, und bietet eine typsichere Umgebung, die strukturierte Datenmodelle nutzt, um die Informationsintegrität über den gesamten Anwendungslebenszyklus hinweg zu wahren. Die Plattform zeichnet sich durch eine tiefe Integration mit formalen Verifizierungstools aus, einschließlich automatisierter Theorem-Prover und symbolischer Ausführungs-Engines. Durch die Transformation von Quellcode in eine regularisierte Zwischenrepräsentation ermöglicht das System automatisiertes Schlussfolgern, um das Fehlen von Laufzeitfehlern und Logikverletzungen zu beweisen. Zudem ist die Laufzeitumgebung auf vorhersagbare Performance ausgelegt und nutzt einen spezialisierten Interpreter, der Garbage-Collection-Pausen eliminiert, um eine konsistente Ausführungslatenz zu gewährleisten. Das Projekt bietet eine umfassende Suite von Tools für die Entwicklung mit hoher Zuverlässigkeit, die Projekt-Paketmanagement, Abhängigkeitsverfolgung und automatisierte Code-Eigenschaftsverifizierung abdeckt. Es unterstützt zudem sprachunabhängiges Schnittstellendesign, was es Entwicklern ermöglicht, gemeinsame Datenstrukturen und Service-Verträge zu definieren, die eine konsistente Validierung über verschiedene Softwarekomponenten hinweg sicherstellen.

    Transforms source code into a standardized intermediate representation to enable automated analysis and formal verification of program logic.

    TypeScript
    Auf GitHub ansehen↗5,215
  • airbnb/lottieAvatar von airbnb

    airbnb/lottie

    4,922Auf GitHub ansehen↗

    Lottie ist eine JSON-Vektoranimations-Engine und ein plattformübergreifender Player, der auflösungsunabhängige Motion-Graphics rendert. Er fungiert als Laufzeit-Renderer, der Adobe After Effects-Kompositionen mithilfe einer JSON-basierten Zwischenrepräsentation in Echtzeit-Animationen übersetzt. Das Projekt zeichnet sich dadurch aus, dass es eine dynamische Steuerung von Vektor-Assets zur Laufzeit ermöglicht. Es erlaubt die programmatische Modifikation von Animations-Eigenschaften, Farben und Wiedergabezuständen durch hierarchische Key-Paths und dynamisches Theming. Dies ermöglicht es Animationen, auf Echtzeit-Anwendungszustandsänderungen und Benutzergesten zu reagieren. Die Engine deckt ein breites Spektrum an Funktionen ab, einschließlich hardwarebeschleunigtem Rendering und Modell-Caching für hohe Performance. Sie bietet eine umfassende Wiedergabesteuerung für Frame-Seeking, Segment-Looping und Event-Triggering, neben einem Rendering-System, das 3D-Kameras, Shape-Morphing und prozedurale Vektorgenerierung unterstützt. Das Asset-Management wird durch Multi-Source-Datenimport gehandhabt, der lokale Bundles, Netzwerk-URLs und verschiedene Vektordateiformate unterstützt.

    Uses a JSON-based intermediate representation to decouple design tool compositions from cross-platform runtime playback.

    HTML
    Auf GitHub ansehen↗4,922
  • llvm-mirror/llvmAvatar von llvm-mirror

    llvm-mirror/llvm

    4,580Auf GitHub ansehen↗

    LLVM ist eine modulare Compiler-Infrastruktur und ein Framework, das aus einer Sammlung wiederverwendbarer Bibliotheken besteht, um Sprach-Frontends und Optimierungstools zu entwickeln. Es fungiert als Low-Level Virtual Machine, die eine Zwischenrepräsentation und eine Optimierungspipeline bereitstellt, um eine sprachunabhängige Codegenerierung zu ermöglichen. Das Projekt bietet ein Toolkit für Just-in-Time-Kompilierung, das Zwischenrepräsentationen zur Laufzeit für die sofortige Ausführung in Maschinencode übersetzt. Das modulare Design erlaubt es Entwicklern, eigene Sprach-Frontends und hochperformante Laufzeitumgebungen für verschiedene Zielarchitekturen zu erstellen. Die Infrastruktur deckt die hochperformante Code-Optimierung sowie die Koordination plattformübergreifender Toolchains ab, einschließlich der Integration von Compilern, Runtimes und Debuggern.

    Implements an intermediate representation using static single assignment form to simplify data flow analysis and optimization.

    LLVMcode-generationintermediate-representationllvm
    Auf GitHub ansehen↗4,580
  • yosyshq/yosysAvatar von YosysHQ

    YosysHQ/yosys

    4,543Auf GitHub ansehen↗

    Yosys ist ein digitaler Logiksynthesizer und RTL-Synthese-Tool, das Hardware-Beschreibungssprachen-Code in optimierte Gate-Level-Repräsentationen transformiert. Es fungiert als Hardware-Logikoptimierer und Tool für formale Verifikation und bietet ein Framework, um generische Schaltungsrepräsentationen in spezifische Technologie-Bibliothekszellen für zielgerichtete Hardwareplattformen zu konvertieren. Das Projekt dient als Hardware-Design-Automatisierer durch eine skriptfähige Umgebung, die zur Ausführung von Sequenzen von Synthesebefehlen verwendet wird. Diese Automatisierung ermöglicht die Verwaltung komplexer digitaler Hardware-Workflows und integriert RTL-Design-Synthese mit Technologie-Zell-Mapping. Seine Verifikations- und Analysefunktionen umfassen symbolisches Model-Checking und Design-Äquivalenzverifikation. Diese Tools unterstützen die formale Hardware-Verifikation durch das Überprüfen von Sicherheits- und Lebendigkeitseigenschaften und das Generieren von Simulations-Testbenches, um sicherzustellen, dass Designs ihren ursprünglichen Spezifikationen entsprechen.

    Uses directed graphs of cells and nets as an intermediate representation for hardware design analysis and transformation.

    C++
    Auf GitHub ansehen↗4,543
  • openvinotoolkit/open_model_zooAvatar von openvinotoolkit

    openvinotoolkit/open_model_zoo

    4,408Auf GitHub ansehen↗

    Open Model Zoo ist eine kuratierte Sammlung vortrainierter und optimierter Deep-Learning-Modelle, die für hochperformante Inferenz mittels OpenVINO entwickelt wurden. Es dient als Modell-Repository und Deployment-Framework, das die Integration neuronaler Netze in Produktionsumgebungen rationalisiert. Das Projekt nutzt ein zentralisiertes Manifest und eine versionierte Registry, um das Herunterladen und die Organisation von Modellgewichten und Metadaten zu automatisieren. Es enthält Tools zum Benchmarking der Inferenzleistung und zur Validierung der Modellgenauigkeit durch den Vergleich von Ausgaben mit Ground-Truth-Tensoren, um Präzisionsverluste zu quantifizieren. Das Ökosystem bietet Referenzimplementierungen und eine modulare Demo-Architektur, um Inferenz-Engines von der Anwendungslogik zu entkoppeln. Diese Tools unterstützen die Implementierung von Computer-Vision-Aufgaben durch standardisierte Wrapper, die Anforderungen an Pre- und Postprocessing abstrahieren.

    Translates diverse deep learning framework formats into a unified intermediate representation for hardware-independent execution.

    Pythoncaffemodelcnn-modeldeep-learning-models
    Auf GitHub ansehen↗4,408
  • 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

    Transforms source code into structured descriptors to decouple analysis from final documentation rendering.

    PHPdocblockdocblocksgraphviz
    Auf GitHub ansehen↗4,332
  • hyperai/tvm-cnAvatar von hyperai

    hyperai/tvm-cn

    3,813Auf GitHub ansehen↗

    This project is a collection of technical guides and manuals for the Apache TVM compiler stack translated into Simplified Chinese. It provides translated documentation focusing on deep learning compilation and the transformation of machine learning models into optimized executable code. The documentation covers the use of hardware backend guides for deploying models across CPUs, GPUs, and specialized accelerators. It also includes references for intermediate representations and graph-level optimizations used to compile tensor programs.

    Describes the transformation of high-level graph operators into low-level primitives matching target hardware specifications.

    TypeScriptapachechinese-simplifieddeep-learning
    Auf GitHub ansehen↗3,813
  • ghdl/ghdlAvatar von ghdl

    ghdl/ghdl

    2,759Auf GitHub ansehen↗

    GHDL is a compiler and simulator for VHDL hardware descriptions. It functions as a multi-pass analysis elaborator that resolves design hierarchies and dependencies to prepare hardware descriptions for simulation or synthesis. The project transforms VHDL source code into executable binaries for high-speed digital design verification and serves as a synthesis tool that converts descriptions into structural netlists compatible with vendor or open-source flows. It also implements the Language Server Protocol to provide static analysis, autocomplete, and code navigation for VHDL files. The toolse

    Implements backend-agnostic intermediate representations to support multiple target machine-code generators.

    VHDLcompilergccghdl
    Auf GitHub ansehen↗2,759
  • flix/flixAvatar von flix

    flix/flix

    2,585Auf GitHub ansehen↗

    Flix is a statically typed multi-paradigm programming language that combines functional, imperative, and logic programming paradigms within a single unified environment. It utilizes a constraint-driven execution environment to derive results by satisfying logical predicates rather than following linear sequential instructions. The language features a unification-based logic engine designed to solve complex computational problems through term unification and backtracking. This is supported by a core library of persistent immutable data structures that ensure side-effect free state management a

    Uses a statically typed intermediate representation to maintain safety during translation to machine instructions.

    Flixflixfunctionalhacktoberfest
    Auf GitHub ansehen↗2,585
  • foonathan/type_safeAvatar von foonathan

    foonathan/type_safe

    1,641Auf GitHub ansehen↗

    This library is a collection of zero-overhead C++ abstractions designed to replace primitive types with strict wrappers. By leveraging template metaprogramming, it enforces compile-time type safety and validates data integrity, ensuring that logic errors are caught during the build process rather than at runtime. The project distinguishes itself by providing a zero-cost abstraction layer that maps high-level type safety wrappers directly to machine instructions. It utilizes static type identity enforcement to treat logically distinct data as incompatible types, even when they share the same u

    Treats logically distinct data as incompatible types at compile time to prevent accidental mixing.

    C++c-plus-plustype-safety
    Auf GitHub ansehen↗1,641
  • webassembly/wasi-sdkAvatar von WebAssembly

    WebAssembly/wasi-sdk

    1,504Auf GitHub ansehen↗

    The WASI SDK is a comprehensive compiler toolchain designed to transform C and C++ source code into portable, sandboxed binary modules. It provides the necessary utilities to target the WebAssembly System Interface, enabling native code to execute across diverse hardware and operating system environments through a standardized interface. The toolkit distinguishes itself by providing a complete, sysroot-isolated environment that ensures build consistency regardless of the host operating system. By bundling compilers, system headers, and libraries into unified, portable archives, it facilitates

    Utilizes LLVM intermediate representation to perform cross-platform optimizations during the compilation process.

    CMakellvmsysrootwasi-libc
    Auf GitHub ansehen↗1,504
  • grin-compiler/grinAvatar von grin-compiler

    grin-compiler/grin

    1,062Auf GitHub ansehen↗

    Grin is a compiler infrastructure designed for the translation and optimization of high-level functional languages. It functions as a graph-reduction compiler, transforming source code into a standardized intermediate representation that facilitates whole-program analysis and efficient execution across diverse hardware architectures. The project distinguishes itself through a modular backend infrastructure that separates intermediate representation management from target-specific code generation. By utilizing graph-based transformations, the system performs advanced optimizations such as valu

    Generates standardized intermediate representations to enable back-end optimizations and translation for diverse hardware architectures.

    Haskellcompilerdata-flow-analysisfunctional-programming
    Auf GitHub ansehen↗1,062
  1. Home
  2. Programming Languages & Runtimes
  3. Machine Code Generation
  4. Intermediate Representations

Unter-Tags erkunden

  • AnimationTarget-neutral schemas that translate design tool compositions into runtime-ready animation specifications. **Distinct from Intermediate Representations:** Specializes general intermediate representations (f6_mt3) by focusing on design-to-playback animation mapping rather than machine code generation.
  • C-Like Intermediate LanguagesIntermediate representations that use C-like syntax and semantics as a stepping stone to native code generation. **Distinct from Intermediate Representations:** Distinct from general Intermediate Representations: specifically uses a C-like syntax and semantics as the intermediate format, not an abstract or target-neutral IR.
  • Data Structure RepresentationsIntermediate formats used to define data structures independently of a target language's memory layout. **Distinct from Intermediate Representations:** Distinct from Intermediate Representations: focuses on data structure layouts for serialization rather than instruction sets for execution.
  • Documentation DescriptorsIntermediate tree structures specifically designed for decoupled API documentation analysis and rendering. **Distinct from Intermediate Representations:** Distinct from general machine-code intermediate representations: focuses on documentation metadata rather than executable instructions.
  • Hardware IR GraphsDirected graphs representing hardware cells and nets used for logic analysis and transformation. **Distinct from Intermediate Representations:** Distinct from general machine-code IRs by representing structural hardware nets and cells.
  • IR LoweringThe process of transforming high-level intermediate representations into lower-level primitive functions. **Distinct from Intermediate Representations:** Focuses on the transition from high-level graphs to low-level primitives, rather than just the definition of the IR.
  • Model Architecture Code GeneratorsTools that generate native framework code from intermediate model representations. **Distinct from Intermediate Representations:** Distinct from general Intermediate Representations by focusing on the generation of executable source code for neural networks.
  • Static Single Assignment FormsIntermediate representations where each variable is assigned exactly once to simplify data flow analysis. **Distinct from Intermediate Representations:** Specializes general intermediate representations into the specific Static Single Assignment (SSA) form.
  • Statically Typed1 Sub-TagInternal formats that preserve type safety during translation from source to machine code. **Distinct from Intermediate Representations:** Specifically emphasizes the preservation of static types within the IR, unlike general target-neutral IRs.