Highlights

• Ask, don't dig. Describe the change on the page you are looking at. The model finds the code, edits it, and the page reloads.
• Any model. Claude, GPT, Gemini, Mistral, OpenRouter, local models through Ollama, LM Studio or llama.cpp, any OpenAI-compatible server, or the Claude Code, Codex and Gemini CLIs you already use. No CLI? The agent built into the Claude Desktop or ChatGPT app works too.
• All your sites in one place. A dashboard lists your projects. Each one is served as-is or behind your dev server (Vite, Next, Astro…).
• Safe by default. Sandboxed file tools, a backup before every edit, one-click Undo, and API keys that never reach the browser.
• Every request is a version. Browse them in the bar, preview any of them live without touching your files, and go back to it in one click.
• Nothing to install in your project. The bar is added while pages are served, never written to disk. Zero dependencies: just Python.

Quick start

You need Python 3.10+, nothing else. Runs on Linux and macOS (Windows is not supported).

curl -fsSL https://ybucaille.github.io/livequill/install.sh | sh
livequill

The script installs a single file, livequill.pyz from the latest release, after checking its SHA-256. It goes in ~/.local/share/livequill, with the livequill command in ~/.local/bin. It needs no root, no git and no pip. Run it again to upgrade. It is tested on Ubuntu, Debian, Fedora, Rocky Linux, Arch, Alpine, openSUSE and macOS. If Python is missing, it tells you the command for your distribution.

Press Ctrl+C in the terminal to stop it.

1. Setup. The first launch opens the setup page. Pick a provider: paste an API key, or click a local model or CLI agent detected on your machine.
2. Add a site. You land on Mes sites (the interface is in French for now). Add a project folder, or the URL of your running dev server.
3. Open it and ask. The site opens with the floating bar. Try “make the hero title red”, watch it change, then click Undo.

Handy shortcuts:

livequill ~/projects/my-site                            # add this folder and open it
livequill --proxy http://localhost:5173 ~/projects/app   # same, behind your dev server

Screenshots

Mes sites. Add, edit, open or stop each project. Every site runs on its own port, with its own history.	Setup. Each provider shows Available (connection checked live), Detected (one click away), or a link to get a key.
Live panel. The answer streams in, with the tools called and the files changed. It survives the reload.	Themes. Claude, ChatGPT, Gemini and Minimal, in light and dark, following your system.

What the bar can do

Providers

Desktop apps, no CLI needed

The Claude Desktop app ships with its own copy of Claude Code, and the ChatGPT app (and the Codex app on macOS) ships with Codex. If the CLI is not installed, LiveQuill uses the agent built into the app, with the account you are already signed in with. The setup page shows it as “Trouvé dans l’app Claude Desktop”, the connection test checks that you are signed in, and the newest version is picked every time the app updates itself.

An installed CLI always takes priority. The macOS locations follow the same layout as Linux but have not been tested on a real Mac yet.

Security

LiveQuill lets a model touch your files, so the guard rails are on by default:

• Local only. Servers listen on 127.0.0.1, reject foreign Host headers (DNS rebinding), and require a per-launch session token plus a same-origin request on every API call.
• Keys stay server-side. Stored in ~/.config/livequill/config.json (folder 700, file 600), never sent to the browser, masked in error messages and logs.
• Sandboxed tools. No path outside the project, no .git/, .env* or node_modules/, and no shell commands for API and local models. Files are opened without following symbolic links at any level, so a path cannot be swapped for a link between the check and the write; the web server applies the same rule to the files it serves.
• Backups first. Every file is saved to <project>/.livequill/history/ (private, 700/600) before it changes. That folder ignores itself in git.
• Undo for CLI agents. Claude Code and Codex write files themselves, so the project is copied before each request (everything except .git/ and node_modules/, .env* included) and compared afterwards, content included. Undo then restores modified, deleted and created files, and replaces any symbolic link an agent left in their place. If the project is larger than 2 GB, the request is refused rather than run without a reliable undo.

Found a vulnerability? Please report it privately: see SECURITY.md.

How it works

