Game Scripting Languages Family Index
type: language-family-index family: game-scripting languages_catalogued: 15 tags: [language-reference, family-index, game-dev, scripting, embedded-vm]
Game Scripting Languages — Family Index
Family overview
Games embed scripting languages for three converging reasons: iteration speed (recompiling C++ kills designer flow), safety (a sandboxed VM can’t segfault the engine or trash a save), and moddability (shipping bytecode lets a community write content without engine source). The host engine owns rendering, physics, audio, and the main loop in native code; the script VM owns gameplay logic, AI behavior, dialogue, and event hooks. The interface between them — the binding layer — is where most of the engineering effort lives, and where most of the pain lives too.
The languages in this family span a spectrum. At one end sit engine-native bytecode languages designed by the engine team for one host: UnrealScript, Papyrus, QuakeC, Pawn, and GDScript. They are tightly coupled, ship with the engine, and rarely escape it. At the other end sit general-purpose embeddable VMs that a game studio adopts off the shelf: Lua (the canonical pick), Squirrel, AngelScript, Wren, ChaiScript, GameMonkey. These are written by language designers, distribute as small C/C++ libraries, and host any number of unrelated apps. In between are derivative or transpiled languages like MoonScript (compiles to Lua) and Haxe (compiles to many backends including game targets), and content-domain DSLs like Ren’Py and Lingo, which are scripting languages but are dominated by their content/director model rather than their syntax.
The dominant 2026 picture: Lua and C# (Unity, MonoGame) own the modern commercial market; GDScript owns the open-source-engine niche following Godot’s surge; bespoke languages like UnrealScript and Lingo are deprecated; modder-driven ecosystems (SA-MP/Pawn, Bethesda/Papyrus, Source/Squirrel) keep their old languages alive long after the studios would have preferred to retire them.
In our deep library
The Tier 1 deep lua note is the canonical embedded scripting language used in games (LÖVE, Defold, Roblox-original) and is the implicit baseline against which every entry below is compared. Cross-reference. Note that forth-and-concatenative also covers some game-adjacent embedded VMs — most directly MUF, the Multi-User Forth dialect used by TinyMUCK servers, which is reproduced in this index for completeness but whose Forth lineage is detailed there.
Tier 3 family table
| Language | First appeared | Engine / use | Status (2026) | URL |
|---|---|---|---|---|
| UnrealScript | 1998 | Unreal Engine 1, 2, 3 / UDK | Deprecated; removed in UE4 (2014) in favor of C++/Blueprints | https://docs.unrealengine.com/udk/Three/UnrealScriptReference.html |
| Squirrel | 2003 | Source engine VScript (L4D2, Portal 2, CS:GO), Titanfall 2, IO games | Active; reference impl maintained on GitHub | http://squirrel-lang.org/ |
| AngelScript | 2003 | Hazelight UE plugin (It Takes Two), Embark (The Finals, ARC Raiders), Openspades, Rigs of Rods | Active; zlib-licensed, maintained by Andreas Jonsson | https://www.angelcode.com/angelscript/ |
| Wren | 2013 | Embeddable; used in indie engines and tools, WebAssembly-friendly | Active under new maintainer; “modern Lua alternative” momentum in 2025 | https://wren.io/ |
| Pawn (formerly Small) | 1998 | SA-MP, open.mp, AMX Mod X, SourceMod precursor, embedded systems | Active; CompuPhase still publishes updates (2025) | https://www.compuphase.com/pawn/pawn.htm |
| GDScript | 2014 | Godot Engine (1.x through 4.x) | Active; flagship language of a rapidly growing engine | https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/ |
| GameMonkey Script | 2002 | Embedded C++ apps; historical use in mid-2000s indie games | Dormant; MIT-licensed, only community/unofficial maintenance | https://en.wikipedia.org/wiki/GameMonkey_Script |
| ChaiScript | 2009 | C++ embedded scripting, ECMAScript-flavored, header-only | Active but slow-moving; stable releases since 2009 | http://chaiscript.com/ |
| Lingo | 1988 | Macromedia/Adobe Director; Shockwave CD-ROM era | Dead; Director discontinued by Adobe Feb 2017, Shockwave Apr 2019 | https://en.wikipedia.org/wiki/Lingo_(programming_language) |
| QuakeC | 1996 | Original Quake engine (id Tech 1); compiled to progs.dat bytecode VM. (Note: id Tech 2 / Quake II abandoned QuakeC for native C DLLs.) | Historical; lives on in FTEQW / Quakespasm-spiked sourceports | https://en.wikipedia.org/wiki/QuakeC |
| MUF | 1990 | TinyMUCK 2.0+, Fuzzball, ProtoMUCK, GlowMUCK servers | Niche/active in surviving MUCK communities; Forth-family stack lang | https://mud.fandom.com/wiki/MUF_(programming_language) |
| Papyrus | 2011 | Bethesda Creation Engine: Skyrim, Fallout 4, Fallout 76, Starfield | Active for modders; canonical mod-scripting language for Bethesda RPGs | https://ck.uesp.net/wiki/Papyrus_Introduction |
| Haxe (as game script) | 2005 | HaxeFlixel, OpenFL, Heaps.io, Defold-Haxe, Friday Night Funkin’ | Active; Haxe 4.3.7 (May 2025), Haxe 5 in preview | https://haxe.org/ |
| MoonScript | 2011 | Compiles to Lua; usable anywhere Lua runs incl. LOVE 2D via wrappers | Stable but quiet; reference compiler maintained by leafo | https://moonscript.org/ |
| Ren’Py script | 2004 | Ren’Py visual-novel engine (Python-hosted DSL) | Very active; 8.5.2 “In Good Health” (Jan 2026), 8.5.3 prerelease (Apr 2026) | https://www.renpy.org/ |
Notable threads
- GC pause vs frame budget. A 16.6 ms frame leaves no slack for a stop-the-world collector. Lua’s incremental GC, Wren’s compact object model, and Squirrel’s reference-counting-plus-cycle-detector are all answers to “how do we collect without dropping a frame?” — Papyrus dodges it differently by running scripts on a separate thread with no realtime contract. Engine-native langs that ignored this (early UnrealScript) became infamous for stutter.
- Hot-reload as a feature, not an afterthought. The reason a studio picks a script language over native C++ is to edit-and-see in seconds. GDScript, Lua, Squirrel, and AngelScript all support reloading classes/functions live; UnrealScript famously did not, which is part of why the UE4 team killed it.
- Modder-vs-dev API split. Papyrus, Pawn (SA-MP), and Source/Squirrel succeed not because the language is great but because the studio shipped a stable, documented surface area for modders. Haxe and MoonScript fail to gain ground in this niche specifically because they expect you to recompile the whole game.
- The drift toward Lua and C#. Most modern commercial engines now expose Lua (Defold, Solar2D, World of Warcraft addons, Garry’s Mod, Roblox-Luau-fork) or C# (Unity, MonoGame, Stride) instead of inventing a bespoke language. The cost of designing, documenting, and maintaining a new VM almost never pays off — UnrealScript and Lingo are the cautionary tales.
- GDScript and the Godot surge. GDScript was an outlier when Godot was niche; with Godot 4.x’s adoption explosion (post-Unity-pricing-crisis 2023, sustained through 2026) it’s now arguably the most-written game scripting language outside Lua and C#. Python-like syntax + tight engine integration + first-party tooling beat the “but it’s another bespoke language” objection.
- The QuakeC → Pawn → AngelScript lineage. John Carmack’s choice in 1996 to ship a custom compiled bytecode VM with Quake set the template every entry in this table follows. Pawn (1998) is essentially the “Small C” branch of that idea, AngelScript (2003) is the “but with real C++ types” branch, and Squirrel (2003) is the “but with table-based prototypes like Lua” branch. All three are direct descendants of the QuakeC insight: ship a tiny VM, expose your game state as natives, let modders work without your source.
Citations
- https://en.wikipedia.org/wiki/UnrealScript
- https://docs.unrealengine.com/udk/Three/UnrealScriptReference.html
- http://squirrel-lang.org/
- https://github.com/albertodemichelis/squirrel
- https://en.wikipedia.org/wiki/Squirrel_(programming_language)
- https://www.angelcode.com/angelscript/
- https://en.wikipedia.org/wiki/AngelScript
- https://wren.io/
- https://github.com/wren-lang/wren
- https://www.compuphase.com/pawn/pawn.htm
- https://github.com/compuphase/pawn
- https://wiki.alliedmods.net/Pawn_tutorial
- https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/
- https://github.com/godotengine/godot
- https://en.wikipedia.org/wiki/GameMonkey_Script
- http://chaiscript.com/
- https://github.com/ChaiScript/ChaiScript
- https://en.wikipedia.org/wiki/Lingo_(programming_language)
- https://en.wikipedia.org/wiki/Macromedia_Director
- https://en.wikipedia.org/wiki/QuakeC
- https://en.wikipedia.org/wiki/Quake_engine
- https://en.wikipedia.org/wiki/TinyMUCK
- https://mud.fandom.com/wiki/MUF_(programming_language)
- https://ck.uesp.net/wiki/Papyrus_Introduction
- https://www.creationkit.com/
- https://haxe.org/
- https://haxeflixel.com/
- https://moonscript.org/
- https://www.renpy.org/