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
Back to ioi/isolate

Projects sharing features with Isolate

30 open-source projects similar to ioi/isolate, ranked by shared indexed features. Tags may describe platforms or build tools rather than the same primary purpose. Check each project’s use case, license, and deployment requirements before treating it as a replacement.

  • netblue30/firejailnetblue30 avatar

    netblue30/firejail

    7,733View on GitHub↗

    Firejail is a Linux application sandbox and kernel security wrapper that isolates untrusted applications from the host system. It uses kernel namespaces and seccomp filters to restrict filesystem access, drop kernel capabilities, and limit the system attack surface. The project is distinguished by its use of predefined security profiles to automatically apply filesystem restrictions and syscall limits based on the executable being launched. It provides specialized isolation for portable packages such as AppImages and implements X11 display isolation via proxy servers to prevent keyboard loggi

    C
    View on GitHub↗7,733
  • youki-dev/youkiyouki-dev avatar

    youki-dev/youki

    7,452View on GitHub↗

    Youki is a low-level container runtime written in Rust that creates and manages isolated containers according to Open Container Initiative specifications. It serves as an execution engine that can function as a rootless container manager or a pluggable Kubernetes CRI runtime to manage pods and containers within a cluster. The project distinguishes itself by providing a Wasm container runtime capable of executing WebAssembly modules as isolated workloads compatible with standard orchestration tools. It further supports a rootless execution model, allowing isolated environments to start as non-

    Rustcontainersdockerkubernetes
    View on GitHub↗7,452
  • projectatomic/bubblewrapprojectatomic avatar

    projectatomic/bubblewrap

    7,731View on GitHub↗

    Bubblewrap is an unprivileged sandbox execution utility for Linux that isolates processes from the host system. It creates secure environments by leveraging Linux namespaces to separate system resources, including network, PID, and IPC stacks. The project distinguishes itself by enabling the execution of untrusted software without requiring root privileges on the host machine. It prevents privilege escalation by disabling the execution of setuid binaries and uses user identity mapping to isolate process permissions from the host operating system. The tool manages a comprehensive security sur

    C
    View on GitHub↗7,731

AI search

Explore more awesome repositories

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

