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

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 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, Dewy polls the configured registry for new versions, downloads artifacts when updates are detected, and manages the process lifecycle.

The implementation in 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.

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.

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 handles Docker-specific operations, container/podman.go provides Podman runtime support, and artifact/oci.go manages OCI image pulling. According to the source code in 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, allowing parallel running instances for safer releases.

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 and managed via config.go, allows running two parallel instances of the same application (designated as "blue" and "green") to facilitate safe cutover and rollback procedures.

# 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, with core orchestration logic in dewy.go and specialized handlers for containers (container/docker.go, container/podman.go) and artifacts (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 and the core orchestrator 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 and managed via 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}