What is Calimero network?

Network
2025-18-12 Fran Domovic
What is Calimero network?

An Overview of framework for Peer-to-Peer CRDT-Based Applications

Calimero Network can be described in many ways, and each description is correct in its own context. Each one reveals a different layer of what Calimero is and what it aims to achieve. At its core, Calimero provides infrastructure — or, if you prefer, a framework — for building peer-to-peer, self-sovereign applications. Another way to describe it is as an application layer built on top of user owned encrypted private peer-to-peer networks.

Calimero Network is like Signal, but designed to power any kind of application—not just messaging. On top of that it is fully P2P, censorship-resistant and owned by the users.

Regardless of the phrasing, the goal of Calimero Network is always the same: to bring data ownership back to users. Calimero's mission, as a pioneer of what we like to call “The new internet”, is to encourage the building and use of peer-to-peer applications that are:

  • • free of centralized servers
  • • local first - computations are executed on your device and data stays with you at all times
  • • open-source
  • • fully end-to-end encrypted
  • • accessible through invite-only membership

This approach challenges the assumptions of today's web and offers a fundamentally different way of building and using applications.

Understanding the Terminology

Before going deeper, let's clarify some key concepts that are essential to understanding how Calimero works.

CRDT (Conflict-Free Replicated Data Type) - A CRDT is a replicated data type designed so that independently-updated replicas can be merged automatically and deterministically, guaranteeing convergence without requiring synchronous coordination.

Self-Sovereign Applications - Applications in which users retain primary ownership and control over their data, identity, and interactions, independently of centralized service providers, and explicitly choose if, when, and with whom their data is shared.

WASM (WebAssembly) - A platform-independent binary instruction format designed for safe, sandboxed execution of code at near-native performance, enabling applications compiled from multiple programming languages (Rust and TypeScript for Calimero) to run consistently across environments.

Runtime - The execution environment provides the resources, rules, and services required for a program to run, such as memory management, execution control, system interfaces, and isolation.

Application (in Calimero terms) - A Calimero application is a program built with CRDTs, typically in TypeScript or Rust, and compiled into WebAssembly (WASM). It runs inside a Calimero node's runtime, on an user owned device, directly interacting with the node's storage and participating in peer-to-peer data synchronization across the network.

Context - A context is an isolated instance of a Calimero application with its own state, members, and permissions — essentially a private workspace where a specific application runs, synchronizes CRDT-backed data among invited peers, and optionally integrates with blockchains.

Consensus - A mechanism in distributed systems that ensures nodes eventually converge to the same application state, even in the presence of failures, delays, or temporary divergence. In Calimero, consensus refers to the guarantees provided by CRDTs that all participating peers will reconcile their updates and reach a consistent state once data is fully synchronized.

The Calimero Tooling

Calimero Network is not a single piece of software — it is made up of several components. At a high level, it consists of:

Merod - The Calimero node, the core component that runs applications, handles storage, and connects peers. It is written in Rust and runs WASM applications while keeping data in sync across nodes.

Meroctl - The CLI for managing Calimero nodes, applications, contexts, and blobs. It provides a complete toolkit for development, deployment, and operations.

Merobox - A Python CLI tool for managing Calimero nodes in Docker containers. Ideal for local development and testing, it allows you to spin up multi-node networks, automate workflows, and run complex testing scenarios.

Calimero Authentication Service (Optional Service) - Generates JWT tokens for web applications, enabling secure access to your Calimero node from multiple devices.

Admin Dashboard - A web interface for managing nodes, monitoring metrics, and controlling contexts and applications.

Calimero-Client - Libraries that connects to Calimero nodes and provide easy access to features like JSON-RPC calls, server configuration, and node options.

Calimero SDK - Provides everything you need to build distributed, peer-to-peer applications with automatic conflict-free synchronization using CRDTs.

CLI-JS is a build toolchain that converts TypeScript applications into WebAssembly (WASM) using Rollup → QuickJS → WASM. This allows TypeScript apps to run inside the Calimero node runtime.

Each of these tools exists to simplify development, deployment, and usage — but everything revolves around the node.

The Node: The core of Calimero

The Calimero node (merod) is the main part of the network that runs applications, handles storage, and connects peers. It is written in Rust and runs WASM applications while keeping data in sync across nodes. The node makes sure applications work correctly and that data is shared safely between peers. Each node can run either on a local desktop or be deployed on a server

And in future on mobile devices.

Every node owner decides which peers to connect to, which contexts to join, and which applications to run. There is no global network you must join — participation is always explicit and intentional.

Calimero Applications and Storage

A Calimero application is built specifically for the Calimero network. It uses CRDTs provided by the Calimero SDK to safely manage and update shared data across multiple nodes.

Calimero Storage is an CRDT abstraction layer on top of RocksDB. Despite being simple in concept, it is powerful enough to support most modern applications. Using CRDTs ensures that multiple nodes can update the same data at the same time without conflicts, and all changes automatically merge to a consistent state.

Applications interact with storage and other peers through the node. While there are additional internal components in the node, for a high-level understanding, you only need to know that the node handles storage, synchronization, and data consistency.

Network Layer

The network layer in Calimero is built on top of libp2p, which provides peer-to-peer connectivity, discovery, and communication. Nodes communicate using Gossipsub for fast message propagation and reliable P2P streams for syncing data periodically.

Each node can also act as a server, offering a JSON-RPC interface for clients and supporting real-time updates through WebSockets or SSE.

Authentication and authorization are handled at the network level to ensure that only invited members can participate in contexts or access application data.

The network is designed to be flexible and decentralized, so there is no single point of control, and every connection is explicitly chosen by the node owner.

Why Calimero Works

What makes Calimero special is not just the technology, but the experience it enables. Calimero provides tooling that simplifies every step of the process. If you care about privacy, you can build an application and start using it with friends almost immediately. At minimum, you need:

  • • a node
  • • application logic
  • • optionally a frontend for a user interface

Nothing needs to be publicly deployed. Calimero is local-first by design. You can run the node locally, run the frontend on localhost, and everything works as expected. Applications communicate with the node using a JSON-RPC interface exposed by the node server. Calimero applications are intentionally lightweight — similar in spirit to smart contracts, but without the heavy constraints and costs of blockchains. Simple applications require very little code. At the same time, complexity is not a limitation. Calimero supports many features expected from traditional backend systems, including:

  • • collections
  • • state mutations and queries
  • • cross-context calls
  • • blockchain integrations (NEAR, ICP, Starknet, Ethereum)
  • • peer-to-peer file sharing for images and other data

Bringing It All Together

Calimero solves hard parts so you don't have to, for users and developers, the focus is always on simplicity. Calimero takes care of networking, encryption, synchronization, and data safety. That frees builders to focus on creating applications — and users to focus on what they actually want to use those applications for. Whether you are building the next generation of “new internet” applications or simply using tools that respect your privacy, Calimero provides everything you need. All tooling is available for both developers and users.

You can learn more by visiting the documentation, exploring the open-source repositories, or contributing directly. We actively encourage community feedback, feature requests, and contributions.

If you have questions, you can always reach out via Discord or email (support@calimero.network). Calimero is built to be open, private, and owned by the people who use it.