Where do generated Podman Quadlet files go on Linux?

Place rootless unit files in ~/.config/containers/systemd/ and run systemctl --user daemon-reload. Place rootful system-wide units in /etc/containers/systemd/ and run sudo systemctl daemon-reload.

Why does systemctl enable fail on a Quadlet .container service?

Quadlet services are generated dynamically by podman-system-generator on each daemon-reload, which marks them as transient generated units. Instead of running systemctl enable, include an [Install] section with WantedBy=default.target so systemd starts the container automatically at boot or login.

Does QuadletGen upload my Compose YAML or environment secrets?

No. Parsing, unit file synthesis, secret separation, and ZIP archive assembly run entirely in browser JavaScript with zero server requests.

How do containers in the same Compose stack resolve each other by hostname?

Enable the shared network option to generate a dedicated .network file and attach each .container unit to it. Podman configures netavark and aardvark-dns on that bridge so services resolve peer container names.

Podman 4.4+ systemd Quadlet podman-system-generator compatible

Docker Compose to Podman Quadlet Converter

Convert multi-service compose.yaml files or container CLI commands into native Podman 4.4+ Quadlet systemd unit files inside your browser. Inspect every generated .container, .network, .volume, and .env file before downloading a deployment archive.

Compose -> Quadlet Cheat Sheet Architecture Notes Deployment FAQ Specialized Generators

1-Click Stack Quick-Load Zero server uploads. Runs locally in browser memory.

Sample Stack Template

Stack Name Prefix

Install Scope

SELinux Mounts

AutoUpdate=registry Generate shared .network Extract secrets to .env

Drop compose.yaml / .txt here or browse .yml .yaml .txt

Detected mode: compose-yaml | Generated units: 6 (3 services) | Target directory: ~/.config/containers/systemd/

3 .container units .network DNS: webapp.network (aardvark-dns) 2 .volume units Install path: ~/.config/containers/systemd/

Compose YAML or Docker / Podman Run Input Mode: compose-yaml

services:
  web:
    image: node:22-alpine
    working_dir: /srv/app
    command: ["node", "server.js"]
    ports:
      - "3000:3000"
    volumes:
      - ./app:/srv/app
    environment:
      NODE_ENV: production
      DATABASE_URL: postgres://appuser@postgres:5432/appdb
      REDIS_URL: redis://redis:6379/0
      SESSION_SECRET: s3cr3t-session-signing-value
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
    restart: unless-stopped

postgres:
    image: postgres:16-alpine
    volumes:
      - postgres-data:/var/lib/postgresql/data
    environment:
      POSTGRES_USER: appuser
      POSTGRES_DB: appdb
      POSTGRES_PASSWORD: strong-postgres-password
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U appuser -d appdb"]
      interval: 10s
      retries: 5
    restart: unless-stopped

redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes
    volumes:
      - redis-data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      retries: 5
    restart: unless-stopped

volumes:
  postgres-data:
  redis-data:

Generated Quadlet systemd Units

# === web.container (~/.config/containers/systemd/web.container) ===
[Unit]
Description=webapp web container
Wants=network-online.target
After=network-online.target
After=webapp-network.service
After=postgres.service
Requires=postgres.service
After=redis.service
Requires=redis.service

[Container]
Image=docker.io/library/node:22-alpine
ContainerName=web
Network=webapp.network
WorkingDir=/srv/app
Exec=node server.js
PublishPort=3000:3000
Volume=./app:/srv/app
Environment=NODE_ENV=production
Environment=DATABASE_URL=postgres://appuser@postgres:5432/appdb
Environment=REDIS_URL=redis://redis:6379/0
Environment=SESSION_SECRET=s3cr3t-session-signing-value

[Service]
Restart=always
TimeoutStartSec=900

[Install]
WantedBy=default.target

# === postgres.container (~/.config/containers/systemd/postgres.container) ===
[Unit]
Description=webapp postgres container
Wants=network-online.target
After=network-online.target
After=webapp-network.service

