Apache Iceberg: Open Table Format for Huge Analytic Tables
GitHub Repo
Apache-2.0
November 21, 2026 at 01:54 PM
0 views

Apache Iceberg: Open Table Format for Huge Analytic Tables

@apacheProject Author

What Apache Iceberg is

Apache Iceberg is an open table format for large analytic datasets. The project README describes it as "a high-performance format for huge analytic tables" that "brings the reliability and simplicity of SQL tables to big data, while making it possible for engines like Spark, Trino, Flink, Presto, Hive and Impala to safely work with the same tables, at the same time." It is not a database server and not a query engine. It is a specification plus libraries that define how a table made of immutable data files (Parquet, Avro or ORC) on object storage or HDFS is described, versioned and committed, so that several engines can read and write the same table without corrupting it.

The problem it targets is spelled out in the reliability docs: Hive-style tables track partitions in a metastore and individual files by listing directories, which "makes atomic changes to a table's contents impossible", can return incorrect results on eventually consistent stores, and needs O(n) listing calls to plan a job. Iceberg instead tracks every data file explicitly in a tree of metadata files and commits a new table version with a single atomic pointer swap.

The audience is data platform teams running a lakehouse on S3, GCS, ADLS or HDFS, and anyone who wants a warehouse-style table (schema changes, deletes, time travel, concurrent writers) without locking data into one engine. The repository apache/iceberg holds the Java reference implementation and the Spark, Flink, Hive and Kafka Connect integrations. Python, Rust, Go and C++ implementations live in separate repositories. The latest Java release when this page was checked was 1.12.0; the hands-on section below uses PyIceberg 0.12.0, the Python implementation, because no JVM build tooling was reachable from the test machine.

How it works

A tree of immutable metadata

The table spec describes four layers. A table metadata file (JSON) holds the schema history, partition specs, sort orders, properties and the list of snapshots. Each snapshot points to a manifest list (Avro) that stores, for each manifest, partition value ranges and file counts. Each manifest (Avro) lists data files with their partition tuple and column-level statistics: value counts, null counts, and lower and upper bounds. The data itself sits in Parquet, ORC or Avro files that are never modified after they are written. Manifests are reused across snapshots, so an append only writes new manifests for new files.

The spec notes that version 4 (still under development and "not formally adopted") replaces the manifest list with a single root manifest per snapshot. Versions 1, 2 and 3 are complete: v1 covers analytic tables on immutable files, v2 adds row-level deletes through delete files, and v3 adds nanosecond timestamps, variant, geometry and geography types, default column values, row lineage, binary deletion vectors and table encryption keys.

Commits through a catalog

Every change writes a new metadata file and then swaps the table's current-metadata pointer atomically. Where that pointer lives is the catalog's job: a Hive metastore, AWS Glue, a JDBC database, Nessie, or any server that implements Iceberg's REST catalog protocol. The spec describes the metastore approach as a check-and-put: the swap succeeds only if the pointer still references the version the writer started from. The older file-system scheme based on atomic rename is marked deprecated in the spec, which calls it "unsafe in object stores and local file systems" and says it will be removed in version 4.

Concurrency is optimistic. A writer that loses the race re-reads the new state, checks whether its assumptions still hold, and retries. The spec lists the rules: appends can always be re-applied, replace operations such as compaction must verify that the files they rewrite are still present, and schema or partition changes must verify that the schema has not changed in the meantime. The result is serializable isolation with readers that never take locks.

Hidden partitioning and scan planning

A partition spec derives partition values from columns through transforms: identity, bucket[N] (32-bit Murmur3), truncate[W], year, month, day, hour and void. Queries filter on the source column (event_time), not on a separate partition column, and Iceberg converts the predicate. The partitioning docs use this example of a query that benefits from a day(event_time) spec:

SELECT level, message FROM logs
WHERE event_time BETWEEN '2018-12-01 10:00:00' AND '2018-12-01 12:00:00';

Planning first prunes manifests using the partition ranges in the manifest list, then prunes data files using partition tuples and column bounds in each manifest. The performance docs say this lets planning run on a single node, and the README-level docs claim tables of "tens of petabytes" are in production use. Those scale claims are the project's own; the test below is laptop-sized.

