explaingit

risingwavelabs/risingwave

9,005RustAudience · dataComplexity · 4/5LicenseSetup · moderate

TLDR

A streaming database that processes live data continuously and keeps query results up to date in real time, replacing the multiple separate tools usually needed for stream processing.

Mindmap

mindmap
  root((repo))
    What it does
      Stream processing
      Materialized views
      Real-time queries
    Tech stack
      Rust
      SQL
      Kafka
      Apache Iceberg
    Use cases
      Live dashboards
      CDC pipelines
      Stream analytics
    Audience
      Data engineers
      Backend teams
Click or tap to explore — scroll the page freely

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

Things people build with this

USE CASE 1

Write SQL queries that automatically update as new Kafka messages arrive, replacing a separate stream processor with a single database.

USE CASE 2

Capture changes from a PostgreSQL or MySQL database and query the live results with sub-100-millisecond latency.

USE CASE 3

Build a real-time analytics dashboard that queries continuously updated materialized views instead of stale snapshots.

USE CASE 4

Store streaming results in Apache Iceberg so Spark or DuckDB can also query the same data for batch workloads.

Tech stack

RustSQLPostgreSQLKafkaApache IcebergDockerKubernetesS3

Getting it running

Difficulty · moderate Time to first run · 30min

Requires Docker or Kubernetes for deployment, connecting data sources like Kafka needs additional configuration.

Free to use, modify, and distribute for any purpose including commercial, with a notice of changes and a copy of the Apache 2.0 license.

In plain English

RisingWave is a database built for working with data that changes constantly. Rather than analyzing data after the fact by running queries against a stored snapshot, it processes incoming data streams continuously and keeps results up to date. When you query it, you get the current state, not information from minutes ago. The problem it addresses: building a system that ingests live data, transforms it, and serves fresh results has traditionally required stringing together several separate tools. You might use one tool to capture database changes, another to move those changes around, a third to process and aggregate them, and a fourth to store the results for querying. RisingWave replaces that whole chain with a single system. You write queries in standard SQL (the same language used to query most databases), and RisingWave maintains what it calls materialized views: precomputed results it updates automatically as new data arrives. Query latency stays under 100 milliseconds regardless of how much data is flowing through. It connects using the same wire protocol as PostgreSQL, so existing tools and database drivers work without changes. Data can come from multiple sources: changes captured from PostgreSQL and MySQL databases, messages from Kafka or other streaming platforms, HTTP webhooks from external services, or files from storage systems like S3. All these sources can be queried together with the same SQL interface. For long-term storage, RisingWave writes to Apache Iceberg, an open table format that other tools such as Spark, DuckDB, and Trino can also read. It manages ongoing table maintenance automatically. Hot data for fast queries is kept in an internal row store, cooler historical data lives in object storage, which is substantially cheaper than keeping everything in memory. It can be deployed as a managed cloud service or self-hosted using Docker or Kubernetes. The source code is licensed under the Apache 2.0 license.

Copy-paste prompts

Prompt 1
Help me write a RisingWave SQL CREATE MATERIALIZED VIEW that counts events per user from a Kafka topic in real time.
Prompt 2
How do I connect RisingWave to a PostgreSQL database using CDC to capture row changes and query the latest state?
Prompt 3
Show me a Docker Compose setup for RisingWave that includes a Kafka source and writes results to an Iceberg table on S3.
Prompt 4
I want to replace my Flink job with RisingWave. Help me rewrite a windowed aggregation in RisingWave SQL with a tumbling window.
Open on GitHub → Explain another repo

← risingwavelabs on gitmyhub — every repo by this author, as a profile.

Verify against the repo before relying on details.