Open-source alternatives to Rescript

Oxc is a high-performance toolchain designed for the analysis, linting, formatting, and transformation of JavaScript and TypeScript codebases. It functions as a comprehensive static analysis engine and compiler-based utility, providing the infrastructure necessary to parse source code into high-performance abstract syntax trees and map complex module dependency graphs across entire projects. The project distinguishes itself through its use of multi-core parallel processing to maximize throughput during intensive tasks like linting and minification. It offers deep, type-aware static analysis t

PureScript is a statically typed, purely functional programming language that compiles to JavaScript. It is designed as a cross-platform frontend language for building safe web applications, utilizing a static type system and a JavaScript compiler to ensure program correctness across browser and server environments. The language is distinguished by its emphasis on mathematical purity, featuring a robust type system with first-class support for monads. It provides a sophisticated toolset for static verification, including algebraic data types, type classes, and automatic type inference to reje

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

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

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

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

A library for development of single-page full-stack web applications in clj/cljs

TeaVM is a Java bytecode transpiler and browser-based JVM runtime that converts compiled Java class files into JavaScript or WebAssembly. It functions as a compiler and build pipeline tool that enables applications written in various JVM languages to execute natively within a web browser. The project distinguishes itself by transforming bytecode directly into optimized web formats without requiring the original source code. It includes a WebAssembly bytecode compiler for high-performance execution and a specialized emulation system to handle asynchronous multithreading within the single-threa

Brython is a Python 3 runtime and interpreter that executes scripts directly in the web browser. It serves as a client-side environment that translates Python source code into executable JavaScript to handle frontend logic without requiring server round-trips. The project provides a bidirectional interoperability bridge between Python and JavaScript, allowing for the integration of external JavaScript libraries. It further functions as a tool for packaging Python scripts into standalone native mobile applications for Android devices. The runtime includes a library for programmatic manipulati

Kotlin is a statically typed, general-purpose programming language designed for type safety and concise syntax. It functions as a cross-platform development toolkit that enables the sharing of business logic across mobile, web, and server-side environments by compiling a unified intermediate representation into platform-specific machine code, bytecode, or source code. The project distinguishes itself through a multi-target build orchestration model that manages complex compilation units and hierarchical source sets. Developers can define common interface logic that is satisfied by platform-sp

Sway is a smart contract development language and programming environment designed for writing, compiling, and deploying secure blockchain programs. It serves as a type-safe language for building on-chain logic and a static analysis toolchain that validates contracts before they are executed on a network. The ecosystem provides a development environment focused on blockchain application logic and web3 backend engineering. It integrates a type-safe programming approach to reduce vulnerabilities and ensure reliable state transitions for decentralized services. The toolchain incorporates static

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

Crystal is a statically typed, compiled programming language designed for high performance and memory safety. It leverages an LLVM-based compiler to translate source code into optimized machine-executable binaries, while its type-inference-based static analysis enforces strict safety rules during the build process. The language distinguishes itself through a fiber-based concurrent runtime that manages lightweight execution units for asynchronous input and output without blocking the main process. It also features a powerful compile-time macro system that allows for the inspection and transfor

Flow is a JavaScript static type checker and AST parser that identifies type errors and prevents runtime failures through static annotations. It functions as a code intelligence engine and a static analysis linter to identify unsafe coding patterns and enforce consistency across a codebase. The project includes a type annotation stripper that removes static type signatures from source code, ensuring the resulting JavaScript is compatible with any runtime environment. It also provides a parser that converts typed JavaScript into an abstract syntax tree conforming to the ESTree specification.

Rust-analyzer is a language server implementation that provides real-time code intelligence, static analysis, and development productivity tools for the Rust programming language. It functions as a backend engine that communicates with text editors to deliver deep structural understanding of source code, enabling features like semantic analysis, symbol navigation, and automated refactoring. The project distinguishes itself through a core engine designed for high-performance responsiveness, utilizing incremental query-based compilation and lazy demand-driven evaluation to minimize resource con

This project is a technical breakdown and implementation of a user interface framework's internal architecture, focusing specifically on the mechanics of the virtual DOM, reconciliation, and component lifecycles. It serves as a resource for understanding how a core logic layer manages the transition from high-level component descriptions to physical browser elements. The project distinguishes itself by providing detailed visualizations, including flowcharts and block schemes, to map the reconciliation process and code execution paths. It explores how a platform-agnostic core can be adapted fo