[Container]
Image=docker.io/library/postgres:16-alpine
ContainerName=postgres
Network=webapp.network
Volume=postgres-data.volume:/var/lib/postgresql/data
Environment=POSTGRES_USER=appuser
Environment=POSTGRES_DB=appdb
Environment=POSTGRES_PASSWORD=strong-postgres-password
HealthCmd=pg_isready -U appuser -d appdb
HealthInterval=10s
HealthRetries=5

[Service]
Restart=always
TimeoutStartSec=900

[Install]
WantedBy=default.target

# === redis.container (~/.config/containers/systemd/redis.container) ===
[Unit]
Description=webapp redis container
Wants=network-online.target
After=network-online.target
After=webapp-network.service

[Container]
Image=docker.io/library/redis:7-alpine
ContainerName=redis
Network=webapp.network
Exec=redis-server --appendonly yes
Volume=redis-data.volume:/data
HealthCmd=redis-cli ping
HealthInterval=10s
HealthRetries=5

[Service]
Restart=always
TimeoutStartSec=900

[Install]
WantedBy=default.target

# === webapp.network (~/.config/containers/systemd/webapp.network) ===
[Unit]
Description=webapp shared Podman network

[Network]
NetworkName=webapp

# === postgres-data.volume (~/.config/containers/systemd/postgres-data.volume) ===
[Unit]
Description=postgres-data Podman volume

[Volume]
VolumeName=postgres-data

# === redis-data.volume (~/.config/containers/systemd/redis-data.volume) ===
[Unit]
Description=redis-data Podman volume

[Volume]
VolumeName=redis-data

systemd Deployment & Reload Commands

mkdir -p ~/.config/containers/systemd
systemctl --user daemon-reload && systemctl --user start web.service postgres.service redis.service
systemctl --user status web.service postgres.service redis.service
loginctl enable-linger $USER

Syntax Mapping Reference

Compose Key -> Quadlet Directive Cheat Sheet

Reference how Docker Compose service fields and container run flags compile into declarative Podman Quadlet systemd sections.

Compose Key / CLI Flag	Unit Section	Quadlet Directive	Linux systemd Behavior
services.<app>.image	[Container]	Image=docker.io/library/...	Use a fully qualified registry host when AutoUpdate=registry is enabled.
ports: ["8080:80"] / -p	[Container]	PublishPort=8080:80	Repeats once per published host port; supports bind IP and /udp protocol suffixes.
volumes: ["./data:/data"] / -v	[Container] + .volume	Volume=/srv/data:/data:Z	Named volumes map to <name>.volume units; bind mounts append :z or :Z on SELinux hosts.
environment / env_file / -e	[Container]	Environment= / EnvironmentFile=	Sensitive password, token, and key entries extract into <stack>.env with chmod 600.
depends_on	[Unit]	After=<dep>.service + Requires=	Starts PostgreSQL, MariaDB, and Redis units before dependent web or worker units.
networks (or stack default)	[Container] + .network	Network=<stack>.network	Creates an aardvark-dns bridge so peer containers resolve each other by service name.
restart: unless-stopped	[Service] + [Install]	Restart=always + WantedBy=	systemd restarts crashed containers and launches units on boot or user linger.
healthcheck.test / interval	[Container]	HealthCmd= / HealthInterval=	Translates CMD and CMD-SHELL probes along with retries, timeout, and start_period.
devices / cap_add / user	[Container]	AddDevice= / AddCapability= / User=	Passes /dev/dri GPU render nodes and scoped Linux capabilities without --privileged.
io.containers.autoupdate	[Container]	AutoUpdate=registry	Works with podman-auto-update.timer to pull newer image digests and roll services.

Quadlet conversion architecture notes

01
Podman 4.4 and newer include podman-system-generator, which compiles declarative .container, .network, and .volume files into transient systemd services during daemon-reload.
02
Compose depends_on entries translate to systemd [Unit] After= and Requires= directives so PostgreSQL, MariaDB, and Redis containers start before application workers.
03
Rootless units live in ~/.config/containers/systemd/ and run under your unprivileged user session via systemctl --user without a root daemon.
04
Named volumes from top-level Compose volumes blocks become dedicated .volume Quadlet files referenced by unit name in Volume= directives.

