Open-source alternatives to Seajs

This project is a CommonJS module bundler and resolver designed to combine interdependent JavaScript files into a single script for execution in web browsers. It functions as a Node.js JavaScript bundler that emulates server-side core modules and resolves dependencies to ensure compatibility between server-side logic and browser environments. The system features an extensible bundling pipeline and a browser-side module resolver. It provides a plugin architecture for transforming source code and a source map generator to correlate bundled output back to original files for debugging. The proje

This project is a multi-language compiler collection and cross-platform toolchain used to translate source code from various programming languages into optimized machine code for different hardware architectures. It provides a suite of tools including an optimizing compiler backend, a machine code generator, and a comprehensive runtime library suite that implements necessary execution environments and support functions. The system utilizes a multi-pass compilation pipeline and pluggable language front-ends to process source code into intermediate representations. It distinguishes itself throu

Headjs is an asynchronous asset loader designed to load JavaScript and CSS files in parallel and execute them in a specific sequence to improve page speed. It functions as a resource dependency manager that tracks script loading status and executes callbacks only after all required dependencies are fully loaded. The project includes a browser feature detection library that checks for HTML5 and CSS3 capabilities. This allows for conditional resource loading, where assets are delivered based on detected browser features, device capabilities, or screen resolution. The system further manages fro

Spec is a comprehensive set of frontend coding standard specifications and project architecture guides. It provides a framework for organizing directory structures, module dependencies, and package layouts to create scalable and predictable codebases. The project defines rigorous governance standards for React components, including specific naming conventions and structural patterns for props. It also establishes a JSON API data specification to ensure predictable communication between system components through standardized exchange formats and HTTP response structures. The specification cov

This project is an interactive programming education resource and tutorial designed for learning the Rust programming language and systems programming concepts. It provides a collection of runnable and editable code examples that serve as a practical reference for language syntax and implementation. The resource features an interactive code sandbox that allows users to execute and test code snippets in real time. It emphasizes the verification of technical accuracy by executing embedded code blocks during the build process to ensure all examples remain functional. The content covers a compre

Janet is a Lisp-based dynamic programming language featuring a register-based bytecode virtual machine and an embeddable scripting engine. It functions as a fiber-based concurrency runtime and includes a parsing engine based on Parsing Expression Grammars. The project is distinguished by its ability to be integrated into C or C++ applications via a minimal header interface. It utilizes a Lisp-style macro system for compile-time code transformation and employs prototype-based table inheritance for object-oriented behavior. The runtime covers a broad set of capabilities, including asynchronous

Snowpack is an ESM-powered frontend build tool and development server that serves native ES modules directly to the browser. By eliminating the bundling process during development, it enables nearly instant server startup and unbundled frontend development. The project features a framework-aware hot module reload system that preserves component state during updates, with specific Fast Refresh integration for React, Preact, Svelte, and Vue. It also acts as a modern web transpiler, automatically converting TypeScript, JSX, and CSS Modules into browser-compatible code without requiring manual co

This project is a cross-platform package manager designed to automate the acquisition, compilation, and integration of third-party software libraries into native development projects. It functions as a manifest-driven dependency manager, utilizing declarative configuration files to define project requirements and resolve them into consistent, versioned dependency graphs across Windows, Linux, and macOS. The system distinguishes itself through port-based build automation, which uses standardized scripts to fetch, patch, and compile source code, and triplets-based configuration files that encap

Yarn is a command-line package manager for JavaScript projects that automates the installation, versioning, and configuration of external code dependencies. It functions as a deterministic build tool, utilizing a lockfile to calculate a fixed dependency graph that ensures identical package versions across development, testing, and production environments. The project distinguishes itself through a content-addressable storage system that indexes packages by hash to eliminate redundant downloads and enable instant linking. It incorporates a virtual file system mapping that presents a unified vi

loadCSS is an asynchronous CSS loader and non-blocking stylesheet injector. It provides a technical implementation for loading stylesheets without blocking the browser rendering process to maintain a responsive user interface. The project implements a specific CSS loading pattern to detect when asynchronous stylesheets have finished loading across different web browsers. This allows for the execution of callback functions only after a stylesheet has fully loaded to ensure consistent visual behavior. The tool covers programmatic stylesheet insertion, dynamic injection based on application log

CMake is a cross-platform build system generator and build automation tool. It is used to define build requirements and dependencies for C and C++ source code, managing the compilation and linking process across different operating systems. The project functions by generating platform-specific build files and scripts from a single configuration. This allows for the standardization of how software is compiled and packaged for compilers and development tools across various environments. The tool covers C++ project configuration and native application compilation for desktop and embedded system

Tuist is a Swift manifest–based project manager for Xcode projects. It replaces manual Xcode project file editing with a declarative Swift DSL where build targets, settings, and dependencies are defined in code. The tool then generates Xcode workspaces and projects from that manifest, and can bootstrap new projects with a given platform target and initial structure. Beyond generation and scaffolding, Tuist provides a command-line build capability that compiles Apple platform projects without launching Xcode. It resolves the dependency graph between targets, detects cycles, and determines buil

