Open-source alternatives to Groovy

Sweet-core is a JavaScript source-to-source compiler and Lisp-style macro system. It functions as a syntax transformer that extends JavaScript by allowing the definition of custom syntax and operators during the compilation process. The system provides a framework for building domain-specific languages through hygienic, recursive macro expansion and the creation of new language constructs. It distinguishes itself by supporting custom operator definitions with configurable associativity and precedence to control expression evaluation. The compiler includes a specialized module system for mana

This project is a terminal automation and recording tool that uses a custom declarative scripting language to execute command-line sequences. It functions as a framework for both generating animated media files and performing automated terminal output validation. By managing isolated pseudo-terminal sessions, it captures and renders terminal interactions into high-quality GIFs, videos, or static images. The tool distinguishes itself through its ability to treat terminal sessions as testable, repeatable artifacts. It supports golden-file testing, allowing users to verify command-line behavior

Cake is a cross-platform build automation system and scripting framework that allows users to define software build pipelines using C# scripts. It functions as a CI/CD pipeline orchestrator and build runner, providing a strongly-typed domain-specific language to simplify the orchestration of compilation, testing, and packaging processes across Windows, Linux, and macOS. The system ensures reproducible build environments by pinning the versions of build tools, modules, and dependencies. It distinguishes itself by enabling a C# scripting workflow with full IDE support, including autocomplete, s

Scala.js is a compiler and cross-platform language toolchain that transforms Scala source code into JavaScript or WebAssembly. It functions as a statically typed tool for the JavaScript ecosystem, enabling the development of applications for web browsers and Node.js environments. The project serves as a JavaScript interop framework, allowing the creation of type-safe facades and bindings to interact with external libraries and global objects. It provides mechanisms for both static and dynamic JavaScript invocation, including the generation of TypeScript bindings and the ability to export inte

This project is a comprehensive functional programming curriculum and learning resource for Haskell. It provides sequenced educational paths and technical reference guides designed to take developers from beginner to advanced levels of proficiency. The project distinguishes itself through a deep focus on theoretical and technical foundations, offering detailed studies on type theory, category theory, and runtime internals. It includes a dedicated performance handbook for optimizing execution speed and memory management, as well as an ecosystem guide for managing development tools and editor c

This project is a comprehensive technical interview preparation guide and computer science knowledge base. It serves as a structured study resource designed to help software engineers review core engineering concepts and prepare for professional coding assessments. The repository focuses on a wide array of theoretical and practical domains, including detailed references for mobile application architecture and operating system fundamentals. It provides curated materials on software architecture patterns and network protocol analysis to support professional development. The content covers foun

Haxe is a statically typed, multi-target programming language and open-source compiler toolkit that translates a single codebase into native executables and scripts for JavaScript, C++, C#, Java, Python, Lua, PHP, and Flash targets. It provides a unified type system with automatic type inference, a compile-time macro system for code transformation and generation, conditional compilation directives, and a static analysis engine that enforces null safety and eliminates dead code to produce smaller, safer outputs. The language is supported by the HashLink virtual machine, which executes platform

Clojure is a general-purpose, functional programming language hosted on the Java Virtual Machine. It is a homoiconic S-expression language that represents programs as nested data structures, allowing code to be manipulated and evaluated as data. The project provides a framework for JVM interoperability, enabling the invocation of Java methods and integration with other JVM-based languages. It distinguishes itself through a persistent data structure library that uses bitmapped vector tries to manage immutable collections and a programmatic REPL for interactive software development and real-tim

The OWASP Cheat Sheet Series is a comprehensive, community-driven repository of concise security best practices and defensive coding patterns. It serves as a centralized knowledge base for developers and security professionals, providing actionable guidance to secure applications across the entire software development lifecycle. The project covers a vast array of security domains, ranging from fundamental web application hardening and authentication protocols to specialized controls for modern infrastructure and artificial intelligence systems. What distinguishes this project is its decentral

This project is a build orchestration engine and development toolkit designed for managing large-scale monorepos. It provides a unified workspace environment that maps project relationships and dependencies, enabling the system to perform intelligent impact analysis and execute only the tasks affected by specific code changes. The system distinguishes itself through a persistent daemon that monitors file changes for near-instant feedback and a content-addressable caching mechanism that stores task outputs to prevent redundant computation across local and remote environments. It further suppor

This project is a C++ template tutorial and metaprogramming guide. It provides instructional content on using templates to implement generic programming and execute Turing-complete logic during the compilation process. The guide serves as a reference for static type dispatching, substitution failure, and the use of concepts to ensure type safety. It covers methods for selecting function implementations at compile time to eliminate runtime branching. The material addresses compile-time type manipulation, including the transformation of type qualifiers and the use of constraints to prevent inv

Scala 3 is an open-source, statically typed programming language that compiles to JVM bytecode, combining object-oriented and functional programming paradigms. Its core identity is defined by a sophisticated type system that includes traits, generics, union types, and a dependent object type system where types can depend on runtime values through path-dependent and singleton types. The language distinguishes itself through several advanced type-level and metaprogramming capabilities. It features a contextual abstraction mechanism using given instances and using clauses for compile-time implic

DBML is a domain-specific language and schema definition language used for documenting database architecture and design. It provides a human-readable text format for defining database tables, columns, and relationships in a standardized way. The project functions as a relational schema parser and SQL schema generator. It transforms declarative design specifications into an abstract syntax tree for programmatic manipulation and converts these definitions into executable SQL statements across various database dialects. The system covers relational data modeling, database schema design, and arc