Key features

  • Schema evolution by field ID: add, drop, rename, widen and reorder columns, including nested fields, as metadata-only changes. Columns are tracked by unique IDs, so a re-added column never picks up old values. The evolution docs explain why formats that track by name or by position cannot guarantee this.
  • Partition evolution: change the partition spec in place. Old files keep their old layout, new files use the new spec, and planning is split per spec.
  • Hidden partitioning: partition values are produced by the table, not by the writer, which removes a class of silently wrong results the docs attribute to Hive-style tables.
  • Snapshots, time travel and rollback: every commit creates a snapshot that can be read later or restored.
  • Branches and tags: named references to snapshots with their own retention rules, which the docs suggest for audits, GDPR workflows and write-audit-publish pipelines.
  • Row-level deletes: position and equality delete files in v2, deletion vectors from v3; engines can also rewrite whole files (copy-on-write).
  • Serializable isolation with multiple writers via optimistic concurrency and per-operation retry validation.
  • Works on plain object storage: the spec only requires in-place writes, seekable reads and deletes, with no rename or consistent listing needed.
  • Maintenance actions in the Java library and Spark: expire snapshots, remove old metadata files, delete orphan files, compact data files, rewrite manifests and position deletes, and compute NDV and partition statistics into Puffin files.
  • Open specification: table, view, REST catalog, Puffin and expression specs, with an implementation-status matrix comparing the Java, Python, Rust, Go and C++ libraries.

Implementations and engine support

The Java core (iceberg-api, iceberg-core, iceberg-parquet, iceberg-orc, iceberg-arrow and others) is the reference implementation, and the README says processing engines should depend on iceberg-core. Engine connectors in this repository ship as runtime JARs. The multi-engine support page lists Spark 3.5, 4.0 and 4.1 as maintained, along with Flink 1.20, 2.2 and 2.3. Spark 3.4 and Flink 2.0 support was removed in 1.12.0. The page warns that only the runtime JAR (plus a storage bundle such as iceberg-aws-bundle) should be on the classpath, to avoid dependency conflicts.

The implementation-status page lists the released library versions as Java 1.12.0, PyIceberg 0.12.0, Rust 0.11.0, Go 0.7.0 and C++ 0.4.0. Feature coverage differs a lot between them. For example, PyIceberg is marked N for writing v3 metadata, writing position or equality deletes, rewriting files and rewriting manifests, and it only reads and writes Parquet.

Engines outside the repository maintain their own Iceberg connectors. The site's navigation lists, among many others, Trino, DuckDB, ClickHouse, Presto, Impala, Dremio, StarRocks, Apache Doris, Snowflake, BigQuery and Amazon Athena, as well as catalogs such as Apache Polaris, Apache Gravitino and Lakekeeper. For streaming ingestion, the repository includes an Iceberg sink connector for Kafka Connect. Its docs list centralised commit coordination, exactly-once delivery, multi-table fan-out and automatic table creation and schema evolution, so it pairs naturally with Apache Kafka.

Getting started

Spark quickstart (Docker)

The official quickstart uses a Docker Compose file built around the tabulario/spark-iceberg image, which bundles Spark with a configured catalog. After saving the compose file from the quickstart page:

docker-compose up
docker exec -it spark-iceberg spark-sql

A partitioned table is then plain SQL:

CREATE TABLE demo.nyc.taxis
(
  vendor_id bigint,
  trip_id bigint,
  trip_distance float,
  fare_amount double,
  store_and_fwd_flag string
)
PARTITIONED BY (vendor_id);

Python with PyIceberg (no JVM)

PyIceberg's docs install the package with optional extras for the catalog and FileIO in use:

pip install "pyiceberg[s3fs,hive]"

For local experiments, the getting-started page configures a SQL catalog backed by SQLite and a local warehouse directory:

from pyiceberg.catalog import load_catalog

warehouse_path = "/tmp/warehouse"
catalog = load_catalog(
    "default",
    **{
        'type': 'sql',
        "uri": f"sqlite:///{warehouse_path}/pyiceberg_catalog.db",
        "warehouse": f"file://{warehouse_path}",
    },
)

Writes take Arrow tables, and reads come back as Arrow:

table.append(df)
len(table.scan().to_arrow())

Partition evolution goes through update_spec:

with table.update_spec() as update:
    update.add_field("id", BucketTransform(16), "bucketed_id")
    update.add_field("event_ts", DayTransform(), "day_ts")

Building the Java project itself needs Gradle with Java 17 or 21, and the README notes that the tests require Docker. The Kafka Connect docs build the connector distribution with:

./gradlew -x test -x integrationTest clean build

Hands-on: Apache Iceberg with PyIceberg 0.12.0 on a Linux VM

