KDB-X: Next-gen kdb+ is here – and it’s built different

We’re proud to announce the General Availability of the KDB-X Community Edition, marking a major milestone in our journey to make the world’s fastest time-series and analytics engine more accessible, modular, and open than ever.

When we first introduced KDB-X in Public Preview, we invited the community to explore early builds, push the limits, and help us modernize the experience around the next-gen KDB-X engine. That collaboration shaped what KDB-X has become: a unified, developer-first platform that brings time-series, SQL, Python, and AI workflows together in one high-performance environment.

With General Availability (GA), KDB-X delivers fully on that vision — introducing a powerful module system, expanded interoperability across q, Python, and SQL, first-class dashboarding, and new AI-native integrations like the Model Context Protocol (MCP) Server.

The Community Edition makes all of this freely available — including for commercial and offline use — with no expiry date. It offers a feature-complete experience within defined resource limits, empowering teams to build, experiment, and innovate with the same speed, scalability, and intelligence that power the world’s most demanding data systems.

From a vision to a platform — shaped by the community

During the Public Preview, we focused on three core promises:

• Unify the developer experience — bring the best of KX technology together with an accessible, modern developer experience (DX), clear documentation, one simple install, and a one-stop-shop developer center.
• Meet developers where they are — support interoperability with q, Python, SQL, and REST in one environment, with support for cloud object storage access and open file formats like Parquet.
• Open the platform — deliver an extensible module framework so teams can compose, share, and reuse capabilities instead of rewriting code.

Over the past releases, we’ve built toward that vision — The KX developer community played a key role in the current version of KDB-X by testing early versions and providing feedback in real time during development. The result at GA isn’t just a faster database; it is a cohesive environment that enables users to shorten the time from planning to production.

What’s new in KDB-X

From Public Preview to a full platform, let’s take a look at what’s new (also summarized here):

The KDB-X module system

At the heart of GA is the new KDB-X module system, a foundation that enables functionality to be portable, reusable, and composable.

Modules encapsulate functionality with a clean interface, local namespaces, and a standardized packaging and load mechanism (use + export). That means you can confidently adopt community modules, share internal libraries without copy-pasting utilities, and curate a consistent toolkit across teams.

Under the hood, the module framework is designed for developers who care about maintainability, reproducibility, and control:

• Each module has its own file path and private namespace, keeping code isolated and collision-free.
• Modules are portable across both in-memory and on-disk environments, so the same component can serve local workflows or production deployments.
• They can be written in q, k, or C extensions, making it easy to blend performance-critical code with higher-level logic.
• Every module defines an export dictionary that explicitly exposes its public interface while keeping implementation details private.
• Module loads are idempotent — repeated calls won’t reinitialize state or duplicate imports.

Together, these properties make modules true building blocks for the KDB-X ecosystem — composable units you can version, share, and extend without friction.

Core KDB-X modules available at GA include:

• Parquet: Query Parquet files with KDB-X. Native support spans q, qSQL, and Python, with built-in datatype conversion, and queries run transparently against virtual tables (type 102h). This allows Parquet data to behave like native KDB-X tables — complete with support for select, exec, and meta operations.
• AI Libraries: Vector, keyword, and hybrid search on unstructured data, plus Time Series Similarity Search (TSS) including Dynamic Time Warping for numeric streams. Featuring q-based ANN indexing (Flat, HNSW, IVF-PQ), they enable scalable semantic, temporal, and fuzzy search across documents, logs, and signals—fully integrated with KDB-X’s real-time engine.
• kURL: A modern REST client built into KDB-X, enabling sync and async HTTP calls directly from q. It simplifies cloud integration by managing authentication for AWS, Azure, and GCP—including automatic credential discovery and secure token handling—enabling seamless REST API and cloud storage access directly from KDB-X.
• REST Server: Turn q functions into REST endpoints for applications, microservices, and dashboards by exposing q logic through standard HTTP methods like GET, POST, PUT, and DELETE — with built-in routing and JSON serialization.
• Object Storage: Query massive S3, Blob, or GCS datasets as if they were local without needing local block storage. It works with compressed data, caches metadata, and allows for optimizing queries by filtering partitions, selecting needed columns, ordering constraints, and using multithreading to reduce latency and improve performance.
• PostgreSQL wire-protocol (pgwire): PostgreSQL wire-protocol support so BI tools like Tableau, Power BI, and SQL clients connect natively.

