# What Types of Applications Can Dewy Deploy? A Complete Guide to Non-Kubernetes Workloads

> Dewy deploys binary apps supervised processes static assets and containerized apps with zero downtime rolling updates Explore its capabilities for nonKubernetes workloads

- Repository: [Tomohisa Oda/dewy](https://github.com/linyows/dewy)
- Tags: getting-started
- Published: 2026-03-06

---

**Dewy can deploy three types of applications in non-Kubernetes environments: binary (server) applications as supervised processes, static assets like HTML and CSS, and containerized applications with zero-downtime rolling updates.**

Dewy is an open-source deployment tool designed by [linyows/dewy](https://github.com/linyows/dewy) to simplify application delivery without requiring Kubernetes infrastructure. Understanding what types of applications Dewy can deploy helps teams choose the right deployment strategy for their specific workloads, whether running compiled binaries, serving static content, or managing containerized services.

## Binary (Server) Applications

Dewy handles **binary (server) applications** by running compiled executables as supervised processes. While primarily designed for Go binaries, the tool can manage any executable file. According to the source code in [`dewy.go`](https://github.com/linyows/dewy/blob/main/dewy.go), Dewy polls the configured registry for new versions, downloads artifacts when updates are detected, and manages the process lifecycle.

The implementation in [`cli.go`](https://github.com/linyows/dewy/blob/main/cli.go) defines the `server` subcommand, which accepts the binary path as an argument. Dewy monitors the process health and automatically replaces the running binary when a newer version appears in the registry, ensuring continuous availability without manual intervention.

```bash
dewy server \
  --registry ghr://linyows/myapp \
  -p 8000 -l info \
  -- /opt/myapp/current/myapp

```

## Static Assets

For **static assets**, Dewy provides a dedicated `assets` command that manages files such as HTML, CSS, JavaScript, and images. This mode is ideal for frontend applications or documentation sites that require simple file distribution without process management.

The asset deployment logic, implemented in the codebase, copies the latest artifact from the configured registry into a specified target directory. As documented in the repository, Dewy continuously monitors the registry and updates the files when new versions are published, maintaining an up-to-date static file server.

```bash
dewy assets \
  --registry ghr://linyows/frontend \
  -d /var/www/html \
  -l info

```

## Containerized Applications

Dewy supports **containerized applications** using Docker-compatible images from registries including Docker Hub, GitHub Container Registry (GHCR), Google Artifact Registry (GAR), and Amazon ECR. This mode provides zero-downtime rolling updates with health checks and replica management.

The container deployment implementation spans several key files: [`container/docker.go`](https://github.com/linyows/dewy/blob/main/container/docker.go) handles Docker-specific operations, [`container/podman.go`](https://github.com/linyows/dewy/blob/main/container/podman.go) provides Podman runtime support, and [`artifact/oci.go`](https://github.com/linyows/dewy/blob/main/artifact/oci.go) manages OCI image pulling. According to the source code in [`dewy.go`](https://github.com/linyows/dewy/blob/main/dewy.go), Dewy orchestrates rolling updates by starting new containers, performing health checks, and routing traffic before terminating old instances.

Advanced features include blue/green deployment slots configured via [`config.go`](https://github.com/linyows/dewy/blob/main/config.go), allowing parallel running instances for safer releases.

```bash
dewy container \
  --registry img://ghcr.io/linyows/myapp \
  --port 8080 --health-path /health --replicas 3 \
  -- -e DATABASE_URL=postgres://db:5432/mydb -v /data:/app/data

```

## Blue/Green Deployment Support

All three application types support **blue/green deployment strategies** through the `--slot` flag. This feature, defined in [`cli.go`](https://github.com/linyows/dewy/blob/main/cli.go) and managed via [`config.go`](https://github.com/linyows/dewy/blob/main/config.go), allows running two parallel instances of the same application (designated as "blue" and "green") to facilitate safe cutover and rollback procedures.

```bash

# Blue instance

dewy server --registry ghr://linyows/myapp --slot blue -- /opt/myapp/current/myapp

# Green instance

dewy server --registry ghr://linyows/myapp --slot green -- /opt/myapp/current/myapp

```

## Summary

Dewy provides a unified deployment solution for non-Kubernetes environments across three distinct application categories:

- **Binary applications**: Supervised process management for compiled executables, primarily Go binaries, with automatic restarts and version updates
- **Static assets**: File-based deployment for HTML, CSS, JavaScript, and images with continuous synchronization to target directories
- **Containerized applications**: Docker and Podman support with zero-downtime rolling updates, health checks, replica management, and blue/green deployment slots

The tool consolidates these capabilities in a single CLI interface defined in [`cli.go`](https://github.com/linyows/dewy/blob/main/cli.go), with core orchestration logic in [`dewy.go`](https://github.com/linyows/dewy/blob/main/dewy.go) and specialized handlers for containers ([`container/docker.go`](https://github.com/linyows/dewy/blob/main/container/docker.go), [`container/podman.go`](https://github.com/linyows/dewy/blob/main/container/podman.go)) and artifacts ([`artifact/oci.go`](https://github.com/linyows/dewy/blob/main/artifact/oci.go)).

## Frequently Asked Questions

### Can Dewy deploy applications written in languages other than Go?

Yes. While Dewy is primarily designed for Go binaries, the `server` command can supervise any executable file. The tool manages the process lifecycle—starting, monitoring, and replacing the binary—regardless of the compilation source, as long as the target file is a valid executable for the host operating system.

### Does Dewy require Docker for all deployment types?

No. Dewy supports three distinct deployment modes that do not all require Docker. Binary applications run as native supervised processes, and static assets are managed as simple file copies. Only the `container` command requires a Docker-compatible runtime (Docker or Podman) to orchestrate containerized workloads.

### How does Dewy handle zero-downtime deployments for containers?

Dewy implements zero-downtime rolling updates through logic in [`container/docker.go`](https://github.com/linyows/dewy/blob/main/container/docker.go) and the core orchestrator [`dewy.go`](https://github.com/linyows/dewy/blob/main/dewy.go). When a new version is detected, Dewy starts new containers alongside existing ones, performs health checks via the configured `--health-path`, routes traffic to healthy instances, and only then terminates old containers. The `--replicas` flag controls the desired instance count during this process.

### What is the purpose of the blue/green slot feature?

The `--slot` flag enables blue/green deployment strategies by allowing two parallel instances of the same application to run simultaneously. Defined in [`cli.go`](https://github.com/linyows/dewy/blob/main/cli.go) and managed via [`config.go`](https://github.com/linyows/dewy/blob/main/config.go), this feature designates deployments as either "blue" or "green" slots, facilitating safe cutover procedures where traffic can be switched between environments instantly, and enabling quick rollbacks if issues are detected in the new version.