@flisk-sh/flisk
Advanced tools
👋 Welcome · 欢迎 · 歡迎 · ようこそ · 환영합니다 · Bienvenue · Bienvenido · Bem-vindos · Willkommen · Benvenuti · Bun venit · أهلًا · Hoş geldiniz · Ласкаво просимо · Witamy · خوش آمدید · Selamat datang · Chào mừng · ยินดีต้อนรับ · Καλώς ήρθατε · സ്വാഗതം
Describe an app to your AI helper, or type four commands yourself.
Flisk runs every part of it on your computer (the website, the back end, the database), connects them, and keeps them in sync as you change things.
npm install -g @flisk-sh/flisk
Never written code? Start here, step by step, no experience needed · Words you'll see
🚀 Flisk is live on Product Hunt today. Try it, then tell us there what worked and what did not.
Quick start · Why Flisk · Examples · Installation · FAQ · Documentation
Website · Quickstart · Examples · Awesome Flisk · Demo · Report a bug
An illustrative Claude Code session in the Warp terminal. The Flisk commands, their output, and the URLs Flisk prints come from a real run. Copy the prompt from Try it.
Three quick questions; click the answer closest to your team. Not technical? Pick "not sure" where you need to. You get a score and a plain-English why.
1. What is the app written in?      |
2. How do developers start the app on their laptop today?         |
3. How many parts does the app have? (website, API, background jobs, …)   |
Great fit. Flisk was made for teams like yours. Why this score → · Full calculator on flisk.sh
 |  |  |  |
Teams that run flisk up on their own code, listed with their consent. See all adopters or add yours.
Install Flisk, then paste a prompt into your AI helper: Claude Code, Codex, Cursor, or any other that can run commands. Every grey box below has a copy button: paste the first one into your terminal, and the prompt into your helper.
npm install -g @flisk-sh/flisk
The prompt from the demo:
Build me a small online shop with a storefront and an orders API, and run it on my laptop with Flisk.
Your helper creates the project, adds each part of the app, and starts it. Then open the link Flisk prints, like http://localhost:3000, in your browser: that is your app, on your computer. If something is missing, flisk doctor says what, in plain words.
Add a service to a project you already have
Use Flisk to add a backend service called payments-api to my shop stack, then start the stack and give me the URLs.
Build an AI agent with tools and a database
Use Flisk to scaffold an AI agent, an MCP tools server, and a database in one stack called shop, then start it and tell me how to talk to the agent.
Something is not working
Run flisk doctor, explain every problem in plain words, and fix what you can. Then start my stack with flisk up.
See what is running
Use flisk status to tell me which services are running, which are unhealthy, and what URL each one has.
Stop everything
Stop my Flisk stack with flisk down and confirm nothing is left running.
Each AI helper installs a little differently; pick yours for the exact steps. After that it is the same everywhere: paste the prompt, and the helper runs Flisk for you. (For developers: flisk project also adds the Flisk skills and an AGENTS.md to your project, so the agent knows how to use Flisk.)
Already have a project? One command connects your agent: flisk connect claude (or cursor, codex) writes the flisk mcp server entry and the Flisk skills where that agent reads them. See Flisk for AI agents.
 |
    |
Then start Claude Code by typing |
 |
