jerryscript-project/jerryscript

Features

• JavaScript Engine Embedding - Provides a lightweight JavaScript engine designed for embedding into native C applications on resource-constrained devices.
• Runtime State Snapshots - Executes saved engine states to bypass repetitive parsing and initialization.
• Bytecode Snapshot Merging - Generates and merges pre-compiled script snapshots to accelerate the initial loading process.
• Code Organization - Implements a module system using import and export statements to organize application logic into reusable files.
• Embedded Scripting Runtimes - Enables the execution of JavaScript on memory-constrained hardware to manage device logic and interactions.
• Isolated Heap Regions - Allocates the engine state and heap within isolated memory regions to support independent execution environments.
• Custom Memory Allocators - Supports switching between internal and system memory allocators to optimize for hardware constraints or detect leaks.
• Pluggable Memory Allocators - Allows replacing internal memory management with system-specific allocators to optimize for hardware constraints.
• Memory Optimization Techniques - Adjusts internal heap sizes and garbage collection limits to fit strict hardware memory constraints.
• External State Buffers - Allows the engine to use an externally allocated memory region for internal state instead of static allocation.
• Reference Counting - Implements reference counting to track internal object references and reclaim memory when objects are no longer reachable.
• Automatic Scope Release - Automatically releases value references when variables leave scope through the use of compiler attributes.
• C-Based Scripting Engines - Compiles scripts, modules, or functions from string values into executable bytecode.
• Precompilation - Converts source code into bytecode snapshots to reduce startup time and memory overhead on constrained devices.
• Native C Interoperability - Facilitates converting JavaScript values to C types and assigning C-defined values as object properties.
• C Function Bindings - Maps native C functions to JavaScript methods to enable bidirectional communication between native code and scripts.
• Memory-Efficient Runtimes - Optimizes memory consumption through configurable heap sizes and efficient garbage collection strategies for constrained devices.
• Native-to-Script Function Invocations - Invokes JavaScript function objects using specific context bindings and provided argument lists from C.
• JavaScript Runtimes - Implements a lightweight JavaScript runtime designed specifically for resource-constrained embedded environments.
• Runtime Initializations - Sets up the execution environment and configuration flags required to run JavaScript code.
• Scripting Runtimes - Provides a small-footprint execution environment tailored for IoT device logic and hardware interaction.
• Bytecode Generation - Compiles JavaScript source code into intermediate bytecode for efficient virtual machine execution on constrained devices.
• Runtime - Saves the initialized engine state to binary files to bypass parsing and execution during application startup.
• Runtime Context Isolation - Allocates external buffers for contexts to manage heap size and run multiple applications simultaneously.
• Native Module Definitions - Supports the creation of native modules with defined export lists and custom evaluation callbacks.
• Remote Debugging - Implements a remote client-server architecture to control execution and manage breakpoints in running scripts.
• Asynchronous Task Processing - Provides an asynchronous task queue to process non-blocking operations within the engine.
• Debugger Transport Layers - Allows the definition of custom transport layers to encode and transmit messages between the remote debugger client and server.
• Remote Debugger Connectivity - Transmits engine state and execution control messages over a configurable transport layer to an external debugger.
• Embedded Debugging Clients - Provides a dedicated client to inspect the internal state of JavaScript code running on constrained IoT devices.
• ArrayBuffer Management - Implements memory buffer management allowing JavaScript ArrayBuffers to use external backing stores or custom C allocators.
• Runtime Memory Overhead Tracking - Measures engine overhead by recording memory usage during runtime or termination.
• Build-Time Bytecode Compilation - Provides a compiler that transforms JavaScript source into bytecode before deployment to reduce resource overhead.
• Native Module Registration - Registers C-based modules during startup so the engine can resolve them during execution.
• Script-Controllable Garbage Collection - The C Engine initiates low or high pressure memory reclamation directly from within executing scripts.
• Dynamic Module Resolvers - Resolves module dependencies via user callbacks and executes the resulting linked modules.
• External Buffer Strings - Creates string values from external buffers to prevent duplicating large strings in memory.
• ECMAScript Compliant Engines - Ensures JavaScript code is parsed and executed according to official language specifications.
• Host Code Evaluation - Executes JavaScript evaluation calls on UTF-8 strings to run code dynamically at runtime.
• Module Resolvers - Resolves module names to values using custom resolvers and caches results to optimize performance.
• Object Property Descriptors - Implements property descriptors, including getters and setters, to configure JavaScript object behavior.
• Runtime Feature Toggles - Toggles specific language capabilities using pre-defined or custom profile files.
• Native Pointer Attachments - Links C pointers and type information to JavaScript objects for direct access to native data.
• Manual Memory Reclamation - Initiates manual memory reclamation to free unused values based on a specified operational mode.
• Property Lookup Optimization - Accelerates object property lookups using cached maps to reduce execution time.
• Code Execution Engines - Executes previously parsed scripts or modules within the global scope and returns the result.
• Property Access Caches - Accelerates object property access by caching resolved property locations to avoid repeated linear searches.
• Object Management - Retrieves or replaces the active global object to isolate environments or configure properties.
• Property Extraction & Validation - Extracts and validates specific properties from JavaScript objects to assign them to native C variables.
• Live Process Backtrace Inspection - Provides the ability to retrieve the current execution stack as a list of strings or via frame callbacks for live inspection.
• Heap Memory Monitoring - Provides utilities to retrieve memory usage data from the heap when statistics features are active.
• Scripting and Bindings - Ultra-lightweight JavaScript engine optimized for IoT devices.

Star-Verlauf