TrumpScript is a Python-based domain specific language and compiler extension that wraps the Python runtime to enforce custom grammar and vocabulary rules. It transforms a specialized, case-insensitive vocabulary and natural speech patterns into executable Python instructions. The implementation distinguishes itself through strict constraints on source code, including a variable name system that restricts identifiers to a predefined whitelist and a numeric parser that rejects any integer not exceeding one million. It further utilizes a token-filtering preprocessor to remove filler words and n

This project is a library of automation scripts designed for the BoxJs environment. It functions as an external API client and integration interface for interacting with remote servers. The system provides a persistent local data store to maintain state between script executions by saving and retrieving strings and JSON objects. It enables data exchange through structured JSON objects and supports both synchronous and asynchronous network requests using custom headers.

Taichi is a domain-specific programming language embedded in Python designed for high-performance numerical computing and computer graphics. It functions as a parallel compiler that translates high-level mathematical expressions into optimized machine instructions, enabling developers to write compute-intensive algorithms that execute across diverse hardware architectures, including CPUs, GPUs, and specialized accelerators. The project distinguishes itself through a hardware-agnostic execution layer that maps parallel operations to multiple backends such as CUDA, Metal, and Vulkan. By utilizi

InfluxDB is a specialized time series database platform engineered for the high-speed ingestion, compression, and retrieval of timestamped data at scale. It functions as a distributed metrics platform, providing the infrastructure necessary to organize and analyze massive volumes of time-stamped information to identify trends, patterns, and anomalies within complex data streams. The platform distinguishes itself through a functional dataflow engine that utilizes a specialized programming language for complex analytical transformations and automated tasks. This architecture is supported by a p

The project is a Python metaprogramming toolkit designed to build signature-preserving function decorators, generic dispatch functions, and context managers without losing metadata. It provides utilities for constructing custom function wrappers and converting generator functions or context managers into reusable decorators that automatically wrap execution blocks. The library supports multi-argument generic function dispatch by routing calls based on runtime argument types and virtual base classes, complete with abstract base class and virtual ancestor resolution. It also includes capabiliti

This project is a structured Rust programming curriculum and systems programming course designed to take learners from beginner to expert levels. It provides a comprehensive set of training materials focused on mastering the core syntax, idioms, and technical foundations of the Rust language. The project features a specialized language transition framework that maps concepts from C++, managed languages, and dynamic typing to Rust idioms. This allows developers from different ecosystems to translate architectural patterns and memory models into idiomatic Rust. The training covers a broad rang

Mint is a front-end programming language and compiled web framework designed for building interactive user interfaces. It functions as a transpiler that converts a specialized domain-specific language into standard JavaScript and CSS for execution in a web browser. The toolchain enables type-safe UI development by utilizing static type analysis to validate data structures during the build phase. It organizes web interface logic into a component-based architecture, where encapsulated units synchronize internal state with the rendered view. The system covers a full compiled web toolchain, incl

Kaitai Struct is a framework for declarative binary specification that provides automated parser and serializer generation across multiple programming languages. It uses a portable, domain-specific language to describe the layout of binary files and network packets, converting these specifications into source code for reading and writing binary data. The system enables cross-language data processing by translating a single structural definition into native source code for languages including C++, C#, Go, Java, JavaScript, Python, and Rust. This approach allows the same binary data specificati

This project is a comprehensive programming course and educational curriculum designed to transition developers from basic scripting to advanced software development. It provides structured guides and technical exercises focusing on language internals, professional software architecture, and sophisticated programming techniques. The curriculum distinguishes itself through a deep focus on language internals, analyzing object behavior and memory efficiency to improve execution speed. It provides specialized instruction on metaprogramming using decorators and dynamic attributes, as well as async

Nearley is a JavaScript parser toolkit and context-free grammar compiler. It functions as an Earley parser generator that transforms BNF-like grammar definitions into executable code capable of analyzing text and generating abstract syntax trees. The project is distinguished by its ability to handle any context-free grammar, including those with left recursion and ambiguity, by maintaining multiple valid derivations for a single input. It further supports incremental parsing, allowing input strings to be processed in chunks to provide partial results and real-time feedback. Beyond core parsi

ANTLR is a grammar-based code generator and multi-language parser generator used to design and implement custom languages. It functions as a toolkit for transforming formal language definitions into executable source code for processing structured text or binary files, while providing a framework for automatically constructing and traversing hierarchical parse trees. The project is distinguished by its ability to generate lexers and parsers in various target programming languages from a single shared grammar definition. It supports grammars containing direct left recursion and utilizes adapti

Streem is a stream-based programming language and data pipeline orchestrator. It provides a domain-specific language for defining concurrent data flows, allowing users to link data sources to destinations through a sequence of operations that transform and filter individual stream elements. The system uses a custom script syntax to define data-flow connections and pipeline definitions. This allows for the orchestration of concurrent data processing where multiple pipeline stages execute simultaneously to move data elements through the system. The platform covers functional data transformatio

Alda is a text-based music programming language and command-line tool for composing, playing, and live-coding musical scores. It functions as a MIDI composition engine that renders plain-text scores into audio output, and as a live coding environment where code entered in a read-eval-print loop produces real-time playback without restarting the interpreter. The system distinguishes itself through an event-driven playback engine that schedules timed note events, an instrument-attribute inheritance model that cascades properties like volume and tempo from global defaults to individual parts, an

Lua is an embeddable scripting language written in ISO C, designed to be integrated into host applications for runtime customization. It provides a C-based scripting engine and a prototype-based object model that utilizes associative arrays and metatables to implement inheritance and complex data structures. The language features a cooperative multitasking system that manages concurrent execution threads via coroutines and an incremental garbage collector for automatic memory management. It includes a safe code sandbox to isolate global state and run untrusted scripts within a protected envir