Adminer is a full-featured database management tool that allows you to manage your MySQL, 
MariaDB and PostgreSQL databases with a web interface.


Adminer

Appsmith is an open-source, low-code platform for
building internal tools, admin panels, dashboards, and CRUD apps. Drag-and-drop
pre-built widgets, connect to any database or REST/GraphQL API, and wire up logic
with JavaScript anywhere. The all-in-one container bundles the backend, real-time
service, MongoDB, and Redis, so no external services are required.


Appsmith

This example shows how you can deploy an Astro app to any host with zero
configuration. It runs as a standalone Node server using the
[@astrojs/node](https://docs.astro.build/en/guides/integrations-guide/node/)
adapter and demonstrates static pre-rendering, server-side rendering,
`stale-while-revalidate` caching and built-in image optimization.

Live demo: https://astro.demo.dollardeploy.dev


Astro Boilerplate

Baserow is an open-source no-code database tool and Airtable alternative. It allows you to create custom databases, manage data, and build applications without the need for coding. Whether you're a beginner or an experienced developer, Baserow provides a user-friendly interface to manage your data and build powerful applications.

Baserow

Beszel is a simple, lightweight server monitoring platform that provides real-time
and historical metrics for your systems and containers. With a friendly web interface,
easy setup, and no need for public internet exposure, Beszel tracks CPU, memory, disk,
network, and temperature usage, and supports configurable alerts for system health.
Features include multi-user support, OAuth/OIDC authentication, automatic backups,
and a REST API for integration. The platform consists of a web-based hub and agents
that collect and report system metrics, making it ideal for secure, resource-efficient
infrastructure monitoring.


Beszel

A tiny, zero-dependency Bun web app that serves a single HTML page with Bun.serve.
Fork this repo and start building your own Bun app quickly. See https://bun.sh to learn more.


Bun Boilerplate

Cal.com is a scheduling infrastructure for everyone. It's an open source alternative to Calendly that allows you to schedule meetings efficiently and integrate with various calendar services.

Cal.com

#!/bin/bash
sed -e "s/- 3000:3000/- 127.0.0.1:\$PORT:3000/g" -i docker-compose.yml
sed -e "s/studio:/studio-optional:\n    profiles: [withstudio]/g" -i docker-compose.yml  


Cal.com old

#!/bin/bash
mkdir -p data
mkdir -p data/tmp
mkdir -p data/storage
mkdir -p data/postgres
mkdir -p data/redis
docker compose run --rm rails bundle exec rails db:chatwoot_prepare


Chatwoot is a customer support tool for instant messaging channels

Chatwoot

#!/bin/bash
docker compose run --rm rails bundle exec rails db:chatwoot_prepare


Chatwoot 3.16

Cobalt saves media from social platforms without ads, trackers, or paywalls.

This template runs both halves on one domain: the cobalt web frontend at `/`
(built from source at deploy time) and your own processing instance — the API
that does the actual work — on the same origin. Nothing is shared with
cobalt.tools, and any cobalt client can point at this domain directly.

Bandwidth, not CPU, is the limit: tunnelled downloads stream through your
server. Keep it to yourself, or turn on Cloudflare Turnstile
(`TURNSTILE_SITEKEY` + `TURNSTILE_SECRET`) before sharing the URL.

The frontend is licensed CC-BY-NC-SA-4.0 — unmodified non-commercial hosting
only, and cobalt branding stays copyrighted.


Cobalt

Cobalt saves media from social platforms without ads, trackers, or paywalls.
This template runs the **processing instance** — the API that does the work.
There's no web UI: point any cobalt frontend at it (cobalt.tools → settings →
instances → custom) or call it from your own scripts.

Want the frontend hosted on your server too? Deploy the **Cobalt** template
instead — it runs both on one domain.

An API key is generated on first boot and printed in the deploy logs. Keys
bypass rate limits, and can be made mandatory with `API_AUTH_REQUIRED=1`.

Bandwidth, not CPU, is the limit: downloads stream through your server.


Cobalt Instance

This template launches code-server, which is VS Code running on a remote server, accessible through the browser. It allows you to code on any device with a consistent development environment.

Code Server

CourseLit is a free and open-source learning management system (LMS) for online courses.
It is designed to be easy to use and customizable, making it a great choice for educators
and institutions looking to create and manage online courses.

CourseLit is built on top of the Codelit framework, which provides a powerful and flexible
platform for building web applications.


CourseLit

Crafty Controller is a free, open-source web-based control panel for managing
Minecraft servers — without the Pterodactyl-style wings/node setup.

