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

bellard/quickjs

0
View on GitHub↗
10,411 stars·1,076 forks·C·other·25 viewsbellard.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 history

Star history chart for bellard/quickjsStar history chart for bellard/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.

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

Frequently asked questions

What does bellard/quickjs do?

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.

What are the main features of bellard/quickjs?

The main features of bellard/quickjs are: JavaScript Runtimes, Resource-Constrained Runtimes, Reference-Counting Garbage Collectors, Bytecode Interpreters, C Function Bindings, Memory-Efficient Runtimes, Static Binary Compilers, Binary Compilers.

Which projects share features with bellard/quickjs?

Projects with overlapping indexed features include: 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…

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.
  • jerryscript-project/jerryscriptjerryscript-project avatar

    jerryscript-project/jerryscript

    7,399View on GitHub↗

    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
    View on GitHub↗7,399
  • nim-lang/nimnim-lang avatar

    nim-lang/Nim

    18,071View on GitHub↗

    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
    View on GitHub↗18,071
  • nexe/nexenexe avatar

    nexe/nexe

    13,571View on GitHub↗

    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
    View on GitHub↗13,571
  • google/grumpygoogle avatar

    google/grumpy

    10,528View on GitHub↗

    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
    View on GitHub↗10,528
Compare all 30 related projects→