Skip to content
| Marketplace
Sign in
Visual Studio Code>Programming Languages>QuilloNew to Visual Studio Code? Get it now.
Quillo

Quillo

Quillo Lang

|
3 installs
| (0) | Free
Quillo language support: highlighting, diagnostics, quick fixes, hover, go to definition, completion, end tags closed as you type, outline (via `quillo lsp`) and debugging (via `quillo dap`).
Installation
Launch VS Code Quick Open (Ctrl+P), paste the following command, and press enter.
Copied to clipboard
More Info

Quillo for VS Code

Language support for Quillo, the small web language.

  • Highlighting for private and public before a definition, site shop = "...", a script's #! line, routes and paths, HTML literals (tags, .class#id, @event, bind:value), string interpolation, state declarations, type records, numbers such as 1e-9, types, effects and pipelines. SQL is highlighted as SQL in the string (or template) passed to db.exec, db.one and db.query, and in sql`...`.
  • Diagnostics as you type: unknown names, wrong arguments, type mismatches, effects, component props, code that cannot run in the browser, unused variables.
  • End tags: an element that is never closed is underlined at its start tag, with a quick fix (Ctrl+. / Cmd+.) that adds the end tag where it belongs; a mistyped end tag (</dvi>) has one that corrects it. Typing a start tag's > adds its end tag after the cursor, and typing </ finishes the end tag of the element open there (setting quillo.autoCloseTags).
  • Hover shows types and signatures; Go to Definition works across used files.
  • Classes: from a class in markup (<span.chip>, class="chip"), Go to Definition goes to its CSS rules (in css(...), a component's style, or the CSS files under public/) and hover shows them. Find All References lists its rules and every place the markup writes it, from either side, and Rename Symbol (F2) renames it in both (a class put together, as in card-${size}, is left as it is). A class no sheet has a rule for is marked: a warning when it is close to one that has (.chiip: did you mean chip?), else a faint hint.
  • Completion for your functions and variables, builtins (with signatures), the members of db., http., json., udp., channel., media., crypto., image., math., stats., vec., date., bit. and later., keywords, types, HTTP methods and effects (net among them); after < in markup, your views and components and HTML's elements; after </, the end tag to write; after <span. and in class=", the classes your style sheets define.
  • Parameter hints: inside a call, as you type ( and ,, or with Ctrl+Space, the function's parameters with the current one marked, and a line about what it does: for builtins and .qwer functions, and for your own, from the comment above them.
  • Outline of functions, views, components, variables and routes.
  • Private names: hover and the outline say private fn page_of(...); another file's private names are not offered in completion (nor its private views after <).
  • Snippets: import, client, preload, site, tool (a script reading its input a line at a time), route, routejson, fn, fnb, pfn (private fn), server fn, view, component, match, for, page, and for real time: udplisten, channelon, channelopen, mediartp, quillo-media.
  • File icons: a quill for .qwe files, and a quill with a gear for .qwer files, in the default (Seti) icon theme and any other that has none of its own for them.
  • Rust in .qwer files: highlighted as Rust, with the //! [dependencies] header as TOML; the Rust compiler's errors and warnings as you open and save (through cargo check); the same for a .rs file a program uses (import tw.rs use f), while a crate's own .rs files, which no .qwe file names, are left to rust-analyzer; a warning on each pub fn Quillo cannot export, saying why; hover shows how Quillo sees an export, and the outline lists them. Their functions are checked, completed and hovered in the .qwe files that use them.
  • use and import lines: paths with or without quotes, ./ and ../ counting from the file that writes them, the names taken from a file, as, *, and import, client, preload, preconnect and module are highlighted, as are 0.6's with preload and with preconnect. Go to Definition on the path opens the file, and on a name goes to its Rust function, whose signature hover shows (under the name after as). The path completes to the program's files. On import lib/x.qwe use ... the names complete to the file's functions as you type, as they do before from on 0.6's use a from lib/x.
  • Debugging (F5 in a .qwe file): breakpoints (with conditions, hit counts and logpoints), stepping, the stack, variables (locals, globals and the request), the debug console, and stopping where a runtime error happens. Through quillo dap; see Debugging in the user guide. With "browser": true in the launch configuration, the page opens in Chrome ("edge": Edge) with VS Code's JavaScript debugger too, and the same breakpoints stop in the components' browser code (event handlers, updates), through source maps to the .qwe files.
  • Commands: Quillo: Run this file (watch mode) (also the ▶ button), Quillo: Debug this file, Quillo: Check this file, Quillo: Restart the language server, and Quillo: New program, which asks for the to-do app or a minimal one and a folder, runs quillo new and opens it (needs a quillo that has new).

The editor features come from quillo lsp, the language server built into the quillo binary, and the debugger from quillo dap. The extension looks for the binary in the quillo.path setting, then in target/release or target/debug of the open workspace, then on your PATH.

Install

  1. Install the extension: search for Quillo in the Extensions view (from the Visual Studio Marketplace, or, in VSCodium, Cursor, Windsurf, Gitpod and other editors built on VS Code, the .vsix from the releases with Extensions: Install from VSIX..., or Open VSX once a release is published there).

  2. Install quillo, which the extension runs: download it for your system from the releases and put it on your PATH (or point the quillo.path setting at it), or build it with Cargo:

    cargo install --git https://github.com/quillolang/quillo quillo
    

To build the extension from this repository instead:

git clone https://github.com/quillolang/editors.git quillo-editors
cd quillo-editors/vscode
npm install
npm run package                   # builds quillo-lang-<version>.vsix
code --install-extension quillo-lang-*.vsix

Other editors

For IntelliJ IDEA, WebStorm and the other JetBrains IDEs, see jetbrains/.

Any editor with LSP support can run quillo lsp over stdio for *.qwe files. For example, Neovim:

vim.filetype.add({ extension = { qwe = "quillo" } })
vim.api.nvim_create_autocmd("FileType", {
  pattern = "quillo",
  callback = function() vim.lsp.start({ name = "quillo", cmd = { "quillo", "lsp" } }) end,
})

Helix (languages.toml):

[language-server.quillo]
command = "quillo"
args = ["lsp"]

[[language]]
name = "quillo"
scope = "source.quillo"
file-types = ["qwe"]
comment-token = "//"
language-servers = ["quillo"]

For debugging, any editor with a Debug Adapter Protocol client can run quillo dap (a launch takes program, args, cwd and stopOnEntry). Neovim, with nvim-dap:

local dap = require("dap")
dap.adapters.quillo = { type = "executable", command = "quillo", args = { "dap" } }
dap.configurations.quillo = {
  { type = "quillo", request = "launch", name = "Debug this file", program = "${file}", args = { "--watch" } },
}

Development

npm test checks the grammar against sample lines and the example programs.

  • Contact us
  • Jobs
  • Privacy
  • Manage cookies
  • Terms of use
  • Trademarks
  • Your Privacy Choices
  • Consumer Health Privacy
© 2026 Microsoft