Cube Core version 1.7 is the latest release to date. Its headline is the general availability of Tesseract, Cube's next-generation data modeling engine: the capabilities that have been maturing in preview — multi-stage calculations, multi-fact views, and more — are now ready for production use, and this release adds substantial new modeling power on top of them. Alongside Tesseract, v1.7 brings broad data modeling improvements and a major performance overhaul of the query orchestrator and SQL API.

Headline features in this release:

  • Breaking changes: Tesseract and the native query pipeline are now the default, several long-deprecated options are removed, and the Docker runtimes are upgraded
  • Tesseract is now generally available, with new multi-stage directives, default value filters for views, and automatic parenthesization of member references
  • New in data modeling: number formatting, links in the data model, conditional data masking, and view groups
  • New in pre-aggregations: multiple time dimensions, per-subquery pre-aggregation matching, and pre-aggregation-specific data sources
  • New in APIs and client libraries: a client-side Format API, SQL window functions, and a query format conversion API
  • Performance: a new columnar data transport between JavaScript and Rust, with up to ~5–20x faster result handling

This release contains breaking changes. Most of them enable Tesseract and the native query pipeline by default, or remove options that were deprecated in earlier releases. Before upgrading, please familiarize yourself with the breaking changes below and their migration paths.

Breaking changes

BREAKING: Tesseract SQL planner and pre-aggregations are enabled by default. With Tesseract reaching general availability, CUBEJS_TESSERACT_SQL_PLANNER now defaults to true, so the next-generation data modeling engine is used out of the box, and Tesseract-based pre-aggregation matching now follows the same flag (the separate CUBEJS_TESSERACT_PRE_AGGREGATIONS environment variable has been removed). To fall back to the legacy planner, set CUBEJS_TESSERACT_SQL_PLANNER=false — the legacy planner is deprecated and will be removed in the near future.

BREAKING: The native query orchestrator is now always enabled. The option to disable it has been removed (the CUBEJS_TESSERACT_ORCHESTRATOR environment variable no longer exists), and the native, columnar query path is used in all cases. This is the basis for the performance improvements described below.

BREAKING: Numeric values in REST API results are now serialized as JSON strings. Previously the JSON type of numeric values in /v1/load results varied by driver — sometimes strings, sometimes numbers. Now all numeric values are serialized consistently as JSON strings, regardless of the data source. Applications that read numeric fields from the REST API and relied on receiving JSON numbers should parse the string values. If you use the JavaScript client libraries, you can opt back into JavaScript numbers with the castNumerics load option.

BREAKING: The default continueWaitTimeout changed from 5 to 10 seconds. Raising the default long-polling interval means clients poll less aggressively and short-to-medium queries are more likely to return a result on the first request instead of a Continue wait. To keep the previous behavior, set continueWaitTimeout: 5 explicitly in your orchestrator or queue options.

BREAKING: The running_total measure type has been removed. Deprecated back in v0.33.39, it is now removed: data models that use type: running_total will fail validation. Replace them with a rolling_window measure using an unbounded trailing window.

BREAKING: The renewQuery parameter has been removed. Deprecated in v1.3.73, the renewQuery parameter of the /v1/load REST endpoint and the GraphQL cube query no longer exists. Use the cache parameter instead: cache: 'must-revalidate' replaces renewQuery: true, and the default stale-if-slow replaces renewQuery: false.

BREAKING: The context_to_roles configuration option has been removed. It was deprecated in v1.6.4. Use context_to_groups instead.

BREAKING: The dbType option has been removed. Deprecated back in v0.30.30, CreateOptions.dbType no longer exists. Use driver_factory instead.

BREAKING: The CUBEJS_SCHEDULED_REFRESH_CONCURRENCY environment variable has been removed. It was deprecated in v1.2.7. Use CUBEJS_SCHEDULED_REFRESH_QUERIES_PER_APP_ID instead.

BREAKING: The Elasticsearch driver has been removed. It was deprecated in v1.6.0. There is no drop-in replacement.

BREAKING: Docker images upgraded to OpenJDK 21 and Python 3.13. The -jdk image now runs Java 21, so JDBC drivers and custom JARs must be compatible with OpenJDK 21. Custom Python packages installed into the image (for example, for Python or Jinja data models) must target Python 3.13 — packages built for 3.11 will not load.

BREAKING: Node.js 20 is no longer supported. Node.js 20 reached end of life on April 30, 2026, so the minimum supported version is now Node.js 22. Node.js 22 is itself deprecated (it has been in maintenance mode since October 21, 2025) and support will be dropped in a future release, so we recommend running Node.js 24, which is what the official Docker image now ships.

New in data modeling

Tesseract is now generally available. Tesseract, Cube's next-generation data modeling engine, is now ready for production use. The features it powers — multi-stage calculations, multi-fact views, and the data modeling additions below — graduate from preview in this release, and Tesseract is now enabled by default (CUBEJS_TESSERACT_SQL_PLANNER defaults to true).

