Microsoft Fabric

Microsoft Fabric Runtime 2.0 vs 1.3 vs 1.2: What Changed and Should You Upgrade?

Compare Microsoft Fabric Runtime 2.0, 1.3, and 1.2 across Spark, Python, Java, Scala, Delta Lake, performance, lifecycle, compatibility, and migration risk.

By JaviPublished 15 min readIntermediate

Microsoft Fabric Runtime 2.0 is a much bigger change than its version number suggests.

Moving from Runtime 1.3 to 2.0 means moving from Apache Spark 3.5.5 to Spark 4.1, Python 3.11 to 3.13, Java 11 to 21, Scala 2.12.17 to 2.13.16, and Delta Lake 3.2 to 4.2. If you are still on Runtime 1.2, the jump is larger again.

That makes Runtime 2.0 more than a routine platform update.

It is a runtime migration.

The useful question is not simply:

Is Runtime 2.0 newer?

It is:

Does Runtime 2.0 give my workload enough performance, support, platform, and development value to justify testing the compatibility changes?

This guide compares Fabric Runtime 2.0, 1.3, and 1.2 from that production-engineering perspective.

The short version

For new production workloads, Microsoft currently recommends the latest generally available runtime, which is Runtime 2.0.

Runtime 1.2 is already unsupported. Microsoft states that it reached end of support on March 31, 2026 and no longer receives bug fixes, security updates, or vulnerability remediations.

Runtime 1.3 has entered its end-of-support transition. Microsoft lists September 30, 2026 as its end-of-support date, followed by a six-month Long Term Support period through March 2027.

Runtime 2.0 is GA and currently has an end-of-support date of August 31, 2028.

If you are still on 1.2, migration is now an operational requirement.

If you are on 1.3, the question is no longer whether 2.0 should be evaluated, but how quickly you can validate your workloads against it.

Version comparison at a glance

Component Runtime 1.2 Runtime 1.3 Runtime 2.0
Release status End of support EOSA / LTS transition GA
Apache Spark 3.4.1 3.5.5 4.1
Python 3.10 3.11 3.13
Java 11 11 21
Scala 2.12 2.12.17 2.13.16
Delta Lake 2.4 3.2 4.2
Operating system Mariner 2.0 Mariner 2.0 Azure Linux 3.0
Native Execution Engine No Yes Yes
Production recommendation Migrate Transition off Preferred GA runtime
Support horizon Ended Through LTS transition August 31, 2028
  1. Runtime 1.2Spark 3.4 / Python 3.10 / Delta 2.4
  2. Upgrade
    Runtime 1.3Spark 3.5 / Python 3.11 / Delta 3.2 / Native Execution Engine
  3. Migrate
    Runtime 2.0Spark 4.1 / Python 3.13 / Java 21 / Scala 2.13 / Delta 4.2
Fabric runtime generations

The upgrade decision is therefore not only about Spark.

It affects the complete runtime stack.

Runtime 1.2: the old baseline

Runtime 1.2 is based on Spark 3.4.1 and Delta Lake 2.4, with Python 3.10, Java 11, and Scala 2.12.

The documented Scala patch level is 2.12.17.

For workloads that were built during the earlier Fabric Data Engineering period, Runtime 1.2 may still feel familiar and stable.

But stability is no longer enough.

Microsoft states that Runtime 1.2 reached end of support on March 31, 2026. Unsupported runtimes do not continue receiving the normal stream of fixes, security updates, and vulnerability remediation.

Microsoft has also warned that phased disablement of Runtime 1.2 jobs follows the support end.

For production systems, that changes the risk calculation completely.

A workload that still executes today is not necessarily a workload you should continue designing around.

Runtime 1.3: a major step forward

Runtime 1.3 moved Fabric to Spark 3.5.5, Delta Lake 3.2, and Python 3.11 while keeping Java 11 and Scala 2.12.

It also became an important platform for Fabric’s Native Execution Engine.

For many organizations, Runtime 1.3 has been the practical production baseline through 2025 and much of 2026.

That makes it important to avoid treating Runtime 1.3 as “old technology.”

It is a capable runtime.

The reason to move is that its lifecycle is now closing while Runtime 2.0 establishes the next platform baseline.

Runtime 2.0: the generational jump

Runtime 2.0 moves multiple major ecosystem components at the same time:

  • Spark 4.1;
  • Python 3.13;
  • Java 21;
  • Scala 2.13;
  • Delta Lake 4.2;
  • Azure Linux 3.0.

That is why migration testing matters.

A notebook that contains only straightforward PySpark transformations may move with little work.

A production environment containing custom Python packages, Scala or Java libraries, binary dependencies, Delta protocol features, and third-party integrations deserves a deliberate validation cycle.

Apache Spark 4.1

Spark 4.1 is the biggest platform change in Runtime 2.0.

You should expect improvements in the Spark engine and SQL surface, but you should also treat the major-version move as a compatibility boundary.

