ilya-klyuchnikov

pattern-matching-in-rust. Pattern matching and exhaustiveness checking algorithms implemented in Rust

eqwalizer. A type-checker for Erlang

cherri. Siri Shortcuts Programming Language 🍒

LCTI. Local Contextual Type Inference

worklist_intersection_union. Coq

mog. Programming language for safe AI agents

plush. Minimalistic dynamically-typed language for fun, teaching and creative programming.

ki-editor. ⵣ Ki Editor - Multi-cursor combinatoric modal editor.

mlscript. The MLscript programming language. Functional and object-oriented; structurally typed and sound; with powerful type inference. Soon to have full interop with TypeScript!

z3-rkt. Racket bindings for Z3

nanolang. A tiny experimental language designed to be targeted by coding LLMs

webracket. The WebRacket language is a subset of Racket that compiles to WebAssembly

bitchat. bluetooth mesh chat, IRC vibes

chibi-scheme. Official chibi-scheme repository

loxdown. A statically-typed variant of Lox, written in TypeScript

edb. The next-generation debugger for Erlang.

erlang-markdown. CommonMark and GFM compliant markdown parser in Erlang with ASTs and extensions

Maude. Language based on Rewriting Logic

refal-5-lambda. Компилятор Рефала-5λ

assemblyscript. A TypeScript-like language for WebAssembly.

kano-pixel-kit-pixel32. Code MicroPython on your Kano Pixel Kit on the browser

erlang-language-platform. Erlang Language Platform. LSP server and CLI.

devicescript. TypeScript for Tiny IoT Devices (ESP32, RP2040, ...)

go. Go tools, libraries

factor. Factor programming language

typical. Data interchange with algebraic data types.

aliceml. A functional programming language based on Standard ML, extended with support for concurrent, distributed, and constraint programming

session-types. Rust

ElixirST. Session Types in Elixir

icon. The Icon Programming Language

spsc. SPSC: A Small Positive Supercompiler

toy-lang. Toy language for experimentation and fun.

gambit. Gambit is an efficient implementation of the Scheme programming language.

larceny. Larceny Scheme implementation

shen-scheme. Shen/Scheme implementation

programming-languages. Awesome Programming Languages

Silverfir. A WebAssembly runtime for embedded systems

moonscript. :crescent_moon: A language that compiles to Lua

love. LÖVE is an awesome 2D game framework for Lua.

erlfuzz. erlfuzz is a fuzzer for the Erlang ecosystem

runa. A Python-like systems programming language

iron-kaleidoscope. LLVM tutorial in Rust language

roc-lox. Implementing the Lox programming language from Crafting Interpreters using Roc

io. Io programming language. Inspired by Self, Smalltalk and LISP.

mlua. High level Lua 5.5/5.4/5.3/5.2/5.1 (including LuaJIT) and Luau bindings to Rust with async/await support

pg_graphql. GraphQL support for PostgreSQL

sokoban. Batchfile

hand-crafted-wasm. Creative coding and other mischief in handwritten WebAssembly, using the WebAssembly .wat text format.

marwood. An embeddable Scheme R7 Compiler & Runtime written in Rust

nimble_options. A tiny library for validating and documenting high-level options

roc. A fast, friendly, functional language.

gcc-tiny. GCC Tiny front-end

extism. The framework for building with WebAssembly (wasm). Easily & securely load wasm modules, move data, call functions, and build extensible apps.

wase. WebAssembly made easy

nlvm. LLVM-based compiler for the Nim language

nballerina. Ballerina compiler that generates native executables.

wasmcloud-otp. wasmCloud host runtime that leverages Elixir/OTP and Rust to provide simple, secure, distributed application development using the actor model

weave. A state-of-the-art multithreading runtime: message-passing based, fast, scalable, ultra-low overhead

MinSwift-workshop. ♻️ minimum Swift compiler written in Swift

SwiftBert. BERT serializer for Swift (Erlang External Term Format)

slox. Swift implementation of a Lox interpreter

duckscript. Simple, extendable and embeddable scripting language.

ractor. Rust actor framework

LinearML. Functional language for parallel programming

savi. A fast language for programmers who are passionate about their craft.

ChaiScript. Embedded Scripting Language Designed for C++

uvm. Fun, portable, minimalistic virtual machine.

swam. WebAssembly engine in Scala

nezvm1. The Nez VM Version1

gopher-lua. GopherLua: VM and compiler for Lua in Go

hematita. A memory safe Lua interpreter

Essentials-of-Compilation. A book about compiling Racket and Python to x86-64 assembly

