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
quickjs-ng avatar

quickjs-ng/quickjs

0
View on GitHub↗
quickjs-ng.github.io/quickjs↗

Quickjs

QuickJS is a lightweight, embeddable ECMAScript runtime that executes JavaScript programs conforming to the latest specification. It is designed as a compact, standards-compliant JavaScript engine suitable for resource-constrained environments and embedded systems, available both as prebuilt binaries and as source code that can be compiled for custom integration.

The engine distinguishes itself through a minimal runtime footprint achieved by a single-pass compiler that produces compact bytecode, executed on a stack-based virtual machine. Memory management uses reference-counting garbage collection with cycle detection for deterministic cleanup, while a portable C-based embedding API provides direct memory control for host applications. The platform-agnostic build system compiles across operating systems and architectures without external dependencies.

The engine supports loading and executing JavaScript modules using ES module syntax through a built-in module loader. Prebuilt binaries are available for quick installation, and the source can be compiled for custom integration into host applications.

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

  • ECMAScript Compliant Engines - An interpreter and compiler that executes JavaScript programs conforming to the latest ECMAScript specification.
  • Minimal Runtime Footprints - Achieves a small binary size and low memory usage by omitting unnecessary runtime features.
  • Lightweight Scripting Engines - A small-footprint JavaScript engine suitable for resource-constrained environments and embedded systems.
  • C-Based Embedding APIs - Ships a minimal C API for embedding the engine with direct memory control.
  • JavaScript Engine Embedding - Provides a minimal C API for embedding a standards-compliant JavaScript runtime into host applications.
  • Cross-Platform Build Systems - Compiles across operating systems and architectures using a portable build system without external dependencies.
  • Reference-Counting Garbage Collectors - Manages memory automatically using reference counting with cycle detection for deterministic cleanup.
  • Single-Pass Compilation - Compiles JavaScript source to bytecode in a single pass without intermediate representations.
  • Source-to-Bytecode Compilers - Compiles JavaScript source into compact bytecode for execution on a custom virtual machine.
  • ECMAScript Module Support - Loads and executes JavaScript modules using a built-in module loader with ES module syntax.
  • Stack-Based Virtual Machines - Runs bytecode instructions using a stack-based architecture for simple and efficient execution.
2,703 stars·256 forks·C·mit·36 views

Star history

Star history chart for quickjs-ng/quickjsStar history chart for quickjs-ng/quickjs

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 quickjs-ng/quickjs do?

QuickJS is a lightweight, embeddable ECMAScript runtime that executes JavaScript programs conforming to the latest specification. It is designed as a compact, standards-compliant JavaScript engine suitable for resource-constrained environments and embedded systems, available both as prebuilt binaries and as source code that can be compiled for custom integration.

What are the main features of quickjs-ng/quickjs?

The main features of quickjs-ng/quickjs are: ECMAScript Compliant Engines, Minimal Runtime Footprints, Lightweight Scripting Engines, C-Based Embedding APIs, JavaScript Engine Embedding, Cross-Platform Build Systems, Reference-Counting Garbage Collectors, Single-Pass Compilation.

Which projects share features with quickjs-ng/quickjs?

Projects with overlapping indexed features include: svaarala/duktape — Duktape is an embeddable JavaScript engine and portable scripting runtime designed for integration into C and C++… bellard/mquickjs — mQuickjs is a compact JavaScript engine designed for memory-constrained devices, such as microcontrollers, requiring… mruby/mruby — mruby is a lightweight Ruby interpreter designed to be embedded into C applications. It compiles Ruby source code into… albertlauncher/albert — Albert is a keyboard launcher that opens files, applications, and runs commands by typing search queries into a search… dop251/goja — Goja is a JavaScript engine and ECMAScript compliant interpreter implemented entirely in Go. It serves as an embedded… jerryscript-project/jerryscript — JerryScript is a lightweight, ECMAScript-compliant JavaScript engine and bytecode compiler designed for…

Projects sharing features with Quickjs

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

    svaarala/duktape

    6,208View on GitHub↗

    Duktape is an embeddable JavaScript engine and portable scripting runtime designed for integration into C and C++ applications. It functions as a lightweight ECMAScript runtime that provides a C-JavaScript bridge for exchanging data and invoking functions between native code and a script execution environment. The engine includes an ECMAScript bytecode compiler that allows for the serialization and caching of compiled functions to disk to reduce application startup time. It organizes script dependencies using a CommonJS-compliant module loader. The runtime covers a variety of capabilities in

    JavaScriptduktapejavascriptjavascript-engine
    View on GitHub↗6,208
  • bellard/mquickjsbellard avatar

    bellard/mquickjs

    5,539View on GitHub↗

    mQuickjs is a compact JavaScript engine designed for memory-constrained devices, such as microcontrollers, requiring as little as 10 KB of RAM and 100 KB of ROM. It achieves this through a fixed-buffer memory allocation scheme that avoids system heap usage, a compacting tracing garbage collector that eliminates fragmentation, and a ROM-embedded standard library that reduces both memory footprint and startup time. The engine compiles JavaScript source into portable bytecode that can be stored in persistent memory and executed without reparsing, and it emulates IEEE 754 floating-point arithmetic

    C
    View on GitHub↗5,539
  • mruby/mrubymruby avatar

    mruby/mruby

    5,584View on GitHub↗

    mruby is a lightweight Ruby interpreter designed to be embedded into C applications. It compiles Ruby source code into a compact, platform-independent bytecode that executes on a register-based virtual machine, and exposes a stable C API for host programs to initialize the interpreter, load bytecode, and invoke Ruby methods at runtime. The interpreter distinguishes itself through a tightly coupled parser and compiler that performs lexical analysis, syntax parsing, and bytecode generation in a single pass without constructing an intermediate AST, minimizing memory overhead. It also includes a

    C
    View on GitHub↗5,584
  • albertlauncher/albertalbertlauncher avatar

    albertlauncher/albert

    7,945View on GitHub↗

    Albert is a keyboard launcher that opens files, applications, and runs commands by typing search queries into a search bar. It functions as a keyboard-driven workflow tool, enabling users to navigate their file system, launch installed applications, and execute shell commands without touching a mouse. The launcher processes user input through a plugin-based modular architecture, where functionality is extended by dynamically loaded C++ and Python plugins. Queries are dispatched to all enabled handlers in parallel, with results merged and ranked by a combination of match quality and historical

    C++albertalbertlauncherapplication-launcher
    View on GitHub↗7,945
    • Compare all 30 related projects→