Put this in your browser's address bar. If you have FLASH installed, your terminal opens and starts working:
flash://?prompt=Introduce+yourself+and+explain+what+makes+you+different
No copying. No pasting. No alt-tabbing to a terminal to type the thing you already typed once.
A website handed a prompt to a local AI running on your own machine, and the model that answers it never touched anyone's server.
There's a live one on flashproject.dev under the install section if you want to click it instead of typing it.
Last time I introduced FLASH: local models, real shell access, zero cloud.
👉 Read part 1 first if you missed it (it covers the why; this post is the what else)
I cut a lot from that one to keep it tight. This one is everything I had to cut.
It can see your browser
FLASH renders real pages through Playwright and looks at them. Not a fetch of the HTML. An actual browser, at a viewport size you pick, screenshotted and read back as pixels.
❯ screenshot localhost:3000 at phone width and tell me what's broken
⏺ Screenshot(http://localhost:3000, 390x844)
⎿ screenshot captured
The nav collapses but the menu never opens, so at 390px the links
are simply gone. Everything below the hero is also pushed 40px off
the right edge, which is what's causing the horizontal scrollbar.
Want me to fix it?
Reading your own HTML back is not checking. Every AI that "builds you a page" and hands it over unopened is guessing that the source it wrote is the page you got. This one looks.
To be straight with you about the boundary: it sees, it doesn't click. There's no filling forms or walking a checkout flow yet. It renders a URL at a size you choose and reads what came out.
That yet is doing real work in that sentence. Clicking isn't off the table, and this paragraph is a snapshot like everything else here: it may not still be true by the time you're reading it.
When a tool isn't ready, it fixes the tool
Here's the part I actually want to show you, because it says more about how FLASH behaves than any feature list can.
Playwright ships without its browser binaries. So the first time you ask for a screenshot, the tool fails:
⏺ Screenshot(https://www.google.com, 1280x800)
⎿ Error: Playwright is installed but its Chromium is not. You can
download it with `playwright install chromium`. Install it, then
re-run this tool
Installing Chromium for Playwright to enable the screenshot tool.
⏺ Bash(playwright install chromium)
Read that middle line again. It didn't hand the error back to you. It didn't say "it looks like Chromium isn't installed, you may want to run…" and then stop, leaving you to paste a command it already knew.
It read the error, understood the fix was within reach, said what it was about to do, and did it. Then carried on with the screenshot you originally asked for.
That's the whole design philosophy in six lines. A missing dependency is not a dead end, it's just the next step. The tools are real, the shell is real, and an agent holding both should not need you to be its hands.
It can see your screenshots
Same idea, pointed at anything on disk. You don't need a command for it. Name the file in a normal sentence:
❯ Look at mockup.png and make a site that looks like it.
❯ Here's the crash: error-report.png. What am I actually looking at?
It reads the actual pixels. Error text and labels get read literally, character for character. If a region is cropped or too blurry to read, it says that instead of quietly inventing what was probably there.
Prefer to be explicit? /image <path> <prompt> does the same thing, with path completion as you type, filtered to PNG, JPG, JPEG, WEBP, GIF and BMP, and paths with spaces quoted for you so they never break the parse.
It remembers you after you close it
Most AI tools have a goldfish problem. Every new window, you re-explain your stack, your conventions, where things live.
FLASH remembers across sessions, not just within one:
- Tell it to remember something and it sticks.
- Ask it to recall and it searches everything it knows by keyword.
- Tell it to forget and it's gone for good.
And within a session, automatic history trimming keeps the conversation inside the model's token limit, so a long afternoon of work never dies with a context error.
It types back at you
The final reply streams in as the model produces it. Tokens land as they're generated instead of a spinner sitting there while you wonder if it hung.
What lands is formatted, too: real markdown rendering in the terminal. No raw asterisks, no wall of undifferentiated text. When terminal text isn't enough, it generates actual DOCX and PDF files.
Sit idle for a moment and a rotating tip sweeps in letter by letter, cycling example commands and prompts worth trying. It's a small thing. It's also the difference between a blinking cursor and something that feels alive.
Three ways to drive it
1. Slash commands. FLASH suggests them as you type, so you never have to remember the exact one:
| Command | What it does |
|---|---|
/help /?
|
Show the help message |
/model |
Show or switch the active model, live |
/auto |
Toggle autonomous mode |
/set |
Set any env var, no restart needed |
/unset |
Remove an env var |
/refresh |
Reload your config from disk |
/clear |
Clear the conversation history |
/image |
Hand the model an image explicitly |
/bye |
Exit |
That table grows, and I'm not going to come back and edit this post every time it does. /help always shows the current set, so trust it over anything written here. Odds are decent that something new is being committed while you're reading this.
2. A ! prefix, for when you don't want AI at all:
$ !git status
$ !npm run dev
That's a real terminal channel, not a simulation. Interactive prompts work. Editors work. And passwords typed into a ! command never touch FLASH or the model: they go straight into your terminal's masked input layer, invisible from the first keystroke. FLASH doesn't see them, doesn't log them, can't.
3. Plain English. Just say what you want. If it needs to read a file, run a command, look at an image, or search the web, it reaches for the right tool itself.
You reconfigure it without ever restarting it
This is the one I miss most in other tools.
❯ /model flash-onyx-2:31b
❯ /set OLLAMA_HOST http://192.168.1.50:11434
No restart. No hunting for a JSON file. No losing your conversation. Every change is written straight to ~/.flash.env for you, so it's still there next time you launch.
Prefer a text file? That works too, and docs/CONFIGURATION.md in the repo has the full variable list.
It runs where you want it to run
One environment variable decides where the intelligence lives:
| Local |
OLLAMA_HOST unset, http://localhost:11434
|
| Remote | OLLAMA_HOST=http://192.168.1.50:11434 |
Laptop to home server to cluster, without changing a single thing about how you work.
And to be clear about what "local" means here, because the word gets abused: plenty of AI coding tools look local. They run shell commands and read files right on your machine. But the model doing the thinking is still on someone else's servers, and your files and commands and code travel there first.
The tools run locally. The model runs locally. Your data doesn't leave the building unless you tell it to.
Autonomous mode, and the part nobody thinks about
/auto on and FLASH stops asking permission before each command.
The interesting engineering isn't the permission toggle. It's this: when the agent runs a command itself, input is cut automatically. A self-aware execution layer, built so the agent can never stall forever waiting on a prompt it cannot see. Real autonomy, not a frozen process you discover twenty minutes later.
(Autonomous mode lets it run shell commands without asking. That's genuinely risky. Use it on machines and directories you trust.)
It tells you when it's done
On Windows, FLASH sends a notification the moment it finishes or needs your input, even if the window is minimized.
Kick off something long, go read something else, get pulled back exactly when you're needed. The terminal stops being a thing you have to babysit.
The brain behind it
Everything above is the shell. The intelligence is a separate question, and it's the one I've spent the most time on.
Flash Onyx 2 is the flagship model: gemma4-based, 12B and 31B, 32K context, text and images. It finishes what you asked for, says what it actually verified, refuses to invent a flag it hasn't seen, and won't rebase a commit you've already pushed.
Those numbers move too. New builds ship and this paragraph won't chase them, so treat flashproject.dev as the current spec and this as a snapshot of the day I wrote it.
👉 I wrote up all 14 of its capabilities here
It's worth its own post. It got one.
Install it in under a minute
# macOS / Linux
curl -fsSL https://flashproject.dev/install.sh | bash
# Windows
irm https://flashproject.dev/install.ps1 | iex
flash
That's it. The installer clones the repo, installs with pipx, and cleans up after itself. It also registers the flash:// handler, which is why the link at the top of this post works.
Changed your mind? One line, no residue:
curl -fsSL https://flashproject.dev/install.sh | bash -s -- --uninstall
(There's a manual path too, if you'd rather do it yourself. Note the URL handler only gets registered on the quick install.)
One last thing
FLASH isn't vibe-coded. Every change is reviewed thoroughly by a real human before it ships. In a moment where "I generated an entire tool this weekend" is a flex, I'd rather tell you the boring truth: somebody read every line.
Where to go next
🔗 flashproject.dev for the full breakdown, the demo video, and that clickable flash:// link
⭐ Star it on GitHub if any of this sounds like something you'd use
💬 Tell me what's missing. The ! prefix, the URL scheme, and persistent memory all exist because somebody said "I wish it could…" in a comment thread
Follow me here and I'll show you what lands next. There's more coming, and the roadmap is genuinely shaped by what people ask for in these threads.
If the browser thing surprised you, or you didn't know a website could hand a prompt to a local AI, pass this along to the person you were just complaining about cloud AI with.
Top comments (0)