Open Source · MIT License

Deploy without
complexity

Define your services in a single onix.yaml. Onix translates it into Docker Compose for local dev or Kubernetes for production - no manifest files, no infra overhead.

onix.yaml
name: fullstack

services:
  proxy:
    build: ./proxy
    image: fullstack-proxy
    ports:
      - 80
    expose:
      - 80
    health: /
    depends_on: [frontend, backend]

  frontend:
    build: ./frontend
    image: fullstack-frontend
    ports:
      - 3000
    env:
      PORT: "3000"
      API_URL: "http://backend:4000"
    depends_on: [backend]

  backend:
    build: ./backend
    image: fullstack-backend
    ports:
      - 4000
    scale:
      min: 1
      max: 7
      target_cpu: 70
    resources:
      cpu_request: 100m
      cpu_limit: 500m
      memory_request: 64Mi
      memory_limit: 128Mi
    env:
      PORT: "4000"
      DATABASE_URL: "postgres://onix:${DB_PASSWORD}@db:5432/appdb"
    depends_on: [db]

  db:
    image: postgres:16-alpine
    ports:
      - 5432
    volumes:
      - db-data
    env:
      POSTGRES_DB: appdb
      POSTGRES_USER: onix
      POSTGRES_PASSWORD: ${DB_PASSWORD}

volumes:
  db-data:
    mount: /var/lib/postgresql/data
How it works

From config to cluster
in three steps

No YAML sprawl. No Helm charts. No compose file juggling.
One declarative config, two deployment targets.

01 - INIT

Scaffold your project

Run onix init to generate an onix.yaml interactively. Language is auto-detected - Dockerfile included if needed.

$ onix init
02 - DEPLOY

Deploy to any target

One command deploys locally with Docker Compose or to a Kubernetes cluster. Same config, different runtime flag.

$ onix up
$ onix up --runtime k8s
03 - MANAGE

Scale and monitor

Check status, stream logs, scale replicas, or open the web dashboard - all without touching the underlying runtime.

$ onix status
$ onix scale api 3
Features

Everything you need,
nothing you don’t

Onix is intentionally focused. It handles the hard parts of deployment without growing into a platform.

Single config format

One onix.yaml drives both Docker Compose and Kubernetes. No format translation, no duplication between environments.

Two runtimes, zero lock-in

Switch between Docker Compose and Kubernetes with a flag. Develop locally, deploy to production - same workflow throughout.

Built-in autoscaling

Declare scale.min, max, and target_cpu. Onix creates and manages the Kubernetes HPA automatically - no kubectl required.

Auto Dockerfile generation

No Dockerfile? Onix detects Go, Node, Python, Ruby, and Java and generates one for you on first deploy. Just point to your source.

Web dashboard

A real-time dashboard for service health, CPU, memory, replica counts, and logs. Run onix ui to open it - embedded in the binary.

CLI-first workflow

Deploy, scale, tail logs, and inspect metrics without leaving the terminal. Every lifecycle operation is one command away.

Runtimes

Compose for dev.
Kubernetes for production.

Same config. Onix adapts to your target environment and handles the translation transparently.

Docker Compose

Local & dev environments

No cluster required. Builds images locally. Ideal for development, CI, and single-host deployments.

  • Images built locally with docker build
  • Uses scale.min for replica count
  • State persisted to ~/.onix/apps/
  • No cloud or cluster dependency
  • Generate docker-compose.gen.yml for manual use
Kubernetes

Production & staging

Requires kubectl and a running cluster. Creates Deployments, Services, HPAs, and PVCs from your config.

  • Creates HPA with min/max/target_cpu
  • Resource requests and limits applied
  • Scoped to onix-<app-name> namespace
  • Supports --kube-context for multi-cluster
  • Generate k8s-manifests.gen.yml for review
CLI

Every operation
in one command

Onix wraps Docker Compose and kubectl so you never need to know both. One interface, any backend.

Status at a glance
onix status shows replicas, health state, and uptime across all services simultaneously.
Log streaming
Follow logs from any service with onix logs api -f - works identically with both runtimes.
Safe scaling
Onix warns before overriding autoscaling. Restore original HPA config with onix scale api auto.
zsh - my-app
onix up
  Building api...
  ✓ Deployed my-app (2 services)
onix status
  SERVICE  REPLICAS  STATUS   UPTIME
  api      1/1       healthy   2m
  db       1/1       healthy   2m
onix scale api 3
  Scaled api to 3 replicas
onix logs api -f
  api | Server listening on :3000
  api | GET /healthz 200 0ms

Start deploying
in minutes

Build once. Deploy anywhere. Onix handles the runtime so you can focus on your application, not your infrastructure.