Kubernetes Resource Management for Developers

Getting started

Install the Yoke CLI

From source

go install github.com/yokecd/yoke/cmd/yoke@latest

Download a pre-built binary

# Substitute tag and architecture to fit your needs.
curl -L -o - 'https://github.com/yokecd/yoke/releases/download/latest/yoke_latest_darwin_arm64.gz' | gunzip  > /usr/local/bin/yoke && \
chmod +x /usr/local/bin/yoke

Using homebrew

brew install yoke

Using scoop

scoop install yoke

Deploy your first package

yoke takeoff my-release https://my-domain.com/example/v1/main.wasm.gz

Explore the docs

Concepts Learn about Flights, Yoke's core building block.

Examples Practical examples to get you up and running.

Helm Compatibility Use Yoke alongside your existing Helm charts.

Air Traffic Controller Server-side controller for CRD-native package management.

ArgoCD Plugin GitOps-friendly ArgoCD Config Management Plugin.

Videos Watch tutorials and demos.

Or for technical writing about Yoke and related subjects, visit the blog.

What is Yoke?

Client-side Package Manager

Deploy code packages directly to Kubernetes with the yoke CLI.

ArgoCD Plugin

An ArgoCD Config Management Plugin that enables GitOps workflows with code packages.

Server-side Controller

Create CustomResourceDefinitions (CRDs) to represent packages natively in Kubernetes.

Go SDK

Go packages to facilitate the transition from Helm Charts to Yoke Flights.

The Yoke Project is a set of tools for working with Kubernetes package management differently than the status quo. Where once only YAML and templates of YAML ruled the representation of Kubernetes resources, you can now work with real code, with native control flow, type checking, compiler guarantees, testing, linters, and all the fundamental tools of software engineering.

The primary distinction between Yoke and other Kubernetes package managers (such as Helm and Timoni) lies in how packages are described. In Yoke, packages are called Flights, Flights are to Yoke what Charts are to Helm. Unlike Helm and Timoni, which use YAML, CUE, or other data languages, Yoke uses general-purpose code.

Flights are programs that generate the desired Kubernetes resources in JSON or YAML and output them to stdout. Flights are packaged as WebAssembly (wasm) executables, with Yoke embedding Wazero, a zero-dependency wasm runtime for Go, to execute them.

Sharing packages is the same as sharing code. Package components can be distributed and versioned using the language’s native ecosystem (npm, cargo, Go modules). Any language that compiles to wasm enjoys first-class support in Yoke.

Why Another Package Manager?

As the DevOps ecosystem transitions from platform-operators to platform-engineering, our tools for interfacing with Kubernetes must evolve. Describing Kubernetes resources through text templates is the minimum viable standard, and it clearly doesn’t align with software engineering practices. It lacks type safety, compiler guarantees, validation, testing, autocompletion, and consistent IDE support.

The key insight: Kubernetes resources are structured data, not documents. The most effective tools for handling structured data are programming languages.

New tools like CUE, Jsonnet, PKL, and others have emerged to address the shortcomings of raw YAML, inspiring new package managers like timoni. Yoke’s stance is that these tools will always fall short of the safety, flexibility, and power of building packages from real code.

With the emergence of WebAssembly as a shared cross-platform target, it is now possible to bring type safety, testing, and developer experience to the Kubernetes ecosystem like never before. This is the niche Yoke aims to fill.