From a single container you can:
- Create and run multiple servers: Vanilla, Paper, Spigot, Purpur, Forge, Fabric, and modpacks
- Auto-download server jars by type and version
- Use the built-in web console, file manager, and player management
- Schedule automated restarts and backups
- Watch live CPU/RAM and server status

Java servers use the 25500–25600 port range, Bedrock uses 19132/udp, and Dynmap
uses 8123 — all published so players can connect directly.


Crafty Controller

A boilerplate for building a Deno application
Fork this repo and start building your own app quickly.
This template is a simple Deno application that can be used as a starting point for building your own app.


Deno app boilerplate

#!/bin/bash
mkdir -p ./data/database
mkdir -p ./data/extensions
mkdir -p ./data/uploads
mkdir -p ./data/redis
sudo chown -R "$USER_UID:$USER_GID" ./data/extensions
sudo chown -R "$USER_UID:$USER_GID" ./data/uploads
sudo chown -R "$USER_UID:$USER_GID" ./data/redis


The flexible backend for all of your projects.
Turn your data into a headless CMS, admin panels, or apps with a custom UI, instant APIs, auth & more. Built for devs, used by everyone.


Directus

Discourse is the 100% open source discussion platform built for the next decade of the Internet. We make it easy to have meaningful conversations and collaborate anytime, anywhere. 


Discourse

Documenso is the open source signing infrastructure and a DocuSign
alternative. Upload documents, collect legally binding electronic signatures,
and manage signing workflows — all self-hosted. This template runs Documenso
with a PostgreSQL database and generates a local signing certificate on first
boot.


Documenso

Dozzle is a simple, lightweight web interface for monitoring Docker containers.
It provides a real-time view of all your containers, with detailed information
about each container's status, logs, and metrics.


Dozzle

Evo AI is an open-source platform for creating and managing AI agents, 
enabling integration with different AI models and services. 


EVO AI

EVO AI API

Evolution API is a messaging service that allows you to send and receive messages from your application,
compatible with WhatsApp, Chatwoot, and more.


Evolution API

This MCP server provides tools for interacting with Facebook Ads objects and data.


Facebook Ads MCP Server

ERPNext is a full-featured business management solution that helps SMEs
to record all their business transactions in a single system. With ERPNext, SMEs
can make informed, fact-based, timely decisions to remain ahead in the competition.
It serves as the backbone of a business adding strength, transparency, and control
to your growing enterprise.


Frappe - ERPNext

MCP Proxy with Frappe MCP Server provides a secure and efficient way to run Frappe MCP server
over SSE transport. It allows LLM clients like Claude Desktop to connect to Frappe
servers through a standardized interface.

The setup combines MCP Proxy for transport conversion and Frappe MCP Server for
handling MCP protocol communications, all in a single container solution.


Frappe CRM MCP Server

Ghost is a powerful app for professional publishers to create, share, and 
grow a business around their content. It comes with modern tools to build a 
website, publish content, send newsletters & offer paid subscriptions to members.


Ghost CMS

Gitea is a painless, lightweight, self-hosted Git service written in Go.
It provides repository hosting, issues, pull requests, a wiki, and CI hooks
while running comfortably on modest hardware.

This template runs Gitea backed by a PostgreSQL database. Repository and
database data are persisted to local volumes. Git over HTTPS works through the
app URL out of the box; Git over SSH is exposed on the host port SSH_PORT
(default 2222), which the deploy opens in the host firewall for you. A
firewall at your cloud provider still needs the rule added by hand.


Gitea

A boilerplate for building a Go application
Fork this repo and start building your own app quikly.
This template is a simple Go application that can be used as a starting point for building your own app.


Go app boilerplate

This template provides a server that can be used to serve Google Tag Manager metrics endpoint for your website. Make sure to set CONTAINER_CONFIG to the value provided by GTM.

Google Tag Manager Server

Run OpenAI’s open-sourced GPT-OSS models (117B / 21B) locally using Docker inside your own codebase.
This project avoids third-party GUIs like Open WebUI or LM Studio to help you learn how to
use GPT-based models directly in your applications.
Use **DataCrunch** servers 1xA100, 1xA6000 or 1xH100 to deploy this template.
Read more about this on our blog: https://docs.dollardeploy.com/blog/openai-gpt-oss/


GPT-OSS

Graylog is an open source log management platform. It collects, indexes, and
analyzes both structured and unstructured data, with powerful search, dashboards,
and alerting.

This template runs the official open-core stack (Graylog, a Graylog Data Node,
and MongoDB). The web UI is published on localhost behind the DollarDeploy
reverse proxy, and Graylog's external URI is set to your app URL so generated
links resolve correctly.

The password secret and the hashed admin password are generated during deploy
into a `.env.password` file (never committed) and injected into the containers
via Docker Compose's `env_file` directive.


