Open-source alternatives to Clojure

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

Rhino is a Java-based JavaScript engine that implements an ECMAScript compatibility layer for execution inside a Java virtual machine. It serves as an embedded scripting engine and a scripting bridge, allowing JavaScript code to be integrated and executed within Java applications. The project facilitates direct inter-language communication by mapping Java classes and objects into a JavaScript environment. This integration enables scripts to interact with internal system services and native host objects through a dedicated mapping mechanism. The engine optimizes performance by compiling JavaS

JRuby is a Ruby language implementation that runs on the Java Virtual Machine. It serves as a cross-language runtime and execution environment, allowing Ruby code to run on the JVM and share memory with Java applications. The project functions as a bridge between Ruby and Java, enabling Ruby scripts to call Java classes and libraries directly. It also provides a mechanism to embed a Ruby interpreter into Java applications to allow for dynamic scripting. The runtime leverages the JVM for system scalability and ensures a consistent execution environment across different operating systems.

fq is a command-line binary data processor used for decoding, transforming, and analyzing raw byte streams and bit-level data into structured formats. It functions as a functional binary query engine that allows for filtering and mapping binary structures, as well as a converter that translates complex binary blobs and proprietary file formats into standard JSON, YAML, or XML. The tool distinguishes itself as a low-level bit manipulator capable of performing bit-level slicing, bitwise operations, and cryptographic hashing on raw files. It also serves as a network protocol analyzer with the ab

Lean 4 is a functional programming language and interactive proof assistant used to formalize mathematics and verify software correctness. It functions as a dependent type theorem prover and a formal verification tool that allows users to construct mathematical proofs and ensure program correctness. Additionally, it serves as a logic-based source for generating verified datasets used to train and benchmark artificial intelligence reasoning systems. The system distinguishes itself through a small-kernel verification model, where all proofs are verified by a trusted core of basic logical rules.

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

ClojureScript is a Lisp-based compiler and runtime that translates Clojure source code into JavaScript. It enables functional programming across different JavaScript engines and platforms, allowing developers to build user interfaces and applications for web browsers and server environments. The project provides a read-eval-print loop for executing code live within a browser or server for immediate feedback. This facilitates an interactive development workflow where code can be written and tested in real time without restarting the application. The system covers a broad capability surface, i

Vyper is a security-focused, typed programming language and compiler designed for creating smart contracts that execute on the Ethereum Virtual Machine. It utilizes a Pythonic syntax to define contract logic and state, serving as a target for formal verification to allow for machine-checked proofs of correctness. The language distinguishes itself through strict architectural constraints that prioritize predictability and security. It enforces acyclic call graphs by prohibiting recursion and mandates bounded loops to ensure static gas prediction. Additionally, it features a native fixed-point

This project is a functional programming library and toolkit for building production TypeScript applications. It provides a system for managing concurrency, error handling, and resource lifecycles using functional effects. The project distinguishes itself through a comprehensive suite of specialized toolkits, including a dependency injection framework for decoupling service implementations, a workflow orchestrator for coordinating durable processes, and a SQL database toolkit for consistent data operations across multiple dialects. It also implements an OpenTelemetry instrumentation library f

Pry is a programmable Ruby shell, REPL console, and runtime developer environment. It serves as a debugging toolkit for inspecting object state, navigating bindings, and evaluating code within a running Ruby program. The project differentiates itself through advanced introspection and live iteration capabilities. It allows users to inject an interactive console into a running program at specific points to inspect local state and navigate different object scopes. It further enables live code iteration by integrating with external system editors to modify and reload method definitions without r

Processing is a creative coding environment and Java graphics library designed for writing visual sketches that produce interactive 2D and 3D graphics and animations. It runs on the Java Virtual Machine, using an OpenGL-based hardware-accelerated rendering pipeline, and operates on a sketch-based execution model where programs run as continuous loops of setup and draw functions with event-driven input handling for keyboard, mouse, and window interactions. The environment distinguishes itself as a cross-platform sketch tool that runs visual programs unchanged on desktop, web, Android, and Rasp

This project is a terminal-based command line interface client and agent orchestrator for interacting with multiple large language model providers. It functions as an OpenAI API client and a local API gateway that exposes chat completions and embeddings through an HTTP server. The system distinguishes itself by providing a retrieval-augmented generation tool for indexing local files and URLs into a vector database to provide custom document context. It allows for the creation of specialized AI agents that combine custom system prompts with tool calling and external function execution. The to

AlgoXY is a functional programming educational book and technical publication produced as a LaTeX digital book. It serves as a programming education resource and library focused on functional algorithms and data structures. The project provides a collection of persistent data structures, such as trees and heaps, designed for immutable state management. It includes a series of implementation exercises and verified answers to teach core computer science concepts through the practical application of functional logic. The content covers the design of persistent data structures and the implementa

This is a persistent data structure library for JavaScript that provides collections which prevent the direct mutation of objects and arrays. It serves as an immutable state management tool and functional programming utility, ensuring that data remains unchanged after creation to simplify change detection and state tracking. The library enables the maintenance of application state by producing new versions of data structures during updates. It focuses on efficient data comparison by checking actual content instead of memory references and supports a functional programming workflow to prevent

