Open-source alternatives to Coffeescript

Bhai-lang is a TypeScript-based toy programming language and custom syntax interpreter. It functions as an educational language implementation designed to demonstrate core concepts of variable management, conditional logic, and execution flow. The project provides a custom command line interface and an interactive code playground for writing and testing scripts. It serves as a framework for programming language prototyping, allowing for the definition of custom syntax and execution logic. The system covers the full interpreter pipeline, including lexical analysis, recursive descent parsing,

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

This project is a comprehensive guide and educational resource for the TypeScript language. It covers the fundamental principles of the language, including its structural type system, static type analysis, and the process of transpiling typed source files into JavaScript. The material details how to model complex data and reusable type logic using generics, conditional types, and mapped types. It also explains the use of declaration files to provide type safety for external JavaScript libraries and the integration of type checking into existing JavaScript projects via JSDoc annotations. The

Reason is a statically typed programming language and compiler based on the OCaml ecosystem. It translates high-level, type-safe source code into either JavaScript or OCaml output, providing a typed alternative for web and system development. The language focuses on providing rigorous type safety and a robust module system while integrating with the JavaScript ecosystem. It allows for the development of applications that leverage existing JavaScript libraries while utilizing a more rigid type system to eliminate common runtime crashes and data mismatches. The project covers capabilities incl

PHP-Parser is a tool that converts PHP source code into an abstract syntax tree for static analysis and programmatic manipulation. It functions as a parser, a code generator, and a static analysis framework. The project enables the programmatic construction of abstract syntax tree nodes through a fluent interface and provides the ability to transform these trees back into formatted source code. It includes a serializer that exports abstract syntax trees to JSON format and reconstructs them from strings. The toolset covers several capability areas, including namespace resolution, constant exp

This project is a C language interpreter and a practical implementation of a programming language. It parses and executes C source code directly, removing the requirement for a separate compilation step. The interpreter is designed for self-hosting, meaning it is capable of interpreting its own source code to demonstrate recursive language processing and execution. The system covers the primary stages of language processing, including lexical analysis, recursive descent parsing, and tree-walk interpretation using an abstract syntax tree. It manages memory and scope through a dynamic symbol t

c2rust is a source-to-source translation suite and C-to-Rust transpiler designed to convert C source code and libraries into functionally equivalent unsafe Rust code. It operates as a pipeline that preserves original behavior and data structures, producing translated code that compiles as compatible shared libraries or Rust crates. The system includes an automated Rust refactoring framework that uses pattern-based AST rewriting to transform unsafe Rust into safe, idiomatic constructs. It utilizes an ownership inference engine to determine when raw pointers can be converted into safe reference

This project is a high-performance compiler written in Rust that transpiles TypeScript and ECMAScript into compatible JavaScript code. It functions as a TypeScript transpiler, a JavaScript minifier, and a JavaScript bundler. The system distinguishes itself through a WebAssembly plugin host that allows the execution of custom transformation rules without modifying the core binary. It also provides specialized compilation for React source code to improve runtime performance and reduce execution overhead. The broader capability surface includes source-to-source compilation, type annotation stri

Opal is a Ruby frontend framework and compiler that translates Ruby source code into JavaScript. It functions as a web runtime that allows for the development of client-side web applications using Ruby instead of JavaScript. The project includes a Ruby HTML template engine that evaluates Ruby code embedded directly within markup files. It further integrates with JavaScript environments by bundling core libraries and dependencies into a distribution string for execution in a web browser. The system provides capabilities for Ruby to JavaScript compilation and the ability to encode and decode B

Binaryen is a WebAssembly compiler toolchain and optimizer designed to transform, validate, and shrink binary modules. It provides a comprehensive intermediate representation framework that converts binary code into a single-assignment form to enable advanced program analysis and code transformation. The project includes a specialized transformation engine that applies iterative optimization passes to increase execution speed and reduce binary size. Additionally, it functions as a transpiler that translates WebAssembly binary modules into executable JavaScript for environments that lack nativ

Ivy is a machine learning framework transpiler and model converter designed to ensure deep learning portability. It serves as a tool for migrating source code and models between different deep learning frameworks while maintaining original functionality. The system enables cross-framework model portability by translating model weights, architectures, and source code. It uses abstract syntax tree based transpilation and computational graph tracing to capture execution flows and rewrite high-level logic into target framework code. The project covers model interoperability through weight-layout

Lebab is a JavaScript code modernization tool that converts older ES5 syntax into contemporary ES6 equivalents. It operates as a source-to-source transpiler, parsing code into an abstract syntax tree, applying structural transformations, and regenerating the output without intermediate representations or runtime dependencies. The tool distinguishes itself through a rule-driven pipeline of independent transformation rules, each targeting a specific ES6 feature like arrow functions, let/const, classes, or modules. It provides a programmatic API that accepts source code and an array of transform

Rust-bindgen is a build-time foreign function interface binding generator and C header parser designed to automate cross-language interoperability. It functions as a tool to bridge Rust with C, C++, and Objective-C libraries by producing platform-specific declarations during the compilation process. The project distinguishes itself through its ability to handle complex C-family language constructs, including C++ inheritance and methods, as well as Objective-C classes and protocols. It ensures binary compatibility across different architectures by calculating target-aware memory layouts and va

