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

ptitSeb/box64

0
View on GitHub↗
box86.org↗

Box64

Box64 is a cross-architecture runtime and user-mode emulation layer that allows Linux and Windows software to run on non-native hardware. It functions as an x86-64 instruction emulator and binary translator, executing 64-bit binaries on different CPU architectures by translating machine code into native instructions.

The project utilizes dynamic recompilation to accelerate execution and maps guest system calls to native host libraries to increase speed and hardware compatibility. It can simulate a 32-bit execution environment to support legacy software and integrates with the operating system kernel to automatically recognize and launch foreign executables.

The system covers the execution of 64-bit and 32-bit Linux programs, Windows binaries, and game clients, including support for Vulkan graphics overlays. It provides mechanisms for library bundling, AppImage package loading, and hardware-specific target optimization.

The software supports static binary compilation and provides a cross-compilation toolchain for deployment across different CPU architectures.

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

  • Dynamic Binary Translators - Converts guest machine code into native host instructions at runtime to execute binaries on unsupported architectures.
  • x86 Binary Emulators - Functions as an x86-64 binary emulator that executes machine code on non-x86 hardware architectures.
  • Cross-Architecture Instruction Mapping - Maps 64-bit guest registers and instructions to the available operation sets of the host CPU.
  • Cross-Architecture Binary Execution - Executes software built for different hardware platforms on a host system through dynamic binary translation.
  • System Call Mapping - Intercepts guest operating system requests and translates them into compatible host operations.
  • Linux Environment Emulation - Provides an environment to execute Linux binaries on non-native hardware by emulating the necessary system and kernel interfaces.
  • System-Call Interception - Translates guest operating system requests into compatible host operations by wrapping library functions and system calls.
  • User-Mode Emulation - Simulates a target CPU environment within a host process without requiring a full operating system kernel boot.
  • Binary Translation Layers - Implements a binary translation layer that allows Linux executables to run on non-native hardware without full virtualization.
  • Windows Compatibility Layers - Implements a compatibility layer that allows Windows applications to run on non-Windows operating systems.
  • Cross-Architecture Binary Runtimes - Provides a runtime environment that enables software built for different CPU architectures to execute on the host hardware.
  • Native Library Integrations - Maps guest system calls to native host libraries to increase execution speed and hardware compatibility.
  • Guest-to-Host Library Mapping - Redirects guest library calls to native host equivalents to increase execution speed and ensure hardware compatibility.
  • Dynamic Recompilation Engines - Translates frequently executed blocks of code into native instructions to reduce emulation overhead.
  • ARM Linux Gaming Emulation - Runs PC game clients and graphics-heavy applications on ARM-based Linux devices using Vulkan and native library mapping.
  • Game Client Emulation - Runs game platform clients on non-native architectures for both Linux and Windows versions.
  • Kernel Binary Format Registration - Integrates with the host operating system kernel to automatically route foreign binary executions through the translation layer.
  • 32-bit Runtime Emulation - Simulates a 32-bit execution environment using 64-bit libraries to run software on architectures lacking native support.
  • 32-bit x86 Execution - Supports the execution of legacy 32-bit x86 processes alongside 64-bit binaries.
  • Legacy 32-bit Binary Support - Simulates a 32-bit execution environment to run older software on modern 64-bit systems.
  • Hardware Instruction Targeting - Optimizes build configurations to target specific processor architectures and SoC platforms for improved execution efficiency.
  • Virtualization and Containers - High-performance emulator for running x86 Linux binaries on ARM.
5,480 stars·439 forks·C·MIT·38 views

Star history

Star history chart for ptitseb/box64Star history chart for ptitseb/box64

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 Box64

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

    ptitSeb/box86

    3,783View on GitHub↗

    Box86 is a Linux userspace emulator and instruction translator designed to run x86 binaries on ARM-based devices. It functions as a hardware compatibility layer that simulates an x86 environment, allowing software built for different processor architectures to execute on ARM Linux. The project utilizes a dynamic recompiler to translate x86 opcodes into native ARM instructions at runtime, increasing execution speed over standard interpretation. To further improve performance and stability, it wraps native system libraries and Vulkan drivers, redirecting architecture-specific calls to native ho

    Carmarm-platformsdynarec
    View on GitHub↗3,783
  • tbodt/ishtbodt avatar

    tbodt/ish

    19,992View on GitHub↗

    Ish is a Linux shell emulator for iOS that provides a local terminal environment for running shell commands and managing files. It functions as an instruction-level emulator that enables the execution of Linux binaries on mobile devices by simulating an Alpine Linux environment. The project distinguishes itself by combining user-mode Linux emulation with a virtual root filesystem. This allows the software to map Linux kernel system calls to host functions and execute scripts and toolsets directly on an iPhone or iPad. The emulator also provides low-level program debugging capabilities, inclu

    C
    View on GitHub↗19,992
  • fex-emu/fexFEX-Emu avatar

    FEX-Emu/FEX

    6,896View on GitHub↗

    FEX is an emulator that executes 32-bit and 64-bit x86 binaries on ARM64 hardware. It functions as a binary translation framework that converts guest machine code into host instructions using a JIT compilation engine and a persistent code cache. The project features a Vulkan graphics wrapper that translates OpenGL and Vulkan API calls to native host drivers, enabling cross-architecture graphics rendering. It includes a dedicated root filesystem manager for downloading, mounting, and switching between compressed filesystem images required for guest application environments. The system provide

    C++arm64cppemulation
    View on GitHub↗6,896
  • ravynsoft/ravynosravynsoft avatar

    ravynsoft/ravynos

    6,776View on GitHub↗

    Ravynos is an open-source operating system built on the Darwin kernel designed to provide binary compatibility with macOS software. It functions as a cross-architecture binary runtime capable of executing applications across both x86-64 and ARM hardware. The system implements a desktop environment that replicates the macOS user experience, including the graphical interfaces and menu bars. It ensures software compatibility by mapping binary instructions to the host processor and mimicking the system call interface and memory layout of the target operating system. The platform provides native

    Cccocoacpp
    View on GitHub↗6,776
Compare all 30 related projects→

Frequently asked questions

What does ptitseb/box64 do?

Box64 is a cross-architecture runtime and user-mode emulation layer that allows Linux and Windows software to run on non-native hardware. It functions as an x86-64 instruction emulator and binary translator, executing 64-bit binaries on different CPU architectures by translating machine code into native instructions.

What are the main features of ptitseb/box64?

The main features of ptitseb/box64 are: Dynamic Binary Translators, x86 Binary Emulators, Cross-Architecture Instruction Mapping, Cross-Architecture Binary Execution, System Call Mapping, Linux Environment Emulation, System-Call Interception, User-Mode Emulation.

Which projects share features with ptitseb/box64?

Projects with overlapping indexed features include: ptitseb/box86 — Box86 is a Linux userspace emulator and instruction translator designed to run x86 binaries on ARM-based devices. It… tbodt/ish — Ish is a Linux shell emulator for iOS that provides a local terminal environment for running shell commands and… fex-emu/fex — FEX is an emulator that executes 32-bit and 64-bit x86 binaries on ARM64 hardware. It functions as a binary… ravynsoft/ravynos — Ravynos is an open-source operating system built on the Darwin kernel designed to provide binary compatibility with… vosen/zluda — ZLUDA is a middleware and translation engine designed to enable the execution of unmodified proprietary compute… freebsd/freebsd-src — This repository contains the complete source code for a Unix-like operating system, including the monolithic kernel…