And what to expect — me.whatever(what)
Rust .me is now installable.
cargo add this-me
That line brings in the Rust implementation of the .me semantic kernel: hash-chained memory, path grammar, operators, derivations, secrets, proofs, snapshots, runtime events, receipts, and a small CLI.
Links:
Crate on crates.ioAPI docs on docs.rsRust .me docsGitHub repo
.me is not just a data structure. It is a different way to think about application state.
In a normal stack, one idea usually becomes five pieces:
ALTER TABLE friends ADD COLUMN is_adult BOOLEAN;
UPDATE friends SET is_adult = age > 18;
CREATE TRIGGER …
SELECT …
Then the frontend repeats it again.
In .me, the goal is different: write the meaning once, keep the relation alive, and let the system explain how the value resolved.
.me
Start With A Kernel
use this_me::kernel::{Kernel, Value};
fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut me = Kernel::new();
me.postulate(“profile.name”, “Jabellae”)?;
me.postulate(“wallet.income”, 100_u64)?;
me.postulate(“wallet.expenses”, 40_u64)?;
me.derive(“”, “wallet.total”, “wallet.income – wallet.expenses”)?;
assert_eq!(me.read(“wallet.total”), Some(&Value::from(60_u64)));
Ok(())
}
A .me kernel has two important layers:
The current projection: the latest value at each semantic path.The memory log: an append-only hash chain of what happened.
Reads are fast because they hit the current projection. History remains available because every memory is chained.
Paths Are Meaning
me.whatever(what)
.me does not require a schema migration before you can say something.
me.postulate(“friends.ana.age”, 18_u64)?;
me.postulate(“friends.luis.age”, 17_u64)?;
The path is the structure.
Selectors preserve the plural shape:
me.postulate(“items[sku-001].price”, 100_u64)?;
me.postulate(“items[sku-002].price”, 80_u64)?;
And the parser preserves expressions:
“items[price > 90].name”
[] is not just an array. It is grammar for plurality.
Operators
Rust .me includes the core operators:
@ identity
_ secret scope
~ noise boundary
__ pointer
= derivation
? query / collect
– remove / tombstone
Example:
me.claim_identity(“jabellae”)?;
me.secret(“wallet”, “owner-secret”)?;
me.postulate(“wallet.balance”, 100_u64)?;
assert!(me.read(“wallet.balance”).is_some());
assert!(me.read_public(“wallet.balance”).is_none());
That is structural privacy. The value exists for the owner projection, but it is absent from the public projection.
Use The Runtime For Real Hosts
Kernel is the semantic core. For apps, daemons, gateways, or embedded systems, use KernelRuntime.
use this_me::runtime::{runtime_receipt_to_json, KernelRuntime};
use this_me::storage::JsonFileStore;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let store = JsonFileStore::new(“/tmp/me-state.json”);
let mut runtime = KernelRuntime::load(store)?;
let receipt = runtime.write_with_receipt(
“apps.fulltrailer.home.count”,
3_u64,
)?;
println!(“{}”, runtime_receipt_to_json(&receipt));
Ok(())
}
This is the host shape:
load kernel
execute write or me:// command
save snapshot
return result
return runtime events
That makes it suitable for HTTP, WebSocket, local apps, Raspberry Pi, vehicle computers, robots, or a future monad.ai host.
CLI
Install the CLI:
cargo install this-me
Write/read with persistent state:
me –state /tmp/me-state.json write profile.name ‘”Jabellae”‘
me –state /tmp/me-state.json read profile.name
Without –state, the kernel is ephemeral. With –state, it persists.
You can also bind identity and expression:
me –who jabellae –secret ‘whatever’ about ‘x > 10’
And prove that branch:
me –who jabellae –secret ‘whatever’
about ‘x > 10’
prove local.netget ‘{“nonce”:”n-1″}’
The seed stays private. The proof signs a branch-scoped message.
Benchmarks
Rust .me was compared against the TypeScript .me kernel using a mirror suite: same machine, same operation shapes, same measured percentiles.
The important results:
Sustained mutation p95
Rust: 0.0165 ms
TypeScript: 0.0286 ms
Rust/TS: 0.57xLazy mutation at fanout 5,000
Rust: 0.0025 ms
TypeScript: 0.0053 ms
Rust/TS: 0.47xEager mutation at fanout 5,000
Rust: 55.3975 ms
TypeScript: 99.7792 ms
Rust/TS: 0.56xSecret lazy derivation p95
Rust: 0.0286 ms
TypeScript: 0.5689 ms
Rust/TS: 0.05x
The important part is not “Rust magically wins.” The first Rust benchmark found a real gap: lazy mutation was still walking subscribers at write time. Run #002 fixed it by using source path versions and stale-on-read checks.
That is the .me lesson:
a write states a fact
a fresh read resolves whether a relation changed
Is This Faster Than PostgreSQL?
Wrong question, but useful comparison.
PostgreSQL is a mature relational database. It gives you SQL, indexes, transactions, joins, constraints, replication, and decades of production hardening.
.me is doing a different job.
PostgreSQL asks:
Where is this row?
What query returns this set?
How do I keep schema, triggers, cache, backend, and UI synchronized?
.me asks:
What does this path mean?
What relation produced this value?
Who can see it?
Can I prove this memory chain?
What changed, and who should react?
So no, Rust .me is not “Postgres but faster.”
It is closer to a semantic runtime where state, derivation, privacy, proof, and reactivity live in one language.
For classic relational workloads, use Postgres.
For local-first semantic memory, reactive paths, explainable derivations, cryptographic identity, and embeddable runtime state, .me is a different category.
What To Expect
Expect a small kernel, not a full app framework.
Expect paths instead of schemas.
Expect derivations instead of duplicated business logic.
Expect explain() instead of guessing where a value came from.
Expect public and private projections as part of the structure, not as a legal promise after the fact.
Expect Rust .me to become the lower-level runtime ground: the version you can embed closer to the machine.
.me is a framework where your session is your database, your language is your schema, and privacy is structural.
Rust makes that shape smaller, stricter, and closer to the metal.
GitHub – neurons-me/.me: Here we’re codependently creating .me while it concurrently creates us.
How to Rust .me was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story.