Bun

Bun is a high-performance runtime environment designed to execute JavaScript and TypeScript applications with minimal latency and high throughput. Built on a native core implemented in Zig, it provides a unified execution engine that leverages JavaScriptCore for efficient memory management and low-latency startup. The project functions as an all-in-one toolchain, integrating a native bundler, transpiler, package manager, and test runner into a single command-line interface.

What distinguishes Bun is its focus on native system integration and developer productivity. It features a high-performance server runtime with built-in support for HTTP, WebSockets, and SQLite database management, allowing for the creation of scalable network applications without external dependencies. The platform includes a sophisticated build pipeline that supports incremental bundling, build-time macro execution, and the generation of standalone, cross-platform binaries. It also provides a low-level foreign function interface, enabling direct execution of native C and C++ libraries to bypass traditional runtime bottlenecks.

The project covers a broad capability surface, including automated task scheduling, file-system-based routing, and comprehensive dependency management. It offers built-in utilities for cryptographic hashing, secure password verification, and real-time hot module replacement during development. Additionally, the runtime maintains compatibility with existing ecosystems by implementing standard APIs and module resolution patterns, facilitating seamless integration into existing workflows.

Bun is distributed as a command-line tool that manages the entire application lifecycle, from dependency installation and auditing to production asset building and binary distribution.

Features

