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

robertkrimen/otto

0
View on GitHub↗
8,439 stars·601 forks·Go·MIT·12 viewsgodoc.org/github.com/robertkrimen/otto↗

Otto

Otto is a Go implementation of a JavaScript interpreter and embedded scripting engine. It provides a runtime environment for executing JavaScript code within native applications and includes a parser that converts source code into an abstract syntax tree for analysis and processing.

The project enables the creation of custom scripting interfaces by binding native Go functions into the JavaScript global scope. It also includes a utility to translate JavaScript regular expression patterns into compatible formats for other programming languages.

The engine supports safe script sandboxing through the enforcement of stack-depth limits and execution interruption to prevent resource abuse. It manages runtime efficiency through precompiled script caching, state cloning, and cross-language data exchange between Go and JavaScript types.

Features

  • JavaScript Engine Embedding - Integrates a full JavaScript execution engine as a component within a Go host application.
  • JavaScript Runtimes - Provides a high-performance JavaScript engine for executing scripts within Go applications.
  • Script-to-Native Type Mappings - Translates JavaScript data types into equivalent Go structures for seamless communication between languages.
  • Global Function Injection - Allows binding native Go functions into the JavaScript global namespace for script access.
  • Cross-Language Data Exchange - Facilitates the bidirectional movement of data between the Go host language and the JavaScript guest runtime.
  • Embedded Scripting Engines - Implements a scripting language interpreter integrated into a host application for dynamic logic execution.
  • JavaScript Engines - Provides a complete implementation of the JavaScript language runtime and interpreter in Go.
  • Go Native Bindings - Binds native Go system functions to the global script scope for invocation during execution.
  • Tree-Walking Interpreters - Implements an execution engine that evaluates JavaScript by directly traversing its abstract syntax tree.
  • Custom Scripting Engines - Provides an embedded environment for executing custom JavaScript logic to extend application functionality.
  • Script Execution Interruptions - Implements an interrupt channel to stop running scripts immediately, preventing infinite loops and resource exhaustion.
  • Interpreter Tree Walking - Implements a tree-walking interpreter that executes JavaScript by traversing its abstract syntax tree.
  • Script Compilation - Parses JavaScript source code into reusable handles to avoid redundant compilation costs during repeated executions.
  • Interpreter Stack Depth Limits - Enforces maximum stack depth and trace length to control memory usage and prevent stack overflow during execution.
  • Code Execution Sandboxes - Provides a secure, isolated environment to execute untrusted JavaScript with limits on memory and time.
  • Interpreter Stack Limits - Tracks recursion depth to prevent memory exhaustion and stack overflow errors during script execution.
  • Parsed AST Caching - Caches precompiled abstract syntax trees to eliminate repeated parsing costs for the same script.
  • Script-Channel Integration - Uses Go channels to signal the immediate interruption of script execution to prevent infinite loops.
  • JavaScript Source Parsers - Includes a parser that converts JavaScript source code into structured ASTs for program analysis.
  • Runtime State Namespaces - Manages the scoping and persistence of JavaScript objects and bindings within the live execution environment.
  • Runtime State Cloning - Allows duplicating current execution scopes and object bindings to instantiate similar runtimes quickly.
  • State Preservation Cloning - Provides deep duplication of execution scopes and object bindings to create isolated runtime instances.
  • ESTree AST Parsing - Implements a parser that converts JavaScript source code into abstract syntax trees following the ESTree specification.
  • Compilers and Interpreters - JavaScript interpreter.
  • Embedded Scripting - JavaScript interpreter written in Go.
  • Language Runtimes - JavaScript parser and interpreter written in Go.

Star history

Star history chart for robertkrimen/ottoStar history chart for robertkrimen/otto

How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. 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

Open-source alternatives to Otto

Similar open-source projects, ranked by how many features they share with Otto.
  • dop251/gojadop251 avatar

    dop251/goja

    6,914View on GitHub↗

    Goja is a JavaScript engine and ECMAScript compliant interpreter implemented entirely in Go. It serves as an embedded scripting engine that allows Go applications to execute JavaScript code and integrate a programmable scripting layer without relying on Cgo or external native dependencies. The project functions as a bridge between Go and JavaScript, enabling bidirectional data exchange and function invocation. It allows Go hosts to expose native structs, slices, and maps as JavaScript objects and arrays, while providing mechanisms to export script values and functions back into native Go type

    Go
    View on GitHub↗6,914
  • yuin/gopher-luayuin avatar

    yuin/gopher-lua

    6,933View on GitHub↗

    Gopher-lua is a complete implementation of the Lua language and its standard libraries written natively in Go. It serves as an embedded scripting engine and virtual machine that allows Go applications to execute Lua scripts and exchange data between the host and the script environment. The project provides a bytecode compiler to transform source code into a binary format for faster execution. It enables deep integration between the two languages by allowing the registration of native Go functions to be called from scripts, and the invocation of script functions directly from Go. The engine c

    Gogogopher-lualua
    View on GitHub↗6,933
  • boa-dev/boaboa-dev avatar

    boa-dev/boa

    6,884View on GitHub↗

    Boa is a high-performance JavaScript engine and parser designed to execute JavaScript code and analyze source code structure. It functions as a runtime environment for executing scripts to automate tasks or process data, providing both a command-line JavaScript interpreter and a tool for converting source code into abstract syntax trees. The engine is capable of compiling to WebAssembly, allowing the runtime to be deployed and executed within web browser environments. It includes an interactive read-eval-print loop for real-time logic testing and snippet execution via a terminal. The system

    Rustecmascripthacktoberfestinterpreter
    View on GitHub↗6,884
  • microsoft/chakracoreMicrosoft avatar

    Microsoft/ChakraCore

    9,256View on GitHub↗

    ChakraCore is an embedded JavaScript engine designed to be integrated as a library within a host application. Its primary purpose is to provide a programmable scripting layer and a lightweight runtime environment for executing JavaScript code and managing state via a programmatic interface. The project focuses on bridging high-level scripting with low-level system calls through a C API. This allows developers to implement custom scripting engines and embed JavaScript execution directly into applications to enable task automation and functional extensions. The engine utilizes a bytecode-based

    JavaScript
    View on GitHub↗9,256
See all 30 alternatives to Otto→

Frequently asked questions

What does robertkrimen/otto do?

Otto is a Go implementation of a JavaScript interpreter and embedded scripting engine. It provides a runtime environment for executing JavaScript code within native applications and includes a parser that converts source code into an abstract syntax tree for analysis and processing.

What are the main features of robertkrimen/otto?

The main features of robertkrimen/otto are: JavaScript Engine Embedding, JavaScript Runtimes, Script-to-Native Type Mappings, Global Function Injection, Cross-Language Data Exchange, Embedded Scripting Engines, JavaScript Engines, Go Native Bindings.

What are some open-source alternatives to robertkrimen/otto?

Open-source alternatives to robertkrimen/otto include: dop251/goja — Goja is a JavaScript engine and ECMAScript compliant interpreter implemented entirely in Go. It serves as an embedded… yuin/gopher-lua — Gopher-lua is a complete implementation of the Lua language and its standard libraries written natively in Go. It… boa-dev/boa — Boa is a high-performance JavaScript engine and parser designed to execute JavaScript code and analyze source code… microsoft/chakracore — ChakraCore is an embedded JavaScript engine designed to be integrated as a library within a host application. Its… facebook/hermes — Hermes is a mobile-optimized JavaScript runtime and engine designed for React Native. It functions as an ahead-of-time… d5/tengo — Tengo is a dynamic, embeddable scripting language for Go applications that allows for the execution of custom scripts…