Home / Developers

Developers · Confidential apps

Build on Calimero. Write the logic.

Build a confidential app: write its logic in Rust, bundle it with its frontend into one signed package, and run it on Calimero Cloud: on shared clusters, paying per request, or on a dedicated cluster of your own.

apps/kv-store/logic/src/lib.rsView code ↗
use calimero_sdk::prelude::*;

#[app::state(version = 1)]
pub struct KvStore {
    items: UnorderedMap<String, String>,
}

#[app::event]
pub enum Event {
    Inserted { key: String, value: String },
    Updated { key: String, value: String },
}

#[app::logic]
impl KvStore {
    #[app::init]
    pub fn init() -> app::Result<Self> {
        Ok(Self::load())
    }

    pub fn set(&mut self, key: String, value: String)
        -> app::Result<()> {
        let event = match self.items.insert(&key, &value)? {
            Some(_) => Event::Updated { key, value },
            None => Event::Inserted { key, value },
        };
        env::emit(event, Audience::All)?;
        Ok(())
    }

    #[app::view]
    pub fn get(&self, key: String)
        -> app::Result<Option<String>> {
        Ok(self.items.get(&key)?)
    }
}

Replicated across attested nodes. No server code.

  • 1command line for every stage: meroctl
  • 1signed package: logic and frontend together
  • 10open-source tools and libraries
  • 6client libraries: JavaScript, React, Python, Swift, Kotlin, Rust

01 · Quickstart

From an empty folder to a running app.

Install meroctl, start from the KV Store reference app and run it on a local cluster with its frontend. By hand, sign in with a development passkey, create an app instance and call it. Deploy signs the same app into a package for Calimero Cloud.

curl -fsSL https://raw.githubusercontent.com/calimero-network/core/master/scripts/install.sh | sh -s -- merod meroctl
meroctl app new my-app && cd my-app
pnpm install
meroctl local dev apps/kv-store
# A local cluster on 127.0.0.1:2501, the app built and uploaded,
# its frontend on http://localhost:5173, rebuilt on every save.

meroctl local up runs the node in Docker by default, so it works on Linux and macOS; --local uses a merod on your PATH instead.

meroctl's names: app is a signed package, instance an app instance, namespace an organization and group one of its teams.

02 · Tools and SDKs

Everything you need, one install away.

The node, the command-line tools, the app SDK and the clients. Each is open source.

Node & CLI

Develop and test locally.

  • merod

    The node, for Linux. meroctl local up runs a development cluster with mock attestation, in Docker by default (--nodes 3 for three nodes, --local for a merod on your PATH).

    curl -fsSL https://raw.githubusercontent.com/calimero-network/core/master/scripts/install.sh | sh -s -- merod meroctl
  • meroctl

    The one command line: start an app, build, pack, sign and publish it, run a local cluster around it, call app instances and work with Calimero Cloud.

    curl -fsSL https://raw.githubusercontent.com/calimero-network/core/master/scripts/install.sh | sh -s -- meroctl
  • meroctl, stage by stage

    Start
    app new DIR [--template T]
    Build
    app build app codegen --lang ts|python|swift|kotlin|openapi app abi show|diff
    Ship
    app signer new app pack [--key K] [--previous OLD] app sign app inspect app publish [--org ORG]
    Run locally
    local up|down|status [--local] local dev local test local compute run
    Cloud
    cloud login cloud orgs cloud clusters list|create cloud use CLUSTER cloud compute pipeline|logs
Client libraries JavaScriptReactPythonSwiftKotlinRust
All tools and libraries: app SDK, clients, examplesShow less

App SDK

Write the app.

  • calimero-sdk

    Write app logic in Rust, built for wasm32-wasip2 into a calimero:app component.

    cargo add --git https://github.com/calimero-network/core calimero-sdk

Clients

Talk to a node from your code.

  • calimero-client

    Rust client: verifies a node's attestation, then seals every request. meroctl and the Python client are built on it.

    cargo add --git https://github.com/calimero-network/core calimero-client
  • calimero-client-py

    Python client for Calimero 1.0, version 3.2: Client, with passkey and API key sign-in.

    pip install calimero-client-py
  • mero-js

    JavaScript and TypeScript client for Calimero 1.0, version 35.2: CalimeroClient, with passkey sign-in, for the browser and Node.

    npm install @calimero-network/mero-js
  • mero-react

    React binding, version 11.1: one CalimeroClient in context, with hooks and components for sign-in, sessions, app calls and events.

    npm install @calimero-network/mero-react
  • MeroKit

    Swift SDK for iOS and macOS, version 6.0: attestation, the sealed channel, passkeys and app instances.

    .package(url: "https://github.com/calimero-network/swift-sdk", from: "6.0.0")
  • mero-kotlin

    Android SDK, version 5.0: attestation, the sealed channel, passkeys, and app intents and views.

    implementation("com.calimero.mero:mero-core:5.0.0")

Examples

Start from a working app.

  • apps

    Every Calimero app, from the KV Store reference app up, each with its React frontend on CalimeroClient. meroctl app new --template starts from any of them.

    git clone https://github.com/calimero-network/apps

03 · Calimero MCP

Let any agent drive your apps.

Any agent, local, deployed or from a frontier lab, gets its own scoped API key, so the Calimero MCP can drive your apps under each app's rules. Coding agents such as Claude Code, Cursor and Codex CLI included.

  • Its own key, separate from yours, revocable any time.
  • The app's rules apply to the agent like any other member.
  • Sensitive methods can require a person's fresh passkey confirmation.

04 · Docs and open source

The runtime is open source.

The node, the SDK and the protocol are on GitHub, with a full protocol reference you could reimplement a node from. The docs come in four tracks.

calimero-network/core
Stars
Latest release
Docs
Build · Operate · Protocol · Contribute
View on GitHub

Your customers want control. You want to ship.

Start on Calimero Cloud, or build on the open-source runtime.