awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
anthropic-experimental avatar

anthropic-experimental/sandbox-runtime

0
View on GitHub↗

Sandbox Runtime

This project is an OS-level process sandbox and cross-platform security wrapper for Linux and macOS. It is designed to isolate arbitrary processes from the host machine by restricting filesystem and network access without the use of full containerization.

The system functions as a system-call interceptor and access controller, blocking unauthorized operating system calls based on predefined security policies. It employs allowlists and denylists to manage resource requests and monitors for security violations in real time.

Capability areas include filesystem access management using glob-pattern filtering, network traffic filtering via external proxies for deep packet inspection, and the blocking of local Unix socket creation. These features allow for the execution of untrusted code or agents within restricted security boundaries.

AI search

Explore more awesome repositories

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

Start searching with AI

Features

  • Process Isolation - Isolates processes within native operating system boundaries to restrict access to system resources.
  • Filesystem Access Filtering - Enforces strict path-based permissions using glob-pattern filtering for filesystem operations.
  • Filesystem Access Controls - Enforces read and write permissions using allowlists and glob patterns to prevent unauthorized file access.
  • System Call Interceptors - Intercepts and blocks unauthorized operating system calls based on predefined security policies and allowlists.
  • System-Call Interception - Intercepts system calls to block unauthorized filesystem or network operations.
  • Filesystem Permissions - Enforces strict read and write permissions on files and directories using allowlists and denylists.
  • Allowlist-Based Access Controls - Implements a strict deny-by-default security policy to control access to system resources.
  • System-Call Access Controllers - Blocks unauthorized resource requests and monitors security violations by controlling system calls at the OS level.
  • Network Access Restrictions - Filters outgoing network traffic using allow-only patterns and domain wildcards.
  • Network Traffic Filtering - Restricts outgoing connections to specific domains and routes traffic through proxies for auditing.
  • Process Sandboxes - Runs commands, agents, or servers in an isolated environment to enforce filesystem and network boundaries.
  • Process Sandboxing - Restricts filesystem and network access for arbitrary processes to create a secure execution sandbox.
  • Secure Execution Wrappers - Functions as a cross-platform security wrapper for Linux and macOS to isolate untrusted code from the host.
  • Security Isolation Mechanisms - Encloses arbitrary processes within security boundaries to isolate them from the host system.
  • Cross-Platform System Hardening - Provides a unified tool for enforcing system-level boundaries and hardening on both Linux and macOS.
  • Host-Process Isolation - Isolates processes from the underlying host machine by wrapping commands and library calls in security boundaries.
  • OS-Level Virtualization - Implements system-call interception to isolate processes from the host filesystem and network without using full containerization.
  • Security Wrapping - Wraps processes in native OS boundaries to isolate them from the host machine.
  • Filesystem Access Restrictions - Controls read and write permissions at the OS level using deny-then-allow patterns.
  • Secure Command Wrapping - Wraps shell commands or library calls in a secure environment to restrict host access.
  • Network Proxies - Redirects all outgoing network traffic through an external proxy for deep packet inspection and auditing.
  • Traffic Proxying - Routes sandboxed network traffic through external proxies for deep packet inspection and auditing.
  • Unix Socket Restrictions - Blocks the creation of local communication sockets using system filters on Linux and macOS.
  • Socket Blocking - Prevents the creation of local Unix sockets using system-level filters.
  • System Call Monitors - Detects and logs unauthorized system calls in real time to identify and monitor security violations.
  • Sandbox Violation Monitoring - Detects and logs unauthorized attempts to access restricted system resources in real time.
3,099 stars·186 forks·TypeScript·apache-2.0·32 views

Star history

Star history chart for anthropic-experimental/sandbox-runtimeStar history chart for anthropic-experimental/sandbox-runtime

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Projects sharing features with Sandbox Runtime

These projects share indexed features with Sandbox Runtime. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • redox-os/redoxredox-os avatar

    redox-os/redox

    16,054View on GitHub↗

    Redox is a POSIX-compliant, microkernel-based operating system written entirely in Rust. By utilizing a memory-safe language for the kernel and all system components, the project eliminates common vulnerabilities such as buffer overflows and use-after-free errors. Its architecture relies on a minimal kernel that manages only essential hardware and process isolation, delegating all other system services to unprivileged user-space processes. The system distinguishes itself through a modular design where hardware drivers and system services run as independent user-space daemons, allowing them to

    Rustbsdfreebsdgnu
    View on GitHub↗16,054
  • google/gvisorgoogle avatar

    google/gvisor

    17,748View on GitHub↗

    This project is a secure container runtime that provides strong isolation for application workloads by implementing a userspace kernel. By intercepting system calls and executing them within a memory-safe, restricted environment, it minimizes the attack surface exposed to the host kernel. It functions as a drop-in engine for standard container orchestration platforms, ensuring compatibility with industry-standard runtime specifications while maintaining a hardened execution boundary. The runtime distinguishes itself through its ability to virtualize core system resources, including an indepen

    Gocontainersdockerkernel
    View on GitHub↗17,748
  • sandboxie-plus/sandboxiesandboxie-plus avatar

    sandboxie-plus/Sandboxie

    18,636View on GitHub↗

    Sandboxie is an operating system-level virtualization tool designed to run Windows applications in isolated, secure environments. By intercepting system calls and redirecting file system and registry modifications to a separate, discardable storage area, it prevents untrusted software from making permanent changes to the host system. This containment ensures that browser history, temporary files, and potential malware remain trapped within the sandbox, protecting the integrity and privacy of the underlying host. The software distinguishes itself through granular control over the isolation env

    C
    View on GitHub↗18,636
  • lxc/lxclxc avatar

    lxc/lxc

    5,204View on GitHub↗

    LXC is an OS-level virtualization framework and Linux container manager used to run multiple isolated Linux systems on a single host. It functions as a kernel namespace orchestrator and unprivileged container runtime, allowing for the creation and management of system containers without the overhead of a hypervisor. The project provides unprivileged container execution by mapping container root users to unprivileged host users to prevent host system access. It ensures security through system call filtering and root user isolation, enabling containers to run without requiring host root privile

    C
    View on GitHub↗5,204
Compare all 30 related projects→

Frequently asked questions

What does anthropic-experimental/sandbox-runtime do?

This project is an OS-level process sandbox and cross-platform security wrapper for Linux and macOS. It is designed to isolate arbitrary processes from the host machine by restricting filesystem and network access without the use of full containerization.

What are the main features of anthropic-experimental/sandbox-runtime?

The main features of anthropic-experimental/sandbox-runtime are: Process Isolation, Filesystem Access Filtering, Filesystem Access Controls, System Call Interceptors, System-Call Interception, Filesystem Permissions, Allowlist-Based Access Controls, System-Call Access Controllers.

Which projects share features with anthropic-experimental/sandbox-runtime?

Projects with overlapping indexed features include: redox-os/redox — Redox is a POSIX-compliant, microkernel-based operating system written entirely in Rust. By utilizing a memory-safe… google/gvisor — This project is a secure container runtime that provides strong isolation for application workloads by implementing a… sandboxie-plus/sandboxie — Sandboxie is an operating system-level virtualization tool designed to run Windows applications in isolated, secure… openssh/openssh-portable — This project is a portable implementation of the secure shell toolset designed for deployment across diverse operating… lxc/lxc — LXC is an OS-level virtualization framework and Linux container manager used to run multiple isolated Linux systems on… lxc/lxd — LXD is a unified platform for managing both system containers and virtual machines through a single REST API and…