Fullstack systems for the AI era
AI can generate code. Dowe generates the system.
Website · Quick start · Architecture · Development
Dowe is a Rust compiler and runtime toolchain for building fullstack products from a unified,
declarative source graph. Applications are authored in Dowe Source Format (.dowe
), checked against explicit language and platform contracts, and lowered into the artifacts required by each selected target.
The result is one product architecture across:
Server— Rust-owned routing, data access, host capabilities, and production serving.** Web**— server-rendered HTML, deterministic JavaScript and CSS chunks, and a Rust HTTP router.** Desktop**— generated web/static output hosted in native windows for macOS, Windows, and Linux.** Android**— native Jetpack Compose projects.** iOS**— native SwiftUI projects.
Dowe Source Format is a compiler input, not a JavaScript application runtime. Dowe does not require
Node.js, node_modules
, React, Tailwind, or execution of user source to compile and run an application.
| Principle | What it means |
|---|---|
| Architecture is enforced | |
| Parsing, analysis, routing, runtime behavior, and target generation have explicit owners. | |
| One system, many surfaces | |
| Server, web, desktop, Android, and iOS share one product model instead of diverging into separate stacks. | |
| Output is deterministic | |
| Unchanged inputs produce stable generated artifacts that can be inspected, tested, and regenerated. | |
| Boundaries are explicit | |
| Server-only capabilities and secrets stay out of generated client data. | |
| Agents work inside contracts | |
| Diagnostics, generated type support, Agent Harnesses, and CodeGraph make constraints machine-readable. |
flowchart LR
S["Dowe source graph<br/>main.dowe · theme.dowe · modules"] --> C["Rust compiler<br/>parse · analyze · lower"]
C --> R["Rust server"]
C --> W["Web + SSR"]
C --> D["Desktop"]
C --> A["Android<br/>Jetpack Compose"]
C --> I["iOS<br/>SwiftUI"]
Every project begins with a small set of root contracts:
| Path | Responsibility |
|---|---|
main.dowe |
|
| Application metadata, views, server wiring, and enabled target families. | |
theme.dowe |
|
| Fonts, semantic themes, and project-wide component defaults. | |
.env.example |
|
| Shareable environment variable names and non-secret examples. | |
.env |
|
| Ignored local values. | |
views/ |
|
| Route graphs, layouts, pages, components, stores, and view-only types. | |
server/ |
|
| Endpoints, handlers, middleware, services, repositories, tasks, and providers. | |
.dowe/ |
|
| Generated development and distribution artifacts. Never edit these as source. |
import ApiRoutes from "@/server/endpoints"
import AppRoutes from "@/views/routes/app"
main
app name:"Hello Dowe" bundle:"dev.dowe.hello"
views:AppRoutes
server port:8080
endpoints:ApiRoutes
page HomePage
Section
Title
"Build the system, not the stack."
Text color:"muted"
"One source model. Every product surface."
Button href:"/docs"
"Explore Dowe"
The syntax stays intentionally small: declarations, bindings, key:value
props, and indented children. The Rust compiler owns validation and reports invalid bindings, props, imports, routes, types, and target boundaries before generation.
macOS and Linux:
curl -fsSL https://get.dowe.dev/install | bash
Windows PowerShell #
irm https://get.dowe.dev/install.ps1 | iex
Verify the installation:
dowe version
mkdir hello-dowe
cd hello-dowe
dowe init --template blank
Use dowe init --template crud
for the fullstack CRUD starter. Add --i18n
to either template to include translation catalogs.
dowe dev --target server --target web
Dowe analyzes the project, writes generated files under .dowe
, and prints the development URLs.
Run dowe dev
without flags to select available targets interactively.
| Command | Purpose |
|---|---|
dowe init |
|
| Create a blank or CRUD Dowe project. | |
dowe dev |
|
| Compile, watch, and run selected development targets. | |
dowe test |
|
Discover and run native .dowe literal tests. |
|
dowe deploy |
|
| Produce static, Docker, or Cloudflare distributions. | |
dowe icons |
|
| Generate versioned web, desktop, Android, and iOS icon sets. | |
dowe agent |
|
| Install or update public authoring guidance for coding agents. | |
dowe codegraph |
|
| Inspect ownership, dependencies, modularity, and duplication. | |
dowe database |
|
| Manage Dowe Database instances and data. | |
dowe cache |
|
| Manage Dowe Cache instances and key-value data. | |
dowe vector |
|
| Manage Dowe Vector instances and embeddings. | |
dowe upgrade |
|
| Upgrade through the official release channel. |
This directory is a Cargo workspace. The main responsibilities are grouped as follows:
| Area | Crates and assets |
|---|---|
| Language | compiler , components , and inference |
| Runtime | runtime , stdlib , spawn , crypto , and id |
| Data | database , cache , and vector |
| Targets | generator_web , generator_desktop , generator_android , and generator_ios |
| Tooling | cli , deploy , icons , minifier , and ipc |
| Agent support | agent , agent_harness , codegraph , and skill-data |
| Packaged assets | assets/fonts and assets/icons |
Core behavior belongs in shared crates. CLI and IPC entrypoints remain thin adapters over the same compiler and runtime APIs.
From this directory:
cargo build --workspace
cargo test --workspace
cargo fmt --all -- --check
cargo clippy --workspace --all-targets -- -D warnings
Run the development CLI directly from the workspace:
cargo run -p dowe -- version
Compiler and runtime changes should preserve the single-owner architecture, include focused tests, keep generated output deterministic, and validate every affected target. Dowe source and generated code remain free of runtime Node.js assumptions and framework-specific compatibility layers.
Build the system, not the stack.