⌘ K
docker run → compose · ports · env · volumes · live

Turn docker run into docker-compose

Paste any docker run command and get a docker-compose.yml service ready to commit. Ports, environment, volumes, restart policy and network mode all carry across.

docker run → Compose
Input
103 B
1 lines
Output
207 B
13 lines
Status
ready
live
Ratio
2.01×
out/in
input · docker run command
output · docker-compose.yml
version: '3.8'

services:
  web:
    image: nginx:alpine
    container_name: web
    restart: unless-stopped
    ports:
      - "8080:80"
    environment:
      - DEBUG=true
    volumes:
      - ./data:/data
Quick Start

How the parser works

The command is tokenised with shell-style quoting, flag arguments are pulled into a structured service description, and the leftover positional argument becomes the image (with the rest as the command).

  1. 01

    Paste the command

    Multi-line commands with backslash continuations are supported.

    Parsing is strict-but-tolerant — comments and trailing commas are accepted on input where the source format historically permits them; output stays canonical.

    inputstricttolerantliveparse
    in · sourceshell · live
    docker run -d -p 8080:80 nginx
    loaded · parsedtarget · ready
  2. 02

    Flags collected

    -p, -e, -v, --name, --restart, --network and --privileged all map to known compose keys.

    Conversion preserves type information where the target supports it (numbers stay numeric, booleans stay boolean) so the destination parser never has to re-coerce.

    flagstype-preservinglosslesslivememoised
    flag · optionskey · live
    -p → ports
-e → environment
    options applied · liveround-trip
  3. 03

    Service emitted

    The service uses --name as its key if present, otherwise the image's repository name.

    Re-encoding is idempotent: running output back through the same converter produces the same bytes, which keeps round-trips git-friendly.

    yamlidempotentround-tripdiff-cleandeterministic
    service · convertedcompose · ready
    services:
  web:
    image: nginx
    converted · livediff-clean
  4. 04

    Copy or download

    Drop into docker-compose.yml and bring it up with docker compose up.

    Copy writes via navigator.clipboard.writeText; downloads use the target’s native MIME so editors apply the right syntax highlighting on open.

    exportclipboardtarget MIMEblobclient-side
    ✓ · copiedready · done
    ✓ Copied
    shipped · ready to shipsuccess
Pro tips

Converting between formats, safely

Pick the strictest source format

Lossy formats hide bugs. Choose JSON or YAML as your source-of-truth, convert downstream as needed.

Round-trip in CI

If your converter is idempotent, your CI can verify A → B → A equals the original. Catches subtle data loss.

Numbers vs strings differ

YAML/TOML have a number type; CSV doesn’t. Quote IDs in CSV to keep leading-zero values intact.

Watch character encoding

Source format may be Latin-1 / Windows-1252; target should be UTF-8. Convert encoding before structure.

Preserve comments where you can

YAML and TOML support comments. Don’t silently drop them — they often encode intent.

Schema-aware beats blind

Use a schema to guide conversion. Field types, required-ness, and defaults survive better with structure.

Related toolsENV to JSONJSON to ENVYAML to JSONINI to JSONOpenAPI v2 → v3HAR to cURL
Use Cases

When to convert

Production-isation, repeatable dev environments.

Productionise a one-off

Turn a quick docker run into a versioned compose service. Type information survives: numbers stay numeric, booleans stay boolean, strings stay strings. The destination parser doesn't have to re-coerce, which avoids the "'true' becomes "true"" bug class.

round-trip safe

Onboarding

Hand new devs a single docker compose up instead of a shell snippet. Run output back through the inverse converter to verify idempotent round-trips in CI. A → B → A should produce byte-identical input — if it doesn't, you've found data loss.

type-preserving

Reproducible bug repros

Capture exact run flags for a bug report. Comments and metadata survive where the target format supports them (YAML, TOML, HCL). The tool doesn't silently drop intent-encoded annotations, which keeps your config self-documenting.

schema-aware

CI parity

Mirror local docker run flags inside a CI compose file. Pair with a schema (JSON Schema, OpenAPI, Zod, Pydantic) to catch shape drift on either side. Catch breaking changes at conversion time rather than at runtime in production.

lossless

Multi-service expansion

Start with one service then layer dependencies into the same file. Output respects target-format conventions: quoting in CSV, indent in YAML, brackets in JSON. Existing parsers don't need patches, and the result drops into legacy pipelines unchanged.

diff-clean

Docs

Show the equivalent compose stanza next to a CLI example. Encoding-aware: handles UTF-8 vs UTF-16 vs Latin-1 / Windows-1252 transparently. The character-set surprise that breaks "works on my machine" doesn't apply here.

spec-grade
FAQ

Frequently asked questions

The common ones — ports, env, volumes, name, restart, network and privileged. Unknown flags with a value are skipped.
Top-level networks and volumes definitions aren't generated; add them manually if the service references them.
Yes — nginx:alpine is kept verbatim under image:.
Uses --name when provided, otherwise the image's last path segment (without the tag).
No. Parsing and YAML generation run locally in your browser.
Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

Sent straight to the maintainers · no account needed
47 in queue·8 shipped this month
Request queued. Thanks!