PowerShell 7 (pwsh) is a production-grade cross-platform automation and configuration shell: a scripting language runtime, command engine, and host application. The repository contains the core engine assembly (System.Management.Automation), console host, global tool shim, hundreds of built-in cmdlets, provider infrastructure, remoting, formatting/serialization, and a meta-package SDK for embedding PowerShell in .NET applications. In production it executes scripts and commands, pipelines objects through cmdlets and providers, formats results for console or serialized transport, and supports both local runspaces and remote sessions over WinRM/WSMan and SSH. The primary entry points are ConsoleShell.Start() for the interactive host, the GlobalToolShim for the dotnet tool distribution, and the PowerShell.Create() hosting API used by embedded scenarios.
OpenSCAD is a mature, script-based 3D CAD modeler. It provides a declarative language for defining solid geometry through Constructive Solid Geometry (CSG) operations, extrusions, and transformations. The application consists of a C++ core that parses the custom scripting language, builds an AST, and evaluates geometry using either the CGAL or Manifold library for boolean operations. Rendering is handled via OpenGL with both preview (OpenCSG) and final render modes. The GUI, built on Qt, includes a code editor with syntax highlighting, a 3D viewport, parameter customizer, and an integrated AI assistant for code generation. Exports to STL, OBJ, SVG, 3MF, PDF, and other formats. The codebase demonstrates strong engineering with clear module separation (core, geometry, glview, gui, io, utils), extensive regression tests, and reusable patterns such as visitors, builders, and self-contained geometry utilities.
Murex is a cross-platform shell and scripting language designed as a more readable, safe, and type-aware alternative to Bash. In production it works as both an interactive REPL (with autocomplete, hint text, preview panes, spellchecking, and job control) and a scripting interpreter with a custom expression language, typed pipelines, exception handling (try/catch/trypipe), multi-scope variables, a built-in unit test framework, event hooks (onPrompt, onKeyPress, onFileSystemChange, onSignalReceived), an HTTP client, and a package/module manager. The defining architectural feature is that data in pipelines carries type metadata: JSON, YAML, CSV, TOML, XML, S-expressions, HCL and more are first-class structured objects with registered Marshal/Unmarshal/ReadArray/ReadMap/ReadIndex hooks, so builtins like alter, tabulate, count, and jsplit operate on structured data rather than raw text. The implementation is Go (with a JS/WASM interpreter variant), organized around lang/ (parser, expression engine, process lifecycle), shell/ (interactive terminal layer), builtins/ (roughly 200 commands, data type adapters, pipes, and event handlers), config/ (profile-driven runtime configuration), and utils/ (standalone helper libraries).
Gravity is an embeddable, dynamically typed scripting language written in portable C99 with no external dependencies beyond the C standard library. The repository implements a full language toolchain: a multi-pass compiler (lexer, Pratt parser, AST, IR, optimizer, bytecode codegen) and a register-based virtual machine with mark-and-sweep garbage collection. It provides a CLI (`gravity` executable) for running scripts and a well-defined C embedding API. The architecture is modular, with clear separation between compiler (`src/compiler`), runtime (`src/runtime`), shared utilities (`src/shared`), and optional modules (Math, File, JSON, ENV). The codebase is extensively tested with unit tests (embedded `#unittest` blocks) and a large fuzzing corpus for crash resistance. Despite some monolithic files (`gravity_core.c` >4000 lines) and heavy macro usage, the implementation demonstrates strong software engineering craftsmanship, especially in the hash table, dynamic array macros, and Pratt parser. The project appears to be under active maintenance (last commit 2026-08-05, 34 open issues, 4.5k stars) but shows some technical drift such as outdated CI configurations, platform-specific ifdefs, and a fuzz corpus from 2017.
KVIrc is a production-grade, cross-platform IRC client built on the Qt framework. It features a custom embedded scripting language called KVS (KVIrc Script) with full support for events, aliases, popups, timers, arrays, hashes, object-orientation, and control flow. The application is modular: a core library (kvilib) provides utilities (strings, containers, config, networking, cryptography), the main app (kvirc) manages connection state, IRC protocol parsing, and UI, while dozens of loadable modules (src/modules/) add DCC file transfers, voice/video, media player integration, encryption, language detection, UPnP, KTorrent interface, and more. The UI is heavily configurable with theming, options dialogs, toolbars, and notifier windows. The codebase shows a high degree of craftsmanship in its plugin system, abstraction layers, and the KVS scripting engine, but also carries significant technical debt from its long history (code dating back to the late 1990s) – including manual memory management, custom container classes, conditional compilation for many optional features, and some deprecated Qt API usage.
The Doomsday Engine is a modular game engine and source port for classic FPS games (Doom, Heretic, Hexen, Doom64) with client-server architecture. It provides enhanced rendering (OpenGL), audio systems, GUI frameworks, networking, and scripting capabilities. The engine supports extensibility via plugins and includes tools like Amethyst for documentation processing. The codebase shows strong separation of concerns with distinct libraries for core functionality, game logic, rendering, and UI. While actively maintained, it exhibits technical drift due to platform-specific conditionals, legacy code sections, and complex dependency management.
This repository is a Godot GDExtension that enables using Dart as a scripting language for the Godot game engine. It provides a C++ native plugin that embeds the Dart VM, a Dart runtime library (`godot_dart`) with FFI bindings and type wrappers, and a build runner package (`godot_dart_build`) for generating boilerplate code from `@GodotScript` annotations. A binding generator tool (`tools/binding_generator`) reads Godot's extension API JSON to produce Dart bindings for engine classes and built-in types. The repo includes two example projects: a 2D game tutorial and a networking demo. It is feature-rich but explicitly experimental, with partial support for debugging, hot reload, and editor integration, and acknowledges that performance optimization has not yet been performed. The architecture is a hybrid of C++ native extension and Dart packages with code generation pipelines, making it a complex but well-structured integration layer between the Godot engine and the Dart language.