The Framework That Disappears: How Rich Harris Built Svelte by Admitting He Was Wrong

Svelte is the only JavaScript framework that’s actually enjoyable to use. That’s not a neutral observation — it’s the thing people say after they try it, often with a kind of surprise. The code is small. It reads like plain HTML, CSS and JavaScript. And somehow it’s faster than the frameworks that ship entire runtimes to every user.

Rich Harris is the creator of Svelte and one of its lead developers. We’re in his flat in Carroll Gardens, Brooklyn, and he’s explaining why the project exists at all.

The honest answer is that Svelte began as an act of atonement.

It Started With a Name Nobody Believed Was Real

“It’s always really difficult to find a name for a project that isn’t already a package on NPM,” Harris says. “We had a brainstorming at work, and I was working at The Guardian at the time, and the team that I was working on became a little brain trust. We tried to think of a word that kind of meant lean, and zippy, and fast and elegant. And Svelte is a word that means all of those things. It means sort of live and athletic. It just felt like a really good fit.”

A lot of people didn’t believe it was a real word. Some said it sounded like a dishwasher tablet brand. But it stuck, and the connotations fit.

Svelte is a language for creating user interfaces on the web. When it launched, the term they used was “a framework without the framework.” Harris admits it was a bit of a marketing sleight of hand, but it reflected the mindset: rather than thinking of a framework as something that runs your code, a framework is really a way of thinking about your code.

Doing the Work Before the App Runs

The core idea is simple to state and hard to execute. Svelte tries to do as much work as possible at build time instead of at runtime.

React, by contrast, will do work to compute the difference between what’s currently on the page and what should be on the page — every time, in the browser. Svelte takes that logic and tries to do as much of it as possible before the application even runs.

The mechanism is a compiler. It takes your declarative component code and turns it into an approximation of what you would have written if you were writing hand-optimised vanilla JavaScript.

Which is why Svelte doesn’t ship a library. It ships your code.

A Career That Started With Being Too Cheap to Fire

Harris didn’t come up through computer science. He left journalism school looking for work at a time when everyone was telling journalists to learn to code. He tried to teach himself PHP and didn’t really get into JavaScript.

Then he took a job at a financial publication in London, around the time of the 2008 crash. “A bunch of people got laid off because the economy was crashing. And I thought it was going to be a last in, first out situation, and that I was on the chopping block. But they weren’t paying me enough for it to be worth their time to fire me. So I survived.”

The lesson he took from it: if he was going to make it, he needed to become more employable. He drifted toward technical roles. A couple of years later, they needed someone to do basic HTML wrangling. He was in the right place at the right time.

At that point he was watching the work coming out of the BBC, The Guardian and The New York Times — interactive journalistic experiences built with Flash and increasingly with JavaScript. “I got very inspired by the work that I was seeing happen at those places. Like, I want to do that.”

Ractive, and the Sin of Shipping Too Much JavaScript

When he started doing visual journalism, the tooling wasn’t good. Writing rich interactive applications was hard. With the naivety of youth, he thought he could solve it.

He started working on a framework called Ractive, inspired by a mashup of Knockout and Angular. It had some success, was used by a few companies, and introduced ideas that are now table stakes — single file components among them. But it wasn’t good enough to compete with the bigger frameworks.

And then he changed his mind about the whole approach.

“After a few years, I became of the view that Ractive, like many of the frameworks from that era, weren’t really well suited to the era of the mobile web. The reality was that we were shipping too much JavaScript, and we were doing too much work, and we needed to kind of reset our expectations around what frameworks look like.”

That’s the atonement. Svelte began as a correction to his own earlier work.

Two Ideas Colliding in Brooklyn

The origin traces back to BrooklynJS, a monthly meetup around the corner from where he lives now. One evening he was talking to Jed Schmidt, one of the organisers, about the idea of turning the code you’d written into something else — compilers. Harris didn’t fully understand it at the time, but the idea lodged in his brain.

Two things came together: his own sense of responsibility for having built a framework that shipped too much JavaScript, and the idea that compilers could deliver a better user experience.

