oven-sh/bun

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.

Star history