Projects sharing features with Go Lua

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

Expression evaluation in golang

Go bindings for Lua C API - in progress

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

Simple LISP in Go

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

High level go to Lua binder. Write less, do more.

naive go bindings to the CPython2 C-API

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

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

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

clone of git://git.code.sf.net/p/jamvm/code for experimental branches

Embedded JavaScript engine for C/C++

Small Clojure interpreter, linter and formatter.

Lua binding library for modern C++

CakeML: A Verified Implementation of ML

Ultra Tiny Compiler

CUE has moved to https://github.com/cue-lang/cue

Decorated Syntax Tree - manipulate Go source with perfect fidelity.

An embeddable implementation of the Ngaro Virtual Machine for Go programs

CoreCLR is a runtime environment that manages the execution, memory, and basic types for applications built on the .NET platform. It serves as a managed execution environment that handles low-level system interactions and provides primitive data types for high-level application code. The project functions as a JIT compilation engine and a garbage collected runtime. It translates intermediate language into machine code at runtime for execution on specific hardware and automatically reclaims unused memory to prevent leaks. The system covers broad capability areas including managed code executi

A statically typed scripting language that transpile into POSIX sh