Faster than Redis glue.
Built for state sync.
Redis is a cache. Kafka is a log. Firebase is someone else's cloud. If you only need live application state, those are the wrong layers, and the wrong bill.
Lux is a buyer-deployed sync broker plus a ~2.5 KB client: nanosecond in-memory ops, microsecond broker hot path, local-first reads, WebSocket push, no queue on the hot path. Your state stays in your account. Open source to start. Marketplace when procurement cares.
Measured boundaries, not public internet RTT. Full claim map: Redis is not a state sync layer.
Stop bolting a protocol onto Redis.
Redis pub/sub is fire-and-forget messaging. Application state needs a current value, reconnect, offline queue, CAS, a browser SDK, and a bill that does not scale with every fan-out. Teams rebuild that stack every year and call it “we use Redis for realtime.”
Lux is that stack: open-source client, buyer-deployed broker, optional AWS Marketplace license. No Kafka cluster for a dashboard. No managed realtime meter for an ops board.
- 01 Local-first reads: zero network on the UI hot path
- 02 In-RAM broker path: no MQ, no DB pre-read before ack
- 03 Your account: state never has to leave buyer infrastructure
Real-time shouldn’t cost you control, or a fortune.
If any of these is the problem you woke up with, Lux is the way out.
“Your real-time bill scales with every message.”
Managed sync services meter every read, write, and delivery, so the bill balloons with fan-out. Lux includes real-time delivery and runs as one process at flat, predictable cost.
See how the cost stays flat“User data can’t live on a vendor’s servers.”
Managed services run on the vendor’s infrastructure. Lux deploys in your own cloud account (GCP / AWS); your data never leaves your account.
Deploy in your own cloud“You’re standing up Kafka for state you don’t need.”
Durable event-log stacks are overkill for current-state sync. Lux is a lightweight buyer-deployed broker, the latest value every client needs, no message-queue plumbing.
See the broker architecture“Reads need to be instant, even offline.”
A network round-trip on every read is too slow. Lux serves reads locally from the browser with zero round-trips and pushes changes over a live WebSocket; a ~2.5 KB client, no build step.
See the drop-in client▶ Real-Time Sync in One Install
Add live cross-device state to your app with a single npm i @voxell/lux - local-first reads, WebSocket push, in your own infrastructure. No Kafka, no message-queue plumbing.
Own your data. Predictable cost. Local-first speed.
Managed sync services run on the vendor's infrastructure and meter you per operation, every read, write, and real-time delivery is a line item, and the bill climbs with fan-out. Voxell Lux runs as a single process on infrastructure you control: real-time delivery is included, the cost is flat, and the data never leaves your account.
Self-host, no lock-in
Deploy on your own cloud account (GCP or AWS Marketplace), backed by your own durable store. No proprietary runtime, no data leaving your account, no vendor you can't leave.
Real-time delivery included
Delivery isn't metered per message, so your bill doesn't balloon with fan-out the way per-operation pricing does. One process, flat and predictable as you grow.
Zero round trips, live push
Reads are served from the browser synchronously, no network in the hot path, online or off. Every change pushes across a user's tabs and devices over a live WebSocket the instant it happens. A ~2.5 KB client, no build step.
Built for active application state
Lux is not a general message queue. It's a fast, buyer-deployed synchronization broker for the active state of your application, the latest value every client needs right now, not a durable event log.
Many clients need the latest state immediately.
The broker keeps hot state in memory and pushes every update over WebSockets.
Forms, queues, incident boards, and admin panels need live coordination.
Lightweight sync without standing up a full message-queue stack.
Agents, workers, and UI sessions need shared live state.
A fast state broker that runs right next to the workload.
Local and edge components need to sync active state with cloud apps.
Deploy the broker close to your environment, in your own account.
Presence, cursors, collaborative controls, live UI state.
Low-latency fanout and active-state sync, no game server required.
Device and control status needs live UI updates.
In-memory state on a broker you control and deploy yourself.
Under the Hood: High-Performance State Broker
Voxell Lux bypasses the overhead of traditional enterprise message queue layers. We've optimized the sync engine for extreme microsecond dispatch directly in host memory.
Zero-Plumbing Memory Pipes
By eliminating heavy ActiveMQ, RabbitMQ, or Kafka plumbing, the Go-based broker operates entirely in host memory. Real-time synchronization functions as a clean, lock-free asynchronous pipe that relays diffs directly over optimized persistent WebSockets with near-zero memory footprint.
35 ns/op "C Buckets" Limiter
Patent-Pending Lock-Free Token Layer
Protecting resources under extreme concurrency typically demands expensive database locks. Voxell Lux utilizes a patent-pending, hardware-optimized lock-free rate limiter running at 35 ns/op per bucket in host container memory.
Atomic LWW-Reconciliation
Rather than transferring full database objects or whole state trees on every small modification, the client-side module performs active delta value diffing. The backend synchronizes states using atomic logical timestamps to guarantee LWW (Last-Write-Wins) precision with minimal database overhead.
Drop-in State Synchronizer
Add cross-device synchronization to any existing static HTML file, serverless application, or classic script. No build steps, no webpack configurations, and no complex schemas.
- Last-write-wins reconciliation resolved by atomic server-side timestamps.
-
Flush on demand, call
store.flush()onpagehideto push pending saves before a tab closes. - Secure credentials validated dynamically on Cloud Run against Firestore registration records.
import { lux } from 'https://cdn.jsdelivr.net/gh/VoxellInc/lux_sdk/src/lux.js';
// Initialize state store
const store = lux('user-preferences', {
endpoint: 'https://YOUR-broker.run.app/api/lux',
apiKey: 'fw live ...',
realtime: true
});
// Load local-first state, then update when push sync lands
store.load((data, meta) => {
console.log(`Synced! [Source: ${meta.source}]`, data);
updatePreferencesUI(data);
});
// Save updates synchronously to local cache & debounce to Cloud Sync
saveButton.onclick = () => {
store.save({ theme: 'dark', fontSize: 16 });
};Is Voxell Lux a fit?
We're not for everyone, and we'd rather tell you up front than waste your assessment.
Great fit if you want to…
- • Self-host and keep your data in your own cloud account
- • Keep cost flat and predictable as real-time fan-out grows
- • Avoid lock-in to a single vendor's proprietary stack
- • Add fast, local-first cross-device state with a drop-in client
Probably not, if you…
- • Require a fully-managed, first-party service you never operate
- • Are committed to one vendor's native ecosystem end to end
- • Need a turnkey suite of auth, functions, and analytics in one bill
Open source to start. Marketplace when it has to clear legal.
Same architecture either way: client + broker you deploy. AWS for procurement-safe commercial. OSS when you just need the path live today.
Open source MIT
npm i @voxell/lux: client + edge shape on GitHub. Local-first, no framework, works before you ever talk to sales.
AWS Marketplace Active
Lux Sync SaaS product for procurement. Buyer-deployed broker in your account; signed offline license; support path through Voxell. Search Lux Sync or ask us for the Product ID.
References to other services describe their general architecture and billing model as of June 2026; verify current terms with the respective provider. Performance figures are measured on Voxell's reference hardware and will vary by deployment.