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
asmjit avatar

asmjit/asmjit

0
View on GitHub↗
asmjit.com↗

Asmjit

AsmJit is a runtime machine code generator and JIT compiler backend that translates high-level definitions into executable processor instructions. It provides a unified instruction emission API and an executable memory manager to allocate and protect virtual memory pages across multiple CPU architectures.

The library functions as an assembly engine for x86 and ARM, supporting cross-platform assembly generation through a unified backend. It enables the creation of optimized machine code for different CPUs while maintaining a single codebase.

The project covers low-level system abstractions including register allocation, architecture-specific calling conventions, and dynamic binary instrumentation. It manages the translation of intermediate representations into binary code using label-based offset resolution and direct-to-buffer emission.

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

  • Just-In-Time Compilation - Translates high-level logic into optimized x86 and AArch64 machine code during application execution.
  • Memory Protection Managers - Provides a cross-platform interface for allocating and protecting virtual memory pages for dynamic code.
  • Runtime Assemblers - Implements an assembly engine that produces target-specific binary code and manages CPU register allocation.
  • Instruction Emission APIs - Ships a universal interface for generating SIMD and general-purpose instructions with target-specific performance overrides.
  • JIT Compiler Backends - Provides a low-latency library for generating x86 and AArch64 machine code at runtime.
  • Machine Code Generation - Creates and executes processor instructions during program execution for high performance and low latency.
  • Cross-Architecture Code Generators - Produces optimized machine code for multiple CPU architectures from a single unified API.
  • Machine Code Generators - Translates high-level function definitions into executable processor instructions for multiple architectures.
  • Dual-Mapped Memory Allocation - Implements dual-mapped memory allocation to comply with operating system security restrictions on executable pages.
  • Binary Instrumentation - Enables generating and modifying executable code sequences at runtime to insert probes or optimize hot paths.
  • Intermediate Representations - Uses a mutable linked-list intermediate representation to allow code reordering and modification before binary emission.
  • Direct-to-Binary Emission - Writes machine instructions directly into executable memory regions to minimize latency during runtime generation.
  • Calling Conventions - Provides low-level mechanisms for managing stack frames and argument passing for different processor architectures.
  • Virtual Register Allocation - Maps abstract virtual registers to physical hardware registers to optimize resource use and execution speed.
  • Symbolic Offset Resolution - Calculates final memory addresses for jumps and calls by resolving symbolic labels against the assembled code buffer.
  • Cross-Platform Abstractions - Implements a unified interface to translate universal instructions into target-specific machine code for x86 and AArch64.
  • Compiler Backends - JIT and remote assembler for C++.
  • General Utilities - Low-latency machine code generation library.
4,527 stars·581 forks·C++·Zlib·31 views

Star history

Star history chart for asmjit/asmjitStar history chart for asmjit/asmjit

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.

Frequently asked questions

What does asmjit/asmjit do?

AsmJit is a runtime machine code generator and JIT compiler backend that translates high-level definitions into executable processor instructions. It provides a unified instruction emission API and an executable memory manager to allocate and protect virtual memory pages across multiple CPU architectures.

What are the main features of asmjit/asmjit?

The main features of asmjit/asmjit are: Just-In-Time Compilation, Memory Protection Managers, Runtime Assemblers, Instruction Emission APIs, JIT Compiler Backends, Machine Code Generation, Cross-Architecture Code Generators, Machine Code Generators.

Which projects share features with asmjit/asmjit?

Projects with overlapping indexed features include: gcc-mirror/gcc — This project is a multi-language compiler collection and cross-platform toolchain used to translate source code from… luajit/luajit — LuaJIT is a high-performance Lua language implementation and just-in-time compiler. It functions as an embedded… chakra-core/chakracore — ChakraCore is an embeddable JavaScript engine and high-performance scripting runtime. It provides a just-in-time… bytecodealliance/wasmtime — Wasmtime is a WebAssembly runtime and sandboxed bytecode executor designed to run WebAssembly bytecode on a host… bytecodealliance/lucet — Lucet is a WebAssembly runtime and sandboxing compiler that translates WebAssembly bytecode into native machine code.… jmpews/dobby — Dobby is a dynamic function hooking framework and binary instrumentation tool designed to intercept and redirect…

Projects sharing features with Asmjit

These projects share indexed features with Asmjit. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • gcc-mirror/gccgcc-mirror avatar

    gcc-mirror/gcc

    11,019View on GitHub↗

    This project is a multi-language compiler collection and cross-platform toolchain used to translate source code from various programming languages into optimized machine code for different hardware architectures. It provides a suite of tools including an optimizing compiler backend, a machine code generator, and a comprehensive runtime library suite that implements necessary execution environments and support functions. The system utilizes a multi-pass compilation pipeline and pluggable language front-ends to process source code into intermediate representations. It distinguishes itself throu

    C++
    View on GitHub↗11,019
  • luajit/luajitLuaJIT avatar

    LuaJIT/LuaJIT

    5,592View on GitHub↗

    LuaJIT is a high-performance Lua language implementation and just-in-time compiler. It functions as an embedded scripting engine and dynamic binary translator that converts portable bytecode into native machine code during execution. The project focuses on high-performance scripting by translating bytecode into architecture-specific instructions to achieve execution speeds close to compiled C code. It utilizes a lightweight runtime environment designed for minimal memory overhead. The system supports binary data processing via bitwise operations and enables asynchronous task management throu

    C
    View on GitHub↗5,592
  • bytecodealliance/wasmtimebytecodealliance avatar

    bytecodealliance/wasmtime

    18,241View on GitHub↗

    Wasmtime is a WebAssembly runtime and sandboxed bytecode executor designed to run WebAssembly bytecode on a host system. It functions as an embeddable engine that integrates into applications through native APIs and language-specific bindings, as well as a standalone execution environment accessible via a command line interface. It is a WASI compatible runtime, implementing the WebAssembly System Interface to provide portable access to system resources. The engine utilizes a JIT compilation model to translate intermediate representation into optimized machine code for various CPU architecture

    Rustaotcraneliftjit
    View on GitHub↗18,241
  • chakra-core/chakracorechakra-core avatar

    chakra-core/ChakraCore

    9,242View on GitHub↗

    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

    JavaScriptchakrachakracorecplusplus
    View on GitHub↗9,242
Compare all 30 related projects→