Name: SynCache
Author: SynCache

// why syncache

The problem with caching system market leaders

Leading caching solutions require a network call for every single cache operation. SynCache eliminates that entirely — reads come straight from the same heap your application runs in.

⚡

Reads at Process Speed

No TCP, no kernel syscalls, no context switches. Every remote cache GET forces your application to drop into kernel mode — the CPU saves registers, hands off to the TCP stack, waits for a network round-trip, and climbs back out. SynCache skips all of that: reads are a plain hash lookup inside your own process heap, entirely in user space. The CPU never leaves user mode, and there is no syscall to pay.

🔗

Cluster-Wide Sync, Zero Config

When any instance calls set(), every other instance gets the updated value. When it calls evict(), every other instance drops it. No pub/sub setup, no manual cache busting, no stale reads — consistency across your entire cluster happens automatically as a side effect of normal cache usage.

🔌

Drop-In Migration, No Rewrites

On Spring Boot, switching to SynCache is two lines in application.yaml — set type: syncache and add your token. Your existing @Cacheable, @CachePut, and @CacheEvict annotations work as-is. Every integration is built around each language's native idioms, so you adopt SynCache by adding a dependency, not rewriting your caching logic.

Architecture Overview

App Instance A
In-Process Cache ⚡

App Instance B
In-Process Cache ⚡

↕ evict/update triggers ↕

SynCache Broker
State Sync & Invalidation

✓ All instances notified

App Instance C
In-Process Cache ⚡

App Instance D
In-Process Cache ⚡

Read: app memory · Write sync: broker

💡

The real bottleneck isn't where data lives — it's the trip to get there.

Many teams think the win of a remote cache is that it moves data from disk to memory. But leading cache solutions are already in-memory — that speed gap is already closed. The tax that remains is the TCP round-trip on every GET: your app drops into kernel mode to issue a syscall, the kernel TCP stack serializes a packet, it crosses the network, the cache server processes it, and the reply makes the same trip in reverse. At a million reads per second, those round-trips add up to seconds of pure overhead every hour — just waiting for I/O that carries data you could have read from local memory. SynCache removes that cost entirely on reads. Writes still sync through the broker so your cluster stays consistent — you just stop paying the per-read tax.

// documentation

Everything you need to Implement and Ship fast! Let your service reach its peak...

Pick your language, follow the steps, then explore the full API reference and guides.

+ more coming soon

Quick Start

Follow the steps below to integrate SynCache into your project.

Get Your Broker Token

01 Fill in the form below with your name, email, company, and project name.

02 Click "Generate Free Token" — your token will be sent to your email.

03 Store it as an environment variable: SYNCACHE_TOKEN

Free tier — up to 5 connected instances

Add SynCache to Your Project

Include the SynCache header and link against the shared library via CMake.

# CMakeLists.txt
find_package(SynCache REQUIRED)
target_link_libraries(myapp SynCache::SynCache)

Initialize with Your Token

#include "synCache/Controller.hpp"

Controller controller(synCacheBrokerToken, maxEntries);

Use the Cache

// Set without TTL
controller.set("users", "1", "alice", std::nullopt);

// Set with TTL (seconds)
controller.set("users", "1", "alice", 60L);

// Get as string — returns std::optional<std::string>
auto val = controller.getAsString("users", "1");
if (val.has_value()) {
  std::string s = val.value_or("default");
}

// Get raw bytes — returns std::optional<std::vector<uint8_t>>
auto raw = controller.getRaw("users", "1");

// Evict single entry
controller.evict("users", "1");

// Evict entire namespace
controller.evictAll("users");

// Evict everything
controller.evictAll();

Get Your Broker Token

01 Fill in the form below with your name, email, company, and project name.

02 Click "Generate Free Token" — your token will be sent to your email.

03 Store it as an environment variable: SYNCACHE_TOKEN

Free tier — up to 5 connected instances

Link the Library

Compile with the SynCache C library.

gcc myapp.c -lsyncache -o myapp

Initialize with Your Token

#include "synCache/controller.h"

controller_handle_t *cache = controller_create(
  getenv("SYNCACHE_TOKEN"),
  maxEntries
);

/* Clean up when done */
controller_destroy(cache);

Use the Cache

/* Set string — no TTL */
controller_set_string(h, "users", "1", "alice", NULL);

/* Set string — expires in 60 seconds */
long ttl = 60;
controller_set_string(h, "users", "2", "bob", &ttl);

/* Set raw binary */
uint8_t buf[] = {1, 2, 3, 4, 5};
controller_set_raw(h, "data", "key", buf, sizeof(buf), NULL);

/* Get — always call controller_free() on non-NULL result */
char *val = controller_get_string(h, "users", "1");
if (val) {
  /* use val */
  controller_free(val);
}

/* Evict single entry */
controller_evict(h, "users", "1");

/* Evict entire namespace */
controller_evict_all_namespace(h, "users");

/* Evict everything — always call on shutdown */
controller_evict_all(h);
controller_destroy(h);

Get Your Broker Token

01 Fill in the form below with your name, email, company, and project name.

02 Click "Generate Free Token" — your token will be sent to your email.

03 Store it as an environment variable: SYNCACHE_TOKEN

Free tier — up to 5 connected instances

Install SynCache

pip install syncache

Initialize the Singleton

SynCache uses a singleton — call initialize() once at startup, then use get_instance() anywhere in your app.

import os
from SynCache.Cache import Cache

# Call once at application startup
Cache.initialize(
  broker_auth_token=os.getenv("SYNCACHE_TOKEN"),
  max_entries=1000
)

# Get the instance anywhere in your code
cache = Cache.get_instance()

