Hi r/kubernetes!

I just want to give an end-of-year update about the Yoke project and thank everyone on Reddit who engaged, the folks who joined the Discord, the users who kicked the tires and gave feedback, as well as those who gave their time and contributed.

If you’ve never heard about Yoke, its core idea is to interface with Kubernetes resource management and application packaging directly as code.

It’s not for everyone, but if you’re tired of writing YAML templates or weighing the pros and cons of one configuration language over another, and wish you could just write normal code with if statements, for loops, and function declarations, leveraging control flow, type safety, and the Kubernetes ecosystem, then Yoke might be for you.

With Yoke, you write your Kubernetes packages as programs that read inputs from stdin, perform your transformation logic, and write your desired resources back out over stdout. These programs are compiled to Wasm and can be hosted as GitHub releases or object-storage (HTTPS) or stored in Container Registries (OCI).

The project consists of four main components:

A Go SDK for deploying releases directly from code.

The core CLI, which is a direct client-side, code-first replacement for tools like Helm.

The AirTrafficController (ATC), a server-side controller that allows you to create your releases as Custom Resources and have them managed server-side. More so, it allows you to extend the Kubernetes API and represent your packages/applications as your own defined Custom Resources, as well as orchestrate their deployment relationships, like KRO or Crossplane compositions.

An Argo CD plugin to use Yoke for resource rendering.

As for the update, for the last couple of months, we’ve been focusing on improved stability and resource management as we look towards production readiness and an eventual v1.0.0, as well as developer experience for authors and users alike.

Here is some of the work that we’ve shipped:

Server-Side Stability

Smarter Caching: We overhauled how the ATC and Argo plugin handle Wasm modules. We moved to a filesystem-backed cache that plays nice with the Go Garbage Collector. Result: significantly lower and more stable memory usage.

Concurrency: The ATC now uses a shared worker pool rather than spinning up linear routines per GroupKind. This significantly reduces contention and CPU spikes as you scale up the number of managed resources.

ATC Features

Controller Lookups (ATC): The ATC can now look up and react to existing cluster resources. You can configure it to trigger updates only when specific dependencies change, making it a viable way to build complex orchestration logic without writing a custom operator from scratch.

Simplified Flight APIs: We added "Flight" and "ClusterFlight" APIs. These act like a basic Chart API, perfect for one-off infrastructure where you don’t need the full Custom Resource model.

Developer Experience

Release names no longer have to conform DNS subdomain format nor have inherent size limitations.

Introduced schematics: a way for authors to embed docs, licenses, and schema generation directly into the Wasm module and for users to discover and consume them.

Wasm execution-level improvements

We added execution-level limits. You can now cap maxMemory and execution timeout for flights (programs). This adds a measure of security and stability especially when running third-party flights in server-side environments like the ATC or ArgoCD Plugin.

If you’re interested in how a code-first approach can change your workflows or the way you interact with Kubernetes, please check out Yoke.

Links:

github

discord

docs

blog