Blog
How Quillo's ideas came about, from the year it was only an idea: what each one is for, and what it replaces. Follow the feed, or get them by email.
Most of what we call separation of concerns is separation of files, languages and processes. Each cut makes a seam, and an unchecked seam becomes the concern. Separate by meaning, and let the tool check the cuts.
A Quillo program now runs on a real iPhone: the runtime inside the app, routes served on the phone itself, and real GPS, compass, camera and microphone, with no change to the program.
A component now names the JavaScript library it uses with use, calls it as JavaScript reads (Chart.new, L.map, confetti()), and the page loads the script only where that component is.
Quillo 0.6 lets a file keep names to itself, takes plugin functions by name and under names of your own, installs plugins from the catalog, and drops the quotes from use.
The Quillo UI kit grew from 108 components to 491, with 65 charts from bar charts to an order book, all searchable by tag. And a measurement of what a program pays for holding them.
Build one program, deploy one binary, and when one part gets busy, give it copies of its own, without changing a line. The escape hatch is a flag, not a rewrite.
A page should carry the CSS of what it shows, not of every component the program has. style global did that for the booking app's home page, from 115,598 bytes to 30,663.
A forum, a project board, a newsroom, a bank of five services and a booking platform, each built in Quillo to bring out what breaks. Seventy-nine issues so far.
Exact decimals were the start. An amount also has a currency, minor units and rounding rules, and a split that must not lose a cent.
A language is used in an editor. A language server for hover and checks as you type, and a debugger with breakpoints in routes, views and components.
Many admire Rust, and few want to write their web app in it. Quillo is written in Rust so that web developers get what Rust gives without writing it, and the few who love it still can.
A typical web app is a dozen tools with a dozen configs, each upgraded on its own schedule. What it looks like when most of them are one language and one binary.
An interpreter is slow at loops of numbers. Quillo compiles the functions that only do arithmetic to machine code, and gives the same answers as before.
Most languages are general-purpose and leave the web to frameworks. Quillo goes the other way, a language made of the web's own parts, and that choice explains everything unusual about it.
One process on one core is where most web servers start, and where busy ones run out of room. Quillo spreads the same program over every core, then over several servers, without a broker in between.
Image processing, parsing, a fast library from crates.io. A .qwer file is Rust, used like a .qwe file, with its functions callable from Quillo.
Cursors, game moves and chat need messages both ways as they happen. A channel opened by a component, and handled on the server in a few lines.
Start as one program, and move the heavy part to servers of its own when it needs them, without rewriting the calls between them.
A client that sent a payment and got no answer cannot tell whether it went through. Idempotency keys let it ask again safely; idempotent() makes them one line.
A link someone points at is a link they are about to follow. Fetching it then makes the next page appear at once, as long as fetching it can never change anything.
"1 items" is the most common translation bug on the web. Plural rules per language, built in, make t() say the right thing in Polish and Arabic too.
A language is mostly small choices. A few from the prototype: what braces mean, where a line ends, and why `for` cannot name a label.
After a year and a half of notes, Quillo runs. A tree-walking interpreter in Rust reads a .qwe file and serves its routes.
Type checkers stop at the edge of the language. When routes, markup and effects are the language, the checker can see the whole web program.
Signing in should take three lines and be safe by default. Signed cookies, the right flags and a short list of rules can be the language's job.
0.1 + 0.2 is not 0.3 in most languages, and every shop finds out at checkout. A web language should have exact decimals built in, with a literal of their own.
Async functions spread through a codebase like a dye. A web language can wait where it must and keep every function looking the same.
A type in most web stacks is a promise about data that was never checked. A record that is checked at the door, with its defaults filled in, is a type you can trust.
match, let, for and routes all take apart values. If they share one pattern language, learning one teaches all four.
A year of design notes, and the plan for turning them into something that runs. The first version will walk the syntax tree, in Rust, and serve its own routes.
Real-time pages usually need a message broker, topics and code on both ends. If the language sees what a page read and what a request wrote, it can do the wiring itself.
Server rendering usually means rendering twice: once on the server, then again in the browser to attach the events. A page could instead pick up where the server left off.
Interactive pages usually mean two programs, an API between them, and types kept in step by hand. What if a component and the server function it calls sat in the same file?
A function's signature says what goes in and what comes out, but not whether it writes to the database on the way. A short `with` clause can.
Exceptions jump past the code that could have handled them. An error that is a value can be passed on, given a fallback or answered with, in one character.
Data moves through a web program in steps. A pipe operator lets the code read in the order the data moves, without a class for every step.
Naming a language is hard. This one was named by a tired pair of hands, resting on the keyboard after a long night of coding.
Validation usually happens inside the handler, after the request is already in. A pattern in the route can turn a bad request away before any code runs.
Templates are strings with holes in them. What changes when markup is an ordinary value the language can check, pass around and escape on its own?
Most web code is a router, a template engine and a validator glued together. The first idea behind Quillo: make those three the syntax itself.