Guides

Everything Rask covers, end to end: data and CQRS, auth, background jobs, email, cache, realtime, multi-tenancy, search and deploy — then the UI, from C# components to islands and SPAs. The same guides ship in the repo's docs/ folder; here they carry runnable demos.

Start a project

Nothing preinstalled — the installer brings the .NET SDK with it, under $HOME, with no sudo.

$ curl -sSL https://rask.sh/rask.sh | sh
$ rask new MyApp
$ cd MyApp && rask dev

Windows: irm https://rask.sh/rask.ps1 | iex. Add --template wasm for a standalone browser app. Accounts and cookie sign-in are already on.

Start here

Installing Rask

One line to the CLI and everything it needs — options, upgrade, uninstall.

Getting started

Scaffold a project and build your first component.

Cheat sheet

Every CLI command, flag, and wiring one-liner on one page.

Recipes

Task-first: how do I add a feature, gate a page, run a job, deploy?

Best practices

Production patterns for state, forms, security, and perf.

Migrating from Blazor

Concept mapping and behavioural differences.

Philosophy: the One Person Framework

Why one codebase and one server carry a whole product — for one developer or a team.

Roadmap

The full-stack pillars — shipped and planned.

Tutorial

Ch 0 · Overview

What you'll build: a whole product, one pillar per chapter.

Ch 1 · Scaffold

Scaffold the app with rask new.

Ch 2 · First feature

Declare an entity and build its list, create and edit pages.

Ch 3 · Orders & auth

A second feature, and locking it down.

Ch 4 · Background jobs

Run work off the request thread.

Ch 5 · Email

Transactional email off the request thread.

Ch 6 · Cache

Cache the catalog on your own database.

Ch 7 · Outbox & events

Domain events with the transactional outbox.

Ch 8 · Production SQLite

WAL, pragmas, and continuous backup.

Ch 9 · Push

Send Web Push from your own server, on your own keys.

Ch 10 · Watching it run

An ops page over every pillar's own table.

Ch 11 · Deploy

Ship to one box with rask deploy.

Data

Rask.Data

Declare aggregates, write them off the type, query their generated read faces, bind generated form models.

Data access

EF Core + SQLite, vertical slices, DDD patterns.

Rask.Query

The dispatcher wrapped in a cache: dedup, staleness, invalidation.

CQRS

Source-generated queries, commands, events, behaviors.

Production SQLite

WAL + busy-timeout pragmas, continuous backup, snapshots.

Multi-tenancy

One app, many customers: rows owned by a tenant, filtered on every query.

Full-text search

Ranked search over your own tables — SQLite FTS5 or PostgreSQL — with highlights.

Outbox

Crash-safe domain-event delivery on your database.

Auth

Authentication

Accounts, passkeys, sessions and route guards on Server and WASM.

Auth — cookie

Cookie login and session on Server and on a WASM SPA with an API host.

Auth — providers

Keycloak, Auth0, and other OIDC providers.

Auth — hardening

Production hardening for cookies, tokens, and sessions.

Backend services

Background jobs

Durable enqueued / delayed / recurring work on your database.

Transactional email

Durable email queued on your database, delivered over SMTP.

Cache

A database-backed IDistributedCache plus a typed ICache.

File storage

Uploads kept on disk, S3, Azure or the database, with a row per file.

Excel export

An .xlsx workbook from headings and rows, with no dependency.

HTTP APIs

Controllers and minimal APIs, called through a generated typed client.

HTTP & files

Fetch JSON with a DI'd HttpClient; upload and download files.

Realtime

Subscriptions

Keep a page current: a live query, or an event published to every page subscribed to it.

Web Push (server)

Subscribe with MDN's PushManager, send Web Push from your backend — VAPID keys, delivery results.

IWebRtc

Typed browser API: IWebRtc.

ISignaling

Typed browser API: ISignaling.

Frontend

Building components

Naming a component and chaining onto it; what a component demands before it exists.

