awesome-repositories.com
Blog
awesome-repositories.com

Descoperă cele mai bune repository-uri open source cu căutare AI.

ExploreazăCăutări recomandateAlternative open-sourceSoftware self-hostedBlogHartă site
ProiectDespreCum realizăm clasamentulPresăServer MCP
LegalConfidențialitateTermeni
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
LuaJIT avatar

LuaJIT/LuaJIT

0
View on GitHub↗
5,592 stele·1,161 fork-uri·C·3 vizualizăriluajit.org↗

LuaJIT

LuaJIT este o implementare de înaltă performanță a limbajului Lua și un compilator just-in-time. Funcționează ca un motor de scripting încorporat și un traducător binar dinamic care convertește bytecode-ul portabil în cod mașină nativ în timpul execuției.

Proiectul se concentrează pe scripting de înaltă performanță prin traducerea bytecode-ului în instrucțiuni specifice arhitecturii pentru a atinge viteze de execuție apropiate de codul C compilat. Utilizează un mediu de runtime ușor, conceput pentru un overhead minim de memorie.

Sistemul suportă procesarea datelor binare prin operații pe biți și permite gestionarea sarcinilor asincrone prin integrarea corutinelor C. De asemenea, oferă capabilități pentru generarea de cod la runtime și crearea de instrucțiuni personalizate de cod mașină.

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.

Istoric stele

Graficul istoricului de stele pentru luajit/luajitGraficul istoricului de stele pentru luajit/luajit

Căutare AI

Explorează mai multe repository-uri excelente

Descrie ce ai nevoie în limbaj simplu — AI-ul sortează mii de proiecte open source selectate în funcție de relevanță.

Start searching with AI

Alternative open-source pentru LuaJIT

Proiecte open-source similare, clasificate după numărul de funcționalități comune cu LuaJIT.
  • asmjit/asmjitAvatar asmjit

    asmjit/asmjit

    4,527Vezi pe GitHub↗

    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++
    Vezi pe GitHub↗4,527
  • chakra-core/chakracoreAvatar chakra-core

    chakra-core/ChakraCore

    9,242Vezi pe 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
    Vezi pe GitHub↗9,242
  • bytecodealliance/wasmtimeAvatar bytecodealliance

    bytecodealliance/wasmtime

    18,241Vezi pe 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
    Vezi pe GitHub↗18,241
  • root-project/clingAvatar root-project

    root-project/cling

    4,147Vezi pe GitHub↗

    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
    Vezi pe GitHub↗4,147
Vezi toate cele 30 alternative pentru LuaJIT→

Întrebări frecvente

Ce face luajit/luajit?

LuaJIT este o implementare de înaltă performanță a limbajului Lua și un compilator just-in-time. Funcționează ca un motor de scripting încorporat și un traducător binar dinamic care convertește bytecode-ul portabil în cod mașină nativ în timpul execuției.

Care sunt principalele funcționalități ale luajit/luajit?

Principalele funcționalități ale luajit/luajit sunt: Just-In-Time Compilation, Dynamic Binary Translators, JIT-Compiled Bytecode Execution, General JIT Compilers, Embedded Scripting Engines, High-Performance Scripting, Machine Code Generation, Lua.

Care sunt câteva alternative open-source pentru luajit/luajit?

Alternativele open-source pentru luajit/luajit includ: 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…