Any other agent that can run terminal commands works too. Point it at AGENTS.md, or connect it to flisk mcp, which runs an MCP server over stdio.
npm install -g @flisk-sh/flisk
mkdir my-shop && cd my-shop
flisk project --yes
flisk resource orders-api --type backend --stack shop --yes
flisk resource shop-web --type frontend --stack shop --yes
flisk up shop
You get a working shop on your computer: a storefront website and an orders back end, with a database, one address to open, and changes that show up as you save. In developer terms: an orders API and a storefront behind one local gateway, with Postgres and live reload. You need Docker, Tilt, Node.js 22.12+, and Bun 1.2+; flisk doctor checks your machine. A simpler app needs none of those: give each service a command and run it as local processes. Prefer to answer questions instead? npm init create-microservices my-project asks what to create. See the quick start for every option.
ERP fixture scale run on a clean GitHub-hosted runner (4 vCPU, 15 GB RAM), snapshot from run 39160719471. The live status is in the ERP fixture scale E2E badge above.
AI helpers are great at writing the app itself, and bad at the setup around it: the files that start each part, connect the parts and give them a database. Every time an AI rewrites that setup by hand, something breaks, and you pay for the time and the AI tokens it takes to fix. (For developers: a rewritten Dockerfile, a misconfigured Tiltfile, a broken nginx.conf.)
Flisk writes that setup for you, the same way every time, and keeps it in sync. You and your helper stick to the app.
Fastest way (recommended): open the Flisk starter in a ready-to-use environment.
 |  |  |
 |  |  |
 |  | |
 |  |  |
 |
 |  |  |
 |  |  |
 |  |  |
 |  |  |
 |  |  |
 |  |  |
 |  |  |
 |  |  |
 |  |  |
 |  |  |
 |  |  |
 |  |  |
 |  |  |
 |  |
On a one-backend quickstart with warm image layers, flisk up reaches a healthy API in 12.8 to 13.8 seconds (timing notes). An 8-service stack settles in 32 to 42 seconds warm and about 4.5 minutes on its first cold build (benchmark). No vendor lock-in and no hand-written plumbing.
Flisk is the local runtime for agent systems: the agent, its MCP tools, its database, its queue, behind one gateway, one command.
# Scaffold an agent, an MCP tools server, and a database in one stack
flisk resource bot --type agent --stack shop --yes
flisk resource tools-mcp --type mcp --stack shop --yes
flisk up shop
Agents get durable checkpoint volumes that survive flisk down, sticky session routing via x-session-id, graceful SIGTERM drain during hot reloads, a Docker health check on /health, and application-level readiness checks on /ready. See the AI agents guide and honest comparison with agent frameworks.
What Flisk is: a local development runtime. Define each service in service.json and run flisk up. A service with a command runs as a local process, with nothing else installed. When you need a database, one gateway URL, or the container you deploy, Docker runs the containers, Tilt live-updates them while you code, and Flisk writes the configuration both use. No local Kubernetes is needed.
What Flisk is not: a deploy tool or a Compose file. Production deployment stays with Helm, Argo CD, or Kustomize.
Stability: 1.x. The core CLI is MIT and needs no key; Premium is optional. See what Flisk writes and how to check for drift.
[!IMPORTANT] Get Flisk from the flisk-sh/flisk repository, the
@flisk-sh/flisknpm package, or the official website. Follow the installation links from these official sources. A similar repository name or copied README does not establish that a download is official.
service.json per service. Flisk generates the Dockerfile, Traefik routing, and Tiltfile from it. You do not hand-write a docker-compose.yml or nginx.conf.flisk records the generated files and reports drift, so local config stays in sync. See generated files and drift checks.How Flisk compares, in 10 categories with two tools each. Pick a tab:
           |