Bower is a front-end package manager and client-side dependency manager designed to resolve and download components for web projects. It ensures consistent versions of third-party JavaScript libraries and CSS assets across different development environments. The system functions as a flat dependency resolver, installing packages into a flat directory structure to avoid nested dependency conflicts in the browser. It utilizes a JSON-based manifest to map package names to specific git repositories or version tags. The tool manages the web asset workflow by fetching specific library versions dir

Dynamic-load-apk is an Android plugin framework that enables a host application to load and run uninstalled APK files as plugins at runtime. It provides the core infrastructure for loading APKs from storage, launching their activities, and managing their lifecycle without requiring the user to install them through the system package manager. The framework handles the fundamental challenges of running uninstalled code on Android through several key mechanisms. It isolates plugin classes in a separate DexClassLoader to prevent conflicts with the host class hierarchy, merges plugin resources int

Crab is a memory-safe systems programming language and ahead-of-time compiler designed for high-performance software. It utilizes a type system based on strict ownership and borrowing rules to prevent memory access errors at compile time. The toolchain includes an automated documentation generator that produces technical reference manuals and API guides by parsing structured source code annotations. It also features a dependency management tool to resolve external library graphs and ensure consistent project builds. The project covers software build automation, static type checking, and mult

This project is a curated reference guide and cheatsheet for modern JavaScript development. It provides a collection of syntax and patterns covering ECMAScript standards, specifically focusing on contemporary language features from ES6 and later. The resource offers specialized guides on asynchronous JavaScript, functional programming patterns, and object-oriented design. It details the use of promises and async/await syntax for non-blocking operations, as well as the application of map, filter, and reduce for data transformation. The guide covers a broad range of language fundamentals, incl

ts-node is a TypeScript execution engine and just-in-time transpiler for Node.js. It enables the direct execution of TypeScript files by converting them to JavaScript on the fly, removing the requirement for a manual pre-compilation build step. It also provides a TypeScript read-eval-print loop for evaluating expressions and testing code snippets in real time. The project integrates with the Node.js module system as a loader hook to resolve and load files using native import syntax. It features a pluggable compiler interface that allows the use of external transpilers to accelerate execution

Conan is a package manager and binary repository for C and C++ that resolves and installs external libraries to ensure consistent build environments across different platforms. It functions as a native dependency resolver and a cross-platform build tool designed to facilitate reproducible native builds. The project provides capabilities for native package hosting, allowing users to implement a server to store and distribute pre-compiled libraries and their required dependencies. It also supports standalone binary bundling to create executable files that include all necessary runtime dependenc

Osmedeus is a security workflow orchestration engine that coordinates AI agents, shell commands, and scanning tools through declarative YAML pipelines. It functions as a distributed security scanner, a declarative workflow automator, and an AI agent framework for security, enabling automated multi-step security analysis with conditional branching, parallel execution, and distributed workers. The engine distinguishes itself through a hybrid runner model that executes workflow steps on the local host, inside Docker containers, or over SSH to remote machines, selected per step or module. It supp

Rolldown is a high-performance JavaScript and TypeScript module bundler written in Rust. It functions as a fast module compiler that implements a Rollup-compatible API to ensure compatibility with existing workflows and plugins while specializing in ECMAScript Module formats. The project distinguishes itself by using a Rust-based core engine and lazy compilation to reduce the time spent resolving and transforming source code. It focuses on minimizing final delivery sizes through static analysis and tree-shaking to remove unused code. The toolset covers a broad range of build capabilities, in

Buf is a toolchain for managing the full lifecycle of Protocol Buffers schemas. It provides a set of tools for schema governance, including linting to enforce style guides, a breaking change detector to ensure backward compatibility, and a system for producing language-specific source code via local or remote plugins. The project distinguishes itself through a remote schema registry that centralizes the hosting, versioning, and distribution of Protocol Buffers modules. This registry allows for server-side enforcement of governance policies, such as blocking updates that introduce backward-inc

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

This project is a comprehensive reference guide and technical documentation for the features, syntax updates, and APIs introduced in ECMAScript 6. It serves as a language specification and overview for modern JavaScript development. The guide covers a wide range of language enhancements, including the implementation of classes and prototype-based inheritance, the use of arrow functions for lexical scope binding, and the introduction of block-scoped variables. It details the module system for organizing independent code components via import and export statements. The documentation extends to

Moon is a monorepo build system and task runner designed to orchestrate complex projects with multiple packages. It functions as a dependency graph orchestrator that executes build targets in topological order and utilizes input hashing to cache results and skip redundant work. The project features a polyglot toolchain manager that automates the installation and versioning of language runtimes and CLI tools to ensure environment consistency. It also includes a plugin framework based on WebAssembly, allowing developers to extend build logic and toolchain behavior using any supported language.

Checkov is a static analysis tool and security scanner designed to identify misconfigurations in infrastructure as code, container images, and Kubernetes configurations. It functions as a cloud security posture tool, an SCA vulnerability scanner, and a secret scanning utility to prevent security breaches and version control leaks. The project distinguishes itself through deep graph analysis and variable resolution, allowing it to map relationships between interconnected resources and evaluate the final state of infrastructure attributes. It provides extensibility for defining custom security

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