JavaScript Runtimes - Executes JavaScript and TypeScript applications using a high-performance engine optimized for minimal latency and high throughput.
High-Performance - Optimizes resource-intensive workloads by delivering high-throughput and low-latency processing for modern web applications.
Dependency Managers - Resolves and manages project dependencies with high-speed algorithms to ensure consistent environment configurations.
Dependency Installers - Automates the installation of external packages using optimized resolution utilities.
Source Code Bundlers - Bundles source files into optimized outputs while performing tree-shaking and dead-code elimination.
Runtime - Implements standard module resolution and API patterns to maintain cross-ecosystem compatibility.
Request Routers - Routes incoming network traffic through configurable middleware chains before reaching application logic.
File System I/O - Handles file system operations through native APIs to ensure rapid read and write performance.
High-Performance Server - Powers high-performance network services with native HTTP, WebSocket, and database connectivity.
JavaScriptCore-Based Runtimes - Leverages a high-performance engine for efficient memory management and rapid application startup.
Modular and Plugin Architectures - Structures complex systems using modular primitives that bypass traditional runtime bottlenecks.
Incremental Bundlers - Performs rapid, incremental rebuilds by monitoring file changes during development cycles.
HTTP Servers - Initializes high-performance web servers to process incoming HTTP requests efficiently.
All-in-One Toolchains - Integrates package management, testing, and bundling into a unified command-line interface.
Socket Management - Exposes low-level interfaces for managing socket communication and network protocol tasks.
Traffic Interception and Modification - Supports real-time transformation of network traffic while maintaining efficient streaming capabilities.
API Route Definitions - Maps HTTP methods and URL patterns to specific request handlers within a unified server environment.
Embedded Databases - Embeds relational storage engines directly within the application process to enable high-speed local data management without external servers.
Package Publishing - Publishes project artifacts to registries, simplifying version management and code distribution for developers.
Project Lockfile Management - Generates and updates lockfiles to ensure deterministic dependency versions across different development and production environments.
Hot Module Replacement - Updates application modules in real-time without requiring a full system restart, maintaining state during the development cycle.
Production Asset Builders - Minifies, tree-shakes, and optimizes source code into production-ready web assets using a high-speed native engine.
Build-Time Macros - Evaluates code during the bundling phase to perform static analysis or inject computed values directly into the final output.
Build Plugins - Extends the compilation process through a modular plugin architecture that intercepts build lifecycle hooks for custom transformations.
Native Bundlers and Transpilers - Converts source code into optimized bundles or standalone executables while applying native transformation and minification rules.
Dependency Resolvers - Coordinates the retrieval and installation of software packages by tracking version constraints across multiple registry types.
Standalone Binary Generators - Packages applications and their dependencies into single, cross-platform executable binaries.
WebSocket Servers - Facilitates persistent, bidirectional communication channels for real-time data exchange through high-performance server-side primitives.
Foreign Function Interfaces - Exposes a low-level bridge for calling native C and C++ libraries directly from JavaScript or TypeScript code.
Native Library Integrations - Enables direct execution of external native libraries through low-level bindings.
Cryptographic Primitives - Provides built-in cryptographic primitives for hashing and digital signatures to ensure data integrity.
Snapshot Testing - Compares serialized data or component outputs against stored reference files to detect and report regressions automatically.
Test Lifecycle Hooks - Triggers setup and teardown logic before or after test execution to ensure consistent environments and clean resource management.
Dependency Mocking - Substitutes complex dependencies or network calls with controlled mocks to isolate logic during unit and integration testing.
Build Tools and Tooling - Fast JavaScript runtime, bundler, and package manager.
Developer Tools - Fast JavaScript runtime and package manager.
Web Frameworks and Runtimes - All-in-one JavaScript runtime, bundler, and package manager.
Workspace Managers - Links multiple interconnected packages within a single repository to coordinate shared dependencies and configurations.
CLI Build Executors - Invokes build pipelines via command-line interfaces to trigger bundling, minification, and deployment tasks.
Automated Build Pipelines - Orchestrates the transformation and minification of source code into production-ready assets through an integrated build pipeline.
Process and Memory Management - Spawns, monitors, and controls external system processes with full input and output stream integration.
Native System Integrations - Provides direct access to low-level operating system APIs and native file system operations for high-performance system tasks.
JavaScript Minification - Minimizes file size by stripping whitespace and shortening identifiers during the build process to accelerate application load times.
File-System-Based Routers - Matches directory structures and file paths automatically to URL endpoints to simplify web routing configuration.
Prepared Statement Engines - Compiles SQL queries into efficient binary representations to accelerate the performance of repetitive database operations.
Debugger Interfaces - Links external diagnostic tools to the runtime via a standard protocol to visualize execution state and interact with live code.
JavaScript and TypeScript Debugging - Translates transpiled code back to original source files using integrated source map support for precise line-by-line inspection.
Build Macros - Executes logic during the build phase to fetch external data or inject static values directly into the final output.
Asset Embedding - Injects static assets and binary resources directly into standalone executables to eliminate external dependencies and simplify distribution.
Cross-Compilation Utilities - Produces standalone binaries for diverse operating systems and architectures from a unified build environment to streamline deployment.
TLS Configurations - Configures secure communication channels by managing TLS certificates and encryption settings for high-performance web servers.
FFI Type Definitions - Translates language-specific data structures to native C types, ensuring accurate memory layout and data exchange with external libraries.
Server Metrics - Reports internal server health and performance metrics to provide real-time observability into production resource usage.
UI - Simulates browser-like environments within test suites to verify user interface interactions and ensure consistent visual behavior.
CSS Transpilers - Transforms modern CSS syntax into browser-compatible formats with automatic vendor prefixing to guarantee consistent visual rendering.
CSS Module Bundlers - Aggregates style sheets with automatic class scoping to prevent naming collisions while enabling modular component composition.
Static HTML Serving - Serves static HTML as dynamic routes by automatically bundling necessary scripts and styles during the server-side request lifecycle.
HTML Document Transformation - Parses and modifies HTML content using CSS selectors to dynamically update documents during request or response handling.
Atomic Transaction Execution - Groups multiple database operations into atomic transactions to ensure data consistency and integrity during complex updates.
Dependency Auditing - Scans installed packages for security vulnerabilities and dependency issues to maintain a secure and stable project environment.
Package Metadata Querying - Queries metadata for installed packages and dependencies to simplify version tracking and project configuration management.
Binary Buffer Accesses - Grants direct access to the underlying memory buffers of typed arrays for low-level data manipulation and inspection.
File Watchers - Monitors source files for modifications to trigger automatic incremental rebuilds, keeping development environments synchronized with code changes.
Local Dependency Linkers - Links local development packages to projects to facilitate testing and iterative development without publishing to registries.
Terminal and CLI Enhancements - Enhances command-line interactions with native APIs that improve logging, output formatting, and developer productivity.
Object Storage Clients - Uploads files and data directly to object storage services using static methods for simplified cloud integration.
In-Process Task Schedulers - Schedules asynchronous callbacks on a recurring basis within the current process lifecycle to handle background logic without external dependencies.
HTTP Cookie Management - Manages HTTP cookies with structured access to names, values, and security attributes.
Blob Constructors - Constructs blob objects from various data sources including strings and binary chunks to facilitate standardized web-based data handling.
Cryptographic Hash Computations - Calculates secure message digests for strings and binary data using standard algorithms to verify data integrity.
Binary Integrity Verification - Applies system-level security signatures and entitlements to standalone binaries to satisfy operating system requirements and prevent execution warnings.
Native Plugin Development - Enables high-performance native extensions using low-level modules to run intensive logic in parallel threads and bypass single-threaded limitations.
Bytecode Cache Generators - Generates cached bytecode files during the build process to eliminate runtime parsing overhead and accelerate application startup times.
Architectural Patterns - Facilitates scalable server-side architectures using centralized error handling, environment-based configuration, and reusable response utilities.
DOM Event Listeners - Attaches event listeners to HTML elements matching specific CSS selectors to perform transformations or logic during document parsing.
CSS Asset Bundling - Links style imports to JavaScript entry points while applying content hashing to optimize asset delivery and caching.
Full-Stack Web Development - Unifies server-side API development and client-side interface construction within a single, high-speed environment.
Single Page Application Hosting - Configures fallback routing to serve a single HTML file for all paths, enabling client-side navigation within complex web applications.

