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
youki-dev avatar

youki-dev/youki

0
View on GitHub↗
7,452 stars·440 forks·Rust·Apache-2.0·44 viewsyouki-dev.github.io/youki↗

Youki

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-root users to reduce security risks and remove the need for administrative privileges.

The runtime covers a broad range of system capabilities, including Linux sandbox provisioning, hardware resource limit configuration via cgroups, and security hardening through system call filtering. It also handles container network interface management, process execution control, and the full container lifecycle from creation to termination.

The project includes tooling for multi-architecture cross-compilation and automated provisioning of virtualized Linux environments for testing and development.

Features

  • OCI Container Engines - Implements the Open Container Initiative standards for building and running isolated containers.
  • OCI Runtime Implementations - Implements a low-level container runtime that adheres to Open Container Initiative specifications for image formats and execution.
  • Sandbox Process Execution - Runs containers and pods using compatible sandboxes to isolate processes and manage hardware resources.
  • Runtime Lifecycle Management - Manages the full container lifecycle from creation to termination by interfacing with host kernel features.
  • Container Runtime Integrations - Implements the Container Runtime Interface to allow Kubernetes to orchestrate pods and containers via the runtime.
  • Wasm Execution Engines - Provides a specialized execution environment for running WebAssembly modules as isolated containers.
  • Namespace-Based Isolation - Leverages Linux kernel namespaces to create isolated execution environments and partition system resources.
  • Linux Sandboxes - Implements Linux sandbox provisioning using kernel namespaces and cgroups to create isolated execution environments.
  • WebAssembly - Executes WebAssembly modules as isolated containers by assigning them to a dedicated runtime handler.
  • Containerized Workloads - Executes WebAssembly modules as isolated workloads that are compatible with standard container orchestration tools.
  • Wasm Sandboxes - Provides a dedicated handler to run WebAssembly modules as isolated workloads within a sandbox.
  • Rootless Container Runtimes - Provides a rootless execution model that allows containers to run without requiring administrative privileges on the host.
  • Container Security Hardening - Hardens the container environment by applying security profiles and filtering system calls.
  • Seccomp Profiles - Hardens the container sandbox by restricting available system calls through defined seccomp security profiles.
  • Kernel Resource Limiting - Uses Linux kernel control groups to enforce hardware resource limits like CPU and memory for containers.
  • Container Management Systems - Executes containerized processes by leveraging system primitives and adhering to industry-standard specifications.
  • Rust Systems Programming - Developed in Rust to ensure memory safety and performance when interfacing with low-level Linux kernel features.
  • Memory-Safe Systems Programming - Built with Rust to ensure memory safety while interfacing directly with low-level Linux kernel system calls.
  • Cgroup Resource Analyzers - Exports usage statistics and configures root paths for Linux control groups to monitor resource consumption.
  • DevOps & Infrastructure - Container runtime implementation.
  • Virtualization & Containers - Container runtime implementation.
  • Container Runtimes - Rust-based OCI-compliant container runtime.

Star history

Star history chart for youki-dev/youkiStar history chart for youki-dev/youki

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.

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

Projects sharing features with Youki

These projects share indexed features with Youki. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • containers/cruncontainers avatar

    containers/crun

    3,975View 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↗3,975
  • moby/mobymoby avatar

    moby/moby

    71,729View on GitHub↗

    Moby is an OCI container engine and runtime manager designed for building, running, and managing isolated containers based on Open Container Initiative standards. It functions as a container daemon and image builder, providing a core engine to orchestrate the full lifecycle of containers and the packaging of source code into portable images. The project provides a standardized HTTP interface that allows for programmatic container management, enabling external clients to control daemon settings and container operations. It supports a rootless security model, allowing the engine daemon to execu

    Gocontainersdockergo
    View on GitHub↗71,729
  • containers/youkicontainers avatar

    containers/youki

    7,463View on GitHub↗

    Youki is an OCI container runtime written in Rust. It implements the Open Container Initiative runtime specification to manage the lifecycle of containerized processes and ensure compatibility with standard container images and engines. The runtime is designed for memory safety and supports rootless container execution, allowing containers to run as non-root users to reduce security risks and limit privilege escalation. It provides core container management capabilities, including spawning and managing OCI containers. This is achieved through Linux namespace isolation, cgroup-based resource

    Rust
    View on GitHub↗7,463
  • 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
Compare all 30 related projects→

Frequently asked questions

What does youki-dev/youki do?

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.

What are the main features of youki-dev/youki?

The main features of youki-dev/youki are: OCI Container Engines, OCI Runtime Implementations, Sandbox Process Execution, Runtime Lifecycle Management, Container Runtime Integrations, Wasm Execution Engines, Namespace-Based Isolation, Linux Sandboxes.

Which projects share features with youki-dev/youki?

Projects with overlapping indexed features include: containers/crun — crun is a low-level container runtime that implements the Open Container Initiative specification for managing the… moby/moby — Moby is an OCI container engine and runtime manager designed for building, running, and managing isolated containers… containers/youki — Youki is an OCI container runtime written in Rust. It implements the Open Container Initiative runtime specification… opencontainers/runtime-spec — The project provides an open container runtime specification and standardized schema for defining container… kata-containers/kata-containers — Kata Containers is an OCI container runtime that launches containers inside lightweight virtual machines to combine… ioi/isolate — Isolate is a low-level sandbox designed to execute untrusted programs within a strictly controlled environment. It…