CloudSeed Rust - A Fullstack Rust Boilerplate for Building Webapps in Minutes

Today I'm launching CloudSeed Rust - a Rust boilerplate for spinning up fullstack webapps in minutes.

I started learning Rust as a potential candidate for The Missing Programming Language. I was always hesitant to start learning / building with it as I was afraid of the infamous learning curve. But as I got deeper, I realized that while it does have its edges Rust is first and foremost a high level language and there's ways to write High-Level Rust where you get 80% of the benefits with only 20% of the pain.

Since then I've been hooked. IMO it fills a very big gap in the current programming language landscape. And naturally I wanted to encapsulate all my favorite paradigms of building into a boilerplate so I can start each future project from a good place.

What is CloudSeed Rust?

CloudSeed Rust is a fullstack webapp boilerplate for Rust. It's the seed you grow into a web service / business.

It provides a solid foundation from which to develop your app by handling the table-stakes features most apps need:

• API foundations - Axum web framework with routing, middleware, CORS, error handling
• Auth - Passwordless login with magic links, sessions, rate limiting, auto user creation
• Background jobs - PostgreSQL-backed job queue with retries, exponential backoff, cron scheduling via apalis
• CSS pipelines - Tailwind + DaisyUI pre-configured with build pipeline
• SSR - Type-safe server-side rendering with Maud
• Observability - Structured logging with Open Telemetry so you can easily export to your aggregator of choice (Datadog/Grafana/etc)

Its aim is to give you everything you need out of the box but nothing you don't so it's both quick to setup and easy to change as your app requires.

It uses High-Level Rust patterns throughout to provide good ergonomics without sacrificing much performance - immutable data, service-level traits for easy DI / testing, generous cheap cloning with LightClone.

Why build CloudSeed Rust?

I build a lot of projects and most projects require the same plumbing:

• API scaffolding
• Auth flows + data models
• Background jobs
• CSS pipelines

These are interesting to build the first time but by the 5th or 6th it's just overhead. They don't differentiate your app / product and is time lost from building features that are actually interesting / useful. Plus there's always edge cases with these things so when you're bored and likely generating parts with AI, it's easy to miss smth important that ends up hobbling your app.

I typically solve for this by building up templates / boilerplates for the types of apps / systems I build frequently. Then every time I build a new app and learn smth / find an edge case, I can push a fix / change upstream so all future builds start in a better spot.

I've done this before with:

• CloudSeed for F# - fullstack F# webapp template
• C# + Raylib, TS + Phaser, Sveltekit + ThreeJS templates
• Various markdown blog implementations in F#, C#, SvelteKit which I've shared in my HAMY LABS Example Repo for HAMINIONS Members

And now we're doing this with Rust.

Why Rust? Because it captured my attention as a potential candidate for the missing programming language. The language has everything on paper - great types, great performance, a large, stable, and growing ecosystem but the devx overhead / learning curve is scary and well-documented. So my High-Level Rust paradigm and CloudSeed Rust boilerplate is my attempt to reduce that devx burden to see if we can elevate Rust to an S-Tier language.

How is it built?

• Web API - Axum, the most popular Rust web framework built on Tokio
• SSR - Maud, compile-time type-safe HTML templates (no template files, just Rust code - which I find more ergonomic, understandable, and composable esp if you go the HTMX / Datastar route)
• Styling - Tailwind CSS + DaisyUI with a Docker multi-stage build pipeline
• Data - SQLx for compile-time checked queries + sea-query for composable query building
• Database - PostgreSQL by default (can be easily swapped to anything sqlx supports)
• Auth - Passwordless magic links with HMAC-signed sessions
• Jobs - Apalis for PostgreSQL-backed job queue with retries and cron
• Observability - OpenTelemetry with dual output (stdout always, optional OTLP export)
• Testing - Integration tests with Testcontainers (real Postgres in tests) - taking a pragmatic testing diamond approach to validation
• Deployment - Dockerized with multi-stage builds - if your server can run Docker, it can run CloudSeed

Next

CloudSeed Rust is available now at an early access pricef of $29 at cloudseedrust.com.

I haven't been this excited about a programming language and ecosystem since I found F#. I'll be actively building with Rust and developing CloudSeed as I go. Any feedback you have is welcome - can reach me on any of my socials.

If you liked this post you might also like:

• High Level Rust - the approach behind CloudSeed Rust's patterns
• The Missing Programming Language - why I'm exploring Rust
• The Problem with Clones in Rust - performance patterns used in CloudSeed