Nicheloom

Market intelligence for builders — see what's gaining traction before it's crowded.

S2-lite, an open source Stream Store

Details

External ID
46708055
Source
HN
Company
—
Product
S2-lite, an open source Stream Store
Website domain
github.com
Launched
Jan. 21, 2026
Cohort
—
Upvotes
77
Upvotes percentile
0.8695652173913043
Tags
—
Fetched at
Sept. 7, 2026, 9:25 p.m.
Updated at
Sept. 7, 2026, 9:25 p.m.

Description

S2 was on HN for our intro blog post a year ago (https://news.ycombinator.com/item?id=42480105). S2 started out as a serverless API — think S3, but for streams.The idea of streams as a cloud storage primitive resonated with a lot of folks, but not having an open source option was a sticking point for adoption – especially from projects that were themselves open source! So we decided to build it: https://github.com/s2-streamstore/s2s2-lite is MIT-licensed, written in Rust, and uses SlateDB (https://slatedb.io) as its storage engine. SlateDB is an embedded LSM-style key-value database on top of object storage, which made it a great match for delivering the same durability guarantees as s2.dev.You can specify a bucket and path to run against an object store like AWS S3 — or skip to run entirely in-memory. (This also makes it a great emulator for dev/test environments).Why not just open up the backend of our cloud service? s2.dev has a decoupled architecture with multiple components running in Kubernetes, including our own K8S operator – we made tradeoffs that optimize for operation of a thoroughly multi-tenant cloud infra SaaS. With s2-lite, our goal was to ship something dead simple to operate. There is a lot of shared code between the two that now lives in the OSS repo.A few features remain (notably deletion of resources and records), but s2-lite is substantially ready. Try the Quickstart in the README to stream Star Wars using the s2 CLI!The key difference between S2 vs a Kafka or Redis Streams: supporting tons of durable streams. I have blogged about the landscape in the context of agent sessions (https://s2.dev/blog/agent-sessions#landscape). Kafka and NATS Jetstream treat streams as provisioned resources, and the protocols/implementations are oriented around such assumptions. Redis Streams and NATS allow for larger numbers of streams, but without proper durability.The cloud service is completely elastic, but you can also get pretty far with lite despite it being a single-node binary that needs to be scaled vertically. Streams in lite are "just keys" in SlateDB, and cloud object storage is bottomless – although of course there is metadata overhead.One thing I am excited to improve in s2-lite is pipelining of writes for performance (already supported behind a knob, but needs upstream interface changes for safety). It's a technique we use extensively in s2.dev. Essentially when you are dealing with high latencies like S3, you want to keep data flowing throughout the pipe between client and storage, rather than go lock-step where you first wait for an acknowledgment and then issue another write. This is why S2 has a session protocol over HTTP/2, in addition to stateless REST.You can test throughput/latency for lite yourself using the `s2 bench` CLI command. The main factors are: your network quality to the storage bucket region, the latency characteristics of the remote store, SlateDB's flush interval (`SL8_FLUSH_INTERVAL=..ms`), and whether pipelining is enabled (`S2LITE_PIPELINE=true` to taste the future).I'll be here to get thoughts and feedback, and answer any questions!

Enrichment

Theme
database infrastructure and developer tools
Vertical
Horizontal
Function
Data infrastructure
Audience
Developer
AI stance
Not AI
Project type
Hobby / open-source project
Normalized one-liner
open source stream store
Manually corrected
False

Could you build this?

No Building an open-source distributed or high-performance streaming storage engine requires deep systems engineering, complex I/O handling, consensus protocols, and strict persistence guarantees.

What it would actually take: Implementing a high-performance stream store requires low-level systems programming in Rust, C++, or Go with direct I/O and zero-copy data transfer. It demands custom log-structured storage formats, segment index management, offset coordination, and rigorous testing against network partitions and disk failures (Jepsen-style).

Discussion

20 comments analyzed.

Competitors mentioned: Kafka, Redis streams, Delta Lake, DuckDB, SQLite CDC

Concerns raised: Documentation unclear about problem S2 solves and intended audience, S3 not truly 'bottomless' with practical limits, Single writer limitation with SlateDB causes issues with multiple instances, Stale read potential when multiple instances point to same S3 location, gRPC ecosystem bloat and Python implementation problems

Feature requests: Embedded library API instead of just binary, SlateDB WAL to Valkey or other storage to reduce S3 costs/latency, Enable SlateDB local filesystem WAL option, Application-level hash for record integrity verification, QUIC as gRPC alternative

Competitors

Other products that read as similar to this one — 73 launches clear the similarity bar, closest 8 shown.

Attention rank: #13 of 74 (itself plus its competitors, highest first — normalized so YC and Product Hunt are compared fairly).

Launched 81 days after the earliest competitor.

Other launches for this product

Same idea, different domain

Nobody's really built a data infrastructure tool for Media & entertainment yet.