Public beta

Limitations

Understand these constraints before depending on Nexir. Each item describes the current limit, who it affects, and the safest action.

Maturity and upgrades

Limited: APIs, command behavior, configuration, release packaging, and on-disk formats can change. There is no migration between storage-format generations and no rolling upgrade: a node refuses a data directory from another generation by name, and the procedure is a fresh cluster with data reloaded at the application level. 0.1.0-beta.4 moved the storage layout from 9 to 10, so a beta.3 data directory does not open under beta.4 or later. 0.1.0-beta.5 changes no storage format, but an in-place upgrade from beta.4, a rolling upgrade and a downgrade were not validated for this release.

Affects: Every beta deployment, especially long-lived data.

Do: Pin versions, read release notes, test upgrades on copies, and keep data reproducible from another source.

Authentication and authorization

Limited: No passwords, ACLs, RBAC, cert-to-user authorization, or tenant isolation. mTLS authenticates a trusted certificate, not an application role.

Affects: Shared or untrusted networks and multi-tenant workloads.

Do: Use private networks, separate client/peer mTLS, strict firewalls, protected administration, and one trust domain per intended security boundary.

Backup and restore

Limited: No supported logical backup, restore, or point-in-time recovery. Internal snapshots only catch up nodes.

Affects: Anyone requiring disaster recovery, audit retention, or data portability.

Do: Use replaceable beta data. A stopped, full-directory cold copy is only a same-version node-level workaround—not a backup product contract.

Redis command coverage

Limited: RESP2 with a scalar-only subset — GET, SET with its conditional and expiry options, single-key DEL, the counters INCR/DECR/INCRBY/DECRBY, the EXPIRE/TTL/PERSIST family, and a small operational set. There are no hashes, sets, lists, sorted sets or streams; no multi-key commands such as MSET/MGET; no EXISTS, TYPE, STRLEN or DBSIZE; and no Lua, functions, transactions/WATCH, pub/sub, blocking operations, modules, geospatial, HyperLogLog, persistence commands or cursor scans. Prefix listing of keys and version-conditioned writes are planned; multi-key atomicity and Active-Active replication are not scheduled.

Affects: Applications migrating from Redis or libraries that issue implicit commands.

Do: Audit every required command against the compatibility table and test the exact client configuration with RESP2.

Transactions and retries

Limited: No public Redis transaction commands, and no atomicity across keys — every supported command touches exactly one key. A timeout or error after submitting a write can leave its outcome unknown.

Affects: Workloads needing multi-key or multi-command atomicity.

Do: Keep atomic work within a single key. Every supported write is idempotent when replayed with the same arguments, but a retried SET ... EX restarts its deadline, so read back PTTL when the exact deadline matters.

Pipelined read-then-write ordering

Limited: Within one connection's pipeline, execution order is guaranteed for write-then-write and write-then-read, but not for read-then-write or read-then-read. GET k pipelined immediately before SET k v may return v.

Affects: Clients that pipeline across a read-then-write boundary and assume Redis's strict per-connection submission order.

Do: Read the reply to the read before issuing the write across that boundary. Sequential request/response clients are unaffected. See Redis compatibility.

Cluster management

Limited: Membership, replacement, addressing, and scaling are manual. No automatic discovery, orchestration, Kubernetes operator, Helm chart, or node fencing after removal.

Affects: Operators of multi-node clusters.

Do: Change one member at a time from a healthy leader, verify catch-up before promotion, preserve quorum, and stop removed processes.

Sharding and topology

Limited: Nexir advertises one Redis Cluster slot range for compatibility but does not shard data across slots.

Affects: Workloads expecting horizontal partitioning or Redis Cluster resharding.

Do: Treat the current deployment as one replicated data set and size it accordingly.

Size and request limits

Limited: 512-byte command names, 1 MiB keys, 60 MiB values and aggregate requests, 128 arguments per request multibulk while the surface is scalar-only, bounded reply buffers, and no way to enumerate keys.

Affects: Large values, deep pipelines in one frame, and any workload that needs to discover keys it did not record.

Do: Bound value sizes and request fan-out, and keep your own key index in the application data model — KEYS and cursor SCAN do not exist.

Memory

Limited: Each node plans its memory at startup and refuses new writes under memory pressure, but the plan is a target, not a hard ceiling on resident memory. Work already admitted can carry a process above its target, and there is no guarantee against the operating system's out-of-memory killer. With default settings, a node with 4 GiB of memory is refused at startup.

Affects: Small hosts and containers, and memory-limited deployments sized tightly against the target.

Do: Leave memory headroom above the process target, lower connection, in-flight command or response limits explicitly on small hosts, and retry writes refused with -TRYAGAIN, which have no effect.

Recovery time at scale

Limited: A follower that falls behind can replay recent history while the leader still holds it; the leader keeps extra history for it only within a byte budget, a time limit and its disk headroom. A follower that falls further behind rejoins through a snapshot transfer whose duration grows with dataset size. The beta.4 measurements, which beta.5 has not repeated, took about 2.5 minutes at 7.5 GiB, 9 minutes at 25 GiB and roughly an hour at 73 GiB on that hardware (single zone, local NVMe). The transfer itself is a small share of that time; preparing and activating the data on the receiving node dominates.

Affects: Any deployment whose dataset is tens of gigabytes or more, and any availability plan that assumes a replaced node is back within minutes.

Do: Size datasets so that a rejoin fits the recovery window you can tolerate, keep nodes from falling far behind (short outages, healthy disks), and watch the snapshot-install and catch-up metrics during a rejoin. No recovery time is guaranteed. Shortening this path is planned for a later release.

Leadership transfer under load

Limited: CLUSTER TRANSFER-LEADER and CLUSTER STEPDOWN require the new leader to have matched the leader's last log entry, which a voter rarely does while writes continue, so they are normally refused under sustained writes.

Affects: Planned leader maintenance on a busy cluster.

Do: Pause writes before moving leadership, then confirm the new leader with CLUSTER INFO.

Disk capacity

Limited: Nexir reserves disk for an incoming snapshot transfer and refuses transfers it cannot fit, but it does not yet stop accepting writes when a node's disk fills. The replication log can grow large while it waits for a snapshot to be taken, and a leader keeps up to 32 GiB of extra log by default for a follower that is catching up. A snapshot build that would not fit is deferred and retried rather than stopping the node, but nothing stops client writes from filling the disk. During an install a node briefly holds two copies of its state plus the log.

Affects: Nodes provisioned close to their dataset size, and disks well below 200 GiB with the default catch-up budget.

Do: Follow the disk-sizing checks in the configuration reference, alert on the on-disk footprint metrics for both databases, leave headroom of the same order as the dataset rather than a fixed percentage, and lower raft.log_retention_budget_bytes on small disks. No per-node capacity such as 256 GB has been validated.

Metrics and encryption

Limited: Prometheus is plaintext and unauthenticated. Nexir does not manage encryption at rest.

Affects: Networks or hosts with compliance/confidentiality requirements.

Do: Use a protected scrape path and platform-level disk/volume encryption and key management.