Unified Field

Template to platform

From GitHub to independent platform crates

Unified Field begins as a GitHub template that composes the app. As each family reaches the end-to-end vision, it is designed to graduate into its own 0.2 repository.

GitHub templateShared workspaceIndependent 0.2 crates

Why Unified Field

A Rust-first open source template for composing transparent data, easy job definitions, background work, scheduling, realtime UI, deployment, scaling, and benchmarkable workloads.

Transparent data path

Valence models and policies keep user-visible state honest while Boson and Chronon orchestrate the work behind it.

Realtime + deploy story

Photon streams progress to the UI; Gluon targets fleets and providers so the same template graduates into production footprints.

Why benchmarks matter here

Unified Field is pitched as measurable: these headlines come from decision-grade AWS campaigns in each L0 PERFORMANCE_STUDY — Boson, Photon, Chronon, Spectra, and Valence — not local smoke.

Easy job definitions

Define Boson tasks and Chronon scripts with Rust macros—the runtime registers jobs, exposes operator UI, and scales through Gluon worker pools when workloads grow.

Valence schemaValence

Schema DSL + builder backends

use std::sync::Arc;
use valence::{
    Database, DatabaseFromEngine, FieldType, InMemoryBackend, Valence, MEM_ENGINE_ID,
    valence_schema,
};

const COUNTER_DB: DatabaseFromEngine = Database::from_engine("default", MEM_ENGINE_ID);

valence_schema! {
    Counter {
        table: "counter",
        version: "0.1.0",
        description: "Simple counter",
        database: COUNTER_DB,
        fields: [
            id: { r#type: FieldType::String, primary_key: true, required: true },
            value: { r#type: FieldType::Integer, required: true },
        ],
    }
}

let valence = Valence::builder()
    .add_backend("default", Arc::new(InMemoryBackend::new()))
    .build()?;

Rust docs →Platform guide →

Boson taskBoson

Typed #[task] + enqueue

use std::sync::Arc;
use boson::{
    configure, task, Boson, ExecutionContext, JsonExecutionContextFactory,
    MemQueueBackend,
};

#[task(name = "process_order")]
async fn process_order(
    ctx: Box<dyn ExecutionContext>,
    order_id: String,
    amount_cents: u64,
) -> boson_core::Result<()> {
    tracing::info!(actor = ctx.label(), %order_id, amount_cents);
    Ok(())
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let boson = Boson::builder()
        .queue_backend(Arc::new(MemQueueBackend::new()))
        .execution_context_factory(JsonExecutionContextFactory)
        .auto_registry()
        .build()?;
    configure(boson);

    ProcessOrder::send_with(
        serde_json::json!({"System": {"operation": "checkout"}}),
        ProcessOrderParams {
            order_id: "ord-42".into(),
            amount_cents: 9900,
        },
    )
    .await?;
    Ok(())
}

Rust docs →Platform guide →

Chronon scriptChronon

Cron job + typed #[chronon::script]

use std::sync::Arc;
use chronon::prelude::*;
use chronon::InMemorySchedulerStore;

#[chronon::script(name = "nightly_cleanup")]
async fn nightly_cleanup(
    ctx: Box<dyn ScriptContext>,
    retention_days: u32,
) -> chronon::Result<()> {
    println!("{}: retaining {retention_days} days", ctx.label());
    Ok(())
}

#[tokio::main]
async fn main() -> chronon::Result<()> {
    let chronon = Chronon::builder()
        .scheduler_store(Arc::new(InMemorySchedulerStore::new()))
        .context_factory(Arc::new(JsonScriptContextFactory))
        .embedded()
        .auto_registry()
        .build()?;

    let mut nightly = Job::new("nightly-schedule", "nightly_cleanup");
    nightly.schedule_kind = ScheduleKind::Cron;
    nightly.cron_expr = Some("0 2 * * *".into());
    nightly.timezone = Some("UTC".into());
    nightly.params_json = serde_json::json!({ "retention_days": 7 });
    chronon.coordinator_service().upsert_job(nightly).await?;

    chronon.run().await
}

Rust docs →Platform guide →

See all code recipes on Resources →

AWS performance study

Runtime	AWS campaign	Profile
Boson	89k enqueue/s	Redis · c6i.large · us-east-1
Photon	400k publish/s	Fluvio bc=4 · 4× c6i.large
Chronon	7.7k claims/s	16-cell fleet · c6i.large
Spectra	38k durable/s	ClickHouse L2 · t3.xlarge
Valence	18k write/s	Redis · c6i.xlarge

Runtime story

Chronon schedules recurring reconciliation, Boson executes short-lived units of work, Photon streams progress into Orbital layouts, and Gluon pins the same workloads to provider pools—one template, many runtimes.

Workload Atlas & full benchmark library →