Apache Polaris

An open-source Iceberg REST catalog: one server that every engine asks where a table’s current metadata is, with role-based access control and short-lived storage credentials per table.

What it is: Lakehouse catalogs,Table formats
Used for: Lakehouses
Type: Open source
Made by: Apache Software Foundation
License: Apache 2.0 (since the first public release in July 2024)
Facts checked: 6 October 2026

What it is

Polaris is a Java 21 server (built on Quarkus) that implements the Apache Iceberg REST catalog protocol on port 8181, plus its own management API. An engine such as Spark, Flink, Trino, Snowflake or PyIceberg asks it to create, load or commit a table; Polaris keeps the pointer to each table’s current metadata file and swaps it atomically on commit. The data and Iceberg metadata stay in your S3, Azure or Google Cloud Storage bucket. Polaris’s own state (catalogs, nested namespaces, tables, views, principals, roles, grants and policies) lives in a metastore: PostgreSQL through JDBC for production, MongoDB as an experimental option, or memory, the default, which loses everything on restart. Access works in layers: privileges such as TABLE_READ_DATA are granted to catalog roles, catalog roles to principal roles, and principal roles to principals (users or services that log in with OAuth client credentials). When a principal loads a table, Polaris can vend credentials: it calls AWS STS AssumeRole with a session policy scoped to that table’s location, or issues an Azure user delegation SAS or a downscoped Google token, so the engine never holds broad bucket keys. One server can host several isolated tenants, called realms, each with its own catalogs.

A catalog can also be external, mirroring tables another catalog owns as read-only, and federation can forward requests to another Iceberg REST catalog such as AWS Glue, or to Hive Metastore or BigQuery Metastore in a custom build. Generic tables register Delta Lake or CSV tables by location (in beta), and policies record compaction, snapshot expiry and orphan-file rules, but Polaris doesn’t run them: Spark, Trino or a tool such as Floe has to read and apply them. Snowflake built Polaris, open-sourced it in July 2024 and donated it to the Apache Software Foundation, where it graduated to a top-level project in February 2026. It is free to run yourself. Snowflake sells it as Snowflake Open Catalog, which no longer accepts new customers, and has built it into Snowflake Horizon Catalog; Dremio’s built-in catalog is also based on it.

Why teams pick it

Implements the Iceberg REST protocol, so one catalog serves Spark, Flink, Trino, Snowflake, Dremio, PyIceberg and any other REST client
Access control in one place for every engine, enforced by handing out short-lived storage credentials scoped to the tables a principal may read or write
Vendor-neutral governance: an Apache top-level project since February 2026, with developers from Snowflake, Dremio and others, under Apache 2.0
Several catalogs and isolated realms on one server, federation with Glue, Hive Metastore and BigQuery Metastore, and Open Policy Agent for external authorization

Watch out for

It doesn’t maintain tables: compaction, snapshot expiry and orphan-file cleanup still need Spark, Trino or another tool, even when a policy describes them
Defaults are for development: the in-memory metastore loses data on restart and random signing keys break multi-replica setups; production needs PostgreSQL, fixed keys and realm settings
Its permissions hold only if each table’s files sit in their own directory that mirrors the namespace tree, and only for engines that use the credentials it vends rather than their own bucket keys
Support beyond Iceberg is thin: generic tables for Delta Lake and CSV are in beta, the MongoDB metastore is experimental, and Hive and BigQuery federation need a custom build
Snowflake Open Catalog, the hosted version, is closed to new customers; Snowflake now points them to Horizon Catalog

Alternatives

What all lakehouse catalogs have in common →

Cloudflare Basin CatalogRenamedCommercialCloudflare’s managed Apache Iceberg REST catalog built into R2 buckets, called R2 Data Catalog until it became generally available as Basin Catalog on 1 October 2026, which also compacts tables and expires old snapshots for you.

LakekeeperOpen sourceAn open-source Apache Iceberg REST catalog written in Rust: a stateless server, backed by PostgreSQL, that tells every engine where each table’s current metadata is, checks permissions, and hands out short-lived storage credentials.

Project NessieOpen sourceAn open-source catalog for Apache Iceberg with Git-like branches, tags and commits that span every table at once, so a set of changes to many tables can be tested on a branch and then merged in one atomic step.

Unity CatalogCommercialDatabricks’ catalog and governance layer for tables, files, functions and models, with managed and external tables, an Iceberg REST endpoint and credential vending; a separate Apache 2.0 open-source server lives at LF AI & Data.

How it fits with other technologies

What Apache Polaris uses

What uses Apache Polaris

Create a catalog, give a read-only role to an analyst, and query it from Spark · bash

pip install apache-polaris                 # the Polaris CLI
export CLIENT_ID=root CLIENT_SECRET=s3cr3t  # admin credentials for the server on localhost:8181

polaris catalogs create --storage-type s3 \
  --default-base-location s3://acme-lake/warehouse \
  --role-arn arn:aws:iam::123456789012:role/polaris-lake-access \
  lake

# privilege -> catalog role -> principal role -> principal
polaris principals create analyst        # prints the analyst's clientId and clientSecret
polaris principal-roles create analysts
polaris principal-roles grant --principal analyst analysts
polaris catalog-roles create --catalog lake sales_reader
polaris catalog-roles grant --catalog lake --principal-role analysts sales_reader
polaris privileges namespace grant --namespace sales --catalog lake \
  --catalog-role sales_reader TABLE_READ_DATA

