= Other programming languages
== Minimal/embeddable

https://github.com/dbohdan/embedded-scripting-languages

• Scheme
  classic programming language in the Lisp family. It emphasizes functional programming and domain-specific languages but adapts to other styles. Known for its clean and minimalist design, Scheme is one of the longest-lived and best-studied dynamic languages, and has many fast and portable implementations.
  https://www.scheme.org/
• Lua
  powerful, efficient, lightweight, embeddable scripting language. It supports procedural programming, object-oriented programming, functional programming, data-driven programming, and data description
  http://lua.org/
• Tcl
  high-level, general-purpose, interpreted, dynamic programming language. It was designed with the goal of being very simple but powerful
  https://www.tcl.tk/
• Janet
  functional and imperative programming language - the entire language (core library, interpreter, compiler, assembler, PEG) is less than 1MB
  https://janet-lang.org/
• Gravity
  powerful, dynamically typed, lightweight, embeddable programming language written in C without any external dependencies (except for stdlib). It is a class-based concurrent scripting language with modern Swift-like syntax
  https://github.com/marcobambini/gravity
• Wren
  Wren is a small, fast, class-based concurrent scripting language
  https://github.com/wren-lang/wren
• fe
  A tiny, embeddable language implemented in ANSI C
  https://github.com/rxi/fe
• aria
  A tiny, easily embeddable lisp-shaped language implemented in C89.
  https://github.com/rxi/aria

== Lua-based

http://lua-users.org/wiki/LuaImplementations
https://github.com/hengestone/lua-languages

• Terra
  low-level system programming language that is embedded in and meta-programmed by the Lua programming language
  https://terralang.org/
• Fennel
  programming language that brings together the speed, simplicity, and reach of Lua with the flexibility of a lisp syntax and macro system.
  https://fennel-lang.org/
• NeLua
  Nelua is a systems programming language for performance sensitive applications, like real-time applications and game engines. Its syntax and semantics are similar to Lua, but its garbage collection is optional, it provides optional type notations, and it is free from an interpreter. Nelua uses ahead-of-time compilation to generate optimized native binaries. It is metaprogrammable at compile-time using Lua and it is simple and easy to use.
  https://nelua.io/
• Urn
  new language developed by SquidDev, and demhydraz. Urn is a Lisp dialect with a focus on minimalism which compiles to Lua
  https://urn-lang.com/
• Amulet
  simple, functional programming language in the ML tradition (transpiles to Lua)
  https://amulet.works/
• Luau
  fast, small, safe, gradually typed embeddable scripting language derived from Lua
  https://luau-lang.org/
• Ravi
  Ravi Programming Language is a derivative of Lua 5.3 with limited optional static typing and MIR based JIT compiler
  http://ravilang.github.io/  https://github.com/dibyendumajumdar/ravi?tab=readme-ov-file#readme
• Shine
  expressive, minimalistic, statically typed programming language implemented in C++.
  https://github.com/Koncord/shine
• Glua
  glua(lua + static type system) compiler implemented by golang
  http://glualang.org/
• Teal
  a typed dialect of Lua
  https://github.com/teal-language/tl
• Bright
  A C-like Lua Derivative
  http://www.lua.org/wshop08/Bright.pdf
• Agena
  An Algol68/SQL like Lua Derivative
  http://agena.sourceforge.net/
• LuaJIT
  A (very impressive) JIT for Lua
  http://luajit.org
• MetaLua
  An ML-style language extension
  http://metalua.luaforge.net/
• Squirrel
  high level imperative/OO programming language
  http://squirrel-lang.org/
• GSL Shell
  interactive CLI with easy access to the GNU Scientific Library (GSL)
  http://www.nongnu.org/gsl-shell/index.html
• Objective Lua
  almost pure superset of Lua that welds the Objective C object orientation system and syntax on top of the classic Lua language
  http://olua.sourceforge.net/
• Jill
  Java Implementation of Lua Language
  http://jillcode.googlecode.com/
• Dao
  OO programming language with soft (or optional) typing, BNF-like macro system
  http://daoscript.org/
• MoonScript
  CoffeeScript inspired language that compiles into lua
  http://moonscript.org/
• Piccolo
  experimental stackless Lua VM implemented in pure Rust
  https://github.com/triplehex/piccolo

== LISP syntax-based languages

c.f. https://en.wikipedia.org/wiki/Template:Lisp

• Scheme
  classic programming language in the Lisp family. It emphasizes functional programming and domain-specific languages but adapts to other styles. Known for its clean and minimalist design, Scheme is one of the longest-lived and best-studied dynamic languages, and has many fast and portable implementations.
  https://www.scheme.org/
• PicoLisp
  minimalistic dialect of the language Lisp. It runs on operating systems including Linux and others that are Portable Operating System Interface (POSIX) compliant
  https://en.wikipedia.org/wiki/PicoLisp
• Common LISP:
  LISP dialect with mature, well-established libraries/packages
  https://lisp-lang.org/
• …

== Programming languages that can IMHO replace C++

• rust
  systems programming language with unique borrow checker concept guaranteeing memory safety
  https://en.wikipedia.org/wiki/Rust_(programming_language)
• Zig
  imperative, general-purpose, statically typed, compiled system programming language designed by Andrew Kelley
  https://en.wikipedia.org/wiki/Zig_(programming_language)
• nim
  statically typed compiled systems programming language
  https://nim-lang.org/
• D
  D is a fast, general-purpose language with C-like syntax and systems-level access
  https://dlang.org/
• V
  statically typed compiled programming language designed for building maintainable software similar to Go, influenced by Oberon, Rust, Swift, Kotlin, and Python
  https://en.wikipedia.org/wiki/V_(programming_language) https://vlang.io/
• odin
  general-purpose programming language with distinct typing built for high performance, modern systems and data-oriented programming
  http://odin-lang.org/
• CarbonLang
  Carbon is fundamentally a successor language approach to C++
  https://github.com/carbon-language/carbon-lang
• crystal
  Crystal is a language for humans and computers
  https://crystal-lang.org/

== With features interesting for me

• Racket
  beautiful LISP-based programming language and platform
  https://racket-lang.org/
• Pomsky
  Programming language with tokens as first-class citizens
  https://pomsky-lang.org/
• factor
  a concatenative, stack-based programming language with high-level features including dynamic types, extensible syntax, macros, and garbage collection
  seems to be well-designed to write little programs
  https://factorcode.org/
• mruby
  lightweight implementation of the Ruby language complying with part of the ISO standard
  https://mruby.org/
• Dylan (these days, I am not a fan of multiple dispatch anymore though)
  https://en.wikipedia.org/wiki/Dylan_(programming_language)
  via https://cre.fm/cre122-compilerbau-und-typtheorie
• Dao
  lightweight and optionally typed programming language with many advanced features. It includes features that can make concurrent programming very simple
  http://daoscript.org/
• Onyx
  A data-oriented, expressive, and modern programming language only targetting WebAssembly
  https://onyxlang.io/
• Koka
  A programming language focusing on effects
  https://koka-lang.github.io/koka/doc/book.html
• Hylo (formerly Val)
  programming language that leverages mutable value semantics and generic programming for high-level systems programming
  properly models inout/sink/set/let semantics unlike rust which models references and restricts them with a borrow checker, syntax is simpler
  https://www.hylo-lang.org/