Ivy is a machine learning framework transpiler and model converter designed to translate code and computational graphs between different deep learning ecosystems. It serves as a portability tool for migrating model architectures and logic across competing frameworks to enable flexible deployment. The system achieves cross-framework conversion by utilizing abstract syntax tree analysis to rewrite source code and by employing a computational graph tracer to capture tensor flows and operation sequences during live execution. This process allows for the translation of both high-level model defini

Rollup is an ES module bundler and JavaScript module transpiler. It functions as a build tool that combines JavaScript modules into optimized files and converts modern JavaScript and JSX into various output formats for different runtime environments. The project is distinguished by its static-analysis tree shaking engine, which removes unused code and dead exports to minimize bundle size. It also acts as a code splitting orchestrator, partitioning modules into separate chunks to optimize network requests and load times. The tool provides a hook-based plugin system for extending build logic,

Reason is a strongly typed functional language and multi-target compiler designed to produce either JavaScript for web environments or native machine code for operating systems. It serves as an OCaml-compatible language that shares an abstract syntax tree with OCaml, providing a practical syntax for the OCaml ecosystem. The project functions as a type-safe frontend language, incorporating JSX support to build user interfaces through structural elements that translate into type-safe function calls. It enables deep integration with the JavaScript ecosystem, allowing the use of existing librarie

Traceur is a JavaScript syntax transpiler that transforms modern and next-generation language features into compatible versions for older runtime environments. It functions as a compiler that translates proposed language standards and upcoming syntax into current versions to maintain cross-engine compatibility. The project operates as an asynchronous code transformer, converting async functions and generators into promise-based state machines. It includes a functional tail-call optimizer that wraps recursive functions in trampolines to prevent stack overflows and an ECMAScript polyfill engine

ReScript is a statically typed programming language and compiler designed to transform type-safe source code into efficient, human-readable JavaScript. It functions as a transpiler that enforces data consistency and prevents runtime errors through static type analysis for both web and server applications. The project distinguishes itself as an incremental build system that analyzes dependency graphs to recompile only modified files and their dependents. It includes a JSX compatible compiler for building user interfaces and provides a framework for bridging type-safe code with existing JavaScr

Borgo is a statically typed language and compiler that transforms high-level syntax into Go source code. It functions as a transpiler designed to leverage the Go runtime while introducing a type system centered on algebraic data types and result-based error handling. The language distinguishes itself by replacing Go's multiple return values with result and option types, using a dedicated operator for concise error propagation. It implements sum types with exhaustive pattern matching and provides a tool to generate bindings for existing Go packages, automatically converting multi-value returns

This project is a JavaScript optimizer, minifier, module bundler, transpiler, and static analysis tool. It provides a compilation pipeline designed to shrink file sizes and improve runtime performance. The system utilizes a multi-pass compilation process to perform dead code elimination, global name mangling, and static type inference. It identifies unreachable functions and unused variables to reduce the final output size and detects potential runtime errors without executing the code. The tool manages assets through dependency resolution, code chunking, and bundle management. It ensures co

Grumpy is a native binary compiler that transforms Python source code into Go source code. By transpiling high-level scripts into a strongly typed intermediate representation, the system enables the creation of statically linked native binaries that operate independently of a traditional virtual machine interpreter. The project distinguishes itself by providing a comprehensive runtime library that replicates standard Python data structures and object behaviors. This emulation layer ensures that compiled code maintains functional parity with the original source environment while leveraging the

This project is a Python web application framework and development kit designed for building fullstack applications and professional APIs. It provides a methodology for constructing responsive user interfaces and backend logic using only the Python language, removing the need for separate frontend markup languages or technology stacks. The toolkit includes a REST API development kit for creating data exchange interfaces and a guide for containerized web deployment to ensure consistent execution across various hosting services and pipelines. The project covers the integration of relational da

This project is a functional programming compiler and JavaScript transpiler that transforms a statically typed language into optimized JavaScript for web browsers. It serves as a frontend architecture framework, providing a static type system and a package manager that enforces semantic versioning. The compiler uses a type-checking engine with automatic type inference to prevent runtime errors and guide code refactoring. It implements a structural pattern for managing application state and rendering user interfaces through a virtual DOM, utilizing immutable data and purity-based state transit

This project provides a server-side language runtime and a standardized Docker image for deploying applications across different operating systems. It functions as an execution environment for generating dynamic HTML, JSON, and XML content, while also serving as a command line interface for automation scripts and background jobs. The runtime is designed for extensibility through a C-based extension architecture, allowing the loading of custom modules for specialized functionality. It supports multiple server application interfaces, including a FastCGI web interface for high-performance commun

Microbundle is a zero-configuration JavaScript module bundler designed to package small libraries and modules into optimized distribution files. It serves as a JavaScript library packager and TypeScript compiler, converting source code into compatible module formats for both browser and server-side runtimes. The tool functions as a bundle size optimizer by mangling object properties and analyzing bundle composition to reduce final file sizes. It also acts as a CSS module processor, converting style imports into external stylesheets or scoped modules to prevent global namespace collisions. It

The Concise TypeScript Book: A Concise Guide to Effective Development in TypeScript. Free and Open Source.

This project is a Webpack build guide and a reference for implementing a JavaScript module bundler. It serves as a frontend build pipeline designed to resolve dependencies, package source files, and optimize assets for web browsers. The guide focuses on asset optimization and performance strategies. This includes implementing code splitting for asynchronous module loading, extracting shared dependencies to improve browser caching, and generating multiple entrypoints to reduce initial download sizes. The project covers a broad range of build-time capabilities, including modern JavaScript tran