Kind. A modern proof language

buzz. 👨‍🚀 buzz, A small/lightweight statically typed scripting language

wazm. Web Assembly Zig Machine

lc3-vm. Write your own virtual machine for the LC-3 computer!

hlvm. High-Level Virtual Machine for statically-typed functional languages.

SootUp. A new version of Soot with a completely overhauled architecture

setup-graalvm. Set up your GitHub Actions workflow with a specific GraalVM distribution.

dao. Dao Programming Language

squirrel. Official repository for the programming language Squirrel

t. A Runtime Typechecker for Roblox

dora. Dora VM

nanojit. NanoJIT is a small, cross-platform C++ library that emits machine code.

sljit. Platform independent low-level JIT compiler

steel. An embedded scheme interpreter in Rust

Web49. Web49: WebAssembly Interpeter

minivm. A VM That is Dynamic and Fast

erlps-core. Core runtime of Erlscripten - ERTS emulation

herl. Erlang BEAM emulator in Haskell

saturn. Lock-free data structures for multicore OCaml

zetavm. Multi-Language Platform for Dynamic Programming Languages

HVM2. A massively parallel, optimal functional runtime in Rust

inkwell. It's a New Kind of Wrapper for Exposing LLVM (Safely)

lc. JIT compiler for Scheme targeting x86-64 platforms

ribbit. A portable, compact and extensible Scheme implementation to 25 targets. R4RS compliant.

lineiform. A meta-JIT library for Rust interpreters

anzen. The Anzen programming language.

parrot. Parrot Virtual Machine

concurrent-hamt. Rust

rust_lisp. A Rust-embeddable Lisp, with support for interop with native Rust functions

grain. The Grain compiler toolchain and CLI. Home of the modern web staple. 🌾

wasm-micro-runtime. WebAssembly Micro Runtime (WAMR)

atlas. In-memory dimensional time series database.

jank. jank is the native Clojure dialect with seamless C++ interop.

tinygo. Go compiler for small places. Microcontrollers, WebAssembly (WASM/WASI), and command-line tools. Based on LLVM.

simple.vm. Simple virtual machine which interprets bytecode.

buck2. Build system, successor to Buck

jerlang. Erlang/OTP on the Java Virtual Machine (JVM)

rtforth. Forth implemented in Rust for realtime application

rust-forth-compiler. Simple Forth compiler written in Rust

cloe. Cloe programming language

zigler. zig nifs in elixir

zig-stack-vm. Very simple stack virtual machine implementation in Zig

zilox. Implementation of the lox programming language in Zig.

fmm. The uncurried minimal functional programming language for CPS transformation

ling. Erlang on Xen

ErlangRT. Erlang Replacement Therapy. Another attempt to make Erlang runtime (BEAM emulator) in Rust. Good news: I know what to do. Bad news: I have no clue how to Rust

redbug. erlang tracing debugger

PyonR. A Python implementation for Racket

tree-sitter-erlang. Tree-sitter Grammar for Erlang

zuo. A tiny Racket for scripting

rustysignal. Signaling server for WebRTC that supports SSL-encrypted connections

hylo. The Hylo programming language

claro-lang. Claro Lang

LVM. Lua virtualsation toolset in Java

elixir-type_check. TypeCheck: Fast and flexible runtime type-checking for your Elixir projects.

erlirc. Erlang IRC client/server framework

awesome-zig.

wasp. The batteries-included full-stack framework for the AI era. Develop JS/TS web apps (React, Node.js, and Prisma) using declarative code that abstracts away complex full-stack features like auth, background jobs, RPC, email sending, end-to-end type safety, single-command deployment, and more.

prql. PRQL is a modern language for transforming data — a simple, powerful, pipelined SQL replacement

erg. A statically typed language compatible with Python

paranoid_crypto. Paranoid's library contains implementations of checks for well known weaknesses on cryptographic artifacts.

setup-graalvm. JavaScript

JikesRVM. Jikes RVM (Research Virtual Machine)

pie-hs. An implementation of Pie in Haskell

rhai. Rhai - An embedded scripting language for Rust.

erl_dist. Rust Implementation of Erlang Distribution Protocol

shen-c. A C implementation of the Shen programming language

fibers-rs. A Rust library to execute a number of lightweight asynchronous tasks (a.k.a, fibers) based on futures and mio.

ott. The Ott tool for writing definitions of programming languages and calculi

erlyberly. erlang tracing for the masses

mir. A lightweight JIT compiler based on MIR (Medium Internal Representation) and C11 JIT compiler and interpreter based on MIR