Around Thanksgiving 2016, the idea for Svelte happened. He spent a few furious days coding, and at the end there was version 1.

The People Who Kept It Alive

The earliest contributor was Conduitry, who came on board during Svelte 1 and, in Harris’s words, “has kept the project afloat at a number of critical times. Like, it wouldn’t be here today without him.”

Li Hau joined in 2019. Ben joined in 2020. Those three are members of a core team of around twelve people. But the contributor base is far larger — if you count everyone who has committed code to the main Svelte repo, it’s upwards of 450 people.

Svelte 1, 2, and the Rulebook Tearing

Svelte 1 was basically Ractive with a compiler. It inherited a lot of the same design, and Harris hoped the existing Ractive community would come along.

By Svelte 2, they’d realised some of Ractive’s design decisions were wrong and that people’s expectations had shifted. Svelte 2 was a slight refinement — single curly braces in the template syntax instead of double, so it looked more like JSX. Cosmetic changes, mostly.

Svelte 3 was when they tore up the rulebook.

“We started thinking, we have a compiler, we can essentially create our own language. What would it look like if we were to create the most elegant and usable way of describing user interfaces? Whether we achieved that or not, I don’t know, but I think we got pretty close.”

That was the release that changed everything. It’s the one people heard about on Twitter. It’s the one that made developers want to teach it immediately, share it immediately, build more things in it.

Why It Clicks

The technical explanation is about bundles. With most frameworks, a large chunk of library code has to go along to every user who opens your site. Someone visiting to check out a recipe is still downloading that whole bundle.

Svelte compiles your Svelte files into just JavaScript — transforming the code you’re actually using into smaller pieces you can ship to the client, without a library full of code you may or may not be using.

But the practical explanation is simpler. “What Svelte allows us to do is to write code that’s not only small and simple, but plain and readable, in a way that I think instantly attracts people when they try it.”

People might hear about the disappearing framework and get excited. But nothing gets them as excited as trying it out and seeing how much they can accomplish with a few lines of reall y simple code.

If you use React or Vue, the pieces are glued together with JavaScript. If you’re deeply familiar with JavaScript and think in a certain way, that’s great. If you’re newer, or if it’s simply not in your interests to learn the ins and outs of a framework, Svelte mostly just looks like basic HTML, JavaScript and CSS.

The Satisfaction Curve

Harris has a theory about framework adoption. There’s usually a chart of satisfaction against usage. It starts low in usage but high in satisfaction. As usage grows, everyone starts using it because everyone else is, and then they feel obligated — and satisfaction drops, and eventually the thing dies out.

With Svelte, it’s hard to tell if it’s following the same curve. Usage is still lower than the big players, and satisfaction is very high. But there’s now quite a bit of usage, and satisfaction remains among the highest of any widely used framework.

Where Svelte Actually Lives

A lot of people doing interactive data visualisation love Svelte. It’s a good fit for smaller applications that need to be highly interactive, custom and complicated. You’ll see a lot of newer data visualisation work — especially from The New York Times — built in Svelte.

One project: an investigation into gun violence in the United States, from January 2017. Another: a story about Chinese propaganda that involved more than a hundred videos that needed to play without slowing down browsers. The whole article was a single Svelte component controlling the entire experience.

Then there was the Y2K story — an unconventional experience where you explore and dive deep and dive out, simulating the feel of the early internet.

And the official German vaccination dashboard, built mobile-first and lean, because it was going to be a high-traffic site and needed to load fast.

And the Language of Science project for Scientific American, celebrating 175 years of the magazine by visualising how its language had evolved. Because the content wasn’t defined yet, the team was in open exploration — playing through layout variations and perspectives on the data interactively to find the effective visual.

Coming From D3, Coming From React

For data visualisation people, D3 is a great library for map projections, layouts, scatter plots. But it doesn’t help much with managing complex interfaces — lots of tabs and buttons. React was exciting for that, until it grew and grew, with more plugins and competing state management libraries. It became a bit too big.