sequenceDiagram
    participant B as Floating bar
    participant S as LiveQuill (site server)
    participant M as Model (API · local · CLI)
    participant F as Project files
    B->>S: request + page context + attachments
    loop until the model answers without tools
        S->>M: messages + tools
        M-->>S: streamed text / tool calls
        S->>F: search · read · edit (sandboxed, backed up)
        S-->>B: live events (text, tools, files)
    end
    S-->>B: reload

bin/livequill     launcher (no install needed)
livequill/
  cli.py          command line
  server.py       dashboard, per-site servers (folder or proxy), script injection, API, live reload
  agent.py        agent loop, tools, text fallback, page context, history
  sandbox.py      locked-down paths, file tools, backups and undo
  config.py       providers and sites (chmod 600), secret masking
  adapters/       one adapter per provider family
  static/         the bar (overlay.js), setup page, dashboard
site/             showcase website (GitHub Pages)
scripts/          demo recorder, JS syntax check
tests/            unit and integration tests, network mocked

from .base import Adapter, levels

class MyAdapter(Adapter):
    kind = 'my-provider'
    default_base = 'https://api.example.com'

    def list_models(self): ...                    # -> [{"id", "label", "meta"}]
    def caps(self, model, meta=None): ...         # -> {"tools", "vision", "effort", "fast"}
    def build_request(self, model, system, messages, tools, opts): ...  # pure, easy to test
    def parse_stream(self, lines): ...            # -> delta / thinking / part / stop events

Roadmap

Planned

• Dynamic sites with a mock database. Support for sites with a backend and a database, plugged into a disposable mock database seeded with demo data, so the model can work on data-driven pages without ever touching real data.

Ideas

• Point and ask. Click an element on the page, like the browser inspector, to scope the request to it: “make this button bigger”.
• Review before writing. An optional mode that shows the proposed diff for each file and waits for you to accept or reject it.

Want to help with one of them? Open an issue or a pull request.

FAQ

Why the name LiveQuill?

A quill is the pen you write and correct a page with. Here you write the change on the page itself, and the model rewrites the source live, while you watch. It is short, not tied to any model vendor, and easy to type as a command.

Does my code leave my machine?

Only if you choose a cloud provider. With Ollama, LM Studio or llama.cpp, everything stays on your computer. With a cloud API, your request, the page context and the files the model reads are sent to that provider, like with any coding assistant.

Can I use it without an API key?

Yes. Install Ollama, pull a model that supports tools (ollama pull qwen2.5:7b-instruct), and pick it on the setup page. If you already use Claude Code or Codex, LiveQuill can also work through them with your existing login.

Does it work with React, Vue, Svelte or Next.js?

Yes. Keep your dev server running and add the site with its URL (or run livequill --proxy http://localhost:5173 ./my-app). LiveQuill adds the bar to its pages and passes hot-reload WebSockets through, while the model edits your components.

What if the model breaks something?

Click Undo in the bar. The files changed by the last request are restored from the backup taken just before the edit, and you can undo several requests in a row. To go further back, open Versions (the clock button), preview the version you want, and click Revenir à cette version.

Where is my data stored, and how do I uninstall?

Your providers, keys and sites live in ~/.config/livequill/config.json. Each project gets a .livequill/ folder with its backups and conversation history. To uninstall, run curl -fsSL https://ybucaille.github.io/livequill/install.sh | sh -s -- --uninstall (or pipx uninstall livequill, or delete the cloned folder). Then delete ~/.config/livequill/ and the .livequill/ folders you no longer need.

I only have the Claude Desktop or ChatGPT app. Does it work?

Yes. LiveQuill finds the agent built into the app and uses it with your existing sign-in, so there is no CLI to install and no API key to create. See Desktop apps, no CLI needed.

Which local model should I pick?

A 7B model or larger that supports tool calls, such as qwen2.5:7b-instruct, qwen3 or llama3.1. Smaller models work for simple edits, but get lost more often in big files.

Contributing

Contributions are welcome: adapters, themes, roadmap items, fixes and translations (the interface is currently in French). Start with CONTRIBUTING.md. Every pull request runs the full CI (tests on Linux and macOS for Python 3.10 to 3.14, lint, secret scan, CodeQL) and is reviewed by the maintainer before merging.

python3 -m unittest discover -s tests     # about 8 s, no network
node tests/e2e/browser.mjs                # real headless Chrome: edit → reload → undo → versions

License

MIT © 2026 Ybucaille