The internet belongs to everyone.Your data belongs to you.

01Why it’s different

02How it works

From your laptop to your whole team, in four steps.

1. 1

   Set up

   Get Calimero Desktop. It runs your node.

   Get Desktop →
2. 2

   Create

   Install an app. It creates your namespace: the app’s own private space for its data, people and rules. You’re the admin.

   Explore applications →
3. 3

   Keep it on

   Turn on always-on. Sealed cloud machines keep it online while you sleep.

   Go always-on →
4. 4

   Invite

   Send one link. People join from Desktop or the browser — and with always-on, even while you’re offline.

   How invites work →

In the browser, each action is signed on the person’s own device; a cloud machine carries out exactly that — nothing more.

03Use cases

Built for groups whose shared work no vendor should see.

A few people — or agents — who share live, sensitive state and can’t hand it to a third party.

• AI agents

  Give your agents a shared memory no host can read.

  • Shared working memory for a team of agents
  • Coding agents on a private issue tracker
  • Agents that act only on what a person signed
• Sensitive data

  Your most private data, shared only with the people you choose.

  • Deal rooms, board papers and legal matters
  • Family records, finances and health notes
  • Passwords and credentials shared with a team
• Between organisations

  Nobody hosts the room, so nobody owns the relationship.

  • Supplier and buyer collaboration
  • Joint ventures and consortium bids
  • Treasury and multisig operations
• And everything else

  If a group shares it, you can build it.

  • Offline and remote work that syncs when back online
  • Multiplayer games with hidden information
  • Polls, reviews and anything a small group runs together

04Apps

Apps you already need. None that watch you.

06Build on it

Write the app. Skip the backend.

Building privacy-preserving apps has never been simpler: no servers, no database, no sync engine, no auth service and no key management for you to run.

#[app::state(emits = for<'a> Event<'a>)]
pub struct KvStore {
    items: UnorderedMap<String, LwwRegister<String>>,
}

#[app::logic]
impl KvStore {
    pub fn set(&mut self, key: String, value: String) -> app::Result<()> {
        self.items.insert(key, value.into())?;
        Ok(())
    }

    pub fn get(&self, key: &str) -> app::Result<Option<String>> {
        Ok(self.items.get(key)?.map(|v| v.get().clone()))
    }

    pub fn remove(&mut self, key: &str) -> app::Result<Option<String>> {
        let removed = self.items.remove(key)?.map(|v| v.get().clone());
        if removed.is_some() {
            app::emit!(Event::Removed { key });
        }
        Ok(removed)
    }
}

That state syncs, merges and stays encrypted between everyone in the namespace. No server code.

Developer friendly

Write the logic in Rust, connect from JavaScript, React, Python, Swift or Kotlin. Sync, encryption and peer networking are handled for you.

Runs everywhere

Apps compile to WebAssembly and run on any node — a laptop, a server or Calimero Cloud. Clients run in browsers and on phones.

Private by default

Every namespace has its own keys, held by its members and the sealed machines they approve. Removing a member rotates the key.

A whole network on your laptop

Spin up several nodes with merobox and test sync, members and invites end to end before you ship.

Read the quickstartDeveloper tools

07Compare

Why not just build a normal app?