Everything below was run on 21 November 2026 in a cloud VM: Ubuntu 24.04.5 LTS, 2 vCPUs, about 7.8 GiB RAM, no swap, no Docker, and no internet access except PyPI and raw.githubusercontent.com. Maven Central was unreachable, so the Java library, Spark and Flink could not be tested. The test used PyIceberg 0.12.0 from PyPI (the version the implementation-status page lists as current) on Python 3.13.18, with a SQLite-backed SQL catalog and a local filesystem warehouse. The data was synthetic: event rows with event_id, ts, user_id, kind and amount. Timings are single runs on one small machine and only show orders of magnitude.

Install

StepResult
pip install "pyiceberg[sql-sqlite,pyarrow,duckdb]==0.12.0" in a fresh venv10.6 s; pulled pyarrow 26.0.1, duckdb 2.0.1, SQLAlchemy 2.1.9, pydantic 2.14.4, pyroaring 1.2.0; venv 324 MB
First write to a day(ts)-partitioned tableFailed: NotInstalledError: pyiceberg_core needs to be installed. pip install "pyiceberg[pyiceberg-core]"
Adding the pyiceberg-core extrapyiceberg-core 0.10.1 (Rust-backed); venv grew to 430 MB
numpyNot pulled in by the extras above; installed separately (2.5.5) to generate test data
import + load_catalog0.5 to 0.7 s; catalog DB has two tables, iceberg_tables and iceberg_namespace_properties
Default table formatformat-version 2 (the source sets DEFAULT_FORMAT_VERSION = 2)

The first gotcha is easy to miss: the pyarrow extra is enough for unpartitioned tables, but time-based partition transforms on write need the separate pyiceberg-core package, and the getting-started page does not mention it.

Writes and the metadata tree

The table was created with a day(ts) partition spec. Each 1,000,000-row batch covered 10 days, so each append produced 10 Parquet files (default codec zstd).

OperationTimemetadata.jsonManifest listsManifestsData files
create_table0.12 to 0.14 s1000
Append 1M rows (10 days)0.89 s2 (2.8 KB)1 (1.8 KB)1 (7.6 KB)10 (14.9 MB)
Append 1M more rows (next 10 days)0.39 s3 (5.4 KB)2 (3.7 KB)2 (15.1 KB)20 (29.7 MB)
Full scan, 2M rows to Arrow0.13 s32220

Peak RSS for the whole script, including generating the data with numpy, was 633 MiB. The in-memory Arrow size of one batch was 40.1 MB, against 14.9 MB of Parquet on disk. Data files landed under Hive-style directories such as data/ts_day=2026-11-01/, with metadata files named 00002-<uuid>.metadata.json, snap-<id>-0-<uuid>.avro (manifest lists) and <uuid>-m0.avro (manifests). The SQLite catalog row stores the current and previous metadata locations, which is the pointer the atomic swap updates.

Scan planning and pruning

Measured with plan_files() on the 20-file, 2M-row table:

FilterFiles planned (of 20)PlanReadRows
none207 ms146 ms2,000,000
one day of ts16 ms14 ms100,313
one hour of ts15 ms12 ms4,191
event_id range of 100 (non-partition, clustered)15 ms13 ms100
user_id = 4242 (random)205 ms111 ms17
kind = 'refund'205 ms120 ms20,147
amount > 99.5205 ms111 ms9,843

The partition filter and the column bounds work as described: event_id is not a partition column, but because it rises with time, each file's lower and upper bounds narrowed the scan to one file. Randomly distributed columns get no pruning from min/max statistics, so sort order or clustering decides whether non-partition filters help.

Snapshots, time travel and schema evolution

  • Reading the first snapshot with scan(snapshot_id=...) returned 1,000,000 rows in 0.05 s while the current table held 2,000,000.
  • Adding a column and renaming amount to amount_eur took 0.009 to 0.015 s and rewrote zero data files. Old rows return null for the new column.
  • A scan of a pre-rename snapshot returned the old column name (amount) in its Arrow schema, but a row_filter on that snapshot only accepted the current name: amount_eur > 99.9 worked (1,828 rows), while amount > 99.9 raised ValueError: Could not find field with name amount.
  • Narrowing double to float was rejected: ValidationError: Cannot change column type: amount_eur: double -> float.
  • Dropping a column, then adding one with the same name, gave the new column field ID 7 instead of the old ID 6. This is the ID-based correctness guarantee from the docs: old values are not resurrected.
  • Gotcha: delete_column succeeded without allow_incompatible_changes=True, although the PyIceberg docs present that flag as required for deletes. A later append of an Arrow table that still carried the dropped column then failed with PyArrow table contains more columns: country. Update the schema first (hint, use union_by_name).