Laravel Tinker is an interactive shell that boots the full Laravel application context, allowing you to run PHP code, test models, and experiment with the framework in real time from the command line. It integrates PsySH as its underlying REPL engine, providing features like automatic namespace resolution, command history persistence, and on-demand class loading through Composer's autoloader. The tool handles the full lifecycle of a Laravel console command, from defining input signatures and prompting for missing arguments to executing commands programmatically and queuing them for background

The Java Development Kit is a comprehensive software development environment designed for compiling, debugging, and executing applications written in the Java programming language. It provides the core infrastructure necessary to transform human-readable source code into platform-independent bytecode and run those applications across diverse computing environments. At the center of this environment is the Java Virtual Machine, a runtime engine that executes compiled bytecode while managing memory and system resources. This architecture utilizes a stack-based virtual machine and a platform-agn

Underscore is a JavaScript utility library providing a suite of functional programming and data manipulation helpers. It serves as a framework for transforming data collections, composing functions, managing objects, and performing precise data type validation without modifying core language prototypes. The project includes a functional programming toolkit designed to control function execution timing and behavior through techniques such as debouncing, throttling, and partial application. It also provides a dedicated object manipulation utility for cloning, merging, picking, and omitting prop

This project is a comprehensive educational guide and technical manual for the Ethereum blockchain. It provides structured instruction on blockchain fundamentals, smart contract development, and the architectural principles of decentralized applications. The resource covers technical domains including smart contract security auditing, network administration, and web3 programming. It details the implementation of token standards, the use of mnemonic seeds for wallet integration, and the creation of censorship-resistant application architectures. The documentation extends to system-level opera

JNA is a foreign function interface and native memory mapper that allows Java applications to call functions in shared native libraries without writing custom JNI wrapper code. It serves as a JNI alternative framework for invoking C functions and mapping native data structures using high-level interfaces. The library distinguishes itself through its ability to translate Java objects and primitives into C-style structs, unions, and pointers for cross-platform memory exchange. On Windows, it provides a dedicated toolkit for interacting with Component Object Model objects using both early and la

This project is an educational implementation of a relational database engine written in C. It functions as a SQLite clone, demonstrating the internal mechanics of a database system through a C-based systems project that focuses on manual memory management and file I/O. The engine is distinguished by its use of a bytecode virtual machine, which executes database operations by compiling SQL statements into low-level instructions. It utilizes a B-tree database engine to organize records in a balanced tree structure, ensuring efficient insertion, search, and range scanning. The system covers co

This library provides a collection of specialized data structures for the Swift language that extend the standard library with advanced container types. It includes implementations for double-ended queues using ring-buffers, priority queues based on min-max heaps, and memory-efficient bit-set and bit-array storage for boolean values. The project features ordered collections that maintain elements in sorted order via B-tree implementations, as well as persistent sets and dictionaries that use compressed prefix trees to share data between mutated copies. It also provides specialized containers

JavaCPP is a JNI C++ bridge and foreign function interface that provides a binding generator, a native library loader, and a native memory manager. It automates the creation of Java wrappers around native C++ headers and shared libraries to enable interoperability between the two languages. The project features a C++ binding generator that parses header files to automatically produce the necessary glue code and interfaces for calling native functions. It includes a native library loader that locates and extracts platform-specific binaries from the classpath into a local cache for runtime exec

j2objc is a source-to-source compiler and transpiler that converts Java source code into Objective-C. It functions as a cross-platform logic porter, allowing application logic and data models written in Java to be shared and executed on iOS. To support this translation, the project provides an Objective-C implementation of core Java classes and APIs to emulate the Java runtime environment. The system includes specialized translation for Java libraries and provides mapping for dependency injection and static analysis annotations to preserve metadata. It also enables the conversion of JUnit tes

electron-vite is a build system and multi-process bundle orchestrator that uses Vite to compile and bundle the main, preload, and renderer processes for Electron applications. It functions as a desktop application scaffolder, providing templates to integrate various frontend frameworks into a standardized project structure. The project distinguishes itself through integrated source code protection, utilizing a V8 bytecode obfuscator to compile JavaScript into bytecode and obfuscate strings to prevent reverse engineering. It also manages complex desktop architectures by isolating bundles and s

Red-DiscordBot is a modular framework for building and self-hosting Discord bots. It functions as a server management tool and community moderation bot that can be tailored by enabling or disabling specific feature modules. The system is distinguished by its extensible plugin architecture, which allows for the integration of third-party modules and the development of custom functional packages. Users can manage bot behavior through a chat-based interface, enabling them to assemble custom bots and define unique responses and behaviors without writing new code. The framework covers a broad ran

Immutable.js is a library of persistent data structures and a functional state management toolkit. It provides a collection of immutable objects and arrays that prevent direct mutation to ensure predictable state management in JavaScript applications. The library utilizes structural sharing to efficiently create new versions of data without full copying and implements lazy sequence processing to chain data transformations that execute only when values are requested. It also supports batch mutation processing, allowing multiple changes to be applied to a temporary mutable copy before returning