Multi-stage grain directive. Now you can control the grain of a multi-stage measure — the dimensions of its inner aggregation stage — with a single grain directive. It accepts keep_only (restrict the grain to the listed dimensions), exclude (remove them), and include (add them), unifying what previously required the separate group_by, reduce_by, and add_group_by parameters (which remain supported).

measures:
  - name: country_revenue
    multi_stage: true
    sql: "{revenue}"
    type: sum
    grain:
      keep_only:
        - country

Read more in the documentation: Measures.

Multi-stage filter directives. Now multi-stage measures support a filter directive to drop, replace, or extend the filter context that the inner aggregation stage inherits from the query. This enables calculations such as "share of total" where the denominator must ignore a filter applied by the query. Read more in the documentation: Measures.

Default value filters for views. Now a view can declare default_filters that are applied to every query against it, narrowing results to a specific subset of data without requiring consumers to specify the filter explicitly — useful for governance scenarios where a view should always be scoped to a value (e.g. a tenant, region, or currency). Read more in the documentation: View.

Automatic parenthesization of member references. You can now safely reference a member whose sql is a compound expression (such as {price} + {tax}) inside a larger expression: Cube wraps it in parentheses automatically when it's substituted into an arithmetic or logical context, so operator precedence is always preserved. Read more in the documentation: Syntax.

Number formatting for measures and dimensions. Previously, Cube offered only a small, fixed set of formats. Now, Cube Core ships a full number formatting system: you can set a currency on numeric measures and dimensions, use predefined named numeric formats (such as currency_2, percent_1, or abbr), and define custom d3-format specifier strings. Named formats accept an optional _N precision suffix.

measures:
  - name: total_revenue
    sql: amount
    type: sum
    format: currency_2
    currency: USD

Read more in the documentation: Measures, Dimensions.

Links in the data model. Now you can define links on a dimension — a URL constructed from a SQL expression, or a dashboard identifier — that supporting tools (such as Workbooks) can render as clickable HTML links, letting users navigate from a value to a related external resource or dashboard. Read more in the documentation: Dimensions.

Conditional data masking in access policies. Now Cube Core supports masking member values — and conditionally masking them with row-level filters. You can apply a mask to dimensions and measures, and control masking per role via member_masking in access policies, so sensitive values are obscured for users who shouldn't see them while remaining queryable. Read more in the documentation: Data access policies.

View groups. Now you can organize the members of a view into named groups using view_group, giving consumers a more structured, navigable view. Groups can also be nested — placing one view group inside another — so you can build a full folder-like hierarchy within a view. Read more in the documentation: View groups, Nesting.

This release also adds a number of smaller data modeling improvements: join_path support in folder includes, data model name uniqueness validation for cubes, views, members, and folders, an alias for named numeric formats, format description handling, and capitalization of ID acronyms in default meta titles.

New in data source support

Redshift IAM authentication. Now the Redshift driver supports IAM authentication. Read more in the documentation: Amazon Redshift.

Presto and Trino custom headers. Now the Presto and Trino drivers support forwarding custom HTTP headers (such as X-Presto-Source or X-Trino-Routing-Group) on every request. Read more in the documentation: Presto, Trino.

This release also adds: MS SQL named time zones with DST-aware conversion, Databricks export bucket support in read-only mode, a migration of the Postgres driver to Cube's own connection pool with improved error messages, a migration of the MySQL driver to the mysql2 library, contributed by Nathan Fallet, custom HTTP headers for the ClickHouse driver, Oracle driver improvements and fixes, QuestDB HAVING clause support, contributed by @puzpuzpuz, and BigQuery decimal precision and scale handling, contributed by @lvauvillier.

New in pre-aggregations

Multiple time dimensions in pre-aggregations. Now a single pre-aggregation can contain multiple time dimensions. Read more in the documentation: Pre-aggregations reference.

Per-subquery pre-aggregation matching. A query that decomposes into multiple subqueries — across multiple facts (multi-fact views) or multi-stage calculations — can now be served by a separate matching pre-aggregation per subquery, instead of requiring a single pre-aggregation to cover the entire query. Read more in the documentation: Matching queries with pre-aggregations.

Pre-aggregation-specific data source. Now you can point a data source's pre-aggregations at a dedicated connection, building and storing them separately from the source's own connection. Read more in the documentation: Pre-aggregation data source.

This release also exposes a pre-aggregation indicator (the external marker in the REST API response) so you can tell whether a query was served from a pre-aggregation, and adds support for use_original_sql_pre_aggregations in rollups when the Tesseract planner is used.

New in APIs and client libraries

A client-side Format API. Now @cubejs-client/core ships a Format API, imported from the @cubejs-client/core/format subpath, for formatting member values on the client consistently with how Cube formats them: formatValue, getFormat, and formatDateByGranularity, with locale and precision options. Read more in the documentation: @cubejs-client/core.