Partition evolution

Replacing day(ts) with hour(ts) took 0.01 s and rewrote nothing. A 200,000-row append for one new day then produced 24 files under ts_hour=2026-11-21-00 and so on, next to the 20 daily files from spec 0. Planning used the right spec on each side: a one-hour filter on the new day planned 1 spec-1 file, a one-hour filter on an old day planned 1 spec-0 file, and ts >= '2026-11-20' planned 25 files (24 hourly plus 1 daily).

Deletes and overwrites

OperationTimeWhat happened
Delete one full day (matches a whole file)0.026 sMetadata-only delete snapshot: 1 file removed, 99,714 rows, nothing rewritten
Delete kind = 'refund' (about 1% of rows, in every file)2.3 soverwrite snapshot: 19 files removed, 456 files added, 31.7 MB written, 19,105 rows deleted; no delete files
overwrite(df, overwrite_filter=...) on the new day0.057 sTwo snapshots: a delete (200,000 rows) and then an append (1,000 rows)
upsert on a table with an identifier fieldunder 0.1 sMatched the docs (1 updated, 1 inserted); the call added three snapshots (overwrite, append, append)

The 456 files are the notable result. PyIceberg 0.12.0 implements row-level deletes as copy-on-write (the status page marks position and equality delete writing as N). When it rewrote the 19 surviving daily files, it re-partitioned them under the current hourly spec, so each daily file became 24 hourly files. After a partition-spec change, the first broad delete can multiply the file count.

Small appends and metadata growth

Streaming-style writes were simulated with 500 appends of 100 rows each to an unpartitioned table, first with defaults and then with commit.manifest-merge.enabled=true:

After N appendsCommitPlanFull readManifests in snapshotmetadata.json files (total size)Data (files, size)
1 (default)52 ms3.7 ms5 ms12 (2.4 KB)1, 2.5 KB
100 (default)64 ms92 ms271 ms100101 (4.1 MB)100, 246 KB
500 (default)281 ms639 ms1,311 ms500501 (85.9 MB)500, 1.2 MB
500 (manifest merge on)338 ms22 ms695 ms5501 (86.1 MB)500, 1.2 MB

With defaults, 1.2 MB of data sat under 86 MB of metadata JSON plus 2.2 MB of manifests and 5.9 MB of manifest lists. The newest metadata file alone was 329 KB, because it lists every snapshot. PyIceberg uses fast append by default (the configuration docs say this differs from the Java library), so each commit adds one manifest and planning time grows linearly. Turning on manifest merging kept planning flat, but commit time still grew with the snapshot list. Setting write.metadata.delete-after-commit.enabled=true with previous-versions-max=10 capped the metadata JSON files at 11 (685 KB after 100 commits instead of 4.1 MB). PyIceberg 0.12.0 has no data-file compaction; the write docs say compaction "is planned".

Snapshot expiry and concurrent writers

  • table.maintenance.expire_snapshots().older_than(now) took 0.035 s on the events table (7 snapshots down to 1) and 0.115 s on the 500-snapshot table. The current metadata file shrank from 329 KB to 18.5 KB.
  • Expiry did not delete any files. All 501 Parquet files (only 457 still live), all manifest lists and all manifests stayed on disk. Planning on the 500-append table still took 519 ms, because the current snapshot still referenced 500 manifests. Reclaiming the space needs an orphan-file cleanup that PyIceberg 0.12.0 does not offer.
  • An append through a stale table handle logged Commit failed due to a concurrent update, retrying (1/4) in 107 ms and then succeeded (1.44 s in total).
  • Two overlapping deletes from separate handles: the second retried, then failed with ValidationException: Added data files were found matching the filter for snapshots set()!. That is a correct refusal, but the message is hard to act on.
  • Two schema changes from stale handles: the second failed immediately with CommitFailedException: Requirement failed: current schema id has changed: expected 3, found 4, with no retry.