Open-source modules

Beyond the core GA modules, KX maintains several open-source modules that extend KDB-X functionality:

• FusionX: Includes BLAS (Basic Linear Algebra Subprograms) for high-performance mathematical operations and regex support for advanced pattern matching.
• Logging: Comprehensive logging framework for production KDB-X deployments.

Community-created modules

The KDB-X ecosystem is expanding through community contributions. One of our partners, Data Intellect, has pioneered community-driven module development, demonstrating the extensibility of the KDB-X platform.

Read more about their growing collection of community modules addressing real-world use cases covering everything from custom analytics, connectors, data loaders, and usage/memory monitoring in their blog post: KDB-X modules: A community effort.

Together, these modules make KDB-X modular by design — letting you swap cloud vendors, blend file and table formats, add AI search, or wire into your existing services by simply loading small, composable building blocks.

Together, these modules make KDB-X modular by design, letting you swap cloud vendors, blend file and table formats, add AI search, or wire into your existing services by simply loading small, composable building blocks.

Open data formats

KDB-X GA embraces open data standards as a native integration. With Parquet support now delivered as a core module, developers can directly query Parquet datasets as if they were native KDB-X tables—complete with schema introspection, metadata access, and seamless integration across q, SQL, and Python. This allows data teams to work fluidly across ecosystems, eliminating unnecessary conversions or vendor lock-in.

Parquet is just the start. Our roadmap includes expanded support for additional open formats used across modern data lakes and analytics workflows—ensuring KDB-X continues to meet developers where their data already lives. By aligning with open standards, we’re making it easier to integrate KDB-X into any architecture, from local prototypes to multi-cloud lakehouses.

Interoperability across q, Python, and SQL

KDB-X now speaks the three languages most data teams rely on:

• q remains the most expressive language for high-performance time-series analytics.
• SQL is integrated natively, translating statements to q at runtime. SQL and q coexist seamlessly over the same data.
• Python integration feels truly native. We brought PyKX directly into KDB-X core, resulting in less setup, better performance, and full interoperability with q and SQL.

Together, these integrations dramatically lower the barrier to entry, making it easier than ever for developers and data teams—whether fluent in q, Python, or SQL—to start building on KDB-X.

Built-in visualization: Dashboards for everyone

KDB-X now includes KX Dashboards, an integrated tool for building interactive, real-time visuals across static, streaming, and historical data. With drag-and-drop composition, rich components, and SDK integration, dashboards empower both developers and analysts to turn data into insight.

Because a great platform doesn’t stop at query speed, it helps you deliver insights to users.

Cloud-native by design

Modern data lives across clouds and APIs. KDB-X GA embraces that reality.

• Object Storage lets you query partitioned databases or Parquet datasets directly in S3, Blob, or GCS — perfect for lakehouse patterns and cost-efficient historical storage.
• kURL simplifies secure access to REST APIs and cloud providers for data enrichment and ingestion.
• REST Server exposes your analytics as callable endpoints for apps or microservices.

Together, these form a clean north–south architecture: APIs and applications up top, elastic storage beneath, and KDB-X’s high-performance analytics engine in the middle.

AI-native by default

KDB-X GA makes AI a first-class citizen with two significant additions:

• AI Libraries: Add semantic and temporal similarity search directly into pipelines — vectorize documents, match patterns in time-series data, and detect motifs in real time.
• MCP Server (Model Context Protocol): Query KDB-X in natural language from clients like Claude, GPT, Gemini, or GitHub Copilot in VS Code, with your own governance and guardrails.

Together, these make AI a natural interface to your data, without sacrificing performance, privacy, or control.

KDB-X GA isn’t just a faster database; it’s a complete developer platform. Modular, accessible, interoperable, cloud-ready, and AI-native, built to shorten the distance from idea to production.

A Developer-first experience

KDB-X GA marks the next step in unifying our developer products into one consistent experience — built around a single, modular platform.

What GA means for every developer

