Every request hits Rust first

$ request lifecycle

Rust computes, React renders

A page is one Rust handler and one React component. In between flows a single JSON document — the Props. Forte generates the TypeScript types for it, so the compiler catches what used to be a runtime bug.

#[derive(Serialize)]
pub struct Props {
    pub message: String,
}

pub async fn handler(
    _req: ForteRequest<'_>,
) -> Result<Props> {
    Ok(Props {
        message: "hello from Rust".into(),
    })
}

{
    "message": "hello from Rust"
}

import type { Props } from "./.props";
// ^ generated from the Rust Props type

export default function Hello(props: Props) {
    return <h1>{props.message}</h1>;
}

Follow message across the three panels — one field, one type, checked end to end.

Need plain JSON instead of a page? Handlers under rs/src/apis/ skip the SSR step and return the response directly at /api/….

$ file conventions

The directory is the router

Drop a handler in rs/src/pages/ and a component in fe/src/pages/ — Forte generates everything between them: the router, the Zod-typed props, the path helpers. Change the Rust Props and the TypeScript follows; drift becomes a compile error, not a bug report.

$ doc-db

#[forte_doc]
pub struct User {
    #[pk]
    pub id: String,
    pub name: String,
}

// write
UserPut(user).send_with(&db).await?;

// read
let user = UserGet { id }.send_with(&db).await?;

// transaction with conflict retry
db.trx(|trx| async move {
    let mut user = trx
        .get(UserGet { id })
        .await?
        .ok_or_else(|| anyhow!("not found"))?;
    user.name = "New Name".into();
    trx.commit(())
}).await;

$ object storage

let bucket = object_storage::bucket();

bucket.put("avatars/42.png", bytes).await?;

// hand the browser a direct download link
let url = bucket
    .presigned_get_url(
        "avatars/42.png",
        Duration::from_secs(3600),
    )
    .await?;

$ and the rest

Everything a service needs