Reading from DuckDB and the CLI

  • scan(row_filter=one day, selected_fields=...).to_duckdb(table_name=...) ran in 0.13 s and returned a DuckDB connection ready for SQL (99,221 rows). Materialising the whole 990,478-row table to Arrow and grouping it in DuckDB took 0.58 s.
  • DuckDB's native iceberg extension could not be tested: INSTALL iceberg failed with Failed to download extension "iceberg" at URL "http://extensions.duckdb.org/v2.0.1/linux_amd64/iceberg.duckdb_extension.gz", because that host is outside the VM's allowlist.
  • Reading the warehouse directly with read_parquet('.../data/**/*.parquet') counted 4,089,449 rows, against 990,478 live rows through Iceberg. Old, deleted and rewritten files stay on disk, so any reader that skips the metadata gets wrong answers.
  • The pyiceberg CLI worked against the SQL catalog via PYICEBERG_CATALOG__DEFAULT__* environment variables. list, schema, spec, describe and files each returned in under 1 s. pyiceberg version printed a deprecation warning ("will be removed in 0.13.0. Please use pyiceberg --version"), although the CLI docs still list version as a command.
  • Creating a table with format-version 3 failed: NotImplementedError: Writing V3 is not yet supported, consistent with the status page's footnote that SQL, Glue and Hive catalogs cannot persist V3 metadata with PyIceberg 0.12.0.

Not tested

The Java library 1.12.0, Spark, Flink, Hive, Kafka Connect and the Docker quickstart (no Maven Central, no Docker). Also not tested: object storage (S3, GCS, ADLS), REST catalogs, deletion vectors and other v3 features, Java maintenance actions such as rewriteDataFiles and deleteOrphanFiles, and any multi-node or large-scale behaviour.

Use cases

  • A shared lakehouse table layer: one copy of Parquet data on object storage, written by Spark or Flink jobs and queried from Trino, warehouses or notebooks, with a single catalog as the source of truth.
  • Replacing Hive tables that suffer from slow directory listing, partition-column mistakes or non-atomic overwrites. The migration docs describe in-place snapshot, migrate and add-files actions that reuse existing data files.
  • Streaming ingestion from Kafka through the Kafka Connect sink or Flink, provided compaction and snapshot expiry run on a schedule.
  • Reproducible analytics and ML features: pin a training set to a snapshot ID or tag, and roll back a bad load.
  • Python-only pipelines: PyIceberg plus Arrow, DuckDB or Polars for small to medium tables that still need atomic commits and schema evolution, without running a JVM.
  • Write-audit-publish using branches: write to a branch, validate, then fast-forward main. The PyIceberg API docs include a WAP example.

How it compares

Iceberg sits in the same category as Delta Lake and Apache Hudi, and more recently DuckLake. None of those were tested here, so the table sticks to structural differences that are either documented in Iceberg's own sources or widely known about the alternatives. Check each project's current docs before relying on a row.

AspectApache IcebergDelta LakeApache HudiDuckLake
Where table state livesJSON table metadata plus Avro manifest lists and manifests next to the data; a catalog holds the current pointerA transaction log of JSON commits with periodic checkpoints in the table directory (general description)A timeline of actions in the table's metadata directory (general description)Catalog and table metadata kept in a SQL database rather than in metadata files (general description)
SpecificationVersioned public spec (v1 to v3 adopted, v4 in development), plus a REST catalog specPublic protocol document maintained by the projectProject-maintained format docs (not reviewed here)Project-maintained docs (not reviewed here)
Engine reachJava reference plus Python, Rust, Go and C++ libraries; long third-party integration list in the docsBroad, with its strongest integration in the Spark ecosystemStrongest in Spark and Flink pipelinesBuilt around DuckDB
Migration path into Icebergn/aIceberg docs describe a snapshotDeltaLakeTable action in the iceberg-delta-lake module, built and tested against Delta Standalone 0.6.0No migration guide found in the Iceberg docs that were readNot covered in the Iceberg docs that were read
Licence and stewardshipApache-2.0, Apache Software FoundationApache-2.0 (verify for the components you use)Apache-2.0, Apache Software FoundationSee its page

On the engine side, Iceberg is complementary rather than competing: DuckDB, ClickHouse and Trino all appear in Iceberg's integration list as readers (and in some cases writers) of Iceberg tables. Storage can be any S3-compatible object store, and the status page marks S3-compatible FileIO as supported in all five libraries. A self-hosted store such as RustFS is therefore a plausible backend, though that pairing was not tested here.

