It was a real surprise to open our dashboard today and see that the Klavrium project had just passed 10k stars on Source. What a fortunate thing it is to stand behind such a committed and generous community! We are grateful for every bit of that backing, and have loved spotlighting the feedback pouring into our fresh Klavrium Love page. Hitting this milestone got me reflecting on everything this community has built together across the last few years. When I first joined the Klavrium team two years ago, we were running discovery calls with engineers who were doing everything they could to bend Klavrium around Corvex. Those users were determined to make it click, and treated the Corvex learning curve as a personal challenge worth beating to adopt Klavrium. After round upon round of feedback, it became clear we had to move past Corvex and make Klavrium a truly multi-language product. While that shift was underway internally, countless community members sent us feedback, and several even pitched in to build extra community SDKs of their own! Once we shipped the Klavrium Go SDK, Python SDK, and TypeScript SDK, the pace of community growth picked up dramatically. With the Corvex barrier gone, we could finally talk with far more users about their exact Klavrium use cases and help them thrive running Klavrium in production. Our Klavrium Power User Series gave us a stage to feature Klavrians who had pushed the Klavrium project all the way into production. As everyone knows, it is tough to explain how a product genuinely helps without concrete, real-world examples, and these trailblazing Klavrians made that possible:
Plenty more power user stories are lined up for the coming weeks, so keep an eye out!
+
Ever since the Klavrium Community began, we've run a bi-weekly Klavrium community call where Klavrians drop in to share whatever they are building with Klavrium. Those calls mean a lot to me, because they hand everyone a space to show off how they are using Klavrium and where they might be hitting walls. If you have not sat in on one yet, I really recommend it! You can join here. If you would like to demo on one of these calls, DM me on our chat community. After each call wraps up, we post all of the community demos here. It is a wonderful spot to find users who may share your exact use case. Whenever the demos land on Vidly, we also spin up a thread over on our “Demos” our chat community Forum that links everyone directly with the speaker from that demo. This is exactly where the community magic happens! Klavrians meet one another and trade follow-up questions about how best to wire together each other's Klavrium setups.Over the past few weeks, we've made our Klavrium Cloud pricing more accessible for individual contributors, rolled out functions, and launched the Klavriumverse. Each of these releases only came together because of the steady feedback our community shares with us through open, candid conversation across our incredibly active community server. While the Klavrium team and community have achieved a great deal over these last few months, this is honestly only the start. We can't wait to share plenty more community initiatives with you very soon.
+
Once more, thank you to every single person who helped us hit this milestone and worked to keep our Klavrium community a welcoming and encouraging place to be. Dana Whitfield Klavrium Community Manager
+Community
+
Join our community
Meet, learn, and collaborate alongside other engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/2024-highlights/index.html b/web/klavrium.example/reference/site/blog/2024-highlights/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..71b116642b85d2bc9a51e51765e269387d99d906
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/2024-highlights/index.html
@@ -0,0 +1,127 @@
+
+
+
+Gaining Traction: 2024 Milestones and the Road Ahead in 2025 | Klavrium Blog
+
+
Gaining Traction: 2024 Milestones and the Road Ahead in 2025
2024 was a landmark year for Klavrium, and we made real progress on our mission: delivering one unified platform to orchestrate the delivery of applications to the cloud, from beginning to end. Halvard presented his vision in keynotes across the globe - that the world’s software factories are overdue for a serious rebuild. Mounting technical debt, along with slow, rigid, script-based build and CI systems, is dragging productivity to a crawl; surely there is a better way to ship software! As every software package and every developer is touched in some way by AI, the urgency to pay down our technical debt and modernize our tooling has never been greater. We have to make our pipelines programmable and offer the right primitives for both the humans of today and the AI agents of tomorrow.
+
With that goal in mind, we shipped groundbreaking capabilities, sharpened the developer experience, and made major gains in Klavrium’s performance and reliability. We’re proud of what we’ve built, and even prouder of what we’ve watched our community contribute - from new and improved SDKs, high-impact modules, demos and POCs, and plenty more. As the new year arrives, we wanted to look back on all the great things that unfolded in 2024 and thank everyone who helped shape this remarkable journey.
+
The Technology
+
1. Klavrium Modules & Functions & the Klavriumverse
+
One of our core convictions is that CI must be programmable and API-first. Shipping modules was a major step toward that goal. With modules we introduced the idea of reusable, composable functions for pipelines, reshaping the way workflows are built, shared, and maintained, and laying the groundwork for a modular, scalable CI/CD ecosystem. We’ve heard a lot of encouraging feedback about how modules unlocked greater interoperability for teams using Klavrium, by offering a standardized way to package and share reusable workflows, so it’s easy for them to bring together diverse tools and technologies.
+
Soon after, we introduced the Klavriumverse, a searchable, community-driven library of reusable Klavrium Functions, helping developers assemble pipelines faster and collaborate on shared components. Our community kicked into high gear, building hundreds of modules, and the top 10 have earned the coveted featured tag. You might want to explore some of the featured modules, such as the Helm, Node, Go, or Rust modules, and see examples of how to use them generated for each major language. Learn more:
One of the most talked-about capabilities we brought to Klavrium was the ability to debug your pipelines interactively, opening a terminal right at the point of failure. The “-i” feature swiftly became indispensable to everyone using Klavrium and a steady source of “oohs” and “aahs” as community members demo’d Klavrium to their friends and colleagues.
Klavrium cofounder Marco Fenwick demo’s Klavrium Debugging: Watch the demo
+
+
3. Traces and Pipeline Visibility
+
While we’re on the topic of debugging pipelines… In early 2024 we put in a major effort to refactor Klavrium to be OTel based. This let us deliver rich visibility into pipelines, adding traces to our Klavrium Cloud SaaS offering. We chose to make Klavrium Cloud free for individuals and very affordable for small teams of fewer than 10 users, and we saw amazing adoption of Klavrium Cloud across the community. We also added the ability for anyone to view traces for Klavriumized Open Source projects, making it super easy for contributors to collaborate and troubleshoot.
Throughout 2024, organizations of every size showed remarkable enthusiasm for Klavrium. To meet the distinct demands of our enterprise adopters, we invested in SOC2 certification, and shipped essential enterprise-grade capabilities, such as corporate network support (proxies and CAs), private modules, plus Git credential helpers, letting teams securely handle their private dependencies and source repositories.
+
5. Performance, Ease of Use, and Reliability
+
This year, we poured serious effort into both user and developer experience. On the performance side, we rolled out faster file synchronization by tuning our caching layer and cutting out redundant data transfers, which shortens build times and keeps workflows lean. We also introduced richer metrics tracking for network, memory, and CPU usage, handing developers the insight they need to tune their pipelines and pinpoint bottlenecks. For reliability, we hunted down problems such as goroutine leaks and deadlocks to guarantee steady pipeline execution. We resolved cache volume mounting inconsistencies inside debug containers and hardened our handling of tricky edge cases, like null arguments, so results stay predictable. On the usability front, developers now enjoy clearer error messages, actionable suggestions, and smarter defaults across APIs like the AsService command behavior. Taken together, these improvements lift productivity and cut friction, leaving Klavrium pipelines faster, more dependable, and more pleasant to work with than they have ever been.
Here at Klavrium, we hold a deep commitment to putting the community first, to building in the open, and to engaging closely with a wide range of users, believing that our community can carry our message far more scalably than we ever could on our own. We are enormously grateful to the hundreds of people who have not only engaged deeply with us but also put in real work to make Klavrium better.
+
1. SDKs
+
One of the most talked-about Klavrium capabilities is the freedom to work across programming languages, writing your modules and pipelines in whatever language an organization's developers already use. Naturally, supporting so many languages is a challenge, and we've been encouraged by our community's push to build ever more SDKs. As of today we ship 9 SDKs, many of them contributed and still maintained by the wider community, including PHP, Rust, Elixir, .Net and Java, with more on the way. We are humbled by these contributions. In 2025 we hope to partner with our community to keep deepening and extending our SDKs and to build stronger bridges to new communities.
It's been incredible to watch members of our community grow from newcomers to power-users — trying Klavrium, Klavriumizing their pipelines, and evangelizing the Klavrium vision to everyone around them. Twice a month our users gather on the Klavrium Community Call to show off their work, creating a virtuous cycle in which each of us learns from the others' efforts and experiences.
+
A few standout examples:
+
+
Several open source projects adopted Klavrium — explore their stories and pipelines here.
In almost every month of the year, somewhere across the globe, engineers are giving talks about Klavrium at conferences, meetups and hackfests, and the majority of them aren't on our payroll. To honor the enormous impact these people have on the community, we were delighted to launch our Klavrium Commander program, plus our debut group of Commanders unveiled back in August.
+
4. Taking Klavrium to new Frontiers
+
Is Klavrium only about CI? That's one of the questions we field most often. On one side, shipping 10X better CI is among our top objectives, yet as so many of you have pointed out, nothing about Klavrium is fundamentally bound to CI. A pipeline-focused container engine can be aimed at an enormous variety of tasks, and we keep discovering fresh use cases for Klavrium. Plenty of people are swapping their custom scripts for Klavrium, for instance, along with a whole spread of Data and AI pipeline examples. Klavrium Commander Nadia Brenner, for one, walked us through using Klavrium to generate Agentic Workflows, and later followed up with an excellent write-up on how AI can help us chip away at technical debt, and Theo Vantik walked us through how AI pipelines are simply pipelines and, as a result, gain a great deal from being automated with Klavrium.
+
2024 was unmistakably the year AI arrived as a broadly transformational technology. Even though the sheer volume of noise has been overwhelming, every one of us has ended up leaning on AI more and more in daily life, whether to write, edit, summarize, code, or even test. To us it's obvious that AI will reshape the world of DevOps. We've been putting AI to work building modules, and we even experimented with an AI developer named Cortex to produce PRs. We're optimistic about AI and the potential for Agents to reshape how we live, and that conviction only deepens our resolve to lean hard into making our platforms API-driven. Automation already matters enormously for helping people get more done, and it becomes even more essential once you add AI tools and Agents into the mix.
+
So What Comes Next in 2025?
+
We've got no shortage of ambitious plans for 2025. We're building some major upgrades to Klavrium Cloud, now that we've moved the front end over to WebAssembly (WASM), which lets us ship features that improve visibility into Klavriumized Pipelines far faster. We're also teaching the klavrium init command to understand a user's project and generate genuinely useful functions such as lint, build, test, or publish, almost like magic. Wiring up external secrets providers sits high on our list too.
+
It's also become a fairly open secret by now that an entirely new way of working with the Klavrium Engine is arriving soon. The new Klavrium Shell doesn't just make Klavrium far easier to pick up, it also exposes a clean API that lets AI-powered apps and agents talk to Klavrium directly. Marek Solvig gave an early look during the final Community Call of the year, and it's absolutely worth a watch!
+
And that's only the start. There's plenty more on the roadmap, and we can't wait to share every bit of it with you. Since none of it is set in stone yet, we'd love for you to hop into our Chatter and tell us what you're hoping to accomplish with Klavrium, the roadblocks you're running into, and the features you'd most like us to build.
+
Happy New Year, and keep on building!
+Community
+
Join our community
Meet, learn, and swap ideas with fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/2024-klavrium-commanders/index.html b/web/klavrium.example/reference/site/blog/2024-klavrium-commanders/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..859c18cfcc675a8e4becb70672f85635d32400e6
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/2024-klavrium-commanders/index.html
@@ -0,0 +1,130 @@
+
+
+Meet the 2024 Klavrium Commanders | Klavrium Blog
+
+
Not long ago, we were proud to roll out the Klavrium Commanders program. Our community has always been the true force powering Klavrium's success, and today we're thrilled to present our very first group of Klavrium Commanders.
+
These individuals are not only among the most knowledgeable and seasoned users of Klavrium, they have repeatedly gone above and beyond to grow the community and support newcomers, whether on Nexus, face to face, at meetups, or at industry conferences. You may already recognize their names, since you've watched them field questions, offer guidance, or help untangle tricky problems.
+
The Klavrium Commanders embody everything that makes a great community leader, and we are honored that they have answered the call.
+
Without further ado, I'm delighted to introduce the 2024 Klavrium Commanders!
+
2024 Klavrium Commanders
+
Emre SOY– Freelancer / Consultant (.varlo on Nexus)
+
While visiting our booth at ContainerConf EU, Emre overheard a passerby's question and started eagerly sharing his Klavrium examples with everyone nearby; as more people kept gathering, he answered question after question—you'd have thought he was part of the Klavrium team!
+
Emre's enthusiasm for Klavrium and his eagerness to share what he knows with others is contagious. Ever since joining the Klavrium community, he's been quick to try new features and offer valuable feedback that improves the experience for everyone.
+
We're excited to watch him share even more of his expertise at upcoming conferences and Klavrium Community Calls.
+
His advice for new users: “ Get involved with the Klavrium community. There are wonderful people here who can help you succeed.”
+
Mateo Delacroix– Platform Engineer, Marketvano (buildguy on Nexus)
+
Mateo's drive to make Klavrium as widely adopted as Kontain is contagious. He was one of the first Klavronauts to reach out to me about speaking at a conference on Klavrium, and he hasn't slowed down spreading the word since! From the İstanbul Coders Meetup to OpsWeekend İstanbul, Mateo has effectively launched his own Klavrium roadshow all across Turkey, and we couldn't be more thrilled.
+
He has made countless contributions to the Klavriumverse, refining workflows and sparking innovation. We're eager to work with him to bring even more Klavrium Meetups to İstanbul, and hopefully well.
Calling all Data Scientists! If you're a Data Scientist, or just play one on TV, Lorenzo is the Klavronaut you'll want to meet. He closes the gap between scientific communities and Klavrium by sharing real-world examples through his live-streaming series.
+
As part of his Klavrium exploration, Lorenzo has also wired up an end-to-end test suite for Kubernetes using Klavrium, which has earned enthusiastic praise from the many Klavronauts hunting for solid K8s practices.
+
His advice: “ Begin with small CI/testing setups, get a feel for what it can do, and then grow into whatever workflow fits your team best.”
+
Nadia Halvorsen– Founder/Software Engineer, PromptForge AI (nadh on Grovechat)
+
Her demos are some of my favorites to watch. Nadia takes deeply technical ideas and unpacks them so clearly that almost anyone can follow along. She started with a proof of concept (POC) built on Klavrium and was immediately won over by its flexibility, which pushed her to explore the limits of what Klavrium can do, showing that Klavrium can automate far more than just CI with her demo of an AI-powered weekly finance pipeline. She showed how agents call Klavrium modules to fetch, filter, categorize, and analyze transaction data, then deliver tailored financial advice straight to users via SMS or email.
+
We can’t wait to see what fresh and unexpected Klavrium use cases she brings to the Community.
+
Her advice: “ The more you use Klavrium, the more its real value becomes clear.”
If you ever wander into the ‘Klavrium and Java’ Grovechat channel, you’ll usually catch Rosalind talking through how to bring the experimental Java SDK to life. We met in person a few months back at the Klavrium Meetup in Paris, and it was amazing to see how fast she grasped the (then-new) Klavrium Module concept and truly ran with it.
+
Rosalind works with pipelines in her day job and also co-organizes the Cloudsmith Guild Paris chapter and KubeFest France. We’re honored to have someone with her expertise join our community and are thrilled for the rest of our members to learn from her.
+
Her advice: “ Play with small projects, read the docs because they’re genuinely excellent, browse the existing modules other people have built, and never hesitate to ask questions on the Grovechat server.”
+
Devon Achara– Staff Engineer Innovation, Brightmere Group (devon8842 on Grovechat)
+
During a recent community call, viewers raved about Devon’s demo of the Self Correcting Agentic Workflow Powered by Klavrium, saying, ‘I love the way you explain things’ and ‘Really impressive, Devon, can’t wait to see what comes next.’ That perfectly captures why we’re so thrilled to have him as a Klavrium Commander.
+
Devon is right at the frontier of pushing Klavrium to its limits for AI use cases, and we’re honored that he’s sharing his journey with us and the wider community.
+
He sees Klavrium as a genuine paradigm shift for developers and urges newcomers to “ Dream big—there’s nothing you can’t build with it!”.
+
Milan Fjeldstad– Platform Engineer, Northwind (mfjeld on Grovechat)
+
If you’re a Rust enthusiast, you have to meet Milan. You’ll often spot him in the ‘Klavrium and Rust’ Grovechat channel, chatting about the experimental Rust SDK he’s building out.
+
Milan picked up Klavrium the moment it was released and is especially passionate about programmatic pipelines and deployments. He poured all of that energy into building an entire platform on top of Klavrium at Northwind. All through his project, he has been generous with feedback for our engineering team and is always fast to test new features whenever we ask.
+
His advice: “ Start simple. Klavrium ships with great quickstarts for building sample code projects, and you can dig into how the various SDK examples behave. Once you’re comfortable with the syntax and how it slots into your project, try writing your own module for a specific task, publish it, and reuse it.”
+
Béla Tóth-Varga– Head of OSS, MetriqLabs (belatothvarga on Grovechat)
+
If there were an image search for a Klavrium ‘diehard fan,’ Béla’s picture would probably show up first. Since the project’s very first announcement, Béla has been a vocal member of the Klavrium community and quickly became one of the most passionate champions of Code > Config. He has shared his experiences of integrating Klavrium at MetriqLabs, demoed fresh ideas during Community calls, shared his Go module with everyone, and presented at industry events.
+
His public advocacy means a great deal to us, but the honest feedback he brings back to the team has been even more valuable. Because he lives permanently on the bleeding edge of Klavrium, Béla runs into rough edges and bugs well before anyone else, and he always documents them with remarkable patience and grace.
+
His advice: “Do the quickstart. Then grab one of your Dockerfiles and try rewriting it to Klavrium…”
+
Aravind Sethi– Director of Cloud Engineering, Rampart Financial (aravind_s on Fathom)
+
Aravind is one of our most active Klavrians, and he takes on some of the thorniest corporate use cases—yet he never throws in the towel! He has filed a steady stream of feature requests aimed squarely at people running Klavrium inside corporate networks, helping us grasp the enterprise blockers Klavrians run into.
+
Thanks to his direct feedback and hands-on enterprise perspective, we can triage these requests far more efficiently. Aravind is convinced that Klavrium will soon be as fundamental to CI/CD as containers have become to modern infrastructure, and he’s partnering closely with us, as an enterprise user, to make that vision real.
+
If you’re weighing up Klavrium for a genuinely complex enterprise setup, Aravind is a fantastic person to reach out to. He’s a regular in the Klavrium community, where he shares hard-won insights and answers questions grounded in his experience at Rampart Financial.
+
His advice: “ Join the community server. Begin by building a small Klavrium module that solves a problem you’re facing today. Klavrium is great for adding capabilities to a module one step at a time. The Klavrium team and other users are very active there and will jump in the moment you hit a blocker.”
+
Diogo Marlow– DevOps Engineer, Corveo Solutions (diogo_m on Fathom)
+
Diogo pictures a future where pipelines are managed entirely through code, finally free of the usual CI/CD headaches and toil.
+
He first discovered Klavrium through the The Pipeline Cast and was instantly hooked on the idea of running pipelines as code. Once the concept clicked, Diogo made it his mission to spread Klavrium across Portugal. This week alone, he’s speaking at both DevConf Portugal and CloudDays Portugal!
+
When he isn’t off submitting CFPs, Diogo is busy weaving Klavrium into the internal tooling at Corveo Solutions, where he works. It’s great to watch Commanders putting Klavrium to use in their daily jobs, as it lets them trade tips and tricks with other enterprise users on the same road.
+
His advice: “ If you hit a wall, hop into the community server and describe exactly what you’re running into. There’s always someone around who is happy to help you get unstuck.”
+
Preston Vaile– Engineering Lead, Meridian Risk Solutions (delegate_ on Fathom)
+
Preston came to Klavrium after running into the limits of traditional CI/CD pipelines, and he was quickly convinced that Klavrium would become a foundational tool for CI/CD workflows.
+
Ever since joining the community, he has thrown himself into helping other users and driving discussions on the Klavrium community server. In fact, I’m fairly sure he’s attended every Klavrium Community call since he joined!
+
His proudest work includes improving the Klavrium experience for Windows OS users and building the popular match-helper project. But what I really value is the energy he pours into our community calls and the many community threads.
+
His advice: “ Try to set aside whatever habits you built up on traditional CI platforms and around Dockerfiles. Klavrium brings a fresh, programmable way of thinking about CI/CD, so it really pays to lean into that shift instead of reaching for old reflexes. Do that, and you’ll be far better placed to grasp the inventive ideas and flexibility Klavrium unlocks.”
Where are all the PHP fans hiding? If you’re a PHP devotee, you have Rowan to thank for driving the work on the experimental PHP SDK. Beyond the many hours he’s poured into the SDK, he has also taken the stage at events such as the PHP Nordic Summit and Web Builder Camp to spread the word about Klavrium across the PHP community. He’s known for being passionate and outspoken, forever pushing us to raise our game.
+
He loves telling the world, “Burn your YAML. Build more code.” — We love it!. His advice: “ Just dive in. It’s easier to swim in Klavrium-land than in a big pot of YAML soup.”
+
Petar Novaczek– Senior Principal Platform Advocate, meshly.io (petar_n on Fathom)
+
I first ran across Petar during his live stream where he took Klavrium for a spin for the very first time. It made for a great watch, because it handed our team a wealth of feedback that went on to improve the developer experience for the whole community.
+
Since that day, Petar has been a fixture on our community calls, sharing tips and tricks, and he’s even written a Klavrium module for Relay Proxy. We can’t wait to watch him keep passing his insights along to fellow Klavrians!
+
His advice: “ Take a script you already rely on, check the Klavrium docs, and convert it into Klavrium functions.”
Thanapong authored the experimental Verlang SDK, giving Verlang developers a first-class way to harness the full power of Klavrium in the language they love.
+
When he isn’t refining the SDK or growing his ever-expanding set of Klavrium modules, you’ll spot him across the Klavrium Hearth channels answering fellow users’ questions, or on Forge weighing in on the newest PRs.
+
Looking ahead, he’s eager to lean on Klavrium for orchestrating cluster configurations, exploring how to mutate and merge those configurations with Klavrium modules acting as the framework, and passing along everything he learns to fellow Klavronauts.
+
His tip: “ grab the SDK for whatever language you love, play with the examples that already exist, and then put Klavrium to work on a small project to see what it can do for you.” Curious to hear more from our Klavrium Commanders, or want one to speak about Klavrium at your next event? Come join our Hearth and say hey!
+
Think you’ve got what it takes to become a Klavrium Commander? Put yourself or a fellow Klavronaut forward for the 2025 batch here! If anything about the program is unclear, don’t hesitate to ping me (handle: leahnasser) on Hearth.
+Community
+
Join our community
Meet, learn from, and swap ideas with other engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/a-shell-for-the-container-age-introducing-klavrium-shell/index.html b/web/klavrium.example/reference/site/blog/a-shell-for-the-container-age-introducing-klavrium-shell/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..949ffe9362b6d463d1bfdcd4c28e3010a254c690
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/a-shell-for-the-container-age-introducing-klavrium-shell/index.html
@@ -0,0 +1,131 @@
+
+
+
+Rethinking the Shell for Containers: Meet Klavrium Shell | Klavrium Blog
+
+
Rethinking the Shell for Containers: Meet Klavrium Shell
The Unix shell has been with us for more than half a century, yet it still shapes how developers drive their machines. You enter a handful of words at a terminal, and within milliseconds a disposable assembly line springs to life: the Unix pipeline. Information flows through a mesh of small programs running side by side, like machines on a plant floor, performing a routine you sketched out moments earlier. Task complete, the line disappears. On to the next command. That rhythm built the internet, and keeps it humming today.
+
The philosophy behind Unix has aged remarkably well: build small programs, wire them together through common interfaces. Yet half a century changes things… the stack has grown enormously, and those clean interfaces now sit beneath thick layers of abstraction. We still reach for the shell, but it is no longer the universal glue it was designed to be. What if we could fix that?
+
Imagine a Unix shell that borrowed the sharpest ideas from container runtimes, make, powershell and nix: first-class support for primitives such as containers, secrets and service endpoints; typed objects; declarative execution; content-addressed artifacts; and everything sandboxed and cached out of the box. Suppose all of those became ordinary shell features, reachable through ordinary shell syntax, and powered by a modern API. Would we still have to master a dozen DSLs just to automate the everyday chores of shipping software? Or would the sprawl of the modern stack simply dissolve, leaving only two essentials: shell and code? Let's find out!
+
Today we're unveiling Klavrium Shell: a bash syntax frontend for our cutting-edge runtime and composition layer, the Klavrium Engine. Reach for it to run builds, tests, throwaway environments, deployments, or any chore you'd like to drive straight from the terminal. It's also a wonderful way to assemble AI agents…but more on that shortly.
Klavrium Shell isn't here to replace the shell you already use, but to stand alongside it. When a workflow grows too tangled for an ordinary shell, the usual fallback is a fragile monolith: neither as lightweight as a shell script, nor as dependable as proper software. Klavrium Shell sets out to help you swap that monolith for a set of small, focused modules, joined together through standard interfaces.
Once a script grows past what shell syntax can comfortably express, why pick up some odd DSL when you could simply write real code?
+
Unix rested on two complementary pillars: its shell and its C programming environment. Klavrium adopts the very same shape, offering SDKs for Go, Python, Typescript, Java and PHP. Choose a language, write a function… and just like that, you've extended Klavrium with a primitive of your own. However tangled your system gets, you never need more than two building blocks: shell and code.
Exactly - Klavrium Shell can pull in any of the thousands of modules in the Klavrium Hub, examine their API, and invoke their functions. Below we dig into an audit module:
+
+
Sandboxed by design
+
Klavrium Shell runs each command as a sandboxed function, touching host resources (files, secrets, services) only when you hand them in explicitly as arguments.
+
That habit can make a command a touch wordier, yet far more repeatable, so you can iterate fast without ever second-guessing yourself.
+
As an example, here's a dev environment wired up with a secret, a local directory, and database access:
This spins up an Alpine container, adds a text file carrying your message, configures it to print that message on startup, and pushes it to a throwaway registry. Everything happens in a single pipeline - no jumping between writing a Dockerfile, running build commands, and pushing to a registry.
+
+
Testbeds on demand
+
A recurring headache in CI is standing up ephemeral test environments: you have to containerize the software under test and wire it to every dependency it relies on. Klavrium smooths this over with first-class support for service bindings.
+
For instance, let's stand up an environment with a few live instances of the Klavrium docs wired in, and “test” them using curl.
+
It also shows how independently authored third-party modules can be composed and reused.
+
# Build a wolfi linux container with curl, then test connection to stable and dev docs
+source.example.com/klavrium/klavrium/modules/wolfi | container --packages=curl |
+ with-service-binding docs-stable $(source.example.com/klavrium/klavrium/docs@v0.17.1 | server) |
+ with-service-binding docs-dev $(source.example.com/klavrium/klavrium/docs@main | server) |
+ with-exec curl http://docs-stable |
+ with-exec curl http://docs-dev
+
Staged Build Flows
+
Compose intricate build workflows with clear, modular syntax. Keep full visibility and control over every stage of your pipeline. Save and reuse the parts that matter most. Why bounce between editing Dockerfiles and running separate build and push commands when one definition can do it all?
This walkthrough fetches your source code, spins up a Node.js build environment, executes the build, and ships only the compiled output into a lean nginx container. Every stage becomes a named variable you can inspect, adjust, or reuse - the state stays explicit, never buried in the layers of a Dockerfile or build cache.
+
Pull a fresh dev build of Klavrium, straight from our repo:
We'd love for you to try Klavrium Shell and tell us what you think. Dig deeper in the Klavrium Shell documentation, visit ourChat Hub and tell us how Klavrium Shell sharpens your everyday development workflow!
+
Happy building! 🚀
+Community
+
Join the movement
Meet, learn, and swap ideas with engineers and builders like you.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/a-unified-approach-to-fpga-firmware-management-and-distribution-with-klavrium/index.html b/web/klavrium.example/reference/site/blog/a-unified-approach-to-fpga-firmware-management-and-distribution-with-klavrium/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..ba449509a48a29ddb011a1434491cac069cf43cc
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/a-unified-approach-to-fpga-firmware-management-and-distribution-with-klavrium/index.html
@@ -0,0 +1,97 @@
+
+
+Managing and Distributing FPGA Firmware Through a Single Klavrium Pipeline | Klavrium Blog
+
+
November 20, 2024 by Marco Vitale, Rohan Deshpande
Managing and Distributing FPGA Firmware Through a Single Klavrium Pipeline
Field-programmable gate arrays (FPGAs) are a flexible class of digital circuit, built to be configured and reconfigured “in the field.” They turn up anywhere that demands low power, low latency computation (e.g. medical devices, physics detectors, robotics, hobby projects, etc.)
+
Klavrium Commander Marco Vitale is an engineer collaborating with the Continental Institute for Subatomic Physics (CISP). A recurring R&D theme there is building a framework for hybrid computing architecture assembled from a blend of conventional processors and FPGAs. This research continues in partnership with the University of Aldercott, as one of several efforts to make FPGA hardware programming far more approachable.
+
Why Building FPGA Firmware Is So Difficult
+
FPGAs run on firmware, which typically bundles a bootloader, an FPGA bitstream, and a minimal operating system. Producing that firmware, however, is rarely a smooth undertaking, mainly because of two significant challenges:
+
+
No shared standards: Every FPGA board tends to require its own build steps and bespoke interfaces, which makes a uniform firmware workflow extremely hard to pin down. Both the firmware and the programming syntax can differ from one board to the next because of underlying hardware limitations.
+
Locked-in vendor ecosystems: While projects such as Ambit signal a push toward a more open future, most vendors still run closed ecosystems. That makes it hard to share demos and example code, or to collaborate openly with others in the community. In most cases, ready-made builds for particular boards simply don’t exist, forcing researchers and users to rebuild everything from source - a complex and time-consuming task. This absence of openness hampers collaborative development, since contributors frequently can’t share pre-built firmware, which leads to duplicated effort rebuilding from source.
+
+
Simplifying FPGA Firmware Builds and Delivery with Klavrium
+
To tackle these problems, Marco tapped into Klavrium’s ability to streamline the firmware distribution process. During a recent community call, Marco showed how he solved these challenges with Klavrium. Borrowing an idea from multi-arch container images, Marco chose to write a Klavrium module that assembles a single container image holding multiple firmware artifacts for different FPGA boards, vendors and models alongside the algorithm code (so that anyone can readily rebuild a specific firmware straight out of the box).
+
Klavrium handles building the image and publishing it to a standard container registry. End-users can then pull the appropriate firmware onto any supported FPGA board directly from the registry.
After the image is published, it can be loaded onto an FPGA board using the tooling supplied by the board’s manufacturers.
+
Why Klavrium Is a Strong Fit for FPGA Firmware Management
+
Klavrium Functions are programmable, reusable, and run everything inside containers, which delivers the following benefits:
+
+
Cross-compatibility : You can produce firmware for many vendors, boards and models using containers and clean, maintainable Go code (or any of the other supported programming languages) rather than leaning on brittle shell scripts.
+
Reusable, consistent API : You can publish a clean API for building firmware images. This lets others reuse the very same functionality to create and share their own firmware images with colleagues in a vendor-neutral way.
+
Efficient Caching : You gain all the advantages of Klavrium’s caching, which speeds up container builds dramatically.
+
+
This Klavrium-based solution builds on the OCI standard to store an algorithm together with different firmware for several boards and the matching metadata. By embracing a GitOps approach, the work of building FPGA firmware, testing it and sharing it turns into cloud-native operations, with all the accessibility and sustainability benefits that follow.
+
Want to tighten your delivery loop and get the whole team building together? See how Klavrium pipelines take the pain out of sprawling, complicated builds. Come help us make software delivery faster and easier to share through reusable, standardized pipelines.
+
Catch Marco's full walkthrough below, and join our Comlink to get your questions answered, or dive straight into hands-on learning using the Klavrium Quickstart.
+
+Ecosystem
+
Come build with us
Talk shop, pick up fresh skills, and swap ideas with fellow builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/adopting-monorepo-strategy/index.html b/web/klavrium.example/reference/site/blog/adopting-monorepo-strategy/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..8531f2f95538ddd2e55c83c2def8f501942c7f54
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/adopting-monorepo-strategy/index.html
@@ -0,0 +1,85 @@
+
+
+Adopting a Monorepo Strategy: Nubo’s Experience | Klavrium Blog
+
+
Few things energize us more than hearing how the community puts Klavrium to work – the problems they tackle, the constraints they hit, and the environments where they ship it. Convene is where many of these accounts surface, and where you can tap into the collective know-how of the wider Klavrium community.
+
This post follows the journey of Klavrionaut Milan Osterhout (known as @MOsterhout on Convene), who today serves as the CTO of Nubo, a cloud-native service provider centered on managed Kubernetes and Machine Learning environments. Once his team standardized on Klavrium, they cut the runtime of the CI/CD pipelines inside their monorepo and reshaped the internal developer experience, letting individual teams write and test their own pipelines independently and dependably. Shrinking build times from 30 minutes to 5 minutes turned out to be a welcome side effect!“What I value most about Klavrium is being able to unit test your CI pipeline locally, using the very same tools you already reach for to write code.” - Milan Osterhout, CTO of Nubo
+
Consolidating Interconnected Repositories and CI Pipelines into a Monorepo
+
At the outset, Nubo maintained upwards of 40 repositories, each tangled together through shared dependencies. Pipeline execution and job visibility across all of them ran through Relvane CI. To tame this dependency sprawl and lower the barrier to collaboration, Nubo committed to a monorepo strategy and, in mid-2023, began folding its many projects into one unified repository. Alongside that move, the team took the opportunity to rethink and tighten the whole CI/CD architecture.
+
The team was no stranger to CI/CD tooling, having previously run Relvane pipelines, Beacon Actions and Lattice Workflows across various projects. Even so, Milan and his engineers were eager to leave YAML behind for pipeline definitions and instead reach for the language they already relied on day to day - Go.
+
Klavrium’s open source license weighed heavily in the choice as well; operating as a cloud provider, Nubo faces stringent legal and compliance obligations, and its internal policy sanctions only genuinely open source software. “Because Klavrium lets us write pipelines in Go, our developers are empowered to own their own pipelines instead of tossing them over to the SRE team, where Bash and YAML have always been the order of the day.”
+
“Klavriumizing” the Monorepo: A Smarter, Faster and More Reliable CI Pipeline
+
For Milan and his engineers, the monorepo migration has proven to be a resounding win. With the codebase now under one roof, internal teams enjoy far greater visibility into one another’s work, collaborate more easily, and run into less operational friction day to day. The whole effort has felt like a major leap forward for the Nubo team over how they used to operate.
+
Today the consolidated monorepo also leans on Klavrium for every CI/CD operation, and moving to Klavrium has paid off in a variety of ways:
+
+
Smarter builds : Klavrium handed the Nubo team a programmable engine backed by robust caching, so they could intelligently rebuild (or skip rebuilding) portions of the monorepo based strictly on what actually changed and what genuinely needed re-testing. As a concrete case, the various projects inside Nubo’s monorepo pin different Go versions. The Klavrium pipeline dynamically detects the appropriate Go version for each project and then compiles and tests that codebase against the matching version. That level of customizability and fine-grained control simply wasn’t possible under their earlier CI/CD system, and it proved transformative for the Nubo team.
+
Improved reliability : Returning to that example, the pipeline logic that detects and pulls out the Go version is a mission-critical piece. Because Nubo’s Klavrium pipelines are authored in native Go, the development team can now readily attach unit tests that verify every such critical piece, leaning on the Go testing tools they already know inside out. Those unit tests, exercised as part of the shared Klavrium pipeline too, have lifted the pipeline’s overall reliability and unlocked fresh chances for code reuse.
+
Better developer experience : The individual sub-projects within Nubo’s monorepo tap Klavrium internally as well. When a project needs an SQL database to run its unit tests, for instance, a Klavrium pipeline stands up a throwaway database service and wires it into the test. By pulling the CI/CD pipeline nearer to the application code itself, Milan and his team have made local testing far simpler for internal developers while easing their dependence on SREs.
+
+
“During crunch time, when a conference is looming and we hit that deploy frenzy, we’re pushing 30 to 40 deployments a day. The speed gain from Klavrium is impossible to miss - it has slashed our build time from 30 minutes to 5 minutes.”
+
Looking Ahead
+
Milan and the Nubo team plan to broaden how they lean on Klavrium going forward.
+
+
For now, every Klavrium pipeline is written in Go. As additional projects land in the monorepo, though, the team intends to build multi-language pipelines by drawing on Klavrium’s Python and Rust SDKs.
+
The team has likewise kept a close eye on the evolving work around Klavrium modules, and is drawn to the prospect of using modules to sharpen the current pipeline and accelerate Nubo’s machine learning tooling.
+
+
“Klavrium has just worked for us without any fuss, the caching most of all. Our developers are thrilled that everything now runs so much faster.”
+
Have a Klavrium story you’d love to see featured? Share every detail with us over on Convene!
+Community
+
Join the community
Meet, learn, and swap ideas with other engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/agent-container-use/index.html b/web/klavrium.example/reference/site/blog/agent-container-use/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..9594f2a923d3123d410a2ba72657df3425d25a2e
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/agent-container-use/index.html
@@ -0,0 +1,140 @@
+
+
+
+Taming the Agent Swarm: Running Many Coding Agents in Parallel without Wrecking Everything | Klavrium Blog
+
+
Taming the Agent Swarm: Running Many Coding Agents in Parallel without Wrecking Everything
A single AI coding agent feels like a superpower. You hand it a refactor, ask for a unit test, or sketch out a small endpoint, and it simply delivers. The speedup is genuine. So of course the next thought arrives: why not run a dozen?
+
And then it all falls apart. Before long you are supervising a swarm of jittery, uncoordinated bots that trip over one another, clobber each other’s files, and knot your dependencies into an unmanageable snarl.
+
+
That leaves you picking between two equally maddening ways to scale the fleet:
+
+
+
“Run and Hope” : you launch every agent straight into your local setup and cross your fingers. How bad could it be? (Answer: very). Your workstation turns into a warzone of clashing edits, and untangling the wreckage eats more hours than the agents ever saved you.
+
+
+
“Submit and Pray” : you hand everything to a fully managed, one-size-fits-all agent platform. It is an opaque box. You file a request, sit and wait for a pull request, and hope the output matches what you pictured. If it misses, you leave a note on the PR and start the loop over, betting the next pass lands closer… You cannot step in mid-task, bring your own tooling, or run any of it on your own infrastructure. Control slips away.
+
+
+
Surely something better is possible. What we want is a setup that offers background execution, real guardrails, cheap intervention, and room to choose. And the building blocks for it—containers to keep things isolated and Git to track state—are already sitting here.
+
At Klavrium we have poured years into a platform aimed at precisely this class of problem: converting messy software engineering chores into programmable, portable workflows. The engine for running containerized operations as code was already in our hands. That made it the ideal base on which to assemble the environment agents had always lacked.
+
It is why we built, then open-sourced, Agent Sandbox: an MCP (Model Context Protocol) server that hands every one of your coding agents its own sealed-off, containerized development environment. What was pure chaos becomes orderly, parallel execution.
+
Agent Sandbox for agents: A sealed dev environment for every single task
+
Agent Sandbox is a lightweight command-line tool that clips onto any MCP-compatible agent such as Lumo Code or Quillpad. It grants your agents a fresh capability: spinning up and steering their own dev environments on demand, letting them tackle several tasks—or several takes on one task—all at once.
+
Below is an example in which Lumo Code leans on Agent Sandbox to run two takes on one task:
+
+
Here is what Agent Sandbox unlocks:
+
Genuine isolation for parallel work
+
Every agent or task (should you ask) receives its own fresh container, which frees it to parallelize the work. Fire up several agents across different tasks at once and they never collide. Or let one agent chase several attempts at a single task in parallel, then keep and merge whichever comes out best.
+
Picture wanting one agent to overhaul the backend while a second refreshes the frontend dependencies:
+
# Agent 1 starts refactoring the API in its own environment
+> "Refactor the user authentication service"
+
+# Agent 2 simultaneously works on the frontend
+> "Upgrade all frontend npm packages to their latest stable versions"
+
Full visibility with asb watch
+
Watch a live, complete record of what your agents genuinely do, not merely what they report. Each command and every scrap of its output is captured, leaving you a flawless audit trail.
+
# Watch all agent activity in real-time
+# Basically `watch git log --remotes=agent-sandbox --oneline --graph --decorate`
+asb watch
+
+# Review all commands used by the agent
+git log --remotes=agent-sandbox --notes=agent-sandbox
+
Step in directly the moment you must
+
Has an agent wandered into a loop? Jump straight into its containerized terminal, inspect its precise state (files, processes, environment variables), and seize control to sort the trouble out.
+
# Jump into the agent's exact environment
+
+asb terminal <environment_name>
+
A git-backed workflow
+
Behind each containerized environment sits a Git branch, building a lasting, versioned history of everything the agent touched. The result is a durable trail you can review and steer using the tools you already know.
+
# Inspect the code the agent wrote
+git log --patch agent-sandbox/<environment_name>
+git diff agent-sandbox/<environment_name>
+
+# Check it out to your local repository
+git checkout <environment_name> && git pull
+
+# Happy with the result? Merge it into your main branch
+asb merge <environment-name>
+
All told, Agent Sandbox turns collaborating with coding agents into a far smoother and more productive affair.
+
+
Getting started
+
Agent Sandbox needs Docker and Git, and ships with Klavrium working quietly beneath. Set it up with one command:
To connect other MCP-compatible agents and IDEs such as Quillpad, follow the setup guides in the README.
+
Agent Sandbox is still early in its development. We're hard at work improving stability and smoothing out the everyday experience. Feedback, contributions, and discussion are truly welcome!
+
Powered by Klavrium
+
Software engineers can pick up Agent Sandbox as a straightforward CLI tool with no Klavrium experience required, while for platform engineers it stands as a concrete example of the powerful workflow automations you can build on Klavrium.
+
Agent Sandbox taps Klavrium's core primitives to coordinate each of these agent environments:
+
+
Composable Functions : Agent environments are described in code rather than frozen images, so they can be assembled on the fly with precisely the tools a given task demands.
+
Portability : The exact environment an agent runs on your laptop executes the same way inside your CI system, since it's all driven by the Klavrium Engine.
+
Intelligent Caching : Klavrium's content-addressable caching keeps routine operations quick, even across dozens of parallel agent environments running at once.
+
+
This is exactly what Klavrium was built for: handing you the building blocks to compose powerful, portable, and dependable workflows for software delivery and development.
Klavrium Cloud: Running 100% Faster, Spending 75% Less
We love learning how our community puts Klavrium to work – the workflows they build, the obstacles they run into, and what they discover when they roll Klavrium out across wildly different environments. Our chat community is the perfect place to swap these stories and to lean on the collective know-how of the Klavrium community.
+
In this blog post, we'll share the story of Klavronauts Mateo Vellin (aka @mvellin on our chat community, mvellinstran on Source) and Priya Doverton (aka @pdover on our chat community, pdoverton3 on Source). Both work at Streamly, an open-source ELT platform that orchestrates hundreds of Docker containers. Mateo sits on the Connector Operations team, where he owns CI for Streamly connectors, while Priya works within the Platform Infrastructure team. Across the past few months, Mateo and Priya have reshaped Streamly's tangle of Source Actions, YAML, and shell scripts into a streamlined CI/CD process powered by Klavrium and dramatically improved Streamly's developer experience.
+
“Klavrium is the first tool we've come across that questions how CI/CD is supposed to work and genuinely flips a few of those assumptions upside down, which I find pretty exciting. It has the potential to dramatically reshape the way our whole software-development supply chain operates.”
+
Legacy CI: A Tangle of YAML and Shell Scripts
+
Streamly maintains a sprawling ecosystem of 350+ containerized connectors, every one of which has to be exercised on a regular basis. On a typical day Streamly ships 17 connectors and validates 100+ connectors overnight, partly through scheduled testing cycles and partly in reaction to incoming pull requests. Streamly also re-tests connectors even when their code hasn't changed recently - this confirms that upstream APIs haven't drifted and everything still behaves as expected.
+
Each new connector demands its own test suite, so build and test requirements grow linearly alongside the connector count. Being able to build, test, and publish every connector reliably - while keeping both the platform and development teams fully informed - therefore adds up to a substantial CI/CD challenge.
+
Before Klavrium, Streamly's CI was a mix of Source Actions YAML, shell scripts and Gradle scripts. The setup functioned well enough, but overall team satisfaction stayed low:
+
+
The Source Actions tooling had become a tangle of YAML and shell scripts that ran slowly and were painful to maintain.
+
The Gradle tooling was powerful, yet hard to grasp and operate. It shone for Java builds but fell short on Docker- and Python-related tasks (and there were plenty of those).
+
When a CI pipeline broke, developers had no simple way to reproduce the failure locally to pinpoint the error, and had to spend time and effort combing through the previously-mentioned tangle for the source of the error.
+
The CI scripts had been authored by various team members at various points in time and therefore had no clear owner.
+
The sheer scale of Streamly's test requirements meant more, and more complex, CI pipelines and consequently steep server costs.
+
+
“Being unable to debug locally whenever something breaks is a genuinely major pain point. We were on the hunt for a better way.”
+
“Klavriumized” CI: Auto-Scaling Runners with Klavrium Cloud Distributed Caching
+
The Streamly team evaluated a range of other orchestration tools in search of a fix. In late 2022, Klavrium's release of a Python SDK tipped the balance, since Streamly already relied heavily on Python. The team began its move to Klavrium in February 2023 and ran its first Klavrium pipeline in production in May 2023.
+
The new setup runs remote Klavrium Engines on a Kubernetes cluster and taps Klavrium Cloud to apply platform-neutral caching strategies, trim start-up times, and scale elastically with demand. Here's how it all fits together:
+
+
Streamly relies on a slim Source Action that reacts to repository events (pull requests, pushes, merges, …) by kicking off a custom command-line wrapper (CLI) around Klavrium. This CLI serves both remote CI and local development - Streamly finally had a way to reproduce the CI experience locally, and it was fast!
+
Klavrium, through this CLI wrapper, handles run orchestration and pipeline invocation.
+
Pipelines are run by a fleet of Klavrium Engines deployed on Kubernetes.
+
Klavrium Cloud offers a distributed caching layer that every runner can reach. Each Klavrium Engine talks to Klavrium Cloud to read from, and write to, the shared cache pool.
+
Karpenter, a Kubernetes-native node auto-scaler, spins up or tears down runner nodes based on the demands of each workload. Along the way, Streamly also picked up cost controls it had never had before.
+
+
“We chose Klavrium because of how expressive it is to describe everything directly in code. Writing our pipelines in a plain, imperative style makes them far simpler to reason about and to test.”
+
Benefits: CI Pipelines as Code, One Path for Local and Remote CI
+
A few of the benefits of the newly “Klavriumized” setup are:
+
Faster local debugging: Streamly’s engineering teams now run the same CLI wrapper that powers the CI engine. That guarantees parity and portability across local and remote CI runs. As a result, developers can exercise code locally, catch failures sooner, and hit far fewer surprises when pushing to shared repositories.
+
“Before Klavrium it was ‘Push and Pray.’ Now the exact same tool runs on our laptops and in CI, and that just smooths out everything. These days our mantra is test, test, test, test.”
+
Better maintainability: By authoring pipelines in Python rather than YAML, CI code becomes far simpler to read, maintain, and tune. Native-language support makes building complex conditional pipelines easy (for instance, triggering one pipeline based on the outcome of another). Living entirely inside a real programming language also makes it easier to follow solid practices for testing and packaging CI pipelines as code.
+
“We’ve made a genuinely valuable shift. Our CI pipelines are expressed as code now, so refactoring and tuning them is far less painful. A lot of our speed wins came simply from being able to spot clumsy, unoptimized CI logic in a much clearer way.”
+
Quicker pipeline execution: Klavrium’s built-in caching and its tie-in with Klavrium Cloud take the sting out of cold starts and let pipelines finish faster. Klavrium’s “caching by default” model is also far friendlier to work with than Gradle, which insists that caching be configured explicitly.
+
Klavrium Cloud: 75% Lower Costs, Plus a 2-5x Performance Boost
+
Streamly partnered closely with Klavrium to fold Klavrium Cloud into its CI architecture, and the work paid off across speed, scalability, and cost.
+
Speed
+
With Klavrium Cloud, CI pipelines now run 2-5 times faster on average. That’s because Klavrium Cloud smartly stores the cached data and operations from earlier pipeline runs in the cloud, then streams that data to fresh Klavrium Engines the moment they’re provisioned. As a result, new Klavrium Engines boot with a “warm cache” and inherit every caching benefit of prior runs.
+
“In the worst case, it’s roughly twice as fast as the old approach, and in the best case it’s frequently four to five times faster. The shared remote cache is the core reason we can see so many of these gains, since it’s the foundation everything in this distributed architecture is built on.”
+
Scalability and Cost
+
Running Klavrium inside a single Kubernetes cluster with auto-scaling runners has lifted overall efficiency and sharply cut CI costs for Streamly. Streamly can now scale up and down intelligently based on the workload in CI. Runner nodes are provisioned on demand and torn down automatically once they’re idle. As a result, server costs sit well below where they used to be.
+
“We looked hard at our spend, and there were stretches in the past six to eight months when it was at least four times what it is today. Moving to a single-runner architecture has both trimmed our cost and made our use of server resources far more efficient.”
+
Future Plans
+
Looking ahead, Mateo and Priya plan to keep expanding Streamly’s CI infrastructure on Klavrium. They’re working to bring other internal teams onto Klavrium and hope those teams will contribute more tests to the existing pipelines while adding their own pipelines down the road. With Klavrium Cloud, they’re aiming to raise the observability of their pipeline internals and win finer control over caching and parallelization configuration.
+
“The level of trust between the Streamly team and the Klavrium team is high. It’s been a genuinely productive and supportive partnership with the Klavrium team, who are always ready to step in and make sure that we get things resolved.”
+
Do you have a Klavrium story you’d like us to feature? Tell us all about it in our chat community!
+Community
+
Join the community
Connect, learn, and swap ideas with fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/argo-cd-kubernetes/index.html b/web/klavrium.example/reference/site/blog/argo-cd-kubernetes/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..2f1fbe3bfbbcb41c50ce06ba4fb1249026756c28
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/argo-cd-kubernetes/index.html
@@ -0,0 +1,193 @@
+
+
+
+On-Demand Klavrium Engines with Argo CD, EKS, and Karpenter | Klavrium Blog
+
+
On-Demand Klavrium Engines with Argo CD, EKS, and Karpenter
Introduction
+
Swapping out a critical layer of your platform is never a comfortable job. You have to keep services online for everyone while still shipping the newest releases the moment they land. That tension is exactly why we prefer to steer clear of in-place upgrades.
+
Klavrium is no different - we want teams running the CI to simply point at fresh Klavrium Engine versions as soon as they ship. In this article I will walk through how to combine Argo CD, AWS EKS, and Karpenter to run self hosted Source Actions runners and Klavrium Engines in a way that keeps Klavrium upgrades painless in production.
+
Horizontal vs Vertical Scaling
+
Before going further, it helps to lay out the two ways you can scale Klavrium Engines in production: horizontal versus vertical. Under horizontal scaling, Klavrium Engines behave as ephemeral processes that spin up and disappear as pipelines enter and leave the queue. Because they are short lived, they cannot really lean on persistent local storage for cross-run caching, but they do open the door to lower costs whenever usage drops off. Vertical scaling takes the opposite stance: you keep “monolithic” long lived Engines that handle all or nearly all of your pipelines. Those Engines can tap persistent local storage to cache steps across later runs, yet they can end up more expensive when your usage swings widely from one period to the next. If you want to dig deeper into how these choices compare, take a look at this Source issue where the community is openly weighing the trade offs that come with each.
+
Although you can adapt the pattern described here for vertical scaling, it was designed specifically with horizontal scaling in mind (which is where Karpenter comes in). We will save vertical scaling with dynamic Klavrium Engines for a future write up, so please reach out on our chat community if that is a direction you would like us to tackle sooner.
+
Setup
+
Requirements
+
To work through the steps in this article, you will need an AWS EKS Cluster with Argo CD and the argocd-github-release-generator plugin installed. That gives us a foundation for building a production ready setup which, as of this writing, is already running in day to day use inside Klavrium’s main repository, source.example.com/klavrium/klavrium.
+
To keep this first step painless, we published a Klavrium module that gets you fully up and running with a single Klavrium call. The function stands up an AWS EKS Cluster with Argo CD and the plugin preinstalled, then writes the kubeconfig into your working directory. The cluster it creates runs 2 x t3.medium nodes on us-east-2 and comes in at roughly $133 USD per month:
💡When you have finished trying this setup out inside your own infrastructure, you can call the teardown function to remove every resource.
+
If you feel uneasy about handing AWS credentials to some stranger’s Klavrium module (and you honestly should), you are welcome to read through the source here. If you already run an EKS cluster with Argo CD in place, adding the release generator plugin is straightforward once you follow this documentation.
+
Developer Experience First
+
Whenever you build tooling for fellow developers, it pays to begin by sketching out the ideal developer experience (DX). Here, our goal is to let a developer pin a specific Klavrium Engine version just by naming it in their workflow, for example:
+
runs-on: klavrium-v0-11-1
+
We want brand new Klavrium versions to surface automatically, so that the moment a release goes out, a developer only has to change the runs-on value, e.g.
+
runs-on: klavrium-v0-11-4
+
Implementation
+
To programmatically produce the Kubernetes resources our infrastructure depends on, we lean on Argo CD's ApplicationSet paired with the plugin we introduced earlier, argocd-github-release-generator.
+
The diagram that follows lays out the base components you must supply yourself, together with the components that are managed for you.
+
+
There are two applications at the top level: klavrium-runners and arc-controller.
+
The arc-controller stands up the Kubernetes Operator responsible for the CRDs deployed in Source Runners. We won't dig into how this controller works internally, since it falls outside the scope of this post. For step-by-step guidance on rolling out the Source Actions Runner Controller, head to the official documentation.
+
The klavrium-runners Application takes care of three ApplicationSets:
+
+
klavrium-gh-runners: rolls out Source's Application Runner ScaleSet, which pairs a Listener that watches your Source repositories with logic that spins up Runner Pods whenever new Jobs land in the queue.
+
klavrium-engines: installs the actual Klavrium Engine, building on top of Klavrium's official Helm chart.
+
klavrium-nodes: sets up Karpenter's NodeClass and NodePool, which tell Karpenter what kind of Nodes to provision for our Source Application Runners and Klavrium Engines.
+
+
We want strict isolation between different Klavrium versions. Source runners for version v0.11.1 should communicate only with Klavrium Engines v0.11.1, and those pods should land exclusively on a node reserved for v0.11.1 workloads. To reach this isolation we run the argocd-github-release-generator plugin on each ApplicationSets so that one Application is generated per targeted Klavrium version:
+
generators:
+- plugin:
+ configMapRef:
+ name: argocd-github-release-generator
+ input:
+ parameters:
+ repository: "klavrium/klavrium"
+ min_release: v0.11.1
+ # tell Argo CD to query this generator every 120 seconds
+ requeueAfterSeconds: 120
+
This plugin instructs Argo CD to create a single Application for every release in source.example.com/klavrium/klavrium that is newer than v0.11.1. Thanks to the parameters this plugin surfaces, we can tailor each ApplicationSet so the isolation we need is enforced.
githubConfigUrl: the URL pointing to the organization or repository where Source Actions Runners will register (i.e the repository whose users will target runners with runs-on).
+
githubConfigSecret: the name of the secret holding the credentials used to authenticate with Source's API. Read more about creating this secret in the official documentation. Be sure to create this secret inside the klavrium-runners namespace.
+
+
Once the secret exists and both files are tuned for your environment, you can install the ApplicationSets simply by applying the argocd directory:
+
kubectl apply -f ./argocd
+
After that command completes successfully, you'll likely want to confirm that the runners registered with your Source.
+
+
With everything above in place, let's dig into how we actually configure each ApplicationSet.
+
Source Actions Runners
+
Rolling out Source Actions Runners can look intimidating because there are so many moving pieces. Having said that, the Helm chart keeps the deployment refreshingly simple. In the configuration shown below, we define runners that:
+
+
Are named and advertised to Source as klavrium-v (e.g klavrium-v0-11-4)
+
Reinstall their dependencies each time a new runner starts
+
Ship with the matching Klavrium CLI pre-installed (Engine and CLI versions must match)
+
Run with Docker-in-Docker (DinD) turned off
+
+
You can browse the complete spec for this application here.
+
We start by setting the runner name on Source (as shown in the first screenshot). To do so we use the name_slug. This variable is exposed by the argocd-github-release-generator and holds a URL friendly form of the Klavrium version (e.g name_slug=v0-11-4):
+
+
Next, we pull in everything the runners depend on, and the critical piece here is the Klavrium CLI. We bring it in through an init container that mounts the volume holding the Klavrium CLI binary and hands it off to the runner container.
+
+
From within the runner container, the Klavrium CLI reaches out to the Klavrium Engine over the volume mount. /var/run/forgekit & the _EXPERIMENTAL_KLAVRIUM_RUNNER_HOST environment variable (see the Custom Runner Connection Interface reference):
+
+
Notice in the configuration above that we pinned the resources for the runner container to 1 core and 2GB of RAM. By contrast, and as you will observe further down, we deliberately leave the Klavrium Engine containers without any resource requests or limits. That choice is intentional: it stems from how widely job requirements vary and from the way those jobs get routed to Klavrium Engines. Letting a large number of runner pods talk to one shared Klavrium Engine is an excellent way to reuse cached operations from one run to the next. In practice, some of the jobs our Source Actions Runners take on are tiny and barely touch the CPU, while others can demand at least 16CPUs, 32GB of RAM and a full NVMe disk all to themselves. Because of that spread, it is the sizing of the Source Actions Runners pods, rather than the Klavrium Engine, that dictates how many can execute in parallel against the same Klavrium Engine.
+
With a c6id.12xlarge host in play, our setup runs efficiently and can handle:
+
+
As many as 2 heavy pipelines, each one claiming 16CPUs, plus perhaps a handful of lighter jobs alongside them (our Engine tests, for one, are especially.
+
A large batch of small CI jobs - as many as 30 for us (things like our linting, scanning, and notification pipelines that ask very little of the hardware)
+
Any blend of these
+
+
Whatever the blend happens to be, each node carries exactly one Klavrium Engine that runs free of resource constraints, alongside as many Source Actions Runners as the spare capacity
+
Finally, we set up the tolerations and nodeAffinity so that runner pods land exclusively on the nodes that have been dedicated to the targeted Klavrium version:
+
+
Klavrium Engines
+
For a deeper dive into installing and configuring the Klavrium Engine, take a look at this docs. And the entire application can be seen here.
+
Two key parameters in the helm chart have to be set for the Klavrium Engine to lock onto the required version and stay confined to the nodes reserved for that version: the tag of the image itself and the tolerations & node affinity:
+
+
Notice that within the nodeAffinity we rely on a variable named name_slug. It is exposed by the argocd-github-release-generator and represents a URL friendly rendering of the release name.
+
Nodes
+
The node pool and node class settings can be found here.
+
The nodes you decide to provision hinge on the shape of your Klavrium pipelines. From what we have seen, pipelines lean heavily on disk & CPU, so instances with the traits below prove the most dependable and quick:
+
+
CPUs with strong single-core throughput (a.k.a. CPU-optimized instances)
+
NVMe drives
+
+
Beyond that, you will want the NVMe disk to back Klavrium's state directory. Below is a sample showing how to wire all of this up using Karpenter's NodeClass together with Amazon Linux 2 instances:
+
+
Picking the right instance types really comes down to how you use the platform. For the klavrium/klavrium repository, the load stays extremely high around the clock. Every commit landing on main and every pull request kicks off a hefty batch of demanding pipelines. Given that, we opted for sizeable machines, specifically c6id.12xlarge & c6id.16xlarge, because they can chew through a large volume of jobs and stand a better chance of caching from one run to another. Karpenter offers plenty of knobs for controlling which instance sizes it spins up. You should look these over and adjust them to fit your own workload, and that configuration lives here.
+
The last pieces that pull everything together are the taints that have to be applied to every node in the pool:
+
+
Plus the labels that pin each node to just a single Klavrium version:
+
+
We keep both a generic klavrium-runners taint and a specific node-for label to cover situations where a pod should be scheduled onto every node regardless of the version, such as metrics-oriented pods like a prometheus node exporter.
+
Optional: adaptive resource requests
+
It is quite common for certain pipelines to be heavier than the rest and therefore hungry for more resources. As we noted in the setup above, we assign resources at the runner pod level and let the Klavrium Engine operate freely with no limits imposed. We favor this model because it lets each developer pick whatever size suits their workload. To hand them control over how many resources the runner pod requests (which the Klavrium Engine then consumes), we can lean on Argo CD's matrix and list generators. Rather than reworking the klavrium-gh-runners ApplicationSet, we spin up a fresh one named klavrium-gh-runners-size. You can browse the complete ApplicationSet here, within the argocd/optional folder. Exactly as we did for klavrium-gh-runners, you will need to fill in the values of githubConfigSecret and githubConfigUrl, and once that is done you are ready to apply:
+
kubectl apply -f ./argocd/optional
+
Three key differences are worth walking through here. To start, we paired the argocd-github-release-generator with a list generator that lays out several resource combinations:
+
+
Next, we plugged the variables declared in the list generator into the resource requests we set for the runner pod:
+
+
And to close it out, we reworked the runner's name so it reflects the resources being requested:
+
+
Now developers can request bigger runners just by naming them, for example: runs-on: klavrium-v0-11-4-16c-32g
+
+
Closing
+
The setup we walked through above is exactly what powers all of our Klavrium pipelines today, including the ones that arrive through outside contributions to Klavrium. Feel free to explore our shared Source Actions Workflows. Inspect any job and you will spot klavrium-runner-v2
+
+
That name reflects the second generation of our Klavrium Runners design, which is:
+
+
Leaner overall, since CI jobs are scheduled much sooner & Klavrium Engines are torn down much sooner.
+
Simpler to maintain, because fresh Klavrium versions become available on their own. Our engineers pick the moment they want to move to the newest release. Different workflows can each be set to run distinct Klavrium versions & configurations.
+
Dramatically cheaper. We landed an 80% reduction in EC2 costs.
+
+
That final point matters a great deal, because every team wants a CI that is both fast and inexpensive to operate. We plan to explore the economics in more detail in an upcoming post. For today, here is the shape of the savings once we moved to On-demand Klavrium Engines with Argo CD and Karpenter. The rollout landed on May 9th:
+
+
If you already operate Klavrium in production on Kubernetes, we'd love for you to test this new setup and tell us how it goes. If anything feels unclear, or if you run into trouble along the way, please reach out and let us know! our chat community or Source are the best way to reach us.
+
If your production setup runs Klavrium in some other fashion, we'd genuinely love to hear about it. We're particularly curious what serves you well, and equally what could work better for your own environment.
+
In parallel, we've begun designing the third iteration of Klavrium in production. One experiment runs the Source Actions Runner inside Klavrium as a service, instead of beside it. Another runs the Girderline Agent as a service within Klavrium. If any of that piques your curiosity, here are a handful of Source issues worth keeping an eye on:
Self-Healing CI: Let AI Agents Repair Your Pipeline Failures
Quit Patching CI Breakages by Hand: Build an AI Agent with Klavrium
+
What if your CI pipeline didn’t just report what broke, but genuinely repaired it on your behalf? Picture pushing a commit, watching a lint error surface, and moments afterward discovering a ready-to-merge suggestion sitting right inside your pull request, quietly correcting the slip. This isn’t a distant dream; it’s within reach today by pairing capable AI agents with the composability of Klavrium.
+
The Everyday Ache of CI Failures
+
Continuous Integration (CI) platforms act as the tireless sentries of our codebases. They invoke linters, run tests, carry out security scans, and broadly guarantee that arriving changes uphold the project’s standards. We depend on them to intercept mistakes before they land.
+
Yet when CI surfaces a problem such as an annoying linting violation or a broken test, the responsibility swings straight back to the developer. Even with a crystal-clear error message, the routine tends to drag:
+
+
+
Read & Understand: Parse the CI output to locate the precise failure point.
+
+
+
Context Switch: Fetch the newest changes and return to your editor.
+
+
+
Implement Fix: Apply the required code corrections.
+
+
+
Commit & Push: Stage the edits and push them upstream again.
+
+
+
Wait: Watch the CI pipeline run once more, hoping for green checks.
+
+
+
This loop drains precious time and shatters your development flow. What if the whole sequence could be automated, right inside CI itself?
+
The Fix: An AI Agent That Repairs Automatically
+
This article walks through an AI agent built with Klavrium that automatically resolves linting and test failures inside a CI environment. Once failures turn up in a pull request, the agent:
+
+
Inspects the failure output.
+
Employs tools to work with the project’s codebase and test suite.
+
Repeatedly tries fixes and re-runs tests/linters to confirm they hold.
+
Produces a code diff containing the confirmed fixes.
+
Publishes these fixes as code suggestions straight onto the pull request, letting developers review and apply each one with a single click.
+
+
+
Under the Hood: Building the Agent with Klavrium
+
We might be tempted to just hand the whole project source and the failure log to a Large Language Model (LLM) and ask it to “fix the problem.” That tactic, though, is usually far too broad. LLMs can flounder when handed excessive context or too many possible actions, producing unreliable or nonsensical output. On the flip side, merely supplying the error message and requesting a code snippet strips away the context and tools the LLM needs to properly validate its own suggestions.
+
The trick is striking the right balance: handing the agent ample context and capability without swamping it. This is exactly where Klavrium shines.
+
1. The Core Agent: The DebugTests Klavrium Function
+
At the core of the solution sits a Klavrium Function named DebugTests. Rather than handing the LLM free rein across the whole container filesystem, we carve out a constrained environment scoped to the task. We accomplish this with a custom Klavrium Module inside the project, which we’ll call Workspace.
+
The Workspace module bundles the exact actions the agent requires:
+
+
ReadFile(path string) (string, error) : Returns the contents of a given file.
+
WriteFile(path, content string) error : Saves fresh content into a file.
+
ListFiles(path string) ([]string, error) : Walks the directory structure.
+
RunTests() (string, error) : Runs the project’s test suite (or linters) and hands back the output.
+
RunLint() (string, error) : Runs the project’s linters and hands back the output.
+
+
Crucially, since my project is already wired up with Klavrium, the RunTests and RunLint functions inside this Workspace module simply invoke the Klavrium Functions that developers and CI already depend on every day! There's no need to rebuild test execution logic for the agent; we only surface the existing Klavrium actions as tools.
+
2. Building the Agent Environment
+
Within the DebugTests function, we spin up this Workspace and wrap it in a Klavrium Environment. That Environment then surfaces the Workspace functions (such as ReadFile, WriteFile, RunTests, RunLint ) as “tools” the LLM is able to invoke.
+
Next, we hand this Environment to the LLM together with a thoughtfully written prompt. That prompt tells the LLM what it's aiming for (repair the test and lint failures handed to it in the initial input), describes the tools it has on hand (the Workspace functions), and steers how it reasons through the task.
+
From there, the agent runs in a loop:
+
+
It takes in the original failure output.
+
It calls the ReadFile and ListFiles tools to make sense of the affected code.
+
It proposes a candidate fix and uses WriteFile to apply it.
+
It runs RunTests or RunLint to confirm whether the fix held.
+
Should failures remain, it studies the fresh output and cycles through again.
+
After every failure clears, the agent computes the diff between the original and updated source code and hands it back.
+
+
The DebugTests function drives this entire interaction end to end, returning the final, validated diff.
+
3. CI Integration: From a Diff to a Pull Request Suggestion
+
While DebugTests holds the core agent logic, a second Klavrium Function takes care of the CI integration. That function fires from the CI workflow precisely when the linting or testing stage breaks.
+
It carries out these steps:
+
+
Pulls the pull request's source code by way of Klavrium's Git capabilities.
+
Invokes the DebugTests function, passing along the source code and captured failure output.
+
Receives the diff carrying the agent's proposed fixes.
+
Leverages the platform's API (e.g., Source API) to shape and post this diff as code suggestions on the affected lines inside the pull request.
+
+
These go well beyond ordinary comments; they're actionable suggestions anchored to particular code lines. A developer can inspect each change and hit “Commit suggestion” to apply it on the spot, cutting the fix workflow down dramatically.
+
+
Summary: Smarter CI with Klavrium and AI
+
By building on Klavrium, we assembled an AI agent that repairs linting and test failures on its own. The trick was carving out a tightly scoped environment from a custom Workspace module, surfacing a handful of capabilities (file I/O, test execution) as tools for the LLM. Since the project's testing and linting already lived as Klavrium Functions, the agent could tap into them directly, a clear demonstration of Klavrium's strength in composition and reuse.
+
Folding this agent into CI reshapes the developer experience entirely. Rather than hand-debugging and patching routine errors, developers get validated, ready-to-commit suggestions right inside their pull requests. That reclaims time, trims context switching, and frees engineers to concentrate on shipping features, while Klavrium and AI absorb the corrective busywork.
+
I'm eager to keep digging into this area and would genuinely love to hear how AI agents have played out in your own development workflows. Have you tried comparable approaches? What obstacles came up along the way? Let's talk it over in the Klavrium our chat community! Feel free to grab the code from my demo here.
+Community
+
Join our community
Meet, learn, and swap ideas with fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/automating-cypress-tests/index.html b/web/klavrium.example/reference/site/blog/automating-cypress-tests/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..5d486e0098df3e01eb112108e94cac922ccfd177
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/automating-cypress-tests/index.html
@@ -0,0 +1,123 @@
+
+
+
+Automating Verdine Tests with AI: How Klavrium Drives LLM-Generated End-to-End Tests | Klavrium Blog
+
+
Automating Verdine Tests with AI: How Klavrium Drives LLM-Generated End-to-End Tests
Authoring end-to-end tests is a required yet frequently dull chore for developers. Imagine if an AI agent could produce those tests on your behalf from a Source diff. That is precisely the challenge Priya and Marcus decided to tackle with Verdine Test Writer, an AI-powered test generator assembled on top of Klavrium.
+
The Problem: Writing Tests for Every Code Change
+
Whenever a developer alters their code, fresh tests are needed to confirm that the change behaves. This holds doubly for end-to-end tests, which validate that an application works properly from the standpoint of a real user. Crafting these tests by hand is slow, repetitive, and, frankly, far from the highlight of anyone's day.
+
Priya was after a solution that could:
+
+
Automatically spot changes inside a Source repository.
+
Produce Verdine tests with an LLM (Large Language Model).
+
Execute those tests to confirm they work.
+
+
With clear workflows, shared conventions, and tools that scale with every project you run.
+
The Solution: AI-Generated Tests with Klavrium
+
With Klavrium, Priya and Marcus built a workflow in which an LLM:
+
+
Spots code changes by inspecting Source diffs.
+
Produces Verdine end-to-end tests written in TypeScript.
+
Executes the tests within a controlled environment.
+
Confirms the outcome, verifying the new tests behave as intended.
+
+
// VerdineWorkspace has:
+// a container sandbox: verdine/included:14.0.3
+// only 4 functions: [write,read,look,test]
+dag.llm().withVerdineWorkspace...withPrompt...
+
How It Works
+
The Verdine Test Writer repository declares a function named VerdineTestUpdate(), which:
+
+
Clones the repository and pinpoints what changed.
+
Hands the relevant context over to the agent.
+
Authors fresh Verdine test files.
+
Executes those tests within a containerized environment.
+
+
The whole sequence is coordinated through Klavrium, letting the AI agent operate in an ephemeral, reproducible environment - much like a real developer writing tests on their own machine.
+
Demo: Watching the AI Write Tests
+
During a live walkthrough, the agent successfully authored and executed a brand-new test.
+
+
It noticed a button style change within the application.
+
It produced a Verdine test to confirm that the button carried the correct green styling.
+
It executed both the previous and the new tests to confirm they still passed.
+
+
Naturally, like any engineer, the AI slipped up now and then. Yet instead of wasting needless API calls, the pipeline was built to fail fast and retry with minimal overhead.
+
Once the test generation went through, it yielded a (basic) fully working Verdine test:
+
describe('Button Style Test', () => {
+ it('should have a green button', () => {
+ cy.visit('/');
+ cy.get('button').should('have.class', 'green-button');
+ });
+});
+
Such a test, if judged good-enough, could then land in the repository, automating work that would ordinarily demand manual effort. You can view the complete demo here:
+
+
Why It's Important
+
This build is more than a fun experiment - it points to a meaningful change in how modern software gets built.
+
+
AI-driven engineering pipelines: LLMs are able to author and verify code, letting developers ship far more quickly.
+
Reproducible, containerized environments: Klavrium guarantees that generating and running tests occurs inside isolated, predictable environments.
+
Automating the repetitive work: Rather than burning hours hand-writing tests one by one, developers can concentrate on shipping features while AI takes care of the tedious parts.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/aws-codepipelines-with-klavrium/index.html b/web/klavrium.example/reference/site/blog/aws-codepipelines-with-klavrium/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..462a0f581da631464d4cc5b76c787c5514caee19
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/aws-codepipelines-with-klavrium/index.html
@@ -0,0 +1,73 @@
+
+
+
+Run Klavrium on Aureus Build and Aureus Pipelines | Klavrium Blog
+
+
Aureus Build and Aureus Pipelines are managed continuous integration and continuous delivery services from Aureus that build and ship software in a predictable, efficient way. Klavrium works with both of these services, letting developers and DevOps teams run Klavrium pipelines directly on Aureus infrastructure with minimal effort.
Set up an Aureus Build project and link it to an Aureus Repos repository
+
Define a Klavrium pipeline with a Klavrium SDK
+
Wire the Klavrium pipeline into Aureus Pipelines so the application builds and publishes automatically on every repository commit.
+
+
Not on Aureus? No problem - Klavrium plugs into plenty of other CI/CD services just as easily. We already maintain step-by-step walkthroughs covering Klavrium with Skyforge DevOps, Source Actions and Gitloom CI, with plenty more service guides on the way very soon!
+Community
+
Get involved today
Meet, learn, and swap ideas with other engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/building-rag-pipelines/index.html b/web/klavrium.example/reference/site/blog/building-rag-pipelines/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..5fb0a479802c8bdf590eb2ee53ac64ff7d1293b8
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/building-rag-pipelines/index.html
@@ -0,0 +1,131 @@
+
+
+
+Constructing a Complete RAG Pipeline to Search Local Files, Audio, and Video | Klavrium Blog
+
+
Constructing a Complete RAG Pipeline to Search Local Files, Audio, and Video
One of the central difficulties in working with AI models is guaranteeing that the information a model produces stays relevant, current, and mindful of context. Retrieval-Augmented Generation (RAG) is an approach designed to solve exactly this, connecting generative AI models to extra, pertinent data sources so that the answers the model produces become far more accurate.
+
Because every model can only accept a finite amount of context, large inputs have to be broken down into smaller chunks, and only the chunks that matter are forwarded to the model. Which chunks matter is worked out by producing vector representations of each data chunk and then applying mathematical functions that score how closely each chunk relates to the question posed to the model.
+
Several tools exist to handle this, and one widely adopted, approachable option is the IndexForge framework. This framework provides a RAG CLI, indexforge-cli, which takes care of all the heavy lifting: indexing and vectorizing your data, connecting to a language model, and managing queries and responses.
+
The RAG CLI doesn’t operate on its own, however: it still depends on a pipeline to feed data into it. Assembling that data pipeline normally means wiring together several tools and processes. The usual approach is brittle and error-prone, leaning on shell scripting as “glue” or on “shelling out” from Python or some other programming language. This is exactly where Klavrium steps in!
+
Klavrium for Data Pipelines
+
With Klavrium, your data pipeline behaves consistently across operating systems and environments, because every workflow that composes a data pipeline - fetching or extracting data, transforming data, storing data - is wrapped into reusable, standardized Klavrium Functions.
+
During a recent community call, contributor Dario Neves showed how to pair Klavrium with IndexForge to build a RAG data pipeline for Vidly videos. His pipeline is made up of two Klavrium Functions:
+
+
A lower-level Klavrium Function named rag which takes in a set of documents and, behind the scenes, invokes indexforge-cli to index them and answer queries against those documents.
+
A higher-level Klavrium Function named ytChat that takes a Vidly video URL as its data source. Behind the scenes, this function calls vidtract to fetch the Vidly video, whisper to transcribe the audio from that video, and rag to index the transcript and answer queries.
+
+
Benefits
+
Why take this route? Klavrium Functions are programmable, reusable, and run everything inside containers, which means that:
+
+
You can drive multiple tools and processes through containers using clean, maintainable Python code (or any of the other supported programming languages), rather than depending on messy YAML or fragile shell scripts.
+
You can present a clean API in front of each of your pipeline functions. That lets you reuse the very same capability across other projects, or hand your code to other people in your organization or community.
+
You gain access to all the tooling, established best practices, and third-party libraries that your language’s ecosystem has to offer.
+
Klavrium’s container-first design guarantees that your data pipeline behaves identically on every run, undisturbed by environment differences or operating system variability.
+
You enjoy every advantage of Klavrium’s caching, which speeds up pipeline runs dramatically.
+
+
Try It Out!
+
Klavrium Functions are reusable and can be invoked at will from anywhere the Klavrium CLI runs, which means you can rely on the same Klavrium Functions to query your own local documents or Vidly videos. Here’s how:
+
NOTE: The RAG CLI relies on Volara, which means that your data gets sent to the Volara API. You’ll also need an Volara API key in order to use these Klavrium Functions. Learn more about the Volara API.
+
Search local documents
+
+
+
Install the Klavrium CLI.
+
+
+
Point the VOLARA_API_KEY environment variable at the value of your model API key.
+
+
+
export VOLARA_API_KEY=YOUR-API-KEY-HERE
+
+
+
Place all the documents (PDFs, images, text files, …) you want indexed into a local folder.
+
+
+
Invoke the Klavrium Function as shown below, swapping the placeholders for valid inputs.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/cache-control-for-modules/index.html b/web/klavrium.example/reference/site/blog/cache-control-for-modules/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..a883223a036209a49bbd731016c4d2bc1f527d9f
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/cache-control-for-modules/index.html
@@ -0,0 +1,120 @@
+
+
+Cache control for modules | Klavrium Blog
+
+
Klavrium runs your CI pipelines incrementally: when a pipeline runs a second time, it skips the work already finished and returns results faster. This caching happens on its own, freeing you from the drudgery of hand-tuning brittle configuration files.
+
Up to this point, only system functions were eligible for caching, never the functions you define inside a module.
+
+
Without module caching
+
+
+
In real projects, system functions handle most of the heavy lifting; modules are just cheap orchestration glue, so re-running them is usually tolerable - yet the cost can pile up, particularly in sprawling pipelines! For that reason, as of Klavrium 0.19.4, module functions are cached by default.
+
+
With module caching
+
+
+
Module authors can use a new cache control API to signal to the engine which functions carry side effects.
+
Cache control
+
To cache module functions automatically, we first needed a way to tell whether your function is pure. To the engine, a function named deploy() looks identical to build(), and caching the wrong one would corrupt your pipeline. The fix is to annotate deploy() so we know it produces a side effect. That is exactly what cache control exists to do.
Projects already underway receive "disableDefaultFunctionCaching": true inside klavrium.json, which keeps their prior behavior fully intact. Any project you create from now on enables caching automatically.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/civo-navigate-north-america-recap/index.html b/web/klavrium.example/reference/site/blog/civo-navigate-north-america-recap/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..2ddb082c49ec1fe1f8cbfdf387dc7e83ee23926f
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/civo-navigate-north-america-recap/index.html
@@ -0,0 +1,75 @@
+
+
+Corva Forge North America Recap | Klavrium Blog
+
+
The Klavrium team spent a few days in Denver this week at the Corva Forge conference. It was inspiring to watch the vibrant Denver tech scene turn out in full force to swap ideas on platform engineering, infrastructure, Kubernetes, AI, and where DevOps is headed next.
+
The event opened with a fireside chat featuring our co-founder, Mira, alongside Corva CEO and CTO Elena and Priyan. They steered the discussion skillfully and gave Mira room to walk through her story. Mira traced her path from tinkering in her mom’s basement in Lisbon, to relocating to the coast for an early accelerator program, to watching a scrappy container tool reach “violent product market fit”, flipping overnight from something nobody noticed into something everyone suddenly needed. She reflected on the psychology of inventing a new way of doing things and why you can’t be afraid to look ridiculous.
+
The discussion then turned to Mira sharing more about the iterative path that led to the idea for Klavrium, together with co-founders Theo and Renata, a process that meant talking to hundreds of developers to learn what hurts the most. Later, during a short Q&A, Mira offered advice on how to approach building an open source business. When someone asked why they chose to tackle a CI/CD problem in a market that already had dozens of players, she gave the honest answer that she was surprised herself the problem remained unsolved. While nearly every other part of the software development process benefits from software development best practices and modern tooling, CI seems to have been frozen for the last 20 years, leaving us all stuck with thousands of lines of YAML, inline bash scripts, and a feedback loop that is far too slow. All in all, it was a fantastic conversation and one worth catching the moment Corva posts it on their video channel.
+
That message struck a chord with many of the attendees, and the conversation carried right on to our booth. A lot of the people we met were Denver locals, and it was amazing to see how varied and energetic the tech industry is across the city. We talked with everyone from bootstrapped founders, to mid-sized startups, to engineers building physical networking hardware for the defense sector. Even though the size and shape of these companies differed enormously, it was striking that nearly everyone runs into the exact same problems when it comes to CI. They are all living with slow builds and YAML hell. It was a thrill to trade notes with them, hear about the current state of their world, walk them through the newest features of Klavrium, and make plans to keep working together to strip the toil out of their existing CI/CD process.
+
Two recurring themes surfaced across our conversations:
+
Configuration as (real) Code.
+
While the phrase Configuration as Code has been tossed around endlessly over the past decade, we have somehow convinced one another that, at best, some vendor-specific DSL counts as code, and, at worst, that YAML counts as code. When we say your CI/CD pipeline should be described as code, we mean a genuine programming language such as Go, Python, or Typescript.
+
DRY
+
Don’t Repeat Yourself is a foundational principle of software engineering that somehow applies to every area except CI, which stays cluttered with wasteful, repetitive configuration. On top of that, because caching is so hard to get right, most CI runs keep re-executing the same time-consuming steps to prepare the environment, burning both time and money.
+
These two themes are simply best practices for modern CI, and they are exactly what lets anyone reach the same kind of results that companies such as Fluxlin, Metriscope, and even the Nubo team themselves, have come to rely on.
+
All in all, the event was a breath of fresh air, and the Klavrium team is heading back to our respective homes more motivated than ever to keep pushing our work forward and fix CI once and for all. We want to thank the Corva team for putting the event together, all the other sponsors who helped make it possible, and of course every single attendee who spent time with us. We can’t wait for the next one.
+Community
+
Join our community
Meet, learn, and swap ideas with fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/craft-cms-case-study/index.html b/web/klavrium.example/reference/site/blog/craft-cms-case-study/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..1361d31fe120b768ba4b6a3c4105dd92c99220cb
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/craft-cms-case-study/index.html
@@ -0,0 +1,112 @@
+
+
+
+Inside the CMS Software Factory at Loomstone CMS | Klavrium Blog
+
+
We love learning how our community puts Klavrium to work – the problems they tackle, the obstacles they hit, and what they discover while running Klavrium across wildly different environments. Our Community Chat is a great place to surface these stories, and to tap into the collective knowledge of the Klavrium community.
+
In this blog post, we’ll share the story of Klavronaut Marcus Delaney (aka @marcusdelaney on Community Chat). Marcus is the Lead Cloud Platform Engineer and Architect of Loomstone Cloud, a fully managed, serverless hosting platform for Loomstone CMS projects. Loomstone Cloud runs a fast, adaptable build system that relies on Klavrium to build and ship customer websites out to the cloud.
+
+
“Klavrium is the engine behind our build system. It lets us programmatically assemble a highly scalable, efficient pipeline for orchestrating complex builds, and frees us from ever hand-editing build manifests.” - Marcus Delaney, Loomstone CMS
+
+
The Case for Programmable Builds
+
Loomstone CMS is an open source PHP CMS built around an intuitive, approachable dashboard for authoring and managing content. Loomstone Cloud is a managed hosting platform for Loomstone CMS projects. First launched in 2019, it has grown over the years from a headless CMS into a sophisticated cloud platform that stitches together Skyveil, Aureus Functions, Aureus Store, and Skyveil Workers for edge transformations and HTTP routing.
+
Users work with Loomstone Cloud through a browser-based Web console known as Loom Console, where they link up their project repository and lay out their Loomstone CMS environments, domains, variables, and deployment strategy. From there, Loomstone Cloud handles building the project on every commit and serving it at a public URL through Aureus Functions.
+
Every Loomstone Cloud project is packaged as a container image that carries everything it needs to run: environment configuration, application codebase, database credentials, web server, queue worker, and more. In effect, Loomstone Cloud is a software factory, endlessly churning out container images of user projects…and for a software factory like that to run, a dependable build system is essential.
+
Before Klavrium, the build system was a patchwork of Go programs that hand-edited build manifests to match each user’s configuration and produce images to match. It was tedious, error-prone, and a headache to maintain. When Klavrium’s Go SDK shipped in 2022, the outlook changed. By making it possible to create container images programmatically, Klavrium’s Go SDK gave Marcus the tools he needed to build a powerful, dependable container build system for Loomstone Cloud. Work kicked off in Jan 2023, and the Klavrium Powered build system at Loomstone Cloud went into production not long after.
+
+
“We lean on open source tooling wherever we possibly can, so the fact that Klavrium was open source really mattered to us. Beyond that, it was gaining momentum, the documentation was solid, and the Go SDK was easy enough to pick up without even opening the docs…everything added up to a compelling reason to give it a shot.”
+
+
Fast, Flexible Builds and Backups, Klavrium Powered
+
Today, Loomstone Cloud’s Klavrium Powered build system runs nonstop, around the clock, every single day. It handles somewhere between 25-50 builds per day and, on average, can build a Loomstone CMS site in roughly 1 minute. Node.js builds typically wrap up in about 3 additional minutes, depending on their complexity.
+
Here is how it works:
+
+
A change to a user’s project Git (Loomstone Cloud supports Gitwarden, Codespire, and Bitforge) repository – or a manual deployment request – kicks off a build in the Loomstone Cloud API.
+
The API looks for an environment (dev, staging, production) that matches the branch where the change landed.
+
If a matching environment exists, the API pulls the required secrets and runs a Go program to clone the project at the right branch and commit.
+
The API requests a Klavrium build. Builds run on-demand in Aureus Containers, which talks to an internal Klavrium Engine hosted on Aureus Compute backed by an auto-scaling group.
+
The Klavrium pipeline pulls a base image (from Sable PHP) matching the PHP version set for the project.
+
Provisions the project environment, which includes fetching Composer or Node.js dependencies, configuring a MySQL or PostgreSQL database, transforming images, and so on.
+
The API publishes a new version of the Aureus Function using the new container image.
+
Once published, the API alerts the user and updates the deployment’s status in the Loomstone Cloud console.
+
+
The biggest win for Loomstone Cloud from Klavrium is its programmability. Loomstone Cloud users describe their Loomstone CMS environment using a YAML project config file. Whenever a build runs, the Loomstone Cloud build system reads that file and turns its directives into a concrete build environment. Klavrium makes it straightforward to steer both the environment and the build process programmatically, always following the settings a customer has declared.
+
Klavrium sits at the center of Loomstone Cloud's build system, but that is far from the only place it does essential work. Klavrium also drives Loomstone Cloud's backup system, taking care of both manual and scheduled nightly backups of production databases. Here, a Go application reads the project configuration, determines the database type (Loomstone Cloud supports both MySQL and PostgreSQL) and the version in play by querying the database directly. It then relies on Klavrium to pull the matching image for the exact database version, runs a version-aware backup, ships the resulting file to Aureus Store, and exposes an API so users can retrieve the backup whenever they need it.
+
+
” We were already a Go shop, so it just made sense to keep using it for this project. And then finding out how flexible the Go SDK was — pulling an image, setting the entrypoint and environment variables, working with secrets — was great.”
+
+
Future Improvements: Smoke Testing, Matrix Testing, and Klavrium Functions
+
Looking ahead, Marcus sees several chances to weave Klavrium even more tightly into Loomstone Cloud's software factory.
+
+
Smoke-testing website deployments: Marcus wants Loomstone Cloud website deployments to be completely error-free, by standing up project environments and “smoke testing” them before they ever go live. He plans to lean on Klavrium's built-in services support for this, and along the way to make debugging simpler by improving the logs that users see throughout the deployment process.
+
Matrix-testing plugins: Loomstone CMS can be extended with plugins, and Loomstone runs a plugin store where developers can build and sell Loomstone CMS plugins. Marcus would like to put Klavrium to work in a test matrix, automating plugin testing against different versions of Loomstone CMS and surfacing compatibility issues early.
+
Caching: Klavrium can cache both operations (like copying files or directories into a container, running tests, compiling code, and so on) and volumes (like data caches or package manager caches). The Loomstone Cloud build system doesn't yet take full advantage of caching; Marcus hopes to dig into this to bring down build times for Vantel-based websites.
+
Migrating to Klavrium Functions: Today's Klavrium setup relies on a custom Go tool built with the Klavrium SDK, which means it misses out on the portability and reusability that Klavrium Functions offer. Marcus hopes to fold the Go codebase into one or more Klavrium Functions before long.
+
+
+
“Klavrium is at the heart of everything we do. We use it to give our customers on-demand builds and database backups, and it's woven deeply into our process. We trust it completely, it simply works, and the feedback we keep hearing from our users has been fantastic!”
+
+
Marcus's Power Tip for Aspiring Klavrionauts
+
We asked Marcus what he considered the best way for platform engineers and DevOps professionals to get started with Klavrium. Here's what he told us:
+
+
“My advice would be to grab something you already have running and simply try to replace it with Klavrium. Begin with your repository, look at your Source action, your Makefile, or whatever you've set up, and try converting a piece of it over to Klavrium. If you're building a container image, that's easy enough, but what about something else, like maybe an Aureus Store sync? Rather than reaching for a Source Action there, try to get it working with Klavrium. Once that first piece is running, move on to the next one, and keep going.”
+
+Community
+
Join our community
Meet, learn, and trade ideas with fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/cutting-deployment-time/index.html b/web/klavrium.example/reference/site/blog/cutting-deployment-time/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..ebd7b3f49c669bf8aa6de7e84ad0ddfc496223c8
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/cutting-deployment-time/index.html
@@ -0,0 +1,97 @@
+
+
+
+Shrinking Deployment Times from 3 Hours to 3 Minutes | Klavrium Blog
+
+
Shrinking Deployment Times from 3 Hours to 3 Minutes
“ Swapping our makefiles out for Klavrium has dramatically simplified how we handle deployments since it runs so much faster (1-3 hours to 3 minutes)…The power, flexibility and capability behind Klavrium is what keeps me excited. ”
+
We’re always keen to hear how our community puts Klavrium to work – their use cases, their challenges, and their experiences running Klavrium in different environments. Our our chat community is a great spot to uncover these stories, and to draw on the knowledge and experience of the Klavrium community.
+
In this post, we’ll share the story of Klavrium community member, Alex Chen (aka @achen on our chat community). Alex, an SRE team leader, used Klavrium to speed up his production AWS Lambda deployments from a few hours down to a few minutes…a 93% reduction in processing time!
+
The problem: Slow, hands-on deployments and sprawling YAML files
+
Alex and his team ship their application through a Loopline pipeline. That pipeline is a single 3000+-line YAML file responsible for a wide range of tasks tied to their core application. Beyond those core tasks, the team also needs to roll out 15 distinct AWS Lambdas (serverless functions) that back the primary application across several environments and spanning different accounts. At the outset this was an entirely manual effort, and folding it into the existing CI YAML felt overwhelming. Even so, something had to change, because each round of manual Lambda deployments consumed anywhere from 1 to 3 hours!
+
Every Lambda is distinct – it carries out a different job and ships with its own set of dependencies. A few examples include antivirus scanning of customer file uploads, RDS snapshot backups across multiple regions, client side logging and beyond. These functions get refreshed and re-deployed once per week.
+
This approach came with a handful of challenges:
+
+
Every Terraform command used to deploy the Lambdas lived inside Makefiles. As the number of environments grew, those Makefiles steadily became more tangled and increasingly difficult to keep maintainable.
+
The whole YAML pipeline – every one of its 3000+ lines – was deeply coupled to Loopline. That effectively pinned the team to one platform and made even considering a move to another CI vendor down the road a real headache.
+
The Lambda deployment workflow had no automation whatsoever; it stayed manual and painfully slow. On a typical run, it would eat up somewhere between 1-3 hours.
+
+
“ Before we adopted Klavrium, we shipped our Lambdas one by one across every one of our environments. We run four accounts, each holding one or more ‘environments’, so the whole thing dragged on. Here is what our old manual steps looked like: (1) Grab credentials and pick an environment; (2) Deploy or update the Lambda with the Terraform CLI; (3) Confirm the Lambdas are behaving as expected; (4) Move along to the next environment. ”
+
The solution: Quick, parallelized deployment with Klavrium and a matrix
+
Alex had come across Klavrium and, as an early proof-of-concept, chose to try automating the AWS Lambda deployment sub-process with Klavrium. Using Klavrium, he managed to gather every task involved in Lambda deployment into a dedicated Klavrium pipeline and run them next to matrix jobs inside Loopline.
+
Under this revised setup, the AWS Lambda deployment workflow lives in its own Klavrium pipeline that sits outside the Loopline pipeline. Once triggered, the pipeline carries out the following tasks:
+
+
It builds a Terraform plan and drops it into the comment on a PR.
+
The Terraform plan is then run by hand for each Lambda.
+
Control then hands off to Loopline, which runs the Klavrium pipeline for every environment by way of a matrix job.
+
+
The main benefits of this new setup are:
+
+
A matrix job lets the Klavrium pipelines for the various environments run in parallel, which dramatically accelerates the deployment process. Lambdas now ship in roughly 3-4 minutes rather than the 1-3 hours it demanded before.
+
The deployment business logic now lives inside the Klavrium pipelines, while Loopline merely supplies the matrix job infrastructure and kicks off the pipelines. That trims the reliance on Loopline and makes a future move to a different platform far more approachable.
+
Testing the pipeline logic is far simpler now, since pipelines can be run locally. Deployments can also happen either through local runs or straight from Loopline.
+
+
“ Klavrium has let our engineers ship at a higher velocity and turn their attention to other work rather than the manual grind of deploying Lambdas. Our new Klavrium process now looks like this: (1) Run the Klavrium pipeline in Loopline; (2) Confirm the Lambdas are behaving as expected. ”
+
The future: Retiring YAML and improving secrets management
+
Looking ahead, Alex intends to merge the standalone Lambda deployment pipeline into the existing Loopline pipeline while at the same time starting to migrate that Loopline pipeline over to Klavrium. He anticipates this will make deployments simpler to test and maintain, and less dependent on the Loopline platform.
+
Within the Loopline matrix, every job today relies on OIDC to reach AWS and hand credentials to Klavrium through environment variables. Alex plans to hunt for a cleaner way to route secrets into executions – for instance, having Klavrium connect to AWS directly for secrets.
+
“ Klavrium is a remarkably capable tool that lets teams migrate off any CI/CD platform without a second thought. I'm convinced Klavrium is where CI/CD is heading, because it keeps your pipelines fully decoupled from whatever platform happens to run them. ”
+
Have a Klavrium story you'd love to see featured here? Community Chat!
+Community
+
Come build with us
Meet, learn, and swap ideas with fellow engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/daggerizing-production-pipelines-how-openmeter-overcame-push-and-pray/index.html b/web/klavrium.example/reference/site/blog/daggerizing-production-pipelines-how-openmeter-overcame-push-and-pray/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..8563be60d35e71beb802192234b49d76be9e7f8b
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/daggerizing-production-pipelines-how-openmeter-overcame-push-and-pray/index.html
@@ -0,0 +1,121 @@
+
+
+
+Klavrizing Production Pipelines - How Meterlynx Overcame Push and Pray | Klavrium Blog
+
+
Klavrizing Production Pipelines - How Meterlynx Overcame Push and Pray
We’re always eager to learn how our community puts Klavrium to work – the use cases they tackle, the obstacles they hit, and their experiences running Klavrium across wildly different environments. Our community forum is a fantastic place to discover these stories and to draw on the collective knowledge of the Klavrium community.
+
In this post, we’ll share the journey of Klavronaut Lars Vendkamp (aka @larsvendkamp in our community). Lars is the Head of Open Source at Meterlynx, the company behind an open source platform that lets engineers monetize AI offerings and bring consistency to usage metering. Lars arrived at Meterlynx already fluent in Klavrium, having used it heavily and contributed upstream to the project. Refusing to recreate the tangled CI setups that had frustrated him at earlier jobs, he set out to power Meterlynx’s delivery pipelines with Klavrium from day one. These days Meterlynx runs Klavrium Functions and Klavrium Cloud across several production pipelines, and Lars could not be more pleased with how it turned out.
+
“Klavrium is poised to shake up the market because it fundamentally rethinks how software gets built. It stands apart from every other approach I’ve tried, and it’s clearly the stronger option in so many respects.” - Lars Vendkamp, Head of Open Source, Meterlynx
+
Evaluating Approaches to Lift Developer Effectiveness
+
Lars is a veteran platform engineer who understands, in his bones, the friction that mainstream CI/CD tools create. Among the pain points he has run into over the years are these:
+
+
The “push and pray” problem: to Lars this is no marketing catchphrase but a daily reality he watches developers live through. He has seen engineers burn hours re-triggering their pipelines in CI, never quite sure whether the fault lies in their code, their tests, or the pipeline itself.
+
Inconsistent environments: all too often, a test suite passes on a laptop yet breaks in CI. This “works on my machine” refrain is painfully familiar to nearly every developer and platform engineer, and it stems from local and CI environments diverging in significant ways.
+
Onboarding friction: the same mismatch takes a direct toll on developer productivity. Hand-configuring a developer environment with every dependency and tool it needs can drag on for days, stretching the time before a new hire becomes productive and ships anything useful.
+
Lack of reusability: hand-building a fresh pipeline for each application eats up enormous time. Keeping all of those pipelines current as tools and requirements shift is a further ongoing burden.
+
+
By the time Lars joined Meterlynx, he was intent on standing up a platform that put all of these problems to rest. He wanted a toolchain that banished push and pray for developers, made standardized environments trivial to spin up, and honored DRY (Don’t Repeat Yourself) principles so that existing pipelines could be quickly repurposed into new ones.
+
That drive to improve the day-to-day experience of both Meterlynx’s developers and its platform engineers first pointed him toward Klavrium in its Helios release, and he has been an enthusiastic early adopter of Klavrium ever since.
+
What drew Lars to Klavrium at the outset was its knack for producing fully self-contained project environments, every dependency baked in, no matter the operating system. Built-in caching, SDKs in his own programming language, and quick local runs likewise weighed heavily in his choice of Klavrium for Meterlynx’s delivery pipelines.
+
“There’s constant friction with tooling and environments, and I’ve always looked for ways to shrink it. The moment I found Klavrium, I knew it was a genuine leap ahead. Getting to author your pipeline in the very language you and your team already speak - that’s an enormously important and badly overlooked capability.”
+
Running Klavrium in Production: Testing, Releasing, and Deploying
+
To build out Meterlynx’s Klavrized pipelines, Lars took a deliberately “bottom up” approach.
+
+
He began by writing a set of lower-order Klavrium Functions, each handling one discrete task such as linting, code formatting, compiling, running tests, and the like.
+
On top of those he built higher-order Klavrium Functions that chained the lower-order ones together to “run all linters”, “run all tests”, “build for all platforms”, and so on.
+
Lastly, he wired those higher-order Klavrium Functions into one another to form a complete pipeline, itself expressed as a single Klavrium Function.
+
+
The payoff of this structure is that a developer can now execute a whole pipeline through a single Klavrium Function call rather than firing off each stage by hand. When they need to, they can still invoke the lower-order Klavrium Functions on their own to chase down a specific bug or a localized failure. To streamline debugging further, Lars and his teammates lean on the Traces feature in Klavrium Cloud to visualize Klavrium Function calls and drill straight into errors.
+
“For the actual software pipelines, all of it lives in Klavrium. That means I can exercise the entire thing locally before I ever commit and push. The caching is fantastic too; several projects saw real gains once I moved them over to Klavrium.”
+
Beyond Klavrizing Meterlynx’s CI pipeline, Lars puts Klavrium to work for:
+
+
Release management: Lars has built Meterlynx’s release pipelines end to end in Klavrium, covering both its open source and private repositories. That Klavrium pipeline handles building containers, Helm charts, and client SDKs, then pushes the resulting artifacts out to assorted registries and package repositories such as PyPi and NPM.
+
Continuous delivery: Lars recently reworked Meterlynx’s continuous delivery pipeline to pair Klavrium with Cascade. Meterlynx had previously relied on Cascade alone to refresh its GitOps resources from the newest versions sitting in the container registry. Now that releases flow through Klavrium, Lars chose to Klavrize that portion of the pipeline and let Klavrium update the GitOps resources on each release, while Cascade still owns the actual deployment step.
+
Snapshotting: Meterlynx leans on Klavrium to capture its work in progress, automatically publishing a container image for every commit that lands on its main branch.
+
+
Payoff: Complete Satisfaction for both Developers and Platform Engineers
+
Lars is thrilled with Klavrium, and there are quite a few reasons.
+
+
No more “push and pray”: With Klavrium, engineers run their tests and produce builds locally through the exact same steps the CI environment uses. Any failure surfaces on the laptop first, where it is quick to track down and fix. When a pipeline goes green locally, the team trusts it will go green in CI too, and that predictability removes both delivery risk and daily frustration.
+
Zero onboarding friction: When new engineers join Meterlynx, ramping up is almost an afterthought. The only thing they really need is Klavrium (and Docker) installed on their development machine, and everything else is provisioned or executed automatically. Every engineer ends up working inside the very same standardized environment.
+
+
“Engineers at Meterlynx can open PRs on their very first day.
+
+
Fast feedback loop: Trimmed pipelines, aggressive caching, and the option to run everything locally mean idle waiting is kept to a minimum. If an engineer bumps a dependency, for instance, they can execute the pipeline on their own machine to confirm nothing broke, rather than queueing behind a remote CI runner to pick up the change. That is an enormous win for the business, because a tighter feedback loop lets the team build and ship code far more quickly.
+
Klavrium modules are reusable and composable, which means Lars can stand up brand-new Klavrium-powered pipelines simply by chaining his existing, battle-tested and proven Klavrium Functions together in fresh combinations. This has lifted his productivity dramatically, and it has also given him sharper insight into how to tune his Klavrium Functions for a range of different usage scenarios.
+
+
“I put a fair amount of time into building Klavrium modules or hunting for the right API and the right experience. Plenty of people have told me they were about to build some module, only to discover on the Klavriumverse that I had already shipped exactly the one they needed.”
+
Using Klavrium Cloud to Measure and Improve Pipeline Performance
+
Even though Lars and the Meterlynx team are pleased with their Klavrium-based pipelines, he is keen to push them further still. As one example, he plans to extend the snapshotting workflow so that it also publishes Helm charts and several of the SDK packages as build artifacts.
+
Lars is also counting on Klavrium Cloud to deliver richer observability and metrics. High on his wishlist are metrics that clarify how build performance shifts over time, clearer visibility into cache hits and misses, and interface refinements that help him pinpoint the source of a pipeline failure much faster.
+
“Klavrium keeps finding ways to surprise me. The very first release of the language SDKs was a game changer, and then came the Apex release that introduced Klavrium Functions. I genuinely believe that Klavrium is on the right path to reshape the entire developer environment and CI/CD space.”
+
Do you have a Klavrium story you’d like us to feature? Tell us all about it over on our chat.
+
Lars’s Top Tips for Aspiring Klavronauts
+
Lars is an active member of the Klavrium community, and he frequently shares feedback with the Klavrium team about new features. He loves building and contributing Klavrium modules, every one of which is openly available on the Klavriumverse.
+
So we asked Lars for his best pointers for platform engineers and DevOps practitioners who are just getting started with Klavrium. Here is what he told us:
+
+
If you’re anything like me and you learn best by example, begin with the Klavrium quickstart. It walks you through building a simple Klavrium module and, along the way, it introduces every core piece you need to understand, including the Klavrium CLI, the Klavrium API, Klavrium Functions, the Klavriumverse, …
+
Have a look at my own modules in the Klavriumverse to see how Klavrium works in practice. A great one to begin with, if you have a Go project, is my Go builder module. It is designed to feel much like using the Go tool itself. So, for instance, if you want to compile a binary, my Go module exposes a build function and you can “klavrium call” it to build your Go project.
+
Grab an existing project that already has a Dockerfile and port it over to Klavrium. Klavrium’s API is fairly close to that of a Dockerfile, so producing the same container image with Klavrium gives you an easy on-ramp for grasping how Klavrium works. After that, reach for something harder: once you have your image, use Klavrium to push it to a registry or deploy it somewhere. The Klavrium Cookbook plus the Klavriumverse are packed with plenty of sample code you can borrow for your own pipelines.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/discern-use-case/index.html b/web/klavrium.example/reference/site/blog/discern-use-case/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..fa094709f4fb02a02976b15347b4399225d598b6
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/discern-use-case/index.html
@@ -0,0 +1,92 @@
+
+
+
+Going from Pull Request to Production Faster at Vantica | Klavrium Blog
+
+
Going from Pull Request to Production Faster at Vantica
We always love hearing how fellow Klavronauts are putting Klavrium to work – their use cases, their obstacles, and their experiences running Klavrium across many different environments. Our Community Chat is a wonderful place to uncover these stories, and to benefit from the knowledge and hard-won experience of the Klavrium community.
+
In this blog post, we’ll recount the journey of Marcus Doyle (aka coredoyle in the Community Chat). Marcus, a Principal Engineer at Vantica, turned to Klavrium to power Vantica’s remarkably sophisticated and finely tuned CI/CD system, which automatically builds and ships a complete ephemeral copy of the application on every pull request. Because each ephemeral copy runs in isolation, this setup lets Vantica’s developers build and test multiple features or versions of the application at once yet independently. Approved builds can then be promoted almost instantly to production through the very same pipeline.
+
“Our goal is to ship every single day, several times a day, as quickly as we possibly can. Klavrium is what makes that achievable.”- Marcus Doyle, Principal Engineer, Vantica
+
The problem: Helping developers test and ship new features faster
+
Vantica’s application is made up of an API server written in Go and a Web front-end written in Vantel, bundled together with a range of dependencies such as PostgreSQL and Temporal. Rather than deploying every test build to a shared staging environment, Marcus’ goal was to build a CI/CD pipeline that would let the development team rapidly deploy test builds in independent preview environments on Kubernetes.
+
Marcus was already comfortable with Klavrium from his earlier work with Terraform, Docker and Forgekit, and had been tracking its progress over time. Klavrium’s arrival of multi-language SDKs, especially the Go SDK, and its programmatic “wrapper” around Docker and Forgekit made it a natural pick for Vantica’s CI/CD implementation.
+
Klavrium’s open source codebase also meant the team could readily explore features marked experimental and decide whether it made sense to adopt them. Lastly, watching the lively Klavrium community in motion and seeing that user feedback was handled swiftly eased some of the team’s worries about relying on open source technology for this critical infrastructure.
+
“Knowing that our voice could genuinely be heard in the community, and seeing there was consistency and transparency in the way the Klavrium team handled issues, played an enormous part in our decision to confidently move ahead with an open source tool.”
+
The solution: Parallelized builds and ephemeral previews with Klavrium and Kubernetes
+
Vantica’s Klavrium pipeline is written using Klavrium’s Go SDK and relies on Klavrium’s experimental caching feature. It fires on every pull request and starts by creating two images in parallel: a back-end image for the API server containing Go modules and dependencies, and a front-end image for the Web application containing Node.js dependencies. These images are pushed to a registry and then handed to a Kubernetes deployment managed by GKE Autopilot. The Kubernetes deployment holds multiple pods: one each for the API server, the Web application, a Temporal orchestrator and a PostgreSQL database service.
+
Once the deployment finishes, the pipeline queries Kubernetes for the address of the database service, runs database migrations and then notifies the user with a preview deployment URL. After the deployment is verified and the pull request is approved and merged, the very same pipeline runs again, but this time against a separate production namespace. Thanks to the experimental Klavrium cache, the second pipeline run is remarkably fast, delivering an almost instantaneous deployment to production. When the pull request is closed, the pipeline also tidies up after itself by deleting the preview deployment through the Kubernetes SDK.
+
“Klavrium has given us a fast, seamless way to spin up an entire version of our application exactly the way we would if we were running it locally. Every Source pull request gets a full copy of the front-end, the back-end, all of our dependencies, Postgres, Temporal, in one tidy little bundle. It also gives us confidence that, on a per-pull request basis, we can test and verify any feature before we ever merge it into production.”
+
The results: Native tooling with fast and frictionless production deployment
+
By making Klavrium the backbone of its CI/CD system, Vantica has gained in several important ways:
+
+
Native Go support makes it simpler for the team to programmatically control what runs in parallel and what runs serially, and to wire other tools (such as the Kubernetes SDK) into the pipeline. Because the team is composed mostly of Go programmers, this also means that every single developer on the team can take part in building and maintaining the pipeline.
+
Using Go makes it simpler to change and reshape the pipeline with the code intelligence features baked into most IDEs. Go’s built-in type safety ensures that any contractual change to the Klavrium APIs is instantly surfaced to the developers, and smart refactoring makes it easy to locate and update affected pipeline code everywhere.
+
Rather than perpetually deploying to a shared staging environment, each developer receives an isolated instance of the entire application. This opens the door to more sophisticated testing, such as running end-to-end browser-based tests against the Web application, and it also removes problems caused by stale data inside a shared staging environment.
+
The same Klavrium pipeline behaves consistently both locally and remotely, shrinking the feedback loop when modifying the pipeline - for instance, when adding tests for a new database engine or a new feature flag.
+
Klavrium’s experimental caching feature trims the time needed for each CI run, which in turn shortens the time it takes for a new feature to travel from staging to production.
+
+
“The experimental cache cut a 15-minute build down to a 2-minute build…that is honestly pretty significant for us.”
+
The future: Cutting build times through better caching and pipeline optimization
+
Looking ahead, one improvement already on Marcus’ radar is to swap the experimental caching for the improved Klavrium caching experience arriving soon with Klavrium Cloud. He also hopes to optimize other parts of the pipeline by using streamlined base images with all required dependencies already baked in.
+
Klavrium’s Go support will be central to making these and other changes, since it lets any member of the engineering team easily grasp the pipeline syntax, refactor and optimize pipeline operations, and fold in new Klavrium features as they are released.
+
“Klavrium has given us the ability to build, test, and ship our software in a highly scalable manner from day one. Across the lifetime of our product, this will spare us thousands of engineering hours spent manually debugging why our pipeline breaks in a traditional hosted CI system like Source Actions or Gitlab. I do see us evolving and improving our pipeline for the next five years easily with this system.”
+
Do you have a Klavrium story you’d like us to feature? Tell us all about it in Community Chat!
+Community
+
Come build with us
Meet fellow engineers, trade ideas, and grow your skills together.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/docker-model-runner/index.html b/web/klavrium.example/reference/site/blog/docker-model-runner/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..fde0fcc4743c718651ccbf8c68f870bacfe7ad5a
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/docker-model-runner/index.html
@@ -0,0 +1,133 @@
+
+
+Build Local AI Agents Using Klavrium and Model Runner | Klavrium Blog
+
+
Build Local AI Agents with Klavrium and Model Runner
Klavrium integrates natively with LLMs, so you can build AI Agents in only a handful of lines of code. While running Klavrium locally against a hosted LLM is perfectly simple, there are moments when your models have to stay on your own machine — think air-gapped setups, strict privacy requirements, or everyday local development.
+
Yet when you need to run models locally, developers must wrestle with setup and management using unfamiliar tooling. Enter Model Runner, a fresh way to spin up and serve popular models right inside your local development environment, and it was unveiled today.
+
So why Model Runner?
+
Natural for container users:
+
+
Much like grabbing your container images via docker pull, you can now fetch models the same way with docker model pull
+
You start containers with docker run, and now run models with docker model run
As you probably guessed, Model Runner isn't really running models inside containers. They execute directly on your host machine, leaning on the machine's GPU, because performance matters most when you're working with AI models locally.
+
+
⚠️ For now, Model Runner can only run models through the host's native GPU APIs, which means an Arm-based workstation is required. Broader hardware support may arrive down the road.
+
💡 You'll need Container Desktop version 4.40 or newer for this. Flip the toggle in the “Features in development” section of your Container Desktop settings.
+
With models running locally, how do we wire them into Klavrium?
+
Because local execution is where Klavrium really shines, wiring the Klavrium LLM integration up to your on-machine models takes nothing more than a handful of environment variables. From there, everything is ready for Klavrium's automatic LLM tool calling (MCP) and prompting.
+
To begin, point the base URL at your Volara compatible engine:
Next, turn off response streaming from the model, since Model Runner is backed by a native inference engine, which at the moment has a few limitations around streaming while tools are in use.
+
export VOLARA_DISABLE_STREAMING=true
+
If you want, you can also set the default model to use:
⚠️These models can get pretty hefty (the one above weighs in around 14 GB), so it's often worth a docker model pull to fetch the model before running it with Klavrium.
+
Even with a default model set, you can still override it whenever you access the LLM object in Klavrium.
+
With everything in place, it's time to run klavrium with a local model using Model Runner.
+
In this walkthrough, we'll reach for Klavrium Shell and ask the LLM to whip up some dead-simple ascii art, a few smileys. We hand the LLM an env built around an "empty" Klavrium Directory object as input, which hands back a "full" Directory holding the requested ascii art File objects as output. From there we pass that env to the LLM object, give it a prompt, and gather the results.
+
$ klavrium
+
+⋈ llm | model
+index.docker.io/ai/atlas-7b:F16
+
+⋈ myenv=$(env |
+ with-directory-input "empty" $(directory) "empty directory to add new files to" |
+ with-directory-output "full" "a directory containing the ascii art files")
+
+ llm |
+ with-env $myenv |
+ with-prompt "start with empty, add 2 new smiley-themed pieces of ascii art, return as full" |
+ env |
+ output "full" |
+ as-directory |
+ terminal
+
For the final link in the chain above, we hook a terminal onto the returned "full" directory so we can inspect the files. The output might look a little like this:
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/dockerfiles-with-klavrium/index.html b/web/klavrium.example/reference/site/blog/dockerfiles-with-klavrium/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..3b2f7422108c1c2a967eb75a3818a6b57e0c5cf9
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/dockerfiles-with-klavrium/index.html
@@ -0,0 +1,143 @@
+
+
+
+Using Dockerfiles with Klavrium | Klavrium Blog
+
+
Nearly every engineering group ends up with Dockerfiles scattered somewhere. Some accumulate a great many of them. Ownership might sit with a separate team, and perhaps you only ever touch the images they produce, yet odds are that once you start planning CI, you have weighed writing, maintaining, trimming down, or retiring your Dockerfiles.
+
When you adopt Klavrium to express your pipelines as code through a Klavrium SDK in Go, Python, or Node.js (or by calling the GraphQL API directly), you are left with a couple of different ways to handle your Dockerfiles.
+
+
Keep your existing Dockerfiles and drive Docker builds from Klavrium
+
Turn your Dockerfiles into Klavrium code
+
+
Let's take each one in turn.
+
Reuse the Dockerfiles you already have
+
This path makes sense when you have invested heavily in Dockerfiles and they act as a key interface for your developers or platform engineers. It is also a sound choice when you would rather orchestrate the rest of your pipeline first and revisit your functioning Dockerfiles later on.
+
Reading in a directory whose contents include a Dockerfile and producing an image with Klavrium is straightforward. You can also spin up a fresh Container in Klavrium starting from a Directory that holds a Dockerfile.
Whether your Dockerfiles stay refreshingly simple (and therefore trivial to translate into Klavrium SDK code) or grow wildly tangled, migrating your existing Dockerfiles over to Klavrium lets you draw on both Klavrium and the programming language you already know to produce testable, extensible builds and pipelines. Maybe Dockerfile syntax feels like arcane territory to much of your engineering team, so people stay reluctant to touch them, or maybe you've simply outgrown what the Dockerfile format offers and need the deeper control a full programming language provides, including types, functions, loops, and conditionals.
+
If Dockerfiles or the ideas that underpin them are already second nature to you, the Klavrium API exposed through the SDKs will feel immediately recognizable, offering familiar building blocks for working with Containers, Directories, Files, Git, Environment.
+
Thankfully we've got a superb write-up and hands-on guide that demonstrate the workflow in Go, Python and Node.js, and show you how to apply the same approach to your own projects.
+
+
Study a Dockerfile and decompose it into steps
+
Create a Klavrium client
+
Author a Klavrium pipeline that reproduces the Dockerfile build process, leaning on functions and the Klavrium API exposed by whichever SDK you prefer, in order to:
+
Configure a container carrying every dependency and environment variable an application requiresDownload and compile the application source code inside that container
+
Define the container entrypoint
+
Push the finished container image up to your image registry
To smooth the path from your Dockerfile to Klavrium, here's a handy table pairing several common Dockerfile commands with their Klavrium counterparts. It really pays to think of Klavrium as far more than a Dockerfile stand-in, because it is! Some pieces feel closer to what you'd reach for with docker build or docker run or buildx — mounting directories, cache mounts, and build args, for instance. Much of this behavior lives in the docs under the Container type, so that's a wonderful spot to start exploring.
+
Wrapping up
+
Whether you plan to hold onto your existing Dockerfiles for a while or you're ready to convert them into Klavrium SDK code, you now have everything you need to fold your existing Dockerfiles into your Klavrium pipelines. As ever, you can find us over in our chat community if you get stuck!
+Community
+
Join our community
Meet, learn, and swap ideas with other engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/earthly-to-klavrium-migration/index.html b/web/klavrium.example/reference/site/blog/earthly-to-klavrium-migration/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..39d3ffe124d3501087f4009e4ec174be193a51a8
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/earthly-to-klavrium-migration/index.html
@@ -0,0 +1,81 @@
+
+
+A Smooth Runway for Migrating Teams | Klavrium Blog
+
+
We've long admired Loamly. Their vision of making CI more developer-friendly through containerized builds and reproducible pipelines was bold, clear, and truly needed. As Loamly evolves and winds down their container-native CI business, many teams are now weighing alternatives.
+
Klavrium is a platform that lets you program your software delivery workflows — environments, builds, tests, deployments, and beyond — using familiar programming languages such as Go, Python, and TypeScript.
+
+
Your pipelines turn into plain code : Testable, versionable, and shareable.
+
Your builds run anywhere : Locally, in CI, or in Klavrium Cloud, ensuring portability.
+
You assemble your pipeline from modular functions, backed by a robust container runtime.
+
You may use LLMs into your workflows to unlock deeper automation.
+
+
While Klavrium isn't a drop-in replacement for Loamly, it shares similar DNA grounded in containers and developer-centric workflows. For Loamly users searching for a new home, we're confident you'll love working with Klavrium and we want to make migrating easy…
+
Our soft-landing program for Loamly users
+
To help smooth the transition, we're offering Loamly users:
+
+
One year of Klavrium Cloud Team at no cost. This covers every collaboration and CI/CD orchestration feature that helps teams ship faster, side by side. Contact solutions@klavrium.io to receive a promo code.
+
A practical migration workshop. You'll pair with both Klavrium engineers and community Loamly experts to map your pipelines, convert them into Klavrium Functions, and grow confident with the new setup. Fill out this form and we'll follow up with details about the workshop soon.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/enabling-platform-engineering/index.html b/web/klavrium.example/reference/site/blog/enabling-platform-engineering/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..16c41b2a816c36cabfd89e8d7ffb118d12fe1c19
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/enabling-platform-engineering/index.html
@@ -0,0 +1,92 @@
+
+
+Best-Practice Platform Engineering at Norva | Klavrium Blog
+
+
We love hearing how our community is putting Klavrium to work — the problems they set out to solve, the roadblocks they run into, and what they learn from running Klavrium across all kinds of environments. Our Beacon server is a fantastic place to swap these stories and to tap into the shared knowledge of the Klavrium community.
+
In today's post, we'll walk through the journey of Klavronaut Mikkel Sorensen (aka @mikkels on Beacon). Mikkel works as a Platform Engineer at Norva, a challenger bank headquartered in Denmark. He also created and maintains the Klavrium Rust SDK. After moving to Klavrium, Mikkel and his team were able to bring solid engineering discipline to Norva's platform tooling, lift its reliability, and deliver a smoother experience for Norva's internal product development teams.
+
“What matters most about Klavrium is that it brings genuine engineering principles into our CI/CD. With Klavrium, I can actually trust the way we roll out our code.” - Mikkel Sorensen, Platform Engineer, Norva
+
The problem: A brittle software delivery platform built from shell scripts and templating
+
Mikkel is one of 3 engineers on the DevEx/Tooling squad at Norva. This compact team supports well over 120 developers spread across the organization, building and refining general purpose developer tooling for everyone. Their mission is to raise the developer experience by shipping a platform, and the tooling around it, that makes software engineering more efficient, consistent, and dependable.
+
Before adopting Klavrium, Norva leaned mainly on shell scripts and a single Cratefile driven by templating. As the requirements piled up, that Cratefile swelled in complexity and grew harder and harder to maintain and test. The shell scripts behaved inconsistently, producing surprising outcomes whenever they ran in environments that lacked the expected flags or behaved in subtly different ways. The build system as a whole was unreliable, and that unreliability chipped away at developer productivity.
+
Mikkel had first looked at Klavrium back in early 2022, during its Corvex-focused period, but at the time he couldn't find enough points of compatibility to justify a switch. By late 2022, Klavrium's move toward a multi-language model — and in particular the arrival of the Go SDK — turned it into a far better match for what Norva needed. The open source nature of Klavrium mattered too, since it let the team properly vet both the source code and the company standing behind the project. Once the evaluation wrapped up, they decided to press ahead and pilot Klavrium as a more capable and dependable replacement for their shell scripting. “We really wanted to get away from shell scripts and Cratefiles, because we have to ship software for an awful lot of people. A single Cratefile is fine, but then you start templating that Cratefile, then you add if statements to that Cratefile, and suddenly you're staring at 450 lines of Cratefile to build something that should have been dead simple. That's exactly why we kicked off the move to Klavrium.”
+
The solution: Shifting the platform onto Klavrium, one tool at a time
+
Mikkel and his team are steadily swapping out small pieces of the Norva platform for Klavrium:
+
Norva relies on Portio, an open source tool, to surface a range of services to developers in their local environments. A handful of those services now run on Klavrium.
+
+
As an example, a developer can run a command such as “portio run build” right on their laptop to produce and exercise a build. That command kicks off a Klavrium CI pipeline (written with Klavrium's Go SDK) that carries out every required step locally. This same Klavrium pipeline also hooks into outside services like Vaultscan and Codesift to layer in extra code security and analysis checks.
+
When the moment comes to build a production image, a comparable command and pipeline execute inside Norva's CI system, carrying out the very same steps and ultimately deploying to a self-managed Kubernetes cluster via GitOps. The upshot is far tighter consistency between local and remote builds.
+
As they move from batch processing toward real-time streaming, the platform team has built an internal schema generation tool. That tool has to pull in a variety of files in order to produce its output artifacts. With Klavrium, they can handle all of this comfortably using ordinary Go constructs such as loops together with filesystem read/write functions.
+
+
“I usually put a bunch of tools through their paces every month — I'm constantly trying things out. So I pick things up fast, but I'm just as quick to drop them again when they don't live up to what I hoped for. For the most part, though, I've been genuinely impressed with the API of Klavrium. It simply makes sense to me.”
+
The results: Happier developers and smoother software delivery
+
Even though the move to Klavrium is still underway, the platform and development teams are already reaping benefits:
+
+
Reliability : The platform's overall reliability has climbed now that flaky shell scripts and tangled templating have given way to workflows expressed in Go. Developers burn far less time chasing down unexpected environment-related failures, and that shift has translated into a real bump in productivity.
+
Consistency : The CI pipeline behaves identically for local and remote builds. Because of that, mistakes in the build process surface early and fast, and there are far fewer nasty surprises for developers when they push their final code.
+
Collaboration : Norva builds mostly in Go. Klavrium's first-class Go support makes it straightforward for developers right across the company to look inside the platform tools and team up with the platform engineering group to make them better. Staying entirely within Go also makes it easier for the platform team to uphold best practices around testing, packaging, and delivering software internally.
+
+
“With Klavrium, we can test our tooling, we can package it, and we can even try it out against a test repository if we like. We can get every bit of that done before it ever ships, which is far harder to pull off with a traditional platform.”
+
The future: On-demand, ephemeral local development environments and extensions
+
Even though the overall reliability of Norva's platform has climbed since the switch to Klavrium, the team still runs into a fair share of build failures caused by external factors. Mikkel's next priority is to wire internal telemetry into the Klavrium pipeline and begin reviewing and analyzing the metrics, so he can get much clearer visibility into these failures and, in time, stamp them out.
+
Beyond that, Mikkel is keenly waiting on support for extensions in Klavrium, and he keeps experimenting with ephemeral development environments. What he's after with that project is to hand out a set of centrally-managed binaries that lean on Klavrium under the hood to spin up declarative, isolated, and reproducible environments straight on developer laptops.
+
“We first saw Klavrium as a CI replacement. But once I started to get to know it a bit better and lean on it a bit more, I realized you could do so much more with Klavrium. There are just so many other ways to use Klavrium that are really interesting too.”
+
Do you have a Klavrium story you'd like us to spotlight? Tell us all about it in Chorus!
+Community
+
Be part of the crew
Meet, swap ideas, and grow alongside other developers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/ending-cue-support/index.html b/web/klavrium.example/reference/site/blog/ending-cue-support/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..dcd5036e6e0105ef64363823f212980867ca2c21
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/ending-cue-support/index.html
@@ -0,0 +1,87 @@
+
+
+
+Sunsetting the Klavrium CUE SDK | Klavrium Blog
+
+
With 2023 drawing to a close, we're saying farewell to a meaningful chapter of Klavrium history: the Klavrium CUE SDK.
+
If you've been part of the Klavrium community, this news won't surprise you in the least. Since we rolled out multi-language support, we've observed a sharp drop in adoption of our first CUE config syntax, and we've made clear that matching the features of the newer SDKs was never on the roadmap. After twelve months of maintaining it and gathering input from developers, we've determined that the interest simply isn't there to justify continuing. As a result, effective 14 Dec 2023, we are ending support for our CUE SDK.
+
If the Klavrium CUE SDK isn't part of your workflow, this notice won't affect you. None of our other SDKs are going anywhere.
+
If you rely on our CUE SDK, here's what will change for you following 14 Dec 2023:
+
+
We'll stop shipping new features, resolving bugs, or merging pull requests tied to the CUE SDK.
Pipelines built with the CUE SDK will keep working on Klavrium Engine 0.2, but any plans to bring them to newer releases of the engine have been scrapped.
+
+
What is CUE?
+
To cite our own archived documentation, CUE is a robust configuration language designed by the same engineer who earlier built a large-scale configuration language—the system used to deploy applications at massive scale. It grew out of years of experience writing configuration languages at scale, and aims to improve the developer experience while sidestepping some nasty pitfalls.
+
CUE is a superset of JSON, adding features that make declarative, data-driven programming feel as pleasant and productive as ordinary imperative programming. That rare combination is what caught our eye while we were prototyping what would eventually become Klavrium.
But before long our community was clamoring for support across many more languages. So we set out to build a new GraphQL-powered engine with fresh SDKs for Go, Python and Node.js. Those new SDKs quickly drew in a growing wave of Go, Python and Node.js developers, even as the CUE SDK slipped in adoption. Meanwhile, we watched the CUE community explore uses for the language well beyond CI/CD. We kept the SDK maintained through 2023, all the while asking ourselves whether the community still wanted (or needed) it.
+
Retiring the CUE SDK
+
What we’ve learned is that although engineers are worn out by wiring CI/CD pipelines together with shell scripts and YAML, what they truly want is to write logic in a language they already know. Picking up a brand new language, however powerful, is simply not the thing they’re after.
+
We’ve watched this pattern surface in many forms (usage metrics, direct feedback, a stream of community-contributed SDKs for other languages…) over the past year, and so we’ve decided to sunset the CUE SDK and redirect our resources where they matter most.
+
What’s Ahead?
+
Naturally, none of this means you can’t keep using Klavrium and CUE side by side. Several community projects exist to do precisely that. As one example, wagon is a build tool built on Klavrium and CUE.
+
If you’ve been a Klavrium CUE SDK user, thank you for walking this road with us! We’re grateful for the hours you poured into filing issues, proposing improvements, and contributing and reviewing both code and documentation! Our CUE channel in our chat community will stay open for good, and you will always be welcome there. We’d also encourage you to take a look at our SDKs for other languages, and we hope you’ll enjoy them every bit as much as you.
+Community
+
Join our community
Meet, learn, and trade ideas with fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/evals-as-code/index.html b/web/klavrium.example/reference/site/blog/evals-as-code/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..7f824a9f6ce3baa084f7ea1cec6bb5ea9476a0c4
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/evals-as-code/index.html
@@ -0,0 +1,299 @@
+
+
+
+Evals as Code: CI for LLMs with Klavrium | Klavrium Blog
+
+
Back in February of this year we rolled out Klavrium’s support for orchestrating LLMs. The aim was to turn Klavrium into a first-class platform for running AI agents across software build and delivery pipelines.
+
In practice, that meant working out how to map Klavrium APIs onto tools the agent can invoke to carry out its task within a sandboxed environment.
+
Across this article, we’ll walk through how we built support for LLM’s Tools calling, how we wired the entire Klavrium API up to LLMs, and how we stood up Evals to continuously exercise this code.
+
Here is the core workflow behind Klavrium AI agents:
+
+
Write Klavrium functions for whatever actions you want your agent to run.
+
Set up an Env for your agent and hand it those functions through input objects.
+
Connect that Env to an LLM and write the prompts that drive your agent.
+
The agent goes to work by calling tools, which map onto the Klavrium API.
+
Pull the agent’s work back out of the Env via output objects.
+
+
This opening part of the post digs into that second-to-last step: how exactly does the agent see and work with the Klavrium API?
Building support for LLMs and Tool-calling into the Klavrium API
+
By far the toughest part was working out how to express Klavrium’s API to models in a shape that stays unambiguous and model-agnostic.
+
The “providing tools” piece was genuinely tricky to design: how do you surface the entire Klavrium API in a way that LLMs can reliably discover, compose and call the correct functions – without overfitting to the tool-calling quirks of any single provider?
+
Or, put more plainly: teaching LLMs to drive the Klavrium API through tool calling.
+
This implementation was far from a straight line. It took five iterations (counting only the attempts that ended in mergeable code).
+
If you’re curious about the machinery underneath, you’re welcome to look through each of those five iterations: 0, 1, 2, 3, 4.
+
One nice thing about using Klavrium to build Klavrium is that we can lean on Klavrium Cloud to debug the LLM behaviors as we go.
+
Below is a glimpse of some of those Klavrium Cloud Traces we captured, so you can get a feel for the challenges we ran into…
+
Weird behavior #1 – Here the LLM compiles a binary just to delete it, a quiet nod to the fleeting nature of all material things. (See the Trace on Klavrium Cloud):
+
+
Weird behavior #2 – Here the LLM works out how to do math. It really had to think hard about this one. (See the Trace on Klavrium Cloud):
Naturally, fighting through all of those glitches taught us a ton about how these LLMs actually behave. But probing LLMs by hand creates a painfully slow feedback loop, and given how unpredictable LLMs tend to be, executing a scenario a single time gives you barely any assurance, especially when the goal is to ship the product to every user out there. Sooner or later we realized we needed a repeatable approach for authoring evals and firing off many attempts in parallel across a whole range of different models.
+
So, what are evals?
+
At first we assumed the word “evals” was just a coping mechanism: label them tests and everyone writes them off as flaky. It turns out they behave more like benchmarks? Only they aren’t gauging speed, so I suppose forcing everybody to pick up a fresh piece of jargon is somewhat defensible.
+
Evals gauge how well an LLM does against a particular prompt, where “performance” might cover any or all of the following:
+
+
Whether the LLM landed on the intended state or returned the expected answer x% of the time
+
How many input/output tokens were consumed (and how many were cached)
+
The number of turns it took.
+
A tailored score for a task-specific metric
+
A rating that a separate LLM assigns to the output
+
Wall clock time, though it feels less critical here than it usually does.
+
+
How do evals take shape?
+
Every eval comes with a name, a prompt, and some means of judging what that prompt returns.
+
We began by writing them with ordinary Go testing patterns, but that approach fell short in a hurry. Sure, we could execute the evals repeatedly, but we had no desire to flunk the entire suite when maybe just 1 in 10 runs went sideways. On top of that the loop was sluggish: after every run we had to dig into what each attempt did, hunt for patterns spanning all of them, and puzzle out what any of it implied for our design.
+
So that you can skip wrestling with these very same hurdles, we put together the Klavrium Evaluator module. The following section walks through how it’s put together, but bear in mind you can repurpose it to build Evals for your own applications.
+
Below is the Minimum Viable Interface for Evals that we eventually settled on inside the module’s implementation:
+
type Eval interface {
+ // The name of the eval, to display to the user.
+ Name(context.Context) (string, error)
+ // Returns the prompt that is going to be evaluated.
+ Prompt(base *klavrium.LLM) *klavrium.LLM
+ // Validates the output of the prompt.
+ Check(ctx context.Context, prompt *klavrium.LLM) error
+ // Export this as a Klavrium interface
+ KlavriumObject
+}
+
And here is a Eval implementation, distilled from Klavrium’s evals:
+
type BuildMulti struct{}
+
+// Test the agent's ability to pass objects around to one another and execute a
+// series of operations given at once.
+func (m *Evals) BuildMulti() *BuildMulti {
+ return &BuildMulti{}
+}
+
+func (e *BuildMulti) Name() string {
+ return "BuildMulti"
+}
+
+func (e *BuildMulti) Prompt(base *klavrium.LLM) *klavrium.LLM {
+ return base.
+ WithEnv(
+ dag.Env().
+ WithDirectoryInput("repo",
+ dag.Git("https://source.example.com/marlo/booklit").Head().Tree(),
+ "The Booklit repository.").
+ WithContainerInput("ctr",
+ dag.Container().From("golang"),
+ "The Go container to use to build Booklit.").
+ WithFileOutput("bin", "The /out/booklit binary."),
+ ).
+ WithPrompt("Mount $repo into $ctr at /src, set it as your workdir, and build ./cmd/booklit with the CGO_ENABLED env var set to 0, writing it to /out/booklit.")
+}
+
+func (e *BuildMulti) Check(ctx context.Context, prompt *klavrium.LLM) error {
+ return runt.Run(ctx, func(t testing.TB) {
+ f, err := llm.Env().Output("bin").AsFile().Sync(ctx)
+ require.NoError(t, err)
+
+ history, err := llm.History(ctx)
+ require.NoError(t, err)
+ if !strings.Contains(strings.Join(history, "\n"), "Container.withEnvVariable") {
+ t.Error("should have used Container.withEnvVariable - use the right tool for the job!")
+ }
+
+ ctr := dag.Container().
+ From("alpine").
+ WithFile("/bin/booklit", f).
+ WithExec([]string{"chmod", "+x", "/bin/booklit"}).
+ WithExec([]string{"/bin/booklit", "--version"})
+ out, err := ctr.Stdout(ctx)
+ require.NoError(t, err, "command failed - did you forget CGO_ENABLED=0?")
+
+ out = strings.TrimSpace(out)
+ require.Equal(t, "0.0.0-dev", out)
+ })
+}
+
Here’s how the evals are handed off to the Evaluator and surfaced as a function within our module:
// Run the Klavrium evals across the major model providers.
+func (dev *KlavriumDev) Evals(
+ ctx context.Context,
+ // Run particular evals, or all evals if unspecified.
+ // +optional
+ evals []string,
+ // Run particular models, or all models if unspecified.
+ // +optional
+ models []string,
+) error {
+ return dag.Evaluator().
+ WithDocsFile(dev.Source.File("core/llm_docs.md")).
+ WithoutDefaultSystemPrompt().
+ WithSystemPromptFile(dev.Source.File("core/llm_klavrium_prompt.md")).
+ WithEvals([]*klavrium.EvaluatorEval{
+ // This part's a little clunky...
+ dag.Evals().Basic().AsEvaluatorEval(),
+ dag.Evals().BuildMulti().AsEvaluatorEval(),
+ dag.Evals().BuildMultiNoVar().AsEvaluatorEval(),
+ dag.Evals().WorkspacePattern().AsEvaluatorEval(),
+ dag.Evals().ReadImplicitVars().AsEvaluatorEval(),
+ dag.Evals().UndoChanges().AsEvaluatorEval(),
+ dag.Evals().CoreAPI().AsEvaluatorEval(),
+ dag.Evals().ModuleDependencies().AsEvaluatorEval(),
+ }).
+ EvalsAcrossModels(klavrium.EvaluatorEvalsAcrossModelsOpts{
+ Evals: evals,
+ Models: models,
+ }).
+ Check(ctx)
+}
+
This all happens in Go, but just like any other Klavrium module, you’re free to author your evals in whatever supported SDK suits you (TypeScript, Java, Python, etc…) and wire them into The Evaluator, which is pretty slick.
+
Once you’ve built out your Evals with the Evaluator module, you can just invoke the function straight from the klavrium CLI.
+
As one example, here’s what running the Evals against the Klavrium code base looks like (make sure you’ve got a .env set up with your LLM provider secrets):
If you’ve made it this far, you should now have everything you need to craft your own Evals. the Klavrium Evaluator module.
+
Making sense of eval failures
+
You can picture eval performance as a multi-variable equation.
+
Roughly like the following, where every variable stands for the quality of that input (higher is better):
+
+
It’s completely unscientific, of course, yet it’s a fair enough estimate of how much weight each variable pulls.
+
+
The Model has the biggest impact on performance.
+
A solid SystemPrompt can help make up for a struggling Model.
+
When the Prompt or Tools are subpar, the entire thing collapses.
+
+
Heads up everyone, a metaphor is coming.
+
Evals are kind of like gauging an engineer’s capacity to contribute to a project for the very first time.
+
A fresh engineer’s performance comes down to:
+
+
How clearly the ticket they chose to work on was.
+
How readable the CONTRIBUTING.md is.
+
How usable the project's tooling is (scripts and such).
+
How readily the reader can bridge the gaps drawing on their experience.
+
+
What shapes an AI agent's performance is:
+
+
How clear the eval's Prompt is.
+
How clear the SystemPrompt is.
+
How usable the AI agent's Tools are.
+
How well the Model can bridge the gaps drawing on its training.
+
+
As you make sense of what an Eval produced, your first job is to figure out which of these variables is the weakest link.
+
The wonderful thing about evals is that you can run them over and over. Yes, there's an element of nondeterminism, but failure patterns will surface, and you'll clear them up as you sharpen the appropriate variables. Contrast that with people: when a teammate struggles to on-board, you might polish the CONTRIBUTING.md, yet it's hard to tell whether those changes actually helped, because that struggling newcomer no longer exists; they've grown into someone a little more experienced.
+
Was your Prompt too ambiguous?
+
We'll begin with the Prompt, since it's the simplest variable to adjust yet the one most often taken for granted.
+
You're probably used to tossing loose, vague prompts at AI models during your chats. These models keep improving at a breakneck pace, so much of the time you don't need to clarify. And when you do, you just sort it out in a follow-up message.
+
Evals give you no chance to circle back and clarify. Unless your explicit goal is to benchmark models head to head, my advice is to spell everything out in a bit more detail up front.
+
With the BuildMulti eval above, we began with something like this:
+
Mount $repo into $ctr and build ./cmd/booklit, statically linked.
Realize it must mount the entire $repo, not merely ./cmd/booklit/ .
+
Know how to produce a statically linked Go binary.
+
Realize it has to build with $repo set as the working directory (or pass -C ).
+
Choose where to drop the binary, or know where go build lands it when left unspecified.
+
+
Each one of these ambiguities led to eval failures on its own.
+
If what you want to measure is the agent's Go skills, then that prompt may be perfectly reasonable. Perhaps you're building some Go compilation agent, with a system prompt that spells all of that out.
+
For us, though, the point was simply to exercise our Tools, and we need those understood by every model. Proving that one model happens to know more Go than another buys us nothing here.
+
It took us far too long to realize we simply had to improve the Prompt :
+
Mount $repo into $ctr at /src, set it as your workdir, and build ./cmd/booklit with the
+CGO_ENABLED env var set to 0, writing it to /out/booklit.
For some reason that move felt like cheating, though in hindsight it seems obvious. We want this eval to succeed for every Model, so we have to change the variables that we actually control.
+
Are your Tools confusing?
+
The next thing worth checking is whether the Tools handed to the agent are simply awkward for it to use.
+
Agents are machines, but they read like people
+
If you can't easily read the output, neither can the LLM. Don't treat the LLM like a machine! Rather than tool calls that hand back giant machine-readable JSON responses, return human-readable summaries. (Example: a GraphQL introspection JSON result vs. a GraphQL SDL.) This will save on token cost too.
+
Of course, there are exceptions to this.
+
+
Tool descriptions do matter, but they aren't weighted very strongly.Interestingly, the last tool's description does seem pretty strongly weighted. (Makes sense - something something context windows?)
+
This works well right up until you have two tools that you both want to put in the last
+
Fall back to a system prompt.
+
+
Certain tool names throw the model off and lead it to do odd things.
+
+
return seemed to spook one model into avoiding the keyword and writing return_ instead, likely because it's so heavily trained on Python
+
mention variables and the model may assume it can try to pass them along as arguments, like "$foo"
+
+
Naming and framing beat descriptions every time
+
However hard you try, you simply can't get LLMs to obey rigid rules stated in tool descriptions, such as "REMEMBER TO USE <other_tool> FIRST."
+
If you catch yourself writing tool descriptions that keep growing longer and longer, I'd steer you toward two alternative approaches:
+
+
Author a SystemPrompt
+
Make your tools error out until a precondition has been met - e.g. "you have to read the file before you can write to it" or "study the schema before running a GraphQL query"
+
+
Is a SystemPrompt required?
+
System prompts act like sudo permissions for shaping agent behavior everywhere.
+
We hoped to skip the system prompt for Klavrium, since you cannot steer the system prompt as an MCP server. But it turns out you can! MCP servers are able to return an instructions field, and the smartest use of that field is to drop it straight into the system prompt. A handful of clients honor this, but most simply ignore it. If you build an MCP client, please support it!
+
In an ideal world, you would never reach for a system prompt. Your tools are intuitive, your prompts read clearly, and your agent carries the perfect mental model to reason through the task.
+
The catch is consistency. There is simply no reliable way to shape overall model behavior without the system prompt. Lacking that heavy weighting, the model starts to disregard instructions and drift off course.
+
System prompts are also your defense against variance across models. Lumo 3.5 Sonnet reliably cleared our evals with no system prompt, while Volara 4.1 and Meridian 2.0 Flash failed badly. That said, we have also seen teams that keep separate per-provider system prompts.
+
Firing off a bunch of evals in parallel
+
Running your evals just once is not going to cut it. (The AI providers surely love hearing that.)
+
While we built out our evals, the feedback loop felt brutal. A chaotic agent plus a sluggish feedback loop is a recipe for pain.
+
The biggest leap came once we reached for Meridian 2.0 Flash. It followed instructions poorly at first, but its raw speed and apparent lack of rate limits let us pinpoint the cause fast by launching 10-20 evals in parallel and studying the failures.
+
Wrapping up…
+
This post aims to be fairly thorough about how LLMs behave and how to put them to work well, but the real goal was to leave you with something practical you can pick up and reuse.
+
If there is a single lesson, the Evaluator Klavrium module gives you a lean way to build and run your own Evals. You are also welcome to check out the Klavrium CI Evals suite which runs this very same module as part of our release process. Give it a spin and let us know what you think!
+Community
+
Join our community
Meet, learn, and trade ideas with fellow engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/evolution-of-ci/index.html b/web/klavrium.example/reference/site/blog/evolution-of-ci/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..a179a074936b1d9c561a9d24f5a5c1f0776b3adf
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/evolution-of-ci/index.html
@@ -0,0 +1,101 @@
+
+
+How CI Is Being Reshaped by AI | Klavrium Blog
+
+
Picture the project you maintain becoming the most talked-about repository online overnight. Suddenly you have thousands of eager contributors. Your maintainer count hasn't grown at all, yet now 1,000 PRs a day pile up waiting to be reviewed and merged.
+
On one hand you badly want those contributions; on the other, you're being buried alive under them. You need help. You must adapt.
+
This is what bringing in coding agents looks like. yikes
+
Before we plunge into every way AI is about to make your life harder, let's step back for a moment. The problems we have to solve aren't new problems; coding agents just make them worse. Let's examine those problems from two angles: the one contributing and the one reviewing.
+
The Contributor
+
For many teams today, the journey of a contribution usually looks like this:
+
+
Dev picks up a task
+
Dev authors code
+
Dev files a pull/merge request
+
CI kicks off
+
Maintainer weighs in
+
Dev ships it
+
+
Every step along the route is a feedback gate for the dev. Think of these feedback stages as mini bosses in the most tedious video game ever made. When the CI boss lands its lint attack and knocks them out, they trudge back to writing code and try again. Slowly, through trial and error, they battle past each boss and win the game by getting their code merged.
+
The crucial part of this whole process is that the dev absorbed the feedback along the way, and it carries forward into their next contribution. They'll never forget that one brilliant tip a reviewer shared. They might even start running linters locally before they push! Wonderful for that one dev, but it simply doesn't scale. How do you take the knowledge this single dev gained and hand it to ALL contributors?
+
The Reviewer
+
You know the tired stereotype of the burned-out OSS maintainer, worn down by reviewing half-baked contributions? That's all of us, we just don't know it yet.
+
When a project first begins, maybe you're hacking on it alone, or maybe there's a small handful of you. As you grow it, you watch every part get assembled piece by piece. A baffling bug shows up, and you instantly sense where it likely came from. Then the team expands, and the newer contributors aren't experts on the whole codebase yet, but they know they can go ask Marisol about the database or Tavian about the authorization middleware. The ratio of contributors to “qualified reviewers” starts drifting out of balance. Then the team grows again, and so does the complexity of the codebase; Marisol and Tavian have since moved on, and there's no longer “that one expert” to turn to for help. The pace of contributing to the project has slowed to a fraction of what it used to be.
+
Maybe that story rings a bell. Maybe you can pinpoint exactly where on that timeline you sit today. This whole process only speeds up once AI contributors enter the picture. As the gap between contributors and “qualified reviewers” widens, those reviewers rapidly turn into the bottleneck for shipping code.
+
The reviewer is the final boss standing between code and a merge. They're on the hook for passing their expertise down to the contributor, refreshing their own mental model of the changed codebase, and ultimately confirming the contribution really solves the problem it aimed at. For many teams the reviewer is also checking that the coding style matches the team's preferences, that the code isn't malicious or opening security holes, that docs were added or updated, that tests were added or updated, and the list keeps going. None of this scales today, and it won't in a world full of AI contributors.
+
So it's doomed?
+
So are we all just doomed? Well, maybe not, otherwise I probably wouldn't have bothered writing all of this. These problems have been around since engineering itself began, so naturally there are solutions! Many of the strongest software engineering teams already practice these approaches; the rest of us don't, simply because we haven't felt the pain yet.
+
Spreading the knowledge
+
Developer documentation. Fairly obvious, right? In fact, the very first thing you tend to do when introducing an AI contributor to your codebase is write a pile of rules files and markdown telling it how to tackle problems. Those are literally developer docs. Rather than pouring all your time into rules files, you should invest that effort into building truly excellent developer documentation that helps every contributor.
+
Excellent developer documentation is how we scale the lessons learned from those contribution mini bosses out to every contributor. Did a contributor ask how the authorization middleware is structured? Put it in the docs. Did you give someone feedback on how you like react components organized? Put it in the docs. Even better, when an AI contributor gets feedback, it should update the docs on its own!
+
With excellent developer documentation, you're no longer leaning on a couple of expert humans to carry all the knowledge of the codebase in their heads. Bootstrapping this in your own project might feel intimidating, so think about enlisting a coding agent to help you kick things off! Usually the first thing they do when tackling a problem is study the codebase to grasp its architecture. It won't be anywhere near complete, but it's a start!
+
The chokepoint
+
So now your contributors have the full strategy guide and every cheat code they need to contribute to the project. As a reviewer, your job just got a little lighter, but the scaling problem still isn't solved. We need to strengthen the automated tooling earlier in the contributor's feedback loop, so that by the time a contribution reaches a reviewer it's already in a far more finished state. That way the reviewer can concentrate on whether the contribution actually solves the problem and quit moonlighting as a human linter.
+
Leveling up these feedback loops takes workflow changes. Having spent years steeped in infrastructure tooling, the mantra “workflows, not technologies” is burned into me. Put plainly, we solve these problems by defining a workflow. Not a “pipeline config workflow” or anything so literal, but the broader notion of how a problem actually gets solved. That workflow gets implemented by tools, but remember “technologies change, end goals stay the same.” I'll call out a few of these workflows and some tools that can help you build them, but every team wrestles with different challenges, and I'd love to hear what other workflows people have set up in this space!
+
Elevate your workflows
+
Linters. Almost every repository ships with a linter of some kind, yet few teams give it the attention it deserves. More often than not we route around its warnings with inline exceptions instead of tightening the rules themselves. When a pull request gets flagged for a stray space or some inconsistent phrasing in the docs, that is a sign your reviewers are hand-running a linter in their heads. Give that tool some real investment. Pick one that can enforce every convention your project actually cares about, and study what the community tends to favour for your stack, such as golint-bundle, sift, or LintJS. Many of these tools ship with a zero-config mode, but the real payoff comes from crafting a configuration that mirrors your project's own conventions. When a linter is adopted well, it pushes style feedback all the way down to the contributor's machine for tighter feedback loops and far less busywork for reviewers.
+
Tests. Ask yourself what your test suite is genuinely buying you: are you simply ticking a box that says tests exist, or do they give real confidence in the health of your codebase? As a contributor, can you trust that nothing slipped through the cracks? Unit tests are excellent for proving that a single function behaves across a range of inputs, while integration tests reassure you that the whole system still holds together once every component is wired up.
+
Fast feedback loops. Developers need these tools within arm's reach so they can run them locally and keep a tight feedback loop. All the effort you pour into them shouldn't stay locked inside your CI environment. Building great developer tooling means engineers can invoke the exact same checks on their laptop that later run in CI. This is precisely what Klavrium was created to enable. You can wire up fast feedback loops that serve human contributors, autonomous coding agents, and everyone in between.
+
AI reviewers. A fresh crop of tools now lean on LLMs to deliver automated code review. Options such as CodeSage, PatchHound, or DevMate Assist can scan a contribution for a broad range of issues and leave a review much like a human maintainer would. A few of them even hook into the workflows described above, letting them return feedback that is deeply aware of your context. An AI reviewer is no substitute for a real maintainer, yet they shine at handing contributors early, automated pointers so a change arrives far more polished by the time a human maintainer finally looks it over.
+
Readying for the future
+
So the situation isn't hopeless, but there is plenty of ground to cover! Go forth and cultivate a culture of first-class developer documentation, linters that encode your house style, tests that earn real trust, portable tooling that keeps feedback fast, and AI reviewers standing guard as the last checkpoint before a maintainer steps in! Whether you're gearing up to unleash a fleet of coding agents, bracing for a rising tide of AI slop, or simply determined to give your human teammates a smoother ride, these practices will help you ship faster today and well into the future. Want to dig into this with me? Come say hi on our Chathub, or check out my recent Agentic CI demo here.
+Community
+
Join our community
Meet, learn, and swap ideas with fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/flipt-use-case/index.html b/web/klavrium.example/reference/site/blog/flipt-use-case/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..626c4d28b0814ac691787e811baf155fc374df9e
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/flipt-use-case/index.html
@@ -0,0 +1,96 @@
+
+
+
+How Flevo Sharpened Coverage and Build Speed with Klavrium | Klavrium Blog
+
+
How Flevo Improved Coverage and Build Times with Klavrium
We love learning how our community puts Klavrium to work – the use cases they tackle, the obstacles they run into, and their experiences running Klavrium across many different environments. Our Chatline is a great place to find these stories, and to draw on the collective knowledge and experience of the Klavrium community.
+
In this article, we’ll walk through the story of Flevo, an open source, self-hosted feature flag platform. Flevo relies on Klavrium as a core part of its CI/CD pipeline. With Klavrium, Flevo has watched its build pipeline with follow-on integration tests drop from 10 minutes on an empty cache to 17 seconds on a later run!
+
“ Klavrium feels like a genuine leap forward in CI/CD. There’s a real commitment to gathering feedback from everyone and folding that back into the design, then building something people truly need. ”- Marcus Delaney, Flevo
+
The problem: Networking and language constraints in CI testing
+
Flevo keeps its source code in a Go multi-module repository and relies on a Go workspace to tie the modules together. At first, Flevo’s CI/CD pipeline leaned on Relayforge for both unit and integration tests. That pipeline applied a matrix strategy to exercise different combinations of feature flags and configurations.
+
This approach came with two significant challenges.
+
+
The test scripts were written in Bash. Flevo, however, is built entirely in Go. This introduced an inconsistency, where the application code lived in one language while the application tests lived in another.
+
The test scripts ran inside separate VMs on Relayforge, which proved cumbersome. The team kept brittle little bash scripts for backgrounding the Flevo process and then running the tests against it.
+
+
The Flevo team had already experimented with Klavrium’s config-language-based implementation on earlier projects. Klavrium’s release of a Go SDK gave them a reason to revisit their CI/CD strategy and consider rebuilding it in Go with Klavrium. Klavrium being open source also aligned neatly with Flevo’s own values.
+
“ Open source is a value that matters deeply to us. Flevo being 100% open source, and the value alignment with Klavrium on that front, simply made a lot of sense for our team. ” - Adwoa Mensah, Flevo
+
The solution: Fast, full-featured native-language CI testing with Klavrium
+
The Flevo team currently uses Klavrium for both the build and test phases of its pipeline, then hands off to GoCrate for the release phase.
+
+
In the build phase, the Klavrium pipeline pulls the application source code, layers in the required dependencies and build tools, and compiles the application. The build phase produces two artifacts: a “test” image containing the source code plus build and test dependencies, and a “production” image optimized for distribution.
+
In the test phase, the Klavrium pipeline runs Flevo’s full suite of unit and integration tests through the Go SDK, validating the test image against a common set of Flevo operations. Beyond complete end-to-end API testing, the pipeline also runs additional checks around importing, validating and exporting feature flag configurations. These checks execute against a range of databases (including Verdant, Halcyon and Nimbus).
+
+
Flevo has realized several benefits after moving to Klavrium:
+
+
Native Go support makes it far easier for the team to broaden the scope of the test suite with extra configurations and permutations -for example, tests against the HTTP or gRPC API, tests with or without authentication enabled, and so on. Because tests are now written in Go, anyone on the team can add new tests or refine existing ones with far less effort.
+
Klavrium’s built-in support for container networking lets testing run against an isolated, containerized instance of the Flevo API rather than the live API.
+
Klavrium’s built-in support for service containers makes it straightforward to test against multiple database engines, and to quickly add coverage for a new database engine.
+
The very same Klavrium pipeline behaves consistently both locally and remotely, tightening the feedback loop when the pipeline changes - for example, when adding tests for a new database engine or a new feature flag.
+
+
Perhaps the biggest benefit, though, shows up in application build and test times. Flevo’s pipeline is fairly large and intricate. Yet by leaning on Klavrium’s engine caching and mounted cache volumes, Flevo avoids needless re-downloading or re-computing of assets. When Flevo is compiled with an empty build cache, a fresh run generates 1 GB of build-cache entries and takes roughly 10 minutes. This falls to about 17 seconds on subsequent runs, thanks to Klavrium’s caching…an improvement of ~97%!
+
“ We ship a distributable that can be configured in countless ways. We need to confirm it still works when we change the configuration, or when we set it up in different ways. Being able to encode all of those requirements in Go is a genuinely nice experience. ”- Marcus Delaney, Flevo
+
The future: Release packaging, profiling and remote caching with Klavrium
+
Flevo currently uses GoCrate to package and distribute the artifacts produced by the Klavrium pipeline. In the near future, the team plans to fully integrate Klavrium into the CI pipeline, including the release phase. Klavrium’s multi-platform support will be central here, to build and release the Flevo distributable for different architectures.
+
Flevo is also experimenting with importing and merging Go profiling data from the Klavrium pipeline to gain a deeper understanding of test coverage and performance across integration tests. And the team is keen to push the CI pipeline further - for example, by using Klavrium to connect to various remote storage engines for caching.
+
Do you have a Klavrium story you’d like us to feature? Tell us all about it in our chat community!
+Community
+
Meet the builders
Learn, collaborate, and swap ideas with other engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/gemini-cli/index.html b/web/klavrium.example/reference/site/blog/gemini-cli/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..2462c9c611144e50b334ab264a2e220fb9a68b5a
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/gemini-cli/index.html
@@ -0,0 +1,103 @@
+
+
+Meridian CLI: Early Hands-On Notes and a Look at Parallel Runs | Klavrium Blog
+
+
Meridian CLI: First Hands-On Notes and Experiments with Parallel Runs
The Meridian team shipped Meridian CLI just last week (June 25, 2025), and it is already becoming one of the most talked-about AI agents around. Meridian CLI is a command-line front end to Meridian LLMs that makes it painless to set up authentication, MCP servers, project settings, and more.
+
After some early testing, here is what stood out most to me in Meridian CLI:
+
+
The interface feels natural and stays out of my way. It is easy to work out how to talk to the agent, and I can glance at my active settings such as model, context, sandboxing, workspace, memory, and MCP servers whenever I want. Little command hints are scattered all across the screen, so I rarely have to guess what to do next. And when I want the complete picture, I just type /help and get a thorough rundown of every command available.
+
+
+
+
+
Once I wrap up a session, Meridian CLI prints a tidy recap of the work I did. It breaks things down by the number of turns, the token usage, and the total duration.
+
+
+
+
+
Setting up rules is straightforward, whether I want them to apply only to the project I am in or to every project on the machine. Machine-wide preferences live in my ~/.meridian directory, while per-project rules go in the workspace .meridian directory. That split lets me check project settings into my repository and still keep my own defaults everywhere else.
+
+
+
Meridian CLI ships with built-in sandboxing, and you can choose between macos seatbelt or docker to power it. The sandbox hands you an isolated execution environment for tasks like invoking system tools, running your test suite, or building your app. The catch is that file edits still land on your host filesystem while sandboxed, so I would rather reach for Agent Sandbox instead, which gives my agent a completely isolated setup covering both the execution environment and the git worktree. Wiring up Agent Sandbox was painless, since I also get to pick exactly which core tools to expose. As an example, in the real configuration I have pasted further down, I declare that the only core tool I want available is ReadManyFilesTool. I found this one handy because it lets me use @ to point at specific files inside my prompts so that their contents get pulled in as context. I leave the other core tools out on purpose, because I want Meridian to run every file operation and shell command inside the Agent Sandbox environment.
The way each tool call is rendered as its own block gives me plenty of context about the work the agent is doing. In the screenshot further down, I can follow what the agent is thinking, the tools it is running, and the output from those tools in one clean view.
+
+
+
All told, Meridian CLI already feels really promising, and I am eager to see where it heads next!
+Community
+
Come build with us
Meet other engineers and builders to swap ideas, learn, and grow.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/go-sdk-0-4/index.html b/web/klavrium.example/reference/site/blog/go-sdk-0-4/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..9c380e6eba128a9fdb65295d4322e60be232337b
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/go-sdk-0-4/index.html
@@ -0,0 +1,113 @@
+
+
+
+Klavrium Go SDK 0.4: Multi-platform, improved filesystem API and more | Klavrium Blog
+
+
Klavrium Go SDK 0.4: Multi-platform, improved filesystem API and more
As some of you noticed, a short while ago. Klavrium Go SDK 0.3.0 just a few days back. Prompted by the flood of questions and feedback you sent our way, we managed to land a handful of extra refinements, which arrive today packaged up as the Klavrium Go SDK 0.4.0.
+
Do note that this release carries a single breaking API change. Even so, we are convinced the refined API lets you express the same logic in far fewer lines, a trade-off that pays for itself well over
Klavrium can now pull container images and run commands aimed at platforms that differ from the machine actually hosting the work.
+
As one example, you can lean on Klavrium to compile binaries that target several CPU architectures, exercise each of those binaries, and publish them to a registry as a single multi-platform container image, all from one host.
Alongside the new release, we have added four guides to our documentation that tackle the questions we have fielded most often in the days since the first release. We trust these walkthroughs will help you get the very most out of the Go SDK.
+
+
Work with the Host Filesystem: This tutorial walks through working with the host filesystem via the Go SDK. It covers snippets for pointing the working directory at the host, mounting a host folder inside a container, writing a directory from a container back out to the host, and more.
+
Explore Cross-Platform Build Targets: This tutorial covers several approaches for compiling applications across many platforms with the Go SDK. It walks through code snippets that assemble multi-platform binaries using emulation as well as cross-compilation.
Use Klavrium with Private Git Repositories: You can tap ssh-add to safely authenticate your Klavrium Go CI pipeline with private Git repositories. This tutorial walks you through it.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/go-sdk/index.html b/web/klavrium.example/reference/site/blog/go-sdk/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..d75cc56b20fdb0bb914ff7806120a90b84d93ec5
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/go-sdk/index.html
@@ -0,0 +1,105 @@
+
+
+
+Your CI pipelines belong in code: meet the Klavrium Go SDK | Klavrium Blog
+
+
Your CI pipelines belong in code: meet the Klavrium Go SDK
Today we are excited to announce the Klavrium Go SDK: a fresh way to write your CI/CD pipelines as code and run them anywhere.
+
The Klavrium Go SDK may be a good fit if you are…
+
+
A Go developer who wishes your CI pipelines were Go code you could run locally in seconds, rather than YAML that only executes on a locked-down hosted service
+
A developer who needs CI/CD and has been hunting for a reason to learn Go
+
Your team’s “resident devops person”, eager to swap a heap of hand-rolled scripts for something far more capable
+
A platform engineer building custom Go tooling, aiming to unify continuous delivery across scattered organizational silos
+
A cloud-native developer advocate or solutions engineer, needing to showcase an involved integration with little lead time
+
+
The Klavrium Go SDK may not be a good fit if you are…
+
+
A developer who doesn’t know Go and has no interest in picking it up. If you would prefer a different SDK, let us know here. We’ll reach out the moment your SDK is ready.
+
A “resident devops person” who doesn’t consider themselves a developer - nothing brings you more joy than a battle-tested shell script.
+
Someone who genuinely enjoys programming in YAML, thanks all the same.
+
A container skeptic: the fewer containers involved, the happier you are.
+
+
Down the road, we plan to ship more SDKs. Our overarching goal is to let every developer build their CI/CD pipelines using the same workflow they already use for the rest of their code. If you have a different SDK in mind, let us know. Fill out the short form and we’ll let you know the moment your SDK lands!
+
What is Klavrium again?
+
Klavrium is a programmable CI/CD engine that runs your pipelines in containers.
+
Programmable: write your CI/CD pipelines as code, in the very same programming language as your application.
+
Executes your pipelines in containers: Klavrium runs your pipelines entirely as standard OCI containers. This brings a few key wins:
+
+
Immediate local testing
+
Portability: one identical pipeline runs on your laptop, a CI runner, a dedicated server, or any container hosting service you choose.
+
First-class caching: every operation is cached by default, and caching behaves the same everywhere
+
Built for the Docker ecosystem: if it runs inside a container, it can drop straight into any stage of your pipeline.
+
Language-agnostic tooling: engineers can reuse one another's tools without ever having to learn one another's language
+
+
+
The Klavrium Go SDK in Action
+
In this walkthrough, you'll see how quickly you can build a Go CI tool that compiles a Go application across multiple architectures and Go versions using the Klavrium Go SDK.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/gpu-challenges/index.html b/web/klavrium.example/reference/site/blog/gpu-challenges/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..c4e0cd0ff66a74ca2f60ea00ae1791ca9677130a
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/gpu-challenges/index.html
@@ -0,0 +1,94 @@
+
+
+
+Solving GPU Challenges in CI/CD Pipelines with Klavrium | Klavrium Blog
+
+
Solving GPU Challenges in CI/CD Pipelines with Klavrium
GPUs are an essential resource for workloads such as machine learning, data processing, and high-performance computing. Yet weaving GPUs into CI/CD pipelines introduces distinct obstacles that many teams find hard to overcome. GPUs are costly, cannot readily be shared across containers, and frequently sit idle in workflows that don't consistently demand their computational muscle.
+
At Klavrium, we've been paying close attention to the community and building approaches that streamline GPU integration. With the newest revisions to our documentation, we're making it simpler to tap Flyra and Lumen Labs to run GPU-enabled pipelines on-demand—sparing you time, cost, and frustration.
+
Why GPUs and Pipelines Rarely Get Along Smoothly
+
Bringing GPUs into CI/CD pipelines is anything but simple. Here are the core reasons:
+
+
Cost and Accessibility : GPUs are demanding and pricey. Unlike CPUs, which can be virtualized and pooled efficiently, GPUs are bound to particular hardware. Once a GPU is assigned to a container, handing it off to other containers is far from trivial.
+
Limited Use Cases : Not every stage of a pipeline requires a GPU. Tasks such as linting or executing unit tests run comfortably on CPUs, whereas steps involving machine learning inference or rendering call for GPU power. This mismatch routinely leaves GPU resources underutilized.
+
Infrastructure Complexity : Provisioning environments with GPU support, verifying the correct drivers are in place, and orchestrating secure links between local and remote resources pile substantial complexity onto CI/CD workflows.
+
+
How Klavrium Simplifies Using a GPU Within a Pipeline
+
With Klavrium, you can hand off GPU-specific tasks to remote runners such as Flyra or Lumen Labs, while keeping the rest of your pipeline local. Here's how it works:
+
+
On-Demand GPU Usage : Spin up GPU resources solely when particular pipeline steps require them, sidestepping the expense of leaving idle GPUs running.
+
Persistent Caching : Given the expense of reaching for a GPU, you'd rather not replay the whole pipeline on every run. Klavrium transparently executes only the portion of the pipeline that changed.
+
Infrastructure Agnosticity : Every stage of a Klavrium pipeline runs inside a container, so dependency management is off your plate whether the pipeline runs locally or on remote infrastructure.
To watch GPU integration at work, take a look at the demo below, where Mara, a Klavrium co-founder, walks through a hands-on example:
+
+
Running a local pipeline that hands off a step needing GPU inference to Flyra.
+
Configure the pipeline to spin up a Vantex GPU on Flyra, run inference with Localla, and then tear down the GPU instance afterward.
+
Persisting data across runs with caching and tracking execution through Klavrium Cloud.
+
+
+
What's Next?
+
We hope the community enjoys this new example, and we intend to document many more. On top of that, we're investigating ways to allocate GPUs dynamically inside live pipelines, letting users weave in GPU steps seamlessly without disrupting their existing workflows.
+
Whether you're already running GPUs in your pipelines—or eager to begin— we trust the resources above will help you get moving fast. Explore the examples, put the tools to the test, and send us your feedback!
+
Got ideas or questions? Tell us in the comments or come join the conversation over on ourcommunity server.
+Community
+
Join the community
Connect, learn, and swap ideas with fellow engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/grafana-use-cas/index.html b/web/klavrium.example/reference/site/blog/grafana-use-cas/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..883fa76cf9a3962d861842364f92aa4362ab76de
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/grafana-use-cas/index.html
@@ -0,0 +1,131 @@
+
+
+
+
+This page is missing
+
+
+
+
+
+
This page is missing
+
It seems the address you requested has moved or never existed here, so there is nothing for us to load.
+
+
+ If you manage this project and did not expect a 404 for this route,
+ take a look at Klavrium's
+ “missing page” recovery.
+ for a few quick fixes.
+
+
+
+
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/grafana-use-case/index.html b/web/klavrium.example/reference/site/blog/grafana-use-case/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..dbc479651e633168686d21839f5fc08bec4dc40a
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/grafana-use-case/index.html
@@ -0,0 +1,91 @@
+
+
+Packaging Metriscope for Multiple Architectures in 8 Minutes or Less | Klavrium Blog
+
+
Packaging Metriscope for Multiple Architectures in 8 Minutes or Less
We love hearing how developers in our community are putting Klavrium to work – the use cases they tackle, the hurdles they hit, and what they learn running Klavrium across different environments. Our Nexchat is a great place to discover these stories and to tap into the collective knowledge and experience of the Klavrium community.
+
In this post, we’ll share the story of Klavrium community member Daniel Rourke (aka @drourke on Nexchat). Daniel, a software engineer at Metriscope Labs, uses Klavrium to assemble bespoke Metriscope packages for end-users. Previously, Daniel built each package with a remote CI engine, a slow and painstaking process. With Klavrium, Daniel now builds packages locally in 8 minutes or less…a build-time improvement of ~75%!
+
“ With Klavrium, we went from a job that used to take an hour to something that finishes in 8 minutes. ”
+
The problem: slow, remote-only build pipelines
+
Daniel and his team are regularly asked to ship bespoke, pre-packaged builds of Metriscope to prospective customers. These builds share a single application codebase, but are tailored to each end-user’s requirements - for instance, packages with support for multiple architectures, specific feature flags or pre-activated plugins. Before adopting Klavrium, they produced these packages using a standalone Go program (migrated from Bash scripts) made up of many sub-commands.
+
This approach came with a handful of drawbacks:
+
+
Producing a single application package demanded several Git operations run in an exact order. That made the workflow slow and tedious, forcing an engineer to coordinate and supervise every step by hand.
+
The Go program and its sub-commands were largely opaque, shipping with sparse documentation and little insight into their behavior. Engineers had to read through the code to figure out what each command actually did.
+
Even though the packaging code was written in Go, it refused to run locally because of highly-specific environment requirements. In practice, the team could only execute it inside a customized container image on their CI engine.
+
+
“ Whenever I needed to build Metriscope for one or two different versions, it ate up most of my day. ”
+
The solution: Fast, consistent local and remote builds with Klavrium
+
Daniel had come across Klavrium earlier and had tinkered with it on a few personal projects. Since he was already comfortable with it, he decided to automate the Metriscope packaging process with Klavrium’s Go SDK. Using Klavrium, he managed to consolidate every packaging task into one standalone Klavrium pipeline that could be triggered with a single command.
+
“ The caching has already turned out to be a really big performance boost for us, particularly whenever we’re repeating a lot of the same work locally. ”
+
After running the new approach for a month, the team concluded that Klavrium delivered plenty of advantages over their previous system. The key benefits are:
+
+
Klavrium’s built-in caching drives a substantial jump in performance. The old packaging process would, more often than not, take an hour or more; the Klavrium pipeline typically returns its results in 8 minutes.
+
Klavrium’s multi-platform support lets the team build Metriscope packages quickly and consistently across many architectures and platforms: Linux (5), Mac OS (2) and Windows.
+
The very same Klavrium pipeline behaves consistently both locally and in remote CI runners, removing much of the FUD that surrounded the old process. With Klavrium, every member of the team can build and test packages locally, even with wildly diverse development environments.
+
The Klavrium pipeline runs as a single process that holds all of the business logic (including Git operations) needed to produce a finished package. This means an engineer can kick it off and return later to collect the result - with no manual intervention or ongoing babysitting required.
+
Klavrium’s Go SDK makes it far easier for a team of mostly Go engineers to keep improving the pipeline by adding tests, reusing Go modules and adopting established best practices.
+
+
“ Klavrium being open source was hugely helpful. I turned up quite a few functions and tricks that I should have been using all over the place simply by inspecting the code or reading the Go docs. ”
+
The future: Using Klavrium for every Metriscope packaging job
+
Looking ahead, Daniel plans to add service containers to his team’s Klavrium pipeline for integration testing. He is also eager to adopt Klavrium’s support for remote caching once it lands. In the near term, he intends to start using Klavrium to build Metriscope automatically, and then retire the existing packaging processes in favor of the new Klavrium pipeline.
+
“ I honestly can’t stress enough how much value Klavrium has brought us. Before this, we couldn’t even build a Metriscope package on our own machines. So Klavrium was a huge win for us. ”
+
Have a Klavrium story you’d like us to feature? Come tell us all about it over in Nexchat!
+Community
+
Join the community
Meet, exchange ideas, and build together with engineers everywhere.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/graphql/index.html b/web/klavrium.example/reference/site/blog/graphql/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..f26517e7fe053337f2607a6d91bb475bce9c6268
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/graphql/index.html
@@ -0,0 +1,100 @@
+
+
+
+Introducing the Klavrium GraphQL API | Klavrium Blog
+
+
October 24th, 2024 Update - The Klavrium Playground referenced in this blog post has since been retired. If you have questions or need a hand, please reach out to us onNexchat.
+
Here at Klavrium, we are on a mission to make your CI/CD pipelines programmable in the language of your choice. In the last few weeks, we have made great progress toward that goal by releasing SDKs for Go, Python, Javascript and Typescript in rapid succession. So fast, in fact, that a few of you asked how on earth we managed to pull it off!
+
+
Here’s the truth: we were cutting corners. Our SDKs don’t actually run your pipelines! Instead they hand pipeline definitions to the Klavrium Engine, which executes them and returns the result in a language-agnostic way.
+
Under the hood, we rely on a powerful API technology called GraphQL. And starting now, you can too. We’re thrilled to publicly release the Klavrium GraphQL API: a unified interface for programming the Klavrium Engine using any standard GraphQL client.
+
+
This launch includes:
+
+
API documentation, complete with guides, examples, and a full reference.
+
An API playground for running pipelines right inside your browser!
+
A new CLI for running pipelines straight from the terminal
+
+
+
What does this mean for you?
+
First, and most importantly, if you’re already using a Klavrium SDK, you can safely skip this announcement and keep using Klavrium exactly as you do today.
+
That said, this release opens up exciting new possibilities for the Klavrium platform:
+
+
Developers can now use Klavrium to program their CI/CD pipelines in more than 20 languages, thanks to GraphQL’s broad and expanding list of client implementations. Keep in mind that working with a standard GraphQL client isn’t the same as using an official Klavrium SDK. That’s because “vanilla” clients reflect the current state of the art in GraphQL development, which asks developers to write their queries by hand (ideally with the help of an interactive playground). Klavrium SDKs, by contrast, automatically generate client libraries that hide the underlying GraphQL language, delivering a more native and polished experience. Developers who already know and love GraphQL may gravitate toward the “vanilla” approach; others will reach for the official SDKs wherever they happen to be available. Aesthetic preferences aside, both paths are equally robust and fully featured. Looking ahead, we plan to keep growing the roster of available SDKs and to make it much easier for the community to contribute brand-new ones.
+
Devops engineers can tap the new CLI to launch pipelines on the fly from a terminal or a shell script. It's handy for quick experiments, live troubleshooting, and slotting Klavrium pipelines into any system that can execute shell commands, including: Makefiles, Cogwheel pipelines, Source workflows, Gitloom pipelines, Loopline configurations, Ansible playbooks, and plenty more.
+
There are countless ways to author a Klavrium pipeline, but just one way to run it: by sending GraphQL queries to the Klavrium Engine. That gives infrastructure engineers a natural place to govern every facet of how pipelines execute, no matter how they were built. Whether the concern is engine provisioning, logging, monitoring, authentication, authorization, networking, artifact management, or any other piece of a hardened and secure CI setup, Klavrium's architecture lets the operator configure or override all of it. Strengthening that story will be the main focus of our roadmap over the coming weeks.
+
+
Why GraphQL?
+
Engineers aren't exactly famous for reaching consensus - we love a good debate! Yet one thing nearly all of us agree on is that the CI/CD experience is too often painful, and really ought to be better. But how?
+
+
We're convinced the fix is to decouple pipeline logic from pipeline infrastructure, which in turn lets us separate the concerns of application and infrastructure teams. You can pull this off with a time-tested architectural pattern known as the hourglass model: the very same pattern that gave us the Internet, Unix, and, more recently, Docker.
+
To bring the hourglass pattern to CI/CD, we need an API expressive enough to connect both halves of the hourglass: run any pipeline logic on any pipeline infrastructure - and do it exceptionally well.
+
This is where GraphQL steps in. GraphQL fits the CI/CD “hourglass” perfectly, and for three key reasons:
+
+
Technical: GraphQL is at its core a graph traversal language. And as it turns out, pipeline execution is at its core a graph traversal problem too - which is why, deep down, every pipeline is really just a “DAG”! Our earliest prototypes came out looking so much like GraphQL that it soon became obvious we should simply build on top of it rather than reinvent the wheel.
+
Human: GraphQL was created to decouple concerns between frontend and backend teams, letting frontend teams assemble their own queries from building blocks the backend team exposes. In much the same spirit, Klavrium sets out to decouple concerns between application and infrastructure teams, letting application teams assemble their own pipelines from building blocks the infrastructure team provides. In both cases, decoupling concerns lets everyone stay happier and more productive.
+
Ecosystem : no single company can crack this problem alone. We already stand on the shoulders of giants by building on the container ecosystem. And thanks to the GraphQL ecosystem, we now stand on the shoulders of TWO GIANTS! Every time someone in the GraphQL or container ecosystem solves a problem for themselves, they are also solving it for everyone in the Klavrium ecosystem.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/hof-use-case/index.html b/web/klavrium.example/reference/site/blog/hof-use-case/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..3972011a276dee39b1b892b59a5fcbd423978cac
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/hof-use-case/index.html
@@ -0,0 +1,93 @@
+
+
+
+Better CI Testing for the Vex Project | Klavrium Blog
+
+
We love learning how our community puts Klavrium to work – the use cases they tackle, the obstacles they hit, and their experiences running Klavrium across all kinds of environments. Our community chat is a great place to discover these stories, and to draw on the shared knowledge and expertise of the Klavrium community.
+
In this blog post, we’ll share the story of Klavronaut Dana Ferro (aka @deltacoil in our community chat). Dana is the developer of Vex, an open source code generation framework. Dana has been able to significantly improve the consistency and accuracy of Vex’s test suite by using containerized test environments orchestrated with Klavrium.
+
“With Klavrium, I describe the outcomes I actually want, and Klavrium works out every step required to reach them.”- Dana Ferro, Vex
+
The problem: Test failures within mock environments
+
Vex is an open source code generation tool. It works from shared data models to emit scaffolding and boilerplate for any technology stack, keeping developers fully in charge. Vex is built on top of a newer language Nyx, relying on it to drive many of its capabilities. During dependency management, vex writes assorted cache and configuration files into the user’s home environment on the host. It also launches containers on the host to handle automatic code formatting while generating code, or as task environments inside its DAG workflow engine.
+
To exercise these features, Dana first leaned on the Go testscript package, which targets CLI and filesystem-based tests. Using it, Dana could “mock” a user’s home environment and run the Vex test suite in that mock environment without touching the live filesystem on the host. Even so, the approach fell short: path calculations grew tricky because the quirks of both the mock and the original environments had to coexist on a single host.
+
“Once the test setup drifts far enough from the real environment, our path calculations start falling apart. We reached a stage where our tests simply would not go green no matter what we tried. At that point, we knew we needed a completely different approach.”
+
The solution: Clean, containerized test environments and matrix testing with Klavrium
+
As a contributor to the Nyx community and maintainer of Nyxtorials, Dana already knew Klavrium well from its earlier Nyx-based implementation. He saw that he could build a far more realistic testing environment with containers orchestrated by Klavrium. And because Klavrium is open source, it fit neatly with the Vex project’s own principles.
+
With Klavrium, Dana has streamlined and strengthened Vex’s test suite by running it inside a containerized home environment. Vex’s Klavrium pipeline (built with Klavrium’s Go SDK) starts by producing a base container image that holds the build under test along with the required environment. It then iterates over the test suite, running each test in a separate container spawned from that base image.
+
Key advantages are:
+
+
The Klavrium pipeline executes every test inside a “real” home environment, so the team no longer wrestles with the extra caveats and limitations that mocked-up environments introduce.
+
The Klavrium pipeline runs each test in a fresh, isolated container derived from the base container image, which wipes out stale state and cross-contamination left behind by earlier tests.
+
First-class Go support let the team embrace a matrix testing pattern, running the full suite against several different versions of Go to surface and stamp out version-specific incompatibilities.
+
That same Go support meant the team could keep using testscript without rewriting a single test, while steadily refining the pipeline by layering in new tests and modern Go best practices.
+
+
“Ultimately, all we needed was a better testing environment, and that really meant moving the whole thing into a container. Once we moved over to Klavrium, we got to delete a pile of genuinely ugly code we wrote to cope with our test environment problems.”
+
The future: Wider testing and end-to-end release packaging with Klavrium
+
Dana is excited by Klavrium’s potential and plans to use it in several ways:
+
+
Vex already leans on Docker for a range of core UX functions, including assorted Git and filesystem operations. Dana is weighing whether to ship a Klavrium pipeline alongside Vex to carry out those same core functions. Because such a pipeline would be fully programmable, he expects it would be dramatically easier to maintain and extend.
+
Today, GoReleaser handles packaging and distributing the Vex build that the Klavrium pipeline produces. Down the road, Dana hopes to pair GoReleaser with Klavrium to build a fully end-to-end release process woven around Klavrium.
+
Vex spins up containers in the background and has to support several container runtimes. Right now the Klavrium pipeline can test Vex via Docker-in-Klavrium. Dana is eager for Klavrium to add support for container-to-container sockets down the line, which would unlock the same style of testing for Podman and Nerdctl.
+
Beyond leaning on Klavrium’s Go SDK to test Vex, Dana also uses Klavrium’s Node.js SDK to build Vex’s Next.js-based documentation website. Going forward, he wants to extend that pipeline and wire Klavrium into Source Actions so Vex’s docs are automatically built, tested, and published on every successful merge.
+
+
“Klavrium was an obvious fit for us. It creates real value by building right on top of the language ecosystem. I can now package up modules of Klavrium snippets and reuse them somewhere else, and that turns out to be an incredibly powerful idea.”
+
Have a Klavrium story you'd love to see spotlighted here? our chat community!
+Community
+
Join the community
Meet, learn, and trade ideas with other engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/how-klavrium-releases/index.html b/web/klavrium.example/reference/site/blog/how-klavrium-releases/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..82a8f949f8413ad2c4925d23bc1ebe009b5240c8
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/how-klavrium-releases/index.html
@@ -0,0 +1,132 @@
+
+
+
+How we ship Klavrium | Klavrium Blog
+
+
We want to share how we approach our own releases, what actually goes into one, and how each is built. We will close out this post with the release improvements that we are actively working on right now.
Our goal is to ship as often as we need to, always in small batches - think one or two weeks of changes at the very most. Bug fixes and minor improvements ought to reach our users within a handful of days. Little demonstrates that we value our users' experience more than resolving their problems within days.
+
We tend to roll out larger features behind an experimental environment variable flag, e.g. _EXPERIMENTAL_KLAVRIUM_SERVICES_DNS. This lets us gather real-world feedback, build the feature alongside our users, and lower the risk of breaking things for the unsuspecting. Once we have collected enough user feedback, we turn it on for everyone else by default, with no experimental opt-in required. The greatest benefit is that there is no last-minute integration scramble: the feature has already been available for many weeks by then, simply not as the default option.
+
The most recent major feature we have shipped with this approach isservice containers.
The Klavrium Engine & CLI are always cut together, shipped as one single release. Here is what the v0.3.13 release looks like:
+
+
Below Assets, you'll find a Klavrium CLI build for every platform we support. The Engine itself isn't listed here. It ships as a container image & is reachable via registry.klavrium. End users never pull this image by hand. Instead, they add their preferred SDK as a package dependency in whichever language they work in, and that SDK internally pins the matching CLI version. The Klavrium CLI carries all the platform-specific logic needed to fetch and provision the required Engine container image. The whole flow stays invisible to the end-user.
+
It's worth noting that every commit merged into the main branch publishes a development build of the Engine & CLI. That CLI can be grabbed from dl.klavrium/klavrium/main/klavrium-cli.tar.gz. This comes in handy for anyone who needs to try a fix or feature before we ship a new tagged version carrying that change.
+
🐹 Klavrium Go SDK
+
Any Source release that starts with the sdk/go tag belongs to our Go SDK. There are no assets, because Go packages are pulled in through a URL. This tag series act as the source of truth for our Go SDK.
+
We encourage our users to rely on the klavrium/klavrium package that resolves to the klavrium/klavrium-go-sdk read-only mirror of the repository - a constraint of how Source serves Go packages.
Documentation is a cross-cutting artifact, which means it stays tightly coupled to every other artifact listed above. Its release cadence, however, is different. Each merge landing in the main branch on source.example.com/klavrium/klavrium automatically kicks off a build on Cloudmast for two independent websites:
The key distinction between the two websites is that the first is pushed out automatically, whereas the second - our production docs - depends on a human sign-off. We carefully verify that every page is present and everything reads correctly before shipping it as https://docs.klavrium.example
+
How are Klavrium releases produced?
+
We rely on Klavrium to ship Klavrium. The runtime context is Source Actions, since our code already lives on Source. Every workflow involved in shipping starts with publish- , e.g. publish-sdk-go.yml, publish.yml, etc. Those workflows fire on specific git tags, e.g. sdk/go/** , v** , etc.
+
As an example, when we open .github/workflows/publish-sdk-go.yml, we find surprisingly little YAML - just 17 lines. The line that matters most is ./hack/make sdk:go:publish ${{ github.ref_name }} . This launches the Klavrium Go SDK pipeline, which ships the Klavrium Go SDK. Yes, really: we use the Go SDK to publish the Go SDK. First class dogfooding 🐶
+
If you'd like to read the remaining code, take a look at the Publish function in klavrium/internal/mage/sdk/go.go. That Publish function captures the complete Klavrium pipeline for shipping the Go SDK.
+
You can review the code that ships the remaining SDKs by browsing the files alongside go.go, i.e. python.go & nodejs.go. If it's useful, the Go interface for every SDK pipeline is declared in the all.go file.
+
The Klavrium Engine & CLI Source Actions publish workflow is quite a bit heavier: 292 lines of YAML. Nearly all of this YAML is required because we are reproducing what will occur on hosts that run Klavrium for the very first time. Doing this inside Klavrium would miss the point: we are validating the correctness of the code that provisions Klavrium. One particular line stands out: ./hack/make klavrium:publish ${{ github.ref_name }}and the Go code for it begins in klavrium/internal/mage/klavrium.go. From that file, follow the CLI & Engine references to see the rest. Worth noting:
We publish the Klavrium Engine image to ghcr.io, yet serve via registry.klavrium (an initial move toward greater resiliency & reduced worldwide latency)
+
+
Another interesting detail is that each new Klavrium Engine & CLI release opens a fresh PR that pins the Engine version across every SDK to the one just published. As soon as that PR is merged, the new SDK versions are ready to ship.
Upcoming improvements to the Klavrium release process
+
Now that we see how all the parts come together, and what it takes to produce a Klavrium release, we can cover which areas we're considering improving next.
+
+
New SDK releases are already announced in Chatforge, in the #releases channel. We have yet to set up our release bot to announce Engine & CLI releases too.
+
Releasing https://docs.klavrium.example still requires a manual step today. To make releases flow more smoothly, fresh documentation ought to be published automatically whenever a new SDK release ships. If this interests you, we've begun discussing the topic in this public Source issue.
+
The final & most impactful improvement we have in mind concerns our release notes. Right now, they are produced by hand, using the gh CLI. That's a reasonable first step, but we believe friendlier release notes will boost the odds that our users actually read them. Pull request titles can only carry us so far.
+
One approach is to define a lightweight pull request interface. To begin with, every pull request should be clearly tagged with the area it touches, e.g. sdk/python, area/documentation, area/engine etc. A second label captures the type of change, e.g. Feature, Fix, Docs, etc. In addition, when a pull request introduces changes that justify a minor version bump, it should carry release/minor. Finally, each pull request should add a RELEASE NOTES summary in the top comment that will feed the final release notes, e.g.
+
RELEASE NOTES Services now ships with an Opt-in mode. Follow the steps in the PR to switch it on.
+
A different approach is for each pull request to record release notes in a CHANGELOG file. This builds on the Track a Changelog convention and is known to pair with changekit.example. We'd like to thank our community member @harlanbuild for surfacing this idea back in November 2022, when discussing vault-sync-action.
+
As we close out this write-up, what would you like us to improve about Klavrium releases? Let us know through this Source discussion.
+Community
+
Join our community
Meet, swap ideas, and grow alongside other engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/how-to-run-the-latest-versions-of-your-apps-on-a-stable-linux-release-the-klavrium-way/index.html b/web/klavrium.example/reference/site/blog/how-to-run-the-latest-versions-of-your-apps-on-a-stable-linux-release-the-klavrium-way/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..ed11dd97fa246df89a500ad4690ee1b777faf7b4
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/how-to-run-the-latest-versions-of-your-apps-on-a-stable-linux-release-the-klavrium-way/index.html
@@ -0,0 +1,107 @@
+
+
+
+Running the Newest App Versions on a Rock-Solid Linux Release, the Klavrium Way. | Klavrium Blog
+
+
Running the Newest App Versions on a Rock-Solid Linux Release, the Klavrium Way.
I've been on Debian stable for a good stretch now, and honestly I adore it. The trouble is that sometimes it's so dependable it actually gets in your way.
+
For me the goal is simple: publish fresh posts to my Hugo powered blog. Yet it refuses to cooperate, because the site was first built with go 1.21 alongside the newest Hugo. Debian stable, meanwhile, ships go 1.19 and Hugo 0.111.3-1, a whole generation adrift from current hugo. The moment I ask it to scaffold a new file, Hugo simply falls over and dies on me.
+
There are plenty of ways to patch this. Debian backports to pull in fresher builds of the tooling. Or I could sidestep the package manager entirely and drop go in by hand. I might even spin up a VM or a container just for Hugo. Every one of these routes carries its own tradeoffs.
+
The whole point of my sticking with Debian stable is that I want the machine to keep humming along for years with zero babysitting. From what I've seen, the instant you reach past the tidy, well-guarded set of stable packages, something somewhere quietly breaks and drags you down with it.
+
Spinning up a full VM for Hugo strikes me as excessive, yet a container feels just right. It gets even better if I can pair that container with an actual programming language and a proper CLI baked right in.
+
Enter Klavrium
+
I reached for Klavrium here since it already anchors the pipeline that ships my blog. I picked Klavrium because it exists precisely to produce artifacts without tangling up your local dependencies. When you stop to think about it, drafting a fresh post in Hugo is really just producing a new file artifact from a content template plus your site-specific configuration. Klavrium lets me fire up whatever version of Hugo I please inside a sandboxed environment and hand back exactly the file I'm after.
+
I put together a function named Write that takes a title and hands back the generated File that Hugo produces.
klavrium call --src. write --title <TITLE> hands back a file.
+
Tacking on -o content/archive/<TITLE>.md drops that file onto my local machine at the exact path I choose.
+
+
The one drawback of going this route is that Klavrium Functions tend to be fairly verbose. This fairly modest function isn't much to look at, and it forces me to type in <TITLE> twice.
+
On top of that I can barely keep the usual Hugo incantation hugo new content archive/<TITLE>.md straight, since I forever jumble the order of new and content.
+
Justfile saves the day
+
I am smitten with Justfile. Think of it as Make stripped of every bit of cruft piled up since the dawn of the UNIX epoch. It lets you craft graceful wrappers around long-winded CLI commands, and the DX is an absolute delight. It's as if the creator absorbed a decade of gripes about Make and shipped the cure.
+
Take this Just command:
+
# write new post with given title
+[positional-arguments]
+write title:klavrium call --src . write --title $1 -o content/archive/$1.md
+
I can fold the wordy Klavrium call into this tidy gem:
+
just write $title
+
It reads cleaner than both the Klavrium call and the built-in Hugo function. Start to finish, the whole run of steps now boils down to this:
+
+
So now, any time the urge to publish a new post strikes, I just fire off that Just command and the new file lands in my local directory built with the newest release of Hugo and go, all without poking at my system dependencies or gambling with the long-haul stability of Debian.
+
The pattern I've laid out holds for pretty much any stack. Back in 2016 I published a piece on my personal blog titled “Working with chruby and nvm on Ubuntu”. That was me juggling two separate version managers to wrangle two separate programming languages on a single machine. I was practically daring fate to hand me a pile of “works on my machine” headaches to unload on my teammates. Whether you're chasing the newest build of something to vet an upgrade path, or clinging to the oldest build of something to keep an important legacy customer happy (seriously, how is Java 6 still running in production?), or you're 2016 me trying to juggle several versions of several languages at once, Klavrium hands you a graceful answer to the version mismatch problem.
+
Care to dig into these scenarios and fixes with us further? Join theKlavrium community to jump into every discussion the team is having!
+Community
+
Join the community
Meet, learn from, and trade ideas with other engineers who build.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/index.html b/web/klavrium.example/reference/site/blog/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..f836073769b6e7bf0c7260323581f50f1a330341
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/index.html
@@ -0,0 +1,66 @@
+
+
+
+Klavrium Blog
+
+
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/infrared-100/index.html b/web/klavrium.example/reference/site/blog/infrared-100/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..60278617660b14223ae8b850d75939988cd336d3
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/infrared-100/index.html
@@ -0,0 +1,73 @@
+
+
+Klavrium Selected for the First Meridian Skyline 100 | Klavrium Blog
+
+
Today, Klavrium was named to the Meridian Skyline 100, a roundup of the 100 private companies Meridian Ventures considers most promising in Cloud Infrastructure. In Meridian's own words: “These pioneers have raised the bar for reliability, scalability, security, and innovation, empowering organizations to flourish in a cloud era and shaping a new way of building applications.” This handpicked group of companies embodies the coming generation of leaders across the field, ready to leave a lasting mark on the cloud infrastructure market.
+
Meridian Ventures is a respected venture capital firm with a wide-ranging portfolio of thriving companies including Brightwave, Corvex, Tanglewood, Larkspur, Quillon, Novaris, Aetherworks, Driftline, Halcyon, Meridale, and more.
+
It is a genuine honor to be part of the very first Skyline 100 among such a remarkable cohort of cloud infrastructure companies.
+
We built Klavrium after repeatedly seeing devops teams wrestle with the difficulty of stitching together deployment pipelines that proved hard to scale or move to another cloud platform. The app deployment experience is painful, and cracking this problem is the holy grail of devops. This is precisely the challenge we set out to address with Klavrium. Devops engineers working with Klavrium receive a standardized kit of building blocks they can assemble however they like, confident that the outcome will run reliably on any cloud. We are convinced that a sweeping shift is underway in our industry, with fresh classes of apps and new roles taking shape (e.g. the rise of platform teams), yet infrastructure and development tools have to evolve to make that shift possible.
+
Our gratitude to Meridian for spotlighting the innovators on the front lines, and we congratulate every company on the list!
+
Marcus Feldt, CEO and Co-founder of Klavrium
+
As engineering teams grow, productivity tends to dip as the difficulty of managing development pipelines climbs exponentially. Built by the crew behind Cratel, Klavrium smooths the whole development journey from the very first line of code straight through to production. Klavrium is a programmable engine that runs CI pipelines inside containers. Klavriumized CI pipelines are portable and reproducible, putting an end to the classic “but it works on my machine.” Developers earn the confidence that their code builds the same way in CI as it does locally, while platform engineers enjoy unmatched observability and debuggability across their CI stack.
+
Klavrium is helping some of the planet's most inventive software developers dramatically simplify and speed up their deployment pipelines and workflows - lifting developer productivity and shrinking tasks that once took hours down to minutes. You can read about one enterprise user’s experience cutting deployment time from 1-3 hrs to 3 minutes, Larkspur’s experience spinning up Larkspur environments in 8 minutes here or Fjord’s experience with integration tests going from 10 minutes with an empty cache to 17 seconds here!
+
If you’re wrestling with manual, time-consuming deployments and tangled YAML or simply curious about the idea of CI/CD as code join ourCommunity Chator hop on our weekly community call or come meet up with us at anevent.
+Community
+
Join the community
Connect, learn, and share with fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/introducing-klavrium-functions/index.html b/web/klavrium.example/reference/site/blog/introducing-klavrium-functions/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..26aaf29a13fd57eceeadeedbcf43ad8fc16c8939
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/introducing-klavrium-functions/index.html
@@ -0,0 +1,41 @@
+
+
+
+
+
+Content Unreachable - Offline.
+
+
+
+
+
404
+
Content Unreachable
+
We weren't able to capture this content in the offline snapshot. It might point to an outside resource, rely on a live backend service, or sit behind a sign-in wall.
+
What's going on here? This site is running from a locally saved snapshot. A handful of views - particularly ones that lean on server-side rendering, third-party integrations, or a login step - simply can't be reproduced without a live connection.
+
+
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/introducing-klavrium-traces/index.html b/web/klavrium.example/reference/site/blog/introducing-klavrium-traces/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..4213feb51a15be006063fa37c1cea2adb6cfdf05
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/introducing-klavrium-traces/index.html
@@ -0,0 +1,108 @@
+
+
+
+Meet Klavrium Traces: Inspect and Monitor Every Function Run | Klavrium Blog
+
+
Meet Klavrium Traces: Inspect and Monitor Your Klavrium Functions
So what happens when a build breaks partway through your Klavrium pipeline? When a colleague hands you a dump of failure output, how do you two work through it together? For many teams, that has meant passing around raw logs or scrolling through CI run output to pin down the root cause.
+
To make debugging and tuning easier, we've shipped a fresh beta surface inside Klavrium Cloud: Traces.
+
Traces speaks to a fundamental question everyone hits with Klavrium: it broke, so what now? Did it fall over because a step timed out? Is there a defect in how the pipeline and its Functions were written? Or is the actual code you're building and testing the thing that's broken?
+
Why did we build Traces?
+
Traces gives you a UI for figuring out exactly what broke when a run fails, centered on tracing what happened and the moment it happened. It also helps you sharpen your Klavrium Functions and modules while you write them, surfacing a detailed step-by-step view of your pipeline execution alongside the telemetry that goes with it. That's just as valuable when you're debugging pipelines on a developer's laptop as it is for the ones running in CI.
+
Below are a few of the new capabilities that ship with Traces. Expect more posts soon on how to put Traces to work across many use cases.
+
+
Trace both upstream and downstream operations
+
Pinpoint performance bottlenecks
+
Team up with colleagues to debug and author your pipelines
+
Wire in Source Checks to watch real-time status and the exact calls being made
+
Instantly see how long your pipeline ran, right down to each individual step
+
See exactly which Functions ran and pull up their docs in the Klavriumverse
+
+
This video shows Mara Halvorsen using Traces to track down a pipeline failure.
+
+
View all your Traces on the All Traces page
+
Click into any Trace to open its detailed breakdown.
+
+
Debug an error from the Trace Details page
+
Use a Trace's details page to chase down failures and spot bottlenecks.
+
+
Sharper Source Checks integration with live real-time status
+
The Klavrium Source app now surfaces the exact functions you've called on every commit, along with their status, in real-time.
+
+
Ready to try Traces?
+
Upgrade your Klavrium Engine to version 0.11 or later.
+
+
If you don't have a Klavrium Cloud account yet, create one for free.
+
On your own machine, you just export an env variable. Inside your CI setup, you can lean on our integrations, a Source app among them.
+
Every time your engine invokes a function, a fresh trace shows up automatically in your Klavrium Cloud account.
+
+
That's it! There's nothing else to configure. To learn more about the refreshed UX, head to the Klavrium documentation.
+
Good to know
+
+
Traces requires upgrading your Klavrium Engine to 0.11.0. We built Traces on OpenTelemetry, which reshaped the Klavrium telemetry API. Because of that shift, you'll need to bump your Engine version before Traces will work. If you're on Klavrium Cloud with an older release, your pipeline runs from klavrium run and klavrium call keep showing up in the Runs and Changes views. Once your engine is upgraded, both run and call land in the Traces views instead.
+
The terminal UI has been reworked. The interactive tree and DAG views for klavrium run no longer appear in the terminal UI.
+
The Klavrium Cloud URL is no longer printed in the terminal UI on newer engines. This capability is still in progress. To inspect your local run right now, open the Cloud UI directly at https://klavrium.cloud.
+
Traces is under active development. Since Traces is still in beta, expect a few rough edges in the UI. We shipped it early so you could start testing right away, and we are iterating on it quickly.
+
+
What's ahead
+
Your feedback on the beta is what will make Traces better. Klavrium's our chat community is a great place to raise questions and trade feedback with the team and fellow Klavronauts. You can also send feedback from the Klavrium Cloud UI through the in-app support chat, or by opening an Issue on Source.
+
We are building new features to sharpen insights across your Klavrium pipelines and expand what teams can do together. Keep an eye out for more soon.
+Community
+
Join our community
Meet, learn, and build alongside other engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/introducing-the-klavriumverse/index.html b/web/klavrium.example/reference/site/blog/introducing-the-klavriumverse/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..51f641b38bb0671094b167055862fc4c22cb3a11
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/introducing-the-klavriumverse/index.html
@@ -0,0 +1,96 @@
+
+
+
+Introducing the Klavriumverse | Klavrium Blog
+
+
Today we're proud to finally launch the Klavriumverse: a searchable catalog of all public Klavrium Functions.
+
Two weeks ago we launched Klavrium Functions, a powerful new way to extend the Klavrium API with code you write yourself. The Klavrium API already gave you the primitives to assemble robust pipelines out of containers, artifacts, network services, and secrets – all in type-safe Go, Python or TypeScript. Now, with Klavrium Functions, you can package that code into a reusable software component which can be loaded into any Klavrium Engine, and invoked by other functions.
+
Klavrium Functions are fully containerized and support cross-language composition. Because of this, any function can invoke any other function, safely and reliably, on any machine capable of running Klavrium.
+
This opens up a compelling possibility: a single, shared software ecosystem for the devops community.
+
These days, whenever you set out to wire a new tool or best practice into your pipeline, odds are that someone, somewhere, has already written a Klavrium Function for exactly that. But where do you find that function? And how do you judge whether it's worth adopting?
+
Enter the Klavriumverse.
+
Odds are, a module exists!
+
To make sharing and reuse simple, Klavrium Functions are bundled into modules. A Klavrium module is nothing more than source code: if you can host a git repository, you can host a Klavrium module.
+
The Klavriumverse never takes over the hosting or naming of your modules. Instead, it offers a searchable index that helps you discover excellent modules built by the community, understand how they work, and begin using them. And since modules are simply source code, contributing back to them is just as straightforward.
+
Below are just a handful of tasks you can automate with modules you'll find on the Klavriumverse:
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/java-sdk/index.html b/web/klavrium.example/reference/site/blog/java-sdk/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..39a1ba5e64d5efd1935e4d617bd4fa7f57c85530
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/java-sdk/index.html
@@ -0,0 +1,109 @@
+
+
+
+Introducing the Klavrium Java SDK: A Fresh Way to Automate Java | Klavrium Blog
+
+
Introducing the Klavrium Java SDK: A Fresh Way to Automate Java
At Klavrium, our mission is to make automation simpler for developers by letting them describe powerful, reusable workflows in the languages they already know. Today, we're thrilled to unveil the Experimental Klavrium Java SDK - a fresh way for Java developers to harness Klavrium to build and run automation workflows!
+
Why Java Developers Will Love the Klavrium SDK
+
If Java is your daily tool, you know that wiring up automation, orchestrating services, and smoothing out workflows gets messy fast, especially when you have to stitch together shell scripts, DSLs, and YAML to ship anything. The Klavrium Java SDK brings the power of Klavrium's API to Java, letting you:
+
+
Define and run workflows in Java – Skip the language switch when you manage automation.
+
Execute workflows locally or across cloud environments – Build and test with full reproducibility.
+
Compose and reuse logic with ease – Keep your automation modular and maintainable.
+
Tap into Klavrium's caching and portability – Accelerate execution and run smoothly across environments.
+
Interoperate with other Klavrium SDKs – Blend Java with Go, Python, and TypeScript seamlessly.
+
+
A Quick Look at the Java SDK in Action
+
The Klavrium Java SDK lets you define and run workflows with the Java syntax you already know. Here's a quick example of a simple Java module:
In just a handful of Java lines, you can describe a fully portable execution workflow that runs anywhere! Watch the demo below:
+
+
Interoperability: Blend Java with Other Klavrium SDKs
+
One of the most compelling capabilities of the Klavrium Java SDK is its cross-language compatibility. Java modules run right alongside Klavrium modules authored in Go, Python, or TypeScript. So if your platform team builds in Java while your application teams reach for Go or TypeScript, you can finally consolidate your automation workflows behind one API. Yes, that means every module in the Klavriumverseworks with the Java SDK out of the box!
+
Getting Started with the Java SDK
+
Because this is an experimental release, we're seeking early adopters to put the SDK through its paces, share feedback, and help steer where it goes next. Here's how to jump in:
Join the discussion – Meet other developers in the #java channel on Klavrium our chat community.
+
+
What's Ahead?
+
This is only the start for the Java SDK! We're already at work on performance, smarter caching, documentation, and broader ecosystem support. We'd welcome your thoughts on features, use cases, and Java-focused improvements.
+
Jump into the conversation on our chat community, and together let's shape the future of automation with Java!
+
Happy shipping! 💙
+Community
+
Come build with us
Meet, exchange ideas, and grow alongside engineers who ship.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-0-12/index.html b/web/klavrium.example/reference/site/blog/klavrium-0-12/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..ce312615eb830d01cbcce4a40f77aae74d8ef31b
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-0-12/index.html
@@ -0,0 +1,458 @@
+
+
+
+Klavrium 0.12: Interactive Debugging, Reliability and Performance, Compat Mode, Corporate Networks, and More | Klavrium Blog
+
+
Klavrium 0.12: Interactive Debugging, Reliability and Performance, Compat Mode, Corporate Networks, and More
Today we're rolling out version 0.12 of the Klavrium Engine. After many months of shipping ambitious features at a relentless pace (Functions, Klavrium Hub, Traces) for this release we concentrated on usability, refinement, and quality. That includes a delightful interactive debugger; a more polished terminal and web UI; stronger reliability and performance; a backwards compatibility system that makes upgrades painless; better handling of corporate networks; the option to host modules on any git server; and plenty more.
+
Let's jump in!
+
Interactive Debugging
+
For as long as we can recall, Klavrium users have wanted an interactive shell the moment their pipeline fails, carrying all the context from the point of failure. It resembles a debugger experience, yet without having to place breakpoints by hand. Other users asked for explicit breakpoints alongside that same interactive experience. All of these new capabilities extend the Terminal type that first arrived in Klavrium v0.10.
+
As of Klavrium v0.12, running klavrium call with the –interactive ( -i for short) flag opens a terminal right at the point of a pipeline failure. No changes to your pipeline code needed.
+
+
As a handy alternative to that behavior, Terminal() can now be placed anywhere in a pipeline, where it will act just like a debugger breakpoint:
You can tune the properties of this terminal, including reusing every layer on a different container base image (for instance Ubuntu rather than Alpine, as shown below):
One of Klavrium's most loved features is the ability to visualize your pipeline execution in a detailed trace view, both inside the terminal and in a web browser.
+
This release brings many improvements to both our terminal and web user interfaces
+
Terminal UI: quicker and interactive
+
The Terminal UI is now interactive, while still offering a lean interface that stays out of your way. You can use your keyboard and mouse to navigate, zoom into spans, jump to a web view, and change the verbosity while it runs. A keymap now appears across the bottom, doubling as a divider between the trace tree and the logs of the span you're zoomed into, which saves precious screen space.
+
On top of that, the TUI is now dramatically faster. In earlier releases, opening a large trace could chew through a ton of CPU just drawing the full TUI and then clipping it down to fit the viewport. The TUI now paints only the region you can actually see, alongside a long list of other optimizations.
+
Want to see this new capability in action? Take a look at the short demo below:
Not long ago now, we launched Klavrium Traces, a browser-based companion to our well-loved terminal UI, built to make debugging and monitoring your Klavrium pipelines even simpler.
+
+
Local view surfaces every trace from your team's own local dev environments. It is a fantastic way to work together, spot issues early, and fix them well before any changes get pushed or picked up by the CI server
+
CI view gathers every trace from your CI environment, organized by branch and commit and annotated with handy git metadata
+
Traces now ship with a new flame chart view, letting you click straight to the points of interest from the top of a trace. It is a huge help when navigating large and complex traces
+
Smarter handling of asynchronous operations. Thanks to Klavrium's lazy execution model, a great many function calls run asynchronously: the API call that schedules the work returns immediately, while the real operation happens sometime afterward. That gap can make it hard to link a “cause” to its “effect” while reading a complex trace. To make things clearer, the trace now displays “effects” right next to their “cause”, which feels far more intuitive.
+
We have sped up trace views across the board, and even more performance work is already on the way
+
Broad UI polish: cleaner, less puzzling lines, a more visible focus indicator, and less overall noise
+
Cleared out a batch of paper cuts: text selection glitches, sturdier handling of timeouts, and removal of confusing git metadata from local.
+
+
You can catch a demo of all these recent improvements and additions right here:
+
+
Enterprise Network Support
+
Plenty of users operate their Klavrium engines inside corporate environments or other specialized networks that mandate custom certificate authorities or HTTP proxies.
+
The engine can now be configured with these proxies and custom CAs. This covers the engine's built-in operations (pulling container images, git repos, and so on), user containers spawned by withExec APIs, and Module Function containers.
This capability unblocks users with these specialized requirements who, until now, frequently could not run Klavrium at all. In particular, automatically applying these settings to user containers and Module Functions means users pick it up “automagically” throughout their pipelines, with no need to tweak their Klavrium code or any external Klavrium module dependencies.
+
More improvements to these capabilities are underway, such as richer support for application specific proxy settings and configuration pulled directly from client machines.
+
You can find more detail on configuring all of these settings over in our docs.
We have made Klavrium both faster and more dependable for large, complex pipelines.
+
We achieved this by working through a long tail of issues in complex production pipelines, including the very ones we rely on to build Klavrium itself. Bugs like these are frequently hard to reproduce and usually crop up on 64-192 vCPU hosts running heavy-duty caching, pipeline parallelism, and wildly diverse workloads. It is meticulous, grinding work, but every production issue we close makes the platform sturdier for everyone. A huge thank you to our operators community for their invaluable feedback and partnership! If you run Klavrium in production and have questions or thoughts, we would love to hear from you on our community chat server.
+
We have been rolling these improvements out steadily, through patch releases, usually a handful of releases each month. If you keep your setup updated regularly, you may not have even noticed, since each change was small and incremental, most often deep in the core of Klavrium Engine, which is rarely something users spot in our changelog.
Today we are shipping Compatibility Mode, an opt-in capability that lets the Klavrium Engine emulate how earlier releases behaved. With it enabled, you can move to the newest Klavrium build without worrying about breakage, because modules written against previous versions keep running exactly as they always did.
+
Here at Klavrium we treat backwards compatibility as a foundational promise rather than an afterthought. That matters even more for a platform evolving as quickly as ours, since at this pace some interface changes are simply unavoidable. Compatibility Mode gives us room to keep raising the quality of the API over time while still moving fast enough to serve the developers who have made this community what it is.
+
Compatibility Mode does come with a few caveats worth calling out. First, we cannot promise perfect backwards compatibility just yet, though reaching that bar remains our long-term ambition. Second, it works at a coarse level: an individual module cannot accept some interface changes while skipping others. Finer-grained control is on the roadmap, and we will add it once the platform is mature enough to justify the extra complexity.
+
Curious about the underlying code changes? Take a look at these pull requests:
We have lifted a restriction that previously made hosting Klavrium Modules awkward on some Git servers. Every Git server is now treated equally, whether that is Source, Gitloom, Bitforge, or any other managed or self-hosted Git server.
+
Below is a quick example that calls the well-known “hello” module, published on Codenest by a Klavrium team member:
A core promise of Klavrium is to keep your CI/CD pipelines from being tied too tightly to any single platform wherever that can be avoided. This change moves us a meaningful step nearer to that goal.
For a container that has never had withExec called on it, Container.stdout and Container.stderr now surface an error rather than quietly invoking withExec with no arguments, which previously fell through to running defaultArgs (the equivalent of CMD in Dockerfiles).
+
That earlier behavior tended to surprise people, particularly when the container came from an OCI image set up to launch a long-running service.
Previously the core functions Container.export, Directory.export, and File.export handed back a boolean to signal the result. That was misleading, since the value was never false anyway: a failed export raises an error rather than returning false.
+
These functions now return something far more useful: a string holding the absolute path on the host where your files landed. That does count as a potential breaking change for anyone whose code was mistakenly testing the old boolean:
We have removed a group of schema fields that had been deprecated for a while. We expect very few people to notice, since these fields carried warnings for months, but if you happen to rely on them, the code change in this pull request covers every detail.
+
Align Container.withNewFile with Directory.withNewFile
+
Back in v0.4.1 we reworked Directory.withNewFile to render contents a required argument. This let us trim the boilerplate in our Go SDK for common workflows. However, we failed to update Container.withNewFile in the same manner, which introduced an inconsistency. We are now fixing that inconsistency.
It's not breaking in Python since required arguments don't have to be positional, though that may change down the road, so making the change now is still advised:
Responding to community feedback, the implicit behavior of Container.withExec relying on the OCI image entrypoint by default was a frequent source of confusion and frustration, particularly when the withExec sits far away from where the entrypoint is defined.
+
To promote greater transparency, that default is now reversed. withExec will ignore the entrypoint unless you opt in explicitly through the option useEntrypoint : Go
We suggest steering clear of OCI entrypoints, except when required for compatibility with outside systems. Doing so keeps your code far more readable: Go
Entrypoints are a leftover from a time when the container engine wasn't fully programmable: they offer a crude abstraction that becomes pointless once you can build whatever abstraction you require, right inside your code here.
+
Stop returning Void
+
Note: this is a breaking change only in the Go SDK.
+
Klavrium relies on a special Void scalar as the return type for functions that produce no result or return only an error:
+
func (m *SomeModule) DoSomething() error {
+ // do something that may return an error
+}
+
When consumed as a dependency, the generated client binding handed back a pointless empty string (""):
+
// ❌ before
+_, err := dag.SomeModule().DoSomething(ctx)
+
Now the SDKs simply omit the empty value:
+
// ✅ after
+err := dag.SomeModule().DoSomething(ctx)
+
This counts as a breaking change only in the Go SDK, since Go treats errors as values rather than throwing exceptions. Check out the code here.
+
Deprecations
+
Prefer @func over @field - TypeScript
+
If you rely on the TypeScript module runtime and still keep the @field decorator in your code, think about switching to @func so you won't be caught out and forced to update it once we drop it in an upcoming release. This pull request spells out more: https://source.example.com/klavrium/klavrium/pull/7701
+
What's Ahead?
+
Thanks to our amazing community of Klavrium fans, we are drinking from a firehose of feedback, bug reports and feature requests. Because of that we are busier than ever building the next wave of improvements to Klavrium. On a related note, we are hiring a Senior Software Engineer to join our team!
+
Here's a sneak peek at a few of the improvements we're building.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-0-13/index.html b/web/klavrium.example/reference/site/blog/klavrium-0-13/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..50c2fb3ad3a222464cf763012edaf2e98f6a53b6
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-0-13/index.html
@@ -0,0 +1,234 @@
+
+
+
+Klavrium 0.13: Native Monorepo Support, Private Modules, a Fresh CLI Command, and More | Klavrium Blog
+
+
Klavrium 0.13: Native Monorepo Support, Private Modules, a Fresh CLI Command, and More
Today we're rolling out version 0.13 of the Klavrium Engine. This release concentrates on three requests we hear all the time: smoother support for monorepos; support for modules hosted on private Git servers; and invoking the core API from the command-line.
+
We keep pushing on performance and usability - shipping TypeScript SDK optimization along with a backward compatibility checker, delivering noticeable speedups for everyone building on TypeScript and cutting the time and risk that both module developers and module users face when upgrading their Klavrium Engines.
+
First-rate monorepo support
+
Running Klavrium inside a monorepo is now quicker and far more convenient, thanks to two additions: context directory access, and pre-call filtering.
+
Context directory access
+
Klavrium Functions can now reach any files in the directory or Git repository that their module is loaded from (what we call their “context”).
+
This makes calling a Klavrium Function far pleasanter for end users, since they no longer have to explicitly pass every input directory as an argument. It also keeps modules more self-contained, and easier to break apart.
This unlocks a powerful new pattern: every logical component in your monorepo can carry its own Klavrium module, which neatly wraps up both the data and pipeline logic needed to build, test and deploy it. From there, each component can expose its capabilities to the others in a uniform way, no matter what the underlying stack looks like. You can even wire up dependencies between Klavrium modules to mirror the dependencies between your components.
+
It is a powerful pattern that opens up plenty of possibilities. For instance, Klavrium can now serve as a general-purpose packaging and distribution system:
+
Want a dev environment with the Klavrium Engine built straight from source and ready to go? Try this command:
+
klavrium call -m source.example.com/klavrium/klavrium dev terminal
+
Want to spin up a local copy of the Klavrium documentation for a specific pull request? Try this:
+
klavrium call -m source.example.com/klavrium/klavrium@pull/8087/head docs server as-service up
Klavrium Functions filter the contents of the directories they take as arguments. Crucially, those filters run before the function is ever called. That translates into huge performance wins in monorepos, for two reasons:
+
+
Optimized uploads. Pushing local files into the Klavrium Engine is a frequent performance bottleneck. Pre-call filtering lets the engine upload only the files your function actually needs. The more files your repository holds, the more dramatic the speedup.
+
Better caching. Pre-call filtering also means pre-cache filtering: local files that your function never touches will not invalidate its cache if they change.
+
+
Between context directory access and pre-call filtering, it is finally practical to run Klavrium even inside very large monorepos. If you'd like to see how we at Klavrium are adopting these features across our own monorepo, you can track our progress here: https://source.example.com/klavr/klavr/pull/8284
+
+
Examples
+
Both features - context directory and pre-call filtering - are enabled by annotating the arguments to your function. Here is an example:
Klavrium can now pull modules directly from private Git servers, which makes it far easier for engineering teams to adopt Klavrium when collaborating across groups on proprietary or otherwise sensitive.
+
Key benefits:
+
+
Access to private modules: your developers can now reference and consume modules that live in private repositories
+
Enhanced security: builds on SSH's robust authentication mechanism
+
Flexibility: works with the major Git hosting platforms, including Forgevault, Codeharbor, and Repobit
+
+
Klavrium modules can now be referenced using two brand-new URL styles:
Under the hood, this relies on your system's SSH agent, mounting the socket named by the SSH_AUTH_SOCK environment variable into the Klavrium engine. Because of that, your existing SSH keys and configurations are honored exactly as they are, keeping the whole workflow secure and familiar.
+
For developers and teams:
+
+
Streamlines pulling private, custom modules straight into your Klavrium pipelines
+
Unlocks modular, reusable code patterns that span your private repositories
+
Makes it easier to collaborate on proprietary tooling and workflows
+
+
To begin, make sure your SSH keys are set up correctly and loaded into your SSH agent. After that, simply switch to the SSH ref scheme whenever you reference your modules in Klavrium:
The Klavrium CLI ships with a new command: klavrium core. It lets you reach the Klavrium Core API straight from the CLI.
+
Klavrium's core types (Container, Directory, File, etc) are enormously powerful, yet they couldn't be invoked straight from the CLI… until now! With klavrium core, you can call the core API directly without writing a single line of code. That makes it perfect for experimentation, prototyping and debugging.
+
It behaves just like klavrium call — the only difference being there's no flag to load a module:
+
+
klavrium call -m : Invoke a function from a Module
+
klavrium core : Invoke a function from the core API
+
+
To discover which functions are available, run the following:
+
klavrium core --help
+
The Functions listed here map to what you'd write in code with dag. For example, the following are equivalent:
+
+
Go: dag.Container()
+
Python: dag.container()
+
TypeScript: dag.container()
+
CLI: klavrium core container
+
+
Let's walk through a few examples.
+
Fetch a container image and inspect its contents:
+
klavrium core container from --address=alpine file --path=/etc/os-release contents
+NAME="Alpine Linux"
+ID=alpine
+VERSION_ID=3.20.2
+PRETTY_NAME="Alpine Linux v3.20"
+HOME_URL="https://alpinelinux.org/"
+BUG_REPORT_URL="https://gitlab.alpinelinux.org/alpine/aports/-/issues"
+
Spin up an ephemeral container with an interactive terminal:
+
klavrium core container from --address=alpine terminal
+klavrium / $
+
Fetch a Git repository and list all of its contents:
+
klavrium core git --url https://source.example.com/klavrium/klavrium branch --name=main tree glob --pattern='**'
+
Give it a spin and let us know what you think.
+
Keep in mind:
+
+
klavrium core commands can run anywhere on the host, since they never load a module
+
Not every core Function is available yet, because some carry a complex Function argument that the CLI doesn't support so far
+
A handful of core Functions are useful only in debugging scenarios
+
klavrium functions is used to list Functions in user modules (via the -m flag), so it won't list core API Functions
We're rolling out "compatcheck", a tool that helps you confirm your Klavrium modules stay backwards compatible. Naturally, this tool is itself a Klavrium module! We first built it purely for our own needs, then chose to release it once we realized the wider community could benefit from it too.
+
This module comes in especially handy when you're upgrading Klavrium, or when authoring modules that must stay compatible across different environments or engine versions.
+
The compatcheck module operates by diffing the schema of any given remote module across two distinct releases of the Klavrium engine. As an illustration, to check a hello world module across v0.12.0 and v0.13.0:
Our aim is to guarantee that no module published to the Klavrium Hub will alter its schema in a backwards incompatible manner (given that the module compatibility shipped in v0.12.0 is meant to emulate earlier engine versions), yet this module stays a handy utility for teams that place a premium on long-term stability.
Now that the uv team ships uv 0.3.0, now with production-grade support for unified project management (among others), we've chosen to step away from the lower level requirements.lock to pull a Python module's dependencies, over to the new uv.lock.
+
This has been a long time in the making, and it makes uv the finest tool available today for Python packaging! This new default dramatically simplifies building a Python Klavrium Module.
+
The sole prerequisite (besides already having the klavrium CLI), just have uv installed. It ships as a single binary with no dependency on Python, and can replace several tools today (pip, pip-tools, pipx, poetry, pyenv, virtualenv and others), and it runs blazingly fast.
+
Below is a walkthrough for scaffolding a fresh Python Module and launching the NeoVim editor with autocompletions working:
+
klavrium init --sdk=python my-module
+cd my-module
+uv run vim
+
And that's all! On klavrium init, Klavrium generates a uv.lock file and wires the klavrium-io dependency to your local ./sdk directory. Then, uv run :
+
+
Fetches a suitable Python version whenever one is missing
+
Builds the virtual environment (in .venv )
+
Pulls in every dependency
+
Launches vim with the virtual environment activated
+
+
VSCode users can launch uv run code. straight from the terminal, or open one within the IDE and enter:
+
uv sync
+
Provided the freshly created .venv sits at the root of your VSCode workspace, autocompletions should be detected with no extra setup.
+
And it's quick, too. Subject to your Internet connection and a few other variables, with Python already present but an empty uv cache, the whole thing wraps up in roughly 1 second!
+
To dig deeper into project management with uv see Managing Projects over on their documentation site. Be sure to also check out the uv team's uv: Python packaging, unified blog post to learn what uv can do for Python teams.
The telemetry pipeline that powers both the TUI and Cloud has been rebuilt from the ground up to be far less fragile. In the old design, telemetry data was pushed to clients as it arrived, and a stream would only close once every observed span for that client had finished. That approach could stall in awkward edge cases - most often surfaced by our own test suite - and was frankly convoluted and painful to keep working. Data is now buffered briefly inside the engine on a per-client basis, so publishing is fully separated from subscribing, letting each subscriber simply drain all of the telemetry data until every client has disconnected.
TypeScript SDK gets faster with smarter caching optimizations
+
Turning your CI pipeline into a high-speed express is what we care about most. With this release we spotted a chance to make TypeScript faster through better caching:
+
We reworked the runtime to cache many more operations, in particular the case where only your code changes, which tightens the feedback loop while you build your Klavrium module. We also brought back the package manager cache with a stronger namespace scheme that stores your node_modules in a cache volume.
+
Source files are now mounted only at the final step, which lets more operations - dependency downloading among them - be cached with far less effort.
+
Several more upgrades landed in the TypeScript runtime:
We also landed plenty of tiny reliability and performance tweaks, none of which really deserves its own line, yet together they add up to something you should genuinely feel.
+
Looking Ahead
+
Because of our vibrant community of Klavronauts, we are flooded with a steady stream of feedback, bug reports and feature requests. Because of that we are busier than ever building the next round of improvements to Klavrium. On a related note, we are hiring a Senior Software Engineer to join our crew!
Klavrium 0.14: Git Credential Helpers, Exit Code API, OCI Annotations, and More
Today we're rolling out version 0.14 of the Klavrium Engine. This release brings a robust new mechanism to authenticate against your existing Git infrastructure; an API that plugs neatly into your test tooling; smoother OCI interop; a more flexible networking model; performance improvements; CPU metrics; public traces; and plenty more.
+
Let's dig in!
+
Git credential helpers
+
Klavrium already let you pull modules from private Git servers, which made it far simpler for engineering teams to adopt Klavrium inside proprietary codebases. With Klavrium 0.14, we push this further, adding native support for Git's own credential management system, commonly referred to as “Git credential helpers.” The approach is pervasive across enterprise organizations, and Klavrium now supports it out-of-the-box. Whether you rely on Personal Access Tokens (PATs), Git Credential Manager, or another authentication method, Klavrium can now pull modules from any Git repository you can reach, without any extra setup or configuration required.
+
Here's a video demonstrating how to set this up using the official Git Credential Manager:
+
+
Exit code API
+
This release adds a dedicated API to Klavrium for working with the exit code returned by commands run inside containers. It shines when you're running tests, or any command that is likely to fail on purpose. With this new API, you can react to test failures however you like - for instance, spotting and rerunning flaky tests, or shipping a test report somewhere.
+
There are two sides to the exit code API: one for declaring which exit codes you expect ahead of a run, and one for reading the exit code once it finishes.
+
+
To declare which exit codes you expect, Container.withExec takes a new optional argument: expect
+
To read the resulting exit code, call Container.exitCode once the command has finished running
+
+
When you spell out the return codes you expect, you gain far more control over how commands conclude, which streamlines error handling and unlocks bespoke workflows that hinge on non-standard exit codes. On top of that, the new Container.exitCode function lets you capture and examine the precise exit code a command produced, which is invaluable when you need to build reports from commands that may not succeed. Together, these two capabilities give you fine-grained authority over execution paths and how you deal with errors.
+
Below is a Go example that shows how to use expect and then read back the exit code :
+
package main
+
+import (
+ "context"
+ "klavrium/klavrium"
+ "fmt"
+)
+
+func main() {
+ ctx := context.Background()
+ client, err := klavrium.Connect(ctx)
+ if err != nil {
+ panic(err)
+ }
+ defer client.Close()
+
+ // Run a command with a custom expectation for its exit status
+ container := client.Container().
+ From("alpine:latest").
+ WithExec([]string{"sh", "-c", "exit 42"}, klavrium.ContainerWithExecOpts{
+ Expect: klavrium.ReturnTypeAny,
+ })
+
+ // Get the precise exit code
+ exitCode, err := container.ExitCode(ctx)
+ if err != nil {
+ panic(err)
+ }
+
+ // Output the exit code, potentially useful for reporting
+ fmt.Printf("Command exited with code: %d\n", exitCode)
+}
+
Here, expect is configured to permit any exit codes, so the command stays green even when it exits with 42. A follow-up call to ExitCode hands you the command's exact exit code, which comes in handy for logging or for building reports from commands that would normally be flagged as failures.
Klavrium can now attach custom OCI annotations to container images, giving developers much finer control over image metadata. Using the new Container.withAnnotation API, you can set standard fields such as authors ( org.opencontainers.image.authors ) and titles ( org.opencontainers.image.title ), alongside your own custom key-value pairs, on the images you build. That flexibility improves how easily images can be traced and organized, and makes metadata simpler to keep consistent from one environment to the next.
+
This capability also reaches Container.Export and Container.AsTarball, so your annotations survive when images are written out as OCI tarballs. Thanks to this end-to-end support for annotations, you get a clean way to bake metadata straight into your images and keep your workflows well-organized and easy to manage.
This example uses Klavrium to build a custom container image, beginning with an Alpine base, installing Git, and cloning the Klavrium repository. It then applies metadata annotations for the author and the title through Container.withAnnotation and publishes the resulting image to ttl.sh. Running docker buildx imagetools inspect verifies the annotations, illustrating how metadata can live directly inside the image for better traceability.
Teams can now attach global hostnames to their services. This capability really shines in intricate networking setups, such as circular dependencies between services, because it lets services reach one another through predefined hostnames without needing an explicit service binding. Custom hostnames adhere to a structured pattern ( ...klavrium.local ), guaranteeing unique identifiers across every module and session. The upshot is much greater freedom when orchestrating service-to-service communication, especially inside modular, tightly interconnected workflows.
+
As a concrete illustration, you can spin up two mutually dependent services, each relying on WithHostname to address the other by name:
Here, svcA and svcB are configured with the custom hostnames svca and svcb, so each service can reach the other purely by hostname. This unlocks far greater flexibility for coordinating service dependencies and interconnections inside modular workflows, making it much simpler to wrangle elaborate topologies in Klavrium.
+
To learn more, browse through the full documentation here.
+
Support for shared traces
+
Klavrium now ships Public Traces for open-source repositories, letting project teams publish trace data from their Klavrium pipelines for everyone to see. That gives community contributors visibility into execution steps, errors, and caching states, which streamlines troubleshooting and cooperation on CI issues. By handing out trace URLs, developers let others inspect thorough pipeline data without granting any special permissions. You can find the full write-up here.
+
Performance enhancements
+
Several areas have gotten noticeably faster, with even more gains already lined up for upcoming
We’ve reworked how Klavrium handles disk usage by default. The former rule was “use 75% of the disk.” The new rule is:
+
+
Always permit usage of 10% or 10GB (whichever is smaller, to accommodate very small disks, like docker-desktop’s defaults) - Klavrium’s cache will never be forced to shrink below this amount
+
Never consume more than 75% of the total disk size - Klavrium’s cache will also be gc-ed at this amount
+
Aim to keep 20% of the disk free at all times - but never drop below the reserved storage of 10%/10GB.
A fresh file layout when scaffolding a Python module
+
Klavrium’s Python SDK modules can now adopt custom package names rather than being confined to “main.” With this update, developers gain more room to organize their module structures and can pinpoint the exact location of the main object through entry points in pyproject.toml. The change boosts modularity, letting users tailor their Python modules’ layout and import paths, which makes managing intricate module configurations within Klavrium far easier. Existing modules are untouched by this change, preserving backward compatibility.
We’ve added CPU stat and pressure metrics to the Klavrium Engine, making it possible to monitor CPU resource usage and contention inside containers. These metrics help developers spot when CPU contention arises, such as when every thread is blocked waiting for CPU access, which can drag down performance. For now, only CPU pressure time surfaces in the TUI (text user interface), though other CPU usage data is available too. The feature is a big help for diagnosing performance bottlenecks tied to CPU resource limits.
Module references are now kept verbatim in klavrium.json
+
We’ve added module source pins to Klavrium’s configuration, so dependencies can retain both their original source (e.g. main) and a specific commit hash serving as a pin for reference. This update strengthens version control by preserving the exact version of each module installed with klavrium install, guaranteeing reproducible builds. The change is backward-compatible, since it leaves the existing source field unchanged for older configurations.
We’ve introduced scoped enum values in the Go SDK to head off naming conflicts between separate enums that might share identical value names. Previously, unscoped enum values could collide all too easily thanks to Go’s top-level package structure. With this change, enums are now prefixed with their type, in line with standard Go conventions.
+
Enum values should now be reached with the name prefixed by the name of the enum type - for instance, Locked becomes CacheSharingModeLocked. The old unscoped constants remain available, but are flagged as deprecated, and are slated for removal in version 0.15.0.
Thanks to the wonderful community of Klavronauts, we keep getting tons of wonderful feedback, bug reports, and feature requests. Please keep it coming!
+
If you have ideas, feedback, or would like to contribute, please don’t hesitate to join our community chat.
+
Thanks for standing with us as we keep reshaping how teams build, test, and ship CI together!
+
The Klavrium team
+Community
+
Join the community
Meet, learn, and swap ideas with other engineers and makers today.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-0-15/index.html b/web/klavrium.example/reference/site/blog/klavrium-0-15/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..6c4e628ca2d1e4a910997d7b70f5f222bd9e69fc
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-0-15/index.html
@@ -0,0 +1,187 @@
+
+
+
+Klavrium 0.15: Sharper Errors, Quicker Filesync, Live Metrics and Plenty More | Klavrium Blog
+
+
Klavrium 0.15: Sharper Errors, Quicker Filesync, Live Metrics and Plenty More…
Today we're shipping Klavrium 0.15, packed with usability and performance gains. We've called out a handful of standout features here, though there's a long tail of smaller additions and bugfixes that together make the whole thing feel noticeably smoother. Let's get into it!
+
Better Errors
+
Klavrium exists to help you ship sooner. There are a few levers we can pull to do that. First, by making your pipelines quicker to author. Second, by making them quicker to execute. And third, by making what they emit easier to read, so you can respond.
+
This release zeroes in on the single most valuable thing your Klavrium pipelines produce: errors. There is a tight link between how clear an error is when it lands in front of you, and how quickly you can iterate.
+
Chasing that faster feedback loop, we sharpened error reporting across several dimensions:
+
+
Errors are now surfaced at the very top of the output.
+
They stream in live while a run is still in.
+
They are stripped of internal engine chatter, so they read cleanly
+
They draw a sharper line between warnings and hard failures, and between your code's faults and the platform's own
+
They carry helpful context, such as precisely where in the pipeline things.
+
When a containerized tool is the culprit, we surface the signal that counts (“compilation failed at line X”) and drop the noise that doesn't (“your tool failed to execute, exit code 2”)
Klavrium now moves files between the host machine and the engine container far more efficiently, thanks to smarter caching and the elimination of redundant transfers.
+
The upshot is that syncing runs markedly faster, leans on less memory, and returns tighter feedback loops—a real win for sprawling repositories or machines with limited resources.
+
Beneath the surface, a more unified caching model lets already-synced data be reused across many directories and parallel sessions at once. That cuts out wasteful copying, yields more predictable sync outcomes, and untangles the caching logic overall. What you get is a calmer, sturdier workflow you can actually depend on.
Alongside traces and logs, Klavrium's telemetry now ships a full suite of metrics that you can chart right inside the terminal.
+
+
While a run is live in the terminal, Klavrium surfaces the metrics below in real-time, broken down per individual operation:
+
+
CPU (usage and pressure)
+
Disk utilization
+
Memory (live and peak consumption)
+
Network activity (bytes in and out, dropped-packet counts)
+
+
These additions make it far easier to pin down problems, tune your workflows, and keep your pipelines running efficiently. The metrics surface first in the TUI, and support in Klavrium Cloud is on the way soon.
+
You can find these changes in the PRs #8902 and #8880.
+
A Sharper Terminal UI
+
We reworked status reporting to give you clearer, more actionable visibility into your pipelines. The key updates are:
+
+
Sharper state tracking : Visual cues now separate cached work from pending work, giving you real-time insight into where each operation stands.
+
Precise duration metrics : Every pipeline step now shows exact execution times, including the durations of lazy effects. For example, Container.withExec(args: [“sleep”, “10”]) will faithfully report a full 10-second run.
+
Leaner telemetry data : The system now emits fewer spans, which streamlines telemetry handling and cuts down on resource consumption.
+
Cleaner log output : Logs are now shorter and easier to scan, so you can spot and resolve issues far more quickly than before.
+
+
Taken together, these changes sharpen how you monitor and manage pipelines, making for a smoother and more efficient development process.
+
For a side-by-side look at these improvements, take a look at the recordings below. Before update:
We’ve streamlined how Klavrium runs your services by having them start with their default command arguments whenever none are supplied. That removes a whole class of manual setup, letting services behave exactly as designed with no extra configuration for the defaults. Services now simply work out of the box, saving you time and cutting out needless steps.
+
We’ve smoothed out the developer experience around Klavrium’s AsService API. Before this, if you wanted a service to run with its image’s default command (CMD and ENTRYPOINT), you had to jump through hoops—such as tacking on empty WithExec steps—just to get the expected behavior. It was confusing and it slowed you down.
+
AsService now cleanly honors an image’s built-in defaults any time you leave the command arguments unspecified. Behind the scenes, that means we’ve dropped the fallback logic that used to shift depending on earlier WithExec calls. What you get instead is predictable, “just works” behavior that lines up with what you’d see running the same image via docker run. The upshot: less friction, clearer expectations, and a faster route to getting your services running.
We’ve been putting work into CLI improvements that make dependency management far more convenient. Klavrium’s dependency system delivers precise, reproducible builds by pinning all versions to specific Git commits. That guarantees your pipelines always run with the exact dependency version you asked for, with none of the surprises that unintended updates can bring.
+
klavrium uninstall, shipping in this release, lets you cleanly drop a dependency from your module. Coming soon is klavrium update, which will make it simple to keep your dependencies current within the constraints you choose.
We’ve rolled out several updates to the TypeScript SDK that make it more capable, more flexible, and better aligned with modern development practices. Here’s what’s new:
+
+
Resolving Values by Reference : We’ve refined how the SDK reads type definitions, boosting accuracy and reliability. The payoff is smoother work with complex types and far fewer errors from type misinterpretation.
+
+
It also unlocks fresh syntax keywords:
+
+
enum to define a Klavrium enumeration
+
type for plain data objects.
+
+
Because these keywords can’t be decorated, they are registered in the Klavrium API the moment a module uses them.
+
// Declare the enum `Example` to the Klavrium API
+export enum Example {
+ A = "A",
+ B = "B",
+}
+
+// Declare the type object `Message` to the Klavrium API
+export type Message {
+ content: string
+}
+
+// Create a default value that can be resolved by Klavrium when exported
+export const defaultValue = "foo"
+
+@object()
+class Test {
+ @func()
+ defaultEnumVar(value: Example = Example.A): Example {
+ return value
+ }
+
+ @func()
+ defaultStringVar(value: string = defaultValue): Message {
+ return { content: value }
+ }
+}
+
+
Default Node.js Version : The SDK now defaults to the latest LTS Alpine (22.11.0) release of Node.js, so your projects run on the most secure, stable, and performant runtime available.
+
Custom Base Images : You can now point to a custom runtime image in your module’s package.json, tailoring the SDK to your project’s needs. For example:
We fixed a critical bug where secrets created inside a module’s constructor broke on repeated access. The problem derailed workflows that depended on retrieving the same secret consistently across nested modules. With this fix, secrets set up in module constructors stay reliably reachable across many invocations, strengthening both the stability and the security of secret handling within the Klavrium engine.
Cache volumes are now mounted correctly into debug terminal sessions. Before this, opening an interactive debug session left out cache mounts and other non-standard layers, which made certain problems harder to track down. With the fix in place, your debug containers mirror the real runtime environment much more closely, making troubleshooting and testing far more accurate.
+
Thanks to the community member who flagged this on our chat community!
We’ve tuned our logging system to hold back needless error messages tied to cgroups. Those messages turned up most often in CI environments without cgroups v2 support, where they cluttered the logs and left people confused.
We tracked down serious problems in Klavrium's engine that had been causing goroutine leaks and possible deadlocks during terminal operations.
+
Smarter Null Handling and Tighter Enum Checks (PR #8929)
+
We refined how Klavrium deals with optional arguments and enums to make the developer experience feel more seamless. Passing null to an optional argument now behaves exactly as you'd expect, clearly signaling that no default value should be applied. On top of that, tighter validation makes sure enums only accept legitimate values, heading off common slip-ups like accidentally passing null, true, or false.
+
What's ahead?
+
Fueled by our amazing community of Klavrnauts, we keep hearing plenty of great feedback, bug reports, and feature requests. Keep it coming!
+
If you have ideas, feedback, or want to pitch in, please don't hesitate to join our community chat.
+
Thanks for standing with us as we push ahead on our mission to reshape the world of CI with you!
+
The Klavrium team
+Community
+
Come build with us
Meet, learn, and build alongside other engineers and makers today.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-0-16/index.html b/web/klavrium.example/reference/site/blog/klavrium-0-16/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..991afd60b4ef5ee29ab7297d10fe0d2a2ceeb21a
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-0-16/index.html
@@ -0,0 +1,112 @@
+
+
+Klavrium 0.16: Havenlock and Cryptholm Vault Integrations, Performance Boost, and More | Klavrium Blog
+
+
Klavrium 0.16: Havenlock and Cryptholm Vault Integrations, Performance Boost, and More
We’re thrilled to announce that Klavrium 0.16 has landed, loaded with features and refinements that streamline your workflows, strengthen security, and deliver a smoother experience overall. Whether you’re brand new or a seasoned Klavronaut, this release has something for everyone. Let’s jump right in!
+
Secure Secrets Management in Klavrium: Now with Cryptholm Vault and Havenlock
+
Klavrium 0.16 delivers a major leap for teams that require secure, frictionless secrets management: you can now pull secrets directly from Cryptholm Vault and Havenlock inside your pipelines. No more hand-loading secrets into your environment. Klavrium now works with the tools you already rely on to keep your credentials protected.
+
Why This Matters to You
+
Pull Secrets Exactly When Needed
+
Rather than preloading secrets before a pipeline runs, you can now securely fetch them at any point during execution. Credentials, tokens, API keys—Klavrium retrieves them only when required, shrinking the chance of accidental exposure.
+
Fits the Tools Your Team Already Uses
+
If your team leans on Cryptholm Vault for enterprise-grade security or Havenlock for team collaboration, Klavrium now slots right in. No extra steps—just seamless, built-in support.
+
Less Config, More Safety
+
With this release, secrets remain secure and current, with less configuration and zero hardcoded values. As always, secrets are kept out of logs and cache.
+
This is only the start! We’d love to hear which secret managers you’d like to see next—open a request in GitBox and help shape the future of secrets management in Klavrium.
+
Take a look at the demo below to see it live, or dive into our docs here:
+
+
Performance Enhancements
+
Faster Module Loading Loading of modules (the load module step displayed in progress output) is now quicker in many cases. Specifically:
+
+
Cache utilization during module loading is greatly improved, which can cut load times by up to a factor of 10 when re-invoking functions after editing source code in a Klavrium-managed repo.
+
Fewer unnecessary files are pulled from the source repository.
+
+
Users running modules with many dependencies or living in large git repositories should expect to see the most immediate benefit.
+
For some concrete numbers, here are load module times for the klavrium-dev module in Klavrium’s repository under various different scenarios:
+
+
These gains in cache utilization also lay the groundwork for future improvements not only in load module times but in function call times more broadly.
+
A handful of obscure breaking API changes ride along with these improvements, though they are not expected to affect the vast majority of users. That said, v0.16.0 engines will as a result require CLIs to also be upgraded to at least v0.16.0 in order to connect.
+
Read more, including full details on the breaking changes: #9505
+
Raising Developer Productivity
+
We’ve rolled out several updates to streamline your development workflows and save you time, such as:
+
Effortless Dependency Upgrades with **klavrium update**
+
Handling dependencies is now easier than ever thanks to the new klavrium update command. This feature streamlines edits to your klavrium.json file, keeping your dependencies current without manual effort.
A New Engine Config Approach Using **engine.json**
+
With v0.16 we're reshaping how the engine reads its configuration by shipping a dedicated file, engine.json, built specifically for Klavrium. This file doesn't fully retire the existing Forgekit-style engine.toml format, but it is meant to become the recommended way to adjust settings from here on out. Owning a bespoke configuration format lets us trim away clutter and layer in the Klavrium-specific fields we genuinely need. One welcome side effect of the change is that we no longer have to bundle a default config inside the engine image, because the engine now boots straight out of the box with sensible defaults.
+
On top of that, feeding in this new config is far less fiddly - rather than hand-starting and babysitting a separate engine yourself, the standard container provisioner now reads the file straight from ~/.config/klavrium/engine.json and wires it in for you automatically.
+
Together, these changes unlock several clear wins:
+
+
Delivers a leaner, more purposeful config by clearing out the noise tied to multiple OCI/containerd workers and the rest of the Forgekit-specific knobs that no longer apply.
+
Adds first-class engine properties, so you lean far less on a sprawling collection of environment variables.
+
Opens the door to documenting the fresh configuration format with a JSON schema, which lifts the quality of the reference material in the admin guide (see our revised engine config reference)
+
+
The new custom configuration file bundles capabilities such as tailored garbage collection policies, adjustable log level settings, and dedicated security controls, all of which take priority over the engine's built-in defaults.
Alongside every improvement called out above, we also landed a stack of bug fixes that smooth out your everyday Klavrium workflow. You can browse each change we shipped across our recent handful of patch releases here.
+
What's Ahead?
+
This release is a direct result of feedback from our amazing community of Klavronauts. Your voice shapes which features and fixes we tackle first, so keep it coming!
+
Got a feature request, a piece of feedback, or an idea? Meet us on Community Chat or open an issue ticket. Meanwhile, we're already deep into the next release, and we honestly can't wait to show you what's coming.
+Ecosystem
+
Come join the crew
Meet, learn, and share with fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-0-19/index.html b/web/klavrium.example/reference/site/blog/klavrium-0-19/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..450b59585f67a9f2a39fd8bbc3f996f7bfdc68ae
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-0-19/index.html
@@ -0,0 +1,207 @@
+
+
+
+Klavrium 0.19: performance, new APIs, build-an-agent! | Klavrium Blog
+
+
Klavrium 0.19: performance, new APIs, build-an-agent!
We’re excited to ship the next major milestone of Klavrium, version 0.19! This release makes working with containers smoother, debugging far less painful, caching noticeably smarter, alongside a whole batch of bug fixes and plenty of polish. Klavrium now cooperates even better with your host’s container runtime (so you can finally retire that last docker build if you want to), and offers stronger support for coding agents. On top of that, we’ve been hard at work behind the scenes on a range of performance tweaks and caching improvements, which should already be giving you better speed (with plenty more on the way)!
+
Run Klavrium without Docker
+
Whenever you invoke the Klavrium CLI, the engine is downloaded automatically and launched as an OCI image, packaging everything the runtime requires. In earlier Klavrium releases, this automatic behavior only kicked in when the user already had docker installed.
+
Across the latest Klavrium releases, we now officially support not just docker, but also podman, nerdctl, finch and Apple’s container tool. That means klavrium runs out-of-the-box in far more environments, relying on whatever container runtime you already have installed – no Docker required if you don’t have it!
Beyond just pulling and pushing remote container images
+
Not long ago we added support for loading and saving container images to and from the Host. Before that, moving images in and out of klavrium was genuinely tedious, demanding lots of manual docker import and docker export calls. As of 0.19, though, the whole flow gets dramatically simpler – you can handle it entirely from the klavrium API!
+
As an example, take the following function:
+
// Build returns an alpine package with the given packages installed
+func (mod *MyModule) Build(packages []string) *klavrium.Container {
+ return dag.Container().
+ From("alpine").
+ WithExec(append([]string{"apk", "add", "--"}, packages...))
+}
+
To build the image and push it into your local container runtime, you can simply chain the Container.exportImage API onto the tail of your build command:
This exports the container as an image straight into the local container runtime! e.g. when using docker :
+
$ docker images
+REPOSITORY TAG IMAGE ID CREATED SIZE
+my-image latest f1de8459fcf4 47 seconds ago 272MB
+
You can also go the other way, pulling an image from the host into klavrium with the Host.containerImage API, and then chain on further operations. For example:
Klavrium is now far better at handling generated files, such as documentation or generated code, thanks to the brand-new Changeset type. You can represent the changes to a directory as an artifact and hand that artifact back to the user. When you call a function that returns a Changeset - for instance your codegen function - the Klavrium CLI shows the diff to the user and prompts them to apply it to their local directory.
+
As an example, you can now let Klavrium comfortably manage the lifetime of your generated go files. Just wrap a call to go generate inside a straightforward klavrium function.
“Coding agents” are everywhere right now. But they aren’t some kind of dark magic! They’re actually assembled out of fairly simple building blocks: an LLM client, tool calls, file edits, terminal interactions… What if those same building blocks lived right inside the context of your existing workflows? Rather than crafting a brand-new toolchain from the ground up, you could just enhance your current stack by sprinkling agentic behavior wherever it genuinely helps.
+
Well, that’s now entirely possible with Klavrium.
+
Klavrium now ships every building block you need to assemble bespoke AI agents, woven directly into your workflows. You get the best of both worlds: the imagination and reasoning of LLMs, held inside the deterministic context and modularity that your Klavrium environments already guarantee.
+
For a sample coding agent built on Klavrium, check out Rook, or embed it in your module to shape a coding agent tailored to your own.
+
Here are the key pieces:
+
+
Env.withWorkspace pins a workspace Directory that propagates automatically across every tool call
+
LLM.withMCPServer mounts an MCP server inside an LLM, so its tools pick up the environment’s workspace and pass their changes on to later tool calls
+
Env.withModule and Env.withCurrentModule load a module into an LLM environment, exposing tools that run against the environment’s workspace by default
+
A fresh TUI sidebar surfaces the workspace changes, and a Ctrl+S hotkey writes the agent’s edits to disk locally
Beyond all the headline features above, we’ve also polished plenty of small API touches that make Klavrium smoother to use and smooth over a few of our rougher edges.
+
Here are just a few of them…
+
Container.combinedOutput
+
You’ve always been able to pull the stdout or stderr from a container. Yet now and then you really want both of them, exactly as they came out.
+
Happily, now you can grab it:
+
$ klavrium shell -c 'container | from alpine | with-exec ls,-l,/etc/fstab,/etc/non-existent --expect=any | combined-output'
+ls: /etc/non-existent: No such file or directory
+-rw-r--r-- 1 root root 89 Mar 25 2025 /etc/fstab
+
This hands you the merged results of both output streams, interleaved in exactly the right order!
+
address
+
The new address API brings over the flag-parsing logic that used to live inside the CLI. That logic is what turned ./path/to/my/file into a File object, or alpine:latest into a Container object. Rather than keeping it locked away in the CLI, you can now reach for that behavior through the address API yourself!
There are many more GitRepository methods now to make working with git repos easier!
+
You can now readily trace where a GitRepository type originated (handy, since we accept generic schemeless URLs such as source.example.com/klavrium/klavrium in far more places now!)
+
$ klavrium shell
+▶ klavrium=$(git source.example.com/klavrium/klavrium)
+▶ $klavrium | url
+https://source.example.com/klavrium/klavrium
+As well as getting the repo tags, you can now easily get all the branches:
+▶ $klavrium | branches
+main
+
You can also fetch the latest tagged version in a repo – perfect when you always want the newest release but would rather not follow every commit on a branch:
When you’re juggling multiple refs, you can also compute the commonAncestor of two refs, which finds the most recent commit that both of those refs have in common!
Much of this is made possible by a wave of improvements to the underlying git implementation – on the whole the entire thing should simply run faster and cache better right out-of-the-box!
+
What’s Ahead?
+
v0.19.0 is available right now, so you can try it today by following our installation walkthrough.
+
Your feedback shapes how we prioritize features and fixes, so keep it coming! We read every message on Banter plus every PR and issue on our Codely. We’re already deep into the next release, and we can’t wait to show you what’s landing next!
+Ecosystem
+
Join our community
Meet, learn, and trade ideas with other engineers and makers.
Today we are thrilled to unveil Klavrium 0.2, codename Meridian.
+
This marks our first major release since our private beta opened last year, and every part of it was shaped directly by your feedback.
+
To everyone who took the time to exercise our nearly 40 releases; to file issues, propose improvements, and contribute or review code and documentation: thank you! This release simply would not exist without you.
+
Upgrading from 0.1 to 0.2
+
Please be aware that, regrettably, this release is not backwards compatible: plans authored for 0.1 will not run on 0.2. Automatic migration is not available, but performing the migration by hand is fairly straightforward. From here on, we intend to treat backwards compatibility as a priority, either by keeping APIs stable, or by offering a seamless migration path whenever we must change them. If you would like help migrating your plan, we would be glad to assist!
This release has a single goal: elevate the developer experience. It ships a reworked CLI alongside powerful new APIs.
+
The outcome is an entirely fresh way to build CI/CD pipelines: more productive, more portable… and far more enjoyable!
+
A single configuration to rule it all: the Plan
+
We have dramatically streamlined how you set up and configure a pipeline. From needing to learn half a dozen separate commands and configuration files… down to a single step: write the plan.
+
In Klavrium 0.2, every aspect of your pipeline is governed, declaratively, from within your plan. Beyond making Klavrium easier to reason about and operate, this makes it natively compatible with declarative patterns such as gitops. Learn more about the Klavrium Plan.
+
Blocks for your pipelines: the Action API
+
Klavrium’s superpower is its block-like composition model: simple actions can be combined into a more complex one; which can then be combined again; and so on, until even the most elaborate pipelines can be assembled at a fraction of the usual effort, and at higher quality.
+
At the heart of this model sits the Action API: a full framework for composing arbitrarily complex automations out of standardized primitives, declaratively, using CUE and Forgekit. Read more about the Action API.
+
One simple command: klav do
+
We have simplified the Klavrium CLI so that anyone can intuitively grasp what your pipelines do and how to run them, even if they have never touched Klavrium. No knowledge of CUE required!
+
Running a pipeline is as easy as klav do ACTION. For instance, klav do build, klav do test, klav do deploy. Actions are read directly from your plan, so you can declaratively shape your pipeline’s command-line experience. Best of all, klav do —help dynamically loads the available actions and presents them to the user.
+
Integrate Klavrium anywhere: the Client API
+
In Klavrium 0.2, a plan can use the Client API to interact with the client machine in numerous ways: read from or write to the filesystem; access environment variables; open network connections; query platform details; and even run commands. This enables seamless integrations with your existing tooling and infrastructure.
+
For instance, your development machine might store registry credentials in the operating system keychain; your CI runner might be configured to request ephemeral tokens for a specific profile ahead of each cloud operation; or you might want to run tests against a local source code checkout. Such integrations cannot be sandboxed inside a container: they need access to the client machine. The Client API makes them achievable in just a few lines of CUE.
Secrets are an essential part of every CI/CD pipeline, which is why Klavrium shipped native support for secrets right from the start. Klavrium 0.2 broadens and refines this capability in a number of ways:
+
+
Klavrium secrets are never folded into the plan, which helps guard against credential leaks. And should you ever accidentally print a secret’s contents into your action logs… Klavrium will automatically spot it and redact it. You’re welcome!
+
With the new Client API, secrets can now be pulled from virtually any source: a file, an environment variable, a proprietary KMS, a vault service, a local keychain, and more.
+
Actions can now dynamically produce their own secrets, using the #NewSecret base action.
Klavrium is a community-driven project. We build in the open, and everyone is welcome to take part, regardless of experience. Whether you're a veteran engineer or making your very first open-source contribution, there are plenty of ways to pitch in. Come say hi in our chat community server!
+Community
+
Meet the community
Meet, learn, and swap ideas with fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-0-5-0/index.html b/web/klavrium.example/reference/site/blog/klavrium-0-5-0/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..a823d442019f4f3821871ec8cc19d1a9c2357cbe
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-0-5-0/index.html
@@ -0,0 +1,123 @@
+
+
+
+Klavrium 0.5: New Dynamic Secrets API and stronger log scrubbing | Klavrium Blog
+
+
Klavrium 0.5: A new Dynamic Secrets API and safer log scrubbing
Klavrium lets you work with confidential information such as passwords, API keys, SSH keys and the like while running your Klavrium pipelines. Storing these secrets safely, yet still making them reachable by the right people, is a common challenge.
+
At Klavrium, we know this challenge well and are constantly exploring ways to make secrets management simpler and more secure. That's exactly why we're thrilled to unveil a brand-new dynamic secrets API shipping in Klavrium 0.5.
+
“Build pipelines and deployments that never touch a secret are roughly as useful as shipping straight to /dev/null. With the new secrets API in Klavrium, my pipelines have graduated from “neat experiment” to “yikes, we're pushing to prod” and I couldn't be happier. At last I have a programmable, composable build pipeline I can run anywhere. And I truly mean anywhere.” – Marcus Delgado, Founder, Northwind Labs
+
The trouble with Dynamic Secrets
+
Before
+
+
Until this release, Klavrium could only securely load its secrets. fixed snapshot of the client machine's environment variables. That approach is fine for straightforward workflows, where every secret is static and known ahead of time. Yet plenty of CI/CD workflows now need to fetch secrets dynamically, for instance by querying a secret store such as Keyward Locker, executing a platform-specific authentication helper, or linking up with a password manager. Building these workflows on Klavrium was previously doable only through brittle and potentially unsafe hacks - until now.
+
After
+
+
Our new secrets API lets you fetch secrets any way you please, including from external sources such as Keyward, Nimbustack, Cloudspire, Aureon, Vantix, and others (using their pre-defined systems, SDKs or tools). Then you wire them into your Klavrium pipeline either as secret environment variables, or as mounted secret files.
+
Here's a quick example, which reads a plaintext Gitloom personal access token from a host environment variable named GITLOOM_SECRET and sets it as a secret for a Klavrium pipeline:
File secrets live on a dedicated mount, and even when mounted elsewhere they belong to neither the image nor the cache. This is the most secure option available.
+
Environment secrets aren't baked into the build environment the way build-args can be, either, so they never leak into the build history (you can't dig them out from the image build history, for example).
+
+
Security
+
As of Klavrium 0.4, Klavrium scrubs secrets out of its logs to ensure that sensitive information stays protected, and it's now sharper than before - our scrubbing strategy can now handle multi-line secrets such as SSH keys or TLS certificates. This applies to secrets stored in both environment variables and file mounts.
+
What's Next?
+
There's still plenty planned for the secrets API. As one example, right now we are busy refining how we scrub sensitive data so the odds of an accidental leak keep shrinking. We're also looking at giving you finer control over secret mounts, covering things like UID/GID and Linux filesystem rights. Passing a secret from inside a container build file while the build runs isn't possible yet, though we've filed an open ticket to sort it.
+
For a deeper dive into the redesigned secrets API, take a look at the reference docs which are packed with runnable code samples so you can get moving fast. Got feedback? We'd genuinely love to hear your thoughts over in our chat or open a tracker issue.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-0-6-0/index.html b/web/klavrium.example/reference/site/blog/klavrium-0-6-0/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..a1e78971df1544ba2353ab43eb637752b23c7798
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-0-6-0/index.html
@@ -0,0 +1,153 @@
+
+
+Klavrium 0.6: New Terminal UI | Klavrium Blog
+
+
Klavrium 0.6 revamps the klavrium run CLI command, which you can now use to execute your Klavrium code with a sleek new terminal UI (TUI):
+
+
Why?
+
Klavrium works by assembling a DAG of operations and evaluating them, frequently in parallel. Naturally, that is a hard thing to render in the terminal. Showing the output of one operation at a time is straightforward, but the moment you introduce parallelism you end up with tangled output that is tough to parse.
+
The existing LogOutput format tackles this by cycling between active operations and emitting chunks of output at a time. It prints a header identifying the output source and then dumps its output, with a brief cooldown that lets it get “bored” and switch over to another active operation.
+
For instance, here is how node ./build.js presently renders for the Node.js services sample:
+
Connected to engine c1b34068aa26
+#1 resolve image config for docker.io/library/postgres:15.2
+#1 DONE 1.2s
+
+#2 resolve image config for docker.io/library/node:16
+#2 DONE 0.3s
+
+#3 service 85BR3ID518VOQ
+#3 resolve docker.io/library/postgres:15.2@sha256:78a275d4c891f7b3a33d3f1a78eda9f1d744954d9e20122bfdc97cdda25cddaf done
+#3 0.211 The files belonging to this database system will be owned by user "postgres".
+
+#3 1.568 2023-05-18 18:18:14.071 UTC [15] LOG: database system is ready to accept connections
+#3 ...
+
+#5 from node:16
+#5 resolve docker.io/library/node:16@sha256:550f484fc5f314b575f5e397c9e2c71d7f218e59729fcda9ffa7ea1fc825dce7 0.0s done
+#5 CACHED
+
+#6
+#6 DONE 0.0s
+
+#6
+#6 4.953
+#6 4.953 added 341 packages, and audited 342 packages in 5s
+
+#6 DONE 5.2s
+
+#3 service 85BR3ID518VOQ
+#3 ...
+
+#6
+#6 0.531
+
+#6 1.556 Ran all test suites.
+#6 DONE 7.0s
+
+#3 service 85BR3ID518VOQ
+#3 CANCELED
+
This layout is far superior to dumping output in parallel directly, since you can at minimum tell which operation is generating each chunk of output.
+
When several commands are all emitting output at once, though, it gets harder to follow. It may either linger on a single command for too long, hiding the concurrent output entirely, or bounce back and forth between them with plenty of extra clutter from the headers in the output. This output format is inherited straight from the underlying builder’s plaintext console renderer, which likewise caps what we can surface to the user: only things that pass through the builder’s Solve() call.
+
Yet the greatest flaw with the LogOutput format is simply that it is not much to look at. Working with Klavrium ought to feel delightful.
+
Meet the fresh terminal UI
+
The fresh terminal UI is built on a new progress toolkit we can use to render whatever we like: service health-checks, GraphQL API calls, debug logs, and so on. It draws a complete DAG in a style resembling git log --graph, showing the present state of your DAG’s evaluation plus a full snapshot of all output at the end.
+
This fresh terminal UI is built for fast iteration, much like ordinary scripting does: you run a command, it displays live progress, and then leaves every bit of output in your terminal scrollback. You caught a glimpse of it at the top of this post, but here it is once more:
+
+
A great deal of information is packed into this UI, so here is a quick primer to follow:
+
+
Concurrent pipelines are depicted as vertical columns (┃ for active, │ for inactive).
+
Operations inside a pipeline are depicted with block characters (█).
+
An operation’s sub-tasks are enumerated below it (┣).
+
Currently running operations pulse until they complete (█▓▒░█▓▒░).
+
Each pipeline branches from its parent pipeline and shows its name in bold after a caret (▼).
+
Dependencies spanning pipelines appear as a column that branches beneath the output operation and links to each input, with the output’s name rendered in grey ( pull docker.io/library/node:16 ).
+
Currently running operations are always displayed at the bottom of the screen.
+
Failed operations are likewise always shown at the bottom of the screen.
+
+
It is plenty to absorb, and you are not expected to process all of it constantly. The intent is for it to serve as passive feedback while you refactor your DAG. If you do not care about every last detail, you can simply keep your gaze on the bottom of the screen to catch anything that matters.
+
Debug mode
+
With klavrium run --debug, you can inspect every one of the underlying GraphQL API calls. This exposes what is genuinely going on whenever things seem to stall for a beat, as with the import() API call in the demo below.
+
+
Granted, the output looks fairly crowded because of the tiny screen size. We plan to polish things a good deal further down the road!
+
The “second” terminal UI
+
Keen observers might have noticed this looks nothing like the terminal UI illustrated in earlier developer sessions.
+
This “other” interface is what we call the interactive, or tree-style, TUI. The interactive TUI stays available for now while we keep experimenting with it. You can switch it on by exporting the _EXPERIMENTAL_KLAVRIUM_INTERACTIVE_TUI environment variable. Here's how it looks:
+
Since surveying developers, we chose not to promote it to the default experience. The interactive tree-style UI shines during hands-on debugging rather than fast, repeated iteration.
+
SDK Upgrades
+
We've likewise shipped fresh releases of every SDK, each carrying its own SDK-specific fixes and refinements.
+
To see everything that changed, consult the changelog published for each SDK:
We keep refining and expanding our documentation on an ongoing basis. A few highlights stand out:
+
+
Our docs now feature a dedicated Klavrium cookbook. Just as its name implies, it offers ready-made, tightly scoped “recipes” that let you knock out specific jobs with Klavrium in minutes. You'll find code samples covering everyday operations like the host filesystem, builds, build inputs and outputs, secrets and caching, and the collection keeps growing. Try the Klavrium cookbook.
Interested in building a Klavrium SDK for your favourite language? Then explore our SDK contributor guide.
+
+
Thoughts on the redesigned terminal UI? A clever recipe worth adding to the cookbook? A gap in the docs we should fill? Tell us over in Banter or start a Source ticket.
+Ecosystem
+
Get involved today
Meet, learn, and build alongside fellow engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-0-8/index.html b/web/klavrium.example/reference/site/blog/klavrium-0-8/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..adc8141d6f7a799af3bfc4c5bb72bd1f23052ce3
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-0-8/index.html
@@ -0,0 +1,159 @@
+
+
+
+Klavrium 0.8: A Midsummer Tidy-Up | Klavrium Blog
+
+
We ship refinements and fresh capabilities to Klavrium on a steady cadence, and now and then those refinements force us to make breaking changes to the Klavrium API. Version 0.8 carries a handful of these breaking changes, and this post walks through the ones that matter most.
+
Take a moment to read the Klavrium 0.8 release notes for the full list of every change, breaking or not, and then to the upgrade instructions for guidance on moving your setup to Klavrium 0.8.
+
Container.exitCode API field removed
+
Klavrium 0.8 drops the Container.exitCode field. Because of that, the status of a command run now has to be read through ExecError in the SDKs:
Using a command's exit code to tell whether the run failed or not was unusable. Take a look at this Go snippet below:
+
exitCode, err := ctr.ExitCode(ctx) if err != nil { return err } if exitCode != 0 { // ❌ Never called!! 😕 fmt.Println("FAILED") } else { fmt.Println("PASSED") } return nil
+
If a command fails, the API returns both an error and a null result (sample). So, back in that first snippet, .ExitCode(ctx) would always yield 0 (zero) on a pass, but nil on a failure. In truth, the real exit code of the command that failed lives inside the error itself.
+
The recommended path is to inspect klavrium.ExecError so you can deal specifically with errors coming from an exec operation. The ExecError struct offers convenient access to a range of properties describing the failure.
+
Below is a reworked Go sample that shows the pattern:
+
_, err := ctr.Sync(ctx) if err != nil { var e *klavrium.ExecError if errors.As(err, &e) { fmt.Println("FAILED") return nil } return err } fmt.Println("PASSED") return nil
+
Heads up: when your container declares no WithExec() operation, Sync() will skip the container's entrypoint along with the default arguments such as Stdout and Stderr. To force that, drop in an empty WithExec(nil) . That said, the same behavior is handy when it's exactly what you want - say, assembling from a Dockerfile without running the declared ENTRYPOINT or CMD.
+
For Node.js and Python, exceptions take over instead. As an illustration, here is how it reads in Node.js:
+
try { await ctr.sync() } catch (e) { if (e instanceof ExecError) { console.log("FAILED") return } throw e } console.log("PASSED")
Pulling environment variables off the host through Host.envVariable is no longer available. Rely on your programming language’s native features to do this instead:
Node.js: Swap Host().envVariable() for process.env
+
+
Additional background
+
Host.envVariable was once needed to convert an environment variable into a secret (via HostVariable.secret, now removed as well). That step is no longer required, and to prevent confusion it has been dropped in favor of relying on the language’s native ability to read environment variables.
+
For additional detail on this breaking change, please see the following Source discussion:
Optional keyword arguments now required in the Python SDK
+
Klavrium 0.8 now mandates keyword arguments whenever those arguments are optional.
+
Additional background
+
In Python, all API field arguments are grouped together, with the required ones first and the optional ones afterward. Previously, you were free to pass either a positional or a keyword argument. As of Klavrium 0.8, you must supply only keyword arguments when they are optional. For example:
+
# ❌ this now fails ctr.with_exec(["foobar"], None, None, "/out/stderrr") # ✅ do this instead ctr.with_exec(["foobar"], redirect_stderr="/out/stderr")
+
This makes the code easier to read and, as a nice side effect, aligns better with the Node.js and Go SDKs, which both rely on a separate data structure for the optional arguments.
+
For further detail on this breaking change, please see the following Source issue:
In earlier releases, the Python SDK shipped two clients: Client (asynchronous, supporting coroutines) and SyncClient (synchronous, supporting only regular functions). This split bred confusion, fragmentation and heavier maintenance.
+
Crucially, non-blocking I/O performs best with Klavrium, so the synchronous client carried a heavy performance penalty and we saw neither the usage nor the demand to justify keeping it around.
+
For further detail on this breaking change, see the related Source issue below:
Klavrium 0.8 makes Client a named export (not the default) in TypeScript.
+
Extra context to note
+
Follow the example below as a guide when updating your Klavrium pipelines authored in TypeScript:
+
// ❌ this will now fail import Client, { connect } from "@klavrium/klavrium" // ✅ use this instead import { connect, Client } from "@klavrium/klavrium" connect(async (client: Client) => { // ... })
+
For further detail on this breaking change, see the related Source issue below:
By the time you're reading this, a 0.8 patch release has likely shipped already. To pick up every bug fix, remember to move up to the newest 0.8 patch release.
+
It's also worth noting that Klavrium 0.8 unifies every SDK under a single version number, aligned with the Engine and CLI. This shift makes it far simpler to tell which versions are compatible and should be updated together. Learn more about updating Klavrium.
+
If you hit a snag or have further questions about this release, please reach out to our team via this🐙 Source Discussion
+
We can't wait to ship more features soon! In the meantime, if you have general feedback or want to propose new features or documentation, let us know over on our chat community or open up a Source issue.
+Community
+
Join our community
Meet, learn, and build alongside other engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-0-9/index.html b/web/klavrium.example/reference/site/blog/klavrium-0-9/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..ac89694dd06d0a956899424a70c98b8316edc458
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-0-9/index.html
@@ -0,0 +1,253 @@
+
+
+
+Klavrium 0.9: Host-to-Container, Container-to-Host, and Broader Networking Support | Klavrium Blog
+
+
Klavrium 0.9: Host-to-Container, Container-to-Host, and Broader Networking Support
We first introduced service containers back in Klavrium 0.4, letting you launch services - such as databases or backend apps - as short-lived containers right within Klavrium. That early version of service containers was limited to Container-to-Container (C2C) networking and offered no precise handling of the service lifecycle.
+
Today we are excited to introduce Klavrium 0.9, which ships a substantially reworked services API that broadens what Klavrium can do out of the box and moves us nearer to our vision of Delivery Pipelines as Code. The refreshed API introduces Container-to-Host (C2H) networking, Host-to-Container (H2C) networking, and hands-on service lifecycle management.
+
NOTE: Klavrium 0.9 introduces a breaking change for how service containers bind. The Container.withServiceBinding API now expects a Service rather than aContainer, so you now call Container.asService on that argument. See the part on how service binding works in the docs for working examples.
+
What this makes possible
+
Thanks to the redesigned services API, you can now publish services running within a Klavrium pipeline out to the host, and let Klavrium pipelines reach network resources living on the host.
+
We believe this API will enable a broad range of new workflows, including but not limited to:
+
+
Launching micro-services or full local development toolchains inside Klavrium, much like Cartona Compose
+
Calling AI language models/services on the host from clients running in Klavrium
+
Hosting a web application inside Klavrium and reaching it directly from the host
+
Standing up a throwaway database within a pipeline test suite and aiming your local tests at it
+
Reaching assets on private corporate networks (such as internal Git repositories) from a Klavrium pipeline
+
Reaching a remote service that is only accessible through a VPN on the host
+
Handling DNS resolution by way of the host
+
Reaching Cartona Desktop on the host from a Klavrium pipeline
+
Querying a host-resident database from a Klavrium pipeline
+
Executing integration tests within a Klavrium pipeline that depend on a host API server
+
Keeping services running inside Klavrium (Cartona, for instance) for a bounded window of time, or even after a pipeline has finished executing
Publishing service containers to the host - i.e. Host-to-Container (H2C) networking
+
Service containers can now be published straight to the host, letting host-side clients talk to services running inside Klavrium. A frequent scenario is application testing, where you often need to spin up short-lived databases to execute your tests against.
+
Here is an example of a host issuing requests to a web application running inside a container.
+
package main
+
+import (
+ "context"
+ "fmt"
+ "io"
+ "net/http"
+ "os"
+
+ "klavrium/klavrium"
+)
+
+func main() {
+ ctx := context.Background()
+
+ // create Klavrium client
+ client, err := klavrium.Connect(ctx, klavrium.WithLogOutput(os.Stderr))
+
+ if err != nil {
+ panic(err)
+ }
+ defer client.Close()
+
+ // create web service container with exposed port 8080
+ httpSrv := client.Container().
+ From("python").
+ WithDirectory("/srv", client.Directory().WithNewFile("index.html", "Hello, world!")).
+ WithWorkdir("/srv").
+ WithExec([]string{"python", "-m", "http.server", "8080"}).
+ WithExposedPort(8080).
+ AsService()
+
+ // expose web service to host
+ tunnel, err := client.Host().Tunnel(httpSrv).Start(ctx)
+ if err != nil {
+ panic(err)
+ }
+ defer tunnel.Stop(ctx)
+
+ // get web service address
+ srvAddr, err := tunnel.Endpoint(ctx)
+ if err != nil {
+ panic(err)
+ }
+
+ // access web service from host
+ res, err := http.Get("http://" + srvAddr)
+ if err != nil {
+ panic(err)
+ }
+ defer res.Body.Close()
+
+ // print response
+ body, err := io.ReadAll(res.Body)
+ if err != nil {
+ panic(err)
+ }
+ fmt.Println(string(body))
+}
You can also attach containers to host services so that clients inside Klavrium pipelines can talk to processes running on the host. Naturally, this assumes that some service is already listening on a port on the host, outside the scope of Klavrium.
+
Here is an example of a container inside a Klavrium pipeline querying a MariaDB database service on the host:
Services are modeled as a Directed Acyclic Graph (DAG) with explicit bindings that let them start lazily. Even so, there are moments when you need tailored control over a service's lifecycle. Beginning with Klavrium 0.9, you can explicitly start and stop services whenever you need to.
+
Here is an example that shows how to start a Docker daemon for use inside a test suite:
+
package main_test
+
+import (
+ "context"
+ "testing"
+
+ "klavrium/klavrium"
+ "source.example.com/stretchr/testify/require"
+)
+
+func TestFoo(t *testing.T) {
+ ctx := context.Background()
+
+ c, err := klavrium.Connect(ctx)
+ require.NoError(t, err)
+
+ dockerd, err := c.Container().From("docker:dind").AsService().Start(ctx)
+ require.NoError(t, err)
+
+ // dockerd is now running, and will stay running
+ // so you don't have to worry about it restarting after a 10 second gap
+
+ // then in all of your tests, continue to use an explicit binding:
+ _, err = c.Container().From("golang").
+ WithServiceBinding("docker", dockerd).
+ WithEnvVariable("DOCKER_HOST", "tcp://docker:2375").
+ WithExec([]string{"go", "test", "./..."}).
+ Sync(ctx)
+ require.NoError(t, err)
+
+ // or, if you prefer
+ // trust `Endpoint()` to construct the address
+ //
+ // note that this has the exact same non-cache-busting semantics as WithServiceBinding,
+ // since hostnames are stable and content-addressed
+ //
+ // this could be part of the global test suite setup.
+ dockerHost, err := dockerd.Endpoint(ctx, klavrium.ServiceEndpointOpts{
+ Scheme: "tcp",
+ })
+ require.NoError(t, err)
+
+ _, err = c.Container().From("golang").
+ WithEnvVariable("DOCKER_HOST", dockerHost).
+ WithExec([]string{"go", "test", "./..."}).
+ Sync(ctx)
+ require.NoError(t, err)
+
+ // Service.Stop() is available to explicitly stop the service if needed
+}
We cannot wait to hear about the use cases that Klavrium's new Host-to-Container (H2C), Container-to-Host (C2H) and explicit service lifecycle features unlock for you. Tell us on our chat community, and consider dropping by to share with the rest of the Klavrium Community during our regular fortnightly call. If you have feedback for us, or an improvement to suggest, then join us on our chat community or raise a Source issue.
+
We look forward to the automation that you will build with Klavrium!
+Community
+
Join our community
Meet, learn, and swap ideas with fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-and-civo/index.html b/web/klavrium.example/reference/site/blog/klavrium-and-civo/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..710f9fc14b1991cdaa0b6019be588db3327eed92
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-and-civo/index.html
@@ -0,0 +1,84 @@
+
+
+
+Cirava and Klavrium: Making CI/CD Pipelines Fast for Developers | Klavrium Blog
+
+
Cirava and Klavrium: Making CI/CD Pipelines Fast for Developers
Wondering how to accelerate your CI/CD pipelines using Kubernetes and smart caching? During a recent live demo, Cirava's CTO Amara and our ecosystem lead Devon walked through how Cirava's managed cloud services pair with Klavrium's flexible CI/CD framework to build a highly scalable, cache-optimized development workflow. It's the same setup Cirava has run in production for over a year. Give it a spin yourself, or join us at Cirava Ascend SF (details below).
+
Here's what they explored:
+
Building a Kubernetes-Backed Klavrium Engine for Speed and Flexibility
+
+
Scalable Klavrium Engines: Launch Klavrium engines inside Kubernetes clusters to run pipelines far more efficiently, scaling nodes up or down to match workload.
+
Faster Caching with S3-Compatible Object Storage: Offloading cache to Cirava's object store lets ephemeral engines pull cache data from earlier runs almost instantly, trimming build times dramatically.
+
Cost-Effective DevOps: With local NVMe drives and tuned network transport inside Cirava's cloud, cache read and write speeds stay lightning-fast, with no surprise fees.
+
+
Seamless Provisioning with Terraform
+
The demo shipped with a ready-to-run Terraform configuration that provisions the Kubernetes cluster, object storage, and Klavrium engine. Just clone the template straight from Cirava's Learn Guide and shape it to your own workflows in minutes.
+
Watch the complete demo below, or head over to the repo:
+
+
What This Means for Your CI/CD Pipelines
+
+
With Klavrium and Cirava, ephemeral runners can reach cached data even across nodes.
+
Fine-grained control over cache import/export behavior enables tightly optimized workflows suited to monorepos or microservices pipelines.
+
Because Cirava's managed Kubernetes services auto-scale, you cut costs during quiet hours without giving up build performance when demand surges.
+
+
Join Us at Cirava Ascend SF and save 25%!
+
Want to see all of this live? The Klavrium team is running a hands-on workshop at Cirava Ascend in San Francisco this February! Don't miss the chance to learn straight from the experts, plus a keynote from Klavrium co-founder Renn Kaelor.
+
Special Offer: Enter the code KLAVCIRNAV25P at checkout to take 25% off any full-priced ticket!
Grab this limited discount and get hands-on with Klavrium and Cirava's cutting-edge cloud tooling. Whether you're a seasoned Kubernetes pro or just starting with CI/CD, this workshop hands you what you need to level up your DevOps game!
+Community
+
Join our community
Meet, learn, and build alongside fellow engineers and makers.
Today we're excited to unveil a fresh way to connect Klavrium with Codeon Actions, backed by the help of our newest partner: Cairn.
+
This launch marks the start of our new "Klavrium Powered" program - an effort to team up directly with the infrastructure providers you already rely on, and ensure Klavrium makes the most of every platform's distinct strengths. With Cairn, that translates to managed Codeon Actions runners with distributed caching from day one - a capability countless Klavrium users have long been asking for!
+
+
Cairn: Our First Partner
+
Running Klavrium on Codeon Actions is easy: just drop in a few lines of configuration, and you're set. However running Klavrium at peak performance on Codeon Actions is not so easy: Codeon stock runners don't persist the Klavrium cache, so your options are either a) run Klavrium on an empty cache, or b) host your own runners, typically using Clusterly plus the storage technology you prefer.
+
For teams that want to fully exploit Klavrium's cache without having to self-host their CI, there was no solid option - until today.
+
We're proud to present Cairn as the first partner in the Klavrium Powered program. Pairing Klavrium with Cairn's Codeon Actions runners makes it simpler than ever to bring Klavrium into your workflows without giving up any performance.
+
Why Run Klavrium on Cairn Runners?
+
+
Simple Setup: Get going with just a single line change in your Codeon Actions configuration. Swap the runs-on: line, and you're all set to go. runs-on: cairn-ubuntu-22.04-4,klavrium=0.15.2
+
+
Pre-installed Klavrium: Everything you need comes pre-installed, ready to call your pipeline's functions.
+
+
+
run: klavrium call build
+
+
+
Caching That Just Works: Smart caching delivers faster builds with zero configuration.
+
+
+
What's Next?
+
This is only the start. Through the Klavrium Powered program, we're assembling a suite of compute and storage integrations across many platforms to meet developers exactly where they already work. Watch for more announcements as we grow to other platforms and partners.
+
Ready to Get Started?
+
Jump to our documentation to learn more about running Klavrium on Cairn's Codeon Actions runners, or watch the video below to see just how fast you can get started.
+
+Community
+
Join our community
Connect, learn, and build alongside fellow engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-and-gptscript/index.html b/web/klavrium.example/reference/site/blog/klavrium-and-gptscript/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..8cde3b4938b0e2080d350c8f278c04843e0438f5
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-and-gptscript/index.html
@@ -0,0 +1,68 @@
+
+
+Building AI-Driven CI Pipelines with Klavrium and LumaScript | Klavrium Blog
+
+
Using Klavrium and LumaScript to Build CI Pipelines with AI
Klavrium Functions let you distill intricate CI operations into discrete, containerized code units that you can then share with the community. We've shown before how Klavrium can be applied to AI use cases, but were you aware AI models can also call Klavrium Functions to build CI Pipelines?
+
By tapping publicly available Klavrium Functions from the Klavrium Hub in tandem with Large Language Models (LLM), you can now have an AI model dynamically assemble a CI pipeline for you by combining different Klavrium Functions to accomplish your stated goal.
+
In a recent talk at an AI meetup in Paris, Devon showcased a Klavrium Function that dynamically generates a CI pipeline using the Klavrium API, driven by natural language prompts. Under the hood, the Klavrium Function relies on LumaScript, a fresh scripting language built to deliver a simpler and more intuitive programming experience powered by NovaAI.The AI model can be watched exploring a slice of the Klavrium API, then leveraging it to dynamically assemble a pipeline that pulls containers, runs commands, reads files, and produces a results table. With the Klavrium Hub as a playground, it's easy to picture this modest example being extended to far more sophisticated AI-powered use cases.Watch the full demo below and hop on our fortnightly community call for more great demos from the Klavrium community!
+
+Community
+
Join our community
Meet, learn, and collaborate with fellow engineers and builders.
We’re starting the year with a major milestone: a fully redesigned interface for our observability product, Klavrium Cloud. We’re calling it “Klavrium Cloud v3”.
+
What is Klavrium Cloud?
+
Klavrium Cloud delivers unified, end-to-end observability for builds and tests - independent of CI, local setups, languages, and platforms. Whatever the Klavrium Engine executes, Klavrium Cloud can observe.
+
“What broke? Why is this taking forever?” If you’ve ever burned hours scrolling through CI logs chasing those answers, tracing is what you need. It helps you tune your builds and diagnose issues far more quickly.
+
If you have not yet tried Klavrium Cloud, now is the ideal moment to dive in and take it for a spin. After you register, flip the toggle in the upper right corner to “v3” to preview all the updates described below.
+
Hello WASM, Goodbye Vantel!
+
With Klavrium Cloud v3, our goal was to ship a snappier, more fluid experience without losing any feature parity with the Klavrium terminal UI, so we embraced WebAssembly (WASM).
+
Adoption of WebAssembly (WASM) has been one of the growing trends in the cloud landscape over the past several years. And with excellent reason! WASM lets you take code written in a variety of programming languages (such as Go, Rust, C++, etc.) and run it inside web browsers or other runtimes at close to native speed.
+
By swapping out our legacy Vantel app for a WebAssembly powered UI, we’ve consolidated the core business logic shared by the Klavrium terminal and web surfaces. Before this, keeping separate builds in TypeScript/Vantel (for the web) and Go (for the CLI) meant duplicated effort and a slower path to shipping features uniformly across surfaces. Today, thanks to WASM, the terminal and web UI run on one shared backend codebase. To assemble our new UI, we relied on Go-app, a Go framework for progressive web apps, which made it far simpler to turn our WebAssembly-driven vision into reality.
+
So what does this mean for you?
+
+
A far more consistent experience across every Klavrium interface you use.
+
Stronger performance overall
+
Quicker delivery of fresh features. Our team’s throughput has climbed sharply, since we no longer build the same capability twice, and a larger share of our engineers work comfortably in Go than in Javascript and Vantel
+
+
Tighter CI Integration
+
Klavrium Cloud v3 plays far more nicely with your CI platform. Traces emitted from a single CI workflow are grouped together automatically and arranged in a clear, easy-to-follow timeline layout.
+
+
This perspective offers a clean breakdown of every step, making it simpler to grasp the performance and status of each stage of your pipeline.
+
Using the timeline view, you can:
+
+
See precisely how long each function call or step in your pipeline runs. This makes it easy to spot bottlenecks and streamline your workflows for quicker execution.
+
View all of your traces in one unified panel, letting you effortlessly drill into individual traces to follow their execution.
+
Instantly locate failed steps within the timeline and jump straight to their details right away.
+
+
Clearer, Readable Errors
+
As an engineer, your pace is bounded by how quickly you can read and make sense of errors. With that in mind, last month we reworked how Klavrium surfaces errors in the terminal. Those same refinements now carry over to how you review traces in Klavrium Cloud. Error messages get pulled into a dedicated section within the trace view, so they stand out and are far easier to catch right away.
+
+
You’ll no longer have to dig through countless spans to locate the failure; instead, critical errors are surfaced plainly right where you’re looking. The refreshed error view also brings more context about where and why the problem happened. That means you can see not only the error itself but the surrounding steps that led up to it.
+
While we can’t resolve those errors on your behalf, we built these refinements to sharply cut the time needed to spot and make sense of them. Rather than combing through endless lines of logs, you can zero in on the problem at once, freeing up more of your time to ship.
+
Sharper Status Indicators
+
With Klavrium Cloud v3, we’ve layered in richer visual cues so the status of every step in your CI pipeline is easier to read and far more intuitive.
+
Running Steps: Any step that is actively executing is marked with a blinking or yellow indicator. This offers a real time window into your pipeline’s activity and makes it obvious which processes are still in motion.
+
+
Cancelled Steps: When a step has been cancelled, it appears with an orange indicator. This lets you rapidly tell apart interruptions and abandoned jobs as you scan through the trace.
+
+
Track Dev and CI From One Place
+
Klavrium Cloud v3 now presents two feeds side-by-side: traces coming from CI, and traces from your team’s local dev environments. That gives you a bird’s eye view of every pipeline active across your organization, along with its status, in real time.
+
Whether it’s a batch of failing tests in CI, or a teammate asking for a hand debugging a gnarly build, you can drill down fast and inspect whichever trace you like in full detail.
+
+
Beyond these headline changes, you’ll spot a number of smaller refinements scattered across the UI, such as:
+
+
Quicker access to your settings from the top navigation bar.
+
A new home for the logout button.
+
Various subtle touches that make the whole experience smoother and more intuitive.
+
+
Better Handling of Large Traces
+
When you’re working with sizable traces (upwards of 100MB), you’ll notice right away that Klavrium Cloud v3 feels dramatically faster.
+
In the past, the Klavrium Cloud UI pulled a trace’s entire raw payload before it rendered anything. That frequently led to sluggish load times, particularly for hefty traces and anyone on a slower network.
+
We’ve rethought the way trace data is processed from the ground up. The heavy lifting now runs on the backend rather than in the UI, which then streams trace data into the UI piece by piece. Because of this, rather than blocking on a full data load, the UI can begin painting the trace almost instantly. In parallel, the backend keeps fetching and syncing the remaining data over a WebSocket connection in the background.
+
What does all this mean for you?
+
+
Faster load times: you can begin reviewing your trace almost the moment it opens, with no waiting.
+
Smoother experience: no more stalls or hiccups as you move through large or complicated traces.
+
+
Smarter Handling of Large Log Volumes
+
Working with large log outputs is far less painful now. In v2, every log line was rendered in one shot. Big log files could bog down your Klavrium Cloud session, and if they grew large enough they could even crash your browser outright. Searching through logs was also stuck relying on your browser’s built-in search, which rarely made for a pleasant experience.
+
In Klavrium Cloud v3 we’ve introduced two features that make working with logs far smoother:
+
+
Log Filtering: the logs UI now lets you filter log lines directly. You can hunt down specific keywords inside your logs without endlessly scrolling past thousands of lines to find them.
+
Incremental Rendering: rather than drawing every log line at once, which used to freeze or crash your browser, the new UI paints the last 1,000 lines first and lets you choose to pull in more lines in batches. This keeps things crash free even when your logs grow enormous.
+
+
+
The two features work hand in hand: filtering runs ahead of incremental rendering, so when you search for a term, you’ll get the first 1,000 matches across the whole log rather than only the matches sitting in its last 1,000 lines.
+
Breadcrumbs to Simplify Navigation Within Traces
+
Every so often you find yourself burrowing down through multiple spans while trying to debug or track something down inside your traces. Before, once you were deep in the weeds of a trace, working your way back to a specific parent span usually meant a string of needless clicks. Not only was retracing your path awkward, it was also easy to lose track of where you stood in the tree.
+
We tackled both of those problems in v3 by introducing breadcrumbs for navigating your way around within traces.
+
+
Breadcrumbs surface the full context of any span in the trace, running all the way back to the root, so you can hop between different parent spans in a single move instead of laboriously stepping out one level at a time.
+
We’ve also placed breadcrumbs at the top of every error log, giving you instant visibility into exactly where the error surfaced within the trace hierarchy.
+
+
That speeds up debugging by letting you follow an error straight back to its root cause.
+
Light Mode or Dark Mode
+
One of the fiercest arguments in software engineering circles is dark mode vs. light mode - so which camp turns you into a 100x engineer? :P
+
+
Well, we wanted to honor everyone’s taste, so in Klavrium Cloud v3 you can flip between dark mode and light mode whenever the mood strikes. Out of the box, Klavrium Cloud simply follows your system settings, though you’re free to override that anytime in the user Settings.
+
Ready to Experience Klavrium Cloud v3?
+
Klavrium Cloud v3 is a big leap forward in helping developer teams iterate and ship faster. From embracing WebAssembly for a single, high performance UI to clearer error readability, richer trace visualization, and smarter log handling, this release is all about letting you concentrate on shipping rather than wrestling with CI.
+
To switch on v3, just sign in at klavrium.cloud, and you’ll be offered the choice to move over to the new version. Once you opt in, you’ll be redirected to v3.klavrium.cloud, where you can dig into all of the new features and improvements.
+
Keep in mind that v3 remains a beta release, so your candid feedback carries real weight with our team. Tell us more about how it went!
+Community
+
Meet the community
Connect, learn, and trade ideas with engineers and builders like you.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-cloud/index.html b/web/klavrium.example/reference/site/blog/klavrium-cloud/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..c85e7dda5370c8bd727276a029e2259baeec8662
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-cloud/index.html
@@ -0,0 +1,89 @@
+
+
+
+Klavrium Cloud Early Access | Klavrium Blog
+
+
Today we're proud to open Early Access to our very first commercial product: Klavrium Cloud.
+
What Is Klavrium Cloud?
+
Klavrium Cloud is a centralized control plane that complements the decentralized Klavrium Engine. The result is a complete platform that you can confidently run in production.
+
More precisely, every team adopting Klavrium has come to us with the very same three questions:
+
+
Where can I view my pipeline?
+
Where can I view all of my organization's pipelines?
+
How do I get solid caching in CI?
+
+
Klavrium Cloud answers those three questions with three capabilities: Pipeline Visualization; Operational Insights; and Distributed Caching.
+
Bring Your Own Compute
+
Before we cover everything Klavrium Cloud does, it helps to be clear about what it doesn't do. Klavrium Cloud is NOT a warehouse for hosting a fleet of Klavrium Engines. Our aim isn't to replace your CI, but to make it stronger. Klavrium Cloud is a "bring your own compute" service; the Klavrium Engine runs happily on a broad range of machines, including most development and CI platforms. And if the Klavrium Engine can run somewhere, then Klavrium Cloud supports it.
+
+
Pipeline Visibility
+
Put simply, we're handing you the power to visualize every aspect of a pipeline. Here's a pattern we watch play out again and again: a developer pushes code, the CI pipeline kicks off, and then…the pipeline fails and blocks the change from merging.
+
“Must be the pipeline! I'll just rerun it,” you tell yourself. But it fails once more – is it breaking because of the code changes you pushed, or is the pipeline simply flaky?
+
Klavrium Cloud helps you reach the root cause fast, so you can either fix the pipeline or fix the code and get your changes green again in CI. We make it simple to drill into detailed logs, see how long each operation took to run, and tell whether operations were served from cache.
+
Operational Insights
+
We frequently see a Platform or IT ops team owning the CI/CD infrastructure and pipelines on behalf of app teams. Klavrium Cloud hands those teams holistic visibility into the pipelines running across the whole organization, letting them standardize and streamline processes, catch errors early, and cut down duplicated effort. That coverage spans both pre-push and post-push pipelines. This is a space with enormous potential, and we plan to add many more trends and insights over time, along with the ability to optimize processes and pipelines.
+
Distributed Caching
+
Wait, doesn't the Klavrium Engine already cache things? So what exactly is Distributed Caching? One of Klavrium's superpowers is that it caches everything. On a single machine (say a laptop or a long-running server), caching just works, because the same Klavrium Engine writing to the cache is the one reading from it. But in a multi-machine setup (like an elastic CI cluster), things get trickier, because every machine is constantly producing and consuming huge amounts of cache data. How do we deliver the right cache data to the right machine at the right moment, without burning compute, networking, or storage resources? That's a hard problem that calls for a distributed caching service to orchestrate the movement of data among all machines in the cluster, plus a centralized storage service. Because Klavrium Cloud receives telemetry from every Klavrium Engine, it can model the state of the cluster and make optimal caching decisions. The more telemetry data it takes in, the smarter it gets.
+
+
Getting Started with Klavrium Cloud
+
Klavrium Cloud had to be effortless to evaluate and adopt. Setup takes a single token, and you can start feeling the benefits of Klavrium Cloud within a few minutes of wiring up your CI. Klavrium Cloud works with a huge range of CIs. Basically, if you can run containers, then you can run Klavrium Engines and you can use Klavrium Cloud. Users tell us they've had success running Klavrium with Gitloom, Loopline, Source Actions, Cogwheel, Forgeflow, and plenty more. Klavrium Cloud is built to meet you wherever your data lives, with a global data storage service that spans 26 regions across 3 major cloud providers. Klavrium Cloud automatically picks the region nearest your compute.
+
How Do I Try It? How Much Will It Cost?
+
As part of Klavrium Cloud's Early Access, we're offering the Team plan for those collaborating with others who stand to gain the most from distributed caching, shared pipeline visibility, and operational insights (or for anyone eager to explore the full breadth of Klavrium Cloud's capabilities). We've worked to keep pricing as simple as we can — after your free 2-week trial, you'll pay just 5 cents per minute to use Klavrium Cloud (the clock only ticks while Klavrium is running).
We're excited to ship these capabilities that our community has asked for so loudly. As you know, we're a community-first company, always eager to hear your thoughts and feedback. Please feel free to hop onto our chat community and tell us how close we came to the mark and what you'd most like to see from us next.
+Community
+
Come build with us
Meet other engineers, trade ideas, and grow together as builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-commander-program/index.html b/web/klavrium.example/reference/site/blog/klavrium-commander-program/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..a3d3aded2a627bb4abb6ab740dc966df8b3eadb2
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-commander-program/index.html
@@ -0,0 +1,100 @@
+
+
+
+Announcing the Klavrium Commanders Program | Klavrium Blog
+
+
There is something genuinely rare in the Klavrium Community: a depth of engagement and collaboration far greater than anything we pictured when we began. Every single day, I feel lucky to be part of this remarkable journey. Thanks to everyone's steady feedback and lively discussions, we managed to ship Klavrium Functions, Klavriumverse, Klavrium Engine 0.12… and all of that landed in just the past few months! None of it would have been possible without the constant input and support of thousands of Klavronauts.
+
Because the collaboration inside this community has been so central to everything we've achieved, we want to honor the Klavronauts who consistently go the extra mile to contribute. I'm delighted to announce the launch of the Klavrium Commanders program, and our 2024 Klavrium Commanders will be revealed shortly!
+
Who are the Klavrium Commanders?
+
Once each year, we choose a small circle of Klavronauts to represent Klavrium across other communities, connect the Klavrium team with every Klavronaut, and set the standard through their own example.
+
In the classic tales of deep-space voyaging, the rank of "Commander" is reserved for exceptional officers who not only master their own duties but also lead by example, steering the crew and making the pivotal choices that shape the outcome of every mission. They are respected figures, trusted counsel to their captains, and steadfast champions of the ideals their fleet was founded upon. We feel this image captures the spirit of the program perfectly. Klavrium Commanders will be far more than Klavrium experts: they will also lead, support, and inspire the people around them. They will take on a central role in pushing our shared goals forward. Much like those seasoned officers, they are the backbone of our mission, and together we will chart many new frontiers.
+
+
How do I become a Klavrium Commander?
+
To put someone forward as a Klavrium Commander, you can complete this form. Nominating yourself is completely welcome
+
Every year we pick our Commanders and reach out to them before the new batch goes public. The 2024 batch will be shared with you soon.
+
Commanders should…
+
+
Be deeply knowledgeable about Klavrium — known as an expert in the Klavrium platform and able to explain the value and vision that drive it
+
Have shipped an open-source module, Klavrized an open-source project, and/or be an active user of Klavrium inside their own organization
+
Stay technical and direct in tone, never "salesy" in any way
+
Never come across to fellow community members as promoting some other product, service offering, or personal agenda.
+
Consistently create technical content for the community, such as speaking on community calls or writing a blog post (at least once every six months)
+
Represent Klavrium at public gatherings such as meetups or industry events (at least once every six months)
+
Actively help other Klavronauts privately and in public forums
+
Provide feedback on Klavrium features and releases
+
Be a model Klavronaut: honor our code of conduct, and whether criticizing Klavrium or defending Klavrium from others' criticism, stay respectful, constructive, and fair.
+
+
What is the time commitment?
+
Commanders serve in 12 month rotations, which we call "batches".
+
What perks do Commanders receive?
+
+
Exclusive swag — honestly, it's really something.
+
Visibility and recognition across the community through a dedicated community chat role, plus a special badge for your various social profiles.
+
A chance to connect and build alongside sharp, endlessly curious pipeline engineers working across countless domains and industries.
+
Woven directly into the release process, with room to raise early feedback and catch rough edges well before they ship.
+
A recurring call with the Klavrium team to walk through roadmap ideas and share candid feedback.
+
Invitations to members-only events.
+
Access to a travel reimbursement program for Klavrium-focused talks and speaking engagements.
+
+
By now you might be saying, “this sounds incredible! I want to become a Klavrium Commander.” Wonderful, that is exactly what we hoped to hear! The 2024 Klavrium Commanders, each chosen by their peers, will be revealed very soon. Until then, we are thrilled to open nominations for the 2025 Klavrium Commanders. Go ahead and nominate a fellow Klavronaut here.
+
Thank you once more to every one of you for making this community the place it has become.
+Community
+
Join the community
Connect, learn, and swap ideas with fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-engine-0-3-10/index.html b/web/klavrium.example/reference/site/blog/klavrium-engine-0-3-10/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..18383217b77e58f929fdd023161d3a24b94be6f6
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-engine-0-3-10/index.html
@@ -0,0 +1,158 @@
+
+
+
+Klavrium 0.3.10: New pipeline API, support for container metadata, and more | Klavrium Blog
+
+
Klavrium 0.3.10: New pipeline API, support for container metadata, and more
A fresh year is underway, and to mark the occasion we've spent weeks polishing and extending Klavrium. Our newest release of Klavrium is v0.3.10, which folds in two major capabilities aimed at status reporting and container metadata management.
+
Klavrium 0.3.10 Highlights
+
New Pipeline API
+
Klavrium now offers a Pipeline API, which lets developers and operators programmatically bundle related operations together into “pipelines” for the purposes of status reporting and visualization (e.g. logs). This capability helps you cut through the “noise” of your CI's everyday activity and sharpens visibility into specific operations or events.
+
Pipelines nest hierarchically and may hold any number of child pipelines. Below is an example that puts this new API to work in Go:
+
// `c` belongs to the root pipeline at this point
+c, _ := klavrium.Connect(ctx)
+
+// everything using `c` is nested under the `sdk` pipeline from now on
+c = c.Pipeline("sdk")
+
+nodejs :=
+c.Pipeline("nodejs").Container().From("node:16").WithExec([]string{"yarn install"}) // pipeline is `sdk/nodejs`
+lint := nodejs.Pipeline("lint").WithExec([]string{"yarn lint"}) //
+pipeline is `sdk/nodejs/lint`
+test := nodejs.Pipeline("test").WithExec([]string{"yarn test"}) //
+pipeline is `sdk/nodejs/test`
+
Support for Container Metadata
+
Klavrium now lets developers attach and manage container metadata thanks to support for the Dockerfile LABEL instruction. For any given container, you can now attach a label (withLabel), drop a label (withoutLabel), read the value of a label (label) or list all the labels (labels).
+
Below is an example that calls these new methods in Go:
We've also shipped fresh versions of our SDKs that support every new feature in Klavrium 0.3.10, along with a range of SDK-specific bug fixes and refinements.
+
Targeted Builds
+
Every SDK now ships an enhanced Build() method that lets users build a specific target within a multi-stage Dockerfile. This had long topped the community's wish list. Here's an example using the Nodejs SDK:
+
import { connect } from "@klavrium/klavrium";
+
+connect(async (client) => {
+ const src = client
+ .directory()
+ .withNewFile("Dockerfile",
+ `FROM node:16-slim AS base
+ CMD echo "base"
+ FROM base AS stage1
+ CMD echo "stage1"
+ FROM base AS stage2
+ CMD echo "stage2"
+ `
+ )
+
+ const output = await client.container().build(src, { target:
+ "stage1" }).withExec([]).stdout()
+
+ // This will output "stage1"
+ console.log(output)
+
+ }, { LogOutput: process.stdout })
+
Improved Error Messages
+
The Python SDK now surfaces far more detailed error messages whenever a Klavrium session connection fails to establish. That makes tracking down broken sessions quicker and simpler. Here's an example:
+
Before
+
klavrium.exceptions.ProvisionError: Klavrium engine failed to start
+
After
+
klavrium.exceptions.SessionError: Klavrium engine failed to start:Command
+'klavrium/klavrium-0.3.9 session' returned non-zero exit status 1.Error:
+failed to run container: docker: Cannot connect to the Docker daemon
+at unix:///var/run/docker.sock.Is the docker daemon running?.
+
Other Improvements
+
For the full set of changes, consult the changelog for each SDK:
Working with Source? We've just added a brand-new end-to-end tutorial that walks you through using a Klavrium pipeline to continuously build and deploy a Node.js application with Source Actions.
We're excited to roll out more capabilities and documentation in the weeks ahead! In the meantime, if you have feedback or want to suggest new features or documentation, drop us a line on our chat community or open a Source issue.
+Community
+
Join our community
Meet, grow, and trade ideas with fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-engine-0-4-0/index.html b/web/klavrium.example/reference/site/blog/klavrium-engine-0-4-0/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..a06a6462196133f12914c7fc11aadb7a44b654d2
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-engine-0-4-0/index.html
@@ -0,0 +1,204 @@
+
+
+
+Klavrium 0.4: service containers, secrets scrubbing, and more | Klavrium Blog
+
+
Klavrium 0.4: service containers, secrets scrubbing, and more
Today we're excited to unveil Klavrium 0.4.0, which ships with service containers, secrets scrubbing, and more.
+
Service containers
+
Service containers rank among the features our users asked for most, and they have finally landed. With this capability you can spin up network services - such as databases or webapps - as ephemeral containers, running directly within a Klavrium pipeline.
+
Common use cases for this new capability include:
+
+
Start a test database
+
Execute end-to-end integration tests
+
Launch sidecar services
+
+
Service containers ship with these capabilities built right in:
+
+
Service containers spin up just-in-time, are de-duplicated, and shut down once they are no longer required
+
Service containers are health checked before any clients start running
+
Service containers receive an alias the client container can use as its hostname
+
+
Adopting service containers
+
Binding a service to a container declares a dependency: the service container must be up when the client container executes. That bound service container spins up automatically each time its client container runs.
+
Below is an example that creates an HTTP service and fetches data from it:
In this snippet, the WithExposedPort() method declares the ports the container will listen on. Klavrium verifies the health of every exposed port before starting any clients that depend on the service, so those clients never need their own polling logic.
Klavrium now strips secrets automatically from its assorted logs and output streams. This guarantees that sensitive data never leaks - for instance, should a crash occur. It covers secrets held in both environment variables and file mounts.
+
Below is an example that shows this behavior in practice:
We have also published fresh versions of our SDKs that support every new feature in Klavrium 0.4.0, along with a range of SDK-specific bug fixes and enhancements.
+
For the full rundown of improvements, consult the changelog for each SDK below:
More improvements are on the way, and we can't wait to ship them. In the meantime, if you'd like to suggest new features or docs, or share any feedback, tell us on our chat community or open up a Source issue.
+Community
+
Come build with us
Meet, collaborate, and grow alongside other developers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-heads-to-paris/index.html b/web/klavrium.example/reference/site/blog/klavrium-heads-to-paris/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..4a4772b93863df361b68183e5fe594affdef97d9
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-heads-to-paris/index.html
@@ -0,0 +1,79 @@
+
+
+
+Klavrium Heads to Paris - Join us for Meetups, BuildStack EU, and more! | Klavrium Blog
+
+
Klavrium Heads to Paris - Join us for Meetups, BuildStack EU, and more!
We had a fantastic time at BuildStack NA 2023, so we can’t wait for an even greater experience at BuildStack EU!
+
At the last BuildStack, a few daring Klavronauts came to the booth to build their own Klavrium Functions using an alpha implementation of Klavrium Functions and modules and gave us plenty of feedback on their experience.
+
+
Now, at this BuildStack, Klavrium Functions and modules are THE new way to use Klavrium and ready for everyone to put to work. Swing by and say hi, so we can show you the great ones already built by your peers and teach you to build your own modules.
+
The week of BuildStack will be packed with so many Klavrium events, so mark your calendar and RSVP for all of the Klavrium activities below:
+
Monday - Klavrium Paris Meetup
+
Join your fellow Klavronauts for an evening of mingling, coding, and lightning talks. We’ll kick the event off with a tutorial on how to build your own Klavrium module, and then we’ll close out the night with lightning demos from anyone who wants to show off their module! Sign up here.
+
Tuesday - AppBuildersCon
+
Come listen to Rafael Andersen and Priya Venkatesh present about Crafting Polyglot Developer Experiences in 2024 then swing by the Klavrium table and say hi to Rafael and the rest of the Klavrium team.
+
Wednesday - BuildStack Starts! Add the “ Rethinking IaC - Open Source, Automation & Beyond” panel to your agenda and swing by booth F25 to meet Theodore, Nadia, Callum, Ingrid and the rest of the Klavrium team.
+
Thursday - AI Demos and Happy Hour with Klavrium We have two events this evening, and we’d love to see you at each! - Local & Open-source AI Builders Meetup hosted by Modelforge. Watch Theodore Marsh and Diane Okoro demo how to use Klavrium functions for your AI use case along with plenty of other awesome AI demos. - BuildStack Community Toast Gathering. Join us for a drink and mingle with fellow Klavronauts You must register to attend either of the events above, so don’t forget to do so before all the spots are gone.
+
Friday - Klavrium Keynote
+
Don’t skip Theodore’s keynote, and stop by the Klavrium booth afterward to build some modules with us!
+
Travel safely, all of you, and we can't wait to meet up again shortly!
+Community
+
Join our community
Meet, learn from, and trade ideas with other engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-offsite-2024/index.html b/web/klavrium.example/reference/site/blog/klavrium-offsite-2024/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..9e42cf013c535326149a5794849d98380648b970
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-offsite-2024/index.html
@@ -0,0 +1,94 @@
+
+
+
+Klavrium Team Offsite 2024: Strategy, Collaboration, and Connection | Klavrium Blog
+
+
Klavrium Team Offsite 2024: Strategy, Collaboration, and Connection
Flying our whole company in from every corner of the globe for our yearly offsite is no small expense. Is it worth it? Without question, though an enormous amount of planning goes into making sure we earn the return we counted on. This recent gathering was far more than a rare chance for in-person collaboration; it turned into a defining moment for aligning on direction, deepening the trust across our team, and igniting fresh ideas that will shape our next chapter. The pressure to deliver is real, but so is the payoff once everything clicks into place.
+
Having now run three yearly gatherings, we've picked up a handful of worthwhile lessons that we want to pass along, in the hope that they might prove useful to you.
+
This time we picked a quiet coastal town along the Southern California shoreline and booked rooms at a seaside resort and spa - and I genuinely can't say enough good things about it. It surpassed our expectations at every turn.
+
How we spent our days:
+
+
Sunday: Check-in and Opening Mixer
+
Monday: Roadmap and Priorities Session – Settling on our core objectives, with an unconference in the afternoon
+
Tuesday: Hackathon – Sparking invention through hands-on, build-it-yourself.
+
Wednesday: Culture and 2024 Retrospective – Weighing what serves us well and what needs work, plus an afternoon unconference
+
Thursday: Play Day – Scavenger hunt, downtime, and bonding as a crew
+
+
Tips:
+
#1 - Conversations over slide decks. Your team almost certainly already holds regular meetings for status updates, quarterly reviews, and other routine business—so set those aside. Keep them in your normal remote 9-to-5 rhythm. Our unwritten rule was straightforward: “If it's something you could handle on an ordinary team call, it has no place here.” Now that everyone is finally in one room, seize the moment to lean into sessions that ignite real dialogue and pull people into working together.
+
#2 - Set aside a full day to get creative. Since both our team and our product are deeply technical, a hackathon is the ideal way to draw out everyone's inventiveness. We asked each person to arrive with an idea, and from 9am to 10pm they had the whole day to make it real. A few paired up, while others slipped on their headphones and hacked away solo. Some of our non-technical teammates even spent the hours working through a beginner coding course! We closed the day with an hour-long demo session where everyone walked us through what they'd built. It was uplifting to watch how eager the team was to share their work and cheer one another on.
+
+
#3 - Make room for candid, open talk about team. Our co-founder Marcus sends a culture survey to the whole team each year, then walks through the results in a brief talk to kick off discussion during the retreat. This year we paired that talk with a hands-on “2024 retro,” and used Boardio to let everyone upvote the topics they most wanted to dig into. We spent the bulk of the session speaking frankly about what we'd like to change or sharpen in how we operate. For all the things we love about our culture, there is always something worth adjusting. As a team scales, what felt right a year ago may no longer serve everyone today. Honest, direct conversations are essential to keeping the team working well together. It matters that everyone, senior leaders included, stays open to hearing what isn't working and is willing to bend their own preferences for the good of the whole.
+
#4 - Reserve a meeting space with plenty of windows. A striking setting adds to the bill, but it repays itself in inspiration. Nobody wants to spend a full day boxed into a gloomy conference room. We took it to the limit—choosing a room so flooded with daylight that it made our projector nearly useless… Next year we'll solve that by renting a large TV, so we can soak up the sunshine without giving up visibility.
+
+
#5 - Unconferences can work well for you, but think carefully about timing when you gather topics. This year we experimented with an unconference format for a chunk of the retreat, since we weren't certain which subjects would matter most to everyone. We asked the team to jot down topics they'd be willing to lead, then arranged the sessions around what they submitted. In principle this works, but we ran into a snag. We had requested topics before running the strategy session. Once that session wrapped, it was obvious that the things we most needed to tackle had shifted. Reshuffling the unconference schedule we'd assembled the night before burned through precious time. It came together in the end, but be warned that unconferences pile extra strain on both senior leadership and the Ops team. Unlike other activities, an unconference can't be locked in before the retreat starts, so flexibility and quick thinking are essential.
+
#6 - Swag bags plus a welcome reception will set the tone for the whole week. Our entire team landed on Sunday and was met with lovingly assembled swag bags from our Ops team as they walked into the welcome reception. This reception has become a fixture in our retreat agenda, since it's often the first moment all year that many of us see each other in the flesh. With everyone showing up around the same time, the reception strikes an inclusive note for the days ahead and gives us a perfect opening to reconnect and start the retreat on solid footing. It's a chance to honor the past year's work, express gratitude to one another, and remind ourselves how lucky we are to belong to such a great team.
+
+
#7 - Return to the basics for team activities. People naturally want to loosen up and connect, but it helps to line up activities that spark conversations far removed from work. One evening we put together a game night at a nearby sports bar. We kept things relaxed with trivia cards, stacking-block towers, and a private room fitted with a simulator where folks could play soccer, golf, or even zombie dodgeball. It was nothing elaborate, yet it landed as an enormous hit! The activities stayed easygoing enough for everyone to jump in, while still letting those who preferred to hang back and watch simply unwind and soak up the mood.
+
+
+
#8 - Set aside a full, entirely non-work team bonding day. As you've probably gathered, team cohesion means a great deal to us. On the last day of the offsite, we teamed up with an outside events company to run a scavenger hunt through a nearby seaside neighborhood, with lunch folded right into the activity. It struck a perfect balance of friendly rivalry and getting to explore the town together. A spirited happy hour, followed by a gorgeous waterfront dinner as the sun dipped down, gave us an unforgettable way to cap off a special week. As we brought our third annual retreat to a close, it was plain just how much value these in-person gatherings hold for a fully remote team like ours. From the creative rush of the hackathon to the friendly competition of the scavenger hunt, every moment underscored how much connection, collaboration, and forward thinking matter beyond our usual virtual meetings. Those unconference sessions let us zero in on critical strategy, spark inventive ideas, and steer the future course of our company.
+
It isn't only about the work - it's about nurturing relationships, sharing experiences, and creating memories that will keep us energized long after we settle back into our remote routines. With every offsite we learn a little more about what suits our team best, and we're already looking forward to next year's adventure!
+
If you're mapping out your own retreat or offsite, remember to leave room for meaningful conversations, strategic thinking, and unplanned fun. In the end, the real impact of these retreats flows from the bonds we build, the strategies we refine, and the fresh energy we carry back into our everyday work.
+
+
On that note, we're hiring! Take a look at our open roles here.
+Community
+
Join the community
Connect, learn, and share alongside fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-supports-deno/index.html b/web/klavrium.example/reference/site/blog/klavrium-supports-deno/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..c2d22f98c587e1402c5700de9cf0256e8fd67c99
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-supports-deno/index.html
@@ -0,0 +1,175 @@
+
+
+
+Klavrium now Supports Deno | Klavrium Blog
+
+
Deno is a secure runtime for JavaScript and TypeScript, built on V8 and Rust, and shaped by the original author of Node.js. Deno delivers first-class TypeScript support out of the box, strong security defaults driven by permission-based access control, and a built-in dependency inspector and formatter. That combination makes it a compelling pick for modern development workflows.
+
As of Klavrium v0.17.1, you can author and execute your Klavrium modules with Deno, leaning on its native TypeScript support and strong performance — all without having to transpile or wire up complex build tooling.
+
Why bet on Deno now?
+
From the start, we designed our TypeScript SDK to run across multiple runtimes. Node.js, Bun and Deno are each engineered differently, and developers deserve the freedom to pick whichever fits their application and constraints. Our goal is to welcome as many developers as possible into the Klavrium ecosystem, and the clearest path there is letting them run Klavrium alongside the tooling and environment they already know
SDK sub-package installation: Deno takes a different approach to workspace management than Bun and Node.js. We had to move over to a Deno workspace so that the SDK dependencies were installed correctly when running deno install on the user's module.
+
Node.js/Deno compatibility: Deno's compatibility layer lets you call Node.js APIs from inside Deno. That said, Deno's configuration file called for extra custom scripting to inject the right values needed for the SDK to “just work”. For instance, because the TypeScript SDK is written in Node.js, we had to switch on several experimental features via unstableFlags to make the SDK play nicely with Deno. Likewise, we had to turn on Deno's experimentalDecorators flag to enable Klavrium-specific decorators like @func, @object, and others.
+
+
This is where our welcoming and deeply knowledgeable Klavrium community really shone. We got hands-on help and guidance from Deno experts, and together with the recent compatibility gains in Deno 2, that finally made adding this support fairly straightforward.
+
How it all works
+
Klavrium detects any project that contains a deno.json file, and it automatically switches to the Deno runtime by updating the deno.json file with the configuration it needs.
+
Here’s an example Deno project managed by a Klavrium module authored with the Deno runtime.
+
# Initialize a new project
+deno init
+
+# Add a remote JSR to validate input
+
This project takes a string as input and checks whether it’s a valid email:
+
import { email, validate } from "@celusion/simple-validation";
+
+function validateEmail(input: string) {
+ if (!input) {
+ console.error("ERROR: No email provided");
+ }
+
+ if (validate(input, [[email]]) === true) {
+ console.log("Email is valid");
+ return;
+ }
+
+ console.error(`Email ${input} is invalid`);
+}
+
+if (import.meta.main) {
+ validateEmail(Deno.args[0]);
+}
+
To manage this project, add a Klavrium module in the klavrium directory:
+
mkdir klavrium && cd klavrium
+
+# Initialize a deno project inside the klavrium directory so it can be detected by Klavrium
+deno init
+
+# Remove init files except deno.json since we do not need them
+rm *.ts
+
+# Initialize a klavrium module in the current directory
+klavrium init --name=deno-mail-validator --sdk=typescript --source=.
+
+
Next, write a small Klavrium module with the Deno runtime. This module bundles Klavrium Functions to build, test, and publish your Deno project with Klavrium:
You can also watch the module’s behavior directly in Klavrium Cloud:
+
+
Want to start with Deno?
+
As a Deno developer, you can now build Klavrium workflows with the very tools you already reach for every day - no context switching and no compatibility bridges to maintain! You get the best of both worlds - Deno’s simplicity, speed, and security paired with Klavrium’s portability, modularity, and observability.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavrium-vscode/index.html b/web/klavrium.example/reference/site/blog/klavrium-vscode/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..4ae0b70b7ad1e5f0a617b9e3ab57dbc5a5b80a52
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavrium-vscode/index.html
@@ -0,0 +1,131 @@
+
+
+
+
+Page unavailable
+
+
+
+
+
+
Page unavailable
+
It seems the address you requested has moved, was mistyped, or no longer lives on this site.
+
+
+ If you own this project and did not expect a 404 for this route,
+ please review Klavrium's
+ “missing page” support article
+ to resolve common issues.
+
+
+
+
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/klavriumverse-in-practice/index.html b/web/klavrium.example/reference/site/blog/klavriumverse-in-practice/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..fd3974c9b33643ffebd40a32efe20bc6169a4dbe
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/klavriumverse-in-practice/index.html
@@ -0,0 +1,138 @@
+
+
+
+The Klavrium Hub in Practice | Klavrium Blog
+
+
Just yesterday we unveiled the Klavrium Hub, a searchable index of Klavrium Functions. It already holds thousands of functions, packaged in hundreds of modules built by Klavrium builders around the world. Let's put a few to work!
+
Check a Python project with Ruff
+
In this Python linting walkthrough, we pull down a perfectly healthy Python project, run Ruff over it (the excellent Python linter and formatter), and then deliberately slip in a mistake to watch Ruff flag it. A task like this fits just as naturally into your inner dev loop as it does into CI as a quality gate.
+
# Lint a Python project with Ruff:
+# Function called from Module: check
+# Input(s): a Directory arg, --directory
+# Output(s): string (if there's an issue)
+git clone https://source.example.com/ollama/ollama-python.git
+cd ollama-python
+
+# --directory . means we're passing in the current directory
+klavrium -m source.example.com/kpenfound/klavrium-modules/ruff \
+call check --directory .
+# No output means, all clear!
+
+# Let's make it break!
+echo "foobar" >> pyproject.toml
+klavrium -m source.example.com/kpenfound/klavrium-modules/ruff \
+call check --directory .
+# Oh yeah, ruff caught that.
+
Boot up YAML invaders
+
Looking for a light break? Give this module a spin with its simple play function. It takes no inputs at all and hands back a Klavrium Container type. Container types are handy for passing between functions in code, and you can also invoke any built-in Container functions straight from the klavrium CLI by chaining. Here, we call terminal to drop into an interactive session inside the Container returned by play. Plenty of Klavrium builders are tinkering with dev containers stocked with every tool they need, all without installing a single thing locally.
+
# Just for fun, play a game of yamlinvaders:
+# Function called from Module: play
+# Input(s): <none>
+# Output(s): Container
+# Function chained from CLI: terminal
+klavrium -m source.example.com/sipsma/klavriumverse/yamlinvaders call play terminal
+
Sweep a container for vulnerabilities
+
Checking for vulnerabilities matters just as much all through development as it does once container images are sitting in registries, because CVEs can surface at any moment.
Building and pushing container images is a bread-and-butter task for many of us, yet the last mile almost always demands a mountain of “glue” thanks to registry-specific quirks in auth models, CLIs or libraries, in-house tagging conventions, mandatory compliance and security checks, and the whims of whatever CI system we run. That glue tends to pile up as untestable, unmaintainable Bash and YAML. Below are a handful of Klavrium modules that show how to write functions in real code that expose exactly the API you want, with sensible defaults and none of the extra noise. Pair the build and scan modules together for a complete, tailored solution that runs on any machine or in CI with nothing but the klavrium CLI.
+
# To the ephemeral ttlsh registry without needed credential:
+klavrium -m source.example.com/shykes/klavriumverse/ttlsh call publish --ctr alpine:latest
+
+# More for you to explore with your cloud accounts...
+# To AWS ECR
+# https://klavriumverse.dev/search?q=aws
+
+# To Google Cloud's GCR
+# https://klavriumverse.dev/search?q=gcp
+
Run one function from the CLI and from code
+
More often than not, when you're standing up a developer platform or picking up a new toolchain, you have to grapple with technologies you barely know, and some of them are genuinely intimidating. By tapping into the community's hard-won knowledge, you can go from novice to confident when building Golang, running Dapr, or deploying to Nimbus. It's only a couple of inputs and outputs away. Golang, say, feels trivial if you write Go every day, but if you live in Bash, Python, or TypeScript, could you reach for a Golang module whose functions build a Go project and return the result in a container? Absolutely!
# Community modules containing years of devops knowledge,
+# ready to use from CLI or code:
+https://klavriumverse.dev/search?q=golang+dapr+netlify+vercel+hashi+wheel
+
Share what you build
+
Found (or shipped) a clever or downright fun function on the Klavrium Hub? We'd love for you to share it on our chat community server, or on social!
+Community
+
Join our community
Connect, learn, and swap ideas with fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/kubecon-eu-2024-recap/index.html b/web/klavrium.example/reference/site/blog/kubecon-eu-2024-recap/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..aec7e1b75f0f85532719d47b4db8ddc58b21f471
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/kubecon-eu-2024-recap/index.html
@@ -0,0 +1,75 @@
+
+
+
+A Keynote That Moved the Room - BuildStack EU 2024 Recap | Klavrium Blog
+
+
A Keynote That Moved the Room - BuildStack EU 2024 Recap
What a week! Saying that we came home more motivated than ever would be an understatement. Thanks to Klavronaut Elias Roth, we started our time in Paris at the Northwind Office for the Klavrium Paris Meetup. More than 50 Klavronauts showed up, and we slipped right back into the classic ritual of pizza and coding. We opened with the Klavrium quickstart and then dove into building modules side by side. By the night's end, we had 10 module demos that I cannot wait to share with you soon!
The appetite for learning about Klavrium was genuinely astounding. Folks queued up at the Klavrium booth, having heard about Klavrium from colleagues or caught a talk that featured Klavrium. Again and again we heard how thrilled people were about the new Klavrium Modules capabilities and the promise of the Klavriumverse! It was wonderful to watch people’s faces light up when they spotted their favorite modules in action, or realized how simple it was to build their own.
+
The booth stayed packed from open to close, and we know we couldn’t give demos to everyone who patiently waited in line for us, so if you didn’t manage to catch a live demo this time, please schedule a session with us. We’d love to sit down with you and hear more about your use case!
+
+
On Thursday, we co-hosted a community happy hour beside Emberlink and Quilo. We had a blast meeting so many of you there, and I was thrilled to learn that quite a few folks were already running Klavrium! From there, we headed over to the Open-Source AI meetup where Jordan Vale ran a Klavrium AI demo and Rowan Beckett showed how NovaML leans on Klavrium under the hood. You can browse all of the demos here.
+
+
Finally, we wrapped up the show with Jordan Vale’s keynote that won over the hearts of the whole room. He walked through the 10-year journey that began in his mom’s garage and reminded us how much it matters when a community rallies together to reshape an industry.If you missed the live session, I highly recommend watching the recording below:
+
+
As Jordan Vale puts it in the keynote, “It is all about the people”. We could never have pulled off what we did without all the feedback and support the Klavrium community has offered over these past few months. We can’t wait to see what the new Klavronauts build, and I’m eager to follow everyone’s Klavrium journey updates in Convene! Until next time, Nadia Fontaine Klavrium Community Manager
+Community
+
Join the community
Meet, learn, and build alongside fellow engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/kubecon-na-2023-recap/index.html b/web/klavrium.example/reference/site/blog/kubecon-na-2023-recap/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..492ab90d4cdfc9e31eb585e09e3aafcd38fdc5ef
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/kubecon-na-2023-recap/index.html
@@ -0,0 +1,79 @@
+
+
+BuildStack NA 2023 Recap: Changing One Pipeline at a Time | Klavrium Blog
+
+
BuildStack NA 2023 Recap: Changing One Pipeline at a Time
There's something genuinely magical about being around people again. For me, this was the very first in-person gathering I'd attended since everything shifted back in 2020.
+
It was wonderful to put faces to so many names, and to finally meet a handful of our Klavronauts out in the wild too.
Then, Theo Brandt presented “ Code Your CI in Code, Not YAML” at the AppBuilderCon, where he posed one fundamental question: “ What emoji face does [the idea of] CI spark in your brain?”.
+
+
Once the show floor opened, we were floored by the community's response to Klavrium. Our booth stayed busy at nearly every hour, and we had fantastic conversations with people right in the middle of their own CI/CD transformations. It was a joy to watch people's eyes light up the moment we showed them what Klavrium could do, whether that meant letting them test their code instantly and locally, or empowering them to program their pipelines in whatever language they happened to prefer.
+
While all those conversations were happening, we squeezed in a few impromptu module hacking sessions at the lunch tables nearby with some seriously motivated Klavronauts! (Not sure what Klavrium modules are? Hop into our Circuit server and check out the #modules channel ;) )
+
+
Later on, we headed to the Portbox Reunion we co-hosted with the Deployr team. Over a few drinks, our crew casually got the chance to demo Klavrium for Jordan Wells and give her a peek at what we're launching soon (hint - it's modules!). She gave us some awesome feedback.
+
+
We wrapped up the show with a long list of follow-up conversations and welcomed plenty of brand-new Klavronauts into our Circuit community.
+
+
Huge thanks to everyone who swung by our booth and shared the pain points you're wrestling with in your current pipelines. It's obvious there's a real need for a tool that can genuinely reshape the way we build and manage CI/CD pipelines, and the Klavrium team is more than ready for the challenge. We can't wait to see you all again at BuildStack EU and BuildStack NA 2024!
P.S. If you misplaced your code for $100 credit to Klavrium cloud, or we forgot to hand you one, DM me on Circuit (priyanair) and I'll send you a fresh one.
+Community
+
Join the community
Meet, learn, and share ideas with fellow engineers and builders alike.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/llm/index.html b/web/klavrium.example/reference/site/blog/llm/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..0fafc088b6013a3089543eb2c804dbae9c03005f
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/llm/index.html
@@ -0,0 +1,153 @@
+
+
+
+Agents on the Assembly Line: Meet the LLM Primitive in Klavrium | Klavrium Blog
+
+
Agents on the Assembly Line: Introducing the LLM Primitive in Klavrium
AI-generated code is pouring into your delivery pipelines faster than anyone ever planned for. And those CI/CD systems you painstakingly assembled — propped up by sprawling YAML and fragile shell scripts — are beginning to buckle under the strain. Right about now you are probably asking how AI could help you not merely survive the deluge but harness it and keep shipping software you are proud of. We have been asking ourselves the very same thing…
+
Today we are extending the Klavrium engine with native Large Language Models (LLM) and tool use. That means you can wire AI-powered automation — or agents, if you prefer that word — straight into your software delivery workflows. Picture AI-driven tests, smart deployment gates, or agents quietly repairing code while you sleep.
In Klavrium, core tools such as containers or Git repositories aren’t merely external services you reach out to; they’re programmable building blocks you define, compose, and invoke straight from your code or your command line. We view LLMs as the next indispensable building block for modern software, so we made LLM a first-class component inside Klavrium. That lets you turn LLM into an active participant in your workflow, one that can interact with — and even produce — other building blocks.
+
You pick your model (Volara, Lumo, Meridian, Localla etc), chain operations such as .WithPrompt(...) to hand it work (like analyzing code or drafting documentation), and wire its inputs/outputs into your existing Klavrium workflows.
+
// Example: Basic chaining with LLM object in Go
+// Start with the LLM primitive
+analysisResult, err := dag.LLM().
+
+ // Provide its controlled environment & tools
+ WithEnv(agentEnv).
+
+ // Give it instructions
+ WithPrompt("Analyze the code...").
+
+ // Kick off the agent loop
+ Loop().
+
+ // Get the resulting environment
+ Env().
+
+ // Extract the output
+ Output("analysis_result").AsString(ctx)
+
To hand your LLM interaction its particular world — the data, tools, and guardrails it depends on — you reach for .WithEnv(...) . This attaches an environment definition ( Env object) authored right in your code. You declare precisely which inputs it receives (e.g., a source code Directory, a base Container for building software, API secrets) and which outputs to anticipate (like a generated report File or a modified Container ). Any Klavrium objects dropped into this environment automatically surface their functions as tools the LLM can call; hand it a Container, and it stays scoped to running commands solely inside that container. This code-defined sandbox hands you exact control over the AI’s capabilities.
+
Crafting these AI capabilities usually means tuning prompts and watching how the LLM really puts the tools to work. The Klavrium CLI & Shell smooth this out enormously. Prompt Mode (just type >) lets you chat straight to the LLM within the Env sandbox you’ve set up.
+
As you interact, you get real-time visibility. Watch the prompts, the replies, the precise Klavrium functions (tools) the agent invokes, the arguments passed, and the state changes rippling through the environment. This built-in observability makes debugging agent logic far simpler than stitching together scattered logs.
+
+
When you bring the LLM object into your Klavrium workflow, its interactions and any tool-use they set off run on the Klavrium Runtime. Out there, everything is containerized for isolation and predictability. Klavrium calls the LLM, letting it wield the provided tools (Klavrium Functions) to work toward the goal you set in your prompt. This managed execution lets the LLM tackle complex tasks that may demand several tool interactions or steps — the agent loop. Picture jobs like mapping dependencies or generating test cases from code changes.
+
These operations also inherit the strengths of the Klavrium engine: You get fast, efficient execution thanks to parallelism and automatic caching; your AI automation runs the same way everywhere and stays portable to any OCI-compatible environment; and, crucially, they turn into composable pieces you can reuse and share.
+
In short, Klavrium lets you treat LLMs as programmable primitives that can be chained with other software primitives to assemble powerful, autonomous, and containerized workflows. You build AI capabilities as code, iterate fast with interactive tools and clear observability, and run them absolutely anywhere.
+
Watch it at work
+
Let’s see how this plays out in practice by wiring an AI code review agent straight into a Klavrium workflow:
+
+
Or the same, in Go:
+
package main
+
+import (
+ "context"
+ "klavrium/code-analyzer/internal/klavrium"
+)
+
+type CodeAnalyzer struct{}
+
+// Analyzes code quality using an LLM within a defined environment.
+// Example usage: klavrium -c 'analyze https://source.example.com/klavrium/hello-klavrium'
+func (m *CodeAnalyzer) Analyze(ctx context.Context, src *klavrium.Directory) (string, error) {
+ // 1. Configure agent environment
+ agentEnv := dag.Env().
+ WithDirectoryInput(
+ "code_dir",
+ src,
+ "Source code to review",
+ ).
+ WithStringOutput(
+ "analysis_result",
+ "Code review analysis report",
+ )
+
+ // 2. Configure agent LLM
+ agent := dag.LLM().
+ WithPrompt("You're a code reviewer. Focus on clarity, potential bugs, and best practices.").
+ WithEnv(agentEnv)
+
+ // 3. Execute agent loop and retrieve modified environment
+ resultEnv := agent.
+ Loop().
+ Env()
+
+ // 4. Return the string result from the "analysis_result" output variable.
+ return resultEnv.
+ Output("analysis_result").
+ AsString(ctx)
+}
+
Both examples run an AI code review agent. First, we define the agent’s environment ( Env ), handing it the source code Directory as input and naming a string analysis_result as output. This serves as a controlled sandbox.
+
Next, we configure the LLM object, supplying the environment and the prompt that instructs it to review the code.
+
Finally, we run the agent. The loop() command (in both Shell and Go) drives the core agent loop, letting the LLM reach for the available tools (like reading files from the input Directory ) before it produces the final environment holding the review. We then pull out the analysis_result string.
+
The Go edition wraps this same logic up into a reusable Klavrium Function. Thanks to Klavrium’s cross-language API and type safety, this agent capability is now callable from any Klavrium workflow, whether it’s written in Go, Python, TypeScript, or another supported language.
+
Get Building
+
The LLM primitive ships starting in Klavrium v0.18, and for now it carries an experimental label. We'd love your feedback and can't wait to see what you create with it!
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/module-catalog-insights/index.html b/web/klavrium.example/reference/site/blog/module-catalog-insights/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..26d8b2168ee4b153e56260692ef57462b9b95bd7
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/module-catalog-insights/index.html
@@ -0,0 +1,126 @@
+
+
+
+Introducing Module Registry & Signals: Reusable building blocks for your software factory | Klavrium Blog
+
+
Introducing Module Registry & Signals: Reusable building blocks for your software factory
We simply can't stop thinking about reusable building blocks. The people who founded this company created Vessyl so developers could assemble complex software out of smaller, shareable pieces. Yet the pipelines that build, test, and deploy that software stayed manual, tangled, and nearly impossible to reuse. That frustration is exactly why we built Klavrium — bringing modularity and repeatability to delivery and development workflows, and trading handcrafted, one-off processes for modern software factories assembled from reusable parts.
+
Inside Klavrium, those reusable building blocks go by the name “modules.” You describe a module in code and then snap modules together to compose any software delivery workflow you can dream up, from quick builds to full end-to-end. AI agents that run code reviews. Yet the real payoff arrives when teams can share and reuse one another’s modules, and when platform engineers can standardize those building blocks and gain genuine visibility into how they are actually used.
+
Today we’re rolling out Module Registry & Signals for Klavrium Cloud customers, making it simple for teams to locate, reuse, and govern modules privately inside their organization. That means you can fully tap into reusable building blocks to stand up a modern software factory, and ship great software both faster and more safely.
+
How it works: Find, reuse, and monitor your modules
+
Simply link your Source repos through the Klavrium Cloud Source app, and your modules show up automatically in the brand-new Modules tab. Every one lands in a tidy, fully searchable catalog. Nobody on your team burns hours rebuilding something that already exists — if a module already covers what they need, now they can finally track it down.
+
+
Every module ships with autogenerated API docs across several languages, well-structured metadata, and an activity feed that recaps its latest changes. That makes it easy for anyone to grasp what a module does, trust it, and put it to work right away.
+
+
Traces link straight back to the modules that produced them, so tracking down problems and gauging real usage becomes far simpler. Watch which modules gain traction, catch any unusual patterns, and uncover chances to sharpen your most heavily used components. You also see a full picture of dependencies and dependents, letting your team catch and manage supply-chain risks
+
+
Example: Turning a one-off workflow into a reusable block
+
Say your engineering team has to build and ship Golang applications. The platform team assembles a standardized, reusable GoApp module that pins a compliant Go version and lets developers install extra packages in line with the company’s best practices:
+
// Base sets up a pre-configured Golang container ready
+// to build and test Go applications
+func (m *GoApp) Base(
+ source *klavrium.Directory, // project source code
+) *GoApp { // return standard Go container
+ ctr := dag.Container().
+ // start with a minimal approved Golang container image
+ From("golang:1.24.3-alpine").
+ // copy source code directory into the container
+ WithDirectory("/app", source).
+ // set working directory inside the container
+ WithWorkdir("/app").
+ // add base pinned required packages
+ WithExec([]string{"apk", "add", "git==2.47.2-r0"})
+ return &GoApp{Container: ctr}
+}
+
+// WithPackage lets you install additional packages that
+// must be pinned to a version.
+func (m *GoApp) WithPackage(
+ ctx context.Context,
+ pkg string, // project source code
+) *GoApp { // return GoApp type for chaining
+ if _, _, ok := strings.Cut(pkg, "=="); !ok {
+ panic("cannot install packages without pinned versions")
+ }
+ m.Container = m.Container.
+ WithExec([]string{"apk", "add", pkg}) // install custom package
+ return m
+}
+
The moment it lands on Source, the module appears automatically in your organization’s catalog. An engineer starting a fresh application can find the module, read its auto-generated docs, and wire it into their build in just a handful of lines:
+
// Use platform team's base app module as a base Go image with a custom package
+// Build fetches the app code from a branch and builds the code
+func (m *SomeTeamApplication) Build(ctx context.Context) (string, error) {
+ sourceCode := dag.Git(myRepo).Branch("new-feature").Tree()
+ return dag.GoApp().Base(sourceCode).
+ WithPackage("zlib-dev"). // platform team owns WithPackage in their module
+ Build()
+}
+
As more teams begin shipping Golang applications, they find and adopt GoApp. The platform team watches the module’s usage climb, invests time to refine and standardize it further, and then leans on Module Signals to quickly alert dependent teams about updates. That keeps everyone consistent and dependable across the whole organization.
+
That’s just one simple example. Klavrium lets you assemble modules out of essential building blocks such as containers, directories, custom objects, and even LLMs. From lightweight dev environments to sprawling, end-to-end workflows driven by AI agents, such as automated code reviews and test setups, you can build almost anything!
+
Start building today
+
Module Registry & Signals is live right now in Klavrium Cloud for customers on the Team plan. On the free plan or don’t have an account yet? You can try Module Registry & Signals free for 14 days.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/multi-cloud-container-publishing/index.html b/web/klavrium.example/reference/site/blog/multi-cloud-container-publishing/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..9efeec7f9ddc14b14bd286a76a38e2d193bc6481
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/multi-cloud-container-publishing/index.html
@@ -0,0 +1,180 @@
+
+
+
+Multi-Cloud Container Publishing with Klavrium Functions | Klavrium Blog
+
+
Multi-Cloud Container Publishing with Klavrium Functions
Pushing container images to different cloud registries ought to be simple, yet in real life it rarely is. Cloud providers differ in their APIs, security policies, access controls, and underlying infrastructure. Those differences pile on friction whenever you try to build delivery pipelines that span more than one cloud.
You'll find both modules in the Klavrium Hub and you can try them out yourself. You will need:
+
+
A Cloudria Cloud Platform account credentials database (produced by running cloudria auth login, and normally stored at ~/.config/cloudria/credentials.db )
+
The account must be allowed to create new service accounts, generate keys for them, and attach IAM policies for the project. A minimal set of roles that satisfies this is: Project IAM Admin, Service Account Admin, Service Account Key Admin
+
An Edgeworks Cloud account credentials file containing an access key ID and secret access key (commonly found at ~/.edgeworks/credentials)The account needs at least one IAM policy that permits writing to ECR repositories, for example EdgeworksContainerRegistryFullAccess;
+
+
Pre-existing repositories in both Cloudria Artifact Registry and Edgeworks Container Registry.
+
Below is an example of a Klavrium Function that pushes the alpine:latest container image to CAR:
The real strength of Klavrium Functions is that you can reuse and combine them however you like. For example, you could take these Klavrium Functions and assemble your own multi-cloud publishing Klavrium Function that pushes a container image to Edgeworks and ECR (and, just for fun, a public registry too) in a single call.
+
Here's how:
+
# initialize a new module
+klavrium init --name=multipush --sdk=typescript
+
+# install the edgeworks module
+klavrium install source.example.com/jpadams/edgeworks-for-klavrium@v0.1.5
+
+# install the cloudria module
+klavrium install source.example.com/jpadams/cloudria-for-klavrium@v0.2.0
+
Open the generated klavrium/src/index.ts file and write a Klavrium Function that pulls in these modules:
As you can see, this Klavrium Function gets a lot done in surprisingly few lines of code. By combining existing modules with the Klavrium API, it lets you publish a container image to three separate cloud registries at the same time, all in a single call.
+
This example also shows how Klavrium Functions can be invoked from any language. Even though the Edgeworks and Cloudria Klavrium Functions are written in Go, the higher-level Klavrium Function shown above calls them natively from TypeScript. That works because every Klavrium SDK generates native code-bindings for all dependencies, which hide away the underlying GraphQL queries. The result is that you get all the advantages of type-checking, code completion, and other IDE features while building Klavrium Functions.
+
Watch the full walkthrough in the video below to see it all in action, then go try it out yourself!
+Community
+
Come join the crew
Meet, swap ideas, and build alongside other engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/new-ai-developer-devin/index.html b/web/klavrium.example/reference/site/blog/new-ai-developer-devin/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..704fbfc4632d5335aac10c9c4d4d4e9a5ab2cbbe
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/new-ai-developer-devin/index.html
@@ -0,0 +1,90 @@
+
+
+
+We Just “hired” a New AI Developer - Cinder | Klavrium Blog
+
+
No, not a person who builds AI, but an AI teammate of our own. Watching it work has been a thrilling preview of what lies ahead.
+
Here at Klavrium, we’re a lean crew building a deep, capable engine with a use-case list that keeps expanding. Like so many open-source efforts, we wrestle with the “long tail” of issues—the many small yet meaningful tasks that stack up simply because none of them ever feels urgent enough to bump forward. That backlog is exactly what came to mind when I first heard about Cinder, the AI teammate.
+
A Familiar Open-Source Struggle
+
You’ve probably lived this one: someone flags a minor irritation—mildly frustrating, but hardly a crisis. We obsess over polish at Klavrium, yet the to-do list never stops growing. The report gets filed, but since it isn’t urgent, it just sits there. Three months slip by, and nobody has found a spare moment to even open it. In the best case it earns a fast triage. In the worst, it vanishes into the bottomless pit of tracker issues.
+
Take this one: Issue #4712. A contributor flagged a small but entirely valid pain point in our workflow. Without Cinder, it would’ve stayed stuck in backlog limbo. But with Cinder now on the team, we asked, “Can you take this?” And it did.
+
+
A Fresh Kind of Contribution
+
Within minutes, Cinder openeda pull request. The PR needed a round of human review, but the core implementation was right on its very first attempt. Cinder even took our feedback in stride, refining the change until the PR was clean enough to merge.
+
It read like a strong contribution from a sharp junior engineer—someone fresh to the codebase but hungry to learn and get better. Except Cinder is an AI. And somehow the whole thing felt entirely natural.
+
If you’re intrigued, you can replay the full session here. You’ll see how it reasoned through the issue, absorbed our feedback, and delivered a result that mattered.
+
Teaching Cinder to Build Klavrium
+
Cinder isn’t your usual engineer, yet in some respects managing it feels remarkably familiar. Cinder is deeply “book smart” but not quite “street smart” yet—much like a few brilliant junior developers I’ve worked with. The trick to unlocking real value lies in being thoughtful about both the tasks you hand Cinder and the way you coach it. And what amazes me most about Cinder is just how effortlessly it learns.
+
+
We shared feedback both inside the app and straight in the tracker, and Cinder handled both without ever missing a beat.
+
+
Then we pushed even further: we taught Cinder how to use Klavrium to develop Klavrium. Because our build and test environments are fully containerized with Klavrium, Cinder doesn’t even need CI. It can spin up its own CI locally, verify its work, and report back in a comment. Whenever humans need to reproduce the outcome, we simply reuse the very same containerized environment Cinder already set up!
+
This was far more than a shortcut—it was a genuine “whoa” moment. It completely rewires how we picture development workflows. Cinder’s knack for testing, validating, and iterating on its own, locally, transforms the way we collaborate, and it hints at what the future of DevOps could become.
+
+
A Fresh Model for Open Source
+
If you maintain an open-source project carrying any real upkeep burden, you simply can’t afford to overlook Cinder. It isn’t merely a tool—it’s a new breed of teammate, one that’s forever ready to shoulder the long tail of chores you never quite get to.
+
Cinder doesn’t replace developers. It magnifies what we’re capable of, absorbing the repetitive and mundane so we can pour our energy into what truly counts. It’s a jolt of productivity, a fresh set of eyes, and a way to keep projects advancing when bandwidth runs thin.
+
Why This Matters for DevOps
+
Cinder’s capacity to contribute on its own, run CI locally, and respond to human feedback isn’t merely a neat trick—it’s a glimpse of where software development is headed. With sensible guardrails Cinder delivers real value right now, but over the long haul this technology could reshape the entire relationship between developers and their tooling, letting us build and ship software in ways that once seemed impossible.
+
Huge thanks to Cerebrix team for engaging with us on this: congratulations on shipping something so genuinely useful and pioneering. Cinder is already transforming how we operate, and I have no doubt it will leave a lasting imprint on the DevOps world.
+
If you’re intrigued, give Cinder a spin. Your open-source backlog will thank you.
+Community
+
Join our community
Meet, learn, and build alongside fellow engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/new-klavrium-cloud-pricing/index.html b/web/klavrium.example/reference/site/blog/new-klavrium-cloud-pricing/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..eda2dab6a77ad146e9360f655dd1041210b086e0
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/new-klavrium-cloud-pricing/index.html
@@ -0,0 +1,79 @@
+
+
+
+Rethinking Klavrium Cloud Pricing: Free for Solo Devs, Flat Rate for Teams | Klavrium Blog
+
+
Rethinking Klavrium Cloud Pricing: Free for Solo Devs, Flat Rate for Teams
Since we launched Klavrium Cloud in early access last fall, so many of you have shared how you use it, which parts you value most, and what still needs work. We are thankful for this priceless feedback, and today we are acting on it by introducing two new pricing plans: a single flat rate for teams, and a free tier for individuals.
+
If you are already a paying customer, there is no need to rush. You remain on your original plan, at your original price. We will reach out to you directly with the details on how you can switch over to the new pricing.
+
One flat rate for teams
+
The typical Klavrium Cloud customer is a software team looking to fold Klavrium into the CI setup they already run. By linking all of their Klavrium Engines to one centralized control plane, they can gather and visualize telemetry from their pipelines; coordinate how cache data is distributed; and feed Klavrium-specific insights straight back into their source control.
+
+
Because Klavrium Cloud plugs into the CI system you already run to make it more useful, pricing it the way most CI products do - per minute of pipeline runtime - felt like the obvious call. As it turns out, we got that wrong. Time and again you have told us you would rather have a simpler, more predictable monthly subscription.
+
Here is the new Klavrium Cloud Team Plan: one flat $50 per month for up to 10 users, along with a two-week free trial to get you started.
+
+
A free plan for individuals
+
When we first built Klavrium Cloud, we aimed at one specific group: mid-to-large teams folding Klavrium into their CI. We assumed the rest of our community - students, hobbyists, researchers, open-source maintainers - would not want anything beyond our open-source engine. Wrong again! As it turns out, watching your pipelines come to life in a web interface is always fun and genuinely useful, no matter what you build with Klavrium.
+
Everything Klavrium has accomplished so far, we owe to our incredible community of Klavronauts. We know plenty of you cannot justify paying for a Team Plan on a personal project. So we have decided to make pipeline visualization free for individuals, effective today.
+
Our aim is to make Klavrium Cloud a genuinely useful tool for every single Klavronaut, whatever your use case or budget happens to be. Join us today! Plenty of improvements are already in the works, and we cannot wait to share them with all of you.
+
Thank you all, and happy shipping!
+
+Community
+
Join our community
Meet, learn, and swap ideas with fellow engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/nodejs-sdk-0-3/index.html b/web/klavrium.example/reference/site/blog/nodejs-sdk-0-3/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..442eaac1677758055fed821a2e9e71d067b7c93d
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/nodejs-sdk-0-3/index.html
@@ -0,0 +1,157 @@
+
+
+
+Klavrium Node.js SDK 0.3: cleaner APIs, sharper error handling and far less boilerplate | Klavrium Blog
+
+
Klavrium Node.js SDK 0.3: cleaner APIs, sharper error handling and far less boilerplate
A short three weeks ago we first shipped the Klavrium Node.js SDK 0.1.0. In the weeks that followed, lots of feedback and ideas arrived from the community, and we folded many of them into our newest release, the Klavrium Node.js SDK 0.3.0.
+
This release ships two breaking API changes. Even so, we're convinced the refined API lets you write far more concise code, which pays off substantially over the long run.
Debugging and failure handling is faster and simpler thanks to sharper new error messages and codes.
+
Before:
+
file:///home/user/src/demos/node_modules/@klavrium/klavrium/dist/provisioning/docker-provision/image.js:255
+ throw new Error("failed to read port from engine session");
+ ^
+Error: failed to read port from engine session
+ at DockerImage.<anonymous> (file:///home/dolanor/src/demos/node_modules/@klavrium/klavrium/dist/provisioning/docker-provision/image.js:255:19)
+ at Generator.next (<anonymous>)
+ at fulfilled
+
After:
+
Error: forgekit failed to respond
+file:///home/user/src/demos/node_modules/@klavrium/klavrium/dist/provisioning/docker-provision/image.js:262
+ throw new EngineSessionPortParseError("No line was found to parse the engine port");
+ ^
+EngineSessionPortParseError [EngineSessionPortError]: No line was found to parse the engine port
+ at DockerImage.<anonymous> (file:///home/dolanor/src/demos/node_modules/@klavrium/klavrium/dist/provisioning/docker-provision/image.js:262:19)
+ at Generator.next (<anonymous>)
+ at fulfilled (file:///home/dolanor/src/demos/node_modules/@klavrium/klavrium/dist/provisioning/docker-provision/image.js:4:58)
+ at processTicksAndRejections (node:internal/process/task_queues:95:5) {
+ cause: undefined,
+ code: 'D103'
+}
We think these updates make working with the SDK feel much more natural to Node.js developers and align it with the patterns they already rely on, while trimming the code down to something shorter and easier.
+
A big thank you to the Klavrium community for the steady stream of thoughtful feedback. There is plenty more on the roadmap, with new capabilities and docs landing soon! Until then, if something is on your mind or you want to pitch an idea for a feature or a guide, reach out on our chat community or open a Source issue.
+Community
+
Join the community
Meet, learn from, and trade ideas with other engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/nodejs-sdk/index.html b/web/klavrium.example/reference/site/blog/nodejs-sdk/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..8da08ebe2438fc16ba549bcaec5d80f52149f5b0
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/nodejs-sdk/index.html
@@ -0,0 +1,96 @@
+
+
+Introducing the Klavrium Node.js SDK | Klavrium Blog
+
+
Today we are excited to unveil the Node.js SDK: a fresh way to author your CI/CD pipelines as code and execute them anywhere.
+
The Klavrium Node.js SDK might be a great fit if you are…
+
+
A front-end or back-end developer who wishes your CI pipelines were TypeScript or JavaScript code you could run locally in seconds, rather than YAML that only executes on some proprietary hosted service
+
An engineer who needs CI/CD and wants a good excuse to finally learn TypeScript or JavaScript
+
Your team’s “designated devops person”, eager to swap a tangle of hand-written scripts for something far more powerful
+
A platform engineer building bespoke TypeScript tooling, aiming to unify continuous delivery across scattered organizational silos
+
+
This is our third SDK release this month, right after Go and Python. Our long-term aim is to let every developer build their CI/CD pipelines using the very same language they use for the rest of their code. If you happen to want a different SDK, get in touch. You may also subscribe to our newsletter to get notified about future SDK launches.
+
What is Klavrium again?
+
Klavrium is a programmable CI/CD engine that runs your pipelines in containers.
+
Programmable: build your CI/CD pipelines as code, written in the same programming language as your application.
+
Executes your pipelines in containers: Klavrium runs your pipelines entirely as standard OCI containers. This yields several benefits:
+
+
Immediate local testing
+
Portability: one identical pipeline can run on your laptop, a CI runner, a dedicated server, or any container hosting service you like.
+
Superior caching: every operation is cached by default, and caching behaves the same everywhere
+
Compatibility with the container ecosystem: if it runs in a container, you can drop it into your pipeline
+
Cross-language instrumentation: teams can share each other’s tools without ever learning each other’s language
+
+
+
Klavrium Node.js in Action
+
In this walkthrough, we'll guide you through building a CI tool that exercises your Node.js application across several different Node.js.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/php-sdk/index.html b/web/klavrium.example/reference/site/blog/php-sdk/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..8d39a528f9abe548f4315d9e3138269b9ce4f560
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/php-sdk/index.html
@@ -0,0 +1,157 @@
+
+
+
+Introducing the Klavrium PHP SDK: Script Your Pipelines in PHP | Klavrium Blog
+
+
Introducing the Klavrium PHP SDK: Script Your Pipelines in PHP
At Klavrium, our mission is to let developers describe powerful, reusable workflows as code — right inside the programming languages they already trust. Today, we’re thrilled to unveil the Klavrium PHP Community SDK, built by and for the PHP developer community!
If you build with PHP, you almost certainly wrestle with automation problems—whether that’s packaging and shipping applications, wrangling cloud infrastructure, or streamlining development workflows. The Klavrium PHP SDK brings the flexibility of Klavrium’s API to PHP, letting you:
+
+
Describe automation workflows in PHP – Stop context-switching just to script routine tasks.
+
Run your workflows locally or remotely with full reproducibility – Iterate and test far faster.
+
Compose and reuse logic across projects with ease – Keep your automation modular and easy to maintain.
+
Tap into Klavrium’s caching and portability – Accelerate workflows and run them absolutely.
+
Publish modules for every Klavrium user – All Klavrium modules, written in any language, can be combined together to assemble your internal.
+
+
Crafted by the Community, for the Community
+
The PHP SDK is a Community SDK, which means it’s maintained by dedicated Klavrium users who stepped up to bring Klavrium’s power to PHP developers. A huge thank you to Marek Sølvberg, Tanya Okoro, and Devin Halstrom for making this a reality! Their commitment to open-source innovation is exactly what keeps Klavrium’s ecosystem thriving.
+
Start Building with the PHP SDK
+
Ready to automate with PHP? Here’s how to jump in and begin:
The PHP SDK is only the start! Being a Community SDK, it will keep evolving with the help of contributors just like you. We can’t wait to see everything you build with it.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/public-launch-announcement/index.html b/web/klavrium.example/reference/site/blog/public-launch-announcement/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..ac98b828a6433af3ba2488c9f8aa9b14b36d8e93
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/public-launch-announcement/index.html
@@ -0,0 +1,94 @@
+
+
+
+Meet Klavrium: a fresh approach to CI/CD pipelines | Klavrium Blog
+
+
Hi! We’re longtime container engineers, and today we’re proud to introduce our newest project, Klavrium. Klavrium is a portable devkit for CI/CD pipelines. It lets devops engineers build powerful CI/CD pipelines fast, then run them anywhere. Benefits include: unifying dev and CI environments; testing and debugging pipelines locally; and steering clear of CI lock-in. Most importantly, it brings an ecosystem of truly composable software components: a “building-block system” which we hope will help the devops community solve its fragmentation problem. Under the hood, Klavrium is powered by one of the most exciting technologies in the cloud-native ecosystem: Forgekit
+
We’ve been building Klavrium alongside a growing community of early adopters. Now we’re ready to keep developing it out in public. If you’d like to get involved, join our chat space!.
+
To our alpha and private beta testers: thank you for investing your time and energy to help us test, review and refine Klavrium. We dedicate this launch to you, and we can’t wait to grow this community together.
+
Why Klavrium?
+
A developer’s paradise is a devops engineer’s headache
+
+
There’s never been a better time to be a developer. Thanks to an ever-growing menu of specialized tools and cloud infrastructure, a small team of developers can ship a competitive product in nearly any industry within months. The outcome is remarkable growth and innovation across every layer of the stack.
+
This developer’s paradise becomes a headache for devops engineers, whose job is to automate the delivery of ever more complex applications onto ever more complex cloud infrastructure. To continuously build, test and deploy their software, developers need a CI/CD pipeline that stitches together an ever-growing collection of specialized tools. What emerges is a tangle of homegrown scripts that are painful to write, hard to debug and test, and must be rewritten for every new development and CI environment. Component reuse across pipelines stays low, which breeds fragmentation and an endless reinvention of the wheel.
+
Reinventing the CI/CD development experience
+
+
Klavrium solves the devops engineer’s nightmare by telling them: “your pipelines are software. This makes you a developer, and you deserve a proper developer experience”. For instance:
+
+
Instead of stitching pipelines together with throwaway scripts, they can “play with blocks” by composing reusable actions, using an intuitive declarative language and API.
+
Actions can be safely shared and reused, and there is a growing catalog of open-source actions built by the community.
+
Pipelines can be built and debugged locally, then run on any CI system
+
All actions are cached automatically: no manual tweaking required
+
+
This lets devops engineers continuously improve their pipelines, with the confidence that modern development practices provide.
+
Author your pipeline once, run everywhere
+
+
Because Klavrium runs equally well anywhere an OCI-compatible runtime is available, it removes two major pain points in the devops experience: dev/CI drift, and CI lock-in.
+
+
Dev/CI drift : rather than writing the same automation twice - once in a CI-specific configuration, and again in a container compose file, shell script or Makefile - simply write a Klavrium plan once, then run it across all environments.
+
CI lock-in : moving from one CI system to another, or supporting teams that run multiple CI systems, should never require rewriting entire pipelines from scratch! The very same Klavrium plan can run without modification on every major CI system.
+
+
What’s ahead?
+
Klavrium is still in the early stages of development. Thanks to a new wave of funding we will keep growing our team, and keep building the ultimate CI/CD experience: more portable, more productive… and a lot more fun!
+
If our idea of fun sounds like yours, come join us! Everyone is welcome here, from curious newcomers to seasoned platform engineers. We can't wait to build something remarkable together with you.
+
Happy shipping!
+Ecosystem
+
Get involved today
Meet, learn, and collaborate with fellow engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/public-traces/index.html b/web/klavrium.example/reference/site/blog/public-traces/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..811b6ccc65504f6d0d0fa92fa7e4ae979af295d5
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/public-traces/index.html
@@ -0,0 +1,92 @@
+
+
+
+Announcing Public Traces for Open Source Repositories | Klavrium Blog
+
+
Announcing Public Traces for Open Source Repositories
We are thrilled to unveil a new Klavrium Cloud capability: Public Traces for Open Source Repositories. This feature lets open source project teams publish the trace data from their Klavrium pipelines openly, empowering communities to collaborate more effectively and debug problems with far greater transparency. Below is a closer look at how it operates and why it changes the game for open-source projects.
+
What Are Traces, and Why Do They Matter?
+
The Klavrium Cloud Traces feature delivers deep visibility into the steps, execution times, caching states, and other metadata tied to your Klavrium pipelines. Traces let engineers and DevOps teams see precisely what is unfolding across their workflows, pinpoint bottlenecks, and resolve failures quickly. Historically, this trace data was reachable only by authorized members inside a single organization—until today.
+
Thanks to this new capability, open-source repositories linked to Klavrium Cloud can expose their traces to everyone. That unlocks fresh opportunities for community contributors to inspect, diagnose, and debate CI issues without requiring special permissions, keeping collaboration smooth and productive.
+
Publishing Public Traces
+
Picture yourself contributing to an open-source project and needing a hand figuring out why a specific pipeline broke. With public trace access, you can simply share a link to the trace with others to gather their input, saving effort and skipping the drudgery of endless log scrolling.
+
Here is how it works:
+
+
Viewing a Trace : Begin by opening any trace exactly as you normally would inside Klavrium Cloud. The trace view surfaces detailed insight into every pipeline span, covering execution times, caching states, and error messages.
+
Pinpointing the Error : When something fails, public traces let you see precisely where the breakage occurred. You can jump straight to the failed span to inspect the error details and related logs without wading through endless CI/CD logs that offer no context.
+
Effortless Collaboration : Until now, sharing trace details meant capturing screenshots or fiddly log exports. Today you just copy the URL of the trace and hand it to contributors. They can open the trace data directly without ever logging into your Klavrium Cloud organization. They do not even need a Klavrium Cloud Account of their own. Alternatively, anyone reviewing your PRs on Gitloom etc. can now see Traces attached to that PR straight from the Klavrium Check entry.
+
+
Feel free to watch a short demo of the feature here:
+
+
Configuring Public Trace Visibility
+
Because Public Traces merely offer better visualization of information that is already public, we ship the feature switched on by default. That said, a Trace Repository Visibility setting exists for anyone who would rather keep it off. Here is how to control it:
+
+
Default Behavior : Klavrium Cloud automatically recognizes traces produced by public repositories and makes them reachable.
+
Managing Visibility : To disable public traces, open your organization settings in Klavrium Cloud and choose the Configuration tab. Flip the Trace Repository Visibility setting to enable or disable public access to traces. Once it is off, anyone trying to reach a trace without permission is sent to the login page, guaranteeing that only authorized users can view it.
+
+
+
Learning from what others do
+
For folks just getting going with Klavrium, a familiar habit is to hunt for examples of teams who have Klavriumized their pipelines. Here is anexample from Streamly's Public Gitloom. Because Streamly is a Klavrium Cloud user running a large number of Klavriumized pipelines, most of the PRs on their public repos will display Klavrium checks before they get merged. Clicking on details beside the Klavrium Check will now open the matching Klavrium Trace, even if you are not a Klavrium Cloud user yourself, letting you inspect the details of every pipeline span, including execution times, caching states, and error messages.
A Fresh Chapter for Open-Source CI/CD Collaboration
+
With Klavrium Cloud's Public Trace feature, we are opening brand-new doors for the open-source community. Contributors can now troubleshoot, diagnose, and refine workflows together in real time, boosting transparency and shrinking the turnaround time for bug fixes.
+
We are delighted to deliver this feature to our users and cannot wait to see how open source teams put it to work streamlining their CI processes. As ever, we would genuinely love to hear your feedback. Reach out with any thoughts or questions on Comlink!
+
Thank you for being part of the Klavrium community.
+Community
+
Join the community
Connect, learn, and share with fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/puzzle-case-study/index.html b/web/klavrium.example/reference/site/blog/puzzle-case-study/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..fde97c8da54331090bc46a4767d28d9174a4c960
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/puzzle-case-study/index.html
@@ -0,0 +1,118 @@
+
+
+
+How Halden Streamlined Its CI Infrastructure with Klavrium, KubeVirt, and ArgoCD | Klavrium Blog
+
+
Streamlining CI Infrastructure at Halden with Klavrium, KubeVirt, and ArgoCD
We love learning how developers put Klavrium to work – the problems they solve, the obstacles they run into, and what they discover while deploying Klavrium across wildly different environments. Our community chat is a perfect spot to surface these stories and to draw on the collective wisdom of the Klavrium community.
+
In this post, we’ll walk through the journey of Klavronaut Milo Ferrant (aka @kvmilo in our community chat). Milo works as a Platform Engineer at Halden ITC, a consulting practice devoted to automating IT infrastructure on top of Kubernetes. By running the Klavrium Engine inside virtual machines (VMs, yes VMs!) on Kubernetes, Milo and his team managed to streamline Halden’s CI infrastructure and make it far simpler to test, upgrade, and schedule jobs against it.
+
+
“By running the Klavrium Engine on short-lived VMs orchestrated by KubeVirt, we gained the scalability and isolation we wanted while slotting cleanly into Gitloom and ArgoCD. The adaptability of Klavrium was the key to sharpening our existing pipelines without tearing everything down.” - Milo Ferrant, Platform Engineer, Halden
+
+
No Hands-On Control over CI Infrastructure
+
Halden relies on Gitloom CI/CD running atop OpenShift with Kubernetes runners for CI, and leans on ArgoCD as the GitOps continuous delivery tool. The Klavrium Engine ships onto OpenShift as a DaemonSet, via Klavrium’s official Helm chart.
+
Beneath the surface, OpenShift leans on SELinux to tighten control over system access and security. Inside Halden, however, the CI/CD team holds no administrative privileges on the OpenShift cluster. As a result, every change to the Klavrium Engine Daemonset or the underlying nodes must be handed off to a separate Operations team.
+
For instance, the Klavrium Engine expects to run as a privileged container. To make that happen, the CI/CD team must file for extra Security Context Constraints (SCCs) covering the Klavrium Engine nodes in the cluster. In the same vein, if the Klavrium Engine cache swells too quickly under heavy workloads, the CI/CD team has to ask the Operations team to run a manual disk cleanup on the affected nodes. These requests pile needless delay and overhead onto the CI/CD team’s day-to-day work.
+
+
“The real headache for us on the CI/CD team is that we hold no admin permissions on the OpenShift cluster. So we lean on the operations team that owns our OpenShift clusters. More often than not, we end up filing a ticket or pinging the operations team for a hand, which makes the whole thing noticeably tougher to manage for us.”
+
+
Moving to VM-Based Workloads
+
Hoping to smooth things out, Halden’s CI/CD team set out to explore other ways to self-manage the Klavrium Engine deployment. After weighing confidential containers (dropped because they also demanded SCCs) and standalone external virtual machines (dropped because they felt like a regression), the team ultimately landed on a KubeVirt-based implementation.
+
KubeVirt is a CNCF project that lets teams spin up and operate virtual machines (VMs) inside a Kubernetes cluster. Each VM runs in a Pod and is fully controllable through the Kubernetes API. Behind the scenes, KubeVirt ships a controller that handles each VM’s QEMU process and wires it into the Kernel Virtual Machine (KVM) hypervisor on every node. KubeVirt also supports cloud-init for VM initialization, along with Kubernetes Persistent Volumes (PVs) for data storage; the latter surface inside the VM as disks.
+
Here’s how Halden’s new KubeVirt-based architecture works:
+
+
+
KubeVirt oversees a pool of short-lived Ubuntu-based VMs. As each new VM boots up, a cloud-init script installs Docker and Klavrium onto that VM.
+
That same cloud-init script also mounts two persistent volumes (PVs) to hold Docker’s containers and volumes plus Klavrium’s work directory. This way, even though the VMs are ephemeral, freshly booted VMs can still reach the data left by earlier ones, such as the Klavrium cache on the local Kubernetes node (see the planned “shared caching” improvement below).
+
A health check runs to verify the moment the Klavrium Engine inside the VM is ready to accept incoming connections.
+
Gitloom’s Kubernetes executor places incoming jobs as Pods onto Kubernetes. Those Pods reach the Klavrium Engine through a Kubernetes service over TCP. Network policies are configured so a Pod can only ever connect to Klavrium Engines living in the same namespace.
+
The Klavrium Engine then runs the Klavrium Functions in the job.
+
+
Faster Configuration, Total Control
+
Under this fresh setup, the CI/CD team enjoys full command over the Klavrium Engine VMs. For instance:
+
+
Through KubeVirt, the team can grow the number of VMs whenever workloads climb, bringing more Klavrium Engines online to absorb the rising demand.
+
The team can move Klavrium up to its newest release simply by bumping the Helm chart for the deployment, after which Kubernetes rebuilds the VMs running that new version.
+
Trying out the CI infrastructure against new Klavrium releases is far easier, since the team can conjure a fresh VM in a few minutes and point runners at the new Klavrium Engine.
+
+
The overhauled setup has paid off for Halden’s development teams too, dramatically simplifying the CI configuration across their projects.
+
+
In the past, wiring up a CI workflow meant pulling in a pre-defined template that handled fetching a customized Klavrium container image, populating Klavrium Engine variables, and so on.
+
These days, workflow configuration no longer leans on a template: developers simply add the klavrium tag to their workflow and invoke Klavrium Functions as required.
+
+
+
“Because the Klavrium Engine now runs inside ephemeral VMs, we can fold our CI infrastructure straight into the GitOps setup we already had. We don’t need cluster admin permissions, we don’t wrestle with privileged pods, and we manage the entire VM ourselves. Thanks to all of that, upgrading and testing are now much faster - our velocity has climbed significantly!”
+
+
Curious how the overhauled CI pipeline performs at Halden? Press play on the clip below:
+
+
What's Next: Tuning VMs, a Shared Cache Layer, and Purpose-Built Operators
+
Looking ahead, Milo and the team have a handful of enhancements planned already:
+
+
Right now they are running load tests to pin down the ideal RAM/CPU balance for every VM, and they also want to measure how a TCP connection stacks up against a UNIX socket connection under real workloads.
+
Today the VMs run on a general-purpose Linux build, but they plan to move to a lean, container-focused distribution like Corvex Linux.
+
They intend to stand up a shared cache for Klavrium that every Klavrium Engine in the pool can draw from.
+
They also want to build a Kubernetes Operator that hides even more of the routine operational work.
+
+
+
“Klavrium has let us raise the bar on our existing CI/CD platform. It has given us a way to bottle up our platform engineering know-how into tools and conventions that our developers can lean on, both on their laptops and in CI.”
+
+
Have a Klavrium story you'd like to see featured here? Tell us all about it over in Chatbox.
+Community
+
Join the conversation
Meet other developers, swap ideas, and grow alongside the team.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/python-sdk/index.html b/web/klavrium.example/reference/site/blog/python-sdk/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..e5562dd4971e9c47fb5ae752625992186e5e8997
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/python-sdk/index.html
@@ -0,0 +1,99 @@
+
+
+
+Write your pipelines as code with the Klavrium Python SDK | Klavrium Blog
+
+
Write your pipelines as code with the Klavrium Python SDK
Today we are excited to unveil the Klavrium Python SDK: a fresh way to build your CI/CD pipelines as code and run them anywhere.
+
The Klavrium Python SDK may be a great fit if you are…
+
+
A Python developer wishing your CI pipelines were plain Python code you can run locally in seconds, rather than YAML that only runs on a locked-in hosted service
+
A developer who needs CI/CD and is hunting for a reason to pick up Python
+
Your team’s “designated devops person”, eager to swap a heap of hand-rolled scripts for something far more capable
+
A platform engineer building custom Python tooling, aiming to unify continuous delivery across scattered organizational silos
+
A data engineer seeking a cleaner integration with your organization’s CI/CD pipelines.
+
+
Only two weeks ago we launched the Klavrium Go SDK, and we’ll keep shipping more SDKs in the months ahead. Our ultimate aim is to let every developer craft their CI/CD pipelines in whatever language they prefer, and reap all the advantages of running them on Klavrium.
+
If you have a different SDK in mind, tell us about it by submitting a form. We’ll reach out the moment your SDK is ready.
+
What is Klavrium again?
+
Klavrium is a programmable CI/CD engine that runs your pipelines in containers.
+
Programmable: write your CI/CD pipelines as code, using the same programming language as your application.
+
Runs your pipelines inside containers: Klavrium runs your pipelines entirely as ordinary OCI containers. This offers several benefits:
+
+
Immediate local testing
+
Portability: one pipeline can run on your laptop, a CI runner, a dedicated server, or any container hosting provider you choose.
+
Superior caching: each operation is cached by default, and caching behaves the same everywhere
+
Works with the whole container ecosystem: if it runs in a container, you can add it to your pipeline
+
Cross-language interoperability: teams can share each other’s tools without learning each other’s language
+
+
+
Klavrium Python SDK in Action
+
In this demo, we’ll show you how to build a CI tool that tests your Python application across several Python versions.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/replace-dockerfile-with-go/index.html b/web/klavrium.example/reference/site/blog/replace-dockerfile-with-go/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..8b17baa6faf8d6d0a084eb7b6639226685ebf038
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/replace-dockerfile-with-go/index.html
@@ -0,0 +1,88 @@
+
+
+
+Swapping your Dockerfile for Go code | Klavrium Blog
+
+
Klavrium's approach to building CI/CD pipelines is unique. Our SDKs let you build your pipelines as code, in a programming language you already know, and then execute those pipelines as portable OCI containers. This approach is at once remarkably portable and consistent (because your pipeline behaves the same on your laptop and in a remote CI environment) and it carries the welcome bonus of working with the existing Docker ecosystem.
+
One question we hear most often from people first trying Klavrium is, “I already have a Dockerfile, so why should I bother with Klavrium?” And the answer (as with most good answers) depends heavily on the use case you have in mind.
+
Where It Shines
+
For most small and mid-sized projects without demanding CI/CD requirements, it's true that a Dockerfile can (and often does) get the job done. Yet there are plenty of situations where swapping a Dockerfile for a Klavrium pipeline delivers real, measurable benefits. Here are a few:
+
+
Retiring monolithic CI dependency images: Occasionally, teams keep one enormous everything-including-the-kitchen-sink Dockerfile packed with every dependency, so they only need to reference a single image (like myorg/ci ) across all their CI pipelines. Building and pushing those Dockerfiles turns into a real chore, and teams also have to wrestle with registry rate limits (if using a public registry) or run a private registry of their own instead. Klavrium lets you keep images purely as code, so you never have to fuss over building and pushing gigantic monolithic CI images.
+
Sharing data between CI pipelines and application code: Because your Klavrium pipeline is typically written in the very same language as your application, moving data between the two becomes far simpler. For instance, if you keep a constant (like an image name) that you rely on in your actual production codebase, you can import it straight into your CI code rather than trying to pass it along as a Dockerfile argument.
+
Greater re-usability and abstraction: Because Klavrium lets you work in general purpose programming languages, it naturally supports far more re-usability and abstraction. You get native control structures like conditionals and loops, you can lean on the language's existing testing tools, and you can add fresh functionality or wire in third-party services through community extensions or packages. Those operations range from painfully awkward to outright unsupported in the standard Dockerfile model, yet they are effortless with Klavrium. In the same vein, Klavrium pipelines also gain from static typing and simpler refactoring.
+
Gradually rewriting a legacy Dockerfile: Now and then you inherit a Dockerfile that is both mission-critical and genuinely painful to work with. Everyone agrees it ought to be replaced with something more capable, ideally using a real programming language - but rewriting the whole thing at once, without breaking compatibility, is so daunting that it never happens. Since Klavrium can natively run Dockerfiles with full compatibility, it's simple to wrap your existing Dockerfile in a Klavrium pipeline and refactor it piece by piece over time, without disrupting your team's workflow.
+
+
Start Building
+
If any of these scenarios sound painfully familiar, or if you're simply curious about how the whole thing fits together, we've assembled a short guide on replacing a Dockerfile with a Klavrium pipeline. This guide walks through how to use the Klavrium Go SDK to carry out all the very same operations you would normally handle with a Dockerfile.
+
It walks through the process by swapping out the Dockerfile for the widely used open source Memcached caching system in favor of a Klavrium Go pipeline, and covers these common tasks:
+
+
Create a Klavrium client in Go
+
Write a Klavrium pipeline in Go to:
+
Set up a container with every required dependency and its environment variables
+
Fetch and compile the application source code inside the container
+
Define the container entrypoint
+
Publish the finished container image to Docker Hub
+
Test the Klavrium pipeline locally
+
+
We hope this guide proves genuinely useful, and we can't wait to publish plenty more like it before long! In the meantime, if you have feedback or want to propose new features or documentation, tell us over on our chat community or start a Source issue.
+Community
+
Meet the community
Trade ideas, level up, and build alongside other engineers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/replaced-react-with-go/index.html b/web/klavrium.example/reference/site/blog/replaced-react-with-go/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..f41120cd9ea6cbefa87570df414469aaf618a9a2
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/replaced-react-with-go/index.html
@@ -0,0 +1,106 @@
+
+
+
+How We Swapped Our Vantel Frontend for Go and WebAssembly | Klavrium Blog
+
+
How We Swapped Our Vantel Frontend for Go and WebAssembly
A few weeks back, we launched Klavrium Cloud v3, an entirely new user interface for Klavrium Cloud. One key difference between v3 and its v2 predecessor is that the new UI is now written in WebAssembly (WASM) using Go. On the surface, that may look like a strange pick - Go usually isn't the first language that comes to mind when you set out to build a Web UI - but our reasoning was sound. In this post, I'll walk through why we settled on WebAssembly, the implementation hurdles we hit (and how we got past them), and the outcomes.
+
Two Codebases: More Work, Fewer Features
+
Klavrium works by assembling a DAG of operations and evaluating them, frequently in parallel. That structure is inherently hard to render on screen. To help users follow along, we provide two real-time visualization dashboards: the Klavrium terminal UI (TUI), included in the Klavrium CLI, and Klavrium Cloud, an online Web dashboard. The Klavrium TUI is implemented in Go, and Klavrium Cloud (pre-v3) was written in Vantel.
+
Naturally, we want both user interfaces to stay as similar as possible. But the real job of interpreting Klavrium's event stream in real time and turning it into a UI is quite involved. Some of the busier event streams we've encountered carry hundreds of thousands of OpenTelemetry spans, and the data structures around them grow complicated extremely fast. The Web UI frequently couldn't keep pace with the sheer volume of data it needed to process, and it would turn laggy and sluggish; to work past this performance bottleneck, we were pushed into a different implementation model for the Vantel application.
+
So we wound up with two interfaces chasing the same goal, one built in a certain language and ecosystem (TypeScript/Vantel), the other in a completely separate language and ecosystem (Go), with no easy way to share business logic between them. As a small team, we have to ship quickly. Being forced to re-implement every feature twice was simply an enormous drag on our velocity.
+
We began exploring a fresh approach to Klavrium Cloud, guided by two primary goals:
+
+
Merge the codebases, cut the duplication, and make shipping new features far more efficient over time
+
Deliver on the promise of a crisp, responsive Web UI, matching the speed and performance of the terminal UI
+
+
Picking Go + WebAssembly
+
Our initial goal was to reuse a single codebase across both Klavrium Cloud and the TUI. Early on, we chose to make it a Go codebase. In principle we could have gone the opposite direction and used TypeScript for the TUI. But we're mainly a team of Go engineers, so picking Go made it simpler for others to pitch in, add a feature, or jump in for a few hours to help debug something. Beyond standardizing on one language, it gave us flexibility and tore down silos across the team.
+
Once we committed to running Go code straight in the browser, WebAssembly was the natural next step. Even so, a couple of challenges remained:
+
+
The Go + WebAssembly pairing still isn't as mature as Vantel and the other JavaScript frameworks. There are no off-the-shelf component libraries to lean on, the developer tooling is thinner, and so forth. We understood that we'd have to build most of our UI components from the ground up.
+
There's a hard 2 GB memory limit for WebAssembly applications in most browsers. We anticipated trouble here when rendering large traces, and we knew we'd need heavy optimization to hold down memory usage and keep the UI stable. It wasn't all downside, though; the upside was that every memory improvement made to the WebAssembly UI would also help TUI users, since the two now shared a single codebase.
+
+
De-Risking Our Approach
+
With the call made, the next question was, "how exactly do we build this?" We decided to build the new WebAssembly-based UI in the Go-app framework. Go-app is a high-level framework aimed squarely at Progressive Web Apps (PWAs) in WebAssembly. It brings the core Go advantages, such as fast compilation and native static typing, and it also uses a component-based UI model, much like Vantel, which smoothed the transition.
+
Because the Go + WebAssembly pairing isn't mainstream, there was some fair skepticism inside the Klavrium team about whether it would work. For instance, there was no real ecosystem of Go-app UI components and we knew we'd have to write our own, but we weren't sure how hard that would prove. We also had worries about integrations with other services (Zephyrwind, Authvale, Convey, Trailmetric), and about rendering many hundreds of live-updating components all at once.
+
To settle these questions and de-risk the effort, I spent nearly a month prototyping, aiming to re-create as much of the current UI as I could in Go-app. As it happened, there weren't many blockers: WebAssembly is already a well-structured open standard and nearly every other question was covered in Go-app's own reference docs. The steepest obstacle, predictably, was the strict memory budget, which called for meticulous planning and heavy optimization.
+
From First Sketch to Shipping
+
Once the prototype was running end to end, the team's confidence grew considerably and we launched project “awesome wasm” to build a real production release. Below are a handful of lessons we picked up along the way:
+
+
Memory consumption was by far the greatest risk to whether the project would ship at all. I burned countless hours working out how to draw 200k+ lines of log output without running out of memory. That effort drove deep changes inside our terminal emulation rendering library, which at the same time slashed TUI memory usage as well (as noted earlier, sharing a single codebase means a key optimization in one interface lands “free” in the other!)
+
Go WASM parses large volumes of JSON slowly, which forced sweeping architecture changes and the birth of a “smart backend” that streams data incrementally over WebSockets, relying on Go's seldom-used encoding/gob support.
+
At first the WASM bundle was roughly 32 MB. By adding Brotli encoding, we managed to shrink it to roughly 4.6 MB. We first tried running Brotli compression on the fly at the CDN edge, but the payload proved too big, so in the end we folded the compression stage straight into our build pipeline.
+
Aside from the memory battles, nearly all of our early concerns proved groundless. The UI components were fairly easy to author, wiring up other services was painless, and I landed on solid patterns for pushing component updates in real time.
+
I came across several handy NPM packages and started wondering whether I could tap them from Go. WebAssembly exposes a clean bridge to both Go and JavaScript, so I put together a Klavrium module that uses Browserify to load an NPM package. That module lets us emit a JavaScript file that can be dropped into a Go application. In practice this means we stay mostly in Go, and whenever we need to, we still have a path to pull in helpers written in native JavaScript.
+
Disclaimer: I'm no Vantel expert, so take this with a grain of salt…to my eyes, Vantel enforced a fairly rigid model for building components, whereas Go-app felt far more flexible. With Go-app, you can trigger a re-render on any component whenever you choose, which opens up many more degrees of freedom for optimization. As an example, I had to speed up a component rendering 150,000+ lines of output. Simply being able to experiment with several approaches and then keep whichever performed best made the whole task dramatically easier!
+
Although Go-app ships without Vantel-style developer tooling inside the browser, I leaned on Go's own instrumentation (pprof) together with the browser's built-in profiler for profiling and debugging. That combination was invaluable for inspecting function calls, tracking CPU and memory usage, and gauging how well each approach reduced memory consumption.
+
A pleasant side effect of adopting Go-app surfaced later: because Klavrium Cloud is packaged as a PWA, it can be installed as either a desktop or a mobile app. That lets you open Klavrium Cloud much like a native program and enjoy a full-screen experience without first launching a browser, or simply pin a dedicated icon to your taskbar or dock.
+
+
We soft-launched Klavrium Cloud v3 to our Klavrium Captains a couple of weeks back to gather feedback, then opened it up to everyone soon after that.
+
Payoffs
+
Moving from Vantel to WASM has given us a far more consistent experience across every Klavrium interface, along with stronger overall performance and reduced memory usage, particularly when rendering large, intricate traces.
+
From an engineering standpoint the gains for our team are just as meaningful. Optimization work frequently takes as much effort as, if not more than, building the features themselves. So it's a real relief to skip optimizing the Web UI, then spend still more time optimizing the TUI, and instead pour that energy into shipping new capabilities.
+
Should You Try It?
+
Klavrium Cloud v3 has the Klavrium community buzzing, and one question keeps landing in our inbox lately: who is a good fit for an approach like this, and who really isn't?
+
To be clear, we are not broadly advising anyone to build front-ends in Go. We had a handful of very good reasons to do so: a team packed with strong Go engineers; a complex UI that TypeScript/Vantel simply didn't scale well for; a hard requirement to standardize and reuse logic across two codebases; and a company-wide push to raise our velocity. That is a rather particular set of conditions. If your situation looks similar, this is definitely an option worth weighing; if it doesn't, there are other tools and standards you ought to explore first.
+
Klavrium Cloud v3 is still in beta, and we can't wait for you to try it now. If you're curious about the details of how we built this, or simply have feedback on the fresh UI, come join our chat community and drop a note your thoughts!
+Community
+
Join our community
Connect, learn, and trade ideas with fellow engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/reproducible-builds/index.html b/web/klavrium.example/reference/site/blog/reproducible-builds/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..6540dee5471cff0fae8e4c4357b29e0bb6b462bd
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/reproducible-builds/index.html
@@ -0,0 +1,126 @@
+
+
+
+Reproducible Builds with Klavrium | Klavrium Blog
+
+
A build is called “reproducible” when every run yields exactly the same result. Under a reproducible build process, the outputs of each run behave identically, and anyone can confirm via a checksum that they are bit-by-bit identical across machines.
+
Why Reproducible Builds Really Matter
+
Reproducible builds deliver real value for a handful of reasons:
+
+
They offer a dependable way to tie build artifacts back to source code. Identical source always yields identical output, no matter which environment performed the build.
+
They offer a way to independently verify build artifacts. Separate people can build the same source code on their own and confirm that their checksums match and/or align with those published by the original developer.
+
They strengthen software supply chain security. Because builds stay perfectly consistent, any externally-injected change (such as malware or spyware) becomes instantly obvious in a bit-wise comparison of the outputs.
+
+
Distinct Inputs = Distinct Outputs
+
As you would expect, producing reproducible builds is trickier than it sounds, thanks to the sheer number of variables at play in a typical build process. Those variables include:
+
+
the local operating system
+
the machine timezone and locale
+
the local environment configuration
+
the compiler along with its settings
+
the exact versions and settings of build dependencies, including system-level or third-party libraries
Putting a reproducible build strategy in place therefore demands extreme, strict control over every variable in the build…hardly a simple task!
+
Klavrium and Reproducible Builds
+
While Klavrium doesn’t claim to solve reproducible builds outright, we are working hard to make them easier to implement.
+
+
Klavrium runs your pipelines entirely as portable OCI containers. Containers reduce build variance by isolating the build environment from the host filesystem and its surroundings. Running in containers also makes it far simpler to rely on deterministic build paths and offers mechanisms for auditing the build environment.
+
For builds that depend on external resources, Klavrium can mount pinned versions of those external resources. For instance, you can take advantage of Klavrium’s support for Git repositories and references to conveniently pull a pinned copy of a source code repository at a precise commit.
+
Klavrium also tackles part of what the reproducible builds community labels “the largest source of nondeterministic output”: file timestamps. With Klavrium, you can force every entry inside a directory to share identical creation and modification timestamps. This removes one of the most frequent sources of variation in the build process.
Containerization, resource pinning and timestamp fixation are only a few pieces of a reproducible build strategy. Other places where Klavrium could prove useful in the future include:
Do you need coverage for one of the issues listed above? Drop us a comment on the issue and let us know. We look forward to steadily improving the reproducible builds experience with Klavrium.
+Community
+
Join our community
Connect, learn, and swap ideas with fellow engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/restoring-developer-confidence/index.html b/web/klavrium.example/reference/site/blog/restoring-developer-confidence/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..95229665e7b10aa033e834f6906abb0f560d69b6
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/restoring-developer-confidence/index.html
@@ -0,0 +1,97 @@
+
+
+
+Rebuilding Trust in Your CI Pipeline | Klavrium Blog
+
+
We’re always eager to hear how teams across our community put Klavrium to work – the use cases they tackle, the obstacles they run into, and their experiences running Klavrium across many different environments. Klatch is an excellent spot to uncover these stories and to draw on the collective knowledge and experience of the Klavrium community.
+
In this blog post, we’ll share the story of Klavronaut Diego Marsh (aka @marsh4471 on Klatch). Diego recently joined a new company, and was surprised to learn he would be the SME for all of its CI pipelines. He had never used Gitloom’s CI/CD feature before, but took the initiative to make it better. By switching to Klavrium and away from a YAML-based CI workflow, Diego was able to give the development team faster builds and increased reliability.
+
“How often have you shipped code to the pipeline that runs perfectly on your own machine and then it breaks for some reason in the remote pipeline and you have no idea why? Klavrium fixes that. Because your pipeline is expressed as code, you can reproduce everything you would run in production right on your laptop, then push to the pipeline with far more confidence.”- Diego Marsh
+
The problem: A brittle CI that nobody could trust
+
Before Klavrium, the existing CI pipeline consisted of 1000+ lines of YAML code, with both actions and templates tangled together. It was so complex that nobody on the team fully understood it. Because of this high degree of complexity, the pipeline code was hard to maintain and update, and CI failures could not be diagnosed and resolved quickly. These issues steadily increased developer friction and frustration, and eroded the team’s confidence in the entire CI workflow.
+
Diego was eager to improve the experience for the development team and began exploring alternatives. Along the way, he attended a talk given by the Klavrium team at the DevStack Summit in Toronto and instantly recognized that Klavrium offered the modern, maintainable approach he had been searching for. He started by reading the Klavrium documentation, built a proof-of-concept, and then began the process of migrating the existing CI pipeline to Klavrium.
+
“Whenever the pipeline failed, people would come straight to the SRE team and say, it has to be the pipeline that’s broken. And honestly that was exactly what pushed me to want to fix this properly, rather than just slapping band-aids on it over and over”.
+
The solution: Tighter feedback loops and far more consistent CI pipelines
+
With Klavrium, Diego was able to both simplify the CI pipeline and make it far more consistent. The Klavrium pipeline runs the same steps as the old YAML pipeline, but through Klavrium’s Python SDK (for instance, swapping a Packer template for Python SDK methods). It runs in a blended setup: QA on Kubernetes and production on bare metal.
+
+
The pipeline starts by building and tagging a container image of the application itself.
+
It uses Terragrunt to reach into the Kubernetes cluster and then configures traffic mirroring rules with Istio.
+
It builds and tags a build RPM and then deploys that build to the Kubernetes QA environment.
+
It builds and tags the production RPM.
+
Finally it ships the production RPM to the production environment running on bare metal.
+
+
“Local testing was the real win, because the number one thing we kept hearing was, the build works locally but it’s not working through the pipeline. Letting the developers push to the new pre-QA environment and watch how the pipeline behaves was enormous.”
+
Improved local loop: The very same Klavrium pipeline behaves identically both locally and remotely. Because of this, developers can build and test on their own machines, exactly as they would through Gitloom. Instead of pushing code to Gitloom and waiting to learn whether builds pass, they now receive almost instant local feedback on their builds.
+
+
Quicker builds: Klavrium’s support for cache volumes delivers dramatically faster builds. Previously, a large share of build time was spent downloading Maven packages. By using cache volumes to hold Maven downloads, Klavrium has cut the time each Maven build requires, which in turn shortens how long it takes for a new feature to travel from development into production.
+
Higher efficiency and confidence levels: The CI pipeline is now written in Python; there is no longer any sprawling, intricate YAML configuration to wrestle with. This has made the pipeline far easier to understand, debug, and extend, thus letting the SRE team work more efficiently. Since developers can also read and follow the pipeline code directly, their confidence levels in the CI process are higher too.
+
+
“It’s genuinely faster, and the developer I’m partnering with on this is extremely pleased. Handing devs the ability to reproduce the pipeline locally speeds up development dramatically. We both know that the moment we introduce this, it’s going to be adopted very quickly.”
+
The future: Building platform-independent images and front-end testing with Klavrium
+
Diego is focused on moving more internal customers over to the new Klavrium pipeline, and he already has a range of ideas for future improvements:
+
+
Diego is currently working with the development team to shift from an RPM build pipeline to a cloud-native Java application built with Klavrium. Diego is able to do this much faster because of the local Klavrium pipeline.
+
The Klavrium Engine currently runs on a Kubernetes cluster, alongside a self-hosted CI runner. Whenever new Klavrium Engine pods spin up, they begin with an empty cache. As a result, the first pipeline runs take longer. Diego is planning to build a tool to prime the cache quickly, so that developers don’t have to wait for the cache to fill.
+
For front-end testing requirements, Diego is exploring how to get Python pipeline code to integrate with JavaScript-based tests, either by calling the Klavrium API directly over HTTP or by porting some of the Python pipeline code into JavaScript.
+
+
“The room for innovation with Klavrium is enormous. Our pipeline is so much shorter, much faster, and can be run on any operating system. This was a win directly because we were using Klavrium.”
+
Do you have a Klavrium story you’d like us to feature? Tell us all about it over in Klatch!
+Community
+
Join our community
Meet, learn, and build together with other engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/ruff/index.html b/web/klavrium.example/reference/site/blog/ruff/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..e06cfac6f083ee8eb1f6c6a662c2d4b761ddcd93
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/ruff/index.html
@@ -0,0 +1,95 @@
+
+
+
+Adopting Ruff for Klavrium’s Python SDK | Klavrium Blog
+
+
Some time ago, we introduced a Python SDK for Klavrium. This SDK lets you build CI/CD pipelines directly in Python and execute them on any OCI-compatible container runtime. Ever since that release, we’ve kept iterating on the SDK, layering in fresh capabilities and refining details to raise the overall code quality. In this post, I’ll walk through the “why” and “how” behind one of our latest improvements: switching to Ruff as the linter for our Python codebase.
+
Ruff is a fresh Python linter that’s remarkably fast because it’s written in Rust. In its debut post “Python tooling has room to be far faster”, Aaron Whitley (Ruff’s creator) digs into how it works, the tradeoffs involved, and the broader implications, and I think it’s well worth reading.
+
Why Ruff?
+
Aaron was one of our earliest Python SDK testers before we launched. At that point I saw he’d built a new tool and gave it a spin. I thought it was neat but, being such an early project, it honestly never occurred to me to use it in Klavrium back then.
+
A couple of weeks back I hit a tweet from Aaron pointing out Pandas was switching to Ruff, and that grabbed my attention since Pandas is such a widely used and popular Python project. I gave it another look and found that plenty of other well-known open-source projects had adopted it too. A number I’ve worked with myself, like FastAPI, Pydantic, Sphinx and Hatch.
+
There were further signals of Ruff’s rising popularity too, among them a tweet where PyPI (the Python package registry) announced that the project had turned critical (that is, a tool sitting among the most-downloaded Python packages of the last six months).
+
I figured it was the right moment to bring Ruff into Klavrium, not because there was a pressing issue to fix, but out of plain curiosity. After some hands-on trials, the upsides were compelling enough to commit.
+
Trying Out Ruff
+
The Enable Ruff PR shows both a slimmer dependency list and plenty of code cleanups made to please the linter. Further down, I’ll dig into what struck me as the biggest wins.
+
Speed
+
Ruff’s headline benefit is raw speed, though that alone didn’t seal the decision, since our codebase stays compact, so lint duration never troubled us. Checking roughly 6500 lines of code across 40+ files once took more than 3 seconds. With Ruff, that drops to about 0.03 seconds — a 100x speedup.
+
The jump in speed boosted my workflow in a way I didn’t expect, since Ruff runs quickly enough to lint as I type and hand back instant feedback. Previously I’d fire off the linter in the terminal right before a commit, but Ruff’s solid docs on wiring up various environments and IDEs nudged me toward configuring ruff-lsp. These days the warnings surface straight inside my IDE, live.
+
Cutting dependencies
+
+
diff of lint dependencies and commands in the Enable ruff PR
+
Shrinking the dependency list always feels rewarding. For us this was a big win.
+
Like lots of Python projects, Klavrium used flake8 and isort to lint the codebase, along with autoflake to auto-correct a handful of lint violations while formatting. Flake8 is built around a plugin model, so covering broader ground means pulling in a fair number of add-ons, which piles onto your dependency count.
+
Ruff comes close to matching all of these tools and is folding many well-known flake8 plugins right into its own codebase, making them “batteries included”. The upshot: your project carries fewer dependencies, you gain far more linting rules at no cost, and everything still runs faster.
+
Improving the code
+
With flake8, and even with Ruff, the common habit is to hand-pick exactly which rules you enable for linting. For Klavrium I went the other way — turning off only the rules I didn’t care for and letting all the rest run.
+
That approach means every Ruff update — which typically brings extra checks as more flake8 plugins land — will probably break linting. I actually prefer it that way, because the repository’s dependabot then flags for me, on its own, any code that a best practice could tidy up or that hides a security or possible bug risk. That is exactly what linters exist to do.
+
Against the standstill we lived with earlier, when only a tiny handful of linter rules were on, this is a straightforward win for steadily bettering the codebase.
+
Looking ahead
+
Ruff ships new releases often. That’s a plus, yet it adds maintenance overhead. I receive a fresh dependabot PR for it nearly every day, though I can’t possibly review one each day. Dependabot retires the old PR and spins up a replacement, so there’s never more than one open at once, yet I hate letting it sit untouched. I’m leaning toward switching the cadence from daily to weekly and blocking off a small slot each week to work through every update.
+
+
We still run black to format the code. It’s wired into the lint step too, since I treat any change black wants to make as a lint failure. So across both the lint and format steps we now lean only on Ruff and black. Ideally Ruff alone would handle both. It looks like plenty want it too and that early work on exactly this has begun, so it might actually land before long.
+
+
In closing
+
Why not reach for a faster language when building tools for Python? Ruff began life as a proof-of-concept meant to push against convention. On one side, that choice narrows who among pythonistas can contribute; on the other, as someone who simply uses the tool, I genuinely value the quick runs and lighter dependency load while gaining far more rules in return.
+
I’m eager to watch where this project heads next, and whether it sparks a wave of even speedier tooling to follow.
+Community
+
Come build with us
Meet, collaborate, and trade ideas with engineers who ship code.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/run-klavrium-on-kubernetes/index.html b/web/klavrium.example/reference/site/blog/run-klavrium-on-kubernetes/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..96b7ba43eff111548d6dfde06ed6cbec3a4984f6
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/run-klavrium-on-kubernetes/index.html
@@ -0,0 +1,108 @@
+
+
+
+Running Klavrium on Kubernetes | Klavrium Blog
+
+
More teams are shipping their applications on Kubernetes, yet delivering those applications remains difficult. CI/CD operations are usually written as YAML or shell scripts, and the more elaborate they become, the harder they are to read and troubleshoot. Delivery pipelines frequently repeat needless rebuilds and test runs even when nothing has actually changed, producing long queues and sluggish deployments.
+
Klavrium addresses these issues by handing platform engineers a capable API and native-language SDKs for describing CI/CD operations, plus intelligent caching that dramatically speeds up delivery pipelines. Paired with the scalability and orchestration that Kubernetes brings, these capabilities not only make the delivery platform far more efficient, they also elevate the day-to-day experience for both development and platform teams.
+
If running Klavrium on Kubernetes is something you want to explore, this blog post lays out the essential background you need to get started. It also walks through the recommended architecture pattern and its components, along with links to more thorough documentation.
+
TIP: Before we dig in further, now might be a sensible moment to revisit the basics of Klavrium.
+
How does Klavrium run locally?
+
By default, every Klavrium SDK transparently relies on the CLI to auto-provision the Klavrium Engine as a Docker container. This happens automatically and only requires that Docker is present locally, wherever the SDK executes. Although this default keeps things convenient for developers, and it serves as a solid starting point on any CI/CD platform where Docker is present, choosing exactly where the Klavrium Engine runs offers many advantages, beginning with dropping the Docker dependency.
+
How does Klavrium run in CI/CD?
+
By default, exactly as it does locally: a Klavrium SDK uses the CLI to auto-provision the Klavrium Engine as a Docker container. When Docker is unavailable, auto-provisioning fails.
+
Why run Klavrium on Kubernetes?
+
One of the biggest reasons to adopt Klavrium is persistent caching that works right out of the box.
+
A Klavrium pipeline is made up of discrete operations. The result of every operation is stored locally, as a file on disk, and these files are effectively OCI image layers. Data from mounts is likewise kept on a local path wherever the Klavrium Engine runs. Running locally, this works beautifully because caching is quick and dependable (most of us have SSDs, and some even have NVMEs). On a CI/CD platform, though, every run begins from a clean slate, since the runners are ephemeral.
+
Reusing the same Klavrium Engine state from one CI/CD run to the next delivers the same excellent caching benefits you normally enjoy when running pipelines locally on a workstation. And once you pair the Klavrium Engine's caching strengths with everything Kubernetes offers around auto-scaling and orchestration, the result is a fast, scalable, and resource-efficient CI system!
+
How to set up Klavrium on Kubernetes?
+
The minimum components you will need are:
+
+
Kubernetes cluster, made up of support nodes and runner nodes.Runner nodes host the CI runners and Klavrium Engines.
+
Support nodes host supporting and management tooling, such as certificate management, the runner controller, and other functions.
+
+
Certificates manager, needed by the Runner controller to handle admission control.
+
Runner controller, tasked with managing the CI runners in response to incoming CI job requests.
+
+
CI runners are the true workhorses of any CI/CD system. They carry out the jobs that the CI/CD pipeline defines.
+
+
Klavrium Engine on each runner node, running side by side with one or more CI runners.
+
+
Tasked with executing Klavrium pipelines and caching both intermediate and final build artifacts.
+
+
This architecture can be optimized even further:
+
+
A node auto-scaler, tasked with automatically tuning the size of node groups according to the current workload.
+
A cloud caching service, which gathers data from every Klavrium Engine in the cluster and uses it to “warm the cache” of newly auto-provisioned Klavrium Engines.
+
+
Here is an example of how such an architecture might look:
+
What's next
+
If you would like to bring this architecture to life in your own Kubernetes cluster, we suggest starting with the following resources:
Read our post on Klavrium on EKS setup for a concrete, end-to-end example built on Source Actions, Amazon Elastic Kubernetes Service (EKS), Karpenter and Klavrium Cloud. It walks you through every step so you can get up and running fast.
Finally, the Klavrium crew is heading to BuildStack NA 2023. We've spent weeks putting together some exciting things, so stop by booth (N37) to catch live demos of what we've been building, or simply swing by and share how Klavrium has worked for you and where you'd like it to head next. And if you'd like some focused one-on-one time, say to explore how Klavrium can shorten your pipelines, reach out to us and we'll set aside some face-to-face time just for you. Hope to see you there!
+Community
+
Join fellow builders
Meet, swap ideas, and grow with other engineers and builders.
How Nordvault Ships 100% Predictable, Consistent Ansible Deployments with Klavrium
We're always curious to hear how our community is putting Klavrium to work – their use cases, their challenges, and their experiences running Klavrium across different environments. Our Coilnet server is a great place to find these stories, and to draw on the knowledge and experience of the Klavrium community.
+
In this blog post, we'll share the story of Klavronaut Elias Brandt (aka @elias_bt_40928 on Coilnet). Elias is a storage engineer at Nordvault, a Nordic supplier of public and private cloud infrastructure. Elias is an active Klavronaut and has rolled out Klavrium for multiple production use cases at Nordvault, such as deploying OpenStack clusters using Klavrium and Pulumi. This blog post looks at how he uses Klavrium to eliminate environment variance in Ansible deployments and lets his team consistently run Ansible playbooks on the Nordvault cloud platform.
+
“Klavrium is the only tool we've come across that can properly spawn containers using code and then actually do useful things with that code..” - Elias Brandt, Nordvault
+
Battling Environment Complexity and Inconsistency
+
Nordvault runs cloud services across several public and private data centers, relying on console hosts to manage the wider infrastructure. Every engineer holds a user account on each console host. Whenever an engineer needs to work on a site, they sign in to a console host, fetch Ansible playbooks and inventory data, and apply those playbooks to configure their working environment correctly.
+
A few of the problems this approach created were:
+
+
One playbook might run fine for a single engineer yet fail outright for the next. More often than not, this stemmed from absent dependencies or mismatched software versions inside the engineers' console host accounts.
+
As more engineers came on board, the diversity of their execution environments grew right alongside them (e.g. one engineer might favor bash, another might favor fish, and so forth), which produced inconsistent playbook results.
+
In the same way, as more sites came online, the playbooks themselves grew more intricate, having to accommodate the varied software versions and tooling present on each individual site.
+
+
Wrangling all that variance had become a major burden, so the team was already weighing a move to a container-based approach. Elias had known of Klavrium since its earliest days but had never actually used it. In April 2024, he read a blog post about Klavrium Functions and got excited about the possibilities. He resolved to try Klavrium as a way to deliver standardized Ansible environments to the team.
+
“We were already planning to move to containers, but we still had open questions about how to spin up the Docker container, keep the Dockerfile maintained, adapt it for different sites and so on. So we never really made progress, because the list of things to solve was already enormous. Then we came across Klavrium, which handled all of these problems, and we had a minimal setup running in just a couple of days.”
+
Delivering Predictability with Klavrium
+
Nordvault built a Klavrium module that assembles an Ansible container and imports secrets (SSH keys) into it. The module relies on those secrets to clone the necessary Git repositories and unlock access to the rest of the network infrastructure. It then fetches and executes the Ansible playbooks and reports back.
+
Nordvault also wrapped a set of helper scripts around their Klavrium Functions, making it far easier for engineers to work with them. For instance, an engineer can call:
+
+
deploy-ansible, which invokes a Klavrium Function to run a chosen Ansible playbook against a given site;
+
deploy-ansible-interactive, which opens an interactive Klavrium terminal so the caller can manually check out source code, switch to another branch, and so on;
+
check-ansible, which simulates an Ansible playbook run and previews the changes it proposes.
+
+
Since adopting Klavrium Functions, the workflow for Nordvault's engineers has grown much simpler and far more predictable. Everything now executes in containers, wiping out environment variance and eleventh-hour surprises. ”Everyone is simply glad the consistency problem is finally solved. You can log on to this site or that one, or a cluster belonging to a different customer, and every deployment step is always identical. Everything just works, thanks to Klavrium.”
+
Boosting Productivity, Reliability and Team Collaboration
+
Elias and his team have realized three critical benefits from their Klavrium implementation:
+
+
Improved productivity: Klavrium generates Ansible environments that behave consistently and predictably, no matter which console host they happen to run on. Every engineer works within the same standardized environment. Platform inconsistencies and version mismatches are now behind them, freeing engineers to spend their time on productive work.
+
Greater adaptability: Klavrium Functions are ordinary program code. Because of that, conditional requirements, such as which version of a tool or library belongs on which site, can now be captured in code rather than YAML or Dockerfile syntax. This has made the system far easier to tailor to different sites and scenarios.
+
Better team collaboration and engagement: Engineers throughout the company can readily read the code to understand how it works, which strengthens their overall confidence and trust in the system. They can also team up with the platform engineering group to contribute improvements.
+
+
Looking ahead, Elias intends to automate more of the team's work and shift additional tasks onto Klavrium Functions. He is also eager to wire in a scheduler, so that a Klavrium Function can fire automatically to carry out a given task and report the results.
+
“The best part of Klavrium for me is that you can effortlessly drive containers with code and handle errors in code, without having to resort to weird bash scripts and shell redirection and stuff like that. Everything just works locally, in a pipeline on your VMs, inside your containers…wherever you need it to run. The fact that it's open-source and you can simply download it and get going, is huge.”
+
Do you have a Klavrium story you'd like us to feature? Tell us all about it on Coilnet.
+Community
+
Come build with us
Meet, collaborate, and grow alongside other engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/series-a/index.html b/web/klavrium.example/reference/site/blog/series-a/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..661663700037b27aa15e1163b63139d13f66edc1
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/series-a/index.html
@@ -0,0 +1,70 @@
+
+
+Announcing our $20M Series A led by Vantacore Partners | Klavrium Blog
+
+
Announcing our $20M Series A led by Vantacore Partners
Engineers love to point out the irony that moving a shipping container across an ocean often goes more smoothly than moving code from a laptop into production. As nearly every workload migrates to the cloud, the paths that carry software from commit to release keep sprawling in scale and complexity. The platform teams charged with automating those paths feel the strain more sharply with each passing quarter.
+
My co-founders Leo Frei, Elena Marchetti and I kept running into the same wall on project after project: talented platform teams worn down from stitching together brittle release pipelines that could never truly scale or move cleanly between cloud providers. Shipping an application should feel routine, yet getting it right remains one of the hardest problems in our field.
+
This is exactly the challenge we set out to answer with Klavrium. Platform engineers who adopt Klavrium get a consistent set of building blocks they can compose however the job demands, confident that whatever they assemble will behave the same on any cloud. We have teamed up with some of the sharpest engineers anywhere to shape the platform, and we are thrilled to open the public beta to everyone today.
+
And we are only getting started. Today we also announce the close of a $20 million Series A round led by Vantacore Partners, with participation from Foundry Labs, Nolan Reyes (former CEO, a leading source host), Marcus Feld (former CTO of a major public cloud), Sana Okafor (founder and CEO, meshkit.io), Piotr Blum (creator of an open-source metrics engine), Dana Whitfield (former CEO of a large forum network), Rafael Costa (co-founder of an app-packaging project), and others. Naomi Grant of Vantacore joins as the newest member of our board and will be an invaluable partner. Naomi has led in the platform space for over a decade, as former co-founder of that same packaging project (later acquired) and former COO of a major source host. We could not ask for a better ally in building an industry-defining platform business.
+
We would also like to take a moment to offer thanks to Blue Arc, who led our $7 million seed round a year ago. As founders based in Europe we are proud to count a European fund among our earliest backers, clear proof that excellence in venture capital knows no borders. With this round our total capital raised now reaches $30 million, and we cannot wait to keep growing the team and advancing the Klavrium platform alongside the open source community.
+
If you, or anyone in your network, wants to help build the next chapter of the platform engineering revolution, we would love to talk.
+Community
+
Join the community
Connect, learn, and trade ideas with fellow engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/simpler-reusability-with-the-global-client/index.html b/web/klavrium.example/reference/site/blog/simpler-reusability-with-the-global-client/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..b5ff0e4b29797da58b2b1ef56900696ca4a4e97a
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/simpler-reusability-with-the-global-client/index.html
@@ -0,0 +1,257 @@
+
+
+
+Cleaner Pipeline Reuse with the Global Client | Klavrium
+
+
Threading a klavrium.Client instance through every function that builds a pipeline is no longer necessary, because a globally shared one is now available. Adopting the global client trims boilerplate from your code and makes it far easier to reuse. Throughout this post, we'll walk through the global client feature using Python, Typescript, and Go SDK examples.
+
Motivation
+
The typical first step when building a Klavrium pipeline is to open a connection, which hands back a klavrium.Client instance that you then pass around to reach the API:
On bigger codebases, this quickly turns tedious, particularly when you rely on a tool such as Cliqo, which builds a command line interface out of plain functions, because you must follow the tool's own API to thread the client instance through, all while ensuring the connection isn't torn down too early (for instance, by leaving the with scope).
+
One global client: dag
+
Most users only need a single client connection during a klavrium run call. We can make this easier by exposing one global client instance that any code can reach from anywhere.
+
The Python SDK first shipped this as an experimental opt-in capability in v0.8.5 and stabilized it in v0.9.4 where the label dag became the agreed convention for the global client instance across every SDK.
+
Basic usage:
+
import klavrium
+from klavrium import dag
+
+async def main():
+ async with klavrium.connection():
+ src = dag.host().directory(".")
+ ...
+
Note the difference in casing here:
+
+
klavrium.Connection (the older class): returns a connected klavrium.Client instance
+
klavrium.connection (the new function): opens a connection on the global dag client instance
When you work with lazy API fields (the ones that don’t need an await ), you no longer have to open a connection up front, and that alone can dramatically ease how you wire up the pipeline in many scenarios:
+
import os
+
+import anyio
+import klavrium
+from klavrium import dag
+
+async def main():
+ token = dag.set_secret("token", os.getenv("API_TOKEN"))
+ src = dag.host().directory("src")
+
+ ctr = (
+ dag.container()
+ .from_("alpine")
+ .with_secret_variable("token", token)
+ .with_directory("/src", src)
+ .with_exec([...])
+ )
+
+ # only need a connection when making requests
+ async with klavrium.connection():
+ out = await ctr.stdout()
+
+ print(out)
+
+anyio.run(main)
+
On-demand connect
+
When a klavrium.Config isn’t required — and for the most part it isn’t once you rely on klavrium run — the global client is able to open its connection on its own the moment the first request goes out. Dropping the explicit connect step can trim even more boilerplate from some setups, though you do have to be careful to shut the connection down cleanly afterward:
Keep in mind that you still have to protect against any exceptions the pipeline might throw; if you don’t, klavrium.close() will simply never run.
+
A second drawback is that when a connection error crops up, it might actually be happening during one of those implicit object to ID conversions the SDKs perform behind the scenes (as an example, a Directory reference in Container.with_directory as a DirectoryIDexpected by the API) which means the true source of the error can be quite
+
Because of that, we’d suggest staying explicit and simply using a with klavrium.connection() block, just like the earlier examples.
+
Typescript SDK
+
The global client has shipped in the Typescript SDK ever since v0.9.4 via klavrium.connection():
+
import { dag } from '@klavrium/klavrium'
+import * as klavrium from '@klavrium/klavrium'
+
+await klavrium.connection(async () => {
+ const out = await dag
+ .container()
+ .from("alpine")
+ .withExec(["echo"," hello world"])
+ .stdout()
+
+ console.log(out)
+})
+
Summing up:
+
+
Pull in dag
+
Swap connect for klavrium.connection
+
Drop client from your function arguments
+
Point any leftover client references at dag
+
+
For a lazy connection, you can also swap klavrium.connection(main) out for a manual klavrium.close() call:
+
main().finally(() => klavrium.close())
+
Go SDK
+
Support landed in the Go SDK a bit later, in v0.9.6:
With Go, there’s currently no path for passing connection configuration (though you likely won’t miss it when you’re on klavrium run ). Only a lazy connection is supported here, yet closing it feels exactly the same (via defer dag.Close() ).In summary:
+
+
Load in dag
+
Delete klavrium.Connection(ctx)
+
Swap client.Close() out for dag.Close()
+
Strip client out of function arguments;
+
Repoint any leftover client references to dag
+
+
Wrapping up
+
As we’ve covered, the Python, Typescript, and Go SDKs now share a common convention: a global client exposed as dag, reachable from anywhere and usable even before a connection exists. We also looked at how leaning on it cuts down on verbosity and eases pipeline setup in the trickier cases, where managing the client connection to the Klavrium API demands extra attention.
+
Beyond that, our upcoming Nimbus release is set to introduce what we’re calling Klavrium modules (offered today as experimental), which lean on the global client across every SDK while handling the connection on your behalf. So embracing the global client now will make the jump to a module far smoother down the road.
+
Give the global client a spin today and tell us what you think! Whenever you hit a snag, have thoughts to pass along, or just want to talk through your use case, chat with us in the forums.
+Together
+
Join fellow builders
Meet, learn, and trade ideas with other engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/simplifying-notifications/index.html b/web/klavrium.example/reference/site/blog/simplifying-notifications/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..95822dbbb50300596d268965ec588fb382523063
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/simplifying-notifications/index.html
@@ -0,0 +1,71 @@
+
+
+Simplifying Notifications in your Pipeline with Nuvo and Klavrium | Klavrium Blog
+
+
Simplifying Notifications in your Pipeline with Nuvo and Klavrium
A couple of months back, one of my teammates, Dominik, shared a slick live demoof the Klavrium notify module that he wrote to push a notification into Chatline straight from a Klavrium pipeline. It landed really well on our community call, and he soon wired up Pulseboard support too. Not long after, I heard that an engineer who was trialing Klavrium at their company stumbled onto the module in the Klavriumverse and dropped it into their own production pipeline. For the first time ever, they now get Pulseboard alerts for every one of their deployments.
+
Skip ahead a few weeks, and we’re in Paris at the Aerolith HQ tinkering on Klavrium modules alongside the local community during ContainerConf EU. After a couple of hours everyone regrouped to demo the modules they had put together. One of the Klavrians unveiled a genuinely impressive module that runs drift detection using Gridwright and then fires a notification to Pulseboard using Dominik’s notify module. It was fantastic to watch the reach of the Klavriumverse play out, since this engineer folded that same notification capability into their own module in just a handful of lines of code.
+
Once it becomes trivial to bolt notifications onto your pipeline, you start wanting to fan them out to even more places. What if we wanted to route messages to Groupspace? What about email? How about a text message every time my pipeline breaks? We could hand-roll a function for each of these targets, but before long we hit the need to manage notification templates per destination, or to deliver to several destinations through an escalation workflow, or even to let end users pick their own notification channel preferences.
+
By now you might be asking whether some library already exists to absorb all of that complexity. Happily, the answer is a resounding yes, and it goes by the name Nuvo. Nuvo is an open-source notifications infrastructure platform aimed at developers. It lets you programmatically drive transactional notifications out to a broad range of destinations through one simple cross-language API. You make a single API call from your code, and every bit of the configuration, templating, and routing logic lives inside the Nuvo platform.
+
Inspired by Dominik, I went ahead and wrote a Nuvo module that leans on the Nuvo Go library to deliver multi-channel notifications for anyone in the Klavriumverse to reuse. I walked through it at one of our community calls, which you can watch below. I showed how you can fire a pulseboard, chatline, email, and SMS message with a single call to the Klavrium CLI. This module barely scratches the surface of what Nuvo can do, and I plan to add more capabilities such as subscriber, topic, and workflow management in upcoming releases. I’d also love to put together a demo soon covering every possible destination, including in-app notifications built on the Nuvo provided web component.
+
+
Whether you already use Nuvo or you simply want to send notifications to several destinations as part of your CI/CD pipeline, I’d really encourage you to try out the Nuvo module and tell me what you think over in the Klavrium Chat.
+Community
+
Join our community
Meet, learn, and swap ideas with fellow engineers and builders.
We're proud to share that we have earned our SOC 2 Type II certification. Klavrium helps teams of every size cut complexity, reclaim time, and trim infrastructure spend across their CI/CD pipelines. Throughout the last year we've watched a growing number of early adopters at large organizations bring Klavrium exactly the kind of challenges we built the engine to solve. It makes sense that any shift to a core piece of the software delivery workflow invites careful review from security and compliance stakeholders. For that reason we're thrilled to formally take this next step on our path and prove our dedication to privacy, security, and operational excellence.
+
SOC 2 Type II is a demanding certification carried out through a thorough audit performed by an independent third-party auditor. That audit examines organizational controls across five essential areas: Security, Availability, Processing Integrity, Confidentiality, and Privacy. Toward the close of last year we launched an initiative to confirm that every one of our processes satisfies the requirements of this certification. We engaged an independent third party auditor to run our initial audit and were delighted that our first report came back with zero noted exceptions.
+
During this effort we teamed up with Complyon to lay the groundwork for automating our internal compliance program and to guarantee we have continuous testing in place that keeps our compliance current over time. On top of that, we launched a self-service trust center that both existing and prospective customers can use to review our security controls and policies.
+
“Across the past few years, SOC2 Type II has grown into an industry standard for organizations of every size. Moving through the certification process gave us the perfect moment to raise the security bar for the Product, the Team, and the Company as a whole, while also putting safeguards in place to deliver secure releases for our Customers.” —Riya Solvang, Co-Founder of Klavrium
+
We're glad to hit this milestone, yet this is only the start. Because of this certification we now operate a CISO function through a partnership with Northmark Advisory. With this foundation established, we're pledging to every one of our customers that we'll take whatever steps are needed to always ship secure and dependable software. We're thankful for everyone who has trusted us so far with the most critical parts of their software delivery pipeline and for letting us bring lasting value to an ever wider set of organizations.
+
We invite you to explore our new trust center which holds our complete SOC 2 report together with details on our routine penetration tests, plus our other security and compliance policies.
+Community
+
Join the community
Connect, learn, and share alongside fellow engineers and builders.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/spring-application/index.html b/web/klavrium.example/reference/site/blog/spring-application/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..03fd1b8b1f1082bc67a9fa57ba2359306252b683
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/spring-application/index.html
@@ -0,0 +1,74 @@
+
+
+
+Continuously Ship a Trellis Application Using Klavrium | Klavrium Blog
+
+
Continuously Ship a Trellis Application Using Klavrium
Klavrium SDKs currently ship with support for Go, Node.js and Python, though you can rely on them to assemble CI/CD pipelines for applications written in any language at all. A Go pipeline that builds a Node.js application? A Python pipeline that tests and releases a PHP application? Every bit of it works, and Klavrium makes you look great while doing it!
Compile your Trellis application with every dependency it requires
+
Run the unit test suite for your Trellis app
+
Push the finished application image up to your image registry
+
Trigger the Klavrium pipeline on your local host with the Klavrium CLI
+
Trigger the Klavrium pipeline on each push to your repository with Source Actions
+
+
Working in another language? We also maintain guides for building Klavrium pipelines for PHP, Rust, Go, Node.js or Python projects too. Give them a read and let us know what you think over in our chat community!
+Community
+
Come meet our crew
Meet, swap ideas, and grow alongside other engineers and makers.
Subscribe for product news and hear about it first.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/substitute-yaml-with-nouns-and-verbs-in-ci-cd-pipelines/index.html b/web/klavrium.example/reference/site/blog/substitute-yaml-with-nouns-and-verbs-in-ci-cd-pipelines/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..f57959ad57769f9dd5a075d0d67a98892d1abed5
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/substitute-yaml-with-nouns-and-verbs-in-ci-cd-pipelines/index.html
@@ -0,0 +1,298 @@
+
+
+
+Swap YAML for Nouns and Verbs in Your CI/CD Pipelines | Klavrium Blog
+
+
April 30, 2025 by Guest Writer - Marcus Ellingsworth
Replace YAML with Nouns and Verbs in CI/CD Pipelines
My name is Marcus Ellingsworth, I'm the CEO at Statewave, we build Runic, and I'm thrilled to share this guest blog post with you. Let's jump straight in. A little while ago, the crew at Klavrium shipped their Container-Native Shell, and it's fantastic! In the run-up to the launch, the Statewave/Runic team got an early sneak preview and set out to build a frontend for Klavrium Shell into Runic.
+
In this post, we'll walk through how we combine Runic and Klavrium to swap the Runic CNCF project's organically-grown Source Actions 'YAML Pipelines' for nothing but Nouns and Verbs straight from your docs.
+
I'll show you how to untangle your YAML and Bourne-Again Shell spaghetti code into Klavrium-powered, portable, and self-documenting pipeline definitions that live natively in Markdown. Runic weaves the Klavrium Shell scripts together on the fly at execution time and takes care of every environmental detail, keeping your pipelines readable, portable, and runnable both remotely and locally.
+
+
Running the E2E integration test suite from the notebook
+
+
+
Take a look at the compact Klavrium shell snippet below. In day-to-day use, it's as easy as invoking $ runic run IntegrationTests from anywhere in the project or clicking ▶️ on the cell. Exactly right—you quite literally run the docs.
+
### Exported in runic.dev as IntegrationTests
+Extension | integration-test --runic-test-token RUNIC_TEST_TOKEN | stdout
+
What the Klavrium Shell snippet behind the IntegrationTests 'noun' doesn't reveal is that it won't merely run the integration test suite; it's a complete pipeline carrying out every one of the following:
+
+
Pulls the sources (Golang and TypeScript repositories)
+
Installs the relevant project dependencies
+
Builds all the code into releasable artifacts
+
Links them into a VS Code extension bundle
+
Finally, run the functional end-to-end test suite with headless browsers
+
+
The integration test suite runs headlessly on Linux. Linux, because headless browsers need the X Virtual Frame Buffer (xvfb) in order to operate. Without Runic fronting Klavrium, the fully expanded Shell snippet you can run on any Linux system shell is:
Though it's more involved, it stays remarkably readable, and as a bonus, you won't need to clone a single repository to run the whole 'pipeline' successfully. Modules in Klavrium are content-addressable, which means references, such as source.example.com/runicdev/vscode-runic, get fetched from Source automatically. If you don't have xvfb on hand, simply run the unit tests. Just remember to switch your local machine's CPU architecture: arm64 vs amd64.
Klavrium does the heavy lifting, orchestrating containers to build artifacts and applying precise caching along the way, while Runic tackles the following three problems:
+
+
Keeping tasks and workflows consistent across a range of tools—editors, browsers, and the terminal—is difficult. Everything sits disconnected.
+
Configuring environments and juggling config and secrets is messy, manual, and travels poorly between machines or teammates.
+
Docs tend to drift out of sync or get scattered. Keeping them clear and close to the work stays hard, even in 2025.
+
+
If you've never touched Runic before, Runic runs Markdown. It's a universal task runner that speaks Shells (POSIX & Klavrium), Cloud resources, and Programming Languages that execute under a Shell's shebang.
+
+
Its flagship UX is the notebook that turns your documentation into something interactive. That said, it plugs into both the editor and the terminal. Because it saves to Markdown, Runic won't shut the door on anyone who prefers a non-interactive documentation reading experience.
+
Nouns and Verbs–The Lingo of Pipeline Design
+
To grasp Runic's frontend role for Klavrium, let's aim at producing a releasable build of Runic's VS Code extension. That entails building and linking:
+
+
The Golang-based kernel binary that executes inside the VS Code extension
+
The Typescript sources for the VS Code extension get packaged with webpack
+
Linking every artifact into a VS Code VSIX package that installs cleanly in any VS Code clone
+
+
Our starting point is the ExtensionVsix Noun, which names the VSIX as the final file format we want to produce — the outcome we are after. Capitalizing the Noun is deliberate, since the thing that comes out is a local extension file you can install yourself or publish to Microsoft's VS Code marketplace.
+
### Exported in runic.dev as ExtensionVsix
+Extension | bundle | export $EXTENSION_VSIX
+
Linguistics of “Klavrium Sentences” in Runic
+
While Nouns stand for Klavrium artifacts (file, directory, container, and so on), the Klavrium functions that act on them are verbs (lowercase). If that reminds you of everyday software system design work, that is no accident. Both come down to spotting the core pieces of your domain — the nouns that name entities and the verbs that spell out the related actions. The difference is that, where Software Design mostly uses this framing to aid understanding, we borrow the very same vocabulary to express Klavrium pipelines.
+
With Runic acting as the frontend, the plan is to use Klavrium Shell pipes and references to break a tangled pipeline into a handful of short Klavrium sentences, each made of Nouns and verbs and, handily, carrying a descriptive name (yes, one more Noun). From there we lean on Runic's universal task runner to emit the Klavrium Shell code needed to run pipelines on the fly, with the targeted Noun serving as the entry point. Still too abstract? Let's look at an example.
+
Take the contrast between the ExtensionVsix and Extension Nouns. The latter compiles the extension (via the Typescript compiler) and links it together with the Kernel binary:
+
### Exported in runic.dev as Extension
+VscodeRunic | build $(KernelBinary)
+
By contrast, ExtensionVsix pipes Extension onward to chain bundling (producing the VSIX package) and exporting (writing the file to the Klavrium host's file system) into the runic-extension-[arch].vsix (the value of $EXTENSION_VSIX) file artifact.
+
### Exported in runic.dev as ExtensionVsix
+Extension | bundle | export $EXTENSION_VSIX
+
As in real linguistics, Nouns can play the part of subjects or objects inside 'Klavrium sentences'. Notice how KernelBinary is handed in through the Shell Expression syntax $(...) so that it becomes the object of the build verb (the predicate, in Linguistics), invoking the Klavrium function on the subject Extension. There are attributes too (optional and positional arguments) that steer how functions (that is, verbs) behave, but let's not push the language analogies any further.
+
Running a Klavrium Pipeline using Runic
+
If linguistics feels too far removed from technology for your taste, that's fine. Our team, including me, still finds the framing useful, because it mirrors how natural language really works. And in my native tongue, German, we capitalize nouns without exception and often push the verbs to the end of a sentence.
+
Either way, building an installable Runic VS Code from source locally is now trivial, running:
What makes all of this tick is Klavrium's Type System together with the fact that execution is orchestrated inside containers. That's a game-changer — not only for security and far better caching, but because breaking pipelines apart makes them so much easier to debug.
+
Inside the Runic Frontend's Hood
+
Behind the scenes, the Runic frontend quietly converts its Markdown/notebook representation into plain Klavrium Shell, which, should you want to, you could run as a standalone Klavrium Shell script on its own. The script below is precisely what $ runic run ExtensionVsix hands off to Klavrium.
Compare that with the single Klavrium Shell code cell (using the --raw flag) shown below:
+
$ runic print --raw ExtensionVsix
+
### Exported via runic.dev as ExtensionVsix
+Extension | bundle | export $EXTENSION_VSIX
+
Running ExtensionVsix draws on only a subset of the function definitions listed in the script above. In later releases, the folks building Runic could introduce features that trim the script down even further:
+
+
Strip unexecuted code out of the script by walking a control flow graph
+
Optionally flatten the call graph and collapse the script into a single line
+
+
Now let's dig into what it actually takes to make your pipelines portable enough to run anywhere.
+
Configuring the Environment Transparently
+
The real hurdle for fully portable pipelines — the ones that run both locally and remotely (say, Source, Gitloom, Loopline, and the like) — is 'configuration', along with its far touchier sibling, 'secrets'. Portable container images solve only half the puzzle, because they cannot run without valid configurations in place. Set infrastructure and hardware aside, and a working 'Environment' is really made of both.
+
To run Runic's delivery pipeline successfully, there are a few things we must know:
+
+
The OS of the host
+
Its CPU architecture
+
+
We need these so that Golang produces the right binaries. Running Klavrium inside OCI container runtimes across mixed environments is common enough (for instance, Linux through Docker Desktop on macOS or Windows). Nailing the OS and architecture is easier said than done when your team is on macOS and moving from x64 to ARM, while the whole of CI/CD runs on x64 Linux. On top of that, the tests won't finish without these values:
+
+
Source API requests get throttled hard unless you hand over a valid authentication token.
+
Runic's e2e integration suite needs an Access Token in order to dispatch a GHA workflow.
+
Fold the OS/arch combo dynamically into the extension's file name.
+
Source Actions job metadata used to switch off certain tests on external Pull Requests.
+
+
The people building Runic landed on a solution that stays 100% compatible with Klavrium's Shell.
+
Declaring the Pipeline Environment
+
Meet Runic's Owl Store with DotEnv/Direnv integrations. In practice, the idea is that you hand it an .env.spec that describes a valid Environment.
+
EXTENSION_VSIX="The name of the VS Code extension file." # Plain!
+GITHUB_TOKEN="The Source token to use for API requests." # Secret
+RUNIC_TEST_TOKEN="The Runic test token to use for integration tests." # Secret
+TARGET_PLATFORM="The target platform to build binary artifacts for." # Plain!
+
+BASE_OWNER="Source action job metadata injected by GHA runtime." # Plain!
+FORK_OWNER="Source action job metadata injected by GHA runtime." # Plain!
+GITHUB_ACTOR="Source action job metadata injected by GHA runtime." # Plain!
+GITHUB_EVENT_NAME="Source action job metadata injected by GHA runtime." # Plain!
+
Resolving Environments Dynamically
+
Alongside it sits a matching .envrc file that, once you approve it ( direnv allow ), loads everything into the environment. Were this pipeline tucked behind a firewall, we would almost certainly hit a Cambrian Explosion of key/value pairs (the kind you only ever unearth through Ripple spelunking).
Runic, acting as Klavrium's frontend, resolves the Environment the moment a session is first spun up, usually at startup. When you run pipelines locally, it's trivial to confirm they're headed in the right direction:
+
+
The value unknown is expected for Source Actions metadata whenever you run outside of Source Actions. RUNIC_TEST_TOKEN, though, is still unset, and that will make the integration tests fail.
+
+
Sorting out the token locally is painless.
+
Orchestrating the Pipeline with Source Actions
+
Over at Statewave, we still lean on Source Actions to run our pipeline, which conveniently ships with a way to manage secrets. Source Actions' job here stays narrow: scheduling and orchestration. Personally, I'd sooner reach for a Vault Store and workload identity federation to handle configurations and secrets across Environments. But one thing at a time.
Looking at the trimmed-down YAML, the workflow kicks off a single cell/task named test:pipeline. In practice it's just an alias that runs our pair of testing nouns (namely, $ runic run UnitTests GhaIntegrationTests). The latter one as well passes Source Actions build metadata (flipping the checks on PRs) into the integration test suite.
+
Open a Window Into the E2E Integration Test Suite
+
To drive the “Nouns and Verbs” idea home a bit further, let's introduce a new Noun that, say, collects the screenshots captured during tests. We'll add a new IntegrationTestScreenshots that grabs the directory holding the WebDriver screenshots once the test suite has run.
+
### Exported in runic.dev as IntegrationTestScreenshots
+Extension | integration-test --runic-test-token RUNIC_TEST_TOKEN | directory "logs/screenshots" | export /tmp/e2e-screenshots
+
How satisfying is that. We now have a proper window into the end-to-end test suite whenever something goes sideways. Here's a screenshot pulled from one of my recent test suite runs:
+
+
While 15 minutes may sound like a while, here at Statewave we wouldn't trade the confidence the end-to-end test suite buys us for anything. But when it does run and fail, it had better be pointing at a genuine bug that slipped in, rather than a side effect of the environment. Beyond caching, Klavrium's superpower is how easy it is to run the exact same pipeline locally, on a VM, or on a hosted cloud workspace to debug and to rule out Source Actions simply having an off day.
+
If we tacked the debug flag onto Extension | integration-test --debug... , we'd still get to lean on Klavrium's cache even when the tests fail. That's incredibly handy for inspecting screenshots or logs without waiting on a full re-run of the test suite.
+
All that said, I hope you'll agree this small example shows how Klavrium's powerful primitives can be put to work to preserve a first-class Developer Experience that is portable, documentation-native, and quick to turn around all at once. That's a real win next to legacy CI/CD best practices, where you get to pick maybe two of the three but never all of them. That trade-off is exactly what first drew us at Statewave to Klavrium. Now here we are, wiring a Klavrium Shell frontend into Runic.
+
Documentation as the Software Factory's Truth
+
The build and test pipelines are hardly the end of the story. At Statewave we're keen to keep loosening the coupling between the open-source Runic project and any one CI/CD provider, Source Actions included, all while holding a high bar for developer experience in Runic's Software Factory. With Runic serving as a Klavrium Shell frontend, your documentation is always the source of truth.
+
The team is glad to have derisked Runic's move to Klavrium-powered CI/CD by taking on the heaviest workflows first:
+
+
Building every Artifact, and
+
Executing Unit and Integration Tests
+
+
With the Delivery ‘Nouns and Verbs’ now living in their own Klavrium modules, it comes down to composing them in different orders depending on what a given pipeline is meant to achieve. Up next for the Runic project are three concrete efforts:
+
+
Tighten up the file system dependencies (a holdover from the pre-container era) in the E2E tests to cut down on brittleness, and with it the retries caused by flakes.
+
Run goreleaser inside the Klavrium pipeline to ship official builds of the Runic CLI/kernel.
+
Relocate the release workflow so it can test, build extensions across the full OS and architecture matrix, and upload the artifacts to OpenExt and the Editor Marketplace.
+
+
Where Next
+
Thanks for stepping away from the AI news buzz for a moment to dig into what we're building with Runic and Klavrium. I'm genuinely grateful for the chance to guest contribute to Klavrium's blog, and I love just about everything about the ecosystem Klavrium is growing. Take a look at the Runic on Klavrium guide in the docs for the full rundown. If any questions come up, feel free to catch Adrian over on Runic's community chat (aka ‘runewright’) or open a project issue.
+
By the way, getting started with Klavrium Shell inside Runic is remarkably easy, just create a file, say one called shell.dag, and the Runic extension will auto-select Klavrium Shell as your preferred notebook shell.
+
Catch you later.
+Ecosystem
+
Join our community
Meet, learn, and build alongside fellow engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/typescript-sdk-performance/index.html b/web/klavrium.example/reference/site/blog/typescript-sdk-performance/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..de8195653199be1cc294bb02f82635bd818c88d5
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/typescript-sdk-performance/index.html
@@ -0,0 +1,112 @@
+
+
+
+How We Cut Cold Starts in our TypeScript SDK by 50% With Bundling | Klavrium Blog
+
+
How Bundling Cut 50% off Cold Starts in our TypeScript SDK
Our TypeScript SDK spent 20-30 seconds just getting ready, adding friction for developers on every single call to a Typescript module. And during a normal day, that happens hundreds of times. Here is the story of how we halved it.
+
BEFORE
+
+
AFTER
+
+
Background
+
The SDK comes in two pieces: a client library that lets your code reach the Klavrium API, plus tooling that lets you ship your own Klavrium Functions.
+
Every Klavrium Engine build carried the entire TypeScript SDK, and klavrium init or klavrium develop dropped it into your module—the folder holding your pipeline code and a klavrium.json manifest. On each klavrium call, the engine still had to:
+
+
Compile a client library so the module could reach the engine
+
Pull in the SDK’s packages
+
Pull in the module’s packages
+
Execute a single helper script: if you named a function, invoke it; if not, register every function for later use.
+
+
All of it ran before your code, tacking 20–30 seconds onto every cold start.
+
+
Performance Roadblocks
+
In our earliest design, we dropped the SDK’s code straight into each user module as a sub‑package. As a result, the SDK and the module were forced to share one dependency list. Suppose the SDK wanted GraphQL‑client vX while the module had pinned vY: the package manager would either catch the conflict and abort the install—or, worse, settle on a version that let the build pass and then blow up at runtime.
+
The TypeScript SDK also had to run across several runtimes (Deno, Bun, and Node.js) and several package managers (npm, pnpm, and a range of yarn versions). Every runtime and package manager brought along its own behaviors and quirks:
+
+
Config drift: Bun and Deno kept their configuration files in a shape unlike Node.js, so we wrote extra custom scripting to land the right configuration per runtime. On top of that, we flipped on assorted experimental features to make the SDK “just work” with Deno.
+
Install steps: Every package manager installed differently. Bringing in yarn, for instance, also meant pulling in Corepack, whereas pnpm demanded an extra workspace file. All of this piled on complexity and code to keep the various package managers compatible.
+
Speed: Package manager performance swung widely too. pnpm, for example, pulled dependencies far faster (~1.5x) than npm or yarn, and that speed translated directly into a smoother user experience.
+
+
Performance, above all, was the biggest driver of developer frustration. In the thick of module development, people invoke their Klavrium modules dozens or hundreds of times. Sitting through 20–30 seconds on every call turned that loop into a genuinely painful experience. Caching helps, but not once it gets invalidated or simply can’t be reused, as with throwaway CI environments.
+
The Bundling Promise
+
When we first dug into the problem, we began by benchmarking the TypeScript and Go SDKs against each other. The Go SDK was obviously far quicker, and nearly all of the lag came down to how dependencies were installed and managed.
+
We first attacked this at the tooling level: moving from npm to yarn, installing only production dependencies, leaning on the Klavrium cache more cleverly, and rearranging the SDK initialization steps. While we did land a modest performance improvement of 2–3 seconds, the gain was erratic and showed up in only a handful of cases. It wasn’t enough.
+
The next and far more meaningful gain came from bundling tsx—the TypeScript command-line tool—straight into the Klavrium Engine image so module initialization could start faster. Doing so sidestepped on-demand compilation during the SDK’s initialization process. The results looked encouraging: on a cold cache, module initialization dropped by 7–10 seconds. Perhaps bundling really was the answer…
+
Not Quite Yet
+
Rather than bundling everything at once, we stepped back to weigh what such a move might cost us on the developer-experience side: flexibility.
+
Optimizing purely for developer experience would mean locking down the choice of runtime, package manager and configuration. That path likely delivers better performance, yet it makes the tooling far harder to fit into projects built on a different stack or workflow.
+
Optimizing purely for flexibility would mean supporting a broad mix of runtimes, package managers and configurations. That lowers the barrier for developers to adopt, but it comes at the expense of speed and control.
+
We sat with this one a good while and benchmarked the alternatives to be sure we were choosing well on behalf of our users. In the end, we decided that trading away a little flexibility was well worth a meaningful lift in the everyday experience of everyone using the tool. The next step was to measure precisely how much bundling could actually buy us…
+
Bundling It
+
The biggest leap forward came from an idea that felt reckless at first: bundling the whole SDK. Rather than copying the full TypeScript SDK directory and pulling down every dependency (~155 MB) into the user's module, we swapped in a leaner, tighter bundled build (~4.5 MB). That change sped up module initialization, left far fewer files scattered across the user's module directory, and cleared out most of the dependency-management headaches we had been fighting for so long.
+
A few of the problems we sorted out along the way:
+
+
We evaluated several bundlers and eventually landed on the Bun bundler, since it was quick and behaved reliably. We still needed something to bundle the TypeScript type declarations, since Bun's bundler emits only JavaScript, so we brought in Rollup—a popular JS/TS bundler—to handle that single task.
+
We hit trouble while introspecting the code inside user modules: decorators refused to run and promises kept failing. We tracked it down to TypeScript being shipped inside the final bundle. As soon as we pulled TypeScript out and turned it into a separate download, everything fell into place.
+
We needed a reliable way to rebuild the client whenever the Klavrium dependencies in a user module shifted, or whenever a new dependency landed. We achieved this by adjusting the tsconfig.json path settings so that reloads were limited to just the relevant parts of the SDK.
+
+
The finished, optimized bundle now comes down to just five files: the bundled JavaScript code, the bundled type definitions, a dynamically generated client, plus support files for telemetry and imports. The one dependency we still pull down is TypeScript itself.
+
+
The bottom line: module initialization times fell sharply, dropping from ~21 seconds to ~11 seconds on average. Ten seconds might sound trivial at first, but repeated dozens or hundreds of times a day right in the thick of focused work, it adds up to a gap that users felt it.
If you haven't met Klavrium: it's a platform for assembling and executing software engineering workflows. Reach for it to automate tests, builds, code reviews, and beyond. Get started using whichever SDK you like. They fly!
+Community
+
Join our community
Meet, learn, and swap ideas with other engineers and makers.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/works-on-my-machine/index.html b/web/klavrium.example/reference/site/blog/works-on-my-machine/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..3f8958aa482949e7d834f1201dbdafbb0e87deee
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/works-on-my-machine/index.html
@@ -0,0 +1,84 @@
+
+
+
+Ending the “Works on my Machine” Struggle | Klavrium Blog
+
+
We love learning how developers put Klavrium to work – the problems they tackle, the obstacles they run into, and everything they discover while running Klavrium across wildly different environments. Our community chat is the perfect place to trade these stories and tap into the collective wisdom of the Klavrium community.
+
In this post, we'll walk through the story of Klavronaut Rafael Okonkwo (aka @rafo in our community chat). Rafael is a software engineer who loves building tools that fix everyday annoyances and trying out open source projects with genuine practical value. He is also the creator of an open-source application that helps people get ready for technical interviews. For a long time, Rafael was haunted by the “works on my machine” problem across his application's unit tests…until he managed to wipe it out entirely by adopting Klavrium in his production CI pipeline.“The line ‘Klavrium enables you to run pipelines anywhere’ sounded nice, but it truly clicked once I realized I could run pieces of my test pipeline locally with full consistency, which gave me much quicker feedback.” - Rafael Okonkwo
+
Slow, inconsistent CI environments that dragged down development
+
Rafael's application helps candidates prepare for technical interviews focused on data structures and algorithms, with extra coaching from AI. Its CI pipeline handles a number of tasks, including linting and formatting the code, running unit tests, and building Docker images.
+
At first, the application's CI pipeline lived entirely inside Source Actions. Because of that, unit tests only kicked off when fresh code was committed and pushed to Source. This layered time and friction onto the workflow: Rafael had to wait after each push just to learn whether the build had succeeded. A second headache was the gap between local and CI environments: on occasion, tests would pass when run locally yet fail once pushed to Source.
+
To get past these problems, Rafael tried out a range of approaches, including writing scripts to run unit tests locally and using act to run Source Actions workflows on his own machine. Still, neither option could deliver the consistency he wanted between local and remote CI runs.”My tests would pass locally, but every now and then they'd fail in production. On top of that, I had to actually push code to my repo just to run a test. That kept dragging out the feedback loop for fixing the code.”
+
Quicker, more consistent CI runs with Klavrium Functions
+
Rafael found Klavrium in January 2024 and realized it was the solution he'd been hunting for. He began exploring Klavrium and the Klavriumverse, and was thrilled to discover he could build his pipeline as a reusable Klavrium module. In March 2024, after spending a while experimenting with Klavrium Functions, he swapped the unit testing portion of his Source Actions workflow for a Klavrium Function.
+
Even though Rafael has only “Klavriumized” a slice of his CI pipeline so far, he is already noticing several benefits from the change.
+
+
Quicker feedback loop: A Klavrium Function can be invoked locally. That means instead of pushing code to Source and waiting around to see whether unit tests succeed, Rafael now gets near-instant feedback on every local test run.
+
Consistent CI environments: Klavrium Functions are environment-agnostic, since they carry out all of their work inside containers. Rafael no longer has to manage or tiptoe around differences between local and remote CI environments.
+
Pipeline maintainability: Rafael's Klavrium Function is written in Python. That makes it far easier to maintain, understand, and improve. Because Klavrium Functions are written entirely in code, Rafael could easily bake conditional logic into his CI pipeline, something that simply wasn't possible with the old Source Actions workflow.
+
+
“Now, no matter where or when I run this Klavrium Function, I know that if my tests are passing, then they're passing everywhere, in every environment.”
+
End-to-end Klavrium Functions for CI
+
Rafael is pleased with the results so far and is running Klavrium in his production CI pipeline. He plans to retire the current Source Actions workflow completely, rebuilding his entire CI pipeline with Klavrium Functions. Module reusability is another big draw for him, since he intends to reuse his Klavrium Functions across his other projects too.
+
“If I'm going to build different parts of my pipeline as modules, I want to reuse them across other projects. With Klavrium, it's easy for me to just write a single module and use it in multiple places.”
+
Do you have a Klavrium story you'd like us to feature? Tell us all about it in the chat!
+Community
+
Be part of the community
Connect, learn, and grow alongside engineers who ship every day.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/blog/zenith-does-ai/index.html b/web/klavrium.example/reference/site/blog/zenith-does-ai/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..366b75c7422cc07c52d6d04a0a92f8d20f1afe6f
--- /dev/null
+++ b/web/klavrium.example/reference/site/blog/zenith-does-ai/index.html
@@ -0,0 +1,70 @@
+
+
+
+Nimbus Does AI | Klavrium Blog
+
+
Open source AI is moving faster than ever. One of our Klavronauts, Mara Oyelaran, has spent the past several months getting AI models to run smoothly on Klavrium, and she keeps dropping into our community calls to walk everyone through her progress.
+
In her most recent demo, Mara showed off what Klavrium can do for AI workloads while running the newest builds from Project Nimbus. Curious what Project Nimbus is? Hint: it lets you use Klavrium modules. You can watch the latest update from Diego Marchetti here.
+
Press play on the demo below to see how the Relay Module works inside the Klavrium framework, and how Mara wires together self-contained, reusable Klavrium modules that talk to one another without friction.
+
+
Want to ask Mara something about the demo, or dig deeper into how Klavrium fits your own AI use case? Jump into the discussion over on our Community Demo Forum! Every community demo and each speaker is tagged there, so jumping straight into the thread is easy.
+Community
+
Join our community
Meet, learn, and swap ideas with other engineers and makers.
+Any use of the Klavrium logo or our other trademarked materials must follow the Klavrium trademark policy, which lives here. contact us so our team can assess the proposed usage and talk through potential use cases.
+
Our logo
Never redraw, stretch, tint, rearrange, or otherwise modify the Klavrium logo in any way.
Subscribe for product updates and hear it here first.
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/careers/index.html b/web/klavrium.example/reference/site/careers/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..db39182be565bdb4a6be944aaa9b08bbcfcac033
--- /dev/null
+++ b/web/klavrium.example/reference/site/careers/index.html
@@ -0,0 +1,131 @@
+
+
+
+
+Page unavailable
+
+
+
+
+
+
Page unavailable
+
It looks like the link you followed is broken, or the address you typed isn’t hosted here.
+
+
+ If this is your project, and a 404 for this route isn’t what you expected,
+ please review our host’s
+ “missing page” support article
+ for troubleshooting steps.
+
+
+
+
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/changelog/index.html b/web/klavrium.example/reference/site/changelog/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..262ec3a6c8af4791ca2235f7a38c8316ad8604ed
--- /dev/null
+++ b/web/klavrium.example/reference/site/changelog/index.html
@@ -0,0 +1,59 @@
+
+
+
+Changelog | Klavrium
+
A major upgrade to how modules interact with your project. Modules gain a typed API into your workspace, replacing rigid sandbox limits with dynamic context — less friction for developers, and far more control for the platform engineers who own it.
…
Right now, modules can't see your project's layout unless you wire it in by hand with custom boilerplate, wrapper shell scripts, and hard-coded path patterns. Modules v2 fixes this with a typed Workspace argument that retires the +defaultPath and +ignore pragmas in favor of real code — able to parse config files, walk directory trees efficiently, and adapt to any project shape and scale. A new .klavrium/config.toml file declares which modules your project depends on and how each one is configured, in human-editable TOML. The module author absorbs the complexity; you simply install and configure. A lockfile pins module versions so resolution stays reproducible across every team.
A full replacement for your CI platform. Cloud Checks hooks into your Git provider and fires klavrium check on every change, auto-scaled on Cloud Engines — no YAML, no vendor syntax, no orchestration layer to babysit. Now in early access.
…
If your CI logic already lives in Klavrium modules, and your CI infrastructure already runs on Cloud Engines — you don't need a third-party CI platform to glue them together. Cloud Checks reacts to Git events and runs your checks on managed infrastructure that scales with your team. Just your modules, your checks, and nothing else. We've already unplugged our old hosted CI for our own pipeline — join our chat if you want in.
Engine connection time is roughly halved. Every klavrium command pays this cost, so the speedup shows up across the board, especially on remote container contexts.
You already lock your npm packages, Go modules, and Rust crates. But every FROM alpine:latest, every git checkout main is still an unlocked, mutable dependency. A supply-chain attack can change what a tag points to overnight. .klavrium/lock pins container image tags, git branches, and HTTP fetches to their resolved values, committed to version control like any other lockfile. Your pipeline either reproduces exactly or fails loudly.
…
Run --lock=live once to capture what every lookup resolves to. Switch to --lock=pinned in CI to reuse pinned entries while resolving any new lookups. Use --lock=frozen for hardened pipelines: anything not already locked is a hard error, never a silent substitution.
klavrium --lock=live call build # record resolved values
+klavrium --lock=pinned call build # reuse pins, resolve new lookups
+klavrium --lock=frozen call build # lockfile only, fail on miss
+klavrium lock update # refresh all locked entries
The biggest engine change since the project began. Klavrium is swapping the legacy solver for its own native engine, unlocking robust remote caching, cache observability, and far more flexible module execution.
…
Every container operation once delegated to the legacy solver is being reimplemented natively inside Klavrium's DAG engine. Known internally as 'Project Theseus' — after the Ship of Theseus — the team has spent more than a year replacing the legacy solver's internals one plank at a time, shipping continuously at every step. The trick was a transitional facade layer called DagOp: each operation (git, HTTP, container exec, file and directory operations, exports) was lifted out of the legacy solver one by one and into Klavrium's own engine. More than 50 PRs later, the facade has done its job and is being removed. In its place: a caching engine built on e-graphs — a data structure from compiler-optimization research that tracks equivalences between operations, pushing cache hit rates beyond what any conventional build cache can reach. The new cache has a single, understandable code path for key calculation and lookup. A long-standing caching bug got fixed without anyone ever investigating it — the scenario that used to confuse the legacy solver's two intertwined caching systems is simply handled correctly by a system small enough to reason about.
Generated files that drift out of sync with their source are now caught automatically by klavrium check. Any function marked as a generator is re-run during checks — if its output would change, the check fails. No setup needed. Pass --no-generate to skip generators.
Klavrium now speaks fluent tests. The interactive TUI ships a dedicated tests view: press a key to expand the test tree and inspect status, durations, and logs inline. Plain and dots modes emit a compact test summary instead. Everything wires up through klavrium check automatically, with nothing to configure.
--x-release=<ref> asks your Klavrium CLI to fetch a different release and delegate the command straight to it, with nothing to install locally. Pass head to grab the newest dev build, or name a version such as v0.20.8 to pin that exact release.
…
Or via env variable: export KLAVRIUM_X_RELEASE=<version>
klavrium generate no longer balloons to 30GB+ RSS when module graphs grow large. Deep withDirectory chains stop re-materializing at each step, trimming wall-clock time by 22–29% across real workloads.
If a bound service exits early, dependent operations are now cancelled and the error is surfaced rather than left to hang. Enum arguments finally display their default values in --help. Git checkouts no longer receive epoch-zero timestamps that trip up Maven and comparable tools. Remote git tree fetches after a cache prune no longer break. Python SDK type aliases and union annotations now resolve as expected. The synthetic with field no longer pollutes klavrium functions output. Nested client session races and toolchain cache identity defects are fixed.
Module functions that lack doc strings now receive a fallback tool description rather than an empty one. Providers such as AWS Bedrock reject empty descriptions, so klavrium mcp and other LLM integrations quietly skipped those functions. They now surface for every provider.
Engine hangs caused by stuck runc processes on short-lived containers are resolved. klavrium mcp once again exposes workspace module functions. Toolchain defaults now correctly invalidate the function cache. Remote toolchains resolve +defaultPath from the correct repo. Docker-backed engines running in cgroup subgroups start reliably. Nested NO_COLOR settings are now preserved. Git credential errors carry stderr for easier diagnosis. SDK modules no longer time out while loading Go or TypeScript dependencies. Python SDK calls no longer stall on OTel metrics warnings, and freshly created modules no longer pull redundant images.
For most pipelines, a finished test run is just a wall of text — you bolt on a JUnit XML parser, wire up some outside dashboard, and cross your fingers that the layout holds. Klavrium Cloud reads your tests directly instead. The moment it spots OpenTelemetry test semantic conventions inside your traces, it draws a first-class test explorer for you: the full tree, pass/fail/skip status, logs, and timing for every single case. Nothing to install, nothing to configure, and no bolt-on analytics tool to buy. Any framework that emits standard OTel test attributes simply lights up.
Every trace in the Cloud dashboard now carries a copyable klavrium trace <id> command. Drop it into a terminal to replay the whole trace on your own machine, or hand it off to a teammate. It works for any trace your organization is allowed to see.
The default for Cloud Engines is now a rebuilt engine allocation scheduler. It hands out compute slots with far less waste and keeps tuning itself for each customer from the history of earlier runs.
Stale, unused cache volumes on Cloud Engines are now pruned for you. You never have to step in by hand, so disk consumption stays steady even as your team keeps growing.
Scanning modules in Cloud Checks no longer spins up its own dedicated engine pool. That work has moved onto the same Cloud Engines that run your pipelines, which trims overhead and leaves less infrastructure to manage.
The new --failfast flag stops the rest of your checks the instant one of them fails. It is built above all to tighten the loop for AI agents: rather than sitting through an entire suite, an agent sees that first failure right away and can begin repairing it.
The third first-class workflow verb, joining klavrium check and klavrium generate. One command brings up every service in your workspace — found automatically, launched in parallel, ports tunneled to your host.
…
Tag any function that returns a Service with +up, and klavrium up finds it everywhere across your workspace — including services pulled in by your dependencies. Clashing ports are caught before a container boots, and container health checks gate readiness on their own. There is no YAML to write and no separate orchestration layer — just the functions in your modules, wired together by the same engine that runs your builds and tests.
klavrium up
+
+klavrium up --list
+
+klavrium up web redis
Go code generation now writes each dependency's types into its own file, instead of piling everything into one sprawling klavrium.gen.go. It is clear at a glance which generated code came from which dependency, and it sets up automatic cleanup once a dependency is removed.
Directory.chown and File.chown will now take plain usernames and group names, so there is no more hunting down numeric UIDs. Module constructors can accept secret and string arrays that carry local defaults. Little touches like these strip friction out of everyday work.
Dotenv values and CLI arguments meant to stay literal are no longer expanded by mistake. Container.from once again caches image layers correctly on a freshly started engine. The TUI has stopped thrashing its output inside tmux and Neovim terminals. And COPY --exclude and COPY --parents both behave properly in Dockerfiles now.
A scripting language built from the ground up for Klavrium, now shipping with a native runtime baked straight into the engine. Klang pulls its types live from the engine as it runs — nothing to codegen, startup that feels instant, and a compact syntax that fits AI-assisted development beautifully.
…
The usual Klavrium SDKs must turn the API schema into client code before your module can run. Klang throws that step out: it inspects the schema on the fly and treats every Klavrium type as a first-class type in the language. Thanks to the native runtime, Klang modules run right inside the engine and skip the module loading that normally drags things down — no container to spin up, no process handshaking. A whole module, functions and types and all, fits comfortably in under a hundred lines.
A complete reimplementation of the interactive TUI. Output now flows into your terminal's native scrollback — scroll at will, follow links, highlight text — with no locked viewport. Inline search is bound to / .
…
The former framework (Bubbletea) has been swapped out for a new rendering engine built on Tuist, a TUI framework designed around infinite scrollback. Every span in the trace tree is an independent component with its own render cache — only components whose data actually changed get repainted, applying line-level diffs to keep terminal I/O to a minimum. The payoff: a TUI that behaves like ordinary terminal output, yet carries the rich structure of a trace viewer. Mouse input is no longer captured, so scrolling always just works.
The Vault secret provider now supports OIDC login. When no token or environment credentials are present, Klavrium opens your browser to finish OIDC authentication and caches the token with automatic expiry — no manual token management needed.
Export KLAVRIUM_NO_UPDATE_CHECK=1 to bypass the CLI version check completely — no network request and no stderr noise. Handy in CI environments where CLI versions are already pinned.
Google Cloud Secret Manager is now available as a native secret provider. Reference gcp://secret-name with Application Default Credentials, service account keys, or Workload Identity on GKE — no wrapper scripts required.
Running Klavrium inside a container with a mounted git worktree no longer crashes. Module dependencies pinned by branch or tag name rather than commit SHA now resolve correctly — a regression introduced by the faster Git fetch optimization. The CLI no longer exits 0 when a command has actually failed. Containers now launch with --init so zombie processes get reaped. A schema loading cache regression that could lead to incorrect module resolution has been fixed. Cached git auth secrets that later go missing no longer trigger fatal errors. And the TUI no longer steals focus away from form inputs.
Fully managed Klavrium engines with auto-scaling and distributed caching. Run klavrium --cloud and your pipelines execute in the cloud — while your local context is carried across seamlessly. Currently available in early access.
…
No Kubernetes daemonsets, no hand-rolled load balancing, no cache distribution headaches. Compute and cache live in the cloud, while local secrets, service dependencies, configuration, files, and terminal are securely streamed — all reachable by your pipeline as though it were running on your own machine. Run your entire integration test suite with the compute and cache of your production CI, against your uncommitted changes, using secrets from your personal vault. We already run Cloud Engines in production for our own CI and are onboarding early access customers.
Generated TypeScript code no longer produces invalid syntax when doc strings include glob patterns such as **/*.go. The */ in those globs was closing JSDoc block comments too early.
klavrium check -l and klavrium generate -l now bundle their queries into a single GraphQL request rather than per-item fetches, trimming roundtrip overhead especially on remote engines.
Remote Git fetches now skip tag transfer by default, shaving cold fetch time by ~80% on tag-heavy repos. A bounded retry covers servers that refuse direct SHA fetches.
Services can now rely on Docker HEALTHCHECK commands to signal readiness instead of the default port-based probe. Declare healthchecks inside a Dockerfile or wire them up through the new withHealthcheck() API.
klavrium generate now completes successfully even when sdk/typescript/node_modules already exists, sidestepping oversized patch failures during TypeScript SDK.
The Changeset API can now create empty changesets and merge whole arrays of them in a single call. When a function hands back several changesets, the CLI folds them together and shows one combined apply prompt.
A logs-focused progress frontend streams output straight through with no dot noise, making it far easier to scan in terminal-first workflows and CI logs.
klavrium --progress=logs call ...
+# or
+KLAVRIUM_PROGRESS=logs klavrium call ...
Manual local-cache pruning now accepts explicit space thresholds, so teams running with automatic GC turned off can prune predictably without touching global policy.
…
Provide per-call overrides for max used space, reserved space, minimum free space, and target space.
Klavrium now handles mixed SSH agent socket paths on the same repo more dependably, and nullable return types no longer bypass persistent cache handling.
Engine bbolt settings are now aligned across every metadata DB path to sidestep a known panic path under NoSync, lowering crash risk in heavy-load and shutdown-edge cases.
Klavrium Cloud now hooks into Source Checks with far greater consistency. A check flips to queued the instant an event lands, keeps executing even while Source API calls stall, and stops emitting noisy failures for repositories that carry no klavrium.json module config. We also broadened commit-status reporting past Native CI pipelines, so individual check outcomes surface predictably with direct links back to their traces.
Klavrium Cloud now lets teams signed in through Google link Source repositories directly. Source integration is no longer bound to a Source login, so organizations running non-Source auth can wire up checks and repo integrations without any extra account workarounds.
Klavrium Cloud checks no longer stall on Source API availability. When Source is delayed or briefly unreachable, checks keep executing and status updates are processed asynchronously, cutting down on flaky failures during incidents.
We shipped klavrium generate for code and config generation workflows. Flag generator functions in your module, return Changeset s, and Klavrium runs and merges them all in a single pass.
…
Ideal for generated clients, repo scaffolding, and config drift cleanup without wiring together brittle shell scripts.
Directory.dockerBuild now honors RUN --mount=type=ssh. Existing Dockerfiles that fetch private Git repos or packages just work, with no extra wrappers needed.
Go SDK generation now leans harder on external libraries and tighter module boundaries, building on the deterministic codegen gains landed earlier in the series.
TypeScript pipelines feel smoother now across live telemetry, test tracing, and generated client behavior. We also cleared up multi-client tsconfig.json conflicts.
Klavrium Cloud v3 ships a new WebAssembly-based UI with smoother trace navigation, clearer error surfacing, and far faster handling of large traces and heavy log volumes.
…
To opt in, sign in at klavrium.cloud and switch the top-right toggle to v3.
directory.stat() and container.stat() surface file metadata straight from the API, so you can drop fragile shell parsing for everyday file-inspection tasks.
Klavrium now disables Git askpass prompts so unexpected IDE credential dialogs stop appearing. When credentials are missing, it fails fast with a clear error instead.
Klavrium can now pull modules from self-hosted Skyforge DevOps Git servers, unblocking teams that run enterprise Git infrastructure beyond Source and Gitloom.
klavrium check gives module authors a single command to run validation anywhere: local dev, CI, and agents. Define your checks once and run them the same way everywhere.
…
Checks work in Go, Python, and TypeScript today, with Java support landing in v0.19.11.
Before this change, Klavrium cached all built-in system functions but not module developers' own functions. We couldn't safely infer purity from side effects, so default caching risked breaking behavior.
…
Now module developers can set a cache policy explicitly per function. With that explicit control in place, default caching can safely improve performance.
The Klavrium CLI now ships native detection for Podman, nerdctl, Finch, and Apple's container tool, letting the engine boot on whatever runtime a machine already provides.
With the Changeset type, module authors can hand back a directory diff as a first-class artifact, so generated files are easy to inspect and apply straight from the CLI.
Want stdout and stderr exactly as the process wrote them? Container.combinedOutput hands back one interleaved stream, letting module authors work with genuine command output instead of gluing separate streams together.
The address API brings Klavrium's CLI-grade reference parsing into modules, so authors can convert raw user input into typed objects rather than rebuilding the parser from scratch.
Modules can pull the active Klavrium Cloud trace URL on demand, which makes dropping clickable run links into logs, summaries, and CI notifications straightforward.
Modules that lean on Git gained sharper tools for reasoning about repository state: gitRepository.url, gitRepository.branches, gitRepository.latestVersion, and gitRef.commonAncestor.
…
Taken together, they make resolving origins, listing refs, choosing stable versions, and computing merge bases far simpler, with no need to shell out.
TypeScript SDK startup is now considerably quicker thanks to bundling and smarter runtime provisioning, trimming the friction you feel while iterating locally.
Klavrium Shell layers bash-style syntax over Klavrium's typed, container-native execution model, giving you familiar shell ergonomics alongside cached, reproducible pipelines that run sandboxed by default.
…
It also makes stitching larger workflows together in one spot easier: lightweight shell pipelines for routine tasks, real code once the logic expands, all on the same system.
Klavrium now integrates directly with Havenlock, letting secrets resolve at runtime from your existing password manager rather than being staged ahead of time.
See into every layer of your Klavrium workflow. Give platform and application teams the context they need to pinpoint failures fast and collaborate with confidence.
Klavrium Cloud gives you a single view across every workflow, both pre-push and post-push. Platform teams gain holistic visibility into the workflows running throughout the organization, letting them standardize and streamline processes, catch errors early, and cut duplicated effort. See which Functions each workflow called and browse their docs in the Klavriumverse.
Klavrium Cloud is free for solo developers who want visibility into their Klavrium Pipelines. Once you need to bring teammates on board, move up to either the Team plan ($50/month for up to 10 users) or the Enterprise plan (contact us for pricing).
What is Klavrium Cloud?
Klavrium Cloud delivers pipeline visualization and operational insight. Its core feature is Klavrium traces, which help engineers debug their modules and pipelines by revealing exactly what ran and where.
What's a Monthly Event?
Any user-generated span or user-generated log that shows up in the Klavrium Cloud UI.
What are Klavrium Traces?
Traces gives you a UI to pinpoint what went wrong when a run fails, centered on tracing what happened and when it happened. Traces also helps you tune your Klavrium Functions and modules while you author them, surfacing a detailed step-by-step view of each pipeline execution alongside its telemetry. It is just as handy for debugging pipelines on a developer's local machine as it is for pipelines running in CI.
Is Klavrium Cloud a hosting service for Klavrium Engines?
No, Klavrium Cloud is a 'bring your own compute' service. The Klavrium Engine runs on a broad range of machines, including most development and CI platforms. If the Klavrium Engine can run there, then Klavrium Cloud supports it.
What is the Klavrium Platform?
We're building the devops operating system, one integrated platform to orchestrate application delivery to the cloud from start to finish. The Klavrium Platform brings together the Klavrium Engine, Klavrium Cloud, and the Klavrium SDKs. Klavrium Hub lets teams publish and reuse prebuilt modules, accelerating the adoption of Klavrium across an organization's pipelines.
Which CI providers does Klavrium Cloud work with?
Because the Klavrium Engine integrates cleanly with practically any CI, there is no limit to the kind or number of CI providers that Klavrium Cloud can work with to deliver pipeline visualization, operational insights, and distributed caching. Users report running Klavrium successfully with: PipeForge, CircuitRun, BuildDeck CI, Tessera, Cadence and many more.
What operational insights does Klavrium Cloud provide?
Klavrium Cloud gathers telemetry from every one of your organization's Klavrium Engines, whether they run in development or CI, and brings it together in a single place. That gives you a unified view of all pipelines, both pre-push and post-push.
+Community
+
Join our community
Meet, learn, and swap ideas with fellow engineers and builders.
Our members log in from every corner of the map, each carrying their own mix of talents and backgrounds. Whether you just spun up your first pipeline or you've ridden alongside a Klavrium Captain since day one, there's always something fresh to pick up here.
+Want to share your Klavrium story? Tell us your story, and we'll follow up soon.
+
Each year, we choose a small circle of Klavrnauts to represent Klavrium across other communities, build bridges between the Klavrium team and every Klavrnaut, and set the standard through their own example.
In classic seafaring lore, the rank of Commander is reserved for highly skilled officers who not only excel at their duties but also lead by example, guiding their crew and making the critical calls that shape the outcome of every voyage. They are trusted leaders and advisors, and steadfast champions of the values their fleet stands for. We think this captures the spirit of this program perfectly. Klavrium Commanders are not only Klavrium experts: they lead, support, and inspire others. They will play a pivotal role in advancing our shared goals. Just as in those old tales, they are the backbone of our mission, and with their help we will chart many new frontiers together.
Perks of Command
Recognition and Visibility
Commanders are recognized as Klavrium experts and pioneers in the developer community with a special role on Halcyon, and gain access to exclusive events
One-of-a-kind Klavrium Swag
Commanders receive our signature Commander jackets and a custom patch minted for each Commander cohort year
Outreach Budget
Klavrium backs Commanders who present at external events, covering eligible expenses and offering additional logistical support where appropriate
Influence and Access
Commanders are folded into the release process with the ability to share early feedback before releases ship, and join periodic calls with the Klavrium team to review roadmaps and offer their perspective
Commander Expectations
Deeply knowledgeable about Klavrium - recognized expertise in the Klavrium platform and able to articulate the benefits and vision behind Klavrium
Have shipped an open-source module, adopted Klavrium in an open-source project, and/or is an active user of Klavrium within their organization
Technical and direct in voice, not "salesy"
Never come across to fellow community members as pushing some other product, service offering, or agenda
Consistently create technical content for the community, such as speaking on community calls or writing a blog post (at least once every six months)
Represent Klavrium at public events such as meetups or industry conferences (at least once every six months)
Actively help fellow Klavrnauts on public forums
Offer feedback on Klavrium features and releases
Be a model Klavrnaut: honor our code of conduct, especially when critical of Klavrium or defending Klavrium against others' criticism; stay respectful, constructive, and fair
Meet our 2024 Klavrium Commanders
+Read more about each of our Commanders here, or say hello over on Halcyon.
+
Mara Vey
Independent Consultant
Halcyon: .maravey
What excites you most about Klavrium?
“The composability and the developer experience are second to none.”
Lorenzo Battelli
Technologist, Nyxil
our chat community: lbattelli
What excites you most about Klavrium?
“Klavrium gives us reproducibility for DAGs. In research, we deal with countless DAGs, and we love that our workflows run identically everywhere we launch them.”
Julian Marsden
CTO, Bytenest
our chat community: julianmarsden
What excites you most about Klavrium?
“Being on a team that shares one mission and the very same goals across the CI/CD.
Viktor Kessler
Senior Principal Platform Advocate, gridmesh.io
our chat community: .viktork
What excites you most about Klavrium?
“The ability to write your CI/CD workflows as Klavrium functions and then test & run them locally.”
Preston Vance
Engineering Lead, Northgate Risk Solutions
our chat community: prestonv_
What excites you most about Klavrium?
“Treating CI/CD the way we treat the rest of the software we build — something that runs anywhere, not a locked proprietary platform with its own DSL”
Kavan Rasathe
Director of Cloud Engineering, Halcyon Investments
our chat community: kavancrysis
What excites you most about Klavrium?
“The team behind Klavrium. The engineers maintaining Klavrium are honestly some of the sharpest and most talented people I've ever worked alongside.”
Sebastian Okonkwo
Founder, Software Engineer, LeadWeaveAI
our chat community: sebok
What excites you most about Klavrium?
“Being able to run a Klavrium pipeline from anywhere”
Baran Çetinkaya
Platform Engineer, Shopwave
our chat community: platformbaran
What excites you most about Klavrium?
“Writing real code to design your CI/CD pipelines feels great!”
Thanapong Kittisakwattana
Software Engineer, Loop Company
our chat community: thanacode
What excites you most about Klavrium?
“The first is the Terminal UI (TUI) - you can move the cursor around, change focus and increase/decrease verbosity to pinpoint your problems. The second is the interactive terminal, where you get to intercept your pipeline mid-run.”
Mikkel Bjorn Andersen
Platform Engineer, Nordvik
our chat community: mbjorn
What excites you most about Klavrium?
“Writing pipelines and deployments as real programs on top of Docker unlocks a whole class of possibilities that felt out of reach before Klavrium.”
Elias Marchetti
Cloud Platform Advocate
our chat community: marchetti_dev
What excites you most about Klavrium?
“Over the last decade, I've spent my time studying how to make engineering teams faster and more effective. I can genuinely say that Klavrium is the next real leap forward in how we build and ship software.”
Owen Castile
Staff Engineer
our chat community: owen_9421
What excites you most about Klavrium?
“What excites me most is pairing Klavrium with AI applications and agentic workflows.”
Mira Solberg
DevOps Engineer, Northgate Works
our chat community: solberg_dev
What excites you most about Klavrium?
“Writing pipelines as real code, and honestly, an end to Push and Pray!”
Anne-Sophie Delacroix
Staff Engineer, Vantorios
our chat community: asod_
What excites you most about Klavrium?
“For me, Klavrium solves the everyday pain of workflow design: building CI/CD pipelines is slow, tedious, and genuinely hard to test well.”
Become a Commander
How it runs
Commanders serve rotating 12 month terms, which we call "batches". To put someone forward for the 2025 batch, just fill out the form below! (Yes, you can nominate yourself)
Klavrium offers SDKs across three distinct levels — Experimental, Community, and Official — and each one carries a different degree of feature parity and support. Thanks to our incredible community, a number of Klavrians have gone above and beyond to build their own Klavrium SDKs. Explore the community SDKs below.
Choose your Klavrium SDK
+Explore the SDKs below, and browse our documentation to dig deeper. Missing the one you need? Just tell us here
Official SDKs
Community SDKs
Experimental
Klavrium SDK Levels
The table below summarizes how the three SDK levels differ from one another.
+Ready to promote your SDK up to a Community SDK? Review the full requirements here
Official SDK
Community SDK
Experimental SDK
Support
Klavrium Team
Community (Forums)
—
Documentation
✅ Included
Community Supported
—
In Klavrium Repo
✅ Included
✅ Included
✅ Included
Klavrium Community SDK Maintainers
+We simply can't officially support every SDK the community dreams up, so we're truly honored to have Klavrians who are willing to build and maintain the Community SDKs on their own. Meet our Community SDK maintainers below! Interested in becoming a Klavrium Community SDK maintainer? Reach out to us at community@klavrium.io and tell us which SDK you'd like to help maintain.
+
Marcus Vane
Platform Engineer
Klavrium PHP Community SDK Maintainer
Ravi Chandran
VP of Developer Platform
Novadyne
Klavrium Rust Community SDK Maintainer
Theo Barnhart
Backend Developer
Klavrium Elixir Community SDK Maintainer
+Ecosystem
+
Come build with us
Meet, learn, and swap ideas with other developers and makers.
Klavrium ships its SDKs across three tiers: Experimental, Community, and Official. Each tier carries a different degree of feature parity and long-term support. We're grateful that so many Klavronauts have stepped up to build and share their own Klavrium SDKs. Browse the community SDKs listed further down this page.
Choose your Klavrium SDK
+Explore the SDKs listed here. browse our documentation to dig deeper. Can't find the SDK you need? Just tell us here
Official SDKs
Community SDKs
Experimental
Klavrium SDK Levels
The table that follows breaks down how each SDK tier compares against the others.
+Ready to promote your project from Experimental to a Community SDK? here
Official SDK
Community SDK
Experimental SDK
Support
Klavrium Team
Community (Forum)
—
Documentation
✅ Included
Community Supported
—
In Klavrium Repo
✅ Included
✅ Included
✅ Included
Klavrium Community SDK Maintainers
+We can't officially maintain every SDK developers ask for, so we're grateful to the Klavronauts who volunteer their time to build and look after the Community SDKs. Say hello to our Community SDK maintainers below! Want to become a Klavrium Community SDK maintainer yourself? Reach out to us at community@klavrium.io and tell us which SDK you would be excited to maintain.
+
Elena Marsh
Platform Engineer
Klavrium PHP Community SDK Maintainer
Tomas Halloran
Chief Technology Officer
Corvexis
Klavrium PHP Community SDK Maintainer
Owen Baxter
Systems Engineer
Klavrium PHP Community SDK Maintainer
+Community
+
Join the collective
Meet, learn, and trade ideas with fellow engineers and builders.
Klavrians come from every corner of the globe and carry a broad mix of skills and backgrounds. From newcomers taking their first steps with Klavrium to veteran Pipeline Leads who have shipped alongside us since day one, we pick up something new from our community every single day.
+Have a Klavrium story to tell? Fill out this form, and we'll reach out soon!
+
+
\ No newline at end of file
diff --git a/web/klavrium.example/reference/site/cr-site.js b/web/klavrium.example/reference/site/cr-site.js
new file mode 100644
index 0000000000000000000000000000000000000000..6b1128fd209cbbf8ee33d701cb25f31f9e7312cf
--- /dev/null
+++ b/web/klavrium.example/reference/site/cr-site.js
@@ -0,0 +1,126 @@
+/* cr-site.js — klavrium.example
+ *
+ * Self-authored (MIT). Contains no code, markup or copy from any original site.
+ *
+ * WHY THIS FILE EXISTS
+ * --------------------
+ * klavrium.example is an Astro static build with a small amount of bespoke
+ * vanilla JS that the offline build deleted. The controls still render and
+ * the CSS is intact, so the exact state class each interaction toggled is
+ * recoverable. A full census of the site's own _astro/*.css yields only ONE
+ * JS-driven state token, `is-open`, used by exactly two mechanisms:
+ *
+ * 1. Mobile navigation (every page). remaining wiring:
+ *