Potential areas to validate include:

  • SQL behavior changes;
  • removed or changed Spark APIs;
  • configuration defaults;
  • legacy behavior that Spark 4.x no longer preserves;
  • third-party connectors compiled for older Spark versions;
  • custom Scala or Java libraries;
  • serialization behavior;
  • UDF behavior;
  • schema and timestamp handling.

Do not assume that a notebook compiling successfully means the workload is migration-safe.

Validate output correctness as well as execution success.

Python 3.13

Runtime 2.0 moves from Python 3.11 in Runtime 1.3 to Python 3.13.

For pure PySpark code, this may be straightforward.

The risk usually comes from package compatibility.

Review:

  • pinned packages;
  • binary wheels;
  • compiled Python extensions;
  • packages abandoned on older Python versions;
  • internal libraries;
  • libraries installed through Fabric environments;
  • code relying on behavior deprecated or removed between Python versions.

A reliable migration test should rebuild the environment rather than assume that a package set validated on Python 3.11 is automatically valid on Python 3.13.

Java 21

Java moves from version 11 to version 21.

This is a large jump for teams with:

  • custom JARs;
  • Java libraries;
  • Spark extensions;
  • JVM agents;
  • vendor connectors;
  • Java-based dependencies.

A library that is compatible with Java 11 may still work on Java 21, but that should be verified rather than assumed.

Check both build compatibility and runtime compatibility.

Scala 2.13

Runtime 1.3 uses Scala 2.12.17.

Runtime 2.0 uses Scala 2.13.16.

This matters because Scala binary compatibility is encoded directly into many Spark artifact names.

A dependency built for _2.12 should not simply be copied into a Scala 2.13 runtime.

For custom or third-party JARs:

  1. identify the Scala version they target;
  2. obtain or rebuild a Scala 2.13-compatible artifact;
  3. compile against the appropriate Spark 4.x dependency set;
  4. test behavior inside a Fabric environment.

This is one of the first checks I would perform for Scala-heavy production workloads.

Delta Lake 4.2

Runtime 2.0 moves to Delta Lake 4.2.

That introduces newer Delta capabilities, but also makes interoperability testing important.

Delta table features can change the Delta protocol.

Some protocol upgrades are not reversible, and older engines may not understand newer features.

This becomes especially important when the same OneLake Delta table is accessed from multiple workloads or runtimes.

Before enabling a new Delta feature, ask:

Does every engine that reads this table support the resulting protocol and table feature?

Do not use a runtime upgrade as an excuse to enable every new Delta feature immediately.

Runtime migration and Delta protocol migration should be treated as related but separate decisions.

Native Execution Engine

The Native Execution Engine is one of the strongest performance reasons to evaluate modern Fabric runtimes.

It is supported in Runtime 1.3 and Runtime 2.0.

Instead of executing all supported Spark operators through the traditional JVM path, the engine can offload supported operators into a vectorized native execution path based on technologies including Apache Gluten and Velox.

Microsoft reports representative benchmark gains of up to six times versus open-source Spark for supported TPC-DS workloads.

That does not mean every notebook becomes six times faster.

The benefit depends on:

  • operators used;
  • data format;
  • query shape;
  • whether an operator is supported;
  • whether execution falls back to the JVM;
  • whether the workload is CPU-bound rather than I/O-bound.

The important production lesson is:

Measure your own workload.

For suitable joins, aggregations, sorts, and transformations over Parquet or Delta, the Native Execution Engine can materially improve performance without requiring a rewrite.

It also changes where Spark starts to beat single-node Python engines; pandas vs Polars vs DuckDB vs PySpark in Microsoft Fabric compares them by data size, memory and Delta support.

Vectorized CSV parsing

Runtime 2.0 also includes a vectorized CSV parser in the native execution path.

That is particularly relevant to ingestion-heavy workloads that still receive large CSV feeds.

If your Fabric architecture has a substantial CSV landing layer, Runtime 2.0 is worth benchmarking against your existing runtime rather than assuming the ingestion cost will be unchanged.

Performance: what should actually be tested?

Do not benchmark Runtime 1.3 and Runtime 2.0 using only one notebook duration.

Capture at least:

  • total notebook duration;
  • Spark job duration;
  • stage duration;
  • shuffle read/write;
  • input size;
  • output size;
  • executor CPU behavior;
  • fallback from native execution;
  • failure/retry behavior;
  • capacity consumption where available.

Use representative production-sized inputs.

A runtime can finish faster while producing different capacity or concurrency behavior. Compare the job’s CU consumption in the Capacity Metrics app before and after the upgrade (reading capacity usage).

Performance testing should answer both:

Did it finish faster?

and:

Did it use the platform more efficiently?

Runtime lifecycle matters

Fabric runtimes have an explicit lifecycle.

Microsoft currently lists:

Runtime Lifecycle state End of support
Runtime 1.2 Unsupported March 31, 2026
Runtime 1.3 EOSA / LTS transition September 30, 2026, with LTS through March 2027
Runtime 2.0 GA August 31, 2028

Microsoft recommends using the latest GA runtime for production workloads.

That matters because runtime support is not just a feature question.