denoland/deno

107,110View on GitHub

Deno is a high-performance runtime for JavaScript and TypeScript that prioritizes security and developer productivity. Built on the V8 engine, it provides a secure execution environment that enforces a default-deny security model, requiring explicit user authorization for access to system resources like the file system, network, and environment variables. The runtime natively supports modern web-standard APIs, ensuring consistent behavior and portability across different environments. What distinguishes Deno is its integrated approach to the software development lifecycle. It bundles essentia

vitejs/awesome-vite

16,866View on GitHub

Awesome Vite is a curated collection of resources, plugins, and templates designed for the Vite build tool ecosystem. It serves as a central directory for developers looking to extend the capabilities of this high-performance frontend build pipeline and module bundler. The project highlights the core strengths of Vite, including its native ESM-based development server, instant hot module replacement, and pre-bundled dependency optimization. By aggregating community-maintained tools, it showcases how to leverage Vite’s plugin-based architecture to customize build pipelines, integrate popular f

quii/learn-go-with-tests

23,510View on GitHub

This project is an educational platform and tutorial series designed to teach the Go programming language through the practice of test-driven development. It provides a structured path for developers to master language fundamentals, concurrency, and standard library usage by building functional applications in small, verifiable increments. The core methodology centers on the test-driven development cycle, where failing tests are written before implementation to define requirements and ensure code correctness. This approach is applied across a wide range of practical scenarios, including the c

vitest-dev/vitest

15,970View on GitHub

Vitest is a high-performance testing framework designed for JavaScript and TypeScript applications. It provides an integrated environment that supports unit, integration, and browser-based testing, allowing developers to execute test suites natively without requiring separate build steps or complex configuration. The project distinguishes itself through a highly optimized execution model that leverages worker-thread isolation and on-demand module transformation to provide rapid feedback. It includes a comprehensive suite of mocking and spying utilities that allow for the interception of depen

oven-shbun

Features