Introduction to KDB-X
This page introduces KDB-X and explains how it builds on kdb+ to support modern, real-time, and AI-driven analytics. By the end, you should understand what KDB-X is, how it differs from kdb+, and where it fits within a modern analytics stack.
Why KDB-X?
kdb+ has long been a benchmark for high-performance time-series analytics. Its combination of an in-memory, columnar database and the expressive q language enables developers to process massive volumes of data with extremely low latency. However, while performance remains critical, modern data teams increasingly require more than raw speed.
Modern data teams now expect:
- Interoperability with open data formats (for example, Parquet) and external systems
- Polyglot access (Python and SQL alongside domain-specific languages)
- Strong tooling and package management for easier extensibility and community contribution
- Integration with AI
KDB-X exists to address these needs while preserving the core strengths of kdb+.
q and kdb+: the foundation
Info
KDB-X is built on the kdb+ database and the q programming language. Familiarity with q helps in understanding how KDB-X works and in leveraging the platform’s full capabilities.
q is a concise and expressive programming language (built on k) that combines vector operations with functional programming. Tables — equivalent to data frames — are first-class citizens and can reside in memory or be stored on disk in a columnar format.
The kdb+ engine is optimized for temporal workflows, with native support for:
- Time bucketing and windowing
- As-of and temporal joins
- Time-based partitioning
- High-throughput ingest and low-latency queries
A q process can act as a database (kdb+) simply by opening a port and accepting queries.
kdb+ handles both real-time and historical data, processing billions of events and querying trillions of records efficiently. Its query language enables developers to express complex analytical logic succinctly, making them significantly more productive. These capabilities have made kdb+ especially popular in domains such as capital markets, where traditional databases struggle to meet the volume and speed demands of time-series analytics.
The following examples illustrate the expressiveness of q for vector operations and analytical queries.
q)buys: 2 1 4 3 5 4
q)sell: 12
q)sums buys
2 3 7 10 15 19
q)deltas sell&sums buys
2 1 4 3 2 0
select sym, time, pricegroup:({sums differ x};price) fby sym, price
from trade where sym in `GOOG`TSLA
sym time pricegroup price
-------------------------------------------
GOOG 0D04:00:00.005432812 1 177.5
GOOG 0D04:00:00.013933115 2 177.72
GOOG 0D04:00:00.014699994 3 177.5
GOOG 0D04:00:00.014806245 3 177.5
GOOG 0D04:00:00.014808873 4 177.4
GOOG 0D04:00:00.014808936 4 177.4
From kdb+ to KDB-X
While kdb+ excels at performance and expressiveness, it was not originally designed to meet all the expectations of modern data platforms.
KDB-X retains the proven kdb+ execution engine but extends it with a focus on on developer experience through improved accessibility, extensibility, and interoperability.
KDB-X enables the same analytical workloads to be expressed using q, Python, or SQL, while executing on a unified underlying engine. This allows teams to adopt KDB-X incrementally—preserving existing q code while enabling new users to work in familiar languages.
It introduces architectural improvements that enable community contributions, making it highly extensible. It supports Python, SQL, and q, and is being built to work with open data formats like Parquet and Iceberg for interoperability.
Lastly, it's built for the AI era with transformative agentic AI interaction and scalable machine learning integration. Our vision is to make it easier for developers to build, extend, and deploy high-performance analytics applications without compromise.
The following examples show equivalent analytical logic expressed across q, Python, and SQL.
select avgSpread: avg ask - bid by sym, 0D00:10 xbar time
from quote where sym in `GOOG`TSLA`FANG
db.quote.select(columns=(kx.Column('ask') - kx.Column('bid')).avg().name('avgSpread'),
where=kx.Column('sym').isin(["GOOG", "TSLA", "FANG"]),
by= kx.Column('sym') & kx.Column ('time').minute.xbar(10))
s)SELECT sym, xbar('0D00:10', time) AS time, AVG(ask - bid) AS avgSpread
FROM quote WHERE sym IN ('GOOG', 'TSLA', 'FANG')
GROUP BY sym, time
About KDB-X
KDB-X is a modern, modular analytics platform under active development by KX for real-time, AI-driven workloads. Built as the next generation of kdb+, it unifies with existing applications while introducing a framework that encourages community-driven contributions to the evolving, open, and modern data ecosystem.
Rather than stitching together separate tools for time-series analytics, vector search, and AI workloads, KDB-X provides a unified environment in which these workloads can coexist. Developers can build and ship data-intensive applications faster — with support for Python, SQL, and q — in one unified, scalable, and developer-friendly environment designed for both structured and unstructured data.
KDB-X is designed to analyze massive volumes of time-series data with exceptional speed and efficiency. It supports open data formats such as Parquet and Iceberg, making it easier to exchange data with external systems and cloud-native pipelines. Advanced AI and machine learning capabilities are integrated directly into the platform, enabling analytical workflows that combine structured and unstructured data.
Whether you’re working with real-time or historical data, KDB-X delivers the speed, flexibility, and interoperability needed for today’s data-driven world.
Key advantages
- Unified analytical data stack: Seamlessly handle streaming, batch, and historical data in real time through a single compute and data environment.
- Polyglot access: Support for Python, SQL, and q in a single platform designed for modern data workflows.
- High-performance engine: Built on the proven kdb+ kernel, delivering industry-leading speed for time-series data processing.
- Built-in vector search and AI capabilities: Leverage both structured and unstructured data for unified queries and insights.
- Streaming analytics runtime: Optimized for low-latency execution on high-volume, time-sensitive data streams.
- Backward compatibility: Supports existing q code, APIs, and workflows, preserving prior investments while enabling next-generation workloads.
- Modular architecture and extensibility: Designed from the ground up for modular integration, making it easier to manage libraries and expand functionality over time.
- Deployment agility: Operate self-managed in the cloud or on-premises environments with consistent control and performance.
What’s included?
KDB-X includes a KDB-X Community Edition that has limited resource capacity, while a paid licensed edition is available with full capacity, enterprise support, service-level agreements (SLAs), and options for integration into production environments.
For more details on inclusions and limitations, refer to our usage restrictions.
Ready to get started? Install KDB-X now by following the KDB-X Install guide.