What is RediForge and how is it compatible with Redis?

RediForge is an enterprise-grade, memory-first key-value database engineered from first principles in Node.js with zero external runtime dependencies. It provides 100% RESP2 wire compatibility, allowing standard Redis clients such as redis-py, ioredis, Jedis, and redis-cli to connect seamlessly over TCP port 6379 or WebSockets.

How do I connect external Python or Node.js applications to RediForge?

RediForge is 100% RESP2 wire-compatible. You can connect using any standard Redis client library (e.g. redis-py on host rediforge.in port 6379, or ioredis on redis://rediforge.in:6379/0) or directly through secure WebSockets at wss://rediforge.in.

How many isolated databases does RediForge support?

RediForge supports 16 independent logical databases (db0 through db15). Each database maintains an isolated keyspace, independent TTL tracking, and atomic execution contexts accessible via the SELECT command.

What persistence mechanisms does RediForge offer?

RediForge provides dual persistence: compact point-in-time binary RDB snapshots (dump.rdb) and Append-Only File (appendonly.aof) write-ahead transaction logging with configurable fsync policies (always, everysec, no) to prevent data loss.

How does RediForge prevent accidental data loss and dangerous command execution?

RediForge implements CommandGateway security guards that intercept destructive operations such as FLUSHALL and FLUSHDB, requiring explicit confirmation and administrative RBAC privileges before execution.

RediForge — High-Performance Redis-Compatible In-Memory Datastore

RediForge is an enterprise-grade, memory-first key-value database engineered from first principles with zero external runtime dependencies and 100% RESP2 wire compatibility. Built by Ashutosh Yadav.

Key Features & Architecture

100% RESP2 Protocol Compliance: Connect using redis-py, ioredis, Jedis, or standard redis-cli on TCP port 6379.
Multi-Database Isolation: 16 independent logical databases (db0 through db15).
Dual Persistence Subsystem: Binary RDB point-in-time snapshots and Append-Only File (AOF) write-ahead logging.
Integrated Observability: Real-time WebSocket telemetry, memory usage visualizer, key browser, and in-browser RESP terminal.
Enterprise Security: SSRF protection, dangerous command guards (FLUSHALL/FLUSHDB), and multi-tenant Role-Based Access Control (RBAC).

Developer & Author Contact

Lead Architect: Ashutosh Yadav • Email: ashutosh4tech@gmail.com • Portfolio: ashutoshwork.space • LinkedIn: linkedin.com/in/ashutoshyadav256

database RediForge

dns

database

RediForge

Redis-Compatible Engine

High-performance in-memory cache & real-time telemetry console

Create Account • Forgot Password?

account_tree

RediForge System Architecture & Engineering Whitepaper Deep-Dive

High-Level Architecture, Subsystems, Workflows & Developer Philosophy

memory WHAT IS REDIFORGE?

An enterprise-grade, memory-first key-value database engineered from the ground up to provide 100% RESP2 wire compatibility with standard Redis clients (redis-py, ioredis, Jedis) alongside an integrated real-time WebSocket observability console.

lightbulb WHY WAS IT CREATED?

Built to demonstrate first-principles systems engineering with zero external runtime dependencies in the data engine, while providing developers with a transparent, fully auditable alternative following recent Redis commercial licensing shifts.

check_circle PROBLEMS SOLVED

Delivers sub-millisecond data access, prevents accidental data erasure via dangerous command interceptors (FLUSHALL), and eliminates external sidecar complexity with unified live WebSocket telemetry.

verified Core Technical Pillars

Zero Runtime Engine Dependencies: Native standard library execution with zero external runtime packages.

Multi-Database Isolation: 16 independent logical databases (db0 – db15).

Dual Persistence Engine: Point-in-time binary RDB snapshots + Append-Only AOF write-ahead logs.

Enterprise SSRF & RBAC Guard: Loopback IP filters, IPv6 evasions blocker, and structured audit logs.

schema Interactive System Architecture Diagram Live Trace & SVG

open_in_new Open Fullscreen

┌─────────────────────────────────────────────────────────────────────────────────┐
│                              CLIENT ACCESS LAYER                                │
│   [redis-cli]         [ioredis / redis-py / Jedis]        [Web GUI Console]    │
└─────────┬──────────────────────────┬───────────────────────────────┬────────────┘
          │ (TCP Port 6379)          │ (TCP Port 6379)               │ (HTTPS/WSS)
          ▼                          ▼                               ▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│                       GATEWAY & PROTOCOL PARSER LAYER                           │
│   • TCP Socket Manager (server.js)        • HTTP/WS Gateway Bridge (bridge.js)  │
│   • Binary RESP2 State Machine (parser.js) • OAuth & JWT Security Authenticator │
└────────────────────────────────────┬────────────────────────────────────────────┘
                                     │
                                     ▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│                      SECURITY & COMMAND ROUTING GATEWAY                         │
│   • requirepass Auth Guard                 • Dangerous Command Interceptor       │
│   • RBAC Role Evaluator (Admin/Dev/Read)   • Structured Password-Redacted Audit  │
└────────────────────────────────────┬────────────────────────────────────────────┘
                                     │
                                     ▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│                         CORE IN-MEMORY DATASTORE ENGINE                         │
│   [db0]   [db1]   [db2]   [db3]   ...   [db14]   [db15] (16 Isolated Databases) │
│   Data Types: Strings | Hashes | Lists | Sets | Sorted Sets | Bitmaps           │
│   ├─ TTL Expiry (Passive check-on-access + Active 100ms cron sampling)          │
│   └─ LRU Memory Accounting (MaxMemory threshold eviction manager)               │
└────────────────────────────────────┬────────────────────────────────────────────┘
                                     │
                                     ▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│                              PERSISTENCE SUBSYSTEM                              │
│   • Binary RDB Snapshot Engine (rdb.js)   • Write-Ahead AOF Logger (aof.js)     │
└─────────────────────────────────────────────────────────────────────────────────┘

Click nodes for deep code audit Live/Still trace motion Guided views & Route probes

Archify 3.0 Showcase

Request Execution Workflow:

1. Packet Ingestion: Raw bytes received on TCP socket or WebSocket framing buffer.

2. RESP Framing: State machine parses stream chunks into command arguments array (['SET', 'key', 'val']).

3. Security Pipeline: Command Gateway validates session authentication, RBAC privileges, and danger bounds.

4. Engine Execution: Target database executes command with $\mathcal{O}(1)$ or $\mathcal{O}(\log N)$ complexity.

5. Replication & Persistence: If mutating, command is appended to AOF stream and TTL tracked in expiry heap.

6. Encoding & Egress: Result serialized to standard RESP2 bytes and pushed to socket buffer.

data_object Data Structures & Algorithmic Complexities

Data Type	Internal Structure	Read Complexity	Write Complexity	Primary Redis Commands
String	Flat Native Buffer / V8 String	O(1)	O(1)	SET, GET, INCR, APPEND
Hash	Hash Map (Map<string, string>)	O(1)	O(1)	HSET, HGET, HDEL, HGETALL
List	Doubly-Linked Node Buffer Array	O(1) head/tail	O(1) push/pop	LPUSH, RPUSH, LPOP, LRANGE
Set	Unique Hash Table (Set<string>)	O(1)	O(1)	SADD, SMEMBERS, SREM, SISMEMBER
Sorted Set	Balanced Score Array + Hash Map	O(log N)	O(log N)	ZADD, ZRANGE, ZREM, ZSCORE

RESP2 Protocol Parser Implementation

The parser in src/protocol/parser.js is written as a zero-copy state machine that processes arbitrary streaming chunks without memory leaks. It recognizes all 5 RESP2 types: Simple Strings (+), Errors (-), Integers (:), Bulk Strings ($), and Arrays (*).

Direct Author Reach: ashutosh4tech@gmail.com • GitHub Source

show_chart Memory History

manage_search Key Browser

show_chart Memory History

manage_search Key Browser

RediForge

Legal & Compliance Center

cookie Cookie Preferences

Cookie & Privacy Choice

manage_accounts Account & Security Settings

help_center Help Center & FAQ

support Submit Support Ticket

Create Account

Page Not Found

System Health & Cluster Status

RediForge System Architecture & Engineering Whitepaper Deep-Dive

verified Core Technical Pillars

schema Interactive System Architecture Diagram Live Trace & SVG

data_object Data Structures & Algorithmic Complexities

timer Dual-Phase Expiry & LRU Eviction Subsystem

rocket_launch Key Industry Use Cases

psychology What the Developer Thinks (Philosophy & Design Principles)

add_circle Add New Key

edit_note Edit Key Value

warning Dangerous Action Warning

explore Welcome to RediForge