For q Developers:

You will experience q as you always have. Install KDB-X and load what you need — Object Store to query S3/BLOB/GCS data, kURL for API access, REST to expose services, and ai-libs for similarity search. Your q skills carry forward — now with less boilerplate, better code reuse, and seamless access to Python, SQL, and AI capabilities. More developer tooling — including unit testing, linting, profiler, debugger, qdocs generation, Qlog, and additional integrations — will arrive as native modules inside KDB-X. See what is coming on the roadmap.

For Python Developers:

Use KDB-X Python to create tables, run queries, and connect to your ML stack. Keep writing Python while gaining access to KDB-X performance, streaming, and time-series primitives without switching environments.

For SQL and BI developers:

Start with SQL in KDB-X and connect your preferred tools through pgwire. Query and visualize instantly, then move to idiomatic q over time for deeper control and speed.

For Quants and Trading Desks:

Accelerate every step of the research-to-post trade analysis workflow, from hypothesis testing and model calibration to real-time signal detection. KDB-X delivers sub-millisecond analytics, integrated Python and AI libraries, and a unified environment for building, validating, and analyzing trading strategies.

For Data Scientists:

Work natively in Python while leveraging KDB-X for high-performance feature engineering, time-series transformations, and vector similarity search. Train and serve models close to the data — then surface insights through Dashboards or connect to AI agents via the MCP Server.

For Data Engineers & Architects:

Simplify data infrastructure and reduce integration overhead. Design for your use-case with the proven tick architecture — across real-time (RDB/IDB) and historical (HDB) data within a single runtime. With built-in modules for Parquet, Object Storage, and REST, you can ingest, transform, and serve streaming and batch data across environments, with consistent governance, observability, and performance.

One platform. One developer hub.

Alongside GA, we’re launching the KX Developer Center, your one-stop shop for everything KDB-X.

It brings together downloads, quickstarts, tutorials, forum, academy, and use-cases in one place, giving developers a truly self-serve experience to install, learn, and ship faster. You’ll also find open-source repositories (including the KDB-X MCP Server) and real-world examples you can clone directly into your projects.

Performance that stands up in public: TSBS DevOps

We ran a series of TSBS DevOps benchmarks comparing KDBX with QuestDB, ClickHouse, TimescaleDB, and InfluxDB. Each system ingested the same dataset and executed identical query definitions on the same hardware under identical conditions.

Key setup details:

• KDB-X used its Community Edition configuration—one q process, 16 GB memory, and four execution threads—while competitors ran default open-source configs with access to full system resources.
• KDB-X achieved these results using only 1.5% of available CPU threads and 8% of system memory, while all other databases ran with full hardware access.

Results snapshot:

• Benchmark wins: KDB-X outperformed competitors in 58 out of 64 scenarios.
• Average query speed: On the geometric mean across all queries, every competitor was significantly slower (the closest, QuestDB, averaged 3.4× slower).
• Peak query performance: On worst-case queries, users would wait ~20× longer with QuestDB and up to ~1,100× longer with ClickHouse compared to KDB-X.
• Breadth of performance: KDB-X was faster in 90%+ of all test cases, including both short-range and multi-year datasets, excelling in aggregation, filtering, and group-by queries.

We encourage you to review the methodology and reproduce the runs; the report explains data generation, parameters, and scripts in detail. (Numbers and methodology summarized here).

Getting started

Start your KDB-X journey with these key resources:

• Install KDB-X
• Tutorials
• Documentation
• Developer Center
• Release notes
• Roadmap
• MCP Server

Moving forward

GA is not a finish line; it’s a foundation. We set out to modernize kdb+ without losing what made it special. With KDB-X, we’ve added an extensible module system, opened standard interfaces and formats (Parquet, SQL, Python, pgwire, REST), embraced cloud native storage and AI workflows, and kept the performance edge that matters in production. For the q community, it’s a faster onramp with less boilerplate. For non-q users, it’s a lower barrier to entry with familiar tools and clear paths to deeper optimization.

If you’ve been following since Public Preview, thank you for the feedback that shaped this release. If you’re new, there’s never been a better time to start building with KDB-X.

– The KDB-X Product Team