Skip to main content

Distributed Cache for .NET
Built natively for .NET

Stop managing Redis clusters for your .NET apps.

No external dependencies
Runs fully in-process
Seamless scale to cluster
Built for modern .NET (DI-first)
QuickStart.cs
var services = new ServiceCollection()
.AddClustronDkvStores(cfg =>
{
cfg.AddStore("demo", s => s.UseInProc());
})
.BuildServiceProvider();

var client = await services
.GetRequiredService<IDkvClientProvider>()
.GetAsync("demo");

await client.PutAsync("hello", "world");

var value = await client.GetAsync<string>("hello");

Distributed Cache for .NET

High-performance distributed caching with seamless in-process and cluster modes.

Built-in Coordination Primitives

Leader election, distributed locks, counters, watchers, and transactions — built-in.

>_

Production-Ready Tooling

Manage clusters and automate operations using powerful CLI tooling and APIs.

Distributed cachingSession storageHigh-performance APIsLeader electionDistributed locks

Clustron is a distributed coordination platform for modern .NET applications, providing primitives like distributed key-value storage, leader election, distributed locks, transactions, and watch notifications.

Similar to systems like etcd and Consul — but designed specifically for high-performance .NET workloads.

Why Not Redis for .NET?

Redis is powerful — but often overkill for many .NET applications.

Redis

  • Requires external infrastructure
  • Separate deployment & maintenance
  • Network overhead for every call
  • Generic (not .NET-native)

Clustron

  • Runs in-process (zero setup)
  • Scales to cluster when needed
  • No network cost in local mode
  • Built specifically for .NET

Start simple. Scale when needed. Stay in .NET.

Built for High-Performance .NET Workloads

Designed for low-latency, high-throughput applications — without the overhead of external systems.

⚡ In-Process Speed

Zero network overhead when running in-process. Achieve ultra-low latency for critical application paths.

🚀 Scales to Distributed

Seamlessly transition to a distributed cluster when your system grows — without changing your application code.

🧠 Optimized for .NET

Built using modern .NET patterns, memory-efficient structures, and async-first APIs.

Start local. Scale globally. No rewrites.

Built for Real-World .NET Applications

From simple caching to distributed coordination — Clustron adapts to your needs.

🗄️ API Response Caching

Cache expensive queries and API responses with near-zero latency using in-process mode.

🔐 Session Storage

Manage user sessions reliably across instances with seamless distributed support.

⚙️ Distributed Locks

Coordinate background jobs and critical sections safely using built-in locking primitives.

👑 Leader Election

Elect a leader node for scheduling, coordination, or task orchestration.

📡 Watch Notifications

React to data changes in real-time using watch and event-based APIs.

⏱️ TTL & Expiry Workflows

Automatically expire data and trigger workflows using built-in TTL scheduling.

Clustron Architecture

Clustron provides a distributed coordination and key-value platform designed for building reliable distributed systems.

Clustron DKV Architecture

Get Started in 30 Seconds

Install the .NET client and start using Clustron immediately.

1. Install the .NET Client

Install NuGet Package
dotnet add package Clustron.DKV.Client

2. Quick Start (Zero Setup)

QuickStart_InProc.cs
var services = new ServiceCollection()
.AddClustronDkvStores(cfg =>
{
cfg.AddStore("demo", s => s.UseInProc());
})
.BuildServiceProvider();

var client = await services
.GetRequiredService<IDkvClientProvider>()
.GetAsync("demo");

await client.PutAsync("hello", "world");

var value = await client.GetAsync<string>("hello");

3. Connect to a Distributed Cluster

QuickStart_Remote.cs
using Clustron.DKV.Client.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;

var services = new ServiceCollection()
.AddClustronDkvStores(cfg =>
{
cfg.AddStore("teststore", s =>
{
s.UseRemote()
.AddServer("localhost", 7861);
});
})
.BuildServiceProvider();

var client = await services
.GetRequiredService<IDkvClientProvider>()
.GetAsync("teststore");

await client.PutAsync("hello", "world");

var value = await client.GetAsync<string>("hello");

Console.WriteLine(value);

Build your first distributed system in minutes

No Redis. No setup. No infrastructure.
Just .NET.