Quickstart ↗
| [Core repository](https://github.com/flisk-sh/flisk) | [Examples](https://flisk.sh/docs/examples/) | [Notes and gists](#notes-and-gists) | [CI and benchmarks](#ci-and-benchmarks) | [Article index](https://flisk.sh/blog/)
Awesome Flisk · learning index
Go deeper.
Find your source.
The catalog points back to official Flisk materials and useful community resources. Labs make selected topics hands-on; the catalog remains the index.
Flisk website ↗
overview, documentation, and project news. **Official**
Quickstart ↗
install Flisk and run your first local stack. **Official**
flisk ↗
the main public monorepo for the CLI, Tilt engine, and service discovery. **Official**
CLI quick start and command overview ↗
install Flisk, create a project, scaffold a resource, and run a stack. **Official**
npm package ↗
install the Flisk CLI with npm or Bun. **Official**
releases ↗
prebuilt Flisk CLI binaries for supported platforms. **Official**
flisk.sh ↗
source for the public install site and CLI installer. **Official**
Install script ↗
shell installer for the published CLI binary. **Official**
Changelog ↗
notable CLI and framework changes. **Official**
website ↗
source for the official documentation and project site. **Official**
Examples guide ↗
walkthroughs of projects built with Flisk. **Official**
Core repository docs ↗
detailed framework documentation. **Official**
Contributing to flisk ↗
development setup and contribution workflow. **Official**
MCP guide ↗
scaffold a Model Context Protocol server as a resource that `flisk up` starts like any other service. **Official**
Bring-your-own (BYO) guide ↗
wrap an existing service with Flisk orchestration without generating application code. **Official**
WSL2 guide ↗
run Flisk on Windows through WSL2. **Official**
Honest comparison ↗
where Flisk fits next to Compose and Kubernetes, and where it does not. **Official**
Flisk Labs ↗
([source](https://github.com/flisk-sh/flisk-labs)): ordered lessons with captured CLI output, the files each command writes, and a static replay. Labs 02 and 03 are marked pending until their capture image is published. **Official**
Flisk blog ↗
browse the complete official article library. **Official**
We Ran 100 Microservices on a 16GB Laptop. No Kubernetes. ↗
Flisk overview and reproducible scale benchmark using the 100-service ERP example. **Community**
AI Assistants Need Topology ↗
Why coding assistants behave better when they understand services, boundaries, generated files, and ownership. **Official**
From Ticket to Topology ↗
How assistants can work better when user stories connect to actual services and generated context. **Official**
Stop Asking AI to Guess Your Architecture ↗
How Flisk gives assistants concrete context before they suggest changes in the wrong layer. **Official**
The AGENTS.md Advantage ↗
A practical guide to generated assistant briefings and why they matter in larger repos. **Official**
The AI Code Review Context Problem ↗
Why reviewers and assistants both need a map of generated files and service boundaries. **Official**
Why AI Needs Guardrails, Not Theater ↗
The practical role of generated boundaries, ownership notes, and service maps in AI-assisted coding. **Official**
Databases Are Part of the App ↗
How local database setup, migrations, and service ownership shape daily developer confidence. **Official**
Microservice Sprawl Needs a Workbench ↗
Why service count becomes manageable only when developers have a coherent local surface. **Official**
Microservices Without Local Theater ↗
How to tell the difference between a useful local stack and a fragile demo. **Official**
NATS in the Development Loop ↗
Why event-driven services need local messaging support that developers can see and restart. **Official**
Postgres as a First-Class Neighbor ↗
How local database services become less painful when they are part of generated orchestration. **Official**
Queues Belong in the Local Story ↗
Why background work and messaging need first-class local support, not production-only mystery. **Official**
Service Definitions as Team Contracts ↗
How one service.json can make runtime expectations visible across product and platform work. **Official**
The Local Gateway Pattern ↗
Why gateways, nginx, and routing deserve generated support in local service landscapes. **Official**
The Local System Is a Contract ↗
Why every service should declare how it runs, connects, and participates in the development loop. **Official**
The Service Registry as Shared Memory ↗
How a service registry helps teams understand what exists, where it runs, and how it connects. **Official**
Why One Manifest Matters ↗
The benefits of giving each service one explicit source for local development intent. **Official**
Golden Layers for Boring Builds ↗
How shared Docker layers can make generated services faster and easier to reason about. **Official**
Counting the Cost of Waiting ↗
Why blocked developers are expensive even before a team buys any extra infrastructure. **Official**
The Hidden Price of Cloud Workspaces ↗
Why rented developer environments can solve setup while introducing spend, latency, and governance questions. **Official**
The Quiet ROI of Fewer Interruptions ↗
How reducing setup questions and environment drift returns attention to product work. **Official**
When Cloud Development Makes Sense ↗
A fair look at where cloud workspaces help and where local tooling remains simpler. **Official**
C4 Diagrams That Do Not Rot ↗
Why architecture diagrams should be generated from the system instead of redrawn after the fact. **Official**
Configuration That Explains Itself ↗
Why generated configs should carry enough structure for humans and assistants to understand them. **Official**
Documentation for Humans and Assistants ↗
Why modern engineering docs need to serve both people reading and agents acting. **Official**
The Best Docs Are Rebuilt ↗
Why documentation that regenerates from service definitions is easier to trust than a wiki page. **Official**
Why Generated Docs Beat Forgotten Docs ↗
How generated C4 diagrams and assistant briefings keep documentation closer to the live system. **Official**
Hot Reload Is a Trust Feature ↗
Why developers keep using local tools only when feedback feels immediate and reliable. **Official**
No Kubernetes Before Lunch ↗
Why Flisk keeps developers productive without asking every product engineer to become a cluster operator. **Official**
Ports Should Not Be Folklore ↗
Why local port assignment belongs in generated configuration instead of memory and Slack. **Official**
Selective Startup for Big Repos ↗
How teams can work on one slice of a system without booting every service every time. **Official**
The Laptop Should Tell the Truth ↗
Why local environments should reveal integration problems early instead of hiding them until CI. **Official**
The Local Stack as a Product Surface ↗
Why internal developer experience deserves the same care as user-facing workflows. **Official**
The Real Meaning of Reproducible ↗
What reproducibility should mean for service discovery, ports, credentials, generated files, and startup. **Official**
Why Local Feedback Still Wins ↗
The case for fast local loops even when cloud development environments look convenient on paper. **Official**
Do Not Rewrite Before You Understand ↗
Why brownfield modernization starts with discovery, not a heroic platform replacement. **Official**
Gradual Adoption Without Drama ↗
How teams can bring Flisk into an existing repo without stopping product work. **Official**
Making Brownfield Code Legible ↗
How discovery can reveal hidden services, missing manifests, and patterns worth preserving. **Official**
The Brownfield Rescue Path ↗
How existing repos can be discovered and gradually shaped into explicit service definitions. **Official**
The First Manifest to Write ↗
Where to start when turning an existing service into an explicit Flisk service definition. **Official**
Generated Does Not Mean Disposable ↗
How generated artifacts can become stable, reviewable parts of the engineering system. **Official**
MIT License as Product Philosophy ↗
Why open licensing matters when a tool sits in the middle of daily engineering work. **Official**
Owning the Output ↗
Why teams should be able to keep every generated file if they outgrow the generator. **Official**
Standard Files Beat Platform Lock-In ↗
Why teams should keep generated output they can read, edit, commit, and carry forward. **Official**
The Escape Hatch Is the Product ↗
How no-lock-in design makes a developer tool safer to adopt. **Official**
The DevOps Case for Flisk ↗
How generated local environments keep platform attention closer to production reliability. **Official**
The Platform Engineer Case for Flisk ↗
Why platform teams should automate local development instead of becoming laptop support. **Official**
A Better Default for Service Teams ↗
Why Flisk is built for teams that want standard tools, faster feedback, and less local ceremony. **Official**
Local First Does Not Mean Local Only ↗
Why strong local development complements CI, staging, and production instead of replacing them. **Official**
The Difference Between Simple and Simplistic ↗
How Flisk tries to reduce local complexity without pretending distributed systems are easy. **Official**
Why Flisk Does Not Hide the Stack ↗
Flisk exposes standard tools because hiding every detail makes teams weaker when debugging starts. **Official**
Why Flisk Is Not a Cloud IDE ↗
The difference between renting a remote machine and generating a better local development surface. **Official**
Terminal UI for Real Work ↗
How a focused terminal interface can make a complex service landscape easier to scan. **Official**
The CLI as a Calm Interface ↗
Why a development CLI should guide without burying engineers under flags and hidden states. **Official**
The Product Engineer Case for Flisk ↗
How product developers can ship across services without memorizing infrastructure internals. **Official**
Why Local Dev Needs Product Design ↗
Internal tools still have users, workflows, friction, and moments where clarity matters. **Official**
A Smaller Surface for Mistakes ↗
How generated conventions reduce the number of places local setup can quietly drift. **Official**
Observability Starts on the Laptop ↗
Why logs, status, health, and service relationships should be visible before staging. **Official**
The Difference Between Demo and Daily Driver ↗
What separates a local stack that impresses once from one developers trust every day. **Official**
When the Stack Should Say No ↗
Why good local tooling should fail early, explain clearly, and avoid partial mystery states. **Official**
The Spec Is the Map, Not the Terrain ↗
How teams can use specs to reduce ambiguity without confusing written intent for production behavior. **Official**
What SDD Cannot Do ↗
Why specs cannot replace product judgment, architecture tradeoffs, operational feedback, or integration testing. **Official**
What SDD Gets Right ↗
The useful parts of spec-driven development: shared language, reviewable intent, and better AI handoffs. **Official**
When Specs Lie Quietly ↗
A practical look at stale assumptions, missing edge cases, and the false comfort of tidy requirements. **Official**
Why Flisk Matters After the Spec ↗
A closing argument for pairing spec-driven thinking with a development workbench that can actually run the system. **Official**
Local Credentials Without Spreadsheets ↗
Why developer secrets need managed paths, not tribal knowledge and old setup docs. **Official**
Secrets Are Not Onboarding Steps ↗
How managed identities reduce the habit of copying credentials through unsafe channels. **Official**
MVP Speed Without Throwaway Tooling ↗
Why fast early product work still deserves a local stack that can survive growth. **Official**
The Fast Path to a Useful Demo ↗
Why a runnable multi-service demo beats screenshots when teams need product feedback. **Official**
The Founder Case for Flisk ↗
How Flisk reduces setup drag so tiny teams spend more time on customer-facing decisions. **Official**
A Better First Week for Founding Engineers ↗
How early teams can avoid building local infrastructure from scratch before the product is proven. **Official**
Day-One Onboarding for Microservices ↗
What it should feel like when a new developer joins a service-heavy product team. **Official**
Local Tooling and Team Morale ↗
Why reliable development environments make engineers more willing to touch unfamiliar services. **Official**
New Hire Confidence Is a Feature ↗
Why the first successful local boot shapes how quickly people feel useful. **Official**
The Cost of Setup Rituals ↗
How repeated onboarding chores quietly consume product time and make teams afraid to change services. **Official**
The End of Setup Archaeology ↗
Why developers should not have to reconstruct old setup decisions from scripts and memories. **Official**
The Problem With Works on My Machine ↗
How reproducible generated environments remove a phrase teams should not need anymore. **Official**
Playwright Belongs Near the Stack ↗
Why end-to-end testing is more useful when the local system is easy to boot and reset. **Official**
Testing the System You Actually Run ↗
How local orchestration can make tests reflect real service relationships instead of isolated assumptions. **Official**
A Local Registry for Real Teams ↗
Why internal packages and generated clients benefit from a local registry during development. **Official**
Bun, Node, and Practical Defaults ↗
How runtime choices should serve developer feedback instead of becoming identity debates. **Official**
Code Generation That Stays Inspectable ↗
How generated files can help teams without becoming an opaque maintenance burden. **Official**
Generated Clients Without Guesswork ↗
How generated SDK and client surfaces reduce drift between frontend and backend work. **Official**
How to Review Generated Infrastructure ↗
A guide to inspecting generated Docker, Tilt, TypeScript, and config outputs with confidence. **Official**
Plain Docker Is Still a Feature ↗
Why standard generated Docker files are easier to inspect, debug, and keep than opaque platform magic. **Official**
Prisma in a Generated Stack ↗
Where ORM setup fits when service definitions generate development infrastructure. **Official**
Starlark for Repeatable Local Rules ↗
Why small deterministic orchestration rules can beat a pile of custom shell scripts. **Official**
flisk doctor as Team Memory ↗
How health checks can replace long troubleshooting threads with actionable local diagnostics. **Official**
The Case for Verdaccio ↗
How a local package registry supports service-heavy TypeScript development. **Official**
The Discipline of Boring Defaults ↗
Why teams move faster when generated defaults are predictable, readable, and unexciting. **Official**
The Problem With Perfect Templates ↗
Why templates help only when they keep matching the system after the first generation. **Official**
Tilt Without the Cluster Tax ↗
How Flisk uses Tilt and Starlark for local orchestration without forcing Kubernetes concepts into every task. **Official**
Traefik Without Mystery ↗
How generated routing config can make local service URLs predictable. **Official**
Vite Everywhere It Helps ↗
How consistent Vite usage can make frontend, backend, SDK, and library workflows easier to reason about. **Official**
From Empty Repo to Working Landscape ↗
How a service landscape forms when definitions, generated artifacts, and local orchestration line up. **Official**
From Product Intent to Runnable Services ↗
How Flisk turns service definitions into local systems developers can actually inspect and run. **Official**
Frontend and Backend in One Loop ↗
Why product work moves faster when UI, API, and generated clients update together. **Official**
The Practical Beauty of One Command ↗
Why one reliable command can be more valuable than a thick setup guide. **Official**
What Belongs in CI After Flisk ↗
How local reproducibility changes what teams expect from continuous integration. **Official**
Why Big Repos Need Small Rituals ↗
How simple repeated commands can hold a large service graph together. **Official**
Flisk demo animation ↗
source for a short visual tour of the CLI workflow and generated project ([view the animation](https://flisk-sh.github.io/flisk-demo-animation/)). **Official**
flisk-skills ↗
portable Agent Skills (`flisk-doctor`, `flisk-troubleshoot`, `layer-autoresearch`) plus `AGENTS.md` rule templates. Install with `npx skills add flisk-sh/flisk-skills`. **Official**
Agents guide ↗
how agents should drive the Flisk CLI. **Official**
Website llms.txt ↗
machine-readable index of the Flisk docs. **Official**
flisk-skills llms.txt ↗
index of every skill and rules template with raw URLs. **Official**
Repository rule templates ↗
baseline `AGENTS.md` files for Flisk project repos and for `flisk` contributors. **Official**
flisk-example ↗
small project demonstrating the Project-Stack-Resource model. **Official**
flisk-saas-starter ↗
SaaS dashboard starter with a working checkout flow. **Official**
flisk-restaurant-example ↗
restaurant operations example covering reservations, kitchen pacing, menu availability, and floor control. **Official**
flisk-ecommerce-example ↗
Vue storefront and Hono catalog API built with Flisk. **Official**
flisk-erp-system ↗
100-service ERP fixture across seven business domains, used for scale testing. **Official**
flisk-person-crud-example ↗
person CRUD with React, Express, MongoDB, Redis, and RabbitMQ. **Official**
flisk-agent-stack ↗
AI agent stack: a Bun agent, an MCP tool server, Postgres, and NATS. The template behind `flisk project agent-stack`. **Official**
vercel-store ↗
storefront landscape with a Hono BFF and a Vue frontend. **Official**
flisk-thor-storefront ↗
storefront landscape for Thor Commerce. **Official**
create-flisk ↗
starter generator and landing page for creating a Flisk stack. **Official**
flisk-stack ↗
convention-over-configuration full-stack skeleton (Actions, Models, Jobs, views, migrations) started with `flisk up`. **Official**
flisk-template-launch ↗
one free Bun + Hono service with SEO, icons, and a Product Hunt kit. **Official**
flisk-template-portal ↗
sign in with GitHub, API keys, usage, and a metered `/v1` proxy in one Bun service. **Official**
flisk-cli-starter ↗
starter for a local app stack, open in any cloud dev environment. **Official**
Bring-your-own templates ↗
apps from the framework generators that run under `flisk up`: [Vue](https://github.com/flisk-sh/flisk-template-vue), [Next.js](https://github.com/flisk-sh/flisk-template-next-app), [Bati](https://github.com/flisk-sh/flisk-template-bati) (React + Hono), [Analog](https://github.com/flisk-sh/flisk-template-analog) (Angular), and [AdonisJS](https://github.com/flisk-sh/flisk-template-adonisjs). **Official**
flisk-service-definitions ↗
community registry of `service.json` definitions, one directory per app, validated against the schema. **Official**
More example repositories ↗
browse public Flisk example repositories. **Official**
TubeHaus ↗
self-hosted video stack with an optional Flisk start path next to Docker Compose; the setup was proved with a real `flisk up`. **Community**
Lekast ↗
runs Flisk on its own repositories. **Community**
mfin.services ↗
public write-up of running Flisk. **Community**
MakeOffer ↗
runs Flisk on its own repositories. **Community**
Red Moon Digital ↗
runs Flisk on its own repositories. **Community**
flisk-import ↗
scan a repo and import its Procfile, Compose, Dockerfile, and `package.json` services into Flisk. Keeps ports, healthchecks, env, volume names, and the Compose project name. **Official**
flisk-export ↗
write `render.yaml`, `wrangler.toml`, or Compose files from `service.json`. Files only; it never deploys. **Official**
Bring-your-own guide ↗
wrap an existing service with Flisk orchestration. **Official**
fliskos ↗
local desktop command center for Flisk projects. **Official**
pages ↗
publish an interactive page from your agent to pages.flisk.si. **Official**
citable ↗
check whether AI answers can cite your site. **Official**
readme-score ↗
score a README out of 100, with a fix for every miss. **Official**
helpdock ↗
your docs as a help center that answers with sources, with an MCP server. **Official**
flisk-tools ↗
run small web and GitHub tools on your own GitHub. **Official**
live-preview ↗
public HTTPS link for a Docker stack on a GitHub Actions runner. **Official**
command-comparer ↗
Flisk next to Terraform, CDK, Compose, Tilt, Skaffold, and more, with a source for every cell. **Official**
roadmap ↗
community-edited map of local DevEx tools. **Official**
awesome-rea-flisk-cases ↗
reverse-engineer apps and rebuild them with Flisk. **Official**
flisk-model ↗
a 62-question test of whether a small model can write correct Flisk config files. **Official**
Node.js ↗
required runtime when installing the CLI from npm; prebuilt binaries are also available. **Core runtime**
Bun ↗
supported CLI installer and runtime/package tool used by generated services. **Core and generated apps**
npm ↗
publishes and installs the Flisk CLI package; generated services can use a local registry. **Core and optional service**
TypeScript ↗
implementation language for the CLI and generated service configuration. **Core and generated apps**
Starlark ↗
language used by the Tilt topology and resource generators. **Core engine**
Bash ↗
used by install, release, and generated container scripts. **Core scripts**
Vite ↗
generated frontend development and build configuration. **Generated apps**
React ↗
default frontend framework and the rendering foundation for Flisk's terminal interface. **Core and generated apps**
Vue ↗
supported frontend framework, also used in official ecommerce and identity examples. **Generated apps and examples**
Hono ↗
TypeScript web framework used for backend APIs in official examples. **Examples**
Ink ↗
React components for the interactive CLI interface. **Core CLI**
Commander.js ↗
command and option parsing for the `flisk` CLI. **Core CLI**
Handlebars ↗
templates used to generate service files and configuration. **Core generator**
Docker ↗
builds and runs the local service containers. **Core requirement**
Docker Desktop ↗
, [OrbStack](https://orbstack.dev/), and [Colima](https://github.com/abiosoft/colima): supported local Docker environments for macOS development. **Docker options**
Docker Compose ↗
describes supporting services and local infrastructure. **Core and examples**
Tilt ↗
orchestrates the landscape and provides the live development loop. **Core requirement**
Traefik ↗
routes local traffic to services through stable development URLs. **Core service**
PostgreSQL ↗
default local database service. **Core service**
Prisma ↗
opt-in schema, client, and migration workflow for backend resources. **Optional generator**
NATS ↗
, including [JetStream](https://docs.nats.io/nats-concepts/jetstream): messaging and persistence demonstrated in Flisk's queue example. **Optional service and example**
Debezium ↗
optional change data capture from PostgreSQL. **Optional infrastructure**
Elasticsearch ↗
search and storage component in the optional ELK stack. **Optional infrastructure**
Logstash ↗
collection and processing component in the optional ELK stack. **Optional infrastructure**
Kibana ↗
exploration interface in the optional ELK stack. **Optional infrastructure**
SigNoz ↗
observability option for metrics, traces, and logs. **Optional infrastructure**
Apache SkyWalking ↗
alternative observability option listed by Flisk. **Optional infrastructure**
OpenID Connect ↗
identity protocol demonstrated by the auth emulator and protected API example. **Example integration**
Mailpit ↗
local email capture and inspection in the auth and email example. **Example integration**
Verdaccio ↗
private local npm registry. Requires a Flisk license. **Paid optional service**
Sablier ↗
on-demand service start and stop. Requires a Flisk license. **Paid optional service**
Biome ↗
linting and formatting in the CLI workspace. **Core development**
Vitest ↗
unit and integration test runner for the CLI. **Core development**
Knip ↗
detects unused files, exports, and dependencies. **Core development**
Playwright ↗
browser test configuration available through a licensed Flisk extension. **Paid generator**
GitHub Actions ↗
runs CI, quickstart, examples, scale, and release workflows. **Core delivery**
GitHub CLI ↗
dispatches follow-up CI runs from the repository workflow. **Core delivery**
Dependabot ↗
automated dependency updates for GitHub repositories. **Repository maintenance**
GNU Make ↗
common contributor commands such as `make test` and `make help`. **Core development**
pre-commit ↗
local hook runner configured for the core repository. **Core development**
Feature reference ↗
project and resource features, including monitoring, ELK, Debezium CDC, and local registry options. **Official**
flisk-docker-compose-example ↗
run the Flisk CLI and its development workflow from Docker Compose. **Official**
Security policy ↗
responsible vulnerability reporting for the core project. **Official**
flisk-auth-queue-email-example ↗
local identity, queue, and email example with an OIDC emulator, NATS JetStream, and Mailpit. **Official**
flisk-user-management ↗
identity and user-management demo organized into Flisk stacks. **Official**
Current CLI extensions ↗
extension and IDE integration source maintained in the core monorepo. **Official**
flisk-discovery ↗
**Archived.** Earlier standalone service-discovery repository; current development is in [flisk](https://github.com/flisk-sh/flisk).
flisk-ext ↗
**Archived.** Earlier extensions repository; use the current [flisk extension documentation](https://github.com/flisk-sh/flisk/tree/main/ext) for current work.
flisk ↗
**Archived.** Earlier platform specifications and generators repository; consult the current core repository and website for maintained material.
Flisk organization ↗
official public repositories and projects.
Organization profile source ↗
source for the public Flisk organization profile.
Open an issue on flisk ↗
ask questions, report a bug, or suggest a framework improvement.
Good first issues ↗
beginner-friendly ways to contribute to the core project.