Redis-compatible storage with a sharper edge.
Use your existing Redis client with zero code changes. Redge turns familiar Redis commands into durable storage on D1, Turso, SQLite, Postgres, or MySQL, with a hot cache in front for fast reads.
import Redis from "ioredis";
const redis = new Redis(process.env.REDIS_URL);
await redis.set("session:42", userId, "EX", 1800);
await redis.incr("rate:api:42");
await redis.zadd("leaderboard", 9310, "ana");The migration
Change the URL. Keep the Redis workflow.
Redge speaks the Redis protocol over TCP, so normal clients connect the way they already do. The app sees Redis commands. Redge handles cache, persistence, TTL cleanup, and backend-specific storage.
REDIS_URL=redis://cache.internal:6379 const redis = new Redis(process.env.REDIS_URL)
REDIS_URL=rediss://acme.redgedb.com const redis = new Redis(process.env.REDIS_URL)
Why Redge
Most apps do not need all of Redis. They need the Redis developer experience.
Keep the protocol
Your app keeps GET, SET, EXPIRE, INCR, SCAN, sorted sets, pipelines, and simple transactions through the clients developers already know.
Persist to real storage
Data lives in SQL-backed backends instead of disappearing with a cache process. Inspect it, back it up, and move it later.
Deploy where the app lives
Start locally with SQLite, go edge-native with D1 or Turso, or run against Postgres/MySQL when that is already your operational center.
Architecture
A practical Redis interface in front of durable edge storage.
Redge is not a Redis clone, message broker, or cluster replacement. It is a focused protocol layer for the Redis-shaped state modern apps actually use.
Client
Existing Redis or Valkey client.
Redge TCP
RESP2 listener and command router.
L1 cache
Process-local hot cache with TTL and metrics.
Backend
D1, Turso, SQLite, Postgres, or MySQL.
Self-host in minutes.
Start from the MIT-licensed repo, run the Go server, point DATABASE_URL at the backend you want, then connect with redis-cli or your app.
github.com/pubflow/redgego run ./cmd/redge
Use cases
Built for the Redis-shaped state apps reach for first.
Sessions, API keys, rate limits, user context, leaderboards, feature flags, and hot cache without committing to a dedicated Redis bill from day one.
Sessions with TTL
Keep login state close to your app without a memory-only source of truth.
API keys and auth context
Store operational state in SQL-backed keys you can inspect and revoke safely.
Rate limits
Use counters, expirations, and sorted sets for practical quota patterns.
Leaderboards
Sorted sets for scores, ranks, and lightweight competitive product moments.
Feature flags
Fast reads from the hot cache, durable values in the backend you choose.
Hot app cache
Cache the keys your app reads constantly without adopting another service bill.
Compatibility
Honest Redis compatibility for commands modern apps use most.
Redge is compatible where the storage model maps cleanly today. Unsupported primitives are named clearly, so teams can adopt it with confidence.
Redge Cloud
More than hosted Redge. Operations, visibility, and edge cache.
Redge Cloud sells the hard part: managed redgedb.com subdomains, storage provisioning, key inspection, compatibility reports, audit logs, alerts, and hot keys served close to your app.
Join cloud waitlistHosted Redge subdomains
Give every project a managed rediss://team.redgedb.com endpoint and keep the same client code.
Managed backends
Provision D1, Turso, or Postgres with schema, migrations, tokens, and health checks handled.
Global edge read cache
Serve hot keys near your app and watch cache hit rate, hot keys, and slow backend queries.
Key explorer
Inspect keys, TTL, type, size, last access, sorted-set members, and delete with guardrails.
Pricing direction
Simple enough to try, serious enough to grow.
Self-host Redge for free. Move to Cloud when the team wants hosted endpoints, managed storage, observability, auditability, and edge read performance without operating the stack.
Free
Starter
best startPro
Business
Keep your Redis client. Choose your backend.
Redge gives apps Redis-compatible workflows, durable SQL-backed storage, hot-cache performance, and infrastructure that can start near zero.