Fullstack in Rust Zonder de Pijn en Onnodige Abstracties

Dat bekende gevoel: je wilt een kleine webapp schrijven in Rust, maar het opzetten van de infrastructuur kost meer tijd dan de eigenlijke logica. Eerst kies je een webframework (Axum of Actix-web), dan een template-engine (Askama of Tera), en dan bedenk je hoe je data naar de frontend kunt sturen zonder dat je code verandert in eindeloze API-endpointbeschrijvingen. Uiteindelijk groeit een project met 10 regels logica tot honderden regels configuratie.

Het Tokio development team (ja, de mensen die de async runtime voor de helft van het Rust-ecosysteem hebben geschreven) besloot dit op te lossen. Ze introduceerden Topcoat — een framework dat Rust-ontwikkeling zo snel en prettig moet maken als Ruby on Rails of Next.js, met behoud van alle voordelen van typesafety.

Wat Is Het Eigenlijk

Topcoat is een modulair fullstack framework dat het principe van "batteries included" volgt. Het dwingt je niet om te kiezen tussen server-side rendering (SSR) en client-side reactiviteit. In plaats daarvan biedt het een hybride aanpak: je schrijft code in Rust, en het framework beslist zelf wat op de server moet draaien en wat JavaScript moet worden voor de browser.

Het project bevindt zich momenteel in een vroeg stadium (experimentele status), dus de API kan nog veranderen. Maar de architecturale ideeën die erin zijn verwerkt zien er heel solide uit voor iedereen die moe is van de technologiejungle.

Reactiviteit Zonder Pijn en WASM Bundles

Meestal, als je een knop op een pagina tot leven wilt laten komen, heb je twee paden: ofwel schrijf je in JS/TS, ofwel sleep je zware WebAssembly aan. Topcoat biedt een derde optie.

Een speciale expressie $(...) binnen de view! macro is reguliere Rust-code. Het wordt gecontroleerd door de compiler, maar Topcoat weet hoe het naar JavaScript moet vertalen. Wanneer je een click handler schrijft die de staat wijzigt (signal), hoef je geen frontend build op te zetten of een API te beschrijven. Het framework zelf zal het direct laten werken in de browser.

Als een update data van de server nodig heeft (bijvoorbeeld een databasenzoekopdracht), komen "shards" te hulp. Je markeert een component met het #[shard] attribuut, en Topcoat zal het automatisch op de server opnieuw renderen wanneer argumenten veranderen, en vervolgens het HTML-fragment zorgvuldig vervangen in de browser.

Routing Die Orde Brengt

In plaats van een padboom te beschrijven in één huge main.rs bestand, stelt Topcoat voor om folderstructuur te gebruiken. Als je met Next.js hebt gewerkt, voel je je direct thuis.

Een src/app/about.rs bestand wordt automatisch beschikbaar op /about, en src/app/posts/id.rs wordt een route met een /posts/{post_id} parameter. Er is geen runtime-magie aan te pas — het is een optionele feature die je kunt inschakelen als je van dat soort orde houdt.

Templates Die HTML Blijven

Veel template-engines in Rust zijn ofwel te ver verwijderd van HTML, of dwingen je om veel extra code te schrijven. De view! macro in Topcoat probeert zo dicht mogelijk bij markup te blijven, terwijl je nog steeds reguliere Rust-constructies zoals loops for en condities if kunt gebruiken.

Trouwens, voor degenen die zich zorgen maken over code-netheid: het pakket bevat een CLI-hulpprogramma topcoat fmt dat code zelfs binnen macros kan formatteren. Het is een klein ding dat in andere projecten vaak ontbreekt.

Kant-en-Klare Componenten en Assets

De ontwikkelaars kozen de shadcn/ui-route. In plaats van een zware componentbibliotheek als afhankelijkheid toe te voegen, gebruik je het topcoat ui commando. Het kopieert de code voor de componenten die je nodig hebt (knoppen, kaarten, formulieren) direct in je project. Hiermee kun je het ontwerp naar wens aanpassen zonder te vechten met library-stijlen. Alles is gebouwd op Tailwind CSS, dat direct in de build-pipeline is geïntegreerd.

Werken met afbeeldingen en fonts is ook vereenvoudigd:

Frameworks voegen hashes toe aan bestandsnamen voor caching en zorgen ervoor dat assets beschikbaar zijn.

Is Het Nu de Moeite Waard om Te Proberen

Topcoat lijkt een poging te zijn om een "correct" webframework voor Rust te maken, waar typen helpt in plaats van de ontwikkelsnelheid in de weg te staan.

Waar het zeker voor is:

• Degenen die snel een prototype of intern hulpmiddel in Rust willen bouwen.
• Ontwikkelaars die moe zijn van de kloof tussen backend en frontend.
• Degenen die het Tokio-ecosysteem waarderen en vertrouwen op hun architecturale beslissingen.

Het project groeit momenteel actief. De auteurs plannen om WebSocket-ondersteuning, background jobs en zelfs OpenAPI-specgeneratie toe te voegen. Als je op zoek was naar een reden om iets voor het web in Rust te schrijven, is de komst van Topcoat misschien precies dat teken.

Bekijk de tokio-rs/topcoat repository — er is een uitstekende handleiding om te beginnen. Maar onthoud: het project is experimenteel, dus het gebruiken voor mission-critical systemen is nog een beetje prematuur.