Graylog Open

Hermes Agent is an open-source AI agent from Nous Research with a built-in
learning loop: it creates skills from experience, improves them during use,
keeps persistent memory and searches its own past conversations.

- Web dashboard to chat, manage config, API keys, skills, cron jobs and sessions
- Messaging gateway: Telegram, Discord, Slack, WhatsApp, Signal and more
- Built-in cron scheduler with delivery to any platform
- Subagents, MCP servers and a headless browser tool
- Any model: Nous Portal, OpenRouter, OpenAI, Anthropic or your own endpoint
- Connect Hermes Desktop to it as a remote backend

Runs the official `nousresearch/hermes-agent` image. Gateway and dashboard
are supervised in one container; all state lives in a persistent volume.

License: MIT. Source: https://github.com/NousResearch/hermes-agent


Hermes Agent

Simplify the management of your server with Homarr - a sleek, modern dashboard that puts all of your apps and services at your fingertips.


Homarr

Inngest is the orchestration engine for building agentic workflows and fully autonomous AI agents, powering products from experiment to production.
Develop reliable, fault-tolerant, and scalable AI applications with step-based workflows, built-in retries, observability, and instant local development.
Focus on your product, not infrastructure—Inngest provides the building blocks to ship AI features faster, with enterprise-grade reliability and security.


Inngest

A boilerplate for building a Java application
Fork this repo and start building your own app quikly.
This template is a simple Java application that can be used as a starting point for building your own app.


Java app boilerplate

Lithium is a batteries-included Django starter project with everything you need to start coding, including user authentication, static files, default styling, debugging, DRY forms, custom error pages, and more.
Fork this repo and start building your own app quikly. 


Lithium Python Boilerplate

Local AI is an open-source, self-hostable online OpenAI API compatible service with chatbot UI.

Local AI (CPU)

Local AI is an open-source, self-hostable online OpenAI API compatible service with chatbot UI. This template is compatible with server which have NVidia GPU with CUDA 12 configured. We tested it with DataCrunch provider in DollarDeploy, and it works well with GPU instances of type A6000 and better (1€/hr).

Local AI (NVidia CUDA 12)