Window functions in the SQL API. Now the SQL API pushes down window functions — LAG and LEAD, as well as aggregate functions (such as SUM, AVG, COUNT) used with an OVER (...) clause. Read more in the documentation: SQL API reference.

Query format conversion API. A new /v1/convert-query endpoint converts queries between formats. Read more in the documentation: REST API reference.

The SQL API also gains: SET TIME ZONE support and parsing of additional time zone formats including IANA time zone names, FULL/RIGHT and grouped sub-query joins with SQL push down, ILIKE push down for BigQuery, LIMIT/ORDER BY push down through UNION inputs, boolean and numeric filter values, a cube_cache session variable, universally prefixed errors with improved parsing-error UX, and improved Talend compatibility.

The REST and GraphQL APIs also gain: relative date ranges inside and/or filter groups (for example, "last 2 weeks" in an inDateRange filter within an or), contributed by Elijah Evans, a columnar response format for /v1/load, dataSource in the /v1/sql response (contributed by @seshness), request ID propagation for the REST /cubesql endpoint, and GraphQL response extensions carrying annotation and lastRefreshTime.

The client libraries also gain: lastRefreshTime on the client SQL result types and a server-side cache mode option on the load method (contributed in part by @hannosgit).

New in query orchestrator

Distributed query cancellation. Now you can cancel a running query via the DELETE /v1/running-query/{requestId} endpoint, using the request ID from the x-request-id header. Cancellation propagates across the query queue and to the data source (for example, to Athena via StopQueryExecution). Read more in the documentation: REST API reference.

This release also adds exponential backoff in the refresh scheduler. Note that the native orchestrator is now always enabled and the default continueWaitTimeout has increased from 5 to 10 seconds — see the breaking changes above.

New in Cube Store

AWS Web Identity authentication for S3. Now Cube Store can authenticate to S3 using AWS Web Identity (for example, IRSA on Amazon EKS) instead of static access keys, via the CUBESTORE_AWS_WEB_IDENTITY_TOKEN_FILE and CUBESTORE_AWS_ROLE_ARN environment variables. Read more in the documentation: Environment variables.

This release also adds Cube Store tuning options — a stale-while-revalidate timeout for the SQL query cache (CUBESTORE_QUERY_CACHE_STALE_WHILE_REVALIDATE) and a configurable compaction readiness threshold (CUBESTORE_COMPACTION_READINESS_CHUNKS_THRESHOLD) — the EXPLAIN ANALYZE DETAILED command for per-query execution tracing, configurable top-k merge strategies via CUBESTORE_TOPK_STRATEGY, backward-compatible decimal handling, and queue external_id and exclusivity support.

New in configuration

Structured JSON logging in production. Now Cube emits logs as structured JSON in production — one JSON object per line, each including a level field — while development logs remain human-readable text. Read more in the documentation: Environment variables.

This release also adds initial support for Python 3.13 in the native runtime that powers Python and Jinja data models.

Performance optimizations

This release delivers a substantial performance overhaul centered on a new columnar data transport between JavaScript and Rust. Results are now moved in a columnar format and parsed with hand-written deserialization, dramatically reducing the cost of handling large result sets:

  • Columnar format in the SQL API transport — roughly 5x faster — and between the JS→Rust data transport.
  • Hand-written Deserialize for DBResponsePrimitive — about −95%, ~20x faster parsing.
  • ResultWrapper raw data transferred as a JSON buffer — about 10x faster.
  • Improved columnar transform (−77%, 4.4x), compact transform (−70%, 3x), and get_vanilla_row (−66.8%, 3x).
  • Snowflake driver: a UTC formatter replacing formatToTimeZone (~12x faster) and a single combined ALTER SESSION for session init.
  • Fast date and timestamp parsers for the Postgres driver.
  • Cube Store compaction: streaming k-way merge and early compaction split, and load-aware placement of CSV import jobs.
  • Cube Store partitioning and repartitioning: reduced metastore RPC fan-out, prefetching, per-partition merges, range jobs, and a worker-side group-by-limit hash-aggregate trim.
  • Schema compiler: granularityHierarchies optimized to avoid O(n²) object spread during data model compilation.

Version changes

  • The Docker image now runs Node.js 24 (24.18.0) on a Debian Trixie base. The minimum supported Node.js version is 22 (see the breaking changes above).

What's next?

With Tesseract now generally available, we're continuing to broaden its data source coverage and deepen its multi-stage and pre-aggregation support, and to push more of the query path into the native, columnar pipeline introduced in this release.

This release contains breaking changes. After checking the breaking changes above and their migration paths, please upgrade and give this release a try. As always, the changelog above reflects work contributed by members of the Cube community as well as the Cube team.

If you have questions or feedback, join our Slack community, open an issue on GitHub.

Enjoy the new features and happy Cube-ing!