Elements & the DSL

Primitives, tag entries, universal props, SVG, the element catalog.

Routing

Route attributes, params, nested layouts, type-safe URLs.

Composition

Children, fragments, callbacks, context, virtualize.

Composition — callbacks & context

Child→parent callbacks and provide/consume context.

Composition — lists & more

Virtualize, keyed lists, toasts, drag-and-drop, error boundaries.

Lifecycle

Mount, updated, first render, rendered, unmount, cancellation.

Live pages

Every page live: WebSocket or HTTP fallback, waiting for async data, status codes, redirects.

Forms & validation

Two-way binding, Form.Model(m), inline Validate rules.

Forms — validation

Inline Validate rules, sync or async; attributes and FluentValidation too.

Forms — advanced

Nested/complex models, radio & checkbox groups, custom controls.

Validation

Inline rules in a form; attributes and AbstractValidator<T> on requests too.

JavaScript interop

Scoped CSS/TypeScript, element refs, IJSRuntime, typed APIs.

JS interop — runtime

Calling JS, the typed browser-API layer, element refs, third-party libs.

Single-page app front ends

An npm-built front end built, published and served by its ASP.NET host.

Islands

A .tsx or Lit file as an ordinary Rask component, with props owned by C#.

Blazor components

A real Blazor component — MudBlazor, an RCL — hosted in a Rask page, server-rendered.

Tailwind CSS

Tailwind v4 compiled by dotnet build — no npm, no config file.

UI kit

The components the framework's own surfaces are drawn with.

Accessibility

ARIA, focus management, the img-alt analyzer.

Localization

Ship in more than one language: negotiated culture, typed catalogs, plurals.

Deploy & operate

The rask CLI

new, dev, db, deploy, info, doctor — the front door.

Deployment

rask deploy: a bare VPS to a live HTTPS site, zero downtime.

Scaling

How far one box goes, measured — and where the wall actually is.

Secrets

Where passwords and API keys live, and how they reach the server.

Configuration

Every setting, under Rask in appsettings.json.

Dashboard

An operator dashboard over every battery's table.

Logging

A durable log store in a database of its own.

Observability

Logging, tracing, diagnostics.

Browser & devices

Web APIs from MDN

Every web API the browser ships, as MDN names it, from C#.

Browser APIs

MDN's browser APIs in C#, and the few typed wrappers beside them.

Browser APIs — sharing model

Where wrappers live; declarative vs imperative; subscriptions.

Browser APIs — reference & demos

Every browser API with a runnable live demo.

Mobile & PWA

Service workers, Web Push, offline, installable apps.

Browser API reference

Capability matrix

Which browser/device API works on which host.

IBackgroundSync

Typed browser API: IBackgroundSync.

IIndexedDb

Typed browser API: IIndexedDb.

IWebAuthn

Typed browser API: IWebAuthn.

Advanced

Testing

Unit testing with Rask.Testing, event handlers, E2E.

DevTools

A panel in the page: wire, component tree, renders, perf and errors, Debug-only.

Building form controls

Author your own IFormControl<T>.

AOT compilation

Ahead-of-time compile for WASM, and trim-safety.

Prerendering

Render a standalone WASM app's pages to HTML at publish.

Code analysis

The analyzers, warnings as errors, and the SOLID + Clean Code standard.

Public API style

How every public name is chosen, and the gate that records the surface.

Diagnostics

Every RASK0xx descriptor, its trigger, and the fix.

Contributing & internals

Development workflow

How the repo builds, tests, and ships.

Repo administration

Governance, CODEOWNERS, releases, automation.

Building with AI assistants

llms.txt and the published guides, for an assistant building on Rask.

Live-rendering internals

The diff codec and the live-render pipeline.

Live rendering — walk & codec

Parallel HTML+frame walk, the edit-op diff codec, keyed reconciliation.

Live rendering — cache & dispatch

SessionRenderCache, head/query-nav, handler ordering, slow-connection.