Portainer Skunkworks

Things we built because we could.

Free tools from the Portainer engineering team. Each one solves a real problem we kept running into. None of them are on the product roadmap. All of them are open source.

These tools carry no support SLA, no guaranteed update cadence, and no roadmap commitment. If something breaks, raise a GitHub issue. If something is useful, tell us... we might build more. KubeSolo is proof that we do.
01 — Active
D2K
github.com/portainer/d2k
Open Source
Free

Platform engineering teams are increasingly running shared Kubernetes clusters, but most application developers still think in Docker. D2K bridges that gap. It presents a synthetic Docker API endpoint that translates incoming Docker CLI commands and API calls into the equivalent Kubernetes operations on a shared cluster... letting developers work exactly as they always have, without touching a kubeconfig.

The result is a clean separation: developers get the Docker workflow they know, platform teams keep full Kubernetes control. No retooling of CI pipelines. No Kubernetes training for every developer on the floor.

Target Audience
Platform Engineering teams delivering internal developer platforms on shared Kubernetes clusters
How It Works
Exposes a Docker-compatible HTTP API. Translates calls to Kubernetes Pod and Deployment operations at runtime
Language
Go
Cluster Compatibility
Any conformant Kubernetes distribution: EKS, AKS, GKE, KubeSolo, bare metal
# Developer runs this on their laptop — no Kubernetes knowledge required docker -- host tcp://d2k.internal:2375 run -d nginx docker --host tcp://d2k.internal:2375 ps # D2K translates both calls into Kubernetes Deployments on the shared cluster
02 — Active
Portainer Run
Self-hosted Cloud Run UX
Open Source
Free

Developers who have used Google Cloud Run know the experience: point at a container image, get a URL, done. Portainer Run delivers that same screen-by-screen workflow, self-hosted on your own Kubernetes cluster via the Portainer API. No Google account. No egress costs. No data leaving your infrastructure perimeter.

It's not a wrapper around Cloud Run. It's a UI that replicates that serverless container experience using Kubernetes primitives under the covers... giving internal developers the simplicity of a managed cloud platform without the dependency on one.

Target Audience
Internal developers who need a simple, self-service way to deploy containers without cloud access
How It Works
Web UI modelled on Google Cloud Run. Calls the Portainer API to manage deployments on Kubernetes
Prerequisite
A running Portainer instance with a connected Kubernetes environment
Infrastructure
Fully self-hosted. No outbound cloud dependency required
# Portainer Run calls the Portainer API on the developer's behalf POST /api/endpoints/{id}/kubernetes/namespaces/{ns}/deployments { "image": "myapp:latest", "replicas": 1, "expose": true } # Developer sees: a Cloud Run-style form, a progress bar, and a live URL
03 — Active
Krill
Native iOS & Android for Portainer
Free
Open Source

Portainer's web UI works in a mobile browser, but that's not the same as a native app. Krill is a native iOS and Android application for Portainer... built for engineers who are on call, on the factory floor, or just away from a desk when something needs attention.

Connect to any Portainer instance, monitor environment health, inspect containers and stacks, and take action when you need to. The same Portainer API that powers the web UI powers Krill. Everything you can see in the browser, you can see on your phone.

Platforms
iOS (App Store) and Android (Google Play)
Connects To
Any Portainer CE or BE instance accessible from the device. Supports multiple instances
Authentication
Portainer username/password or API token
Cost
Free. No in-app purchases. No subscription.
# Krill talks directly to the Portainer REST API GET /api/endpoints # list environments GET /api/endpoints/{id}/docker/containers/json # list containers POST /api/endpoints/{id}/docker/containers/{cid}/restart # restart
04 — Graduated
KubeSolo
kubesolo.io
Graduated to Product
Open Source
KubeSolo started here as a Skunkworks experiment. It now has its own dedicated site, its own product page, and an active development roadmap. This is what graduation looks like.
See the full product page.

The question was straightforward: why does running a single-node Kubernetes cluster still require so much operational ceremony? K3s, K0s, MicroK8s all work, but none were built with the Portainer operator in mind. KubeSolo is a single-node Kubernetes distribution built specifically for edge, IoT, and resource-constrained environments, and packaged to integrate natively with Portainer from day one.

It ships as a single binary. No kubeadm, no etcd cluster, no control-plane setup. Just Kubernetes on a single node, managed through Portainer. What started as a Skunkworks experiment to answer one question became a standalone project with its own community and a clear roadmap.

Target Environments
Edge, IoT, OT — anywhere a full multi-node cluster is impractical but Kubernetes is needed
Distribution Model
Single binary. Minimal footprint. Integrates with Portainer out of the box
Status
Active development. Dedicated site at kubesolo.io. Full product support available
License
Open source. Free to use.
# Install and start KubeSolo on a Linux node curl -sfL https://get.kubesolo.io | sh - kubesolo start # Portainer agent connects and registers the node automatically # Manage it from Portainer like any other Kubernetes environment
What's next

We're building more.

If you're using one of these tools, or have a problem you think we should take a look at, we want to hear about it. The best Skunkworks projects start with a real operational problem nobody has properly solved.