tokenizers. 💥 Fast State-of-the-Art Tokenizers optimized for Research and Production

ante. A safe, easy systems language

cotowali. A statically typed scripting language that transpile into POSIX sh

navi. An interactive cheatsheet tool for the command-line

WASM-Redex. A model of the WebAssembly language in Redex

coffeebeam. A lightweight Erlang VM for Android

wasmer. 🚀 Fast, secure, lightweight containers based on WebAssembly

codec-beam. Generate Erlang VM byte code from Haskell

superconsole. The superconsole crate provides a handler and building blocks for powerful, yet minimally intrusive TUIs. It is cross platform, supporting Windows 7+, Linux, and MacOS. Rustaceans who want to create non-interactive TUIs can use the component composition building block system to quickly deploy their code.

nickel. Better configuration for less

rules_scala. Scala rules for Bazel

computationbook-rust. Example code for Understanding Computation http://computationbook.com/ in Rust

wasm-lsp-server. A language server for WebAssembly

RustPython. A Python Interpreter written in Rust

fengari. 🌙 φεγγάρι - The Lua VM written in JS ES6 for Node and the browser

scaladyno-plugin. scaladyno is an attempt to make scala a more dynamic language :)

bazel-bsp. An implementation of the Build Server Protocol for Bazel

melody. Melody is a language that compiles to regular expressions and aims to be more readable and maintainable

prolog. The only reasonable scripting engine for Go.

ukanren-rs. Rust implementation of µKanren, a featherweight relational programming language.

nom-tutorial. Tutorial for parsing with nom 5.

gerlang. Calling Go functions from Erlang

coalton. Coalton is an efficient, statically typed functional programming language that supercharges Common Lisp.

scalaris. Scalaris, a distributed, transactional key-value store

gluonvm1. OUTDATED see https://github.com/kvakvs/ErlangRT, https://github.com/kvakvs/ErlangAoT and https://github.com/kvakvs/E4VM instead -- Gluon BEAM-compatible Erlang Abstract Machine (GLEAM) written in portable C++

semgrep. Lightweight static analysis for many languages. Find bug variants with patterns that look like source code.

difftastic. a structural diff that understands syntax 🟥🟩

scala-gdpr-plugin. A plugin for the Scala compiler to enhance GDPR compliance

CAMLBOY. A Game Boy emulator written in OCaml that runs in your browser 🐫 🎮

taint. Thesis code

polytracker. An LLVM-based instrumentation tool for universal taint tracking, dataflow analysis, and tracing.

racket-lox. An implementation of the Lox language in Racket.

munit. Scala testing library with actionable errors and extensible APIs

rust. Empowering everyone to build reliable and efficient software.

Ironclad.old. A RUSTy fusion of OTP lib/dialyzer and lib/compiler empowering regular Erlang with type inference

staged-fold-fusion. Scala

parsequery. A fast parser combinator library, with extra querying goodness

partcl. ParTcl - a micro Tcl implementation

luau. A small, fast, and embeddable programming language based on Lua with a gradual type system.

clojure-rust-graalvm. An example of Clojure program calling a Rust library, all combined into one executable using GraalVM.

ETC. ETC

xgo. XGo is a programming language that reads like plain English. But it's also incredibly powerful — it lets you leverage assets from C/C++, Go, Python, and JavaScript/TypeScript, creating a unified software engineering ecosystem. Our vision is to enable everyone to become a builder of the world.

Distiller. Implementation of the distillation algorithm as described in the paper "Distillation: Extracting the Essence of Programs".

pen. The parallel, concurrent, and functional programming language for scalable software development

flowcaml. Flowcaml compiler

polyglot. Polyglot Extensible Compiler Framework for Java

jif. Java-like Language with Static Information Flow Types

datatt. A dependent type theory with user defined data types

korn. Korn - C Verification with Loop Invariants and Summaries

tyrade. A pure functional language for type-level programming in Rust

craftinginterpreters. Repository for the book "Crafting Interpreters"

bidi-higher-rank-poly. Didactic implementation of the type checker described in "Complete and Easy Bidirectional Typechecking for Higher-Rank Polymorphism" written in OCaml

frunk. Funktional generic type-level programming in Rust: HList, Coproduct, Generic, LabelledGeneric, Validated, Monoid and friends.

aspectd. AOP for Flutter(Dart)

sml-compiler. A compiler for Standard ML, somewhat

spire. Powerful new number types and numeric abstractions for Scala.

scryer-prolog. A modern Prolog implementation written mostly in Rust.