# Apache Airflow 3.3.0 — Apache Airflow 3.3.0

- Product: Apache Airflow (https://whatsnew.fyi/product/apache-airflow)
- Vendor: Apache Software Foundation
- Date: 2026-07-06
- Version: 3.3.0
- Original notes: https://github.com/apache/airflow/releases/tag/3.3.0
- Permalink: https://whatsnew.fyi/product/apache-airflow/releases/3.3.0

What's New is an index, not a publisher: every entry below links to the vendor's own release notes, which are the authoritative source. Entries are labelled where they are hand-curated sample data, pre-releases, or drawn from a secondary source such as a developer blog.

Reuse: the summaries, labels and curation here are © What's New. Quote freely with attribution and a link back; wholesale republication of the corpus is not permitted — terms: https://whatsnew.fyi/terms. The vendors' own release notes remain their publishers'.

---

- **added** — Asset partitioning with new partition mappers RollupMapper, FanOutMapper, FixedKeyMapper, and SegmentWindow that compose with time windows and wait policies to control when partitioned runs fire
- **added** — PartitionedAtRuntime timetable that allows Dag to declare partition keys assigned at run start rather than mapped from upstream events
- **added** — Partition mapper max downstream keys configuration option [scheduler] partition_mapper_max_downstream_keys to bound total fan-out per upstream event
- **added** — First-class state store for tasks and assets via task_state_store and asset_state_store accessors that persist arbitrary key-value state across retries and runs
- **added** — State store support for per-key retention with periodic garbage collection and optional clear_on_success
- **added** — Pluggable retry policies that enable custom retry strategies such as retrying only on specific exceptions or backing off based on custom logic
- **added** — Coordinator layer and Language Task SDK for Java and Go that allows task implementations to be written in non-Python languages while Dag and scheduling stay in Python
- **added** — Task stub declaration with @task.stub(queue=...) for routing to language-specific coordinators
- **added** — rerun_with_latest_version setting to control whether cleared, rerun, or backfilled Dag runs use the latest bundle version or the original version
- **added** — Example Dags from provider distributions registered as dedicated bundles named apache-airflow-providers-<distribution>-example-dags
- **changed** — Remote task log handler resolution now owned by airflow_shared.logging.factory module with well-defined precedence over custom configs and ProvidersManager scheme dispatch
- **changed** — Remote logging resolution is now lazy on first use instead of eagerly resolved
- **deprecated** — airflow.logging_config.load_logging_config is deprecated in favor of new private helpers
- **deprecated** — Legacy fallback reading airflow_local_settings.py for remote logging configuration to be removed in Airflow 4.0

📦 PyPI: https://pypi.org/project/apache-airflow/3.3.0/
📚 Docs: https://airflow.apache.org/docs/apache-airflow/3.3.0/
🛠 Release Notes: https://airflow.apache.org/docs/apache-airflow/3.3.0/release_notes.html
🐳 Docker Image: "docker pull apache/airflow:3.3.0"
🚏 Constraints: https://github.com/apache/airflow/tree/constraints-3.3.0

##### Significant Changes

###### Asset Partitioning (#64571, #65447, #66030, #66848, #67184, #67475, #67716, #68978)


Building on the asset partitioning introduced in 3.2.0, Airflow 3.3.0 substantially expands how a
single upstream asset event fans out to partitioned downstream Dag runs. New partition mappers —
``RollupMapper`` (many-to-one), ``FanOutMapper`` (one-to-many), and ``FixedKeyMapper`` +
``SegmentWindow`` (categorical rollup) — compose with time windows (day/week/month/quarter/year) and a
``wait_policy`` (``WaitForAll`` or ``MinimumCount(n)``) to control when partitioned runs fire. Windows
can fan out forward or backward in time, and total fan-out per upstream event is bounded by the new
``[scheduler] partition_mapper_max_downstream_keys`` config (configurable per mapper). Airflow 3.3.0
also adds the ``PartitionedAtRuntime`` timetable, which lets a Dag declare that its partition key(s)
are assigned when the run starts rather than mapped from an upstream event.

For detailed usage instructions, see :doc:`/authoring-and-scheduling/assets`.

######  Task and Asset State Store (#65759, #66073, #66160, #66463, #66586, #66859, #67041, #67292, #67319)


Airflow 3.3.0 introduces a first-class state store for tasks and assets (AIP-103). Tasks can persist
arbitrary key-value state that survives across retries and runs via a new ``task_state_store`` accessor, and
assets can carry their own state via ``asset_state_store`` — both available from the Task SDK. State is kept
in the metadata database by default, or in a custom worker-side backend (``[workers]
state_store_backend``), supports per-key retention with periodic garbage collection and an optional
``clear_on_success``, and is fully manageable through the Core API and Execution API.

For detailed usage instructions, see :doc:`/core-concepts/task-and-asset-state-store`.

###### Pluggable Retry Policies (#65474)


Task retry behaviour is now pluggable (AIP-105). In addition to a fixed ``retries`` count, you can
attach a custom retry policy that decides whether and when a task is retried, enabling strategies such
as retrying only on specific exceptions or backing off based on custom logic.

For detailed usage instructions, see :ref:`concepts:retry-policies`.

######  Language Task SDK (Java and Go) (#65958, #67161, #67635, #67699)


Airflow 3.3.0 adds a Coordinator layer (AIP-108) that lets individual task implementations be written
in non-Python languages while the Dag and its scheduling stay in Python. A task is declared in the Dag
with ``@task.stub(queue=...)``; the worker routes it to a configured coordinator
(``JavaCoordinator`` for JVM languages, ``ExecutableCoordinator`` for self-contained native binaries
such as Go) that runs the task in a language runtime and proxies Variables, Connections, and XComs back
through the Execution API.

.. warning::

  The Coordinator layer and the Java/Go SDKs are experimental in 3.3.0 and may change in future
  versions based on user feedback.

For detailed usage instructions, see :doc:`/authoring-and-scheduling/language-sdks/index`.

######  Dag bundle version on clear, rerun, and backfill (#63884)


The new ``rerun_with_latest_version`` setting controls whether a cleared, rerun, or backfilled Dag run
uses the latest bundle version or the original version from the initial run. The default is resolved
by precedence: an explicit request parameter/CLI flag, then the Dag-level ``rerun_with_latest_version``,
then ``[core] rerun_with_latest_version``, and finally ``False`` for clear/rerun and ``True`` for
backfills (preserving historical behavi

_[Truncated at 4000 characters — full notes: https://github.com/apache/airflow/releases/tag/3.3.0]_