awesome-repositories.comBlog
© 2026 Bringes Technology SRL·VAT RO45896025·hello@bringes.io
MCPBlogSitemapPrivacyTerms
Deno | Awesome Repository
← All repositories

denoland/deno

0
View on GitHub↗
106,258 stars·5,902 forks·Rust·mit·5 viewsdeno.com↗

Deno

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Let's find more awesome repositories

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.
  • Integrated - Bundles essential utilities for formatting, linting, testing, and dependency management into a single unified binary.
  • Package Registry Integrations - Imports external packages directly via URLs to integrate with global registry ecosystems without local dependency folders.
  • 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.
  • Isolate Execution Environments - Isolates untrusted code within a secure sandbox that prevents unauthorized access to host system resources.
  • 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.
  • 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.
  • Automated 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.

    • 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 essential utilities—including a formatter, linter, test runner, and dependency manager—directly into the runtime, eliminating the need for external build tools or complex transpilation steps. The platform features a universal module resolution system that supports remote HTTPS URLs, local paths, and standard package registries, all backed by lockfiles to ensure build determinism and supply chain security.

    Beyond its core runtime capabilities, Deno includes a built-in, persistent key-value database engine that supports atomic transactions and reactive data monitoring. It also provides a robust compatibility layer for the Node.js ecosystem, allowing for the seamless execution of legacy modules and native binary addons. For multi-tenant or distributed applications, the runtime offers isolated sandbox environments that manage resource constraints and security boundaries, facilitating secure code execution in shared infrastructure.

    The project is distributed as a single binary, providing a unified toolchain for managing dependencies, executing tasks, and configuring runtime security policies.