Docker Compose and Tilt are tools developers use to start the parts of an app on their computer. Compose runs containers from a YAML settings file you write. Tilt watches your files and live-updates the running app as you save them, from a Tiltfile you write. Flisk writes both files for you from one small service.json per service (per part of your app), then runs Tilt.
| Docker Compose | Tilt | Flisk | |
|---|---|---|---|
| Scaffold a new service in one command | Partial (docker init writes a Dockerfile and compose file) | No | Yes (flisk resource) |
| Hot reload on file change | Partial (compose watch) | Yes (live_update) | Yes (generated Tilt live_update) |
| Health-checked startup order | Yes (depends_on: condition: service_healthy) | Yes (resource_deps, written by hand) | Yes (from dependsOn) |
| Gateway URL per service and Postgres included | No (you add them) | No (you add them) | Yes (Traefik *.localhost and Postgres) |
| Start one stack of a large system | Partial (profiles) | Yes (tilt up <resource>) | Yes (flisk up <stack>) |
| Config you write by hand | compose.yaml | Tiltfile (Starlark) | service.json only; the rest is generated and drift-checked |
Where they are stronger
Use them together. Flisk generates a Compose file and a Tiltfile and runs them with Docker and Tilt, so the generated files stay readable with flisk config explain.
More: Flisk vs Docker Compose
See the detailed tool comparison for architectural tradeoffs, when each tool is the better choice, and migration workflows.
service.json next to its code.flisk up <stack>. Flisk generates the local runtime files from those manifests: Dockerfiles, Traefik routing, and the Tiltfile.flisk ui to inspect running services, and flisk doctor or flisk config verify to check the environment and generated files.Production deployment stays with your own tools (Helm, Argo CD, or Kustomize).
You do not connect services by hand. Flisk derives each connection from the same service.json files and regenerates it when they change.
| When you... | Flisk updates |
|---|---|
Add a service with flisk resource | It is discovered automatically and its stack is enabled on the next flisk up. It gets an image build, a Compose entry, gateway routes, a health check, and its own .autogenerated/ files. |
Edit a service.json (port, dependsOn, features) | The Dockerfile, Compose entry, Traefik labels, and nginx config are regenerated on the next flisk up. A hand edit to a generated file is caught as drift before anything starts. |
| Edit your code | Tilt live-updates the running container. No rebuild step. |
| Add a backend route | Frontends already point at the API through generated VITE_API_URL, env.ts, and api-client.ts, built from the same hostnames the gateway routes. |
| Add a database or a second backend | DATABASE_URL and the other connection settings are injected into each service's environment. No copying of passwords or hostnames. |
Run on a project with an older or missing .env | Missing secrets such as JWT_SECRET are generated without overwriting your values. |
Declare dependsOn | Services start in health-checked order. |
See how flisk up works for the full startup sequence.
| You want to | Flisk does | Command |
|---|---|---|
| Start a new project | Creates the project and first services | flisk project --yes |
| Add a service | Writes its service.json and generated files | flisk resource <name> --type backend --stack <stack> --yes |
| Start a whole stack | Starts Postgres, your services, and the routing, and prints the URLs | flisk up <stack> |
| Preview before starting | Shows which services and URLs would start, without containers | flisk up <stack> --dry-run |
| Inspect running services | Opens an interactive terminal dashboard | flisk ui |
| Check your machine | Reports Docker, Tilt, and port readiness | flisk doctor |
| Catch config drift | Compares generated files with what Flisk last wrote | flisk config verify |
| Keep Flisk current | Upgrades the CLI in place | flisk upgrade |
Flisk works with:
Teams that run flisk up on their own code (listed with their consent in ADOPTERS.md):
Using Flisk too? Tell us or add a row to ADOPTERS.md.
If Flisk saves you time, a ⭐ on this repo helps other developers find it.
Get your app running on your computer in 3 commands. Works on Mac, Linux, and Windows (through WSL2). Never used a terminal? Start here instead.
| Tool | Version | Install | Needed for |
|---|---|---|---|
| Your app's runtime | whatever your app uses | Node.js, Python, Go, Bun, ... | Every path: it runs your code |
| Node.js | 22.12+ | nodejs.org | npm install (npm install -g @flisk-sh/flisk) |
| Docker | Engine 25+, Compose 2.20.2+ | docker.com | Docker + Tilt path only |
| Tilt | 0.25+ | curl -fsSL https://raw.githubusercontent.com/tilt-dev/tilt/master/scripts/install.sh | bash | Docker + Tilt path only |
| Bun | 1.2+ | curl -fsSL https://bun.sh/install | bash | Bun install (bun add -g @flisk-sh/flisk), or generated JavaScript services |
Two ways to run. Small apps run as plain programs, with nothing extra to install. Apps with a database, one address for every part, or the same setup you ship to customers need Docker and Tilt. In developer terms: a project whose services each declare a
commandruns them as local processes: you need only Flisk and your app's runtime (simplest path). Docker and Tilt are needed for the Docker + Tilt path: databases such as Postgres, one gateway URL for every service, and running the same container you deploy.flisk doctorchecks only what your project uses.
Set up your machine. Pick your system:
 |
     |