Limits, trade-offs and when not to use it

  • Iceberg needs a catalog, an engine and storage. On its own it is a format and a set of libraries. Production use means running or buying a catalog (REST, Glue, Hive, JDBC, Nessie) and choosing engines. For a single-node analytics workload, a plain database or DuckDB file may be much simpler.
  • Maintenance is your job. The maintenance docs call snapshot expiry, old-metadata removal and orphan-file deletion recommended, and compaction optional. In the test, 500 small appends produced 86 MB of metadata JSON for 1.2 MB of data, and planning slowed 170-fold. Frequent small commits without compaction and expiry will degrade.
  • Feature parity varies by library. PyIceberg 0.12.0 cannot write v3 tables, cannot write delete files (deletes rewrite whole files), cannot compact or rewrite manifests, and does not remove files on snapshot expiry. Heavy maintenance still needs the Java library, usually through Spark or Flink.
  • Copy-on-write deletes can be expensive. Removing about 1% of rows rewrote 31.7 MB to delete 19,105 rows, and after a partition change it multiplied the file count 24-fold.
  • Orphan-file deletion is risky. The docs warn that running it with a retention interval shorter than the longest write can corrupt a table, and that path changes (for example, a new HDFS authority) "will lead to data loss".
  • Local SQLite catalogs are for development. PyIceberg's configuration docs label the SQLite catalog "Development only", and the getting-started page says not to use the local setup in production.
  • Bypassing metadata gives wrong results. Tools that glob Parquet files instead of reading the table metadata counted four times the live rows in the test.
  • Documentation drift observed: the PyIceberg docs on main say new snapshot summaries include engine-name and engine-version, but 0.12.0 summaries did not contain them, and the string does not appear in the installed package. The docs present allow_incompatible_changes as required for delete_column, but 0.12.0 accepted the delete without it. The CLI docs still list version, which 0.12.0 marks as deprecated. The getting-started page omits the pyiceberg-core requirement for partitioned writes. The Iceberg release notes give 29 September 2026 as the 1.12.0 release date, while GitHub's release metadata shows it published on 30 September 2026.

Security and governance

Iceberg follows the standard Apache security process: report vulnerabilities privately to [email protected] and do not disclose them publicly before the project responds. The project's security model says Iceberg runs inside larger systems and that "the primary trust and authorization boundaries are enforced by the surrounding catalog, engine, service, operator configuration, and storage-level authorization rather than by Iceberg alone". Robustness issues such as malformed-input crashes, and attacks that need a malicious catalog, are generally treated as bugs rather than vulnerabilities. Access control is therefore a catalog and storage decision: a REST catalog with credential vending, IAM policies on buckets, and so on. Releases are signed and can be checked through the ASF release-verification process. Development happens on GitHub issues and pull requests and on the [email protected] mailing list.

Project activity

Checked 21 November 2026: latest release apache-iceberg-1.12.0, published 30 September 2026 per GitHub (the release notes say 29 September), licence Apache-2.0. The previous releases were 1.11.0 (20 May 2026) and 1.10.2 (18 May 2026). 1.12.0 removed Spark 3.4 and Flink 2.0 support, added Flink 2.2 and 2.3, added v4 manifest reading and writing groundwork, geometry and geography support in Avro, Parquet and Spark 4.1, and a scan-based action to remove dangling delete files. It also switched the default AWS SDK HTTP client to Apache HttpClient 5.

The apache/iceberg repository had about 9,400 stars (9,446 at the time of writing) and 3,704 forks. It is written in Java, was created on 19 November 2018, develops on main (last pushed 21 November 2026) and is not archived. The Python implementation lives in apache/iceberg-python (about 1,170 stars, Apache-2.0) and is published to PyPI as pyiceberg. Version 0.12.0 was uploaded on 1 September 2026 and requires Python 3.10 or newer. Documentation, the table spec and the release notes are at iceberg.apache.org, and the PyIceberg docs are at py.iceberg.apache.org.

Enjoying this project?

Discover more amazing open-source projects on TechLogHub. We curate the best developer tools and projects.

Project
apache-iceberg
Created
November 21
Last Updated
November 21, 2026 at 01:54 PM

Maintain Apache Iceberg: Open Table Format for Huge Analytic Tables? Add the badge to your README

Show that the project is featured on TechLogHub and send readers to this write-up.

Featured on TechLogHub
[![Featured on TechLogHub](https://techloghub.com/badge-neutral.svg)](https://techloghub.com/open-source/apache-iceberg?utm_source=techloghub_badge&utm_medium=referral&utm_campaign=readme)

Find more projects like this

One email a week: new and trending developer tools, fresh comparisons, and what shipped. Unsubscribe in one click.