blank-tauri-starter

A clean Tauri starter for shipping desktop ideas without fighting setup first.
Start blank. Add your feature. Keep the good parts already wired.

Quick start · What you get · Customize it · Release flow

Why this starter

Most desktop starters are either too bare or too opinionated.

blank-tauri-starter aims for the useful middle:

• blank enough to become your app quickly
• polished enough to feel real on day one
• structured enough to scale past a toy demo
• small enough to understand without a long onboarding session

It already includes the parts people usually rebuild every time:

• Tauri v2 desktop shell
• React 19 + TypeScript frontend
• Zustand stores
• Tailwind styling and theme setup
• persisted settings via SQLite
• updater wiring
• CI and release workflow scaffolding

Quick Start

Prerequisites

• Node.js 22+
• pnpm
• Rust stable
• Tauri system dependencies: Tauri prerequisites

1. Install dependencies

pnpm install

2. Initialize the starter with your app details

pnpm run init

You will be prompted for:

• app name
• app slug
• bundle identifier
• short description
• author or organization
• GitHub repo (owner/repo)

You can also run it non-interactively:

pnpm run init -- \
  --app-name "My App" \
  --app-slug "my-app" \
  --app-id "com.example.myapp" \
  --app-description "A desktop app built with Tauri." \
  --app-author "Your Name" \
  --github-repo "your-org/my-app"

3. Start development

pnpm tauri dev

What You Get

Frontend foundation

• React 19 with TypeScript
• Vite-based dev flow
• Zustand stores for app state
• shared UI primitives and starter layout
• appearance settings with theme and accent support

Desktop foundation

• Tauri v2 runtime
• Rust command layer
• SQLite-backed settings persistence
• updater plugin integration
• starter app/window configuration already in place

Repo foundation

• CI workflow for checks
• release workflow for tagged builds
• template init script
• verification script for placeholder and branding checks

Starter Experience

This repo is intentionally positioned as a reusable base, not a fake product demo.

That means:

• the default UI is generic
• branding can be swapped quickly
• the codebase is cleaned up to avoid template noise
• the first real feature is expected to be added vertically: Rust command -> frontend wrapper -> store -> component

Use It Your Way

If you want...	Start here
A reusable template repo	Keep the generic starter copy and improve the init experience
A base app for your own project	Run pnpm run init, replace branding, then start building features
A polished internal tool shell	Keep most of the starter UI and add your workflow-specific screens

Commands

pnpm dev
pnpm tauri dev
pnpm test
pnpm build
pnpm lint
pnpm lint:fix
pnpm format
pnpm format:check

Validation

Template repo validation

Use this before init if you want to confirm the repo is still a healthy template:

node scripts/verify-template.mjs

Initialized app validation

Use this after pnpm run init:

node scripts/verify-template.mjs --all
pnpm lint
pnpm test
pnpm build
cargo test --manifest-path src-tauri/Cargo.toml
cargo clippy --manifest-path src-tauri/Cargo.toml -- -D warnings

Customize It

Replace next

1. Update the app name, bundle id, author, and repo with pnpm run init.
2. Replace public/images/logo.svg and public/images/logo.png with your own branding.
3. Regenerate the icons in src-tauri/icons/.
4. Replace the dashboard copy in src/components/Home/StarterHome.tsx.
5. Add your first real feature.

Recommended first feature path

Rust command
-> frontend command wrapper
-> store
-> screen/component

Project structure

.
|-- .github/workflows/        # CI and release automation
|-- public/images/            # Starter branding assets
|-- scripts/                  # Init, verify, updater, and version helpers
|-- src/
|   |-- components/Home/      # Generic starter dashboard
|   |-- components/Settings/  # Appearance and update preferences
|   |-- components/Shared/    # Shared UI primitives
|   |-- lib/                  # Tauri wrappers and platform helpers
|   |-- stores/               # Zustand stores
|   `-- styles/               # Global CSS and design tokens
`-- src-tauri/
    |-- src/commands/         # Rust commands exposed to the frontend
    |-- src/db/               # SQLite setup and migrations
    |-- icons/                # Generated app icons
    `-- tauri.conf.json       # Desktop app configuration

What the init script updates

The init script replaces app identity values across the repo, including:

• package.json
• src-tauri/Cargo.toml
• src-tauri/tauri.conf.json
• .github/workflows/release.yml
• .env.example
• visible UI strings that show the app name

Release Flow

Bump the version

bash scripts/bump-version.sh 0.2.0

Commit and tag

git add -A
git commit -m "chore: bump version to v0.2.0"
git tag v0.2.0
git push
git push --tags

Pushing a v* tag triggers the release workflow.

Required GitHub secrets

• TAURI_PRIVATE_KEY
• TAURI_KEY_PASSWORD
• TAURI_PUBLIC_KEY

Updater variables used by CI

• BLANK_TAURI_STARTER_UPDATER_REPOSITORY
• BLANK_TAURI_STARTER_UPDATER_PUBKEY

Tech Stack

• Frontend: React 19, TypeScript, Zustand, Tailwind CSS, Vite
• Desktop runtime: Tauri v2 + Rust
• Persistence: SQLite via rusqlite
• Updates: tauri-plugin-updater
• Tooling: ESLint, Prettier, import sorting

License

MIT