|
Get your Mac ready once. Paste each grey box into the terminal (press Cmd+Space, type 1. Node.js 22.12+ from nodejs.org, plus your app's own language if it is not JavaScript. That is all a small app needs: the simplest path. 2. Only for bigger apps (a database, one address in front of every part, or the same container you deploy): start Docker Desktop, OrbStack or Colima, and install Tilt: 3. Install Flisk and check your Mac:
|
 |
Four ways to get your app running: the simplest one, a one-command demo, a project you set up by hand, and a guided setup that asks you questions. The simplest is below; each tab opens its own page.
     |
|
Run your app on your own computer with one command, without Docker. This path fits an app made of a few parts that each start with one command, for example a back end (an API), a website and a worker. You need only Flisk and the program that runs your code, such as Node.js. For developers: each service runs as a local process. You need only Flisk and your app's runtime. 1. Install Flisk. Paste this into your terminal and press Enter: 2. Describe each part. Put a small settings file called This one is for the website. 3. Start everything. In the terminal, go to your project folder and run: What you will see: Flisk starts the API, waits until it answers, then starts the website. It prints both URLs (the web addresses to open in your browser; they are localhost links, so only you can see them). Each line of output starts with the name of the part that wrote it. If a part crashes, Flisk starts it again. To stop, press Ctrl+C (hold Control and press C), or run |
After flisk up, you'll see output like:
Flisk is up.
Tilt UI: http://localhost:10350
Services:
✓ api → http://api.main.localhost/api/api/health
✓ web → http://web.main.localhost
Stop: flisk down
Logs: flisk logs <service>
Next: flisk help # or visit https://flisk.sh/docs
flisk down stops everything; containers persist for inspection| Goal | Command |
|---|---|
| See running services | flisk ui |
| Check environment health | flisk doctor |
| View service logs | flisk logs api |
| Restart a service | flisk restart api |
| Preview without starting | flisk up main --dry-run |
| Catch config drift | flisk config verify |
| Upgrade Flisk | flisk upgrade |
| Issue | Fix |
|---|---|
flisk doctor fails | Run the fix commands it prints, then retry |
| Port 80/5432 in use | flisk doctor shows the owner; stop it or set FLISK_HTTP_PORT |
| Docker not running | Start Docker Desktop / systemctl start docker |
| Windows native | Use WSL2 Ubuntu; see Windows guide |
flisk up refuses | Run flisk doctor first; it explains what's missing |
Full troubleshooting: docs/troubleshooting.md
You write one service.json per service. For the two-service shop above, Flisk writes the rest at three levels: the project, the stack, and each service.
my-shop/
├── .env # generated DB_PASSWORD and JWT_SECRET
├── .flisk/
│ ├── project.json # project settings (yours to edit)
│ └── .flisk-out/ # PROJECT LEVEL
│ ├── Tiltfile # what Tilt runs
│ ├── docker-compose.traefik.yml # local gateway, bound to 127.0.0.1
│ ├── golden-layers.Dockerfile # shared base image layers
│ ├── TILT_TECH_STACK.star # tech stack settings
│ ├── TILT_RESOURCE_DEFAULTS.star # service defaults
│ ├── spec.master # project spec by stack
│ └── flisk-cli-ext/ # pinned copy of the Flisk engine
├── shared-platform-engineering/
│ └── docker-templates/ # container entrypoint scripts
└── services/
├── platform/database-management/
│ └── docker-compose.yml # Postgres 16
└── shop/
├── .autogenerated/ # STACK LEVEL
│ └── docker-compose.app.autogenerated.yml # every service in the stack
├── orders-api/
│ ├── service.json # you write this
│ └── .autogenerated/ # SERVICE LEVEL: 14 files
└── shop-web/
├── service.json # you write this
└── .autogenerated/ # SERVICE LEVEL: 18 files
The stack's Compose file is the part you would otherwise write by hand. For these two services it holds the image builds, environment, 33 Traefik routing labels, four networks, health checks, and CPU and memory limits. An excerpt:
orders-api:
environment:
- DATABASE_URL=postgresql://my_shop:${DB_PASSWORD}@my_shop_postgres:5432/my_shop_shop?schema=public
- JWT_SECRET=${JWT_SECRET:?JWT_SECRET is not set. Run `flisk up` ...}
labels:
- "traefik.http.routers.orders-api-project.rule=Host(`api.my-shop.localhost`) && PathPrefix(`/api/orders`)"
- "traefik.http.middlewares.orders-api-strip-prefix-project.stripprefix.prefixes=/api/orders"
- "traefik.http.services.orders-api.loadbalancer.healthcheck.path=/health"
healthcheck:
test: ["CMD", "curl", "-f", "--max-time", "5", "http://localhost:4000/health"]
Secrets come from the project .env by default: flisk project generates a random database password and JWT secret, and .env is added to .gitignore. Set FLISK_SECRET_PROVIDER=infisical to read secrets from Infisical instead (environment).
.autogenerated/ foldershop-web/.autogenerated/
├── Dockerfile.app.autogenerated # app image
├── Dockerfile.app.autogenerated.dockerignore # build context
├── nginx.autogenerated.conf # serves the build, routes API requests
├── vite.config.frontend.autogenerated.ts # dev server
├── vite.config.build.autogenerated.ts # production build
├── tsconfig.autogenerated.json # TypeScript, host
├── tsconfig.docker.autogenerated.json # TypeScript, container
├── .npmrc.autogenerated # package registry, host
├── .npmrc.docker.autogenerated # package registry, container
├── bunfig.autogenerated.toml # Bun settings, host
├── bunfig.docker.autogenerated.toml # Bun settings, container
├── .env.frontend.autogenerated # frontend environment
├── env.ts # API URL for your imports
├── api-client.ts # client for the frontend's API route
├── api-index.ts # re-exports the client and URL
├── service.yaml # Tilt's projection of service.json
├── validation-report.autogenerated.json # preflight validation result
├── AGENTS.md # tells coding agents not to edit here
└── .flisk-contract/ # snapshots for drift checks
orders-api/.autogenerated/
├── Dockerfile.app.autogenerated # app image
├── Dockerfile.app.autogenerated.dockerignore # build context
├── vite.config.backend.autogenerated.ts # server build
├── prisma.config.autogenerated.ts # database client
├── tsconfig.autogenerated.json # TypeScript, host
├── tsconfig.docker.autogenerated.json # TypeScript, container
├── .npmrc.autogenerated # package registry, host
├── .npmrc.docker.autogenerated # package registry, container
├── bunfig.autogenerated.toml # Bun settings, host
├── bunfig.docker.autogenerated.toml # Bun settings, container
├── .env.backend.autogenerated # backend environment
├── service.yaml # Tilt's projection of service.json
├── validation-report.autogenerated.json # preflight validation result
├── AGENTS.md # tells coding agents not to edit here
└── .flisk-contract/ # snapshots for drift checks
A stack with a database migrator also gets docker-compose.migrator.autogenerated.yml in the stack folder, and the migrator gets its own Dockerfile.migrator.autogenerated.
You never write an nginx config, a Dockerfile, a Compose file, or Traefik labels for this stack. flisk up regenerates these files when service.json changes and refuses to start if one was edited by hand. Python, Go, and Rust services, and optional features such as Playwright, get their own sets; the generated-files guide lists them and explains the drift checks.
If Helm, Compose, or your existing Tilt setup already gives you a working local environment, keep using it. Flisk CLI is for engineers managing several services who want a clear local service contract and one command to start the stack.
See how Flisk compares to alternative dev tools, how Flisk CLI works alongside Helm, the service schema, and the project configuration schema.
Use flisk ui to inspect stacks and resources. Arrow keys or j/k move the
selection; g/G or Home/End jump to the first/last item, and PageUp/PageDown
move one visible page. / searches; navigation letters remain search text
while searching. Press 1–5 to jump between tabs. The selected row stays
visible when the terminal is resized. See docs/ui.md for every key binding.
Keep Flisk up to date to get the latest bug fixes:
flisk upgrade
flisk update is an alias for the same command. If you installed with npm, you can also run npm install -g @flisk-sh/flisk@latest. To pin a version or read what changed, see upgrading and version pinning.
Runnable examples show Flisk on real stacks. Start with the smallest one:
| Example | What it shows |
|---|---|
| one-backend | One Bun/TypeScript backend with Postgres |
| one-backend-python | A Python backend in the same local stack |
| one-backend-helm | Working alongside Helm |
| byo | Bringing your own existing resources |
| byo-jobs | Bring-your-own jobs |
| flisk-example | A full multi-service stack |
Connect your coding agent with one command: flisk connect claude, flisk connect cursor or flisk connect codex adds the flisk mcp server (19 tools) and the Flisk skills to the project; add --dry-run to see the files first. What the agent can then do: Flisk for AI agents.
The repository ships agent skills for common Flisk work under .agents/skills: flisk-build (turn "build me a shop" into Flisk steps, check every URL, and report them), flisk-recipe-starters (start from a working restaurant, SaaS, store, AI agent or user-management app), recipes for a shop, a SaaS with login and billing, an AI agent with MCP tools and a database, and a blog (flisk-recipe-shop, flisk-recipe-saas, flisk-recipe-ai-agent, flisk-recipe-blog), flisk-doctor (environment checks), flisk-up (preview and start a stack), flisk-resource (create a service), flisk-status (health and URLs), and flisk-troubleshoot (fixing flisk and Tilt errors). More prompts to copy, by category (spreadsheets, recruiting, product management, shops, AI agents), are in the prompt gallery. Agents working in this repo also follow AGENTS.md. Use these skills to let your agent check your setup and explain failures instead of guessing at Docker or Tilt configuration.
Install the CLI with npm, with Bun, or as a prebuilt binary that needs no Node.js or Bun:
    |
This downloads Flisk with npm, which comes with Node.js 22.12+. Check it with For developers: public npm is the recommended default; to install through GitHub Packages instead, configure registry authentication as described in GitHub Packages installation. |
flisk up shop --dry-run previews selected local services and URLs before starting containers. The default starter is Bun/TypeScript; Flisk's core role is running local containers through Docker + Tilt, not providing a Node.js application framework. See the one-backend example.
service.json manifests and generated local configuration.Set FLISK_DEBUG=1 before running flisk up --verbose to include Starlark debug logs in Tilt output.
main that affects start-up)Flisk development began on 21 April 2026. The archived, read-only flisk-sh/flisk
repository records its first commit
("Initial commit: Flisk specs, generators, CLI, and standards") from that day. A separate flisk-cli history spanning 21 April to
18 September 2026 was imported into this repository as 306 filtered
commits. Those commits are now ancestors of main; the import did not change the source tree.
This flisk repository was created on 19 September 2026, and the @flisk-sh/flisk npm package was first
published on 21 September 2026. Those dates describe the current repository and package, not the start of Flisk development.
For the local runtime, install Docker (Desktop, OrbStack, or Colima; Engine 25+, Compose 2.20.2+) and Tilt. Bun 1.2+ is used by the default generated services. Flisk selects host ports from bounded fallback ranges for HTTP, HTTPS, and Postgres; set FLISK_HTTP_PORT, FLISK_HTTPS_PORT, or FLISK_POSTGRES_PORT to override them. Dev ports listen on 127.0.0.1 only, so other machines on your network cannot reach them. Set FLISK_BIND_ADDRESS (for example 0.0.0.0, to test from a phone) to change that; flisk doctor warns when it is a wildcard address. Flisk supports macOS, Linux, and Windows through WSL2 Ubuntu; native Windows supports CLI inspection only (flisk --version, flisk doctor, flisk up --dry-run). flisk up exits with a clear refusal pointing to WSL2. See the Windows & WSL2 guide for the recommended setup, prerequisites, verification steps, and troubleshooting.
On native Windows, flisk --version, flisk doctor, and flisk up --dry-run are inspect-only commands. flisk up exits 1 with “Landscape startup needs Ubuntu on WSL2. Native Windows is inspect-only.”
| Capability | Free | Premium |
|---|---|---|
flisk up, scaffold, Traefik, Postgres, Tilt live update, golden layers | yes | yes |
| Verdaccio, DDD scaffold, Sablier idle stop | no | key |
| Playwright, C4, AGENTS.md | free if generated in-repo | only if the implementation is downloaded with a key |
Core stays free. Premium is a separate key for the extras above; no key required to run flisk up.
Ecosystem map: examples, articles, related tools, and notes live in awesome-flisk-framework. Star this repo (flisk) if the CLI is what you run; use the awesome list to browse the rest.
Share: X · Bluesky · Threads · Mastodon · Reddit · Hacker News · Facebook · LinkedIn · Telegram · WhatsApp · Email
Yes, if you build with an AI helper like Claude Code, Codex or Cursor. You describe the app; the helper writes it and uses Flisk to run it on your computer. Start here walks you through it step by step, and Words you'll see explains the terms. You will paste a few commands into a terminal, but you do not need to write any code.
The Flisk command-line tool is free and open source (MIT); optional Premium extras need a key (see the license matrix). Your AI helper has its own plans and prices. Bigger apps also use Docker Desktop, which is free for personal use and small companies.
No. Flisk runs your services with Docker and Tilt on your machine. It does not need a local cluster such as kind or minikube, and it does not replace Helm, Compose, or your production deployment tools.
No. Core CLI is MIT and needs no key to run flisk up. Premium extras are optional and use a separate key (see the license matrix).
macOS and Linux are supported directly. Windows is supported through WSL2 Ubuntu; native Windows supports CLI inspection only (flisk --version, flisk doctor, flisk up --dry-run). See Requirements and support and the Windows & WSL2 guide for the recommended setup, prerequisites, verification steps, and troubleshooting.
Flisk runs the local stack on your machine. For network calls, secrets, and supply-chain details, see security: network calls, secrets and supply chain.
Yes. If your existing setup already gives you a working local environment, keep using it. See working alongside Helm and gradual adoption for adding Flisk to an existing repository.
Update first; a recent release may already fix it. Run flisk upgrade (also available as flisk update), or:
npm install -g @flisk-sh/flisk@latest
Then run flisk doctor and retry the same task. If the problem persists, open an issue with your Flisk version, operating system, steps to reproduce, and the error output. See upgrading and version pinning and troubleshooting.
Contributions are welcome. First step: say hello on Discord, tell us what you want to work on, and we will point you to a good first task. Then start with CONTRIBUTING.md and the contributor guide. For the project structure, see the architecture and repository map. To review pull requests, see Review a pull request. Report security issues using SECURITY.md.
Thank you to everyone who has shipped code, docs, and fixes to Flisk since July 2026. Every merged change makes the local stack better for the next developer.
Flisk is MIT-licensed; see LICENSE. The license boundary says which code is MIT and which is downloaded with a key.
Project governance: GOVERNANCE.md, MAINTAINERS.md, ADOPTERS.md.
Using Flisk in Slack or Discord? Get the Flisk green thunder emoji (SVG and PNG, MIT).
FAQs
Flisk: your whole app, running on your computer with one command.
The npm package @flisk-sh/flisk receives a total of 0 weekly downloads. As such, @flisk-sh/flisk popularity was classified as not popular.
We found that @flisk-sh/flisk demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 2 open source maintainers collaborating on the project.
Threat Research
/Security News
319 browser extensions installed by 13.4 million users hijack searches, capture queries, and collect referral payments from Yahoo and Bing.
Threat Research
Malicious Firefox extensions mimic Phantom, Jupiter, and Bitget wallets to steal recovery phrases and private keys, with one fetching its payload remotely.
Product
Socket Threat Intel now shows which malware campaigns were blocked or detected in your organization, with links to scans and Firewall events.
