.me

Own your knowledge.

0dec8214…a292d7 keccak-256

Hello, I am .me A Cryptographic Identity. ⌬ Docs → Watch the hash: neurons-me.github.io/.me

Getting Started

Install .me. Open your terminal and run:

git clone https://github.com/neurons-me/.me.git
cd .me

Choose

🔷 Typescript

cd Typescript
npm install
npm run build

🦀 Rust — crates.io · docs.rs
🐍 Python — Not Available Yet.

Demos

⟐🤖 ⇆ 🤖⟐ Robots That Understand Context — Same object, different meaning.

node tests/Demos/Robots_Contexts.ts

∴ 🏙️ ◉ 📡 ⌬ Smart City — A city reacting as one connected graph.

node tests/Demos/Smart_City.ts

𓀠 ⟐👤 ⇄ 👥 ⌬ ∴ 𓀠 Social Graph — Identity, trust, and relationships.

node tests/Demos/Social_Graph.ts

🏪 ⇄ 📦 ⇄ 📈 CoffeeShops — Inventory and operations as a graph.

node tests/Demos/ShopsExample.ts

💳 ⇄ 👥 ⌬ ⚖️ ∴ Splitting your Bill — Shared expenses with automatic settlement.

node tests/Demos/WalletSplit.ts

🌐 ⇄ ⌬ 𓇳 ⌬ ⇄ 🌐 Hemisphere Scale — 1 million sensors. One flips. Only 6 recompute. The other 999,994 untouched. That's O(k).

node tests/Demos/Hemisphere_1M.ts

⚡⚡⚡ ⟶ ⌬⌬⌬⌬ Extreme Fan-Out — One write updates 100k dependents.

node tests/Demos/Root_Fanout_100k.ts

⌬ ⊚ View all demos →

---

𓂀 Syntax - me.whatever(what)

Subject. Verb. Object. It reads as a sentence because it is one.

import Me from "this.me"
const me = new Me()

me["@"]("abella") // you are Abella

me.users.ana.name("Ana")
me.users.ana.age(22)

me.friends.ana["->"]("users.ana") // pointer

// one graph declaration can replace:
// migration, derivation, query, trigger, validation plumbing
me.friends["[i]"]["="]("is_adult", "age >= 18")

me("friends.ana.is_adult")  // -> true
me("friends[age > 18].name") // ->  { ana: "Ana" }

me is the subject, .whatever is the verb (capability), (what) is the object.

Any path you write becomes a node. No schema. No migrations. If it changes, everything that depends on it updates automatically.

me.users.ana.age(22)
me.friends.ana["->"]("users.ana")
me.friends["[i]"]["="]("is_adult", "age >= 18")
me("friends.ana.is_adult")
me("friends[age > 18].name")

You can actually see the graph language emerging.

Op	What it does	Example
->	Points to another path	me.card["->"]("inventory")
=	Derived value	me["="]("total", "price * 1.16")
_	Secret — structurally invisible	me.wallet["_"]("vault")
[i]	Broadcast to a family	me.robots["[i]"]["="]("canProceed", "...")
[filter]	Query	me("trucks[fuel > 200].fuel")

Developers may recognize the idea more quickly written like this:

me.city.population = 700_000
me.city.area = 200
me.city.density = () => me.city.population / me.city.area

Same grammar, 4 robots or 100k nodes. me.robots["[i]"] in Robots and me.dep[100000] in Fan-Out operate on the same graph model.

Language-agnostic:

me.shop.items[1].price(100) = me.tienda.articulos[1].precio(100) = me.店舗.商品[1].価格(100) — meaning is structure.

Full spec: me --describe syntax and Syntax reference

▵ Why.me?

1. Structural Privacy — Private data is structurally invisible (not just hidden by rules).

2. Subjective Reality — Same graph, different views per agent.

3. Full Explainability — Every derived value can explain exactly how it was computed.

   me.explain(Why Did You Say That?)

   Ai can describe its reasoning, but that description is still generated by the same system being questioned.

   .me returns the computation itself.

   me.explain("robots.surgeon.canProceed")
   {
     value: true,
     expr: "canLift && softGripReady && !needsHumanReview",
     dependsOn: [...]
   }

   explain() returns the expression actually evaluated and the inputs that produced it.

   If no derivation exists, it returns none. If an input is secret, the value stays masked.

   Self-report describes the computation. me.explain() exposes its record.

   And me["!"].prove() can cryptographically sign that state.

   Explainability without asking the system to explain itself.

Local compute makes memory an OS primitive.
Cloud makes it a service.

In the Extreme Fan-Out benchmark, one write propagates to 100,000 dependents in 6252ms — about 62μs per dependent.

Real Performance

.me uses true O(K) reactivity — when a value changes, only its actual dependents update. Not the whole graph.

More importantly, propagation cost follows K, not total graph size. In the Hemisphere benchmark, a graph with 1,000,000 nodes changes one sensor and recomputes exactly 6 dependents in 0.256ms.

• 1 million nodes in memory
• 1 sensor changed → exactly 6 dependent nodes recomputed
• Time to propagate: 0.256ms
• K=6 out of 1,000,000 — the rest of the graph is untouched

Scale the graph to 10 million nodes — if your change has 6 dependents, it still takes the same time. Data that thinks. Logic that explains itself.

---

𓅓 Own your intelligence.

suiGn MIT License © 2025 · neurons.me