# the analyst connects with their own credentials; Polaris vends short-lived S3 keys
spark-sql \
  --packages org.apache.iceberg:iceberg-spark-runtime-3.5_2.12:1.10.0,org.apache.iceberg:iceberg-aws-bundle:1.10.0 \
  --conf spark.sql.catalog.polaris=org.apache.iceberg.spark.SparkCatalog \
  --conf spark.sql.catalog.polaris.catalog-impl=org.apache.iceberg.rest.RESTCatalog \
  --conf spark.sql.catalog.polaris.uri=http://localhost:8181/api/catalog \
  --conf spark.sql.catalog.polaris.warehouse=lake \
  --conf spark.sql.catalog.polaris.credential="$ANALYST_ID:$ANALYST_SECRET" \
  --conf spark.sql.catalog.polaris.scope=PRINCIPAL_ROLE:ALL \
  --conf spark.sql.catalog.polaris.header.X-Iceberg-Access-Delegation=vended-credentials \
  --conf spark.sql.catalog.polaris.client.region=eu-west-1 \
  -e "SELECT count(*) FROM polaris.sales.orders"

Ways to get a Polaris catalog#

The open-source server and the commercial catalogs built on it, checked 2026-10-06.

	Apache Polaris	Snowflake Open Catalog	Snowflake Horizon Catalog	Dremio Open Catalog
Who runs it	You: binary, Docker image or Helm chart	Snowflake, as a separate Open Catalog account	Snowflake, inside every Snowflake account	Dremio (now part of SAP), inside Dremio
What it is	The Apache project itself	A managed service for Apache Polaris	Snowflake’s catalog, with Polaris built in and an Iceberg REST endpoint	Dremio’s built-in lakehouse catalog, based on Polaris
Access control	Polaris roles and privileges, or an external policy engine such as OPA	Polaris roles, managed in a web UI	Existing Snowflake users, roles and policies	Dremio’s own
Availability	Open to all; 1.8.0 in September 2026	Existing customers only; new customers can’t sign up	All commercial Snowflake regions	Dremio Cloud and Enterprise
Price	Free; you pay for the servers and PostgreSQL	Billing added at general availability in October 2024, free until 30 April 2025	Part of Snowflake	Part of Dremio

Snowflake’s managed service was called Polaris Catalog during its preview from July 2024 and renamed Snowflake Open Catalog at general availability.

Other Iceberg REST catalogs#

Any of these can sit where Polaris sits: engines speak the same REST protocol to all of them.

AWS Glue Iceberg REST endpoint

AWS service

The Glue Data Catalog answers the Iceberg REST protocol at https://glue.<region>.amazonaws.com/iceberg, for Iceberg tables in S3 and S3 Tables. Nothing to run, but the endpoint is regional and serves one AWS account’s Data Catalog.

Lakekeeper

Apache 2.0, Rust

An Iceberg REST catalog written in Rust, with access control and credential vending; a commercial Lakekeeper+ edition comes from Vakamo.

Unity Catalog OSS

Apache 2.0, LF AI & Data

The open-source Unity Catalog, a sandbox project at the LF AI & Data Foundation. It registers Delta Lake tables, and Iceberg and Hudi through UniForm, answers the Iceberg REST and Hive metastore APIs, and also catalogs files, functions and AI models.

Project Nessie

Apache 2.0

A catalog with Git-like branches and multi-table commits, created by Dremio’s founders. Dremio said in 2024 it would bring Nessie’s features into Polaris.

See it in a real stack

No architecture uses Apache Polaris yet. Drop it into the playground and wire it up yourself.Open playground →

Where it came from2024–2026

By 2024 Iceberg had become the table format most engines could read and write, but each engine still had to agree on a catalog, the service that says which metadata file is a table’s current version. The Iceberg community had written an open REST protocol for catalogs, yet most implementations were tied to one vendor or covered only part of the protocol. Snowflake argued that these limits recreated the lock-in open table formats were meant to remove.

At its June 2024 Summit, Snowflake announced Polaris Catalog: a full implementation of the Iceberg REST protocol with its own role-based security, designed to run on Snowflake’s infrastructure or your own. It published the code under Apache 2.0 on 30 July 2024, opened a hosted preview the same day, and Dremio said it would fold the ideas of its Nessie catalog into the project. In August 2024 Polaris entered the Apache Incubator, with a core team drawn mostly from Snowflake and Dremio; the proposal admitted that diversifying beyond those two companies was its main risk.

The first Apache release, 0.9.0-incubating, came in February 2025 and 1.0 in July 2025. Polaris graduated to a top-level Apache project in February 2026, and by then both Snowflake’s and Dremio’s own catalogs were built on it.

Why it’s built this way

The whole Iceberg REST protocol, not a subset: The proposal set out to be a full, production-ready reference implementation: if something is in the spec, it should work in Polaris, so any REST-compatible engine can use it without vendor-specific gaps.
Security designed into the catalog: The REST protocol said little about authorization. Polaris added a role-based model and credential vending so access rules are enforced the same way whichever engine reads the table.
Multi-tenant from the start: Snowflake wanted to host it as a service, so one deployment serves many catalogs and users, with realms keeping tenants apart in the same database.
Donate it to the ASF: A catalog meant to be vendor-neutral needed governance no single company controls. Snowflake granted the code and donated its “POLARIS CATALOG” trademark application to the foundation.

Timeline

2024
Snowflake announces Polaris Catalog in June; open source and hosted preview on 30 July
2024
Enters the Apache Incubator in August; Snowflake Open Catalog GA in October
2025
First Apache release, 0.9.0-incubating, in February
2025
Polaris 1.0.0-incubating in July
2026
Graduates to a top-level Apache project in February

Sources30 · facts checked 6 October 2026

Improve this page on GitHub