February 10, 2025
I was scrolling Twitter late at night. Saw some Jaspr updates. Kilian was shipping quietly, nobody was talking about it. Server-side rendering in Dart. Hydration. Static generation. The real deal. And nobody cared.
So I tweeted:
"Jaspr is underrated... I need to do a Nuxt-like thing with this."
That was it. No planning. No design doc. No "let me think about this for 6 months." Just a thought that wouldn't shut up.
The Pattern#
I've seen this before. Vue existed for years before Nuxt gave it structure. React was just components before Next.js made it a real framework. The pattern is always the same — someone builds an incredible engine, and then someone builds the car.
Jaspr was the engine. It had everything. SSR, SSG, client interactivity, components. But if you wanted file-based routing, you build it yourself. Module architecture? Figure it out. Tailwind integration? Good luck. ORM? There's the door.
I didn't want to figure it out every time. I wanted duxt create and start building. Like how it should be.
First Commit Was Days Later#
Not weeks. Days. When you've been building frameworks for 25 years you don't need to plan how to build a meta-framework. You know what works. File-based routing. Module architecture. Convention over configuration. Sensible defaults. A CLI that does the boring stuff.
First version was ugly. A CLI that scaffolded projects. A router that read file structure. A dev server. Nothing fancy. But it worked. Ship it.
JavaScript Fatigue Is Real#
Let me be honest about the other reason. I was done with JavaScript.
Done with node_modules folders bigger than the app. Done with choosing between 47 bundlers. Done with frameworks that need a tutorial to set up a tutorial. The ecosystem reinvents itself every year and somehow gets worse.
Dart is one language. One toolchain. Type safety that isn't bolted on. A compiler that catches your shit before users do. It just works. The question was never "why Dart" — it was "why did it take so long."
Then It Grew#
What started as "a Nuxt-like thing" became its own thing:
Duxt CLI — scaffold, generate modules, dev server, build. One command: duxt create.
Duxt UI — buttons, cards, badges, blog components. The boring stuff every site needs.
Duxt HTML — 117 PascalCase components. Div, Span, A,
Img. Write HTML like Dart because it is Dart.
Duxt ORM — database access that feels native. Not a port from another language.
Duxt Signals — reactive state. Because you always end up needing state.
None of these were planned upfront. Each one was extracted from real work. I needed an ORM for a project, so I built one. I needed components, so I built them. I needed HTML helpers, so I made 117 of them. That's how frameworks should grow — from necessity, not from roadmaps.
The Recursion Part#
This website — basecode.al — is built with Duxt. The framework I built is building the site that tells you about building the framework. That's the loop. Every product feeds back into the tools. Every tool makes the next product faster.
The tweet became a framework. The framework became the foundation. The foundation is now building everything else.
It's Open Source#
Always will be. Not because it's trendy. Because the tools that made me were open source, and you pay that back. That's how it works.
If you write Dart, try it. If you've been watching Jaspr from the sidelines, this is your way in. If you just want to build something without configuring 14 tools first — that's exactly why Duxt exists.
Started with a tweet. Was really 25 years in the making.