Which runtimes are supported?

Nine: Node.js, Python, Go, Rust, Ruby, Java, Deno, Bun, and static Nginx. Each preset ships a sensible multi-stage layout — a `builder` stage that installs dependencies (and compiles where relevant) and a `final` stage that copies the build artefacts into a smaller runtime image.

What does the matching docker-compose.yml contain?

A single `app` service that builds from the current directory, maps the final-stage EXPOSE port to the host, applies the environment variables you entered, and adds a `healthcheck:` block if you enabled one. It is intentionally minimal — just enough for `docker compose up` to bring the service online without hand-writing the build context or port mapping.

Why does the healthcheck show up in both files?

The Dockerfile `HEALTHCHECK` directive is what the Docker daemon uses to mark the container unhealthy; the compose `healthcheck:` block does the same thing when the container is started via Compose. Keeping the command, interval, timeout, and retries identical in both places ensures the container is marked unhealthy the same way regardless of how it is run.

Is anything uploaded?

No. Stage configuration, environment variables, and the generated Dockerfile and compose file are all produced in your browser; nothing you enter is sent to a server.

Dockerfile Builder

Generate production-ready Dockerfiles with multi-stage builds, .dockerignore, and companion Compose — all in your browser.

Dockerfile Compose Run → Compose

Configuration

Select language, base image, and core build settings

Runtime

Base Image Version

Multi-Stage Build

Smaller final images

Add Healthcheck

Shell-form CMD

Quick insert RUN

Build Stages

Configure build and final image stages

builder

Intermediate

Base Image

Working Directory

COPY before RUN (one per line; use --from=stage src dest)

RUN Commands (one per line)

COPY after RUN (source after deps install)

final

Final

Base Image

Working Directory

COPY before RUN (one per line; use --from=stage src dest)

RUN Commands (one per line)

COPY after RUN (source after deps install)

EXPOSE Port

CMD

ENTRYPOINT (optional)

Run as Non-Root User

Alpine/Debian-aware (nodejs)

Environment

Build ARGs

Optional build-time args

LABELs

e.g. org.opencontainers.image.source

Best practices

Multi-stage keeps build tools out of the final image.
Non-root USER improves container security.
Dependency files are copied before source for better layer caching.

Generated Files

# Generated by DevTools Dockerfile Builder — https://www.devtools.tools/dockerfile-builder

# Build stage
FROM node:20-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY . .

# Runtime stage
FROM node:20-alpine

WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/package*.json ./
COPY --from=builder /app .

ENV NODE_ENV=production

EXPOSE 3000

RUN addgroup -g 1001 -S nodejs && adduser -S nodejs -u 1001 -G nodejs
USER nodejs

CMD ["node", "server.js"]

Service Worker Generator: Cache Strategies for PWAs

Generate cache-first, network-first, or stale-while-revalidate service worker scripts with precache lists and registration snippets — entirely in your browser.

From docker run to docker-compose.yml: Converting One-Off Commands into Versioned Files

Why a checked-in Compose file beats a one-liner in your shell history, the exact flag-to-key mapping the converter uses, and the gotchas worth knowing when you migrate.

.env Secret Safety Linter

Validate .env syntax and spot likely leaked credentials or placeholder secrets.

.htaccess Generator

Build an Apache .htaccess — HTTPS redirects, rewrites, error pages, security headers, and basic auth

2D Fluid Dynamics & Particle Physics Sandbox

A physics playground with two engines sharing one canvas. The fluid mode runs a real Eulerian Navier-Stokes solver — semi-Lagrangian advection, explicit diffusion, Jacobi pressure projection and vorticity confinement — that you paint with dye and velocity using mouse or touch. The particle mode is a damped Verlet N-body engine with gravity wells, Coulomb attractors and repulsors, spring links, wall restitution and elastic circle collisions. Particle counts adapt to the device (100k target on WebGL2 desktop, 2k-5k on CPU fallback), and every configuration exports as runnable code: a Matter.js world, a PixiJS ticker setup, or a standalone vanilla Canvas engine.

AI Function Calling Schema Generator

Generate function calling JSON schemas from TypeScript interfaces

Algorithm Arena & Data Structure Visualizer

Interactive arena for algorithms and data structures: eight sorting algorithms racing on one seeded input, six pathfinding algorithms walking generated mazes, and BST, AVL, Red-Black, B-tree, heap and trie operations replayed step by step with rotations highlighted. Every run shows the Big-O table and the phase-highlighted reference implementation in four languages, and compared values can be played as pitch (sonification) through the shared audio engine. Everything runs client-side; inputs never leave the browser.

Ansible Playbook Generator

Build an Ansible playbook — hosts, vars, and tasks with modules — as YAML