Frequently asked questions

Where do generated Podman Quadlet files go on Linux?: Place rootless unit files in ~/.config/containers/systemd/ and run systemctl --user daemon-reload. Place rootful system-wide units in /etc/containers/systemd/ and run sudo systemctl daemon-reload.
Why does systemctl enable fail on a Quadlet .container service?: Quadlet services are generated dynamically by podman-system-generator on each daemon-reload, which marks them as transient generated units. Instead of running systemctl enable, include an [Install] section with WantedBy=default.target so systemd starts the container automatically at boot or login.
Does QuadletGen upload my Compose YAML or environment secrets?: No. Parsing, unit file synthesis, secret separation, and ZIP archive assembly run entirely in browser JavaScript with zero server requests.
How do containers in the same Compose stack resolve each other by hostname?: Enable the shared network option to generate a dedicated <stack>.network file and attach each .container unit to it. Podman configures netavark and aardvark-dns on that bridge so services resolve peer container names.

Focused Workflows

Jump directly to a pre-configured QuadletGen preset for SELinux bind mounts, single-command CLI conversion, AutoUpdate timers, or multi-service self-hosted stacks.

AutoUpdate + systemd

Podman Quadlet Generator for Declarative systemd Services

Interactive Podman Quadlet generator for declarative systemd services. Configure AutoUpdate=registry, health checks, rootless paths, and .env files.

Open Quadlet Generator ->

CLI Flag Parser

Docker Run and Podman Run to Quadlet Converter

Paste any docker run or podman run command into this Podman run to Quadlet converter to generate clean .container systemd units with ports and mounts.

Open Docker Run to Quadlet ->

SELinux :z / :Z Mounts

Rootless Podman Quadlet Volume and SELinux Label Generator

Configure rootless Podman Quadlet volume z and Z bind mount labels for Fedora, RHEL, Bluefin, and CoreOS without permission denied container errors.

Open Rootless & SELinux ->

Self-Hosted Stacks

Podman Quadlet Examples for Immich, Nextcloud, and Vaultwarden

Ready-to-deploy Podman Quadlet Docker Compose examples for Immich, Nextcloud, Vaultwarden, and Postgres stacks with shared DNS networks and volumes.

Open Self-Hosted Templates ->

Multi-Unit ZIP Bundle

Podlet Online Multi-Container Quadlet Network and ZIP Packager

Run a Podlet online workflow in your browser without Cargo or Rust. Package Compose stacks into linked .container, .network, .volume, and .env ZIPs.

Open Podlet Online Packager ->

Architecture & Dry-Run Guide

QuadletGen Conversion Rules and systemd Dry-Run Verification

Review how QuadletGen synthesizes .container, .network, .volume, and .env units locally and how to verify syntax with podman/quadlet --dryrun.

Read architecture guide ->

How QuadletGen compares with containers/podlet CLI and Podman Desktop

Choose the right workflow for converting Compose stacks and container commands into Podman systemd units.

Capability	QuadletGen (Web)	containers/podlet CLI	Podman Desktop
Host setup required	Zero installation in any browser	Rust Cargo build, distro package, or container image	Desktop GUI plus local Podman machine and extension
Multi-file stack preview	Live unit tabs, combined view, and one-click .zip bundle	Writes separate files to disk or stdout per CLI run	Inspects running local pods or containers one by one
Shared .network synthesis	Automatic <stack>.network generation on toggle	Converts declared Compose networks via CLI flags	Depends on existing local Podman network state
SELinux :z and :Z volume toggle	Instant switch across none, shared :z, and private :Z	Manual volume string editing in input YAML or flags	Manual edit after generating the unit file
Secret .env extraction	Extracts sensitive keys into <stack>.env with EnvironmentFile=	Preserves inline environment entries unless pre-split	Inline Environment= lines by default
Data privacy	100% client-side JavaScript with zero server uploads	Local binary execution	Local desktop execution