wren-lang/wren

Features

• Class-Based Scripting Languages - Implements a small and fast object-oriented scripting language designed for embedding and concurrent task execution.
• Fiber-Based Concurrent Execution - Implements a concurrent runtime based on lightweight fibers and cooperative scheduling to handle asynchronous workflows.
• Embeddable Scripting Engines - Ships a dependency-free virtual machine with a C API for integrating dynamic script execution into host applications.
• Virtual Machines - Provides a virtual machine that can be integrated into applications via static libraries or direct source inclusion.
• Single-Pass Compilation - Emits bytecode during a single parsing pass to minimize memory allocation and accelerate application startup.
• Bytecode Interpreters - Implements a bytecode interpreter that runs compiled source code to produce output and verify logic.
• Bytecode Virtual Machines - Implements a custom virtual machine that executes a specialized instruction set for the language runtime.
• C-Based Embedding APIs - Provides a minimal C-based API for embedding the scripting engine and defining host functions within native applications.
• Class System Implementations - Organizes execution around a core class system implementation with a modern object-oriented model.
• Bytecode Interpreters - Provides an execution engine that compiles source code into bytecode in a single pass for fast startup.
• Computed Goto Dispatch - Uses computed gotos in the bytecode loop to create distinct branch points and reduce CPU pipeline stalls.
• Embedded Script Execution - Enables the execution of a scripting language runtime within a larger compiled host application.
• Fixed-Offset Field Access - Accesses object fields using fixed memory offsets to avoid expensive runtime hash table lookups.
• Language Embedding - Provides a dependency-free scripting layer that can be embedded into existing software to allow user extensions.
• Fiber-Based Schedulers - Features a cooperative scheduler that manages lightweight fibers for concurrent operation without using OS threads.
• Method Dispatch Optimizations - Copies inherited methods into subclasses during definition to eliminate walking the inheritance chain at runtime.
• Object-Oriented Scripting - Uses a modern class-based model with inheritance and method overloading for organized state and behavior.
• Primitive Types - Implements a set of basic built-in data types including booleans, floating-point numbers, and UTF-8 strings.
• Tagged Value Storage - Stores numbers and booleans as unboxed values using tagging to reduce memory overhead and cache misses.
• Object-Oriented Programming - Employs a class-based model supporting inheritance, method overloading, and first-class functions.
• Field Offset Accessors - Implements fixed-offset field access to eliminate expensive hash table lookups for object properties.
• Command Line Interfaces - Ships as a standalone binary tool that allows scripts to be executed from a command-line interface.
• VM Runtime Environments - Manages the initialization and destruction of virtual machine instances to control memory and execution state.
• Runtime Instance Isolation - Creates independent runtime instances with custom configurations and output handlers for isolated script execution.
• Arity-Based Method Overloading - Supports defining multiple methods with the same name that perform different tasks based on the number of arguments.
• Class Definitions - Provides syntax and structure to define custom classes with methods, fields, and inheritance.
• Class Inheritance - Supports deriving new classes from existing ones to inherit methods and utilize super-calls.
• Arity-Based Method Definitions - Defines named behaviors with support for arity-based overloading and specialized getters and setters.
• CLI Script Execution - Provides a standalone binary tool to execute scripts directly from the command-line interface.
• Collection Accessors - Enables retrieving or assigning values in collection objects using bracket syntax mapped to method signatures.
• Compile-Time Arity Validation - Checks argument counts against method signatures at compile time to remove the need for runtime validation.
• Computed Goto Dispatchers - Uses computed gotos in the bytecode loop to reduce CPU pipeline stalls and improve execution speed.
• Direct Execution Transfers - Implements a peer-to-peer transfer of control between fibers to switch execution paths without a return stack.
• Dynamic Method Invocation - Allows calling functions on objects by evaluating a receiver and passing arguments to a method identified by name.
• Fiber State Suspension - Allows pausing a fiber's execution at any point and resuming it from the exact same location.
• First-Class Functions - Treats functions as first-class objects that can be stored in variables and passed as arguments.
• Flattened Method Dispatchers - Optimizes method resolution by flattening the inheritance hierarchy during class definition.
• Function Objects - Allows classes to respond to call requests, enabling objects to be used interchangeably with functions.
• Block-Scoped Variable Declarations - Implements block-level scoping and explicit declarations to track data through a script.
• Closure Captures - Maintains access to variables defined outside a local scope through closures to preserve state.
• Module Import Systems - Implements a system for loading and executing external source code to share variables across different parts of a program.
• Module Singleton State Management - Ensures a module is executed only once and reused across multiple imports to maintain a single copy of its state.
• Named Constructors - Provides named constructors to initialize object state during class instantiation.
• Property Access Syntax - Supports reading and writing object properties using assignment syntax or method signatures that omit parentheses.
• Operator Method Mappings - Implements prefix, infix, and range operators that map directly to method calls on operands.
• Ordered Collections - Provides built-in ordered collections that store mixed-type elements accessible by integer index.
• Runtime Library Integrations - Integrates a class-based concurrent language into host applications as either a static or shared library.
• Runtime Bytecode Compilation - Compiles source code strings into bytecode at runtime for execution within the fiber model.
• Tagged Value Boxing - Reduces memory overhead and cache misses by storing booleans and numbers as tagged, unboxed values.
• Static and Instance Field Management - Stores data within objects using implicitly declared fields and static fields for class-level shared state.
• Fiber Data Exchange - Enables passing values to fibers during invocation and receiving values back upon yielding.
• Circular Dependency Resolution - Supports mutual imports between modules by registering them before execution to prevent infinite loading loops.
• Host-Defined Module Resolvers - Resolves module names into source code via a host-side function using the file system or bundled resources.

Star history