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

bellard/quickjs

0
View on GitHub↗
10,411 Stars·1,076 Forks·C·other·5 Aufrufebellard.org/quickjs↗

Quickjs

QuickJS is a lightweight, memory-efficient JavaScript engine and runtime designed for embedding within C applications. It provides a small binary footprint and supports the latest ECMAScript standards, enabling the execution of JavaScript code with fast startup times and low memory usage.

The project includes a standalone JavaScript compiler that transforms source code into independent binary executables. These files run on a machine without requiring an external language runtime.

The engine implements deterministic memory management through reference counting and cycle collection. It also provides capabilities for Unicode text management, standardized regular expression processing, and precise binary floating-point to decimal string conversion.

Features

  • JavaScript Runtimes - Provides a lightweight JavaScript runtime specifically designed for embedding within C applications.
  • Resource-Constrained Runtimes - Executes scripts in memory-constrained environments using deterministic memory management and a small footprint.
  • Reference-Counting Garbage Collectors - Uses a reference-counting garbage collector with a cycle detector to ensure deterministic memory reclamation.
  • Bytecode Interpreters - Implements a virtual machine that executes intermediate bytecode generated from JavaScript source code.
  • C Function Bindings - Provides a mechanism to map native C functions and data structures for direct execution within the JavaScript environment.
  • Memory-Efficient Runtimes - Implements deterministic memory management via reference counting and cycle collection to minimize resource consumption.
  • Static Binary Compilers - Links the JavaScript runtime and source code into a single, self-contained statically linked executable.
  • Binary Compilers - Compiles interpreted JavaScript source code into standalone native binaries that run without an external runtime.
  • Single-Pass Compilers - Employs a single-pass compilation strategy to transform source code into bytecode during a single traversal.
  • Programming Utilities - Small, embeddable JavaScript engine for scripting.

Star-Verlauf

Star-Verlauf für bellard/quickjsStar-Verlauf für bellard/quickjs

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 Quickjs

Ähnliche Open-Source-Projekte, sortiert nach der Anzahl der gemeinsamen Funktionen mit Quickjs.
  • jerryscript-project/jerryscriptAvatar von jerryscript-project

    jerryscript-project/jerryscript

    7,399Auf GitHub ansehen↗

    JerryScript is a lightweight, ECMAScript-compliant JavaScript engine and bytecode compiler designed for resource-constrained devices. It serves as an embedded interpreter and IoT scripting runtime, enabling the execution of JavaScript code within native C applications on hardware with limited memory. The project differentiates itself through a focus on low-memory runtime management, utilizing bytecode precompilation and pre-compiled state snapshots to reduce startup time and memory overhead. It features a C-binding native bridge for bidirectional communication between native code and scripts,

    C
    Auf GitHub ansehen↗7,399
  • nim-lang/nimAvatar von nim-lang

    nim-lang/Nim

    18,071Auf GitHub ansehen↗

    Nim is a statically typed, compiled systems programming language designed for high performance and cross-platform development. It translates high-level source code into C, C++, or JavaScript, allowing developers to produce efficient native binaries or web-compatible scripts from a single codebase. The language emphasizes a clean, indentation-based syntax that simplifies code hierarchy while maintaining the power of a full-featured systems language. What distinguishes Nim is its robust metaprogramming framework, which allows developers to inspect, modify, and generate code structures during th

    Nimcompilerefficienthacktoberfest
    Auf GitHub ansehen↗18,071
  • nexe/nexeAvatar von nexe

    nexe/nexe

    13,571Auf GitHub ansehen↗

    Nexe is a cross-platform binary bundler and compiler that packages Node.js applications and their dependencies into single standalone executables. It functions as a runtime compiler that can build the Node.js runtime from source with custom flags and application snapshots to enable software distribution without requiring a pre-installed runtime. The system allows for cross-compilation across different operating systems and architectures from a single build environment. It includes a static asset bundler to embed external files and directories directly into the compiled binary for access at ru

    TypeScriptbinariesbinarybundle
    Auf GitHub ansehen↗13,571
  • google/grumpyAvatar von google

    google/grumpy

    10,528Auf GitHub ansehen↗

    Grumpy is a native binary compiler that transforms Python source code into Go source code. By transpiling high-level scripts into a strongly typed intermediate representation, the system enables the creation of statically linked native binaries that operate independently of a traditional virtual machine interpreter. The project distinguishes itself by providing a comprehensive runtime library that replicates standard Python data structures and object behaviors. This emulation layer ensures that compiled code maintains functional parity with the original source environment while leveraging the

    Go
    Auf GitHub ansehen↗10,528
Alle 30 Alternativen zu Quickjs anzeigen→

Häufig gestellte Fragen

Was macht bellard/quickjs?

QuickJS is a lightweight, memory-efficient JavaScript engine and runtime designed for embedding within C applications. It provides a small binary footprint and supports the latest ECMAScript standards, enabling the execution of JavaScript code with fast startup times and low memory usage.

Was sind die Hauptfunktionen von bellard/quickjs?

Die Hauptfunktionen von bellard/quickjs sind: JavaScript Runtimes, Resource-Constrained Runtimes, Reference-Counting Garbage Collectors, Bytecode Interpreters, C Function Bindings, Memory-Efficient Runtimes, Static Binary Compilers, Binary Compilers.

Welche Open-Source-Alternativen gibt es zu bellard/quickjs?

Open-Source-Alternativen zu bellard/quickjs sind unter anderem: jerryscript-project/jerryscript — JerryScript is a lightweight, ECMAScript-compliant JavaScript engine and bytecode compiler designed for… nim-lang/nim — Nim is a statically typed, compiled systems programming language designed for high performance and cross-platform… nexe/nexe — Nexe is a cross-platform binary bundler and compiler that packages Node.js applications and their dependencies into… google/grumpy — Grumpy is a native binary compiler that transforms Python source code into Go source code. By transpiling high-level… dop251/goja — Goja is a JavaScript engine and ECMAScript compliant interpreter implemented entirely in Go. It serves as an embedded… tboox/tbox — Tbox is a comprehensive collection of low-level utility libraries and toolkits for portable C development. It provides…