Delta Lake, Apache Iceberg and Apache Hudi are open table formats. Each adds a metadata layer over Parquet files in object storage so a pile of files behaves like a table, with transactions, schema changes and time travel. They overlap a lot. The choice usually comes down to your engines and catalog, how you handle updates and deletes, and how many tools read the same tables. Roughly: Iceberg is built around multi-engine access, Delta around Spark-centred pipelines, Hudi around frequent record-level upserts and incremental processing.
We make HyperLake, a sovereign AI operating platform. It isn't a table format, and the section near the end explains how it relates to this choice.

What is an open table format, and why does it exist?
A bucket of plain Parquet files has no idea what a transaction is. Two jobs writing at once can leave a half-finished result behind, and a reader can pick up files that are still being written. An open table format keeps a metadata record of exactly which files make up the table at each point in time, and commits a change by updating that record. For background, see Open Table Formats Explained for Data Lakes and Apache Parquet: How Columnar Storage Speeds Analytics.
All three formats here store data in open file formats and give you transactional tables. Where they differ is how each tracks state, who it was designed for, and what its documentation stresses.
How do Delta Lake, Iceberg and Hudi differ at a glance?
The table sums up what each project's own documentation emphasises. It's our summary, not a ranking.
| Delta Lake | Apache Iceberg | Apache Hudi | |
|---|---|---|---|
| Documented as | A lakehouse layer over existing data lakes | A table spec for large, slowly changing file collections | An open data lakehouse platform with an open table format |
| Table state kept in | Transaction log | Metadata files, snapshots and manifests | Timeline of actions |
| Stated emphasis | ACID, batch plus streaming, time travel, upserts | Consistent reads without locks, fast planning, evolution | Upserts, deletes, incremental processing, indexing |
| Concurrent writers | Optimistic, conflicts raise exceptions | Optimistic, atomic metadata swap | MVCC, optimistic, or non-blocking modes |
| Docs written around | Apache Spark first | Engine-neutral spec, many integrations | Spark, Flink, Presto, Trino, Hive and others |
Sources for each cell are in the sections below. Use the table as a starting point and check the current docs for the versions you'd actually run. All three projects release often.
What is Delta Lake and when does it fit?
According to the Delta Lake documentation, Delta Lake is an open source project that adds a lakehouse layer over existing data lakes on storage such as S3, ADLS, GCS and HDFS. Its listed features include ACID transactions with serializable isolation for Spark operations, scalable metadata handling, a single table that works as batch table, streaming source and streaming sink, schema enforcement, time travel, and merge, update and delete operations suited to change-data-capture and slowly changing dimensions. The same page says engines including Spark, Flink, Hive and Trino can read and write Delta tables.
Delta's batch read and write guide is written for Apache Spark, with examples in SQL, Python and Scala. It documents schema evolution through a mergeSchema write option and explicit ALTER TABLE changes, and time travel by version or timestamp. By default, table history is kept for 30 days (delta.logRetentionDuration) and deleted files must be 7 days old (delta.deletedFileRetentionDuration) before VACUUM can remove them. Time travel only reaches back as far as those settings allow. Here's a generic example (the docs also support TIMESTAMP AS OF):
-- Illustration only: read an older version of a Delta table
SELECT * FROM my_table VERSION AS OF 5;For concurrency, the Delta concurrency control page describes optimistic concurrency. A write validates against concurrent commits and fails with an exception instead of corrupting the table. Two inserts never conflict. Updates, deletes and merges can conflict with each other, with inserts and with compaction. If you partition by the columns your commands filter on, concurrent operations land on separate files.
Delta usually fits when your pipelines are already Spark-centred and you want the format your Spark tooling documents most directly. Check engine-specific support for the features you need before you commit, because the batch guide we read is written for Spark.
What is Apache Iceberg and when does it fit?
The Iceberg specification describes a table format for large, slowly changing collections of files. Its stated goals: consistent reads and writes without locks for readers, planning that needs a fixed number of remote calls instead of a number that grows with table size, client-side planning so no central store turns into a bottleneck, and schemas and partitioning that can evolve. The table tracks individual data files, not directories, so it never has to list directories to find data. Each snapshot is the table's state at a point in time. Every change writes a new metadata file that replaces the old one in a single atomic swap. For a walkthrough, see Apache Iceberg Snapshots Explained and Apache Iceberg: ACID Tables, Snapshots, and Time Travel.
Two design choices stand out in the project's docs:
- Evolution without rewrites. The evolution docs say you can add, drop, rename, reorder and widen columns, nested fields included, as metadata-only changes. Columns are tracked by unique ID, not name or position, so reusing a name can't bring deleted data back. Partitioning can change, say from monthly to daily, without rewriting old data, and with hidden partitioning your queries don't need to know the layout. See Iceberg Table Partitioning: Hidden Partitions Explained.
- Concurrency by atomic swap. The reliability docs describe optimistic concurrency: each writer prepares new metadata and tries to swap it in atomically, and if someone else committed first, it rebuilds on the latest state and re-checks its assumptions before trying again. The docs also say the design avoids relying on file listings or renames so it can work with any object store.
For row-level changes, the spec describes position deletes and equality deletes, introduced in format version 2, and deletion vectors, introduced in version 3.
On engines, the project's multi-engine support page lists official integrations for Spark, Flink, Hive and Kafka Connect. Its documentation navigation shows a longer list of third-party engines and cloud services, including Trino, Presto, DuckDB, Dremio, ClickHouse, Amazon Athena and Google BigQuery. As of October 2026, that breadth is relevant when several tools must share one set of tables. Support level and write capability vary by engine, so check the specific feature you need.
What is Apache Hudi and when does it fit?
The Hudi overview describes an open data lakehouse platform that started as a way to make data lake tables transactional and now includes an open table format built for fast writes on incremental pipelines. Listed features: upserts and deletes, incremental processing, indexing, Copy-on-Write and Merge-on-Read table types, a timeline, and compaction and clustering table services. Named query engines include Spark, Flink, Presto, Trino and Hive.
Three Hudi concepts shape the comparison:
- Table types. The table types page says Copy-on-Write rewrites base files when records change. That favours reads and suits batch ETL and reference data, but write latency is higher. Merge-on-Read writes changes to log files that get merged at query time or during compaction. Writes stay fast and data stays fresh for streaming and CDC, while snapshot reads are slower and depend on how recently compaction ran.
- Indexes. The indexing docs say Hudi treats indexing as core to its design. An index lets a writer find the affected records without scanning the whole table, by mapping each record key to a file group. Listed index types include bloom filters, a record index, expression and secondary indexes, and several writer-side options. Indexes cost extra storage.
- Timeline. The timeline docs describe a log of every action on the table (commits, delta commits, compaction, clustering, clean, rollback, savepoint and more), with each one moving through requested, inflight and completed states.
Hudi's concurrency control docs list three mechanisms. MVCC covers writers, table services and readers working at once. Optimistic concurrency control handles multiple writers and needs an external lock provider. Non-blocking concurrency control lets writers hit the same file group, but for now it applies only to Merge-on-Read tables using certain bucket indexes.
Hudi tends to fit when frequent record-level updates dominate the workload, CDC from operational databases being the classic case, and you want to tune write cost against read cost through table type and indexing.
How do the three formats handle updates, deletes and concurrent writers?
| Question | Delta Lake | Apache Iceberg | Apache Hudi |
|---|---|---|---|
| Row-level changes | Merge, update, delete | Position and equality deletes (v2), deletion vectors (v3) | Upserts and deletes via indexed file groups |
| Write cost tuning | Partition by filter columns | Hidden partitioning, partition evolution | Copy-on-Write vs Merge-on-Read, index choice |
| Conflict handling | Exception on conflicting commit | Rebuild on latest state and retry if assumptions hold | Depends on mode: MVCC, OCC or NBCC |
| Time travel | By version or timestamp | Past snapshots kept | Savepoints and timeline |
The real difference is where you pay. With Hudi, you decide up front, table by table, whether to pay at write time or at read time. Iceberg pushes the work into metadata and client-side planning. Delta leans on the Spark runtime and its log.
Can the formats interoperate? What about Delta UniForm?
Partly. The Delta UniForm documentation says UniForm lets Iceberg and Hudi clients read Delta tables without copying data, by generating the other format's metadata asynchronously after each Delta commit. From the Iceberg and Hudi side it's read-only, and the docs warn that an external writer could corrupt the Delta table. The same page lists requirements and limitations, including that Hudi support is in preview and that tables with deletion vectors aren't supported. We'd treat it as a bridge for readers. It's no reason to skip choosing a primary format.
How do I choose between Delta Lake, Iceberg and Hudi?
Our read, based on the project docs above and not on any benchmark:
| If your situation is... | Consider first | Why |
|---|---|---|
| Many engines or vendors must read and write the same tables | Iceberg | Long list of listed integrations, engine-neutral spec |
| Spark-centred pipelines, streaming and batch on one table | Delta Lake | Docs and examples centre on Spark |
| Heavy record-level upserts or CDC with tunable write/read cost | Hudi | Indexing, table types, incremental processing |
| Existing Delta tables, but a few Iceberg readers | Delta with UniForm | Read-only Iceberg metadata, subject to limits |
| You want to avoid lock-in to one vendor's catalog | Any, plus an open catalog | See Apache Polaris Open Metadata Catalogs Explained |
Here's where that guidance stops working. If your platform vendor supports only one format well, that constraint usually beats any format's design. Run a proof of concept on your real write pattern and engines before you standardise. For a head-to-head of the first two, see Apache Iceberg vs. Delta Lake: How to Choose.
Where does HyperLake fit?
HyperLake doesn't define or replace a table format. According to HyperLake's product description, the engines it works with follow the workload, and for lakehouse analytics it names Iceberg and Trino. Its data and intelligence example describes a governed data foundation of Iceberg and object storage with a fitting query engine. Delta Lake and Hudi aren't among the engines in our product description, so if you need either one, check with the team before assuming support. For the wider architecture, see What Does an Open-Source Data Lakehouse Stack Look Like?.
Frequently asked questions
Is Iceberg better than Delta Lake?
Not in general. Iceberg's spec and docs stress an engine-neutral table design, while Delta's centre on Spark-based pipelines. Choose by the engines and catalog you run, and test with your own workload.
What is the difference between Delta Lake and Hudi?
Both support upserts and deletes. Hudi gives you Copy-on-Write and Merge-on-Read table types plus a documented indexing system, so you can tune write cost against read cost. Delta uses a transaction log and is documented mainly around Spark.
Is Parquet a table format?
No, it's a columnar file format. Delta, Iceberg and Hudi are table formats that track which Parquet files make up a table and add transactions on top.
Can I use more than one table format?
You can. Some teams run different formats for different workloads, and Delta UniForm exposes Delta tables to Iceberg and Hudi readers read-only, within the limits described above.
Do open table formats prevent vendor lock-in?
They reduce it, because data stays in open files with documented metadata. The catalog and the engines still matter, though, so check who can write to your tables and where the catalog lives.
Which format supports time travel?
All three document it, each its own way: Delta by version or timestamp, Iceberg through retained snapshots, Hudi through its timeline and savepoints. Retention settings decide how far back you can go. See Time Travel in Data Systems.