[Mailpit](https://mailpit.axllent.org/) - email & SMTP testing tool with API for developers. 
Mailpit is a small, fast, low memory, zero-dependency, multi-platform email
testing tool & API for developers.
It acts as an SMTP server, provides a modern web interface to view & test
captured emails, and contains an API for automated integration testing


Mailpit

#!/bin/bash
sed -e "s/mattermost:/mattermost:\n    ports:\n      - '127.0.0.1:3005:8065'/g" -i docker-compose.yml
mkdir -p ./volumes/app/mattermost/{config,data,logs,plugins,client/plugins,bleve-indexes}
mkdir -p ./volumes/db/data
# 70 is the standard uid/gid for "postgres" in Alpine
# https://github.com/docker-library/postgres/blob/master/13/alpine3.20/Dockerfile
sudo chown -R 70:70 ./volumes/db
# Download config which enables uploads and focalboard plugin
curl -o ./volumes/app/mattermost/config/config.json https://gist.githubusercontent.com/huksley/5721e15687fc63e2a197749c4752d80f/raw/1506bb567305ca4fa33db231fb6ab20a091a75f6/mattermost-config.json
sudo chown -R 2000:2000 ./volumes/app/mattermost


Mattermost is a flexible, open source messaging platform that enables secure
team collaboration. It's a self-hosted alternative to proprietary SaaS
messaging and brings all your team communication into one place, making it
searchable and accessible anywhere.

This installation enables uploads and Focalboard plugin.


Mattermost

Maybe is an all-in-one personal finance platform. Track, optimize, grow, and manage your money through every stage of life.

Maybe Finance

MCDash is a lightweight and user-friendly dashboard for Minecraft servers.
It provides real-time monitoring of your server's performance, player statistics,
and server status. With a clean and intuitive interface, you can easily track
server metrics, manage players, and monitor resource usage.


MCDash

Version: v0.61.x. Fast analytics with the friendly UX and integrated
tooling to let your company explore data on their own.
Get your data in front of your team. Connect to your
data stack in 5 minutes to make queries, visualizations, and dashboards
easy for everyone—no SQL required.


Metabase

Provides UI to read RSS feeds. Minimalistic and easy to use, runs natively on your server.


Miniflux

MinIO is a high-performance, S3-compatible object storage solution released under the GNU AGPL v3.0 license. Designed for speed and scalability, it powers AI/ML, analytics, and data-intensive workloads with industry-leading performance. 
🔹 S3 API Compatible – Seamless integration with existing S3 tools 
🔹 Built for AI & Analytics – Optimized for large-scale data pipelines
🔹 High Performance – Ideal for demanding storage workloads.


MinIO

#!/bin/bash
mkdir -p data/n8n
mkdir -p data/n8n/.config
chmod 0700 data/n8n/.config
sudo chown 1000:1000 data/n8n
sudo chown 1000:1000 data/n8n/.config


n8n helps you connect any app with an API to any other, and manipulate its data with little or no code.
It's an easy-to-use, user-friendly and highly customizable service, which uses a visual workflow editor
instead of writing code.


This example nicely shows how you can deploy NextJS app to any host.

Next.js 16 Boilerplate

This example nicely shows how we can deploy NextJS apps to any host. It demonstrates using NextJS with Three.js, a lightweight, 3D library with a default WebGL renderer.

Next.js Example - Three.js

Free version of NextJS SaaS starter template. See more here https://nextjstemplates.com/templates/saas-starter-startup

Next.js Startup

The best way to start a full-stack, typesafe Next.js app. 
Fork this repo and start building your own app quikly. Or go to https://create.t3.gg to learn more about the T3 stack.


Next.js T3 app

Access your Data You can store your files, contacts, calendars, conversations and more on a server of your choosing.

Nextcloud

NodeBB takes the spirit and energy of the great online forum communities of old, and empowers it with powerful, mobile-ready and easy to use software. 


NodeBB

ntfy (pronounced "notify") is a simple, HTTP-based pub-sub notification
service. It lets you send push notifications to your phone or desktop from any
computer or script with a simple HTTP request, entirely without sign-up.

This template runs a self-hosted ntfy server. Cache, attachments, and the user
database are persisted to a local volume. By default the server is open
(read-write); set AUTH_DEFAULT_ACCESS to deny-all and create users with the
ntfy CLI to lock it down.


ntfy

# Builds OpenAGI from the upstream Dockerfile (the GHCR image is not public).
# DollarDeploy writes this file into the cloned openAGI repo, so the build
# context "." is the upstream source tree.
services:
  openagi:
    build:
      context: .
      dockerfile: Dockerfile
    restart: unless-stopped
    ports:
      # Loopback only: DollarDeploy's reverse proxy serves it over HTTPS.
      - "127.0.0.1:${PORT:-43210}:43210"
    volumes:
      - openagi-data:/data
    environment:
      HOST: 0.0.0.0
      PORT: 43210
      OPENAGI_DATA_DIR: /data
      # Required: the daemon refuses a non-loopback bind without a token.
      OPENAGI_AUTH_TOKEN: "${OPENAGI_AUTH_TOKEN:?OPENAGI_AUTH_TOKEN is required}"
      # Public HTTPS origin for Twilio/Telegram webhooks and node pairing.
      OPENAGI_PUBLIC_URL: ${OPENAGI_PUBLIC_URL:-}
      OPENAGI_DAILY_USD_LIMIT: ${OPENAGI_DAILY_USD_LIMIT:-10}
      # Model API keys are intentionally not passed here: an empty env var
      # would shadow the keys the setup wizard saves to /data/.env.
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://127.0.0.1:43210/health"]
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 10s

volumes:
  openagi-data:


OpenAGI is an always-on agent daemon. Instead of waiting for prompts, it
watches your activity, mines recurring routines, drafts skills for them and
reaches out with what it can take off your plate.

- Directional adaptive scrutiny: scores every signal and decides to act, ask, watch, ignore or propagate
- Tiered memory (short / medium / long-term) with condensing and decay
- Propagation: spawns bounded specialist sub-agents for repetitive work
- Chat UI, skills, MCP servers (stdio and HTTP+OAuth), cron and scheduled prompts
- Channels: HTTP, Telegram and Twilio SMS
- Bring your own LLM: Anthropic, OpenAI or any OpenAI Responses-compatible API

All state lives in a persistent volume on your server. Built from source at
the pinned release tag.

License: PolyForm Noncommercial 1.0.0 (source-available, free for
noncommercial use). Source: https://github.com/Spshulem/openAGI


OpenAGI

OpenClaw is a self-hosted AI assistant platform with built-in browser automation.
It supports multiple AI providers (Anthropic, OpenAI, OpenRouter, Gemini, xAI, Groq, Mistral, AWS Bedrock, Ollama, and more)
and integrates with messaging platforms like WhatsApp, Telegram, Slack, and Discord.

Includes a headless browser container for web automation tasks.


OpenClaw

OpenVPN is an open-source virtual private network (VPN) solution that 
creates secure point-to-point or site-to-site connections through
encrypted tunnels over the internet.

It masks your IP address and encrypts your internet traffic, helping you 
maintain anonymity online and preventing ISPs from monitoring your activities.


OpenVPN

The fastest knowledge base for growing teams. Beautiful, realtime collaborative, feature packed, and markdown compatible. 

Outline

Runs Outline Shadowsocks server with WebSockets support.  
Outline enables anyone to access the free and open Internet
more safely by running their own VPN. 
Running your own VPN server through Outline makes accessing
the Internet safer and establishes a connection that is harder to block.


Outline VPN with WebSockets

Paperless-ngx is a document management system that transforms your physical documents
into a searchable online archive so you can keep, well, less paper.

Includes PostgreSQL for storage, Valkey (Redis-compatible) for task queuing, and
Gotenberg + Apache Tika for full-text OCR and Office document conversion.


Paperless-ngx

From prehistoric to peak performance: Pelican takes flight! Pelican is the ultimate,
free game server control panel offering high flying security. It's a breeze to manage
your servers with our sleek and user-friendly interface. Thanks to Docker, every server
runs in its own safe space. Pelican is 100% free and open source—forever—for you,
your friends, family, and community. We support Minecraft, Terraria, Palworld, Valheim,
Factorio, and so much more. Whether you're just playing with friends or running a gaming
community, Pelican scales to the sky. Security is built in, with SSL, 2FA, AES-256
encryption, and more. One click installs, automatic updates, and an active community
make Pelican the best way to host your game servers.


Pelican

A boilerplate for building a PHP application
Fork this repo and start building your own app quickly.
This template is a simple PHP application that can be used as a starting point for building your own app.


PHP app boilerplate

Plane is an open-source project tracking tool for teams to plan, track, and manage software development

Plane

#!/bin/bash
sed -e "s/plausible:/plausible:\n    ports:\n      - '127.0.0.1:${PORT}:3000'/g" -i compose.yml


This template launches Plausible. It is a simple, lightweight web analytics. No cookies and GDPR compliant.

Plausible CE

Portainer Community Edition is a universal container management platform that
simplifies the deployment, configuration, and monitoring of containerized applications
across Docker, Kubernetes, Swarm, and Nomad environments. With its intuitive web-based interface,
Portainer enables users to manage containers, images, networks, and volumes effortlessly,
making it ideal for both beginners and experienced DevOps teams. It supports hybrid and
multi-cloud setups, edge, and Industrial IoT use cases, providing a centralized,
secure solution for container orchestration.


Portainer CE

PostHog is an all-in-one product analytics suite. Track events, understand user behavior
with session replays, run A/B tests, manage feature flags, and analyze funnels — all in
one platform. Self-host to keep full control of your data.
Requires at least **8GB RAM**. Uses PostgreSQL, ClickHouse, Redis, and Kafka.


PostHog

Pterodactyl is a modern, secure, and scalable game server anagement platform. 
Built with PHP, React, and Go, it isolates each game server in its own Docker container
to maximize security and stability. The web-based interface provides real-time
WebSocket consoles, role-based user access, a robust API, and SFTP file management.
Designed for both hobbyists and enterprises, it supports Minecraft, CS:GO, Rust, ARK, and more.


Pterodactyl

Pterodactyl Wings is Pterodactyl's server control plane, built for the rapidly changing
gaming industry and designed to be highly performant and secure. Wings provides
an HTTP API allowing you to interface directly with running server instances,
fetch server logs, generate backups, and control all aspects of the server lifecycle.


Pterodactyl Wings

A lightweight Python web application template using FastHTML, Python 3.11, and UV package manager.


Python Template

A boilerplate for building a Rust application
Fork this repo and start building your own app quikly.
This template is a simple Rust application that can be used as a starting point for building your own app.


Rust app boilerplate

RustFS is a high-performance, S3-compatible distributed object storage system
written in Rust. It is a fast, secure and cost-effective alternative to MinIO,
built for AI/ML, analytics and data-intensive workloads.
🔹 S3 API Compatible – Works with existing S3 tools and SDKs
🔹 Written in Rust – Memory-safe and fast, with a small footprint
🔹 Web Console – Manage buckets, objects and access keys from the browser

This template runs single-node RustFS with data on a bind-mounted volume
(captured by DollarDeploy backups). The S3 API is exposed at the app URL and
the web console is available on a separate local port behind the reverse proxy.


RustFS

Solid Next.js (Free)

#!/bin/bash
set -e

# Load deploy-time variables. DollarDeploy makes the template `env` map available
# to docker compose — either as a ./.env file and/or as exported shell env. We
# source the .env (if present) so the configured values are usable here as real
# shell variables. Most app config lives in the template `env` map (visible and
# editable in .dollardeploy.yml); only secrets and values derived from reserved
# vars are computed below.
set -a
[ -f ./.env ] && . ./.env
set +a

# Persisted app storage + logs (bind-mounted into the containers, owned by the
# image's runtime user 1000:1000).
mkdir -p ./app-storage ./logs
sudo chown -R 1000:1000 ./app-storage ./logs || true

# Generate stable secrets ONCE and persist them in the project dir so they
# survive redeploys (otherwise OAuth tokens and encrypted data would break).
if [ ! -f ./app_key.txt ]; then
  echo "base64:$(openssl rand -base64 32)" > ./app_key.txt
fi
if [ ! -f ./oauth-private.key ]; then
  openssl genrsa -out ./oauth-private.key 4096
  openssl rsa -in ./oauth-private.key -pubout -out ./oauth-public.key
fi
chmod 600 ./app_key.txt ./oauth-private.key

# Fail loudly if the required values didn't arrive, instead of writing a broken
# laravel.env that silently misconfigures the app. APP_URL/APP_HOSTNAME/USER_EMAIL
# are DollarDeploy reserved vars, so the template passes them in via the
# non-reserved aliases PUBLIC_URL / PUBLIC_HOSTNAME / ADMIN_EMAIL.
: "${PUBLIC_URL:?PUBLIC_URL not set}"
: "${DB_DATABASE:?DB_DATABASE not set}"
: "${DB_USERNAME:?DB_USERNAME not set}"
: "${DB_PASSWORD:?DB_PASSWORD not set}"

# Build the application env file consumed by the app/scheduler/queue containers.
# Plain config comes from the template `env` map (with safe fallbacks); APP_URL
# and SUPER_ADMINS are derived from reserved vars; the keys are the generated
# secrets above.
cat > laravel.env <<EOF
APP_NAME="${APP_NAME:-solidtime}"
VITE_APP_NAME="${APP_NAME:-solidtime}"
APP_ENV="${APP_ENV:-production}"
APP_DEBUG="${APP_DEBUG:-false}"
APP_URL="${PUBLIC_URL}"
APP_FORCE_HTTPS="${APP_FORCE_HTTPS:-true}"
APP_ENABLE_REGISTRATION="${APP_ENABLE_REGISTRATION:-true}"
TRUSTED_PROXIES="${TRUSTED_PROXIES:-0.0.0.0/0,2000:0:0:0:0:0:0:0/3}"
LOG_CHANNEL="${LOG_CHANNEL:-stderr}"
LOG_LEVEL="${LOG_LEVEL:-error}"
AUTO_DB_MIGRATE="${AUTO_DB_MIGRATE:-true}"
DB_CONNECTION="${DB_CONNECTION:-pgsql}"
DB_HOST="${DB_HOST:-database}"
DB_PORT="${DB_PORT:-5432}"
DB_SSLMODE="${DB_SSLMODE:-disable}"
DB_DATABASE="${DB_DATABASE}"
DB_USERNAME="${DB_USERNAME}"
DB_PASSWORD="${DB_PASSWORD}"
QUEUE_CONNECTION="${QUEUE_CONNECTION:-database}"
FILESYSTEM_DISK="${FILESYSTEM_DISK:-local}"
PUBLIC_FILESYSTEM_DISK="${PUBLIC_FILESYSTEM_DISK:-public}"
GOTENBERG_URL="${GOTENBERG_URL:-http://gotenberg:3000}"
SUPER_ADMINS="${ADMIN_EMAIL}"
MAIL_MAILER="${MAIL_MAILER:-log}"
MAIL_HOST="${MAIL_HOST:-}"
MAIL_PORT="${MAIL_PORT:-}"
MAIL_USERNAME="${MAIL_USERNAME:-}"
MAIL_PASSWORD="${MAIL_PASSWORD:-}"
MAIL_ENCRYPTION="${MAIL_ENCRYPTION:-tls}"
MAIL_FROM_ADDRESS="${MAIL_FROM_ADDRESS:-no-reply@${PUBLIC_HOSTNAME:-localhost}}"
MAIL_FROM_NAME="${MAIL_FROM_NAME:-solidtime}"
APP_KEY="$(cat ./app_key.txt)"
PASSPORT_PRIVATE_KEY="$(cat ./oauth-private.key)"
PASSPORT_PUBLIC_KEY="$(cat ./oauth-public.key)"
EOF


#!/bin/bash
# Create the Laravel Passport OAuth clients Solidtime needs, after the stack is up.
# Passport 13 resolves clients from the database, so these just have to exist; the
# DB (persisted volume) + marker files (persisted project dir) make this run once.
set -e

run() { docker compose exec -T scheduler php artisan "$@"; }

# 1) Personal access client — enables the "Create API Token" feature.
if [ ! -f ./.passport_personal_done ]; then
  for i in $(seq 1 12); do
    if run passport:client --personal --name="solidtime" --no-interaction >/dev/null 2>&1; then
      touch ./.passport_personal_done
      echo "Created Passport personal access client."
      break
    fi
    sleep 5
  done
fi

# 2) Desktop / Instance OAuth client — used to connect the Solidtime desktop app
#    (and as the template for browser extensions). Public PKCE client.
if [ ! -f ./.passport_desktop_done ]; then
  if run passport:client --name="desktop" --redirect_uri="solidtime://oauth/callback" --public -n >/dev/null 2>&1; then
    # Read the generated client id back cleanly via delimited markers.
    out=$(run tinker --execute="echo 'CID:'.optional(\Laravel\Passport\Client::where('name','desktop')->latest('created_at')->first())->getKey().':END';" 2>/dev/null || true)
    cid=$(printf '%s' "$out" | sed -n 's/.*CID:$.*$:END.*/\1/p')
    if [ -n "$cid" ]; then
      echo "$cid" > ./instance-client-id.txt
      touch ./.passport_desktop_done
      echo "============================================================"
      echo " Solidtime Instance Client ID (desktop app / extension):"
      echo "   $cid"
      echo " (also saved to ./instance-client-id.txt)"
      echo "============================================================"
    fi
  fi
fi

# Best-effort: never fail the deploy over client setup — the app is still usable,
# and anything missing can be created manually.
exit 0


Version: 0.14.0. Solidtime is a modern open-source time
tracking application. Track time across projects and clients, manage teams and
organizations, set billable rates, and export detailed reports and invoices.
A privacy-friendly, self-hostable alternative to Toggl and Clockify, built on
Laravel + Vue. Ships as an all-in-one deployment with PostgreSQL, a queue
worker, a scheduler, and Gotenberg for PDF export.


Solidtime

Stirling PDF is a powerful, locally-hosted web application for performing a
wide range of operations on PDF files — merging, splitting, converting,
rotating, compressing, adding passwords, OCR, and more than 50 tools in total.

Everything runs on your own server; files are processed locally and are not
sent to any third party. Configs, logs, and OCR training data are persisted to
local volumes.


Stirling PDF

This template provides a Fastify-based server  that exposes a /webhooks endpoint for Stripe, providing a ready-to-run service for real-time Stripe-to-Postgres sync. Read more at  https://github.com/supabase/stripe-sync-engine

Stripe Sync

The appview is the web half of [Tangled](https://tangled.org): repo browsing,
issues, pull requests, timelines and OAuth login. It holds no git data — code
lives on knots (see the **Tangled Knot** template), and identity lives on each
user's AT Protocol PDS. This instance just indexes the firehose and renders it.

Users sign in with their existing Bluesky/atproto handle, so no local accounts
are created. `DEFAULT_KNOT` picks the knot offered when someone creates a repo
— point it at your own knot's domain if you run one.

A cookie secret and an OAuth client key are generated per deploy and kept in
the data volume, so sessions survive redeploys.

Everything is compiled from the upstream Nix flake at deploy time: the first
launch spends ~7.5 minutes building and needs a few GB of disk. Redeploys
reuse the Docker layer and start in seconds as long as `TANGLED_VERSION` is
unchanged.

Experimental — Tangled is alpha and the appview is not documented for
self-hosting. Verify the deploy before relying on it.


Tangled Appview

A knot is the headless git server behind [Tangled](https://tangled.org) — the
social coding platform built on the AT Protocol. Your repositories live on
your own server; issues, pull requests and identity stay on the network.

Set `KNOT_SERVER_OWNER` to your DID (Tangled → Settings) before deploying —
the knot refuses to accept repos without it. After it boots, go to
Settings → Knots on tangled.org, add this app's domain and hit **verify**;
that writes the `sh.tangled.knot` record on your PDS which announces the knot.

Git over SSH is published on host port `SSH_PORT` (default 2222); clone with
`ssh://git@<domain>:2222/...`. Set it to `22` if nothing else uses that port,
so plain `git@<domain>` URLs work. The deploy opens the port in the host
firewall automatically — a firewall at your cloud provider (Hetzner Cloud
firewall, AWS security group) still needs the rule added by hand.

The knot is compiled from source on deploy (`KNOT_VERSION` pins the tag), so
first launch takes several minutes.

Experimental — Tangled itself is alpha. Verify the deploy before relying on it.


Tangled Knot

#!/bin/bash
mkdir -p data
mkdir -p data/tmp
mkdir -p data/local
mkdir -p data/db
# TwentyCRM expects to run as 1000:1000
sudo chown 1000:1000 data/local
sudo chown 1000:1000 data/tmp
# The server must be started by the user that owns the data directory.
sudo chown root:root data/db
sudo chmod a+X data/db


The #1 Open-Source CRM Modern, powerful, affordable platform to manage your
customer relationships.
Version v2.38.1.
Check the releases notes at https://twenty.com/releases
For upgrading, see the [self-hosted upgrade guide](https://twenty.com/developers/section/self-hosting/upgrade-guide).


Twenty CRM

Umami is a simple, fast, privacy-focused alternative to Google Analytics.
It collects the metrics you care about — page views, referrers, devices —
without cookies and while staying GDPR compliant.

This template runs the Umami app backed by a PostgreSQL database. Database
data is persisted to a local volume. The default login after first deploy is
username `admin` / password `umami` — change it immediately.


Umami

Uptime Kuma is a simple, easy-to-use uptime monitoring tool.
It's a great way to monitor your website or server uptime.  
It's also a great way to monitor your server resources.


Uptime Kuma

Vaultwarden is an unofficial, lightweight implementation of the Bitwarden
server API written in Rust. It is fully compatible with the official Bitwarden
clients (desktop, browser extensions, mobile, CLI) while using a fraction of
the resources of the official server.

Data is persisted to a local volume. After the first deploy, open the app,
create your account, then set SIGNUPS_ALLOWED to false to lock down
registration. Set ADMIN_TOKEN to enable the /admin panel.


Vaultwarden

Example template of NextJS based commerce app.

FIXME: Requires shopify credentials or else it will fail to start.


Vercel Commerce

VictoriaLogs is an open source, easy to use and fast log management database
built by the VictoriaMetrics team. It ingests logs via many protocols
(Elasticsearch, Loki, OpenTelemetry, Syslog, Journald and more) and queries
them with the powerful LogsQL language.

This template runs the single-node VictoriaLogs server behind vmauth for
authentication and routing, as recommended by the VictoriaLogs security guide.
Only vmauth is exposed (bound to localhost behind the DollarDeploy reverse
proxy); VictoriaLogs itself stays on the internal Docker network. Two
credentials are generated: an admin user for the web UI and querying, and a
separate ingestion-only user for log shippers.


VictoriaLogs

Deploy an OpenAI & Claude compatible REST API endpoint using vLLM with GPU
acceleration — running natively under systemd instead of Docker. Out of the box
this template serves Qwen/Qwen3.8-27B-FP8 on a single FP8-native GPU with
tool calling support and HuggingFace model caching.

The endpoint is fully compatible with the OpenAI  /v1/chat/completions and Claude /v1/messages,
making it a drop-in replacement for any OpenAI compatible SDK client.

Use a GPU server with NVIDIA drivers already installed and native FP8 support
(Hopper or newer — e.g. Verda 1xH200, or scale to 2x/4x/8x for larger models).
Dependencies are managed with uv from a native pyproject.toml, and uv
auto-selects the PyTorch CUDA wheels matching the host driver (CUDA 12.9 / 13.0),
so no CUDA toolkit install is required. Set HF_TOKEN to your HuggingFace token to
download gated models, and set MODEL_NAME and TENSOR_PARALLEL_SIZE to match the
model and GPU count.

This template is experimental — verify the deployment on your own GPU server
before relying on it.


vLLM

Deploy an OpenAI-compatible REST API endpoint using vLLM with GPU acceleration.
This template runs Qwen/Qwen3-Coder-Next across 2+ GPUs with tensor parallelism,
tool calling support, and HuggingFace model caching.

The endpoint is fully compatible with the OpenAI Chat Completions API, making it
a drop-in replacement for any OpenAI SDK client.

Use **Verda** servers with 2xA100, 2xH100, or similar multi-GPU configurations. Make sure to set
HF_TOKEN environment variable to your HuggingFace token to be able to properly download the model.


vLLM (Docker)

port: 3000
bindIP: 127.0.0.1
database:
  type: postgres
  host: localhost
  port: 5432
  user: postgres
  password: postgres
  database: postgres
  ssl: true
  schema: public
  sslOptions:
    auto: false
    rejectUnauthorized: false
dataPath: ./tmp


A modern, lightweight and powerful wiki app built on NodeJS


Wiki.js

#!/bin/bash
mkdir -p ./data/db
mkdir -p ./wordpress
sudo chown -R 999:999 ./data/db


WordPress is open source software you can use to create a beautiful website, blog, or app.


Templates