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
·
LuaJIT avatar

LuaJIT/LuaJIT

0
View on GitHub↗
5,592 Stars·1,161 Forks·C·3 Aufrufeluajit.org↗

LuaJIT

LuaJIT ist eine hochperformante Lua-Sprachimplementierung und ein Just-in-Time-Compiler. Es fungiert als eingebettete Skript-Engine und dynamischer Binär-Übersetzer, der portablen Bytecode während der Ausführung in nativen Maschinencode umwandelt.

Das Projekt konzentriert sich auf hochperformantes Skripting durch die Übersetzung von Bytecode in architekturspezifische Anweisungen, um Ausführungsgeschwindigkeiten nahe an kompiliertem C-Code zu erreichen. Es nutzt eine leichtgewichtige Laufzeitumgebung, die auf minimalen Speicher-Overhead ausgelegt ist.

Das System unterstützt die Verarbeitung binärer Daten mittels bitweiser Operationen und ermöglicht asynchrones Task-Management durch die Integration von C-Coroutines. Es bietet zudem Funktionen für die Laufzeit-Codegenerierung und die Erstellung benutzerdefinierter Maschinencode-Anweisungen.

Features

  • Just-In-Time Compilation - Translates bytecode into native machine code at runtime to achieve execution speeds close to compiled C.
  • Dynamic Binary Translators - Converts portable bytecode into optimized architecture-specific instructions during program execution.
  • JIT-Compiled Bytecode Execution - Translates bytecode into machine code during execution to significantly increase program performance.
  • General JIT Compilers - Implements a high-performance just-in-time compiler that translates Lua bytecode into native machine code.
  • Embedded Scripting Engines - Functions as a lightweight scripting engine that can be integrated into C applications for flexible logic.
  • High-Performance Scripting - Executes Lua scripts at near-native speeds using a just-in-time compiler.
  • Machine Code Generation - Translates bytecode into native machine code during execution to optimize overall program performance.
  • Lua - Provides a complete runtime environment and execution engine for the Lua programming language.
  • Trace-Based Optimization - Identifies frequently executed linear code paths and compiles them into optimized machine code sequences.
  • Ahead-Of-Time Compilation - Provides ahead-of-time compilation of source code into binary format to optimize program loading speed.
  • Direct-Threaded Interpreters - Implements a direct-threaded bytecode interpreter that jumps directly to instruction handlers to minimize dispatch overhead.
  • Coroutine Libraries - Integrates coroutine primitives that allow C functions to suspend and resume state independently.
  • NaN-Boxing - Uses NaN-boxing to store diverse data types within a single double-precision float for memory efficiency.
  • Asynchronous Task Managers - Provides a mechanism for coordinating concurrent background operations using coroutines within C functions.
  • C++ Coroutine Primitives - Implements low-level coroutine primitives in C to manage non-blocking multitasking.

Star-Verlauf

Star-Verlauf für luajit/luajitStar-Verlauf für luajit/luajit

KI-Suche

Entdecke weitere awesome Repositories

Beschreibe in einfachen Worten, was du brauchst — die KI bewertet tausende kuratierte Open-Source-Projekte nach Relevanz.

Start searching with AI

Open-Source-Alternativen zu LuaJIT

Ähnliche Open-Source-Projekte, sortiert nach der Anzahl der gemeinsamen Funktionen mit LuaJIT.
  • asmjit/asmjitAvatar von asmjit

    asmjit/asmjit

    4,527Auf GitHub ansehen↗

    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 in

    C++
    Auf GitHub ansehen↗4,527
  • 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

    JavaScriptchakrachakracorecplusplus
    Auf GitHub ansehen↗9,242
  • bytecodealliance/wasmtimeAvatar von bytecodealliance

    bytecodealliance/wasmtime

    18,241Auf GitHub ansehen↗

    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
    Auf GitHub ansehen↗18,241
  • root-project/clingAvatar von root-project

    root-project/cling

    4,147Auf GitHub ansehen↗

    Cling is an interactive C++ interpreter and read-eval-print loop that allows for the execution of C++ code in real time. It provides an interactive environment where statements can be evaluated immediately, bypassing the manual compilation and linking cycles typically required for the language. The system functions as a Jupyter C++ kernel, enabling cell-based development and visualization within notebook interfaces. It also supports the loading and execution of external source files within an active session. The environment includes capabilities for just-in-time debugging and profiling by em

    C++c-plus-plusclanginterpreter
    Auf GitHub ansehen↗4,147
Alle 30 Alternativen zu LuaJIT anzeigen→

Häufig gestellte Fragen

Was macht luajit/luajit?

LuaJIT ist eine hochperformante Lua-Sprachimplementierung und ein Just-in-Time-Compiler. Es fungiert als eingebettete Skript-Engine und dynamischer Binär-Übersetzer, der portablen Bytecode während der Ausführung in nativen Maschinencode umwandelt.

Was sind die Hauptfunktionen von luajit/luajit?

Die Hauptfunktionen von luajit/luajit sind: Just-In-Time Compilation, Dynamic Binary Translators, JIT-Compiled Bytecode Execution, General JIT Compilers, Embedded Scripting Engines, High-Performance Scripting, Machine Code Generation, Lua.

Welche Open-Source-Alternativen gibt es zu luajit/luajit?

Open-Source-Alternativen zu luajit/luajit sind unter anderem: asmjit/asmjit — AsmJit is a runtime machine code generator and JIT compiler backend that translates high-level definitions into… bytecodealliance/wasmtime — Wasmtime is a WebAssembly runtime and sandboxed bytecode executor designed to run WebAssembly bytecode on a host… chakra-core/chakracore — ChakraCore is an embeddable JavaScript engine and high-performance scripting runtime. It provides a just-in-time… root-project/cling — Cling is an interactive C++ interpreter and read-eval-print loop that allows for the execution of C++ code in real… tencent/xlua — xLua is a scripting bridge and C++ wrapper used to embed the Lua language into host applications. It facilitates… yuin/gopher-lua — Gopher-lua is a complete implementation of the Lua language and its standard libraries written natively in Go. It…