Timeplus Proton

Timeplus Proton is a high-performance, single-binary SQL engine for real-time stream processing, ETL pipelines, observability, and AI/ML feature engineering. Built on ClickHouse’s vectorized query engine with SIMD optimizations, it delivers 90 million events per second throughput and 4ms end-to-end latency — without JVM dependencies, ZooKeeper, or complex cluster orchestration.

Unlike Apache Flink or ksqlDB, Proton ships as a self-contained binary under 500MB that runs on hardware as minimal as an AWS t2.nano instance. It exposes streaming SQL with native Kafka, Redpanda, Pulsar, and NATS JetStream integration through EXTERNAL STREAM declarations, while simultaneously querying ClickHouse, PostgreSQL, MySQL, MongoDB, and S3/Iceberg via EXTERNAL TABLE — all in the same SQL statement.

Proton extends ClickHouse’s proven analytical engine with first-class stream semantics: tumble, hop, and session windows; watermarks and late-event handling; incremental materialized views that continuously write aggregated results to downstream sinks; and stateful checkpointing for fault-tolerant long-running queries. User-defined functions in Python (via embedded CPython) and JavaScript (via V8) add custom transformation logic without external services.

Deployed via a single curl command, Docker, or Homebrew, it integrates with DBeaver, Grafana, Python/Go/Java SDKs, and REST APIs. The open-source Apache 2.0 core is complemented by Timeplus Enterprise, which adds clustering, a web UI with dashboards, additional connectors via Redpanda Connect, and enterprise support with SLA.

What You Get

• Single C++ Binary Deployment - A self-contained executable under 500MB that starts with a single curl command, installs via Homebrew on macOS, or runs in Docker — no JVM, ZooKeeper, Kafka brokers, or external cluster coordination required, even on a 1 vCPU / 0.5 GiB instance.
• Native Kafka, Redpanda, Pulsar, and NATS JetStream Integration - CREATE EXTERNAL STREAM declarations provide direct SQL read/write access to live event streams with SASL_SSL, IAM (AWS MSK), TLS, and multi-broker support — no Kafka Connect, Debezium, or custom connectors needed.
• Incremental Materialized Views with Windowed Aggregations - Define tumble, hop, and session windows once using SQL; Proton continuously maintains the aggregation and writes results to ClickHouse, Kafka topics, or internal storage, with watermarks handling late-arriving events.
• Federated Queries Across Live Streams and Historical Stores - EXTERNAL TABLE syntax gives read/write SQL access to ClickHouse, PostgreSQL, MySQL, MongoDB, Apache Iceberg on S3, and OpenSearch — enabling joins between a live Kafka stream and a Postgres dimension table in a single query.
• Python and JavaScript UDFs with Embedded Runtimes - Stateless and stateful UDFs run in embedded CPython and V8 runtimes directly inside Proton’s query pipeline, enabling complex enrichment, alerting rules, and ML inference without external microservices.
• Fault-Tolerant Checkpointing for Long-Running Queries - Stateful streaming queries use an incremental checkpoint coordinator that persists aggregation state to local or remote storage, enabling automatic recovery after restarts without replaying the entire event log.
• REST API, Python/Go/Java SDKs, and BI Tool Integrations - Connect DBeaver, Grafana, Metabase, and Superset via the ClickHouse-compatible HTTP interface; ingest data via REST compact streaming; query and manage streams programmatically through native client libraries.

Common Use Cases

• Real-time Log and Metrics Pipeline with Noise Reduction - A DevOps team ingests Kubernetes pod logs and Prometheus metrics from Kafka, applies windowed aggregation to filter transient spikes, and routes structured alerts to Slack webhooks and deduplicated records to S3 before forwarding to Elastic — all in one SQL materialized view without additional orchestration.
• AI/ML Real-time Feature Engineering - A machine learning platform streams user clickstream events from Redpanda through Proton, computes rolling session aggregates and recency features using hop windows, writes the output to ClickHouse for low-latency feature serving, and triggers model inference via Python UDFs — replacing a Flink cluster with a single Proton binary.
• CDC Enrichment and Denormalization Pipeline - A fintech application captures PostgreSQL change events via Debezium into Kafka, joins them in Proton with customer dimension data from a PostgreSQL EXTERNAL TABLE, denormalizes the result, and streams enriched records into ClickHouse for real-time fraud detection dashboards with significantly lower infrastructure overhead than traditional Kafka Connect topologies.
• Sub-second Trading Surveillance and Alerting - A quantitative trading firm connects Proton to Redpanda topics carrying high-frequency trade events, runs ASOF JOINs to correlate order fills with reference data, applies rule-based alert logic through SQL UDFs, and surfaces risk metrics in Grafana with end-to-end latency measured in milliseconds.
• Observability Data Routing with In-Pipeline Transformation - A platform engineering team uses Proton as a lightweight alternative to a full observability pipeline tool, routing trace and span data from a Kafka topic through SQL filters and enrichment rules, then writing to OpenSearch for full-text search and ClickHouse for aggregate dashboards simultaneously.

Under The Hood

Architecture Timeplus Proton is structured as a layered C++ system built directly on top of ClickHouse’s core analytical engine, extending it with a dedicated streaming execution path. The architecture separates storage concerns (StorageStream for native streams, StorageExternalStream for Kafka/Redpanda/Pulsar/NATS), query interpretation (a Streaming sub-layer inside Interpreters that handles window semantics, watermarks, and changelog processing), and execution (processor pipelines that route blocks through query plans). A CheckpointCoordinator manages fault-tolerant state persistence for long-running queries, supporting both local file system and remote checkpoint backends. The modular ExternalStream subsystem enumerates connector types (Kafka, Pulsar, NATS JetStream, HTTP, Iceberg, Python, Log) as distinct implementations behind a shared StorageExternalStreamImpl interface, making it straightforward to add new sources without touching the core SQL engine. The result is an event-driven pipeline architecture where streaming and batch semantics share the same vectorized execution blocks, unified by ClickHouse’s column-oriented Chunk and QueryPipeline abstractions.

Self-Hosting

Timeplus Proton is licensed under the Apache License 2.0, one of the most permissive open-source licenses available. You can use, modify, and distribute it freely — including in commercial products and internal tooling — with no copyleft requirement to open-source your own code. The only obligations are preserving the copyright notice and the NOTICE file. For organizations, this means there is no license fee, no registration, and no usage cap on the open-source binary.

Running Proton yourself is operationally lightweight compared to alternatives like Apache Flink or ksqlDB. The single binary requires no JVM, no ZooKeeper ensemble, no Kafka broker, and no external metadata store for single-node deployments. It can run on a t2.nano-class instance for moderate workloads or scale vertically to utilize SIMD-optimized multi-core processing. You are responsible for configuring data directories, setting up checkpoint storage for fault-tolerant long-running queries, and managing upgrades by replacing the binary. Because there is no cluster mode in Proton (cluster support is an Enterprise feature), horizontal scaling requires the commercial tier.

Timeplus Enterprise adds what the open-source edition intentionally withholds: multi-node clustering and Kubernetes-based self-hosting, a web-based UI with dashboards and data lineage visualization, hundreds of additional connectors via Redpanda Connect, WebSocket and HTTP stream sources, CSV upload, API key authentication for REST ingestion, and enterprise support via email, Slack, and Zoom with contractual SLAs. If your use case requires high availability, automated failover across nodes, or managed connectors for Salesforce, S3 sinks, or Slack notifications, you will need to evaluate the commercial tier or build those integrations yourself on top of the OSS binary.