Developers · Dargo

What developer mode unlocks

By default, a Dargo machine is locked down — you install apps from the AppStore and that's it. The dargo system owns Docker, no shell access, no port forwarding for things you write yourself. Great for self-hosting Ghost or Nextcloud; deliberately limited if you're trying to ship something you wrote.

Turn on developer mode in the portal Settings and a new menu appears, with all of this:

SSH access — a devuser account (non-root, not in the docker group) gets created on the device. Bring your public key in the portal and you're in.
Browser terminal — a fully interactive terminal built into the portal. Useful when you don't have ssh handy. Right-click to paste.
Native app deploys — run Django, Flask, FastAPI, Laravel, Rails, Node, anything that listens on a port. Use systemd user services (linger is enabled automatically, so they survive reboots).
Developer proxies — pick a port on the device + a free subdomain (or a custom domain) and Dargo exposes it on the public internet over HTTPS. Same secure tunnel the AppStore apps use; no port forwarding, no router config, no IP exposure.
Custom Docker apps — upload a docker-compose.yml through the Develop page and Dargo runs it like any other AppStore app — private to your account, lives in the same Docker registry.

Works on both Hardware and BYOD

Same developer mode on both. If you bought a Dargo device, flipping the switch turns it into a fully-fledged personal VPS you happen to own. If you're on BYOD, you already do own the machine — developer mode just adds the tunnel + domain plumbing on top of what you'd normally have to set up yourself.

The dev-proxy quota is small for now (2 free proxies per account) — enough to ship a personal site or two.

Two ways to deploy

You have two paths to ship your own app on a Dargo machine. They both end up at the same place — your app on a public subdomain over HTTPS — but the workflow is different. Pick whichever feels closer to how you already work.

Developer Proxy. SSH in, run your app natively (like on any VPS), expose it through a developer proxy. Fast iteration, full Linux toolbox, no Docker required.
Custom Docker app. Build a Docker image, push it to a registry you control, upload a docker-compose.yml through the Develop page. Dargo manages the lifecycle — start, stop, update — just like an AppStore app.

Method 1 — Native deploy with a Developer Proxy (Flask example)

To show the workflow end-to-end. Replace Flask with whatever your stack is — the pattern's the same.

Enable developer mode + add your SSH key

Settings → toggle Developer mode → back to the device details page, in the new SSH & Terminal tab, paste your public key and click the Enable SSH button.

SSH in and set your app up like you would on a VPS

cd ~ && mkdir myflask && cd myflask python3 -m venv venv && source venv/bin/activate pip install flask gunicorn # write app.py … gunicorn -b 127.0.0.1:9000 app:app

Pick any port in the 9000–65535 range — that range is reserved for developer proxies.

Make it survive a reboot — write a systemd user service

cat > ~/.config/systemd/user/myflask.service << 'EOF' [Unit] Description=My Flask App [Service] ExecStart=/home/devuser/myflask/venv/bin/gunicorn -b 127.0.0.1:9000 app:app WorkingDirectory=/home/devuser/myflask Restart=always [Install] WantedBy=default.target EOF systemctl --user enable --now myflask

loginctl enable-linger devuser is set automatically when developer mode is enabled, so the service keeps running after you log out and survives reboots.

Expose it on the public internet

Scroll down to the Developer Proxies section, pick a subdomain and port, and click the Add Proxy button. Make sure the port you pick matches the one you set for your Flask app.

Your Flask app is live at https://<subdomain>.mydargo.com, certs auto-issued, no router changes needed. Want a custom domain? Add it in the proxy settings — CNAME instructions are generated for you.

Method 2 — Custom Docker app (same Flask, packaged)

If you'd rather build your app once and have Dargo manage it like any other AppStore app — install, update, start, stop from the portal — package it as a Docker image and upload a docker-compose.yml on the Develop page.

Write a Dockerfile for your app

FROM python:3.12-slim WORKDIR /app COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt COPY . . EXPOSE 5000 CMD ["gunicorn", "-b", "0.0.0.0:5000", "app:app"]

Bind to 0.0.0.0 inside the container so it's reachable from the host port mapping. The container's port is whatever your app listens on (here, 5000) — the host port comes from Dargo.

Push the image to a registry you control

Dargo doesn't host images for you at this time. Use any registry your device can pull from. Practical options:

GitHub Container Registry (GHCR) — free for public repos, easy to wire up with GitHub Actions so a git push rebuilds the image automatically.
Docker Hub — free for one private repo per account, generous public hosting (subject to pull-rate limits).
Self-hosted — Harbor, Gitea registry, or anything else that speaks the Docker Registry HTTP API.

docker build -t ghcr.io/yourhandle/myflask:latest . docker push ghcr.io/yourhandle/myflask:latest

If the image is private, the device will need credentials to pull it. SSH in once and run docker login ghcr.io as devuser — the auth survives reboots.

Write the compose file Dargo will run

The Develop page tells you the exact host port to use when you create the app. Substitute it where the example shows HOST_PORT.

services: web: image: ghcr.io/yourhandle/myflask:latest ports: - "HOST_PORT:5000" restart: unless-stopped environment: url: https://{{subdomain}}.mydargo.com

Placeholders like {{subdomain}} and {{custom_domain}} are filled in by Dargo at install time, so the same compose works whether the user picks a free subdomain or brings their own domain.

Upload + install

Develop → Create Custom App → paste the compose, give it a name, hit Create. Then install it on a device the same way you'd install an AppStore app: pick a subdomain, optionally a custom domain, Install.

Updates are a one-click action — push a new image tag, then hit Update on the device card. No re-uploading the compose, no SSH gymnastics.

What you can deploy

Anything that runs on Linux and listens on a port. The combinations that show up most:

Python: Django, Flask, FastAPI, Starlette — gunicorn or uvicorn behind the developer proxy
Node: Express, Next.js (custom server / static export), Hono, Fastify — bare node behind a systemd user service
PHP: Laravel, Symfony — php-fpm + nginx or just php artisan serve for staging
Ruby: Rails, Sinatra — Puma listening on a localhost port
Go / Rust / etc.: compile, drop the binary, systemd service it
Static sites: drop files in ~/www, point a tiny nginx/caddy at it, expose via dev proxy
Containerised apps: upload a docker-compose.yml on the Develop page — Dargo handles install + domain + tunnel for you

Security model

Non-root by default. The devuser account isn't in the docker group and can't sudo. AppStore apps stay isolated from your dev stack.
SSH key only. No password auth on the devuser account; you bring your public key, the portal pushes it to authorized_keys.
Outbound tunnel for everything. Dev proxies and AppStore apps share the same secure outbound tunnel. No open ports on your router; your home IP isn't exposed to visitors.
HTTPS automatic. Both *.mydargo.com subdomains and custom domains get auto-issued certs (Cloudflare-managed on the edge).

A VPS you actually own.