Hi HN,

I’m experimenting with a Rust runtime that exposes replicated, consensus-backed state by advertising a *procedural macro*. Client crates invoke the macro and get a typed API; the runtime owns both the protocol and the codegen.

At a high level, the DB cell:

* Handles RPC (Upsert / Get / Remove) * Coordinates macro expansion for client APIs * Stores opaque zero-copy blobs (`rkyv`)

Here’s the core of the DB side:

```rust use cell_sdk::; use cell_model::macro_coordination::; use std::pin::Pin;

#[protein] pub struct Upsert { pub key: u64, pub kind: String, pub blob: Vec<u8>, }

#[protein] pub struct Get { pub key: u64, pub kind: String }

#[protein] pub struct Row { pub blob: Option<Vec<u8>> }

#[service] #[derive(Clone)] struct DbService { state: Arc<RwLock<HashMap<(u64, String), Vec<u8>>>>, }

#[handler] impl DbService { async fn upsert(&self, u: Upsert) -> Result<bool> { self.state.write().await.insert((u.key, u.kind), u.blob); Ok(true) } async fn get(&self, g: Get) -> Result<Row> { let val = self.state.read().await.get(&(g.key, g.kind)).cloned(); Ok(Row { blob: val }) } async fn remove(&self, k: u64, kind: String) -> Result<bool> { Ok(self.state.write().await.remove(&(k, kind)).is_some()) } }

fn expand_table(ctx: &ExpansionContext) -> Pin<Box<dyn Future<Output=Result<String>> + Send + '_>> { Box::pin(async move { let struct_name = &ctx.struct_name; let pk = ctx.fields.first().unwrap().0.clone();

        Ok(format!(r#"
            pub struct {struct_name}Table {{ synapse: ::cell_sdk::Synapse }}
            impl {struct_name}Table {{
                pub async fn connect() -> ::anyhow::Result<Self> {{
                    Ok(Self {{ synapse: ::cell_sdk::Synapse::grow("db").await? }})
                }}
                pub async fn save(&self, row: {struct_name}) -> ::anyhow::Result<bool> {{
                    let bytes = ::cell_sdk::rkyv::to_bytes::<_,1024>(&row)?.into_vec();
                    let req = DbProtocol::Upsert {{
                        key: row.{pk},
                        kind: "{struct_name}".into(),
                        blob: bytes,
                    }};
                    self.synapse.fire(&req).await
                }}
            }}
        "#))
    })

}

#[tokio::main] async fn main() -> Result<()> { let db = DbService { state: Default::default() };

    const macros = vec![MacroInfo {
        name: "table".into(),
        kind: MacroKind::Attribute,
        description: "distributed table".into(),
        dependencies: vec![],
    }];

    Runtime::ignite_with_coordination(
        move |req| db.dispatch(req),
        "db",
        macros,
        expand_table,
    ).await

} ```

consumer

```rust use cell_sdk::;

#[expand("db", "table")] #[derive(Archive, Serialize, Clone, Debug)] pub struct Order { pub order_id: u64, pub user_id: u64, pub amount: u64, }

#[tokio::main] async fn main() -> anyhow::Result<()> { let orders = OrderTable::connect().await?;

    orders.save(Order { order_id: 42, user_id: 7, amount: 1000 }).await?;
    let o = orders.get(42).await?.unwrap();
    println!("loaded {o:?}");

    orders.remove(42).await?;
    Ok(())

} ```
The question: *does letting a distributed service own both its protocol and client-side macro make sense, or is this hiding too much complexity?* And: Would this actually be useful for enterprise? Would you use it?

Thanks — looking for design-level feedback, not users.

EU Council introduces a €3 customs duty on every parcel. Starting July 1, 2026

Nex gaming console – year's hottest toy?

Childhood instability accelerates women's sexual strategies, study suggests

The First Internal Evaluation of the Faust Baseline Version 2.5

AI is part of Linux's plumbing – whether developers like it or not

Where CC Stands on Pay-to-Crawl

CISA orders federal agencies to patch GeoServer flaw

New AI X Youth empowerment focused Initiative in Alabama

315lbs Bench –| 225lbs Squat cofounder needed

A Centralized Database of All Math (2024)

Emacs Propaganda: I wrote a thing for Emacs, but don't call it a "plugin"

Diablo Canyon moves a step closer to staying open

Wine 11.0-rc2 Released With 28 Known Bug Fixes

We've cracked how to make random numbers

Thought Colleague Was a Traitor for Teaching Students to Use AI. Then We Talked

How the Bell Labs Holmdel Complex Inspired 'Severance'

Intel CEO Lip-Bu Tan was investor and adviser to firm sanctioned for China deals

Review of Medical Cannabis Use Finds Little Evidence of Benefit

Divinity

The surprising longevity lessons from the oldest animal

a16z: In 2026, Venture Capital will eat Private Equity

Gemini's live speech to speech translation capabilities

India Is a Rising Power, but Breathing in Its Capital Is Hazardous

HyperCard on the Macintosh

Ask HN: Is this a sane way to expose distributed state in Rust?

Show HN: I made an LLM confessional booth, be a priest and forgive LLMs mistakes

Temporal disobedience: Intersex timescapes, chronopolitics and intersex joy

The Data Marketing Machine

Everything Is Context: Agentic File System Abstraction for Context Engineering

Mount Git repo to view commits and branches as files