Use the Cache

# Set any Python object — serialized automatically
cache.set("users", "1", user_obj)

# Set with TTL in seconds
cache.set("users", "1", user_obj, 60)

# Get — pass return type to deserialize
user = cache.get("users", "1", Person)

# Get without type — returns raw JSON string
json_str = cache.get("users", "1")

# Returns None if not found or expired

# Evict single entry
cache.evict("users", "1")

# Evict entire namespace
cache.evict_namespace("users")

# Evict everything
cache.evict_all()

Get Your Broker Token

01 Fill in the form below with your name, email, company, and project name.

02 Click "Generate Free Token" — your token will be sent to your email.

03 Store it as an environment variable: SYNCACHE_TOKEN

Free tier — up to 5 connected instances

Add Maven / Gradle Dependency

<!-- pom.xml -->
<dependency>
  <groupId>com.tabariyya</groupId>
  <artifactId>syncache</artifactId>
  <version>1.0.4</version>
</dependency>

Initialize with Your Token

The broker URL is embedded in your JWT token — no separate configuration needed.

import com.tabariyya.synCache.Cache;

// token + max entries in cache
Cache cache = new Cache(System.getenv("SYNCACHE_TOKEN"), 1000);

Use the Cache

// Set — any serializable type, no TTL
cache.set("users", "1", user);

// Set with TTL in seconds
cache.set("users", "1", user, 60L);

// Get — returns null if not found or TTL expired
User retrieved = cache.get("users", "1", User.class);
if (retrieved != null) { /* use retrieved */ }

// Works with any type: String, Integer, Boolean, arrays, POJOs
cache.set("config", "maxRetries", 3);
Integer retries = cache.get("config", "maxRetries", Integer.class);

// Evict single entry
cache.evict("users", "1");
// Evict entire namespace
cache.evict("users");
// Evict everything
cache.evict();

Get Your Broker Token

01 Fill in the form below with your name, email, company, and project name.

02 Click "Generate Free Token" — your token will be sent to your email.

03 Store it as an environment variable: SYNCACHE_TOKEN

Free tier — up to 5 connected instances

Add the Starter Dependency

<!-- pom.xml -->
<dependency>
  <groupId>com.tabariyya</groupId>
  <artifactId>syncache-spring-boot-starter</artifactId>
  <version>1.0.4</version>
</dependency>

Configure application.yml

spring:
  data:
    syncache:
      brokerAuthToken: ${SYNCACHE_TOKEN}
      maxNoOfEntries: 500
  cache:
    type: syncache

Use Spring Cache Annotations

@Service
public class UserService {

  @Cacheable(value = "users", key = "#id")
  public User getUserById(Long id) {
    return userRepo.findById(id).orElse(null);
  }

  @CachePut(value = "users", key = "#result.id")
  public User createUser(User user) {
    return userRepo.save(user);
  }

  @CacheEvict(value = "users", key = "#id")
  public void deleteUser(Long id) {
    userRepo.deleteById(id);
  }
}

set() — Store a value

Store a value in the local cache and broadcast to all connected instances.

// Without TTL
controller.set("users", "1", "alice", std::nullopt);

// With TTL in seconds
controller.set("users", "1", "alice", 60L);

// Setting the same key again overwrites the value
controller.set("users", "1", "bob", std::nullopt);

get() — Retrieve a value

Read from local in-process memory. No network call — 197× faster than leading cache solutions.

// getAsString — returns std::optional<std::string>
auto val = controller.getAsString("users", "1");
if (val.has_value()) {
  std::string s = val.value();
}
// or with a fallback default:
std::string s = val.value_or("default");

// getRaw — returns std::optional<std::vector<uint8_t>>
auto raw = controller.getRaw("users", "1");
if (raw.has_value()) {
  std::vector<uint8_t> bytes = raw.value();
}

// Both return std::nullopt if the key is not found or TTL expired

Performance Note

Across all languages, get() reads directly from local process memory — no network call, no kernel syscall, no I/O. This is the core reason SynCache achieves 197× faster reads than leading cache solutions.

evict() — Remove & broadcast

Remove a key locally and notify all connected instances to do the same.

// Evict a single entry
controller.evict("users", "1");

// Evict all entries in a namespace
controller.evictAll("users");

// Evict everything across all namespaces
controller.evictAll();

Cache at thespeed of memory.Scale across every node.

The problem with caching system market leaders

Reads at Process Speed

Cluster-Wide Sync, Zero Config

Drop-In Migration, No Rewrites

Real-world numbers. No compromises.

Everything you need to Implement and Ship fast! Let your service reach its peak...

Quick Start

Get Your Broker Token

Add SynCache to Your Project

Initialize with Your Token

Use the Cache

Get Your Broker Token

Link the Library

Initialize with Your Token

Use the Cache

Get Your Broker Token

Install SynCache

Initialize the Singleton

Use the Cache

Get Your Broker Token

Add Maven / Gradle Dependency

Initialize with Your Token

Use the Cache

Get Your Broker Token

Add the Starter Dependency

Configure application.yml

Use Spring Cache Annotations

set() — Store a value

Decorator alternative — @cache_put

get() — Retrieve a value

Decorator alternative — @cacheable

Performance Note

evict() — Remove & broadcast

Decorator alternative — @cache_evict

Consistency Model

Local Reads — Strong Consistency

Cross-Instance Sync — Eventual Consistency

Namespace-Scoped Updates

Docker & Benchmarks

Running Benchmarks

What's Tested

Start caching at memory speed.

Try SynCache Free

Get in touch.

Send a Message

Cache at the
speed of memory.
Scale across every node.