Sucrase is a high-speed transpilation tool that compiles modern JavaScript, TypeScript, JSX, and Flow to standard JavaScript for modern runtimes. It operates as a fast alternative to Babel, using a single-pass scanner and tokenizer that strips type annotations and applies only requested syntax transforms without building an AST or performing type checking. The tool differentiates itself through a zero-type-checking pipeline that omits type checking entirely, relying on the assumption that input code is already valid for the target runtime. It uses scanner-based tokenization and single-pass co

RLS is a language server that provides language intelligence for the Rust programming language. It implements the Language Server Protocol to enable a standardized communication layer between the Rust compiler and various editor clients. The project focuses on providing real-time code completions, symbol navigation, and type information. It also supports automated structural changes, such as workspace-wide symbol renaming, to maintain semantic correctness during refactoring. The system incorporates static code analysis for linting and formatting, alongside a mechanism for incremental compila

Farm is a Rust-based web build tool and development server that compiles JavaScript, TypeScript, CSS, HTML, and static assets into optimized bundles. It uses a module-graph-based bundling approach with persistent module-level caching, enabling near-instant builds and sub-20ms hot module replacement during development. The tool processes assets based on file extensions, handling CSS, Sass, Less, PostCSS, HTML, and images as first-class modules without requiring JavaScript transformation. Farm distinguishes itself through its Vite-compatible plugin system, accepting Vite, Rollup, and Unplugin p

GraphiQL is an interactive browser-based integrated development environment for writing, testing, and documenting GraphQL queries and mutations. It functions as a code editor, an API exploration tool, and a schema explorer, providing a visual interface for browsing GraphQL types and fields. The project provides a language server that delivers schema-driven autocompletion, linting, and validation via the Language Server Protocol. It allows for the embedding of high-performance editors into external projects and supports the injection of custom tools and components through a sidebar plugin API.

Freeline is a mobile application update framework and bytecode hot-swap engine designed to deliver incremental binary updates to devices. It functions as a binary diff patching tool and a mobile over-the-air patching framework that allows for the delivery of small update packages to fix bugs and replace resources without requiring a full application reinstall. The system distinguishes itself through its ability to perform dynamic code swapping and native library updating. It replaces shared object binaries and code segments in a running process via socket servers, enabling logic updates and h

This project is a high-performance static type checker and comprehensive development toolkit for Python. It functions as a core analysis engine that identifies type inconsistencies and enforces code correctness, while simultaneously providing a language server implementation to deliver real-time diagnostics and intelligence directly within development environments. The tool distinguishes itself through a parallelized execution engine that maximizes performance across large-scale codebases and monorepo structures. It supports gradual type adoption, allowing developers to integrate type checkin

The Dart SDK is a comprehensive development kit for building cross-platform applications using a multi-paradigm programming language. It provides a unified toolchain that supports both just-in-time compilation for rapid development and ahead-of-time compilation for high-performance native machine code. The platform is built on a sound static type system and an isolate-based concurrency framework, which executes independent tasks in separate memory heaps to achieve parallelism without shared state contention. The SDK distinguishes itself through a versatile compilation pipeline that transforms

Wasp is a declarative full-stack web framework that enables developers to build and deploy applications by defining their architecture in a centralized configuration. By using a high-level specification, the framework automates the orchestration of frontend, backend, and database components, ensuring that infrastructure concerns like routing, authentication, and data modeling are handled consistently across the entire stack. The framework distinguishes itself through its compiler-driven approach, which translates declarative configurations into cohesive, production-ready codebases. It provide

The IntelliJ Platform is a modular framework designed for building desktop integrated development environments. It provides the core infrastructure necessary to create specialized coding tools, including a virtual file system for tracking project sources, a text editor, and a cross-platform graphical user interface framework. The platform distinguishes itself through a component-based architecture that allows developers to extend core application behavior via independent functional units. It supports the creation of custom development environments by integrating language analysis logic, enabl

Parcel is a web application bundler designed to automate the packaging of project assets for production. It functions as a zero-configuration tool that detects dependencies and transforms source files into optimized output without requiring manual setup files. The project includes a built-in development server that supports incremental builds and hot module replacement to reflect code changes during the development cycle. The core of the system is a dependency graph resolver that maps relationships between modules to determine the structure of output bundles. This is supported by a modular as