denoland/deno

Features

• JavaScript Runtimes - Powers high-performance JavaScript and TypeScript execution by leveraging the V8 engine for server-side environments.
• Secure JavaScript Runtimes - Mandates explicit, granular security permissions for all system-level operations during code execution.
• Web-Standard Runtimes - Prioritizes native implementation of browser-compatible APIs to maintain consistent behavior across different environments.
• Runtime Permission Policies - Evaluates and enforces resource access policies dynamically while applications are actively running.
• Package Registry Integrations - Imports external packages directly via URLs to integrate with global registry ecosystems without local dependency folders.
• Integrated - Bundles essential utilities for formatting, linting, testing, and dependency management into a single unified binary.
• HTTP Servers - Initializes web servers capable of processing incoming HTTP requests through standard handler functions.
• TypeScript Execution - Supports native execution of TypeScript by automatically performing syntax checks without requiring manual build steps.
• Secure Server-Side Runtimes - Implements a default-deny security model to protect high-performance server-side applications from unauthorized resource access.
• Permission-Based Security - Restricts access to sensitive system resources like file systems and networks by requiring explicit user authorization.
• Network Access Controls - Controls network connectivity by enforcing explicit allow or deny rules for specific hostnames, IP addresses, and ports.
• Sandbox Security Configurations - Limits network connectivity to approved hosts and manages secret injection within isolated execution environments.
• File System Access Controls - Applies granular security flags to strictly permit or deny read and write operations on the host file system.
• Request & Response Handling - Manages the full request-response lifecycle using standard web fetch interfaces.
• Web-Standard APIs - Exposes browser-compatible interfaces for networking, storage, and streams to ensure platform-agnostic development.
• TypeScript Validators - Integrates built-in validation tools to perform type checking on TypeScript and JavaScript codebases.
• Module Loaders - Fetches, parses, and executes modular code files sourced from either local paths or remote network locations.
• Remote Module Loaders - Resolves and loads software dependencies directly from remote network locations using secure HTTPS protocols.
• Isolated Execution Sandboxes - Executes untrusted scripts within a secure, resource-constrained environment to prevent unauthorized system access.
• Integrated Development Tooling - Ships with native formatting, linting, and testing utilities to streamline the entire development lifecycle.
• Dependency Resolution Controls - Redirects module imports to specific remote URLs or local paths to override dependencies during development.
• Resource Constraints - Restricts system resource usage through configurable memory, CPU, and execution timeouts to maintain predictable performance.
• Key-Value Stores - Features a built-in, persistent key-value store that supports atomic transactions and reactive data updates.
• Standard Library Compatibility Shims - Exposes standard library compatibility modules to bridge functionality gaps when migrating legacy codebases.
• Code Executors - Handles shell commands and external processes within isolated environments to maintain a secure system state.
• Sandbox Configurations - Defines strict security boundaries for network access, file system interaction, and environment variable visibility.
• Execution Sandboxes - Creates ephemeral, restricted environments to safely execute code with minimal host system exposure.
• Supply Chain - Ensures build integrity by leveraging lockfiles and dependency pinning to prevent unauthorized code changes.
• Test Runners - Runs test suites with native support for parallel execution, file filtering, and isolated permission sets.
• Developer Runtimes - Secure JavaScript and TypeScript runtime built with V8.
• Development Runtimes - Secure JavaScript and TypeScript runtime built on V8.
• Programming Languages - Secure runtime for JavaScript and TypeScript.
• Web Frameworks and Runtimes - Modern, secure runtime for JavaScript and TypeScript.
• Atomic Transactions - Groups multiple data operations into atomic units to guarantee consistency through conditional validation.
• Dependency Aliasing - Maps complex dependency paths to simplified aliases to maintain consistent module resolution across projects.
• Dependency Resolvers - Downloads and verifies remote dependencies using a secure, lockfile-backed resolution system.
• Import Map Configurations - Standardizes import paths by using configuration files to map module names to specific network locations.
• Universal Module Resolvers - Resolves both local file system paths and remote network URLs through a unified module loading system.
• TLS/SSL Configurations - Secures network traffic by providing native management for TLS certificates and private keys.
• Environment Access Controls - Requires explicit permission grants before allowing code to read or modify system environment variables.
• Key-Value Stores - Integrates a built-in storage engine that performs atomic transactions and efficient indexing for high-speed state management.
• Task Execution Engines - Orchestrates custom project commands through a runner that supports environment-specific configurations and permission settings.
• Code Formatters - Standardizes source code formatting by validating style guidelines during continuous integration processes.
• Linting Engines - Analyzes source code automatically to detect quality issues and enforce consistent formatting patterns.
• Subhosting Platforms - Powers multi-tenant application hosting by isolating user workloads within secure, resource-constrained runtimes.
• WebSocket Servers - Upgrades standard HTTP requests into persistent, bidirectional channels for real-time data exchange.
• Foreign Interface Authorizations - Authorizes the loading of dynamic native libraries by explicitly granting permissions to bypass default security sandboxing.
• CommonJS Compatibility - Resolves legacy module dependencies by identifying specific file extensions and package configurations for compatibility.
• Test Coverage Collections - Calculates execution metrics directly from the engine to identify untested logic and verify code path coverage.
• Test Sanitizers - Identifies unawaited promises and leaked I/O handles to ensure test reliability and clean process exits.
• Data Observability - Monitors key-value stores for real-time changes and triggers asynchronous logic automatically upon data modification.
• NPM Script Runners - Parses package configuration files to trigger automated build, test, or deployment workflows.
• Distributed Edge Compute Platforms - Deploys isolated, resource-constrained sandbox environments across a multi-tenant infrastructure for edge computing.
• Runtime - Maps standard APIs and legacy module formats to the runtime to facilitate seamless integration of existing ecosystems.
• TypeScript Compiler Configurations - Adjusts compiler settings to align build behavior with specific project requirements and environment constraints.
• Native Addon Loaders - Loads compiled binary modules by providing access to local directories and necessary foreign function interface permissions.
• Sandbox Lifecycle Controls - Terminates isolated execution instances prematurely to release system resources and invalidate network sessions.
• Server Network Configurations - Configures hostnames and port bindings to dictate where server-side network services listen for incoming traffic.
• Test Lifecycle Hooks - Orchestrates setup and teardown logic before or after test execution to maintain consistent testing environments.
• Snapshot Testing Utilities - Compares current code output against stored reference values to simplify assertions for complex data structures.

Star history