It determines whether you receive:

  • security fixes;
  • vulnerability remediation;
  • bug fixes;
  • platform support;
  • predictable compatibility guidance.

A note about workspace defaults

Runtime 2.0 is GA and is the recommended production runtime.

However, rollout of default runtime selection can be phased.

Microsoft documentation has described Runtime 2.0 becoming the default in the user experience and for new workspaces through a staged rollout.

That means you should verify the runtime explicitly rather than assume a workspace is already using 2.0.

The selected runtime can be controlled at the workspace or environment level.

How to check your Fabric runtime

In Fabric, check the environment or workspace Spark settings.

For workspace-level settings:

  1. open the workspace;
  2. open Workspace settings;
  3. go to Data Engineering/Science;
  4. open Spark settings;
  5. inspect the configured runtime.

For managed production workloads, environments are usually the better unit of control because they make runtime and library configuration explicit and repeatable.

If you are new to the workflow, start with the Fabric notebook tutorial and creating a Fabric Lakehouse. For a production rollout, put the runtime change through the same Fabric CI/CD process as other platform configuration.

Should you upgrade from Runtime 1.2?

Yes.

This is no longer just an optimization decision.

Runtime 1.2 is unsupported.

The migration path should focus on:

  • moving the runtime;
  • validating Python dependencies;
  • validating Delta tables;
  • checking Spark behavior changes;
  • retesting critical notebooks and jobs;
  • replacing packages that no longer support the newer stack.

Do not postpone this simply because a Runtime 1.2 notebook still starts today.

Should you upgrade from Runtime 1.3?

In most production environments, yes, you should be actively validating Runtime 2.0 now.

Runtime 1.3 remains useful during the transition period, but its lifecycle is closing.

The strongest reasons to move include:

  • longer support runway;
  • Spark 4.1;
  • Python 3.13;
  • Java 21;
  • Scala 2.13;
  • Delta Lake 4.2;
  • continued Native Execution Engine improvements;
  • newer Fabric platform capabilities;
  • avoiding a rushed migration later.

The strongest reason to delay production cutover is compatibility risk.

That is a valid reason to test longer.

It is not a reason to avoid testing.

Migration risks to check first

1. Python libraries

Rebuild and validate package installation under Python 3.13.

2. Scala and Java artifacts

Rebuild or replace Scala 2.12 artifacts and verify Java 21 compatibility.

3. Spark SQL behavior

Run regression tests against important transformations and business rules.

4. Delta table compatibility

Verify that table features and protocol versions remain readable by every required Fabric workload.

5. Custom connectors

Validate third-party JARs, JDBC drivers, APIs, and vendor libraries.

6. Performance behavior

Benchmark representative jobs rather than assuming the newer runtime is automatically faster for every workload.

7. Environments

Clone or create a Runtime 2.0 environment instead of mutating a production environment first.

A safe migration process

I would use this sequence for production Fabric workloads:

  1. inventory current Runtime 1.3 workloads;
  2. identify Python, Java, Scala, and custom dependencies;
  3. identify Delta features and cross-workload table consumers;
  4. create a separate Runtime 2.0 environment;
  5. install equivalent libraries;
  6. run unit and notebook tests;
  7. run representative production-scale inputs;
  8. compare performance and output;
  9. inspect Native Execution Engine usage and fallback;
  10. validate downstream tables and consumers;
  11. migrate development;
  12. migrate test;
  13. migrate production through your normal deployment process;
  14. keep rollback instructions until the production validation window closes.

Use notebook and pipeline monitoring to compare production behavior, and revisit the Medallion architecture guide before enabling Delta 4.x-specific features on shared Bronze, Silver, or Gold tables.

Upgrade decision matrix

Situation Recommendation
New Fabric Spark workload Start with Runtime 2.0
Runtime 1.2 workload Migrate urgently
Runtime 1.3 production workload Validate and plan move to 2.0
Heavy PySpark workload Benchmark 2.0 and package compatibility
Custom Scala JARs Rebuild/test for Scala 2.13 and Spark 4.x
Java integrations Validate on Java 21
Shared Delta tables Validate protocol compatibility before enabling new features
Large joins/aggregations/sorts Benchmark Native Execution Engine
CSV-heavy ingestion Benchmark vectorized CSV parsing
Vendor connector dependency Confirm vendor certification before production cutover

My recommendation

For a new Fabric Data Engineering workload today, I would start with Runtime 2.0.

For Runtime 1.2, I would treat migration as urgent because support has already ended.

For Runtime 1.3, I would not perform a blind production switch, but I would make Runtime 2.0 validation an active engineering task now.

The biggest mistake is to frame this as:

change 1.3 to 2.0 and see whether the notebook runs.

A better migration question is:

Can the workload produce the same correct result, with compatible dependencies and equal or better performance, on the runtime Fabric will support going forward?

That is the standard a production migration should meet.

Official references

Microsoft documentation used for this comparison:

Runtime versions, default rollout behavior, lifecycle dates, and feature status can change, so recheck the current Microsoft documentation during integration.

Tags

  • Microsoft Fabric
  • Delta Lake
  • Fabric Notebook
  • Python