Open-source alternatives to Go Python

Tengo is a dynamic, embeddable scripting language for Go applications that allows for the execution of custom scripts without requiring the host binary to be recompiled. It operates as a bytecode-compiled virtual machine, transforming source code into a compact intermediate representation for execution on a stack-based engine. The system is designed as a secure scripting sandbox, enforcing strict limits on memory allocation and execution time to safely run untrusted code. It supports concurrent script execution by cloning compiled bytecode and using recursive immutability conversion to share

PHP bindings for the Go programming language (Golang)

Gentee - script programming language for automation. It uses VM and compiler written in Go (Golang).

Simple LISP in Go

Scriptable interpreter written in golang

Expression evaluation in golang

A Lua VM in Go

Perl, but fluffy like a cat!

The only reasonable scripting engine for Go.

✨ Yet another Go wrapper for Starlark that simplifies usage, offers data conversion and useful Starlark libraries

A simple embeddable scripting language which supports concurrent event processing.

A Lua VM in Go

xLua is a scripting bridge and C++ wrapper used to embed the Lua language into host applications. It facilitates bidirectional data exchange and function calls between scripts and the host environment. The project includes a runtime patching tool for replacing application logic and fixing bugs without requiring a system restart. It features a coroutine orchestrator that wraps asynchronous operations into linear code and a script validator that verifies digital signatures to ensure code authenticity and integrity before execution. To minimize memory overhead and garbage collection, the system

凹语言, The Wa Programming Language

Fastest lua binding via static code generating for Unity3D and mono.

An embeddable implementation of the Ngaro Virtual Machine for Go programs

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

FrankenPHP is a high-performance application server and runtime for PHP. It functions as a web server that executes PHP scripts and delivers web content, incorporating a binary bundler to package applications and their dependencies into standalone executable files. The project integrates the PHP interpreter directly into the Caddy web server to provide automatic HTTPS and flexible site configuration. It features a worker mode runtime that keeps applications bootloaded in memory across requests to eliminate bootstrap overhead and increase throughput. Additionally, it serves as a communication

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 throug

cel-go is a Go implementation of the Common Expression Language, providing a type-safe engine for the evaluation of non-Turing complete, side-effect-free expressions. It functions as an embedded expression engine that converts human-readable strings into type-checked abstract syntax trees to ensure safe execution. The system utilizes a compile-once evaluate-many model, parsing and validating expressions into cached programs for repeated execution across different datasets. It further distinguishes itself as a partial state evaluator, using commutative logic to compute results and return resid

Starlark in Go: the Starlark configuration language, implemented in Go