Find more with AI search
  • containers/bubblewrapcontainers avatar

    containers/bubblewrap

    9,407View on GitHub↗

    Bubblewrap is a Linux sandbox runner that creates lightweight, isolated execution environments for running untrusted applications. It combines Linux user, mount, network, PID, and UTS namespaces with seccomp-BPF system call filtering to restrict filesystem, network, process, and inter-process communication access. The project provides comprehensive process isolation by giving each sandbox its own private tmpfs root with selective bind-mounts, a separate network stack containing only a loopback interface, an independent process ID space, and remapped user and group identifiers. It applies secc

    Clinux-containersuser-namespaces
    View on GitHub↗9,407
  • opencontainers/runtime-specopencontainers avatar

    opencontainers/runtime-spec

    3,641View on GitHub↗

    The project provides an open container runtime specification and standardized schema for defining container configurations, namespaces, resource limits, security policies, and filesystem mounts across platforms. It outlines the formal configuration formats, lifecycle operations, and execution environments necessary for portable, isolated container workloads. The specification covers container lifecycle management protocols and structured rules governing container creation, execution startup, process signaling, state tracking, and resource teardown. It standardizes local bundle packaging and

    Gocontainersdockeroci
    View on GitHub↗3,641
  • containers/cruncontainers avatar

    containers/crun

    4,206View on GitHub↗

    crun is a low-level container runtime that implements the Open Container Initiative specification for managing the lifecycle of isolated processes. It provides the core mechanisms for container creation, execution, and deletion, ensuring compatibility across platforms through standardized lifecycle management. The project distinguishes itself by offering a shared C library that allows container runtime operations to be embedded directly into other compiled applications. It further extends execution capabilities through specialized handlers that enable the deployment of containers within isola

    Ccontainersiotiot-cloud
    View on GitHub↗4,206
  • iam-veeramalla/docker-zero-to-heroiam-veeramalla avatar

    iam-veeramalla/Docker-Zero-to-Hero

    6,430View on GitHub↗
    View on GitHub↗6,430
  • flatpak/flatpakflatpak avatar

    flatpak/flatpak

    5,107View on GitHub↗

    Flatpak is a sandboxed application framework and standardized packaging format for Linux desktop applications. It functions as a distribution system that allows a single application bundle to run consistently across multiple Linux operating systems without requiring per-distribution builds. The project provides a runtime dependency manager that bundles specific library versions or shared runtimes to create predictable execution environments. It includes a sandbox permission manager to control application access to system hardware and resources, ensuring security and consistent behavior betwee

    C
    View on GitHub↗5,107
  • sandstorm-io/sandstormsandstorm-io avatar

    sandstorm-io/sandstorm

    7,037View on GitHub↗

    Sandstorm is an open-source platform that packages and runs web applications in security-hardened sandboxes on a personal server, functioning as a self-hosted web app operating system. It provides a curated app store where users discover and install sandboxed web applications with one-click ease, while each application runs in an isolated container that uses Linux kernel security features to separate it from the host and other apps. The platform includes a centralized authentication layer so users sign in once and gain access to all installed applications without managing separate accounts per

    JavaScriptcapnprotodecentralizedhacktoberfest
    View on GitHub↗7,037
  • rivet-dev/agentosrivet-dev avatar

    rivet-dev/agentos

    4,858View on GitHub↗

    Agent OS is a lightweight sandbox runtime for running code written by AI agents. It provides a virtualized POSIX userspace inside WebAssembly, with processes, signals, files, sockets, a shell, and core utilities, so unmodified Linux programs and Node.js, TypeScript, and Python scripts execute in isolation from the host. It is used as an embeddable library inside an existing backend process, or through a hosted HTTP API. Many isolated environments run inside one compact runtime on ordinary Linux hosts, with no hypervisor, nested virtualization, or full virtual machine per agent. Every file, pr

    Rustagentaijavascript
    View on GitHub↗4,858
  • langgenius/dify-sandboxlanggenius avatar

    langgenius/dify-sandbox

    1,116View on GitHub↗

    Dify-sandbox is a secure runtime environment designed for the execution of untrusted code snippets. It functions as a containerized sandbox that isolates processes from the host operating system, ensuring that arbitrary scripts can be run without granting them unauthorized access to sensitive data or critical system resources. The project distinguishes itself through a multi-layered security approach that combines kernel-level isolation with strict resource management. By utilizing Linux namespaces and container-based process isolation, it partitions system resources to maintain visibility bo

    Go
    View on GitHub↗1,116
  • docker/docker-cedocker avatar

    docker/docker-ce

    5,755View on GitHub↗

    Docker CE is an OCI compliant container platform and runtime engine used for building and running applications within isolated environments. It functions as a Linux container orchestrator and provides a command-line interface to manage the entire lifecycle of running application instances. The platform enables containerized application deployment and cross-platform software distribution by packaging software with its dependencies. It supports microservices architecture management and the creation of reproducible local development environments. The system includes capabilities for application

    Go
    View on GitHub↗5,755
  • 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
  • lunatic-solutions/lunaticlunatic-solutions avatar

    lunatic-solutions/lunatic

    4,892View on GitHub↗

    Lunatic is a WebAssembly runtime and concurrent process manager that implements an Erlang-inspired model of lightweight concurrency and fault tolerance. It functions as a distributed actor system where isolated processes communicate via message passing across a network of linked nodes. The system utilizes a WebAssembly sandbox environment to isolate memory and restrict system call permissions for each individual process. This capability-based security model ensures that processes are sandboxed to safely execute untrusted code. The platform provides a fault-tolerant supervision tree for hiera

    Rustactorsassemblyscripterlang
    View on GitHub↗4,892
  • 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
  • docker/dockerdocker avatar

    docker/docker

    71,736View on GitHub↗

    Docker is an OCI container engine and runtime orchestrator used to build, run, and manage isolated applications. It functions as a container image builder for creating portable snapshots of applications and a registry manager for storing, versioning, and distributing those images across environments. The platform provides a centralized daemon to control the creation, execution, and termination of containerized workloads. It allows for the assembly of modular container systems by combining build tools, registries, and runtimes. Its core capabilities cover container image creation, registry ad

    Go
    View on GitHub↗71,736
  • nasa/fprimenasa avatar

    nasa/fprime

    10,766View on GitHub↗

    F Prime is a component-based framework designed for the development and deployment of embedded and spaceflight software. It provides a modular architecture that decouples software logic from communication interfaces, allowing developers to define system structures through a domain-specific modeling language. This model-based approach enables automated code generation, ensuring consistency across complex system topologies while maintaining strict interface contracts between software modules. The framework distinguishes itself through its integrated build system and ground data operations suite

    C++componentscppembedded
    View on GitHub↗10,766
  • yeasy/docker_practiceyeasy avatar

    yeasy/docker_practice

    26,355View on GitHub↗

    This project is a Docker educational resource and a collection of practical examples designed for learning containerization technologies. It serves as a guide for understanding container fundamentals, including the creation and management of custom images and the use of registries. The repository provides specialized references for container security hardening, such as managing kernel privileges and implementing supply chain security. It also includes tutorials for multi-container orchestration and a DevOps guide focused on CI/CD automation and image optimization. The material covers a broad

    Gobookcloud-computingcontainer
    View on GitHub↗26,355
  • linkedin/school-of-srelinkedin avatar

    linkedin/school-of-sre

    8,153View on GitHub↗

    This project is a comprehensive educational resource and curriculum focused on site reliability engineering, distributed systems, and infrastructure operations. It provides technical guides, a systems engineering course, and instructional manuals designed to teach the principles of managing large-scale computing environments. The curriculum covers high-level architectural design for scalability and resilience, including fault-tolerant infrastructure, high-availability patterns, and microservices decomposition. It emphasizes the practical application of site reliability engineering through the

    HTMLgithadooplinux
    View on GitHub↗8,153
  • microsandbox/microsandboxmicrosandbox avatar

    microsandbox/microsandbox

    6,683View on GitHub↗

    Microsandbox is a microVM sandbox runtime and hardware-isolated code executor designed for running untrusted code. It functions as an embedded virtual machine manager that allows applications to spawn and control lightweight virtual machines directly within code without the need for a background daemon. The system provides a secure execution environment for AI agents by exposing server controls that allow them to execute tools and manage files. It utilizes standard container image formats and volume workflows to initialize guest virtual machines and implements a secret management mechanism th

    Rust
    View on GitHub↗6,683
  • withcoral/coralwithcoral avatar

    withcoral/coral

    4,937View on GitHub↗

    Coral is a self-hostable execution layer for AI agents. Instead of loading every tool definition into a prompt, an agent searches a typed catalog for the tools it needs and then writes a short program that calls several connected services in one step, returning only the fields the answer requires. Those programs run in an isolated sandbox with no secrets, no network access, and no imports, and service tokens are kept in a central store and attached to outbound calls on the server side, so the agent never sees a credential. Coral also acts as a governance layer. Each tool can be set to Allow,

    Rust
    View on GitHub↗4,937
  • mattpocock/sandcastlemattpocock avatar

    mattpocock/sandcastle

    8,914View on GitHub↗

    Sandcastle is a TypeScript library for launching AI coding agents from scripts or CI pipelines and running them unattended inside isolated sandboxes. A single programmatic call starts a chosen agent, runs it for a set number of iterations, and returns the commits, branch, and per-iteration results. Sandboxes can be Docker or Podman containers, native operating-system sandboxes (Bubblewrap on Linux, Seatbelt on macOS, with no image or daemon), or cloud providers such as E2B, Modal, and Fly.io Sprites. Agents can also run directly on the host with no isolation. The agent and sandbox layers are

    TypeScript
    View on GitHub↗8,914
  • superradcompany/microsandboxsuperradcompany avatar

    superradcompany/microsandbox

    6,570View on GitHub↗

    Microsandbox is a runtime for creating and managing lightweight, hardware-isolated virtual machines — called sandboxes — that boot directly from standard OCI container images. Each sandbox runs as its own host process with a separate kernel, filesystem, and network stack, providing process-per-sandbox isolation. The project includes a command-line tool and multi-language SDKs (Rust, TypeScript, Python, Go) for programmatic lifecycle control, and it communicates with sandbox agents over Unix sockets using a CBOR-encoded protocol. What distinguishes Microsandbox is its combination of host-manag

    Rust
    View on GitHub↗6,570
  • atmosphere/atmosphereAtmosphere avatar

    Atmosphere/atmosphere

    3,830View on GitHub↗

    Atmosphere is a Java-based framework for building and coordinating AI agents. It provides a real-time transport layer for streaming data via WebSockets, SSE, gRPC, and WebTransport, alongside a multi-agent orchestration framework for managing agent fleets through sequential, parallel, and graph-based execution workflows. The project features a durable workflow engine that persists agent state as snapshots, allowing long-running tasks to survive system restarts and incorporate human-in-the-loop approvals. It also implements Model Context Protocol servers to expose tools, resources, and prompt

    Javaacpagentic-aiembabel
    View on GitHub↗3,830
  • mviereck/x11dockermviereck avatar

    mviereck/x11docker

    6,283View on GitHub↗

    x11docker is an OCI container GUI orchestrator and hardware bridge designed to execute graphical applications and full desktop environments inside containers. It functions as a Linux GUI sandbox, linking containerized processes to host X11 or Wayland display servers and audio systems. The project differentiates itself by providing deep system integration for hardware acceleration, including NVIDIA driver automation and GPU passthrough. It supports cross-architecture GUI emulation and provides remote access capabilities through VNC, SSH forwarding, and browser-based HTML5 rendering. The tool

    Shellcontainersdesktopdocker
    View on GitHub↗6,283
  • containers/toolboxcontainers avatar

    containers/toolbox

    3,537View on GitHub↗

    Toolbox is a development workspace orchestrator and container environment manager that bootstraps mutable toolsets and SDKs inside containers. It functions as a Linux distribution sandbox and a host-integrated container runtime, allowing users to run native package managers and software without modifying the host operating system. The project differentiates itself by bridging isolated containers with the host system through the mapping of user identities, network sockets, and home directories. It utilizes a daemonless engine to provide these environments while ensuring that system configurati

    Gocontainerslinux
    View on GitHub↗3,537
  • quii/learn-go-with-testsquii avatar

    quii/learn-go-with-tests

    23,950View 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

    Gogogolangtdd
    View on GitHub↗23,950
  • junit-team/junit-frameworkjunit-team avatar

    junit-team/junit-framework

    7,032View on GitHub↗

    This project is a JVM testing framework that provides a foundation for defining and running automated tests using a pluggable engine architecture. It functions as a JVM test orchestrator and a modular test engine API, allowing multiple testing engines to be grouped and executed as a single coordinated unit. The framework includes a platform launcher for discovering and executing test suites from build systems, integrated development environments, or the command line. It enables the creation of custom testing frameworks through a standardized interface that integrates into a shared execution p

    Javajavajunitjunit-jupiter
    View on GitHub↗7,032
  • deeplethe/sandstormdeeplethe avatar

    deeplethe/sandstorm

    5,452View on GitHub↗

    Sandstorm is a self-hosted platform for running large numbers of isolated sandboxes for AI agents across a cluster of machines. A central master places sandboxes onto worker nodes, which join by pairing code or dial out from behind a NAT. Each node isolates workloads with either Firecracker microVMs or gVisor, a user-space kernel for hosts without KVM. Master, node, and web console roles ship in a single executable. What sets it apart is density and start speed. Children are forked from a warmed parent snapshot using shared copy-on-write memory, so many sandboxes start in milliseconds without

    Rustagent-infrastructureai-agentscheckpoint-restore
    View on GitHub↗5,452
  • anthropic-experimental/sandbox-runtimeanthropic-experimental avatar

    anthropic-experimental/sandbox-runtime

    3,099View on GitHub↗

    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-patte

    TypeScript
    View on GitHub↗3,099