Svelte felt like coming back to something simple.

TypeScript, and the Friend Down the Road

For a long time, TypeScript support was one of the most requested features. People like writing JavaScript inside their components, and TypeScript had become important enough that a lot of developers wouldn’t touch code without it. Its absence was preventing people from using Svelte.

Orta — a friend who used to live down the road and works on the TypeScript team — led a project with several developers to build TypeScript support into Svelte. Not directly into the compiler; you still need a pre-processor. But now you can write TypeScript in a Svelte component and get the same autocompletion and type checking you’d get writing straight TypeScript.

They also built support for Svelte in an LSP, which means it works in Vim, Atom, Sublime Text and VS Code. That matters for scaling codebases — the editor telling you what properties are available, how they intermingle, whether your files link correctly.

“I wish I could do more of it,” says Orta. “People absolutely adore TypeScript, and the fact that he was able to do that just blows my mind. I still don’t understand how any of it actually works, but I use it every day and it’s great.”

The Community That Isn’t Marketing

The core team likes doing core stuff. They want to write code, build features, improve Svelte and SvelteKit. They’re not particularly interested in marketing.

That’s where Svelte Society comes in — separate from the core organisation, an unofficial official place to talk about things without advertising a product. It started with a competitive streak: Antony in London announced the world’s first Svelte meetup, and someone in New York — the city where the creator lives — decided to hold one on the same day. Fifty people showed up. That was the beginning.

“I think there’s only so much that you can do coding,” says one organiser. “Then you have to tell people about it. You have to spell it out. I saw that the technology was ready, but the community had not caught up.”

What you’ll notice about Svelte is that it doesn’t have a strong PR side. It’s a bunch of people who are passionate about what they’re building, who aren’t marketers, who aren’t gaining anything other than their own interest in making something they love.

Going Full Time

A couple of months before this conversation, Guillermo — the CEO of Vercel — sent a message asking whether Harris wanted to work on Svelte full time.

“It was a great opportunity that I would have been an idiot to say no to. If you’d asked me a couple of years ago if I would want to work on Svelte full time, I would have definitely said no. I enjoyed my job at The New York Times way too much. And I worried that if I was working on the framework instead of building things with the framework, that I would kind of lose touch with what the needs were on the ground.”

But Svelte had reached a point where enough people were using it, and there were enough demands on development time, that not having someone working on it full time was unsustainable.

The idea they’re pursuing is an edge-first framework — an application that’s fast by construction. Almost impossible to create a slow app. Svelte’s default app will be fast. The next question is whether the default app you deploy can be fast globally, for every user of the internet.

What Actually Makes Him Happy

“The thing that makes me happiest about working on Svelte is seeing people who don’t think of themselves as programmers, or that are new to programming, building stuff that they’re proud of. And they’re crediting Svelte with enabling them to do that.”

He doesn’t know what the future of Svelte looks like. There’s a long roadmap and a long wishlist. But the North Star is getting rid of barriers to entry — letting as many people as possible build things on the web.

“We’ve never been primarily focused on adoption. Adoption is a good metric. If the numbers are going up, it means people are talking about the thing and other people are listening. But we would rather have a thing that a small number of people love than a thing that a large number of people tolerate.”

And he doesn’t want to be a dictator. Even a benevolent one.

“Svelte has always been this very consensus-driven project. Even if a dictator is benevolent, that still entails probably overriding the will of other people in the community. We’ve always tried to develop consensus around everything we’ve done. You can never get everyone to agree, but we want as many people to agree as possible.”

And he’s not so keen on the “for life” part, either.

“I really love working on Svelte. I’m excited that I can work on it full time now. Will I still want to work on it ten years from now? I’m hoping that if Svelte is still around — and I hope it is still around — that we will have found a way to make it a self-sustaining project. That isn’t reliant on any one individual, but is a thing unto itself.”

A framework without the framework. A project built by someone who admitted his earlier work was wrong. And a language designed to get out of the way.

That’s Svelte. It’s a real word. And it fits.