Getting started
Build your first Runic app.
Use C# for application logic and React, Vue, Svelte or Angular for the frontend. One command creates a project that connects them and opens your app.
Before you start
Install the prerequisites
You need the .NET 10 SDK and a JavaScript package manager: Node.js 24 with npm or pnpm, or Bun 1.4. The creator asks which one to use.
The default CS-WebUI host opens your app in an installed browser in app
mode; Chrome, Edge and other Chromium-based browsers work best, and
Firefox works without app mode. Without a browser it falls back to the
platform WebView: the Edge WebView2 Runtime on Windows, GTK 3 with
WebKitGTK 4.1 on Linux, or WKWebView on macOS. The Runic Desktop host
uses that WebView in a native window. Run dotnet runic doctor in the generated project to check your setup.
SDK 0.7.0-preview.5
Create and run
dnx Runic.Create@0.7.0-preview.5 The creator asks for a project name, frontend, package manager, Window
host, and ViewModel library, then creates the project and prints the
next steps. dnx ships with the .NET 10 SDK and runs the creator
without installing it. Then start the app:
cd MyApp
dotnet tool restore
dotnet runic dev dotnet tool restore installs the project's dotnet runic tool. dotnet runic dev restores the .NET and frontend packages, builds the app, starts the frontend
development server and opens the app. Frontend edits reload in place; C# edits
rebuild and restart the app. Plain dotnet build and dotnet run work too: the first build installs the frontend packages
and builds the production frontend.
Prefer to choose in the browser? Put your app together and copy one command. The creator runs the runic-app template, which you can also use directly:
dotnet new install Runic.Application.Templates@0.7.0-preview.5
dotnet new runic-app --name MyApp --frontend react --package-manager npm --host cswebui --view-models toolkit Make it yours
Change the counter
The generated app contains C# ViewModels, a Window and Views that select
them, and a frontend in Frontend. The build generates a
typed client for each ViewModel in Frontend/src/generated;
it is regenerated on every build and not committed. Change a page, then
follow its client calls into the ViewModel. The frontend owns rendering;
.NET owns the application model and operation lifetime.
Follow Windows and Views, step by step through the generated project and its tests, learn about Windows and Views, or explore the CommunityToolkit Notes example for nested content, editing, and navigation.
Share your app
Publish for your platform
dotnet publish -c Release -r linux-x64 Use win-x64, osx-arm64 or another runtime
identifier for other platforms; the supported platforms page lists them per host. The publish folder contains the executable and a www folder with the built frontend; distribute the whole folder.
Users need no JavaScript runtime or package manager, only a browser or the
platform WebView.
Native windows
Choose a host
The creator asks for the host. CS-WebUI is the default. Choose Runic
Desktop (--host desktop, or --host desktop-gtk4 for GTK 4 on Linux) for native windows, embedded WebViews, file dialogs and
other platform services; existing projects can add Runic.Application.Desktop. The host selection guide compares them.
Existing project
Add one capability
You can adopt Application Views, Desktop, or Assets separately. The package catalog lists the packages for each goal. Command Line and Translations have their own installation guidance.
Add Runic to an existing app or embed and serve a frontend with Runic Assets.
Application Views uses explicit Window and View types. Its build tooling emits the C# attachments and TypeScript client modules for those contracts.
Next steps
Keep building
Read the release notes when upgrading preview versions. Keep Runic packages on the same version. For SDK contributions, use the contributor guide.