diff --git a/backend_py/primary/primary/routers/timeseries/converters.py b/backend_py/primary/primary/routers/timeseries/converters.py
index e449e6e8d..478fa5102 100644
--- a/backend_py/primary/primary/routers/timeseries/converters.py
+++ b/backend_py/primary/primary/routers/timeseries/converters.py
@@ -31,14 +31,7 @@ def to_api_vector_statistic_data(
     """
     Create API VectorStatisticData from service layer VectorStatistics
     """
-    value_objects: List[schemas.StatisticValueObject] = []
-    for api_func_enum in schemas.StatisticFunction:
-        service_func_enum = StatisticFunction.from_string_value(api_func_enum.value)
-        if service_func_enum is not None:
-            value_arr = vector_statistics.values_dict.get(service_func_enum)
-            if value_arr is not None:
-                value_objects.append(schemas.StatisticValueObject(statistic_function=api_func_enum, values=value_arr))
-
+    value_objects = _create_statistic_value_object_list(vector_statistics)
     ret_data = schemas.VectorStatisticData(
         realizations=vector_statistics.realizations,
         timestamps_utc_ms=vector_statistics.timestamps_utc_ms,
@@ -48,3 +41,36 @@ def to_api_vector_statistic_data(
     )
 
     return ret_data
+
+
+def to_api_delta_ensemble_vector_statistic_data(
+    vector_statistics: VectorStatistics, is_rate: bool, unit: str
+) -> schemas.VectorStatisticData:
+    """
+    Create API VectorStatisticData from service layer VectorStatistics
+    """
+    value_objects = _create_statistic_value_object_list(vector_statistics)
+    ret_data = schemas.VectorStatisticData(
+        realizations=vector_statistics.realizations,
+        timestamps_utc_ms=vector_statistics.timestamps_utc_ms,
+        value_objects=value_objects,
+        unit=unit,
+        is_rate=is_rate,
+    )
+
+    return ret_data
+
+
+def _create_statistic_value_object_list(vector_statistics: VectorStatistics) -> list[schemas.StatisticValueObject]:
+    """
+    Create list of statistic value objects from vector statistics object
+    """
+    value_objects: list[schemas.StatisticValueObject] = []
+    for api_func_enum in schemas.StatisticFunction:
+        service_func_enum = StatisticFunction.from_string_value(api_func_enum.value)
+        if service_func_enum is not None:
+            value_arr = vector_statistics.values_dict.get(service_func_enum)
+            if value_arr is not None:
+                value_objects.append(schemas.StatisticValueObject(statistic_function=api_func_enum, values=value_arr))
+
+    return value_objects
diff --git a/backend_py/primary/primary/routers/timeseries/router.py b/backend_py/primary/primary/routers/timeseries/router.py
index 9f0a88708..8b4cc7485 100644
--- a/backend_py/primary/primary/routers/timeseries/router.py
+++ b/backend_py/primary/primary/routers/timeseries/router.py
@@ -12,8 +12,10 @@
 from primary.services.sumo_access.parameter_access import ParameterAccess
 from primary.services.sumo_access.summary_access import Frequency, SummaryAccess
 from primary.services.utils.authenticated_user import AuthenticatedUser
+from primary.services.summary_delta_vectors import create_delta_vector_table, create_realization_delta_vector_list
 
 from . import converters, schemas
+import asyncio
 
 LOGGER = logging.getLogger(__name__)
 
@@ -48,6 +50,56 @@ async def get_vector_list(
     return ret_arr
 
 
+@router.get("/delta_ensemble_vector_list/")
+async def get_delta_ensemble_vector_list(
+    response: Response,
+    authenticated_user: Annotated[AuthenticatedUser, Depends(AuthHelper.get_authenticated_user)],
+    compare_case_uuid: Annotated[str, Query(description="Sumo case uuid for compare ensemble")],
+    compare_ensemble_name: Annotated[str, Query(description="Compare ensemble name")],
+    reference_case_uuid: Annotated[str, Query(description="Sumo case uuid for reference ensemble")],
+    reference_ensemble_name: Annotated[str, Query(description="Reference ensemble name")],
+) -> list[schemas.VectorDescription]:
+    """Get list of all vectors for a delta ensemble based on all vectors in a given Sumo ensemble, excluding any historical vectors
+
+    Definition:
+
+        delta_ensemble = compare_ensemble - reference_ensemble
+    """
+
+    perf_metrics = ResponsePerfMetrics(response)
+
+    compare_ensemble_access = SummaryAccess.from_case_uuid(
+        authenticated_user.get_sumo_access_token(), compare_case_uuid, compare_ensemble_name
+    )
+    reference_ensemble_access = SummaryAccess.from_case_uuid(
+        authenticated_user.get_sumo_access_token(), reference_case_uuid, reference_ensemble_name
+    )
+    perf_metrics.record_lap("get-access")
+
+    # Get vectors parallel
+    compare_vector_info_arr, reference_vector_info_arr = await asyncio.gather(
+        compare_ensemble_access.get_available_vectors_async(),
+        reference_ensemble_access.get_available_vectors_async(),
+    )
+    perf_metrics.record_lap("get-available-vectors")
+
+    # Create intersection of vector names
+    vector_names = {vi.name for vi in compare_vector_info_arr}
+    vector_names.intersection_update({vi.name for vi in reference_vector_info_arr})
+    perf_metrics.record_lap("create-vectors-names-intersection")
+
+    # Create vector descriptions, no historical vectors!
+    ret_arr: list[schemas.VectorDescription] = [
+        schemas.VectorDescription(name=vi, descriptive_name=vi, has_historical=False) for vi in vector_names
+    ]
+
+    perf_metrics.record_lap("convert-data-to-schema")
+
+    LOGGER.info(f"Got delta ensemble vector list in: {perf_metrics.to_string()}")
+
+    return ret_arr
+
+
 @router.get("/realizations_vector_data/")
 async def get_realizations_vector_data(
     # fmt:off
@@ -91,6 +143,98 @@ async def get_realizations_vector_data(
     return ret_arr
 
 
+@router.get("/delta_ensemble_realizations_vector_data/")
+async def get_delta_ensemble_realizations_vector_data(
+    # fmt:off
+    response: Response,
+    authenticated_user: Annotated[AuthenticatedUser, Depends(AuthHelper.get_authenticated_user)],
+    compare_case_uuid: Annotated[str, Query(description="Sumo case uuid for compare ensemble")],
+    compare_ensemble_name: Annotated[str, Query(description="Compare ensemble name")],
+    reference_case_uuid: Annotated[str, Query(description="Sumo case uuid for reference ensemble")],
+    reference_ensemble_name: Annotated[str, Query(description="Reference ensemble name")],
+    vector_name:  Annotated[str, Query(description="Name of the vector")],
+    resampling_frequency: Annotated[schemas.Frequency, Query(description="Resampling frequency")],
+    realizations: Annotated[list[int] | None, Query(description="Optional list of realizations to include. If not specified, all realizations will be returned.")] = None,
+    # relative_to_timestamp: Annotated[datetime.datetime | None, Query(description="Calculate relative to timestamp")] = None,
+    # fmt:on
+) -> list[schemas.VectorRealizationData]:
+    """Get vector data per realization
+
+    Definition:
+
+        delta_ensemble = compare_ensemble - reference_ensemble
+
+    """
+
+    perf_metrics = ResponsePerfMetrics(response)
+
+    service_freq = Frequency.from_string_value(resampling_frequency.value)
+    if service_freq is None:
+        raise HTTPException(
+            status_code=400, detail="Resampling frequency must be specified to create delta ensemble vector"
+        )
+
+    compare_ensemble_access = SummaryAccess.from_case_uuid(
+        authenticated_user.get_sumo_access_token(), compare_case_uuid, compare_ensemble_name
+    )
+    reference_ensemble_access = SummaryAccess.from_case_uuid(
+        authenticated_user.get_sumo_access_token(), reference_case_uuid, reference_ensemble_name
+    )
+
+    # Get tables parallel
+    # - Resampled data is assumed to be s.t. dates/timestamps are comparable between ensembles and cases, i.e. timestamps
+    #   for a resampling of a daily vector in both ensembles should be the same
+    (compare_vector_table_pa, compare_metadata), (reference_vector_table_pa, reference_metadata) = await asyncio.gather(
+        compare_ensemble_access.get_vector_table_async(
+            vector_name=vector_name,
+            resampling_frequency=service_freq,
+            realizations=realizations,
+        ),
+        reference_ensemble_access.get_vector_table_async(
+            vector_name=vector_name,
+            resampling_frequency=service_freq,
+            realizations=realizations,
+        ),
+    )
+
+    # Check for mismatching metadata
+    if compare_metadata.is_rate != reference_metadata.is_rate:
+        raise HTTPException(
+            status_code=400, detail="Rate mismatch between ensembles for delta ensemble statistical vector data"
+        )
+    if compare_metadata.unit != reference_metadata.unit:
+        raise HTTPException(
+            status_code=400, detail="Unit mismatch between ensembles for delta ensemble statistical vector data"
+        )
+
+    # Get metadata from reference ensemble
+    is_rate = reference_metadata.is_rate
+    unit = reference_metadata.unit
+
+    # Create delta ensemble data
+    delta_vector_table = create_delta_vector_table(compare_vector_table_pa, reference_vector_table_pa, vector_name)
+    perf_metrics.record_lap("create-delta-vector-table")
+
+    realization_delta_vector_list = create_realization_delta_vector_list(delta_vector_table, vector_name, is_rate, unit)
+    perf_metrics.record_lap("create-realization-delta-vector-list")
+
+    ret_arr: list[schemas.VectorRealizationData] = []
+    for vec in realization_delta_vector_list:
+        ret_arr.append(
+            schemas.VectorRealizationData(
+                realization=vec.realization,
+                timestamps_utc_ms=vec.timestamps_utc_ms,
+                values=vec.values,
+                unit=vec.unit,
+                is_rate=vec.is_rate,
+            )
+        )
+
+    LOGGER.info(f"Loaded realization delta ensemble summary data in: {perf_metrics.to_string()}")
+
+    return ret_arr
+
+
 @router.get("/timestamps_list/")
 async def get_timestamps_list(
     authenticated_user: Annotated[AuthenticatedUser, Depends(AuthHelper.get_authenticated_user)],
@@ -181,6 +325,93 @@ async def get_statistical_vector_data(
     return ret_data
 
 
+@router.get("/delta_ensemble_statistical_vector_data/")
+async def get_delta_ensemble_statistical_vector_data(
+    # fmt:off
+    response: Response,
+    authenticated_user: Annotated[AuthenticatedUser, Depends(AuthHelper.get_authenticated_user)],
+    compare_case_uuid: Annotated[str, Query(description="Sumo case uuid for compare ensemble")],
+    compare_ensemble_name: Annotated[str, Query(description="Compare ensemble name")],
+    reference_case_uuid: Annotated[str, Query(description="Sumo case uuid for reference ensemble")],
+    reference_ensemble_name: Annotated[str, Query(description="Reference ensemble name")],
+    vector_name: Annotated[str, Query(description="Name of the vector")],
+    resampling_frequency: Annotated[schemas.Frequency, Query(description="Resampling frequency")],
+    statistic_functions: Annotated[list[schemas.StatisticFunction] | None, Query(description="Optional list of statistics to calculate. If not specified, all statistics will be calculated.")] = None,
+    realizations: Annotated[list[int] | None, Query(description="Optional list of realizations to include. If not specified, all realizations will be included.")] = None,
+    # relative_to_timestamp: Annotated[datetime.datetime | None, Query(description="Calculate relative to timestamp")] = None,
+    # fmt:on
+) -> schemas.VectorStatisticData:
+    """Get statistical vector data for an ensemble
+
+    Definition:
+
+        delta_ensemble = compare_ensemble - reference_ensemble
+
+    """
+
+    perf_metrics = ResponsePerfMetrics(response)
+
+    service_freq = Frequency.from_string_value(resampling_frequency.value)
+    service_stat_funcs_to_compute = converters.to_service_statistic_functions(statistic_functions)
+
+    if service_freq is None:
+        raise HTTPException(
+            status_code=400, detail="Resampling frequency must be specified to create delta ensemble vector"
+        )
+
+    compare_ensemble_access = SummaryAccess.from_case_uuid(
+        authenticated_user.get_sumo_access_token(), compare_case_uuid, compare_ensemble_name
+    )
+    reference_ensemble_access = SummaryAccess.from_case_uuid(
+        authenticated_user.get_sumo_access_token(), reference_case_uuid, reference_ensemble_name
+    )
+
+    # Get tables parallel
+    # - Resampled data is assumed to be s.t. dates/timestamps are comparable between ensembles and cases, i.e. timestamps
+    #   for a resampling of a daily vector in both ensembles should be the same
+    (compare_vector_table_pa, compare_metadata), (reference_vector_table_pa, reference_metadata) = await asyncio.gather(
+        compare_ensemble_access.get_vector_table_async(
+            vector_name=vector_name,
+            resampling_frequency=service_freq,
+            realizations=realizations,
+        ),
+        reference_ensemble_access.get_vector_table_async(
+            vector_name=vector_name,
+            resampling_frequency=service_freq,
+            realizations=realizations,
+        ),
+    )
+
+    # Check for mismatching metadata
+    if compare_metadata.is_rate != reference_metadata.is_rate:
+        raise HTTPException(
+            status_code=400, detail="Rate mismatch between ensembles for delta ensemble statistical vector data"
+        )
+    if compare_metadata.unit != reference_metadata.unit:
+        raise HTTPException(
+            status_code=400, detail="Unit mismatch between ensembles for delta ensemble statistical vector data"
+        )
+
+    # Get metadata from reference ensemble
+    is_rate = reference_metadata.is_rate
+    unit = reference_metadata.unit
+
+    # Create delta ensemble data and compute statistics
+    delta_vector_table = create_delta_vector_table(compare_vector_table_pa, reference_vector_table_pa, vector_name)
+    statistics = compute_vector_statistics(delta_vector_table, vector_name, service_stat_funcs_to_compute)
+    if not statistics:
+        raise HTTPException(status_code=404, detail="Could not compute statistics")
+    perf_metrics.record_lap("calc-delta-vector-stat")
+
+    ret_data: schemas.VectorStatisticData = converters.to_api_delta_ensemble_vector_statistic_data(
+        statistics, is_rate, unit
+    )
+
+    LOGGER.info(f"Loaded and computed statistical delta ensemble summary data in: {perf_metrics.to_string()}")
+
+    return ret_data
+
+
 @router.get("/statistical_vector_data_per_sensitivity/")
 async def get_statistical_vector_data_per_sensitivity(
     # fmt:off
@@ -250,18 +481,3 @@ async def get_realization_vector_at_timestamp(
         vector_name=vector_name, timestamp_utc_ms=timestamp_utc_ms, realizations=None
     )
     return ensemble_response
-
-
-# @router.get("/realizations_calculated_vector_data/")
-# def get_realizations_calculated_vector_data(
-#     authenticated_user: Annotated[AuthenticatedUser, Depends(AuthHelper.get_authenticated_user)],
-#     case_uuid: Annotated[str, Query(description="Sumo case uuid")],
-#     ensemble_name: Annotated[str, Query(description="Ensemble name")],
-#     expression: Annotated[schemas.VectorExpressionInfo, Depends()],
-#     resampling_frequency: Annotated[schemas.Frequency, Query(description="Resampling frequency")],
-#     relative_to_timestamp: Annotated[datetime.datetime | None, Query(description="Calculate relative to timestamp")] = None,
-# ) -> str:
-#     """Get calculated vector data per realization"""
-#     print(expression)
-#     print(type(expression))
-#     return "hei"
diff --git a/backend_py/primary/primary/services/summary_delta_vectors.py b/backend_py/primary/primary/services/summary_delta_vectors.py
new file mode 100644
index 000000000..e480160d8
--- /dev/null
+++ b/backend_py/primary/primary/services/summary_delta_vectors.py
@@ -0,0 +1,115 @@
+from dataclasses import dataclass
+
+import pyarrow as pa
+import pyarrow.compute as pc
+import numpy as np
+
+from primary.services.service_exceptions import InvalidDataError, Service
+
+
+@dataclass
+class RealizationDeltaVector:
+    realization: int
+    timestamps_utc_ms: list[int]
+    values: list[float]
+    is_rate: bool
+    unit: str
+
+
+def _validate_summary_vector_table_pa(
+    vector_table: pa.Table, vector_name: str, service: Service = Service.GENERAL
+) -> None:
+    """
+    Check if the pyarrow vector table is valid.
+
+    Expect the pyarrow single vector table to contain the following columns: DATE, REAL, vector_name.
+
+    Raises InvalidDataError if the table does not contain the expected columns.
+    """
+    expected_columns = {"DATE", "REAL", vector_name}
+    actual_columns = set(vector_table.column_names)
+    if actual_columns != expected_columns:
+        unexpected_columns = actual_columns - expected_columns
+        raise InvalidDataError(f"Unexpected columns in table {unexpected_columns}", service)
+
+    # Validate table column types
+    if vector_table.field("DATE").type != pa.timestamp("ms"):
+        raise InvalidDataError(
+            f'DATE column must be of type timestamp(ms), but got {vector_table.field("DATE").type}', service
+        )
+    if vector_table.field("REAL").type != pa.int16():
+        raise InvalidDataError("REAL column must be of type int16", service)
+    if vector_table.field(vector_name).type != pa.float32():
+        raise InvalidDataError(f"{vector_name} column must be of type float32", service)
+
+
+def create_delta_vector_table(
+    compare_vector_table: pa.Table, reference_vector_table: pa.Table, vector_name: str
+) -> pa.Table:
+    """
+    Create a table with delta values of the requested vector name between the two input tables.
+
+    Definition:
+
+        delta_vector = compare_vector - reference_vector
+
+    Performs "inner join". Only obtain matching index ["DATE", "REAL"] - i.e "DATE"-"REAL" combination
+    present in only one vector is neglected.
+
+    Returns: A table with columns ["DATE", "REAL", vector_name] where vector_name contains the delta values.
+
+    `Note`: Pre-processing of DATE-columns, e.g. resampling, should be done before calling this function.
+    """
+    _validate_summary_vector_table_pa(compare_vector_table, vector_name)
+    _validate_summary_vector_table_pa(reference_vector_table, vector_name)
+
+    joined_vector_table = compare_vector_table.join(
+        reference_vector_table, keys=["DATE", "REAL"], join_type="inner", right_suffix="_reference"
+    )
+    delta_vector = pc.subtract(
+        joined_vector_table.column(vector_name), joined_vector_table.column(f"{vector_name}_reference")
+    )
+
+    delta_table = pa.table(
+        {
+            "DATE": joined_vector_table.column("DATE"),
+            "REAL": joined_vector_table.column("REAL"),
+            vector_name: delta_vector,
+        }
+    )
+
+    return delta_table
+
+
+def create_realization_delta_vector_list(
+    delta_vector_table: pa.Table, vector_name: str, is_rate: bool, unit: str
+) -> list[RealizationDeltaVector]:
+    """
+    Create a list of RealizationDeltaVector from the delta vector table.
+    """
+    _validate_summary_vector_table_pa(delta_vector_table, vector_name)
+
+    real_arr_np = delta_vector_table.column("REAL").to_numpy()
+    unique_reals, first_occurrence_idx, real_counts = np.unique(real_arr_np, return_index=True, return_counts=True)
+
+    whole_date_np_arr = delta_vector_table.column("DATE").to_numpy()
+    whole_value_np_arr = delta_vector_table.column(vector_name).to_numpy()
+
+    ret_arr: list[RealizationDeltaVector] = []
+    for i, real in enumerate(unique_reals):
+        start_row_idx = first_occurrence_idx[i]
+        row_count = real_counts[i]
+        date_np_arr = whole_date_np_arr[start_row_idx : start_row_idx + row_count]
+        value_np_arr = whole_value_np_arr[start_row_idx : start_row_idx + row_count]
+
+        ret_arr.append(
+            RealizationDeltaVector(
+                realization=real,
+                timestamps_utc_ms=date_np_arr.astype(int).tolist(),
+                values=value_np_arr.tolist(),
+                is_rate=is_rate,
+                unit=unit,
+            )
+        )
+
+    return ret_arr
diff --git a/backend_py/primary/primary/services/sumo_access/summary_access.py b/backend_py/primary/primary/services/sumo_access/summary_access.py
index e125ec7f6..bb4a7acc7 100644
--- a/backend_py/primary/primary/services/sumo_access/summary_access.py
+++ b/backend_py/primary/primary/services/sumo_access/summary_access.py
@@ -11,8 +11,11 @@
 from fmu.sumo.explorer.objects import TableCollection, Table
 from webviz_pkg.core_utils.perf_timer import PerfTimer
 
-from primary.services.utils.arrow_helpers import sort_table_on_real_then_date, is_date_column_monotonically_increasing
-from primary.services.utils.arrow_helpers import find_first_non_increasing_date_pair
+from primary.services.utils.arrow_helpers import (
+    find_first_non_increasing_date_pair,
+    sort_table_on_real_then_date,
+    is_date_column_monotonically_increasing,
+)
 from primary.services.service_exceptions import (
     Service,
     NoDataError,
diff --git a/backend_py/primary/tests/unit/services/test_summary_delta_vectors.py b/backend_py/primary/tests/unit/services/test_summary_delta_vectors.py
new file mode 100644
index 000000000..050f99922
--- /dev/null
+++ b/backend_py/primary/tests/unit/services/test_summary_delta_vectors.py
@@ -0,0 +1,192 @@
+import pytest
+import pyarrow as pa
+
+from primary.services.service_exceptions import InvalidDataError, Service
+from primary.services.summary_delta_vectors import (
+    create_delta_vector_table,
+    create_realization_delta_vector_list,
+    RealizationDeltaVector,
+    _validate_summary_vector_table_pa,
+)
+
+
+VECTOR_TABLE_SCHEMA = pa.schema([("DATE", pa.timestamp("ms")), ("REAL", pa.int16()), ("vector", pa.float32())])
+
+
+def test_create_delta_vector_table() -> None:
+    # Create sample data for compare_vector_table
+    compare_data = {"DATE": [1, 2, 3, 4], "REAL": [1, 1, 2, 2], "vector": [10.0, 20.0, 30.0, 40.0]}
+    compare_vector_table = pa.table(compare_data, schema=VECTOR_TABLE_SCHEMA)
+
+    # Create sample data for reference_vector_table
+    reference_data = {"DATE": [1, 2, 3, 4], "REAL": [1, 1, 2, 2], "vector": [5.0, 15.0, 25.0, 35.0]}
+    reference_vector_table = pa.table(reference_data, schema=VECTOR_TABLE_SCHEMA)
+
+    # Expected delta values
+    expected_delta_data = {"DATE": [1, 2, 3, 4], "REAL": [1, 1, 2, 2], "vector": [5.0, 5.0, 5.0, 5.0]}
+    expected_delta_table = pa.table(expected_delta_data, schema=VECTOR_TABLE_SCHEMA)
+
+    # Call the function
+    result_table = create_delta_vector_table(compare_vector_table, reference_vector_table, "vector")
+
+    # Validate the result
+    assert result_table.equals(expected_delta_table)
+
+
+def test_create_delta_vector_table_with_missing_dates() -> None:
+    # Create sample data for compare_vector_table
+    compare_data = {"DATE": [1, 2, 4], "REAL": [1, 1, 2], "vector": [10.0, 20.0, 40.0]}
+    compare_vector_table = pa.table(compare_data, schema=VECTOR_TABLE_SCHEMA)
+
+    # Create sample data for reference_vector_table
+    reference_data = {"DATE": [1, 2, 3], "REAL": [1, 1, 2], "vector": [5.0, 15.0, 25.0]}
+    reference_vector_table = pa.table(reference_data, schema=VECTOR_TABLE_SCHEMA)
+
+    # Expected delta values
+    expected_delta_data = {"DATE": [1, 2], "REAL": [1, 1], "vector": [5.0, 5.0]}
+    expected_delta_table = pa.table(expected_delta_data, schema=VECTOR_TABLE_SCHEMA)
+
+    # Call the function
+    result_table = create_delta_vector_table(compare_vector_table, reference_vector_table, "vector")
+
+    # Validate the result
+    assert result_table.equals(expected_delta_table)
+
+
+def test_create_delta_vector_table_with_different_reals() -> None:
+    # Create sample data for compare_vector_table
+    compare_data = {"DATE": [1, 2, 3, 4], "REAL": [1, 1, 2, 3], "vector": [10.0, 20.0, 30.0, 40.0]}
+    compare_vector_table = pa.table(compare_data, schema=VECTOR_TABLE_SCHEMA)
+
+    # Create sample data for reference_vector_table
+    reference_data = {"DATE": [1, 2, 3, 4], "REAL": [1, 1, 2, 2], "vector": [5.0, 15.0, 25.0, 35.0]}
+    reference_vector_table = pa.table(reference_data, schema=VECTOR_TABLE_SCHEMA)
+
+    # Expected delta values
+    expected_delta_data = {"DATE": [1, 2, 3], "REAL": [1, 1, 2], "vector": [5.0, 5.0, 5.0]}
+    expected_delta_table = pa.table(expected_delta_data, schema=VECTOR_TABLE_SCHEMA)
+
+    # Call the function
+    result_table = create_delta_vector_table(compare_vector_table, reference_vector_table, "vector")
+
+    # Validate the result
+    assert result_table.equals(expected_delta_table)
+
+
+def test_create_realization_delta_vector_list() -> None:
+    # Create sample data for delta_vector_table
+    delta_data = {"DATE": [1, 2, 3, 4], "REAL": [1, 1, 2, 2], "vector": [5.0, 10.0, 15.0, 20.0]}
+    delta_vector_table = pa.table(delta_data, schema=VECTOR_TABLE_SCHEMA)
+
+    # Expected result
+    expected_result = [
+        RealizationDeltaVector(realization=1, timestamps_utc_ms=[1, 2], values=[5.0, 10.0], is_rate=True, unit="unit"),
+        RealizationDeltaVector(realization=2, timestamps_utc_ms=[3, 4], values=[15.0, 20.0], is_rate=True, unit="unit"),
+    ]
+
+    # Call the function
+    result = create_realization_delta_vector_list(delta_vector_table, "vector", is_rate=True, unit="unit")
+
+    # Validate the result
+    assert result == expected_result
+
+
+def test_create_realization_delta_vector_list_with_single_real() -> None:
+    # Create sample data for delta_vector_table
+    delta_data = {"DATE": [1, 2, 3, 4], "REAL": [1, 1, 1, 1], "vector": [5.0, 10.0, 15.0, 20.0]}
+    delta_vector_table = pa.table(delta_data, schema=VECTOR_TABLE_SCHEMA)
+
+    # Expected result
+    expected_result = [
+        RealizationDeltaVector(
+            realization=1, timestamps_utc_ms=[1, 2, 3, 4], values=[5.0, 10.0, 15.0, 20.0], is_rate=False, unit="unit"
+        )
+    ]
+
+    # Call the function
+    result = create_realization_delta_vector_list(delta_vector_table, "vector", is_rate=False, unit="unit")
+
+    # Validate the result
+    assert result == expected_result
+
+
+def test_create_realization_delta_vector_list_with_empty_table() -> None:
+    # Create an empty delta_vector_table
+    delta_vector_table = pa.table({"DATE": [], "REAL": [], "vector": []}, schema=VECTOR_TABLE_SCHEMA)
+
+    # Expected result
+    expected_result: list[RealizationDeltaVector] = []
+
+    # Call the function
+    result = create_realization_delta_vector_list(delta_vector_table, "vector", is_rate=True, unit="unit")
+
+    # Validate the result
+    assert result == expected_result
+
+
+def test_validate_summary_vector_table_pa_valid() -> None:
+    vector_name = "VECTOR"
+    data = {"DATE": [1, 2, 3], "REAL": [4, 5, 6], vector_name: [7.0, 8.0, 9.0]}
+    schema = pa.schema([("DATE", pa.timestamp("ms")), ("REAL", pa.int16()), (vector_name, pa.float32())])
+    table = pa.Table.from_pydict(data, schema=schema)
+    try:
+        _validate_summary_vector_table_pa(table, vector_name)
+    except InvalidDataError:
+        pytest.fail("validate_summary_vector_table_pa raised InvalidDataError unexpectedly!")
+
+
+def test_validate_summary_vector_table_pa_missing_column() -> None:
+    vector_name = "VECTOR"
+    data = {"DATE": [1, 2, 3], "REAL": [4, 5, 6]}
+    schema = pa.schema([("DATE", pa.timestamp("ms")), ("REAL", pa.int16())])
+    table = pa.Table.from_pydict(data, schema=schema)
+    with pytest.raises(InvalidDataError):
+        _validate_summary_vector_table_pa(table, vector_name)
+
+
+def test_validate_summary_vector_table_pa_unexpected_column() -> None:
+    vector_name = "VECTOR"
+    data = {"DATE": [1, 2, 3], "REAL": [4, 5, 6], vector_name: [7.0, 8.0, 9.0], "EXTRA": [10.0, 11.0, 12.0]}
+    schema = pa.schema(
+        [("DATE", pa.timestamp("ms")), ("REAL", pa.int16()), (vector_name, pa.float32()), ("EXTRA", pa.float32())]
+    )
+    table = pa.Table.from_pydict(data, schema=schema)
+    with pytest.raises(InvalidDataError):
+        _validate_summary_vector_table_pa(table, vector_name)
+
+
+def test_validate_summary_vector_table_pa_invalid_date_type() -> None:
+    vector_name = "VECTOR"
+    data = {"DATE": [1, 2, 3], "REAL": [4, 5, 6], vector_name: [7.0, 8.0, 9.0]}
+    schema = pa.schema([("DATE", pa.int32()), ("REAL", pa.int16()), (vector_name, pa.float32())])
+    table = pa.Table.from_pydict(data, schema=schema)
+    with pytest.raises(InvalidDataError):
+        _validate_summary_vector_table_pa(table, vector_name)
+
+
+def test_validate_summary_vector_table_pa_invalid_real_type() -> None:
+    vector_name = "VECTOR"
+    data = {"DATE": [1, 2, 3], "REAL": [4.0, 5.0, 6.0], vector_name: [7.0, 8.0, 9.0]}
+    schema = pa.schema([("DATE", pa.timestamp("ms")), ("REAL", pa.float32()), (vector_name, pa.float32())])
+    table = pa.Table.from_pydict(data, schema=schema)
+    with pytest.raises(InvalidDataError):
+        _validate_summary_vector_table_pa(table, vector_name)
+
+
+def test_validate_summary_vector_table_pa_invalid_vector_type() -> None:
+    vector_name = "VECTOR"
+    data = {"DATE": [1, 2, 3], "REAL": [4, 5, 6], vector_name: [7, 8, 9]}
+    schema = pa.schema([("DATE", pa.timestamp("ms")), ("REAL", pa.int16()), (vector_name, pa.int32())])
+    table = pa.Table.from_pydict(data, schema=schema)
+    with pytest.raises(InvalidDataError):
+        _validate_summary_vector_table_pa(table, vector_name)
+
+
+def test_validate_summary_vector_table_pa_sumo_service() -> None:
+    vector_name = "VECTOR"
+    data = {"DATE": [1, 2, 3], "REAL": [4, 5, 6]}
+    schema = pa.schema([("DATE", pa.timestamp("ms")), ("REAL", pa.int16())])
+    table = pa.Table.from_pydict(data, schema=schema)
+    with pytest.raises(InvalidDataError) as excinfo:
+        _validate_summary_vector_table_pa(table, vector_name, Service.SUMO)
+    assert excinfo.value.service == Service.SUMO
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 1d03a1c5b..99930f0c7 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -85,11 +85,18 @@ function App() {
             setIsMounted(true);
 
             const storedEnsembleIdents = workbench.maybeLoadEnsembleSettingsFromLocalStorage();
-            if (storedEnsembleIdents) {
+            const storedDeltaEnsembles = workbench.maybeLoadDeltaEnsembleSettingsFromLocalStorage();
+            if (storedEnsembleIdents || storedDeltaEnsembles) {
                 setInitAppState(InitAppState.LoadingEnsembles);
-                workbench.loadAndSetupEnsembleSetInSession(queryClient, storedEnsembleIdents).finally(() => {
-                    initApp();
-                });
+                workbench
+                    .loadAndSetupEnsembleSetInSession(
+                        queryClient,
+                        storedEnsembleIdents ?? [],
+                        storedDeltaEnsembles ?? []
+                    )
+                    .finally(() => {
+                        initApp();
+                    });
             } else {
                 initApp();
             }
diff --git a/frontend/src/api/services/TimeseriesService.ts b/frontend/src/api/services/TimeseriesService.ts
index b872c2ed4..967dbc1d4 100644
--- a/frontend/src/api/services/TimeseriesService.ts
+++ b/frontend/src/api/services/TimeseriesService.ts
@@ -38,6 +38,40 @@ export class TimeseriesService {
             },
         });
     }
+    /**
+     * Get Delta Ensemble Vector List
+     * Get list of all vectors for a delta ensemble based on all vectors in a given Sumo ensemble, excluding any historical vectors
+     *
+     * Definition:
+     *
+     * delta_ensemble = compare_ensemble - reference_ensemble
+     * @param compareCaseUuid Sumo case uuid for compare ensemble
+     * @param compareEnsembleName Compare ensemble name
+     * @param referenceCaseUuid Sumo case uuid for reference ensemble
+     * @param referenceEnsembleName Reference ensemble name
+     * @returns VectorDescription Successful Response
+     * @throws ApiError
+     */
+    public getDeltaEnsembleVectorList(
+        compareCaseUuid: string,
+        compareEnsembleName: string,
+        referenceCaseUuid: string,
+        referenceEnsembleName: string,
+    ): CancelablePromise<Array<VectorDescription>> {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/timeseries/delta_ensemble_vector_list/',
+            query: {
+                'compare_case_uuid': compareCaseUuid,
+                'compare_ensemble_name': compareEnsembleName,
+                'reference_case_uuid': referenceCaseUuid,
+                'reference_ensemble_name': referenceEnsembleName,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
     /**
      * Get Realizations Vector Data
      * Get vector data per realization
@@ -71,6 +105,49 @@ export class TimeseriesService {
             },
         });
     }
+    /**
+     * Get Delta Ensemble Realizations Vector Data
+     * Get vector data per realization
+     *
+     * Definition:
+     *
+     * delta_ensemble = compare_ensemble - reference_ensemble
+     * @param compareCaseUuid Sumo case uuid for compare ensemble
+     * @param compareEnsembleName Compare ensemble name
+     * @param referenceCaseUuid Sumo case uuid for reference ensemble
+     * @param referenceEnsembleName Reference ensemble name
+     * @param vectorName Name of the vector
+     * @param resamplingFrequency Resampling frequency
+     * @param realizations Optional list of realizations to include. If not specified, all realizations will be returned.
+     * @returns VectorRealizationData Successful Response
+     * @throws ApiError
+     */
+    public getDeltaEnsembleRealizationsVectorData(
+        compareCaseUuid: string,
+        compareEnsembleName: string,
+        referenceCaseUuid: string,
+        referenceEnsembleName: string,
+        vectorName: string,
+        resamplingFrequency: Frequency,
+        realizations?: (Array<number> | null),
+    ): CancelablePromise<Array<VectorRealizationData>> {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/timeseries/delta_ensemble_realizations_vector_data/',
+            query: {
+                'compare_case_uuid': compareCaseUuid,
+                'compare_ensemble_name': compareEnsembleName,
+                'reference_case_uuid': referenceCaseUuid,
+                'reference_ensemble_name': referenceEnsembleName,
+                'vector_name': vectorName,
+                'resampling_frequency': resamplingFrequency,
+                'realizations': realizations,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
     /**
      * Get Timestamps List
      * Get the intersection of available timestamps.
@@ -168,6 +245,52 @@ export class TimeseriesService {
             },
         });
     }
+    /**
+     * Get Delta Ensemble Statistical Vector Data
+     * Get statistical vector data for an ensemble
+     *
+     * Definition:
+     *
+     * delta_ensemble = compare_ensemble - reference_ensemble
+     * @param compareCaseUuid Sumo case uuid for compare ensemble
+     * @param compareEnsembleName Compare ensemble name
+     * @param referenceCaseUuid Sumo case uuid for reference ensemble
+     * @param referenceEnsembleName Reference ensemble name
+     * @param vectorName Name of the vector
+     * @param resamplingFrequency Resampling frequency
+     * @param statisticFunctions Optional list of statistics to calculate. If not specified, all statistics will be calculated.
+     * @param realizations Optional list of realizations to include. If not specified, all realizations will be included.
+     * @returns VectorStatisticData Successful Response
+     * @throws ApiError
+     */
+    public getDeltaEnsembleStatisticalVectorData(
+        compareCaseUuid: string,
+        compareEnsembleName: string,
+        referenceCaseUuid: string,
+        referenceEnsembleName: string,
+        vectorName: string,
+        resamplingFrequency: Frequency,
+        statisticFunctions?: (Array<StatisticFunction> | null),
+        realizations?: (Array<number> | null),
+    ): CancelablePromise<VectorStatisticData> {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/timeseries/delta_ensemble_statistical_vector_data/',
+            query: {
+                'compare_case_uuid': compareCaseUuid,
+                'compare_ensemble_name': compareEnsembleName,
+                'reference_case_uuid': referenceCaseUuid,
+                'reference_ensemble_name': referenceEnsembleName,
+                'vector_name': vectorName,
+                'resampling_frequency': resamplingFrequency,
+                'statistic_functions': statisticFunctions,
+                'realizations': realizations,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
     /**
      * Get Statistical Vector Data Per Sensitivity
      * Get statistical vector data for an ensemble per sensitivity
diff --git a/frontend/src/framework/DeltaEnsemble.ts b/frontend/src/framework/DeltaEnsemble.ts
new file mode 100644
index 000000000..2b727d431
--- /dev/null
+++ b/frontend/src/framework/DeltaEnsemble.ts
@@ -0,0 +1,105 @@
+import { DeltaEnsembleIdent } from "./DeltaEnsembleIdent";
+import { EnsembleParameters } from "./EnsembleParameters";
+import { EnsembleSensitivities } from "./EnsembleSensitivities";
+import { RegularEnsemble } from "./RegularEnsemble";
+import { RegularEnsembleIdent } from "./RegularEnsembleIdent";
+
+/**
+ * Delta ensemble class.
+ *
+ * Delta ensemble is a user created ensemble defined as the difference between two ensembles.
+ *
+ * Definition:
+ *
+ *      DeltaEnsemble = CompareEnsemble - ReferenceEnsemble
+ *
+ */
+export class DeltaEnsemble {
+    private _deltaEnsembleIdent: DeltaEnsembleIdent;
+    private _compareEnsemble: RegularEnsemble;
+    private _referenceEnsemble: RegularEnsemble;
+    private _color: string;
+    private _customName: string | null;
+
+    private _realizationsArray: readonly number[];
+    private _parameters: EnsembleParameters;
+    private _sensitivities: EnsembleSensitivities | null;
+
+    constructor(
+        compareEnsemble: RegularEnsemble,
+        referenceEnsemble: RegularEnsemble,
+        color: string,
+        customName: string | null = null
+    ) {
+        this._deltaEnsembleIdent = new DeltaEnsembleIdent(compareEnsemble.getIdent(), referenceEnsemble.getIdent());
+
+        this._compareEnsemble = compareEnsemble;
+        this._referenceEnsemble = referenceEnsemble;
+        this._color = color;
+        this._customName = customName;
+
+        // Intersection of realizations
+        const realizationIntersection = this._compareEnsemble
+            .getRealizations()
+            .filter((realization) => this._referenceEnsemble.getRealizations().includes(realization));
+        this._realizationsArray = Array.from(realizationIntersection).sort((a, b) => a - b);
+
+        // For future implementation:
+        // - Decide how to handle parameters and sensitivities.
+        // - Note: Intersection or union? How to handle parameter values?
+        this._parameters = new EnsembleParameters([]);
+        this._sensitivities = null;
+    }
+
+    getIdent(): DeltaEnsembleIdent {
+        return this._deltaEnsembleIdent;
+    }
+
+    getDisplayName(): string {
+        if (this._customName) {
+            return this._customName;
+        }
+
+        return `(${this._compareEnsemble.getDisplayName()}) - (${this._referenceEnsemble.getDisplayName()})`;
+    }
+
+    getEnsembleName(): string {
+        return this._deltaEnsembleIdent.getEnsembleName();
+    }
+
+    getRealizations(): readonly number[] {
+        return this._realizationsArray;
+    }
+
+    getRealizationCount(): number {
+        return this._realizationsArray.length;
+    }
+
+    getMaxRealizationNumber(): number | undefined {
+        return this._realizationsArray[this._realizationsArray.length - 1];
+    }
+
+    getColor(): string {
+        return this._color;
+    }
+
+    getCustomName(): string | null {
+        return this._customName;
+    }
+
+    getParameters(): EnsembleParameters {
+        return this._parameters;
+    }
+
+    getSensitivities(): EnsembleSensitivities | null {
+        return this._sensitivities;
+    }
+
+    getCompareEnsembleIdent(): RegularEnsembleIdent {
+        return this._compareEnsemble.getIdent();
+    }
+
+    getReferenceEnsembleIdent(): RegularEnsembleIdent {
+        return this._referenceEnsemble.getIdent();
+    }
+}
diff --git a/frontend/src/framework/DeltaEnsembleIdent.ts b/frontend/src/framework/DeltaEnsembleIdent.ts
new file mode 100644
index 000000000..fe71cc7e5
--- /dev/null
+++ b/frontend/src/framework/DeltaEnsembleIdent.ts
@@ -0,0 +1,109 @@
+import { RegularEnsembleIdent } from "./RegularEnsembleIdent";
+import { ensembleIdentUuidRegexString, isEnsembleIdentOfType } from "./utils/ensembleIdentUtils";
+
+/**
+ * Delta ensemble ident class.
+ *
+ * DeltaEnsembleIdent is the ensemble ident for a delta ensemble.
+ *
+ * The class holds the ensemble idents of the two ensembles used to define the delta ensemble,
+ * i.e. compareEnsembleIdent and referenceEnsembleIdent, for easy usage in the framework.
+ *
+ * Definition:
+ *
+ *      DeltaEnsemble = CompareEnsemble - ReferenceEnsemble
+ *
+ */
+export class DeltaEnsembleIdent {
+    private _ensembleName: string;
+    private _compareEnsembleIdent: RegularEnsembleIdent;
+    private _referenceEnsembleIdent: RegularEnsembleIdent;
+
+    constructor(compareEnsembleIdent: RegularEnsembleIdent, referenceEnsembleIdent: RegularEnsembleIdent) {
+        this._ensembleName = `(${compareEnsembleIdent.getEnsembleName()}) - (${referenceEnsembleIdent.getEnsembleName()})`;
+        this._compareEnsembleIdent = compareEnsembleIdent;
+        this._referenceEnsembleIdent = referenceEnsembleIdent;
+    }
+
+    static compareEnsembleIdentAndReferenceEnsembleIdentToString(
+        compareEnsembleIdent: RegularEnsembleIdent,
+        referenceEnsembleIdent: RegularEnsembleIdent
+    ): string {
+        return `~@@~${compareEnsembleIdent.toString()}~@@~${referenceEnsembleIdent.toString()}~@@~`;
+    }
+
+    private static getEnsembleIdentRegex(): RegExp {
+        const compareEnsembleIdentRegexString = `(?<compareCaseUuid>${ensembleIdentUuidRegexString()})::(?<compareEnsembleName>.*)`;
+        const referenceEnsembleIdentRegexString = `(?<referenceCaseUuid>${ensembleIdentUuidRegexString()})::(?<referenceEnsembleName>.*)`;
+        return new RegExp(`^~@@~${compareEnsembleIdentRegexString}~@@~${referenceEnsembleIdentRegexString}~@@~$`);
+    }
+
+    static isValidEnsembleIdentString(ensembleIdentString: string): boolean {
+        const regex = DeltaEnsembleIdent.getEnsembleIdentRegex();
+        const result = regex.exec(ensembleIdentString);
+        return (
+            !!result &&
+            !!result.groups &&
+            !!result.groups.compareCaseUuid &&
+            !!result.groups.compareEnsembleName &&
+            !!result.groups.referenceCaseUuid &&
+            !!result.groups.referenceEnsembleName
+        );
+    }
+
+    static fromString(ensembleIdentString: string): DeltaEnsembleIdent {
+        const regex = DeltaEnsembleIdent.getEnsembleIdentRegex();
+        const result = regex.exec(ensembleIdentString);
+        if (
+            !result ||
+            !result.groups ||
+            !result.groups.compareCaseUuid ||
+            !result.groups.compareEnsembleName ||
+            !result.groups.referenceCaseUuid ||
+            !result.groups.referenceEnsembleName
+        ) {
+            throw new Error(`Invalid ensemble ident: ${ensembleIdentString}`);
+        }
+
+        const { compareCaseUuid, compareEnsembleName, referenceCaseUuid, referenceEnsembleName } = result.groups;
+
+        return new DeltaEnsembleIdent(
+            new RegularEnsembleIdent(compareCaseUuid, compareEnsembleName),
+            new RegularEnsembleIdent(referenceCaseUuid, referenceEnsembleName)
+        );
+    }
+
+    getEnsembleName(): string {
+        return this._ensembleName;
+    }
+
+    getCompareEnsembleIdent(): RegularEnsembleIdent {
+        return this._compareEnsembleIdent;
+    }
+
+    getReferenceEnsembleIdent(): RegularEnsembleIdent {
+        return this._referenceEnsembleIdent;
+    }
+
+    toString(): string {
+        return DeltaEnsembleIdent.compareEnsembleIdentAndReferenceEnsembleIdentToString(
+            this._compareEnsembleIdent,
+            this._referenceEnsembleIdent
+        );
+    }
+
+    equals(otherIdent: any | null): boolean {
+        if (!otherIdent || !isEnsembleIdentOfType(otherIdent, DeltaEnsembleIdent)) {
+            return false;
+        }
+        if (otherIdent === this) {
+            return true;
+        }
+
+        return (
+            this._ensembleName === otherIdent._ensembleName &&
+            this._compareEnsembleIdent.equals(otherIdent._compareEnsembleIdent) &&
+            this._referenceEnsembleIdent.equals(otherIdent._referenceEnsembleIdent)
+        );
+    }
+}
diff --git a/frontend/src/framework/EnsembleIdent.ts b/frontend/src/framework/EnsembleIdent.ts
deleted file mode 100644
index 28ec10983..000000000
--- a/frontend/src/framework/EnsembleIdent.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-export class EnsembleIdent {
-    private _caseUuid: string;
-    private _ensembleName: string;
-
-    constructor(caseUuid: string, ensembleName: string) {
-        this._caseUuid = caseUuid;
-        this._ensembleName = ensembleName;
-    }
-
-    static fromCaseUuidAndEnsembleName(caseUuid: string, ensembleName: string): EnsembleIdent {
-        return new EnsembleIdent(caseUuid, ensembleName);
-    }
-
-    static caseUuidAndEnsembleNameToString(caseUuid: string, ensembleName: string): string {
-        return `${caseUuid}::${ensembleName}`;
-    }
-
-    static fromString(ensembleIdentString: string): EnsembleIdent {
-        const regex =
-            /^(?<caseUuid>[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12})::(?<ensembleName>.*)$/;
-        const result = regex.exec(ensembleIdentString);
-        if (!result || !result.groups || !result.groups.caseUuid || !result.groups.ensembleName) {
-            throw new Error(`Invalid ensemble ident: ${ensembleIdentString}`);
-        }
-
-        const { caseUuid, ensembleName } = result.groups;
-
-        return new EnsembleIdent(caseUuid, ensembleName);
-    }
-
-    getCaseUuid(): string {
-        return this._caseUuid;
-    }
-
-    getEnsembleName(): string {
-        return this._ensembleName;
-    }
-
-    toString(): string {
-        return EnsembleIdent.caseUuidAndEnsembleNameToString(this._caseUuid, this._ensembleName);
-    }
-
-    equals(otherIdent: EnsembleIdent | null): boolean {
-        if (!otherIdent) {
-            return false;
-        }
-        if (otherIdent === this) {
-            return true;
-        }
-
-        return this._caseUuid === otherIdent._caseUuid && this._ensembleName === otherIdent._ensembleName;
-    }
-}
diff --git a/frontend/src/framework/EnsembleSet.ts b/frontend/src/framework/EnsembleSet.ts
index f1198869d..63e534ed9 100644
--- a/frontend/src/framework/EnsembleSet.ts
+++ b/frontend/src/framework/EnsembleSet.ts
@@ -1,44 +1,127 @@
-import { Ensemble } from "./Ensemble";
-import { EnsembleIdent } from "./EnsembleIdent";
+import { DeltaEnsemble } from "./DeltaEnsemble";
+import { DeltaEnsembleIdent } from "./DeltaEnsembleIdent";
+import { RegularEnsemble } from "./RegularEnsemble";
+import { RegularEnsembleIdent } from "./RegularEnsembleIdent";
+import { isEnsembleIdentOfType } from "./utils/ensembleIdentUtils";
 
 export class EnsembleSet {
-    private _ensembleArr: Ensemble[];
+    private _regularEnsembleArray: RegularEnsemble[];
+    private _deltaEnsembleArray: DeltaEnsemble[];
 
-    constructor(ensembles: Ensemble[]) {
-        this._ensembleArr = ensembles;
+    constructor(ensembles: RegularEnsemble[], deltaEnsembles: DeltaEnsemble[] = []) {
+        this._regularEnsembleArray = ensembles;
+        this._deltaEnsembleArray = deltaEnsembles;
     }
 
     /**
-     * Returns true if there is at least one ensemble in the set.
+     * Returns true if there are any regular ensembles in the set.
+     * @returns True if there are any regular ensembles in the set.
+     */
+    hasAnyRegularEnsembles(): boolean {
+        return this._regularEnsembleArray.length > 0;
+    }
+
+    /**
+     * Returns true if there are any delta ensembles in the set.
+     * @returns True if there are any delta ensembles in the set.
+     */
+    hasAnyDeltaEnsembles(): boolean {
+        return this._deltaEnsembleArray.length > 0;
+    }
+
+    /**
+     * Returns true if there are any regular or delta ensembles in the set.
+     * @returns True if there are any regular or delta ensembles in the set.
      */
     hasAnyEnsembles(): boolean {
-        return this._ensembleArr.length > 0;
+        return this.hasAnyRegularEnsembles() || this.hasAnyDeltaEnsembles();
     }
 
-    hasEnsemble(ensembleIdent: EnsembleIdent): boolean {
-        return this.findEnsemble(ensembleIdent) !== null;
+    /**
+     * Get an array of all regular ensembles in the set.
+     * @returns An array of all regular ensembles in the set.
+     */
+    getRegularEnsembleArray(): readonly RegularEnsemble[] {
+        return this._regularEnsembleArray;
     }
 
-    findEnsemble(ensembleIdent: EnsembleIdent): Ensemble | null {
-        return this._ensembleArr.find((ens) => ens.getIdent().equals(ensembleIdent)) ?? null;
+    /**
+     * Get an array of all delta ensembles in the set.
+     * @returns An array of all delta ensembles in the set.
+     */
+    getDeltaEnsembleArray(): readonly DeltaEnsemble[] {
+        return this._deltaEnsembleArray;
     }
 
-    findEnsembleByIdentString(ensembleIdentString: string): Ensemble | null {
-        try {
-            const ensembleIdent = EnsembleIdent.fromString(ensembleIdentString);
-            return this.findEnsemble(ensembleIdent);
-        } catch {
-            return null;
+    /**
+     * Get an array of all ensembles in the set.
+     * @returns An array of all ensembles in the set.
+     */
+    getEnsembleArray(): readonly (RegularEnsemble | DeltaEnsemble)[] {
+        return [...this._regularEnsembleArray, ...this._deltaEnsembleArray];
+    }
+
+    /**
+     * Returns true if the ensemble set has the given ensemble ident.
+     *
+     * @param ensembleIdent - The ensemble ident to check for, can be either a regular or delta ensemble ident.
+     * @returns True if the ensemble set has the given ensemble ident.
+     */
+    hasEnsemble(ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent): boolean {
+        return this.findEnsemble(ensembleIdent) !== null;
+    }
+
+    /**
+     * Get an ensemble in the set by its ensemble ident
+     *
+     * @param ensembleIdent - The ensemble ident to search for.
+     * @returns The ensemble if found. Throws an error if the ensemble is not found.
+     */
+    getEnsemble(ensembleIdent: RegularEnsembleIdent): RegularEnsemble;
+    getEnsemble(ensembleIdent: DeltaEnsembleIdent): DeltaEnsemble;
+    getEnsemble(ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent): RegularEnsemble | DeltaEnsemble;
+    getEnsemble(ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent): RegularEnsemble | DeltaEnsemble {
+        const ensemble = this.findEnsemble(ensembleIdent);
+        if (!ensemble) {
+            throw new Error(`Ensemble not found in EnsembleSet: ${ensembleIdent.toString()}`);
         }
+        return ensemble;
     }
 
-    getEnsembleArr(): readonly Ensemble[] {
-        return this._ensembleArr;
+    /**
+     * Find an ensemble in the set by its ensemble ident.
+     *
+     * @param ensembleIdent - The ensemble ident to search for.
+     * @returns The ensemble if found, otherwise null.
+     */
+    findEnsemble(ensembleIdent: RegularEnsembleIdent): RegularEnsemble | null;
+    findEnsemble(ensembleIdent: DeltaEnsembleIdent): DeltaEnsemble | null;
+    findEnsemble(ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent): RegularEnsemble | DeltaEnsemble | null;
+    findEnsemble(ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent): RegularEnsemble | DeltaEnsemble | null {
+        if (isEnsembleIdentOfType(ensembleIdent, RegularEnsembleIdent)) {
+            return this._regularEnsembleArray.find((ens) => ens.getIdent().equals(ensembleIdent)) ?? null;
+        }
+        if (isEnsembleIdentOfType(ensembleIdent, DeltaEnsembleIdent)) {
+            return this._deltaEnsembleArray.find((ens) => ens.getIdent().equals(ensembleIdent)) ?? null;
+        }
+        return null;
     }
 
-    // Temporary helper method
-    findCaseName(ensembleIdent: EnsembleIdent): string {
-        const foundEnsemble = this.findEnsemble(ensembleIdent);
-        return foundEnsemble?.getCaseName() ?? "";
+    /**
+     * Find an ensemble in the set by its ensemble ident string.
+     *
+     * @param ensembleIdentString - The ensemble ident string to search for.
+     * @returns The ensemble if found, otherwise null.
+     */
+    findEnsembleByIdentString(ensembleIdentString: string): RegularEnsemble | DeltaEnsemble | null {
+        if (RegularEnsembleIdent.isValidEnsembleIdentString(ensembleIdentString)) {
+            const ensembleIdent = RegularEnsembleIdent.fromString(ensembleIdentString);
+            return this.findEnsemble(ensembleIdent);
+        }
+        if (DeltaEnsembleIdent.isValidEnsembleIdentString(ensembleIdentString)) {
+            const deltaEnsembleIdent = DeltaEnsembleIdent.fromString(ensembleIdentString);
+            return this.findEnsemble(deltaEnsembleIdent);
+        }
+        return null;
     }
 }
diff --git a/frontend/src/framework/GlobalAtoms.ts b/frontend/src/framework/GlobalAtoms.ts
index 443e02abc..c0695ca14 100644
--- a/frontend/src/framework/GlobalAtoms.ts
+++ b/frontend/src/framework/GlobalAtoms.ts
@@ -3,8 +3,9 @@ import { EnsembleSet } from "@framework/EnsembleSet";
 import { atom } from "jotai";
 import { isEqual } from "lodash";
 
-import { EnsembleIdent } from "./EnsembleIdent";
+import { DeltaEnsembleIdent } from "./DeltaEnsembleIdent";
 import { RealizationFilterSet } from "./RealizationFilterSet";
+import { RegularEnsembleIdent } from "./RegularEnsembleIdent";
 import { EnsembleRealizationFilterFunction } from "./WorkbenchSession";
 import { atomWithCompare } from "./utils/atomUtils";
 
@@ -26,7 +27,7 @@ export const EnsembleRealizationFilterFunctionAtom = atom<EnsembleRealizationFil
         return null;
     }
 
-    return (ensembleIdent: EnsembleIdent) =>
+    return (ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent) =>
         realizationFilterSet.getRealizationFilterForEnsembleIdent(ensembleIdent).getFilteredRealizations();
 });
 
@@ -40,7 +41,7 @@ export const ValidEnsembleRealizationsFunctionAtom = atom((get) => {
     let validEnsembleRealizationsFunction = get(EnsembleRealizationFilterFunctionAtom);
 
     if (validEnsembleRealizationsFunction === null) {
-        validEnsembleRealizationsFunction = (ensembleIdent: EnsembleIdent) => {
+        validEnsembleRealizationsFunction = (ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent) => {
             return ensembleSet.findEnsemble(ensembleIdent)?.getRealizations() ?? [];
         };
     }
diff --git a/frontend/src/framework/RealizationFilter.ts b/frontend/src/framework/RealizationFilter.ts
index 63c29e9a3..cc66910bd 100644
--- a/frontend/src/framework/RealizationFilter.ts
+++ b/frontend/src/framework/RealizationFilter.ts
@@ -1,7 +1,7 @@
 import { isEqual } from "lodash";
 
-import { Ensemble } from "./Ensemble";
-import { EnsembleIdent } from "./EnsembleIdent";
+import { DeltaEnsemble } from "./DeltaEnsemble";
+import { DeltaEnsembleIdent } from "./DeltaEnsembleIdent";
 import {
     ContinuousParameter,
     DiscreteParameter,
@@ -10,6 +10,8 @@ import {
     ParameterIdent,
     ParameterType,
 } from "./EnsembleParameters";
+import { RegularEnsemble } from "./RegularEnsemble";
+import { RegularEnsembleIdent } from "./RegularEnsembleIdent";
 import {
     DiscreteParameterValueSelection,
     IncludeExcludeFilter,
@@ -28,16 +30,16 @@ import {
 /**
  * Class for filtering realizations based on realization number or parameter values.
  *
- * The class is designed to be used in conjunction with the Ensemble class.
+ * The class is designed to be used in conjunction with the RegularEnsemble or DeltaEnsemble class.
  *
  * The class is designed to keep track of the filtering state and provide the filtered realizations
  * for an ensemble.
  *
- * Should not provide interface to get the Ensemble object itself, but can provide access to information about the ensemble,
- * such as the ensemble ident and realization numbers.
+ * Should not provide interface to get the RegularEnsemble/DeltaEnsemble object itself, but can provide
+ * access to information about the ensemble - such as the ensemble ident and realization numbers.
  */
 export class RealizationFilter {
-    private _assignedEnsemble: Ensemble;
+    private _assignedEnsemble: RegularEnsemble | DeltaEnsemble;
     private _includeExcludeFilter: IncludeExcludeFilter;
     private _filterType: RealizationFilterType;
 
@@ -52,7 +54,7 @@ export class RealizationFilter {
     private _filteredRealizations: readonly number[];
 
     constructor(
-        assignedEnsemble: Ensemble,
+        assignedEnsemble: RegularEnsemble | DeltaEnsemble,
         initialIncludeExcludeFilter = IncludeExcludeFilter.INCLUDE_FILTER,
         initialFilterType = RealizationFilterType.BY_REALIZATION_NUMBER
     ) {
@@ -65,7 +67,7 @@ export class RealizationFilter {
         this._parameterIdentStringToValueSelectionMap = null;
     }
 
-    getAssignedEnsembleIdent(): EnsembleIdent {
+    getAssignedEnsembleIdent(): RegularEnsembleIdent | DeltaEnsembleIdent {
         return this._assignedEnsemble.getIdent();
     }
 
diff --git a/frontend/src/framework/RealizationFilterSet.ts b/frontend/src/framework/RealizationFilterSet.ts
index bd1f29fb6..e8adb2539 100644
--- a/frontend/src/framework/RealizationFilterSet.ts
+++ b/frontend/src/framework/RealizationFilterSet.ts
@@ -1,8 +1,7 @@
-import { isEqual } from "lodash";
-
-import { EnsembleIdent } from "./EnsembleIdent";
+import { DeltaEnsembleIdent } from "./DeltaEnsembleIdent";
 import { EnsembleSet } from "./EnsembleSet";
 import { RealizationFilter } from "./RealizationFilter";
+import { RegularEnsembleIdent } from "./RegularEnsembleIdent";
 
 export class RealizationFilterSet {
     // Map of ensembleIdent string to RealizationFilter
@@ -17,14 +16,23 @@ export class RealizationFilterSet {
     synchronizeWithEnsembleSet(ensembleSet: EnsembleSet): void {
         // Remove filters for ensembles that are no longer in the ensemble set
         for (const ensembleIdentString of this._ensembleIdentStringRealizationFilterMap.keys()) {
-            const ensembleIdent = EnsembleIdent.fromString(ensembleIdentString);
+            let ensembleIdent = null;
+            if (RegularEnsembleIdent.isValidEnsembleIdentString(ensembleIdentString)) {
+                ensembleIdent = RegularEnsembleIdent.fromString(ensembleIdentString);
+            } else if (DeltaEnsembleIdent.isValidEnsembleIdentString(ensembleIdentString)) {
+                ensembleIdent = DeltaEnsembleIdent.fromString(ensembleIdentString);
+            }
+            if (!ensembleIdent) {
+                throw new Error(`Invalid ensemble ident string: ${ensembleIdentString}`);
+            }
+
             if (!ensembleSet.hasEnsemble(ensembleIdent)) {
                 this._ensembleIdentStringRealizationFilterMap.delete(ensembleIdentString);
             }
         }
 
         // Add filters for ensembles that are new to the ensemble set
-        for (const ensemble of ensembleSet.getEnsembleArr()) {
+        for (const ensemble of ensembleSet.getEnsembleArray()) {
             const ensembleIdentString = ensemble.getIdent().toString();
             const isEnsembleInMap = this._ensembleIdentStringRealizationFilterMap.has(ensembleIdentString);
             if (!isEnsembleInMap) {
@@ -36,7 +44,7 @@ export class RealizationFilterSet {
     /**
      * Get filter for ensembleIdent
      */
-    getRealizationFilterForEnsembleIdent(ensembleIdent: EnsembleIdent): RealizationFilter {
+    getRealizationFilterForEnsembleIdent(ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent): RealizationFilter {
         const filter = this._ensembleIdentStringRealizationFilterMap.get(ensembleIdent.toString());
         if (filter === undefined) {
             throw new Error(
@@ -46,21 +54,4 @@ export class RealizationFilterSet {
 
         return filter;
     }
-
-    isEqual(other: RealizationFilterSet): boolean {
-        if (
-            this._ensembleIdentStringRealizationFilterMap.size !== other._ensembleIdentStringRealizationFilterMap.size
-        ) {
-            return false;
-        }
-
-        for (const [ensembleIdentString, realizationFilter] of this._ensembleIdentStringRealizationFilterMap) {
-            const otherRealizationFilter = other._ensembleIdentStringRealizationFilterMap.get(ensembleIdentString);
-            if (!otherRealizationFilter || isEqual(realizationFilter, otherRealizationFilter)) {
-                return false;
-            }
-        }
-
-        return true;
-    }
 }
diff --git a/frontend/src/framework/Ensemble.ts b/frontend/src/framework/RegularEnsemble.ts
similarity index 64%
rename from frontend/src/framework/Ensemble.ts
rename to frontend/src/framework/RegularEnsemble.ts
index cd028fd1c..add818619 100644
--- a/frontend/src/framework/Ensemble.ts
+++ b/frontend/src/framework/RegularEnsemble.ts
@@ -1,13 +1,13 @@
-import { EnsembleIdent } from "./EnsembleIdent";
 import { EnsembleParameters, Parameter } from "./EnsembleParameters";
 import { EnsembleSensitivities, Sensitivity } from "./EnsembleSensitivities";
+import { RegularEnsembleIdent } from "./RegularEnsembleIdent";
 
-export class Ensemble {
-    private _ensembleIdent: EnsembleIdent;
+export class RegularEnsemble {
+    private _ensembleIdent: RegularEnsembleIdent;
     private _fieldIdentifier: string;
     private _caseName: string;
-    private _stratigraphic_column_identifier: string;
-    private _realizationsArr: number[];
+    private _stratigraphicColumnIdentifier: string;
+    private _realizationsArray: number[];
     private _parameters: EnsembleParameters;
     private _sensitivities: EnsembleSensitivities | null;
     private _color: string;
@@ -18,29 +18,29 @@ export class Ensemble {
         caseUuid: string,
         caseName: string,
         ensembleName: string,
-        stratigraphic_column_identifier: string,
-        realizationsArr: number[],
-        parameterArr: Parameter[],
-        sensitivityArr: Sensitivity[] | null,
+        stratigraphicColumnIdentifier: string,
+        realizationsArray: number[],
+        parameterArray: Parameter[],
+        sensitivityArray: Sensitivity[] | null,
         color: string,
         customName: string | null = null
     ) {
-        this._ensembleIdent = new EnsembleIdent(caseUuid, ensembleName);
+        this._ensembleIdent = new RegularEnsembleIdent(caseUuid, ensembleName);
         this._fieldIdentifier = fieldIdentifier;
         this._caseName = caseName;
-        this._stratigraphic_column_identifier = stratigraphic_column_identifier;
-        this._realizationsArr = Array.from(realizationsArr).sort((a, b) => a - b);
-        this._parameters = new EnsembleParameters(parameterArr);
+        this._stratigraphicColumnIdentifier = stratigraphicColumnIdentifier;
+        this._realizationsArray = Array.from(realizationsArray).sort((a, b) => a - b);
+        this._parameters = new EnsembleParameters(parameterArray);
         this._color = color;
         this._customName = customName;
 
         this._sensitivities = null;
-        if (sensitivityArr && sensitivityArr.length > 0) {
-            this._sensitivities = new EnsembleSensitivities(sensitivityArr);
+        if (sensitivityArray && sensitivityArray.length > 0) {
+            this._sensitivities = new EnsembleSensitivities(sensitivityArray);
         }
     }
 
-    getIdent(): EnsembleIdent {
+    getIdent(): RegularEnsembleIdent {
         return this._ensembleIdent;
     }
 
@@ -49,7 +49,7 @@ export class Ensemble {
     }
 
     getStratigraphicColumnIdentifier(): string {
-        return this._stratigraphic_column_identifier;
+        return this._stratigraphicColumnIdentifier;
     }
 
     getDisplayName(): string {
@@ -72,19 +72,19 @@ export class Ensemble {
     }
 
     getRealizations(): readonly number[] {
-        return this._realizationsArr;
+        return this._realizationsArray;
     }
 
     getRealizationCount(): number {
-        return this._realizationsArr.length;
+        return this._realizationsArray.length;
     }
 
     getMaxRealizationNumber(): number | undefined {
-        if (this._realizationsArr.length == 0) {
+        if (this._realizationsArray.length == 0) {
             return undefined;
         }
 
-        return this._realizationsArr[this._realizationsArr.length - 1];
+        return this._realizationsArray[this._realizationsArray.length - 1];
     }
 
     getParameters(): EnsembleParameters {
diff --git a/frontend/src/framework/RegularEnsembleIdent.ts b/frontend/src/framework/RegularEnsembleIdent.ts
new file mode 100644
index 000000000..e18a0b93a
--- /dev/null
+++ b/frontend/src/framework/RegularEnsembleIdent.ts
@@ -0,0 +1,65 @@
+import { ensembleIdentUuidRegexString, isEnsembleIdentOfType } from "./utils/ensembleIdentUtils";
+
+export class RegularEnsembleIdent {
+    private _caseUuid: string;
+    private _ensembleName: string;
+
+    constructor(caseUuid: string, ensembleName: string) {
+        const uuidRegex = new RegExp(ensembleIdentUuidRegexString());
+        if (!uuidRegex.exec(caseUuid)) {
+            throw new Error(`Invalid caseUuid: ${caseUuid}`);
+        }
+
+        this._caseUuid = caseUuid;
+        this._ensembleName = ensembleName;
+    }
+
+    static caseUuidAndEnsembleNameToString(caseUuid: string, ensembleName: string): string {
+        return `${caseUuid}::${ensembleName}`;
+    }
+
+    static getEnsembleIdentRegex(): RegExp {
+        return new RegExp(`^(?<caseUuid>${ensembleIdentUuidRegexString()})::(?<ensembleName>.*)$`);
+    }
+
+    static isValidEnsembleIdentString(ensembleIdentString: string): boolean {
+        const regex = RegularEnsembleIdent.getEnsembleIdentRegex();
+        const result = regex.exec(ensembleIdentString);
+        return !!result && !!result.groups && !!result.groups.caseUuid && !!result.groups.ensembleName;
+    }
+
+    static fromString(ensembleIdentString: string): RegularEnsembleIdent {
+        const regex = RegularEnsembleIdent.getEnsembleIdentRegex();
+        const result = regex.exec(ensembleIdentString);
+        if (!result || !result.groups || !result.groups.caseUuid || !result.groups.ensembleName) {
+            throw new Error(`Invalid ensemble ident: ${ensembleIdentString}`);
+        }
+
+        const { caseUuid, ensembleName } = result.groups;
+
+        return new RegularEnsembleIdent(caseUuid, ensembleName);
+    }
+
+    getCaseUuid(): string {
+        return this._caseUuid;
+    }
+
+    getEnsembleName(): string {
+        return this._ensembleName;
+    }
+
+    toString(): string {
+        return RegularEnsembleIdent.caseUuidAndEnsembleNameToString(this._caseUuid, this._ensembleName);
+    }
+
+    equals(otherIdent: any | null): boolean {
+        if (!otherIdent || !isEnsembleIdentOfType(otherIdent, RegularEnsembleIdent)) {
+            return false;
+        }
+        if (otherIdent === this) {
+            return true;
+        }
+
+        return this._caseUuid === otherIdent._caseUuid && this._ensembleName === otherIdent._ensembleName;
+    }
+}
diff --git a/frontend/src/framework/Workbench.ts b/frontend/src/framework/Workbench.ts
index 424813de4..09c4c2066 100644
--- a/frontend/src/framework/Workbench.ts
+++ b/frontend/src/framework/Workbench.ts
@@ -1,15 +1,15 @@
 import { QueryClient } from "@tanstack/react-query";
 
 import { AtomStoreMaster } from "./AtomStoreMaster";
-import { EnsembleIdent } from "./EnsembleIdent";
 import { GuiMessageBroker, GuiState } from "./GuiMessageBroker";
 import { InitialSettings } from "./InitialSettings";
 import { ImportState } from "./Module";
 import { ModuleInstance } from "./ModuleInstance";
 import { ModuleRegistry } from "./ModuleRegistry";
+import { RegularEnsembleIdent } from "./RegularEnsembleIdent";
 import { Template } from "./TemplateRegistry";
 import { WorkbenchServices } from "./WorkbenchServices";
-import { loadEnsembleSetMetadataFromBackend } from "./internal/EnsembleSetLoader";
+import { loadMetadataFromBackendAndCreateEnsembleSet } from "./internal/EnsembleSetLoader";
 import { PrivateWorkbenchServices } from "./internal/PrivateWorkbenchServices";
 import { PrivateWorkbenchSettings } from "./internal/PrivateWorkbenchSettings";
 import { WorkbenchSessionPrivate } from "./internal/WorkbenchSessionPrivate";
@@ -28,14 +28,28 @@ export type LayoutElement = {
 };
 
 export type UserEnsembleSetting = {
-    ensembleIdent: EnsembleIdent;
+    ensembleIdent: RegularEnsembleIdent;
+    customName: string | null;
+    color: string;
+};
+
+export type UserDeltaEnsembleSetting = {
+    compareEnsembleIdent: RegularEnsembleIdent;
+    referenceEnsembleIdent: RegularEnsembleIdent;
     customName: string | null;
     color: string;
 };
 
 export type StoredUserEnsembleSetting = {
     ensembleIdent: string;
-    customName: string;
+    customName: string | null;
+    color: string;
+};
+
+export type StoredUserDeltaEnsembleSetting = {
+    compareEnsembleIdent: string;
+    referenceEnsembleIdent: string;
+    customName: string | null;
     color: string;
 };
 
@@ -228,38 +242,69 @@ export class Workbench {
 
     async loadAndSetupEnsembleSetInSession(
         queryClient: QueryClient,
-        userEnsembleSettings: UserEnsembleSetting[]
+        userEnsembleSettings: UserEnsembleSetting[],
+        userDeltaEnsembleSettings: UserDeltaEnsembleSetting[]
     ): Promise<void> {
         this.storeEnsembleSetInLocalStorage(userEnsembleSettings);
+        this.storeDeltaEnsembleSetInLocalStorage(userDeltaEnsembleSettings);
 
         console.debug("loadAndSetupEnsembleSetInSession - starting load");
         this._workbenchSession.setEnsembleSetLoadingState(true);
-        const newEnsembleSet = await loadEnsembleSetMetadataFromBackend(queryClient, userEnsembleSettings);
+        const newEnsembleSet = await loadMetadataFromBackendAndCreateEnsembleSet(
+            queryClient,
+            userEnsembleSettings,
+            userDeltaEnsembleSettings
+        );
         console.debug("loadAndSetupEnsembleSetInSession - loading done");
         console.debug("loadAndSetupEnsembleSetInSession - publishing");
         this._workbenchSession.setEnsembleSetLoadingState(false);
         return this._workbenchSession.setEnsembleSet(newEnsembleSet);
     }
 
-    private storeEnsembleSetInLocalStorage(ensemblesToStore: UserEnsembleSetting[]): void {
-        const ensembleIdentsToStore = ensemblesToStore.map((el) => ({
+    private storeEnsembleSetInLocalStorage(ensembleSettingsToStore: UserEnsembleSetting[]): void {
+        const ensembleSettingsArrayToStore: StoredUserEnsembleSetting[] = ensembleSettingsToStore.map((el) => ({
             ...el,
             ensembleIdent: el.ensembleIdent.toString(),
         }));
-        localStorage.setItem("userEnsembleSettings", JSON.stringify(ensembleIdentsToStore));
+        localStorage.setItem("userEnsembleSettings", JSON.stringify(ensembleSettingsArrayToStore));
+    }
+
+    private storeDeltaEnsembleSetInLocalStorage(deltaEnsembleSettingsToStore: UserDeltaEnsembleSetting[]): void {
+        const deltaEnsembleSettingsArrayToStore: StoredUserDeltaEnsembleSetting[] = deltaEnsembleSettingsToStore.map(
+            (el) => ({
+                ...el,
+                compareEnsembleIdent: el.compareEnsembleIdent.toString(),
+                referenceEnsembleIdent: el.referenceEnsembleIdent.toString(),
+            })
+        );
+        localStorage.setItem("userDeltaEnsembleSettings", JSON.stringify(deltaEnsembleSettingsArrayToStore));
     }
 
     maybeLoadEnsembleSettingsFromLocalStorage(): UserEnsembleSetting[] | null {
         const ensembleSettingsString = localStorage.getItem("userEnsembleSettings");
         if (!ensembleSettingsString) return null;
 
-        const ensembleIdents = JSON.parse(ensembleSettingsString) as StoredUserEnsembleSetting[];
-        const ensembleIdentsParsed = ensembleIdents.map((el) => ({
+        const ensembleSettingsArray = JSON.parse(ensembleSettingsString) as StoredUserEnsembleSetting[];
+        const parsedEnsembleSettingsArray: UserEnsembleSetting[] = ensembleSettingsArray.map((el) => ({
+            ...el,
+            ensembleIdent: RegularEnsembleIdent.fromString(el.ensembleIdent),
+        }));
+
+        return parsedEnsembleSettingsArray;
+    }
+
+    maybeLoadDeltaEnsembleSettingsFromLocalStorage(): UserDeltaEnsembleSetting[] | null {
+        const deltaEnsembleSettingsString = localStorage.getItem("userDeltaEnsembleSettings");
+        if (!deltaEnsembleSettingsString) return null;
+
+        const deltaEnsembleSettingsArray = JSON.parse(deltaEnsembleSettingsString) as StoredUserDeltaEnsembleSetting[];
+        const parsedDeltaEnsembleSettingsArray: UserDeltaEnsembleSetting[] = deltaEnsembleSettingsArray.map((el) => ({
             ...el,
-            ensembleIdent: EnsembleIdent.fromString(el.ensembleIdent),
+            compareEnsembleIdent: RegularEnsembleIdent.fromString(el.compareEnsembleIdent),
+            referenceEnsembleIdent: RegularEnsembleIdent.fromString(el.referenceEnsembleIdent),
         }));
 
-        return ensembleIdentsParsed;
+        return parsedDeltaEnsembleSettingsArray;
     }
 
     applyTemplate(template: Template): void {
diff --git a/frontend/src/framework/WorkbenchServices.ts b/frontend/src/framework/WorkbenchServices.ts
index 2757fc3c2..83af3c61c 100644
--- a/frontend/src/framework/WorkbenchServices.ts
+++ b/frontend/src/framework/WorkbenchServices.ts
@@ -4,7 +4,7 @@ import { Point2D, Point3D } from "@webviz/subsurface-viewer";
 
 import { isEqual } from "lodash";
 
-import { EnsembleIdent } from "./EnsembleIdent";
+import { RegularEnsembleIdent } from "./RegularEnsembleIdent";
 import { Workbench } from "./Workbench";
 import { InplaceVolumetricsFilter } from "./types/inplaceVolumetricsFilter";
 import { Intersection } from "./types/intersection";
@@ -24,7 +24,7 @@ export type GlobalTopicDefinitions = {
     "global.hoverRegion": { regionName: string } | null;
     "global.hoverFacies": { faciesName: string } | null;
 
-    "global.syncValue.ensembles": EnsembleIdent[];
+    "global.syncValue.ensembles": RegularEnsembleIdent[];
     "global.syncValue.date": { timeOrInterval: string };
     "global.syncValue.timeSeries": { vectorName: string };
     "global.syncValue.surface": { name: string; attribute: string };
diff --git a/frontend/src/framework/WorkbenchSession.ts b/frontend/src/framework/WorkbenchSession.ts
index 54fa1c5ad..b1774c595 100644
--- a/frontend/src/framework/WorkbenchSession.ts
+++ b/frontend/src/framework/WorkbenchSession.ts
@@ -1,13 +1,15 @@
 import React from "react";
 
 import { AtomStoreMaster } from "./AtomStoreMaster";
-import { Ensemble } from "./Ensemble";
-import { EnsembleIdent } from "./EnsembleIdent";
+import { DeltaEnsembleIdent } from "./DeltaEnsembleIdent";
 import { EnsembleSet } from "./EnsembleSet";
 import { RealizationFilterSet } from "./RealizationFilterSet";
+import { RegularEnsembleIdent } from "./RegularEnsembleIdent";
 import { UserCreatedItems } from "./UserCreatedItems";
 
-export type EnsembleRealizationFilterFunction = (ensembleIdent: EnsembleIdent) => readonly number[];
+export type EnsembleRealizationFilterFunction = (
+    ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent
+) => readonly number[];
 
 export enum WorkbenchSessionEvent {
     EnsembleSetChanged = "EnsembleSetChanged",
@@ -78,7 +80,9 @@ export class WorkbenchSession {
 }
 
 export function createEnsembleRealizationFilterFuncForWorkbenchSession(workbenchSession: WorkbenchSession) {
-    return function ensembleRealizationFilterFunc(ensembleIdent: EnsembleIdent): readonly number[] {
+    return function ensembleRealizationFilterFunc(
+        ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent
+    ): readonly number[] {
         const realizationFilterSet = workbenchSession.getRealizationFilterSet();
         const realizationFilter = realizationFilterSet.getRealizationFilterForEnsembleIdent(ensembleIdent);
 
@@ -137,15 +141,6 @@ export function useEnsembleSet(workbenchSession: WorkbenchSession): EnsembleSet
     return storedEnsembleSet;
 }
 
-export function useFirstEnsembleInEnsembleSet(workbenchSession: WorkbenchSession): Ensemble | null {
-    const ensembleSet = useEnsembleSet(workbenchSession);
-    if (!ensembleSet.hasAnyEnsembles()) {
-        return null;
-    }
-
-    return ensembleSet.getEnsembleArr()[0];
-}
-
 export function useIsEnsembleSetLoading(workbenchSession: WorkbenchSession): boolean {
     const [isLoading, setIsLoading] = React.useState<boolean>(false);
 
diff --git a/frontend/src/framework/components/EnsembleDropdown/ensembleDropdown.tsx b/frontend/src/framework/components/EnsembleDropdown/ensembleDropdown.tsx
index f8bfd6a8c..86ffd582e 100644
--- a/frontend/src/framework/components/EnsembleDropdown/ensembleDropdown.tsx
+++ b/frontend/src/framework/components/EnsembleDropdown/ensembleDropdown.tsx
@@ -1,32 +1,56 @@
 import React from "react";
 
-import { Ensemble } from "@framework/Ensemble";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { DeltaEnsemble } from "@framework/DeltaEnsemble";
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { ColorTile } from "@lib/components/ColorTile";
 import { Dropdown, DropdownOption, DropdownProps } from "@lib/components/Dropdown";
 
-type EnsembleDropdownProps = {
-    ensembles: readonly Ensemble[];
-    value: EnsembleIdent | null;
-    onChange: (ensembleIdent: EnsembleIdent | null) => void;
+// Overload for EnsembleDropdown with DeltaEnsembleIdent
+export type EnsembleDropdownWithDeltaEnsemblesProps = {
+    ensembles: readonly (RegularEnsemble | DeltaEnsemble)[];
+    allowDeltaEnsembles: true;
+    value: RegularEnsembleIdent | DeltaEnsembleIdent | null;
+    onChange: (ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent | null) => void;
 } & Omit<DropdownProps<string>, "options" | "value" | "onChange">;
 
-export function EnsembleDropdown(props: EnsembleDropdownProps): JSX.Element {
-    const { onChange, value, ...rest } = props;
+// Overload for EnsembleDropdown without DeltaEnsembleIdent
+export type EnsembleDropdownWithoutDeltaEnsemblesProps = {
+    ensembles: readonly RegularEnsemble[];
+    allowDeltaEnsembles?: false | undefined;
+    value: RegularEnsembleIdent | null;
+    onChange: (ensembleIdent: RegularEnsembleIdent | null) => void;
+} & Omit<DropdownProps<string>, "options" | "value" | "onChange">;
+
+export function EnsembleDropdown(props: EnsembleDropdownWithDeltaEnsemblesProps): JSX.Element;
+export function EnsembleDropdown(props: EnsembleDropdownWithoutDeltaEnsemblesProps): JSX.Element;
+export function EnsembleDropdown(
+    props: EnsembleDropdownWithDeltaEnsemblesProps | EnsembleDropdownWithoutDeltaEnsemblesProps
+): JSX.Element {
+    const { onChange, ensembles, allowDeltaEnsembles, value, ...rest } = props;
 
     const handleSelectionChange = React.useCallback(
         function handleSelectionChange(selectedEnsembleIdentStr: string) {
-            const foundEnsemble = props.ensembles.find(
+            const foundEnsemble = ensembles.find(
                 (ensemble) => ensemble.getIdent().toString() === selectedEnsembleIdentStr
             );
-            onChange(foundEnsemble ? foundEnsemble.getIdent() : null);
+            if (foundEnsemble && allowDeltaEnsembles) {
+                onChange(foundEnsemble.getIdent());
+                return;
+            }
+            if (!foundEnsemble || foundEnsemble instanceof DeltaEnsemble) {
+                onChange(null);
+                return;
+            }
+            onChange(foundEnsemble.getIdent());
         },
-        [props.ensembles, onChange]
+        [allowDeltaEnsembles, ensembles, onChange]
     );
 
-    const optionsArr: DropdownOption[] = [];
-    for (const ens of props.ensembles) {
-        optionsArr.push({
+    const optionsArray: DropdownOption[] = [];
+    for (const ens of ensembles) {
+        optionsArray.push({
             value: ens.getIdent().toString(),
             label: ens.getDisplayName(),
             adornment: (
@@ -37,5 +61,5 @@ export function EnsembleDropdown(props: EnsembleDropdownProps): JSX.Element {
         });
     }
 
-    return <Dropdown options={optionsArr} value={value?.toString()} onChange={handleSelectionChange} {...rest} />;
+    return <Dropdown options={optionsArray} value={value?.toString()} onChange={handleSelectionChange} {...rest} />;
 }
diff --git a/frontend/src/framework/components/EnsembleSelect/ensembleSelect.tsx b/frontend/src/framework/components/EnsembleSelect/ensembleSelect.tsx
index 6fae717a6..b40b64d68 100644
--- a/frontend/src/framework/components/EnsembleSelect/ensembleSelect.tsx
+++ b/frontend/src/framework/components/EnsembleSelect/ensembleSelect.tsx
@@ -1,37 +1,64 @@
 import React from "react";
 
-import { Ensemble } from "@framework/Ensemble";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { DeltaEnsemble } from "@framework/DeltaEnsemble";
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
+import { isEnsembleIdentOfType } from "@framework/utils/ensembleIdentUtils";
 import { ColorTile } from "@lib/components/ColorTile";
 import { Select, SelectOption, SelectProps } from "@lib/components/Select";
 
-type EnsembleSelectProps = {
-    ensembles: readonly Ensemble[];
-    value: EnsembleIdent[];
-    onChange: (ensembleIdentArr: EnsembleIdent[]) => void;
+// Overload for EnsembleSelect with DeltaEnsembleIdent
+export type EnsembleSelectWithDeltaEnsemblesProps = {
+    ensembles: readonly (RegularEnsemble | DeltaEnsemble)[];
+    multiple?: boolean;
+    allowDeltaEnsembles: true;
+    value: (RegularEnsembleIdent | DeltaEnsembleIdent)[];
+    onChange: (ensembleIdentArray: (RegularEnsembleIdent | DeltaEnsembleIdent)[]) => void;
 } & Omit<SelectProps<string>, "options" | "value" | "onChange">;
 
-export function EnsembleSelect(props: EnsembleSelectProps): React.ReactNode {
-    const { ensembles, value, onChange, multiple, ...rest } = props;
+// Overload for EnsembleSelect without DeltaEnsembleIdent
+export type EnsembleSelectWithoutDeltaEnsemblesProps = {
+    ensembles: readonly RegularEnsemble[];
+    multiple?: boolean;
+    allowDeltaEnsembles?: false | undefined;
+    value: RegularEnsembleIdent[];
+    onChange: (ensembleIdentArray: RegularEnsembleIdent[]) => void;
+} & Omit<SelectProps<string>, "options" | "value" | "onChange">;
+
+export function EnsembleSelect(props: EnsembleSelectWithDeltaEnsemblesProps): JSX.Element;
+export function EnsembleSelect(props: EnsembleSelectWithoutDeltaEnsemblesProps): JSX.Element;
+export function EnsembleSelect(
+    props: EnsembleSelectWithDeltaEnsemblesProps | EnsembleSelectWithoutDeltaEnsemblesProps
+): JSX.Element {
+    const { onChange, ensembles, value, allowDeltaEnsembles, multiple, ...rest } = props;
 
     const handleSelectionChange = React.useCallback(
-        function handleSelectionChanged(selectedEnsembleIdentStrArr: string[]) {
-            const identArr: EnsembleIdent[] = [];
-            for (const identStr of selectedEnsembleIdentStrArr) {
+        function handleSelectionChanged(selectedEnsembleIdentStringArray: string[]) {
+            const identArray: (RegularEnsembleIdent | DeltaEnsembleIdent)[] = [];
+            for (const identStr of selectedEnsembleIdentStringArray) {
                 const foundEnsemble = ensembles.find((ens) => ens.getIdent().toString() === identStr);
-                if (foundEnsemble) {
-                    identArr.push(foundEnsemble.getIdent());
+                if (foundEnsemble && (allowDeltaEnsembles || foundEnsemble instanceof RegularEnsemble)) {
+                    identArray.push(foundEnsemble.getIdent());
                 }
             }
 
-            onChange(identArr);
+            // Filter to match the correct return type before calling onChange
+            if (!allowDeltaEnsembles) {
+                const validIdentArray = identArray.filter((ident) =>
+                    isEnsembleIdentOfType(ident, RegularEnsembleIdent)
+                ) as RegularEnsembleIdent[];
+                onChange(validIdentArray);
+                return;
+            }
+            onChange(identArray);
         },
-        [ensembles, onChange]
+        [allowDeltaEnsembles, ensembles, onChange]
     );
 
-    const optionsArr: SelectOption[] = [];
+    const optionsArray: SelectOption[] = [];
     for (const ens of ensembles) {
-        optionsArr.push({
+        optionsArray.push({
             value: ens.getIdent().toString(),
             label: ens.getDisplayName(),
             adornment: (
@@ -42,17 +69,17 @@ export function EnsembleSelect(props: EnsembleSelectProps): React.ReactNode {
         });
     }
 
-    const selectedArr: string[] = [];
+    const selectedArray: string[] = [];
     for (const ident of value) {
-        selectedArr.push(ident.toString());
+        selectedArray.push(ident.toString());
     }
 
     const isMultiple = multiple ?? true;
 
     return (
         <Select
-            options={optionsArr}
-            value={selectedArr}
+            options={optionsArray}
+            value={selectedArray}
             onChange={handleSelectionChange}
             multiple={isMultiple}
             {...rest}
diff --git a/frontend/src/framework/components/FieldDropdown/fieldDropdown.tsx b/frontend/src/framework/components/FieldDropdown/fieldDropdown.tsx
index 922387576..aed8241ad 100644
--- a/frontend/src/framework/components/FieldDropdown/fieldDropdown.tsx
+++ b/frontend/src/framework/components/FieldDropdown/fieldDropdown.tsx
@@ -14,17 +14,17 @@ export function FieldDropdown(props: FieldDropdownProps): JSX.Element {
         onChange(fieldIdentifier);
     }
 
-    const optionsArr: DropdownOption[] = [];
-    for (const ens of ensembleSet.getEnsembleArr()) {
+    const optionsArray: DropdownOption[] = [];
+    for (const ens of ensembleSet.getRegularEnsembleArray()) {
         const fieldIdentifier = ens.getFieldIdentifier();
-        if (optionsArr.some((option) => option.value === fieldIdentifier.toString())) {
+        if (optionsArray.some((option) => option.value === fieldIdentifier.toString())) {
             continue;
         }
-        optionsArr.push({
+        optionsArray.push({
             value: fieldIdentifier.toString(),
             label: fieldIdentifier.toString(),
         });
     }
 
-    return <Dropdown options={optionsArr} value={value?.toString()} onChange={handleSelectionChanged} {...rest} />;
+    return <Dropdown options={optionsArray} value={value?.toString()} onChange={handleSelectionChanged} {...rest} />;
 }
diff --git a/frontend/src/framework/internal/EnsembleSetLoader.ts b/frontend/src/framework/internal/EnsembleSetLoader.ts
index 9e1faf451..2089b8ef4 100644
--- a/frontend/src/framework/internal/EnsembleSetLoader.ts
+++ b/frontend/src/framework/internal/EnsembleSetLoader.ts
@@ -1,30 +1,167 @@
 import { EnsembleDetails_api, EnsembleParameter_api, EnsembleSensitivity_api } from "@api";
 import { apiService } from "@framework/ApiService";
-import { UserEnsembleSetting } from "@framework/Workbench";
+import { DeltaEnsemble } from "@framework/DeltaEnsemble";
+import { UserDeltaEnsembleSetting, UserEnsembleSetting } from "@framework/Workbench";
 import { QueryClient } from "@tanstack/react-query";
 
-import { Ensemble } from "../Ensemble";
-import { EnsembleIdent } from "../EnsembleIdent";
 import { ContinuousParameter, DiscreteParameter, Parameter, ParameterType } from "../EnsembleParameters";
 import { Sensitivity, SensitivityCase } from "../EnsembleSensitivities";
 import { EnsembleSet } from "../EnsembleSet";
+import { RegularEnsemble } from "../RegularEnsemble";
+import { RegularEnsembleIdent } from "../RegularEnsembleIdent";
 
-export async function loadEnsembleSetMetadataFromBackend(
+type EnsembleApiData = {
+    ensembleDetails: EnsembleDetails_api;
+    parameters: EnsembleParameter_api[];
+    sensitivities: EnsembleSensitivity_api[];
+};
+type EnsembleIdentStringToApiDataMap = {
+    [ensembleIdentString: string]: EnsembleApiData;
+};
+
+export async function loadMetadataFromBackendAndCreateEnsembleSet(
     queryClient: QueryClient,
-    userEnsembleSettings: UserEnsembleSetting[]
+    userEnsembleSettings: UserEnsembleSetting[],
+    userDeltaEnsembleSettings: UserDeltaEnsembleSetting[]
 ): Promise<EnsembleSet> {
-    const ensembleIdentsToLoad: EnsembleIdent[] = userEnsembleSettings.map((setting) => setting.ensembleIdent);
+    // Get ensemble idents to load
+    const ensembleIdentsToLoad: RegularEnsembleIdent[] = userEnsembleSettings.map((setting) => setting.ensembleIdent);
+    for (const deltaEnsembleSetting of userDeltaEnsembleSettings) {
+        if (!ensembleIdentsToLoad.includes(deltaEnsembleSetting.compareEnsembleIdent)) {
+            ensembleIdentsToLoad.push(deltaEnsembleSetting.compareEnsembleIdent);
+        }
+        if (!ensembleIdentsToLoad.includes(deltaEnsembleSetting.referenceEnsembleIdent)) {
+            ensembleIdentsToLoad.push(deltaEnsembleSetting.referenceEnsembleIdent);
+        }
+    }
+
+    // Fetch from back-end
+    const ensembleIdentStringToApiDataMap = await loadEnsembleIdentStringToApiDataMapFromBackend(
+        queryClient,
+        ensembleIdentsToLoad
+    );
+
+    // Create regular ensembles
+    const outEnsembleArray: RegularEnsemble[] = [];
+    for (const ensembleSetting of userEnsembleSettings) {
+        const ensembleIdentString = ensembleSetting.ensembleIdent.toString();
+        const ensembleApiData = ensembleIdentStringToApiDataMap[ensembleIdentString];
+        if (!ensembleApiData) {
+            console.error("Error fetching ensemble data, dropping ensemble:", ensembleSetting.ensembleIdent.toString());
+            continue;
+        }
+
+        const parameterArray = buildParameterArrFromApiResponse(ensembleApiData.parameters);
+        const sensitivityArray = buildSensitivityArrFromApiResponse(ensembleApiData.sensitivities);
+        outEnsembleArray.push(
+            new RegularEnsemble(
+                ensembleApiData.ensembleDetails.field_identifier,
+                ensembleApiData.ensembleDetails.case_uuid,
+                ensembleApiData.ensembleDetails.case_name,
+                ensembleApiData.ensembleDetails.name,
+                ensembleApiData.ensembleDetails.stratigraphic_column_identifier,
+                ensembleApiData.ensembleDetails.realizations,
+                parameterArray,
+                sensitivityArray,
+                ensembleSetting.color,
+                ensembleSetting.customName
+            )
+        );
+    }
+
+    // Create delta ensembles
+    // - Delta ensembles does not support parameters and sensitivities yet
+    const outDeltaEnsembleArray: DeltaEnsemble[] = [];
+    const emptyParameterArray: Parameter[] = [];
+    const nullSensitiveArray = null;
+    const emptyColor = "";
+    for (const deltaEnsembleSetting of userDeltaEnsembleSettings) {
+        const compareEnsembleIdentString = deltaEnsembleSetting.compareEnsembleIdent.toString();
+        const referenceEnsembleIdentString = deltaEnsembleSetting.referenceEnsembleIdent.toString();
+
+        const compareEnsembleApiData = ensembleIdentStringToApiDataMap[compareEnsembleIdentString];
+        const referenceEnsembleApiData = ensembleIdentStringToApiDataMap[referenceEnsembleIdentString];
+        if (!compareEnsembleApiData || !referenceEnsembleApiData) {
+            console.error(
+                "Error fetching delta ensemble data, dropping delta ensemble:",
+                deltaEnsembleSetting.customName ?? `${compareEnsembleIdentString} - ${referenceEnsembleIdentString}`
+            );
+            continue;
+        }
 
-    console.debug("loadEnsembleSetMetadataFromBackend", ensembleIdentsToLoad);
+        const compareEnsembleCustomName =
+            userEnsembleSettings.find((elm) => elm.ensembleIdent.toString() === compareEnsembleIdentString)
+                ?.customName ?? null;
+        const referenceEnsembleCustomName =
+            userEnsembleSettings.find((elm) => elm.ensembleIdent.toString() === referenceEnsembleIdentString)
+                ?.customName ?? null;
+
+        // Look for existing regular ensembles
+        const existingCompareEnsemble = outEnsembleArray.find((elm) =>
+            elm.getIdent().equals(deltaEnsembleSetting.compareEnsembleIdent)
+        );
+        const existingReferenceEnsemble = outEnsembleArray.find((elm) =>
+            elm.getIdent().equals(deltaEnsembleSetting.referenceEnsembleIdent)
+        );
+
+        // Create delta ensemble
+        const compareEnsemble = existingCompareEnsemble
+            ? existingCompareEnsemble
+            : new RegularEnsemble(
+                  compareEnsembleApiData.ensembleDetails.field_identifier,
+                  compareEnsembleApiData.ensembleDetails.case_uuid,
+                  compareEnsembleApiData.ensembleDetails.case_name,
+                  compareEnsembleApiData.ensembleDetails.name,
+                  compareEnsembleApiData.ensembleDetails.stratigraphic_column_identifier,
+                  compareEnsembleApiData.ensembleDetails.realizations,
+                  emptyParameterArray,
+                  nullSensitiveArray,
+                  emptyColor,
+                  compareEnsembleCustomName
+              );
+
+        const referenceEnsemble = existingReferenceEnsemble
+            ? existingReferenceEnsemble
+            : new RegularEnsemble(
+                  referenceEnsembleApiData.ensembleDetails.field_identifier,
+                  referenceEnsembleApiData.ensembleDetails.case_uuid,
+                  referenceEnsembleApiData.ensembleDetails.case_name,
+                  referenceEnsembleApiData.ensembleDetails.name,
+                  compareEnsembleApiData.ensembleDetails.stratigraphic_column_identifier,
+                  referenceEnsembleApiData.ensembleDetails.realizations,
+                  emptyParameterArray,
+                  nullSensitiveArray,
+                  emptyColor,
+                  referenceEnsembleCustomName
+              );
+
+        outDeltaEnsembleArray.push(
+            new DeltaEnsemble(
+                compareEnsemble,
+                referenceEnsemble,
+                deltaEnsembleSetting.color,
+                deltaEnsembleSetting.customName
+            )
+        );
+    }
+
+    return new EnsembleSet(outEnsembleArray, outDeltaEnsembleArray);
+}
+
+async function loadEnsembleIdentStringToApiDataMapFromBackend(
+    queryClient: QueryClient,
+    ensembleIdents: RegularEnsembleIdent[]
+): Promise<EnsembleIdentStringToApiDataMap> {
+    console.debug("loadEnsembleIdentStringToApiDataMapFromBackend", ensembleIdents);
 
     const STALE_TIME = 5 * 60 * 1000;
     const CACHE_TIME = 5 * 60 * 1000;
 
-    const ensembleDetailsPromiseArr: Promise<EnsembleDetails_api>[] = [];
-    const parametersPromiseArr: Promise<EnsembleParameter_api[]>[] = [];
-    const sensitivitiesPromiseArr: Promise<EnsembleSensitivity_api[]>[] = [];
+    const ensembleDetailsPromiseArray: Promise<EnsembleDetails_api>[] = [];
+    const parametersPromiseArray: Promise<EnsembleParameter_api[]>[] = [];
+    const sensitivitiesPromiseArray: Promise<EnsembleSensitivity_api[]>[] = [];
 
-    for (const ensembleIdent of ensembleIdentsToLoad) {
+    for (const ensembleIdent of ensembleIdents) {
         const caseUuid = ensembleIdent.getCaseUuid();
         const ensembleName = ensembleIdent.getEnsembleName();
 
@@ -34,7 +171,7 @@ export async function loadEnsembleSetMetadataFromBackend(
             staleTime: STALE_TIME,
             gcTime: CACHE_TIME,
         });
-        ensembleDetailsPromiseArr.push(ensembleDetailsPromise);
+        ensembleDetailsPromiseArray.push(ensembleDetailsPromise);
 
         const parametersPromise = queryClient.fetchQuery({
             queryKey: ["getParameters", caseUuid, ensembleName],
@@ -42,7 +179,7 @@ export async function loadEnsembleSetMetadataFromBackend(
             staleTime: STALE_TIME,
             gcTime: CACHE_TIME,
         });
-        parametersPromiseArr.push(parametersPromise);
+        parametersPromiseArray.push(parametersPromise);
 
         const sensitivitiesPromise = queryClient.fetchQuery({
             queryKey: ["getSensitivities", caseUuid, ensembleName],
@@ -50,92 +187,82 @@ export async function loadEnsembleSetMetadataFromBackend(
             staleTime: STALE_TIME,
             gcTime: CACHE_TIME,
         });
-        sensitivitiesPromiseArr.push(sensitivitiesPromise);
+        sensitivitiesPromiseArray.push(sensitivitiesPromise);
     }
-    console.debug(`Issued ${ensembleDetailsPromiseArr.length} promise(s)`);
-
-    const outEnsembleArr: Ensemble[] = [];
+    console.debug(`Issued ${ensembleDetailsPromiseArray.length} promise(s)`);
 
-    const ensembleDetailsOutcomeArr = await Promise.allSettled(ensembleDetailsPromiseArr);
-    const parametersOutcomeArr = await Promise.allSettled(parametersPromiseArr);
-    const sensitivitiesOutcomeArr = await Promise.allSettled(sensitivitiesPromiseArr);
+    const ensembleDetailsOutcomeArray = await Promise.allSettled(ensembleDetailsPromiseArray);
+    const parametersOutcomeArray = await Promise.allSettled(parametersPromiseArray);
+    const sensitivitiesOutcomeArray = await Promise.allSettled(sensitivitiesPromiseArray);
 
-    for (let i = 0; i < ensembleDetailsOutcomeArr.length; i++) {
-        const ensembleDetailsOutcome = ensembleDetailsOutcomeArr[i];
+    const resMap: EnsembleIdentStringToApiDataMap = {};
+    for (let i = 0; i < ensembleDetailsOutcomeArray.length; i++) {
+        const ensembleDetailsOutcome = ensembleDetailsOutcomeArray[i];
         console.debug(`ensembleDetailsOutcome[${i}]:`, ensembleDetailsOutcome.status);
         if (ensembleDetailsOutcome.status === "rejected") {
-            console.error("Error fetching ensemble details, dropping ensemble:", ensembleIdentsToLoad[i].toString());
+            console.error("Error fetching ensemble details, dropping ensemble:", ensembleIdents[i].toString());
             continue;
         }
 
         const ensembleDetails: EnsembleDetails_api = ensembleDetailsOutcome.value;
         if (
-            ensembleDetails.case_uuid !== ensembleIdentsToLoad[i].getCaseUuid() ||
-            ensembleDetails.name !== ensembleIdentsToLoad[i].getEnsembleName()
+            ensembleDetails.case_uuid !== ensembleIdents[i].getCaseUuid() ||
+            ensembleDetails.name !== ensembleIdents[i].getEnsembleName()
         ) {
-            console.error("Got mismatched data from backend, dropping ensemble:", ensembleIdentsToLoad[i].toString());
+            console.error("Got mismatched data from backend, dropping ensemble:", ensembleIdents[i].toString());
             continue;
         }
 
-        const parametersOutcome = parametersOutcomeArr[i];
+        const parametersOutcome = parametersOutcomeArray[i];
         console.debug(`parametersOutcome[${i}]:`, parametersOutcome.status);
-        let parameterArr: Parameter[] = [];
+        let parameterArray: EnsembleParameter_api[] = [];
         if (parametersOutcome.status === "fulfilled") {
-            parameterArr = buildParameterArrFromApiResponse(parametersOutcome.value);
+            parameterArray = parametersOutcome.value;
         }
 
-        const sensitivitiesOutcome = sensitivitiesOutcomeArr[i];
+        const sensitivitiesOutcome = sensitivitiesOutcomeArray[i];
         console.debug(`sensitivitiesOutcome[${i}]:`, sensitivitiesOutcome.status);
-        let sensitivityArr: Sensitivity[] | null = null;
+        let sensitivityArray: EnsembleSensitivity_api[] = [];
         if (sensitivitiesOutcome.status === "fulfilled") {
-            sensitivityArr = buildSensitivityArrFromApiResponse(sensitivitiesOutcome.value);
+            sensitivityArray = sensitivitiesOutcome.value;
         }
 
-        outEnsembleArr.push(
-            new Ensemble(
-                ensembleDetails.field_identifier,
-                ensembleDetails.case_uuid,
-                ensembleDetails.case_name,
-                ensembleDetails.name,
-                ensembleDetails.stratigraphic_column_identifier,
-                ensembleDetails.realizations,
-                parameterArr,
-                sensitivityArr,
-                userEnsembleSettings[i].color,
-                userEnsembleSettings[i].customName
-            )
-        );
+        resMap[ensembleIdents[i].toString()] = {
+            ensembleDetails: ensembleDetails,
+            parameters: parameterArray,
+            sensitivities: sensitivityArray,
+        };
     }
 
-    return new EnsembleSet(outEnsembleArr);
+    return resMap;
 }
 
-function buildSensitivityArrFromApiResponse(apiSensitivityArr: EnsembleSensitivity_api[]): Sensitivity[] {
-    const retSensitivityArr: Sensitivity[] = [];
+function buildSensitivityArrFromApiResponse(apiSensitivityArray: EnsembleSensitivity_api[]): Sensitivity[] {
+    const retSensitivityArray: Sensitivity[] = [];
 
-    for (const apiSens of apiSensitivityArr) {
-        const caseArr: SensitivityCase[] = [];
+    for (const apiSens of apiSensitivityArray) {
+        const caseArray: SensitivityCase[] = [];
         for (const apiCase of apiSens.cases) {
-            caseArr.push({
+            caseArray.push({
                 name: apiCase.name,
                 realizations: apiCase.realizations,
             });
         }
 
-        retSensitivityArr.push({
+        retSensitivityArray.push({
             name: apiSens.name,
             type: apiSens.type,
-            cases: caseArr,
+            cases: caseArray,
         });
     }
 
-    return retSensitivityArr;
+    return retSensitivityArray;
 }
 
-function buildParameterArrFromApiResponse(apiParameterArr: EnsembleParameter_api[]): Parameter[] {
-    const retParameterArr: Parameter[] = [];
+function buildParameterArrFromApiResponse(apiParameterArray: EnsembleParameter_api[]): Parameter[] {
+    const retParameterArray: Parameter[] = [];
 
-    for (const apiPar of apiParameterArr) {
+    for (const apiPar of apiParameterArray) {
         if (apiPar.is_discrete) {
             const retPar: DiscreteParameter = {
                 type: ParameterType.DISCRETE,
@@ -146,7 +273,7 @@ function buildParameterArrFromApiResponse(apiParameterArr: EnsembleParameter_api
                 realizations: apiPar.realizations,
                 values: apiPar.values,
             };
-            retParameterArr.push(retPar);
+            retParameterArray.push(retPar);
         } else {
             const retPar: ContinuousParameter = {
                 type: ParameterType.CONTINUOUS,
@@ -158,9 +285,9 @@ function buildParameterArrFromApiResponse(apiParameterArr: EnsembleParameter_api
                 realizations: apiPar.realizations,
                 values: apiPar.values as number[],
             };
-            retParameterArr.push(retPar);
+            retParameterArray.push(retPar);
         }
     }
 
-    return retParameterArr;
+    return retParameterArray;
 }
diff --git a/frontend/src/framework/internal/components/NavBar/leftNavBar.tsx b/frontend/src/framework/internal/components/NavBar/leftNavBar.tsx
index 05eb6bcd8..60a49b5d1 100644
--- a/frontend/src/framework/internal/components/NavBar/leftNavBar.tsx
+++ b/frontend/src/framework/internal/components/NavBar/leftNavBar.tsx
@@ -1,13 +1,17 @@
 import React from "react";
 
 import WebvizLogo from "@assets/webviz.svg";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { GuiState, LeftDrawerContent, useGuiState, useGuiValue } from "@framework/GuiMessageBroker";
-import { UserEnsembleSetting, Workbench, WorkbenchEvents } from "@framework/Workbench";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
+import { UserDeltaEnsembleSetting, UserEnsembleSetting, Workbench, WorkbenchEvents } from "@framework/Workbench";
 import { useEnsembleSet, useIsEnsembleSetLoading } from "@framework/WorkbenchSession";
 import { LoginButton } from "@framework/internal/components/LoginButton";
 import { SelectEnsemblesDialog } from "@framework/internal/components/SelectEnsemblesDialog";
-import { EnsembleItem } from "@framework/internal/components/SelectEnsemblesDialog/selectEnsemblesDialog";
+import {
+    DeltaEnsembleElementItem,
+    DeltaEnsembleItem,
+    EnsembleItem,
+} from "@framework/internal/components/SelectEnsemblesDialog/selectEnsemblesDialog";
 import { Badge } from "@lib/components/Badge";
 import { Button } from "@lib/components/Button";
 import { CircularProgress } from "@lib/components/CircularProgress";
@@ -30,6 +34,7 @@ export const LeftNavBar: React.FC<LeftNavBarProps> = (props) => {
     const ensembleSet = useEnsembleSet(props.workbench.getWorkbenchSession());
     const [ensembleDialogOpen, setEnsembleDialogOpen] = React.useState<boolean>(false);
     const [newSelectedEnsembles, setNewSelectedEnsembles] = React.useState<EnsembleItem[]>([]);
+    const [newCreatedDeltaEnsembles, setNewCreatedDeltaEnsembles] = React.useState<DeltaEnsembleItem[]>([]);
     const [layoutEmpty, setLayoutEmpty] = React.useState<boolean>(props.workbench.getLayout().length === 0);
     const [collapsed, setCollapsed] = React.useState<boolean>(localStorage.getItem("navBarCollapsed") === "true");
     const [prevIsAppInitialized, setPrevIsAppInitialized] = React.useState<boolean>(false);
@@ -45,7 +50,7 @@ export const LeftNavBar: React.FC<LeftNavBarProps> = (props) => {
     const isAppInitialized = useGuiValue(props.workbench.getGuiMessageBroker(), GuiState.AppInitialized);
 
     if (isAppInitialized !== prevIsAppInitialized && !loadingEnsembleSet) {
-        setEnsembleDialogOpen(ensembleSet.getEnsembleArr().length === 0);
+        setEnsembleDialogOpen(ensembleSet.getEnsembleArray().length === 0);
         setPrevIsAppInitialized(isAppInitialized);
     }
 
@@ -117,29 +122,68 @@ export const LeftNavBar: React.FC<LeftNavBarProps> = (props) => {
         localStorage.setItem("navBarCollapsed", (!collapsed).toString());
     }
 
-    const selectedEnsembles: EnsembleItem[] = ensembleSet.getEnsembleArr().map((ens) => ({
-        caseUuid: ens.getCaseUuid(),
-        caseName: ens.getCaseName(),
-        ensembleName: ens.getEnsembleName(),
-        color: ens.getColor(),
-        customName: ens.getCustomName(),
-    }));
-
-    function loadAndSetupEnsembles(ensembleItems: EnsembleItem[]): Promise<void> {
+    function loadAndSetupEnsembles(
+        ensembleItems: EnsembleItem[],
+        createdDeltaEnsembles: DeltaEnsembleItem[]
+    ): Promise<void> {
         setNewSelectedEnsembles(ensembleItems);
+        setNewCreatedDeltaEnsembles(createdDeltaEnsembles);
         const ensembleSettings: UserEnsembleSetting[] = ensembleItems.map((ens) => ({
-            ensembleIdent: new EnsembleIdent(ens.caseUuid, ens.ensembleName),
+            ensembleIdent: new RegularEnsembleIdent(ens.caseUuid, ens.ensembleName),
             customName: ens.customName,
             color: ens.color,
         }));
-        return props.workbench.loadAndSetupEnsembleSetInSession(queryClient, ensembleSettings);
+        const deltaEnsembleSettings: UserDeltaEnsembleSetting[] = createdDeltaEnsembles.map((deltaEns) => ({
+            compareEnsembleIdent: new RegularEnsembleIdent(
+                deltaEns.compareEnsemble.caseUuid,
+                deltaEns.compareEnsemble.ensembleName
+            ),
+            referenceEnsembleIdent: new RegularEnsembleIdent(
+                deltaEns.referenceEnsemble.caseUuid,
+                deltaEns.referenceEnsemble.ensembleName
+            ),
+            customName: deltaEns.customName,
+            color: deltaEns.color,
+        }));
+        return props.workbench.loadAndSetupEnsembleSetInSession(queryClient, ensembleSettings, deltaEnsembleSettings);
     }
 
+    const selectedEnsembles: EnsembleItem[] = ensembleSet.getRegularEnsembleArray().map((ens) => ({
+        caseUuid: ens.getCaseUuid(),
+        caseName: ens.getCaseName(),
+        ensembleName: ens.getEnsembleName(),
+        color: ens.getColor(),
+        customName: ens.getCustomName(),
+    }));
+
     let fixedSelectedEnsembles = selectedEnsembles;
     if (loadingEnsembleSet) {
         fixedSelectedEnsembles = newSelectedEnsembles;
     }
 
+    const createdDeltaEnsembles: DeltaEnsembleItem[] = ensembleSet.getDeltaEnsembleArray().map((deltaEns) => {
+        const compareEnsemble: DeltaEnsembleElementItem = {
+            caseUuid: deltaEns.getCompareEnsembleIdent().getCaseUuid(),
+            ensembleName: deltaEns.getCompareEnsembleIdent().getEnsembleName(),
+        };
+        const referenceEnsemble: DeltaEnsembleElementItem = {
+            caseUuid: deltaEns.getReferenceEnsembleIdent().getCaseUuid(),
+            ensembleName: deltaEns.getReferenceEnsembleIdent().getEnsembleName(),
+        };
+
+        const deltaEnsembleItem: DeltaEnsembleItem = {
+            compareEnsemble: compareEnsemble,
+            referenceEnsemble: referenceEnsemble,
+            color: deltaEns.getColor(),
+            customName: deltaEns.getCustomName(),
+        };
+        return deltaEnsembleItem;
+    });
+    let fixedCreatedDeltaEnsembles = createdDeltaEnsembles;
+    if (loadingEnsembleSet) {
+        fixedCreatedDeltaEnsembles = newCreatedDeltaEnsembles;
+    }
+
     return (
         <div
             className={resolveClassNames(
@@ -172,7 +216,7 @@ export const LeftNavBar: React.FC<LeftNavBarProps> = (props) => {
                     onClick={handleEnsembleClick}
                     className="w-full !text-slate-800 h-10"
                     startIcon={
-                        selectedEnsembles.length === 0 && !loadingEnsembleSet ? (
+                        selectedEnsembles.length === 0 && createdDeltaEnsembles.length === 0 && !loadingEnsembleSet ? (
                             <List fontSize="small" className="w-5 h-5 mr-2" />
                         ) : (
                             <Badge
@@ -182,7 +226,7 @@ export const LeftNavBar: React.FC<LeftNavBarProps> = (props) => {
                                     loadingEnsembleSet ? (
                                         <CircularProgress size="extra-small" color="inherit" />
                                     ) : (
-                                        selectedEnsembles.length
+                                        selectedEnsembles.length + createdDeltaEnsembles.length
                                     )
                                 }
                             >
@@ -270,6 +314,7 @@ export const LeftNavBar: React.FC<LeftNavBarProps> = (props) => {
                 <SelectEnsemblesDialog
                     loadAndSetupEnsembles={loadAndSetupEnsembles}
                     selectedEnsembles={fixedSelectedEnsembles}
+                    createdDeltaEnsembles={fixedCreatedDeltaEnsembles}
                     onClose={handleEnsembleDialogClose}
                     colorSet={colorSet}
                 />
diff --git a/frontend/src/framework/internal/components/RightSettingsPanel/private-components/RealizationFilterSettings/realizationFilterSettings.tsx b/frontend/src/framework/internal/components/RightSettingsPanel/private-components/RealizationFilterSettings/realizationFilterSettings.tsx
index 5c2c0cfe1..abaf326e5 100644
--- a/frontend/src/framework/internal/components/RightSettingsPanel/private-components/RealizationFilterSettings/realizationFilterSettings.tsx
+++ b/frontend/src/framework/internal/components/RightSettingsPanel/private-components/RealizationFilterSettings/realizationFilterSettings.tsx
@@ -1,6 +1,6 @@
 import React from "react";
 
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
 import {
     GuiEvent,
     GuiEventPayloads,
@@ -9,6 +9,7 @@ import {
     useGuiState,
     useGuiValue,
 } from "@framework/GuiMessageBroker";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { Workbench } from "@framework/Workbench";
 import { useEnsembleSet } from "@framework/WorkbenchSession";
 import { Drawer } from "@framework/internal/components/Drawer";
@@ -36,7 +37,9 @@ export const RealizationFilterSettings: React.FC<RealizationFilterSettingsProps>
         GuiState.NumberOfUnsavedRealizationFilters
     );
 
-    const [activeFilterEnsembleIdent, setActiveFilterEnsembleIdent] = React.useState<EnsembleIdent | null>(null);
+    const [activeFilterEnsembleIdent, setActiveFilterEnsembleIdent] = React.useState<
+        RegularEnsembleIdent | DeltaEnsembleIdent | null
+    >(null);
 
     // Maps for keeping track of unsaved changes and filter selections
     const [ensembleIdentStringHasUnsavedChangesMap, setEnsembleIdentStringHasUnsavedChangesMap] = React.useState<{
@@ -55,7 +58,7 @@ export const RealizationFilterSettings: React.FC<RealizationFilterSettingsProps>
     }
 
     // Create new maps if ensembles are added or removed
-    const ensembleIdentStrings = ensembleSet.getEnsembleArr().map((ensemble) => ensemble.getIdent().toString());
+    const ensembleIdentStrings = ensembleSet.getEnsembleArray().map((ensemble) => ensemble.getIdent().toString());
     if (!isEqual(ensembleIdentStrings, Object.keys(ensembleIdentStringToRealizationFilterSelectionsMap))) {
         // Create new maps with the new ensemble ident strings
         const updatedHasUnsavedChangesMap: { [ensembleIdentString: string]: boolean } = {
@@ -79,7 +82,11 @@ export const RealizationFilterSettings: React.FC<RealizationFilterSettingsProps>
                 continue;
             }
 
-            const ensembleIdent = EnsembleIdent.fromString(ensembleIdentString);
+            const ensembleIdent = getEnsembleIdentFromString(ensembleIdentString);
+            if (!ensembleIdent) {
+                throw new Error(`Invalid ensemble ident: ${ensembleIdentString}`);
+            }
+
             const realizationFilter = realizationFilterSet.getRealizationFilterForEnsembleIdent(ensembleIdent);
 
             updatedHasUnsavedChangesMap[ensembleIdentString] = false;
@@ -102,7 +109,11 @@ export const RealizationFilterSettings: React.FC<RealizationFilterSettingsProps>
             // Apply all the unsaved changes state and reset the unsaved changes state
             const resetHasUnsavedChangesMap: { [ensembleIdentString: string]: boolean } = {};
             for (const ensembleIdentString in ensembleIdentStringToRealizationFilterSelectionsMap) {
-                const ensembleIdent = EnsembleIdent.fromString(ensembleIdentString);
+                const ensembleIdent = getEnsembleIdentFromString(ensembleIdentString);
+                if (!ensembleIdent) {
+                    throw new Error(`Invalid ensemble ident: ${ensembleIdentString}`);
+                }
+
                 const realizationFilter = realizationFilterSet.getRealizationFilterForEnsembleIdent(ensembleIdent);
                 const selections = ensembleIdentStringToRealizationFilterSelectionsMap[ensembleIdent.toString()];
 
@@ -123,11 +134,15 @@ export const RealizationFilterSettings: React.FC<RealizationFilterSettingsProps>
 
             setEnsembleIdentStringHasUnsavedChangesMap(resetHasUnsavedChangesMap);
             setNumberOfUnsavedRealizationFilters(0);
+
+            // Notify subscribers of change.
+            props.workbench.getWorkbenchSession().notifyAboutEnsembleRealizationFilterChange();
         },
         [
             ensembleIdentStringToRealizationFilterSelectionsMap,
             realizationFilterSet,
             setNumberOfUnsavedRealizationFilters,
+            props.workbench,
         ]
     );
 
@@ -137,7 +152,11 @@ export const RealizationFilterSettings: React.FC<RealizationFilterSettingsProps>
             const resetSelectionsMap: { [ensembleIdentString: string]: EnsembleRealizationFilterSelections } = {};
             const resetHasUnsavedChangesMap: { [ensembleIdentString: string]: boolean } = {};
             for (const ensembleIdentString in ensembleIdentStringToRealizationFilterSelectionsMap) {
-                const ensembleIdent = EnsembleIdent.fromString(ensembleIdentString);
+                const ensembleIdent = getEnsembleIdentFromString(ensembleIdentString);
+                if (!ensembleIdent) {
+                    throw new Error(`Invalid ensemble ident: ${ensembleIdentString}`);
+                }
+
                 const realizationFilter = realizationFilterSet.getRealizationFilterForEnsembleIdent(ensembleIdent);
 
                 resetSelectionsMap[ensembleIdentString] = {
@@ -189,7 +208,7 @@ export const RealizationFilterSettings: React.FC<RealizationFilterSettingsProps>
         props.onClose();
     }
 
-    function handleApplyClick(ensembleIdent: EnsembleIdent) {
+    function handleApplyClick(ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent) {
         const ensembleIdentString = ensembleIdent.toString();
         const realizationFilter = realizationFilterSet.getRealizationFilterForEnsembleIdent(ensembleIdent);
         const selections = ensembleIdentStringToRealizationFilterSelectionsMap[ensembleIdentString];
@@ -214,7 +233,7 @@ export const RealizationFilterSettings: React.FC<RealizationFilterSettingsProps>
         props.workbench.getWorkbenchSession().notifyAboutEnsembleRealizationFilterChange();
     }
 
-    function handleDiscardClick(ensembleIdent: EnsembleIdent) {
+    function handleDiscardClick(ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent) {
         const ensembleIdentString = ensembleIdent.toString();
         const realizationFilter = realizationFilterSet.getRealizationFilterForEnsembleIdent(ensembleIdent);
         setEnsembleIdentStringToRealizationFilterSelectionsMap({
@@ -235,7 +254,10 @@ export const RealizationFilterSettings: React.FC<RealizationFilterSettingsProps>
         setNumberOfUnsavedRealizationFilters(countTrueValues(newHasUnsavedChangesMap));
     }
 
-    function handleFilterChange(ensembleIdent: EnsembleIdent, selections: EnsembleRealizationFilterSelections) {
+    function handleFilterChange(
+        ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent,
+        selections: EnsembleRealizationFilterSelections
+    ) {
         const ensembleIdentString = ensembleIdent.toString();
 
         // Register the filter changes in the map
@@ -264,11 +286,11 @@ export const RealizationFilterSettings: React.FC<RealizationFilterSettingsProps>
         setNumberOfUnsavedRealizationFilters(countTrueValues(newHasUnsavedChangesMap));
     }
 
-    function handleSetActiveEnsembleRealizationFilter(ensembleIdent: EnsembleIdent) {
+    function handleSetActiveEnsembleRealizationFilter(ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent) {
         setActiveFilterEnsembleIdent(ensembleIdent);
     }
 
-    function handleOnEnsembleRealizationFilterHeaderClick(ensembleIdent: EnsembleIdent) {
+    function handleOnEnsembleRealizationFilterHeaderClick(ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent) {
         if (activeFilterEnsembleIdent?.equals(ensembleIdent)) {
             setActiveFilterEnsembleIdent(null);
         }
@@ -284,7 +306,7 @@ export const RealizationFilterSettings: React.FC<RealizationFilterSettingsProps>
             >
                 <div className="flex flex-col p-2 gap-4 overflow-y-auto">
                     <div className="flex-grow space-y-4">
-                        {ensembleSet.getEnsembleArr().map((ensemble) => {
+                        {ensembleSet.getEnsembleArray().map((ensemble) => {
                             const ensembleIdent = ensemble.getIdent();
                             const isActive =
                                 activeFilterEnsembleIdent !== null && activeFilterEnsembleIdent.equals(ensembleIdent);
@@ -322,3 +344,21 @@ export const RealizationFilterSettings: React.FC<RealizationFilterSettingsProps>
         </div>
     );
 };
+
+/**
+ * Get ensemble ident from string
+ * @param ensembleIdentString
+ * @returns RegularEnsembleIdent | DeltaEnsembleIdent | null
+ */
+export function getEnsembleIdentFromString(
+    ensembleIdentString: string
+): RegularEnsembleIdent | DeltaEnsembleIdent | null {
+    let ensembleIdent = null;
+    if (RegularEnsembleIdent.isValidEnsembleIdentString(ensembleIdentString)) {
+        ensembleIdent = RegularEnsembleIdent.fromString(ensembleIdentString);
+    } else if (DeltaEnsembleIdent.isValidEnsembleIdentString(ensembleIdentString)) {
+        ensembleIdent = DeltaEnsembleIdent.fromString(ensembleIdentString);
+    }
+
+    return ensembleIdent;
+}
diff --git a/frontend/src/framework/internal/components/SelectEnsemblesDialog/selectEnsemblesDialog.tsx b/frontend/src/framework/internal/components/SelectEnsemblesDialog/selectEnsemblesDialog.tsx
index 2abc7a2f0..dd43e7b33 100644
--- a/frontend/src/framework/internal/components/SelectEnsemblesDialog/selectEnsemblesDialog.tsx
+++ b/frontend/src/framework/internal/components/SelectEnsemblesDialog/selectEnsemblesDialog.tsx
@@ -17,15 +17,41 @@ import { Switch } from "@lib/components/Switch";
 import { TableSelect, TableSelectOption } from "@lib/components/TableSelect";
 import { useValidState } from "@lib/hooks/useValidState";
 import { ColorSet } from "@lib/utils/ColorSet";
-import { Add, Check, Remove } from "@mui/icons-material";
+import { resolveClassNames } from "@lib/utils/resolveClassNames";
+import { Add, Check, Info, Remove } from "@mui/icons-material";
 import { useQuery } from "@tanstack/react-query";
 
 import { isEqual } from "lodash";
+import { v4 } from "uuid";
 
 import { UserAvatar } from "./private-components/userAvatar";
 
 import { LoadingOverlay } from "../LoadingOverlay";
 
+const CASE_UUID_ENSEMBLE_NAME_SEPARATOR = "~@@~";
+
+// Ensemble element item for a delta ensemble
+export type DeltaEnsembleElementItem = {
+    caseUuid: string;
+    ensembleName: string;
+};
+
+// Internal type before applying created delta ensemble externally
+type InternalDeltaEnsembleItem = {
+    compareEnsemble: DeltaEnsembleElementItem | null; // Allows null
+    referenceEnsemble: DeltaEnsembleElementItem | null; // Allows null
+    uuid: string; // To allow for equal compare and reference ensembles during editing in the dialog
+    color: string;
+    customName: string | null;
+};
+
+export type DeltaEnsembleItem = {
+    compareEnsemble: DeltaEnsembleElementItem;
+    referenceEnsemble: DeltaEnsembleElementItem;
+    color: string;
+    customName: string | null;
+};
+
 export type EnsembleItem = {
     caseUuid: string;
     caseName: string;
@@ -35,9 +61,13 @@ export type EnsembleItem = {
 };
 
 export type SelectEnsemblesDialogProps = {
-    loadAndSetupEnsembles: (selectedEnsembles: EnsembleItem[]) => Promise<void>;
+    loadAndSetupEnsembles: (
+        selectedEnsembles: EnsembleItem[],
+        createdDeltaEnsembles: DeltaEnsembleItem[]
+    ) => Promise<void>;
     onClose: () => void;
     selectedEnsembles: EnsembleItem[];
+    createdDeltaEnsembles: DeltaEnsembleItem[];
     colorSet: ColorSet;
 };
 
@@ -72,12 +102,26 @@ export const SelectEnsemblesDialog: React.FC<SelectEnsemblesDialogProps> = (prop
         users: [],
     });
 
+    const [deltaEnsembles, setDeltaEnsembles] = React.useState<InternalDeltaEnsembleItem[]>([]);
+
     const { userInfo } = useAuthProvider();
 
     React.useLayoutEffect(() => {
         setNewlySelectedEnsembles(props.selectedEnsembles);
     }, [props.selectedEnsembles]);
 
+    React.useLayoutEffect(() => {
+        setDeltaEnsembles(
+            props.createdDeltaEnsembles.map((elm) => ({
+                compareEnsemble: elm.compareEnsemble,
+                referenceEnsemble: elm.referenceEnsemble,
+                uuid: v4(),
+                color: elm.color,
+                customName: elm.customName,
+            }))
+        );
+    }, [props.createdDeltaEnsembles]);
+
     const fieldsQuery = useQuery({
         queryKey: ["getFields"],
         queryFn: () => {
@@ -143,28 +187,117 @@ export const SelectEnsemblesDialog: React.FC<SelectEnsemblesDialogProps> = (prop
     }
 
     function checkIfEnsembleAlreadySelected(): boolean {
-        if (selectedCaseId && selectedEnsembleName) {
-            if (
-                newlySelectedEnsembles.some(
-                    (e) => e.caseUuid === selectedCaseId && e.ensembleName === selectedEnsembleName
-                )
-            ) {
-                return true;
-            }
+        if (
+            !selectedCaseId ||
+            !selectedEnsembleName ||
+            !newlySelectedEnsembles.some(
+                (e) => e.caseUuid === selectedCaseId && e.ensembleName === selectedEnsembleName
+            )
+        ) {
+            return false;
         }
-        return false;
+        return true;
     }
 
     function tryToFindUnusedColor(): string {
-        const usedColors = newlySelectedEnsembles.map((e) => e.color);
+        const usedColors = [...newlySelectedEnsembles.map((e) => e.color), ...deltaEnsembles.map((e) => e.color)];
         for (let i = 0; i < props.colorSet.getColorArray().length; i++) {
-            if (!usedColors.includes(props.colorSet.getColor(i))) {
-                return props.colorSet.getColor(i);
+            const candidateColor = props.colorSet.getColor(i);
+            if (!usedColors.includes(candidateColor)) {
+                return candidateColor;
             }
         }
         return props.colorSet.getColor(newlySelectedEnsembles.length);
     }
 
+    function handleDeltaEnsembleCompareEnsembleChange(
+        deltaEnsembleUuid: string,
+        newCaseUuidAndEnsembleNameString: string
+    ) {
+        const { caseUuid: newCompareEnsembleCaseUuid, ensembleName: newCompareEnsembleEnsembleName } =
+            createCaseUuidAndEnsembleNameFromString(newCaseUuidAndEnsembleNameString);
+
+        const compareEnsemble = newlySelectedEnsembles.find(
+            (elm) => elm.caseUuid === newCompareEnsembleCaseUuid && elm.ensembleName === newCompareEnsembleEnsembleName
+        );
+        if (!compareEnsemble) {
+            return;
+        }
+
+        setDeltaEnsembles((prev) =>
+            prev.map((elm) => {
+                if (elm.uuid === deltaEnsembleUuid) {
+                    const newCompareEnsemble: DeltaEnsembleElementItem = {
+                        caseUuid: compareEnsemble.caseUuid,
+                        ensembleName: compareEnsemble.ensembleName,
+                    };
+                    return {
+                        ...elm,
+                        compareEnsemble: newCompareEnsemble,
+                    };
+                }
+                return elm;
+            })
+        );
+    }
+
+    function handleDeltaEnsembleReferenceEnsembleChange(
+        deltaEnsembleUuid: string,
+        newCaseUuidAndEnsembleNameString: string
+    ) {
+        const { caseUuid: newReferenceEnsembleCaseUuid, ensembleName: newReferenceEnsembleEnsembleName } =
+            createCaseUuidAndEnsembleNameFromString(newCaseUuidAndEnsembleNameString);
+
+        const referenceEnsemble = newlySelectedEnsembles.find(
+            (e) => e.caseUuid === newReferenceEnsembleCaseUuid && e.ensembleName === newReferenceEnsembleEnsembleName
+        );
+        if (!referenceEnsemble) {
+            return;
+        }
+
+        setDeltaEnsembles((prev) =>
+            prev.map((elm) => {
+                if (elm.uuid === deltaEnsembleUuid) {
+                    const newReferenceEnsemble: DeltaEnsembleElementItem = {
+                        caseUuid: referenceEnsemble.caseUuid,
+                        ensembleName: referenceEnsemble.ensembleName,
+                    };
+                    return {
+                        ...elm,
+                        referenceEnsemble: newReferenceEnsemble,
+                    };
+                }
+                return elm;
+            })
+        );
+    }
+
+    function handleAddDeltaEnsemble() {
+        if (newlySelectedEnsembles.length === 0) {
+            return;
+        }
+
+        const compareEnsemble = newlySelectedEnsembles[0];
+        const referenceEnsemble =
+            newlySelectedEnsembles.length === 1 ? newlySelectedEnsembles[0] : newlySelectedEnsembles[1];
+
+        const newDeltaEnsemble: InternalDeltaEnsembleItem = {
+            compareEnsemble: {
+                caseUuid: compareEnsemble.caseUuid,
+                ensembleName: compareEnsemble.ensembleName,
+            },
+            referenceEnsemble: {
+                caseUuid: referenceEnsemble.caseUuid,
+                ensembleName: referenceEnsemble.ensembleName,
+            },
+            uuid: v4(),
+            color: tryToFindUnusedColor(),
+            customName: null,
+        };
+
+        setDeltaEnsembles((prev) => [...prev, newDeltaEnsemble]);
+    }
+
     function handleAddEnsemble() {
         if (!checkIfEnsembleAlreadySelected()) {
             const caseName = casesQuery.data?.find((c) => c.uuid === selectedCaseId)?.name ?? "UNKNOWN";
@@ -181,10 +314,34 @@ export const SelectEnsemblesDialog: React.FC<SelectEnsemblesDialogProps> = (prop
         }
     }
 
+    function handleRemoveDeltaEnsemble(uuid: string) {
+        setDeltaEnsembles((prev) => [...prev.filter((e) => e.uuid !== uuid)]);
+    }
+
     function handleRemoveEnsemble(caseUuid: string, ensembleName: string) {
         setNewlySelectedEnsembles((prev) => [
             ...prev.filter((e) => e.caseUuid !== caseUuid || e.ensembleName !== ensembleName),
         ]);
+
+        // Validate delta ensembles
+        const newDeltaEnsembles = [...deltaEnsembles];
+        for (const elm of deltaEnsembles) {
+            if (
+                elm.compareEnsemble &&
+                elm.compareEnsemble.caseUuid === caseUuid &&
+                elm.compareEnsemble.ensembleName === ensembleName
+            ) {
+                elm.compareEnsemble = null;
+            }
+            if (
+                elm.referenceEnsemble &&
+                elm.referenceEnsemble.caseUuid === caseUuid &&
+                elm.referenceEnsemble.ensembleName === ensembleName
+            ) {
+                elm.referenceEnsemble = null;
+            }
+        }
+        setDeltaEnsembles(newDeltaEnsembles);
     }
 
     function handleClose() {
@@ -201,9 +358,38 @@ export const SelectEnsemblesDialog: React.FC<SelectEnsemblesDialogProps> = (prop
     }
 
     function handleApplyEnsembleSelection() {
+        if (deltaEnsembles.some((elm) => !elm.compareEnsemble || !elm.referenceEnsemble)) {
+            return;
+        }
+
+        const validDeltaEnsembles: DeltaEnsembleItem[] = [];
+        for (const deltaEnsemble of deltaEnsembles) {
+            if (!deltaEnsemble.compareEnsemble || !deltaEnsemble.referenceEnsemble) {
+                continue;
+            }
+
+            // Ensure no duplicate delta ensembles
+            if (
+                validDeltaEnsembles.some(
+                    (elm) =>
+                        isEqual(elm.compareEnsemble, deltaEnsemble.compareEnsemble) &&
+                        isEqual(elm.referenceEnsemble, deltaEnsemble.referenceEnsemble)
+                )
+            ) {
+                continue;
+            }
+
+            validDeltaEnsembles.push({
+                compareEnsemble: deltaEnsemble.compareEnsemble,
+                referenceEnsemble: deltaEnsemble.referenceEnsemble,
+                color: deltaEnsemble.color,
+                customName: deltaEnsemble.customName,
+            });
+        }
+
         setIsLoadingEnsembles(true);
         props
-            .loadAndSetupEnsembles(newlySelectedEnsembles)
+            .loadAndSetupEnsembles(newlySelectedEnsembles, validDeltaEnsembles)
             .then(() => {
                 handleClose();
             })
@@ -212,7 +398,43 @@ export const SelectEnsemblesDialog: React.FC<SelectEnsemblesDialogProps> = (prop
             });
     }
 
-    function checkIfAnyChanges(): boolean {
+    function hasAnyDeltaEnsemblesChanged(): boolean {
+        if (props.createdDeltaEnsembles.length !== deltaEnsembles.length) {
+            return true;
+        }
+
+        const isContentEqual = props.createdDeltaEnsembles.every((elm, idx) => {
+            const internalDeltaEnsemble = deltaEnsembles[idx];
+            return (
+                elm.color === internalDeltaEnsemble.color &&
+                elm.customName === internalDeltaEnsemble.customName &&
+                isEqual(elm.compareEnsemble, internalDeltaEnsemble.compareEnsemble) &&
+                isEqual(elm.referenceEnsemble, internalDeltaEnsemble.referenceEnsemble)
+            );
+        });
+        return !isContentEqual;
+    }
+
+    function areAnyDeltaEnsemblesInvalid(): boolean {
+        return deltaEnsembles.some((elm) => !elm.compareEnsemble || !elm.referenceEnsemble);
+    }
+
+    function hasDuplicateDeltaEnsembles(): boolean {
+        const uniqueDeltaEnsembles = new Set<string>();
+        for (const elm of deltaEnsembles) {
+            if (!elm.compareEnsemble || !elm.referenceEnsemble) {
+                continue;
+            }
+            const key = `${elm.compareEnsemble.caseUuid}~&&~${elm.compareEnsemble.ensembleName}~&&~${elm.referenceEnsemble.caseUuid}~&&~${elm.referenceEnsemble.ensembleName}`;
+            if (uniqueDeltaEnsembles.has(key)) {
+                return true;
+            }
+            uniqueDeltaEnsembles.add(key);
+        }
+        return false;
+    }
+
+    function hasAnyEnsembleChanged(): boolean {
         return !isEqual(props.selectedEnsembles, newlySelectedEnsembles);
     }
 
@@ -244,13 +466,35 @@ export const SelectEnsemblesDialog: React.FC<SelectEnsemblesDialogProps> = (prop
         return filteredCases;
     }
 
+    function handleDeltaEnsembleColorChange(uuid: string, color: string) {
+        setDeltaEnsembles((prev) =>
+            prev.map((elm) => {
+                if (elm.uuid === uuid) {
+                    return { ...elm, color: color };
+                }
+                return elm;
+            })
+        );
+    }
+
     function handleColorChange(caseUuid: string, ensembleName: string, color: string) {
         setNewlySelectedEnsembles((prev) =>
-            prev.map((e) => {
-                if (e.caseUuid === caseUuid && e.ensembleName === ensembleName) {
-                    return { ...e, color: color };
+            prev.map((elm) => {
+                if (elm.caseUuid === caseUuid && elm.ensembleName === ensembleName) {
+                    return { ...elm, color: color };
                 }
-                return e;
+                return elm;
+            })
+        );
+    }
+
+    function handleDeltaEnsembleCustomNameChange(uuid: string, customName: string) {
+        setDeltaEnsembles((prev) =>
+            prev.map((elm) => {
+                if (elm.uuid === uuid) {
+                    return { ...elm, customName: customName === "" ? null : customName };
+                }
+                return elm;
             })
         );
     }
@@ -297,22 +541,35 @@ export const SelectEnsemblesDialog: React.FC<SelectEnsemblesDialogProps> = (prop
                 modal
                 width={"75%"}
                 minWidth={800}
+                // minHeight={600}
+                height={"75"}
                 actions={
                     <div className="flex gap-4">
                         <Button
                             onClick={handleClose}
                             color="danger"
-                            disabled={!checkIfAnyChanges() || isLoadingEnsembles}
+                            disabled={
+                                isLoadingEnsembles ||
+                                areAnyDeltaEnsemblesInvalid() ||
+                                !(hasAnyEnsembleChanged() || hasAnyDeltaEnsemblesChanged())
+                            }
                         >
                             Discard changes
                         </Button>
-                        <Button
-                            onClick={handleApplyEnsembleSelection}
-                            disabled={!checkIfAnyChanges() || isLoadingEnsembles}
-                            startIcon={makeApplyButtonStartIcon()}
-                        >
-                            {isLoadingEnsembles ? "Loading ensembles..." : "Apply"}
-                        </Button>
+                        <div title={hasDuplicateDeltaEnsembles() ? "Duplicate Delta Ensembles (blue rows)" : ""}>
+                            <Button
+                                onClick={handleApplyEnsembleSelection}
+                                disabled={
+                                    isLoadingEnsembles ||
+                                    areAnyDeltaEnsemblesInvalid() ||
+                                    hasDuplicateDeltaEnsembles() ||
+                                    !(hasAnyEnsembleChanged() || hasAnyDeltaEnsemblesChanged())
+                                }
+                                startIcon={makeApplyButtonStartIcon()}
+                            >
+                                {isLoadingEnsembles ? "Loading ensembles..." : "Apply"}
+                            </Button>
+                        </div>
                     </div>
                 }
                 showCloseCross
@@ -399,102 +656,276 @@ export const SelectEnsemblesDialog: React.FC<SelectEnsemblesDialogProps> = (prop
                             </Button>
                         </div>
                     </div>
-                    <div className="flex flex-col flex-grow gap-4 p-4">
-                        <Label text="Selected Ensembles">
-                            <table className="w-full border border-collapse table-fixed text-sm">
-                                <thead>
-                                    <tr>
-                                        <th className="w-20 text-left p-2 bg-slate-300">Color</th>
-                                        <th className="min-w-1/3 text-left p-2 bg-slate-300">Custom name</th>
-                                        <th className="min-w-1/3 text-left p-2 bg-slate-300">Case</th>
-                                        <th className="min-w-1/4 text-left p-2 bg-slate-300">Ensemble</th>
-                                        <th className="w-20 text-left p-2 bg-slate-300">Actions</th>
-                                    </tr>
-                                </thead>
-                                <tbody>
-                                    {newlySelectedEnsembles.map((item) => (
-                                        <tr
-                                            key={`${item.caseName}-${item.ensembleName}`}
-                                            className="hover:bg-slate-100 odd:bg-slate-50 align-center"
-                                        >
-                                            <td className="p-2">
-                                                <ColorSelect
-                                                    value={item.color}
-                                                    onChange={(value) =>
-                                                        handleColorChange(item.caseUuid, item.ensembleName, value)
-                                                    }
-                                                />
-                                            </td>
-                                            <td className="p-2">
-                                                <Input
-                                                    placeholder="Give a custom name..."
-                                                    defaultValue={item.customName ?? ""}
-                                                    onChange={(e: React.ChangeEvent<HTMLInputElement>) =>
-                                                        handleEnsembleCustomNameChange(
-                                                            item.caseUuid,
-                                                            item.ensembleName,
-                                                            e.target.value
-                                                        )
-                                                    }
-                                                />
-                                            </td>
-                                            <td className="p-2">
-                                                <div
-                                                    className="text-ellipsis overflow-hidden whitespace-nowrap"
-                                                    title={item.caseName}
-                                                >
-                                                    {item.caseName}
-                                                </div>
-                                            </td>
-                                            <td className="p-2">
-                                                <div
-                                                    className="text-ellipsis overflow-hidden whitespace-nowrap"
-                                                    title={item.ensembleName}
-                                                >
-                                                    {item.ensembleName}
-                                                </div>
-                                            </td>
-                                            <td className="p-2">
-                                                <IconButton
-                                                    onClick={() =>
-                                                        handleRemoveEnsemble(item.caseUuid, item.ensembleName)
-                                                    }
-                                                    color="danger"
-                                                    title="Remove ensemble from selection"
-                                                >
-                                                    <Remove fontSize="small" />
-                                                </IconButton>{" "}
-                                            </td>
+                    <div className="flex flex-col flex-grow max-h-full gap-4 p-4">
+                        <div className="flex-1 flex-col">
+                            <div className="flex-shrink">Selected Ensembles</div>
+                            <div className="flex-1 overflow-auto">
+                                <table className="w-full border border-collapse table-fixed text-sm">
+                                    <thead className="sticky top-0">
+                                        <tr>
+                                            <th className="w-20 text-left p-2 bg-slate-300">Color</th>
+                                            <th className="min-w-1/3 text-left p-2 bg-slate-300">Custom name</th>
+                                            <th className="min-w-1/3 text-left p-2 bg-slate-300">Case</th>
+                                            <th className="min-w-1/4 text-left p-2 bg-slate-300">Ensemble</th>
+                                            <th className="w-20 text-left p-2 bg-slate-300">Actions</th>
                                         </tr>
-                                    ))}
-                                </tbody>
-                            </table>
-                        </Label>
-                        {newlySelectedEnsembles.length === 0 && (
-                            <div className="text-gray-500">No ensembles selected.</div>
-                        )}
+                                    </thead>
+                                    <tbody>
+                                        {newlySelectedEnsembles.map((item) => (
+                                            <tr
+                                                key={`${item.caseName}-${item.ensembleName}`}
+                                                className="hover:bg-slate-100 odd:bg-slate-50 align-center"
+                                            >
+                                                <td className="p-2">
+                                                    <ColorSelect
+                                                        value={item.color}
+                                                        onChange={(value) =>
+                                                            handleColorChange(item.caseUuid, item.ensembleName, value)
+                                                        }
+                                                    />
+                                                </td>
+                                                <td className="p-2">
+                                                    <Input
+                                                        placeholder="Give a custom name..."
+                                                        defaultValue={item.customName ?? ""}
+                                                        onChange={(e: React.ChangeEvent<HTMLInputElement>) =>
+                                                            handleEnsembleCustomNameChange(
+                                                                item.caseUuid,
+                                                                item.ensembleName,
+                                                                e.target.value
+                                                            )
+                                                        }
+                                                    />
+                                                </td>
+                                                <td className="p-2">
+                                                    <div
+                                                        className="text-ellipsis overflow-hidden whitespace-nowrap"
+                                                        title={item.caseName}
+                                                    >
+                                                        {item.caseName}
+                                                    </div>
+                                                </td>
+                                                <td className="p-2">
+                                                    <div
+                                                        className="text-ellipsis overflow-hidden whitespace-nowrap"
+                                                        title={item.ensembleName}
+                                                    >
+                                                        {item.ensembleName}
+                                                    </div>
+                                                </td>
+                                                <td className="p-2">
+                                                    <IconButton
+                                                        onClick={() =>
+                                                            handleRemoveEnsemble(item.caseUuid, item.ensembleName)
+                                                        }
+                                                        color="danger"
+                                                        title="Remove ensemble from selection"
+                                                    >
+                                                        <Remove fontSize="small" />
+                                                    </IconButton>{" "}
+                                                </td>
+                                            </tr>
+                                        ))}
+                                    </tbody>
+                                </table>
+                            </div>
+                            {newlySelectedEnsembles.length === 0 && (
+                                <div className="text-gray-500">No ensembles selected.</div>
+                            )}
+                        </div>
+                        <div className="flex-1 flex-col">
+                            <div className="flex-shrink flex flex-row">
+                                <Info
+                                    fontSize="medium"
+                                    titleAccess={`Create delta ensemble using selected ensembles:\n\n"Delta Ensemble" = "Compare Ensemble" - "Reference Ensemble"`}
+                                    className={
+                                        "rounded-md px-0.25 py-0.25 border border-transparent text-white bg-indigo-600 hover:bg-indigo-700 cursor-help"
+                                    }
+                                />
+                                <div className="pl-2 pr-2">Delta Ensembles</div>
+                                <IconButton
+                                    title="New delta ensemble"
+                                    onClick={handleAddDeltaEnsemble}
+                                    disabled={newlySelectedEnsembles.length < 1}
+                                >
+                                    <Add />
+                                </IconButton>
+                            </div>
+                            <div className="flex-1 overflow-auto">
+                                <table className="w-full border border-collapse table-fixed text-sm">
+                                    <thead>
+                                        <tr>
+                                            <th className="w-20 text-left p-2 bg-slate-300">Color</th>
+                                            <th className="min-w-1/3 text-left p-2 bg-slate-300">Custom name</th>
+                                            <th className="min-w-1/3 text-left p-2 bg-slate-300">Compare Ensemble</th>
+                                            <th className="min-w-1/4 text-left p-2 bg-slate-300">Reference Ensemble</th>
+                                            <th className="w-20 text-left p-2 bg-slate-300">Actions</th>
+                                        </tr>
+                                    </thead>
+                                    <tbody className="overflow-y-auto w-full">
+                                        {deltaEnsembles.map((elm) => {
+                                            const isDeltaEnsembleValid =
+                                                elm.compareEnsemble !== null && elm.referenceEnsemble !== null;
+                                            const isDuplicateDeltaEnsemble =
+                                                deltaEnsembles.filter(
+                                                    (e) =>
+                                                        e.compareEnsemble?.caseUuid === elm.compareEnsemble?.caseUuid &&
+                                                        e.compareEnsemble?.ensembleName ===
+                                                            elm.compareEnsemble?.ensembleName &&
+                                                        e.referenceEnsemble?.caseUuid ===
+                                                            elm.referenceEnsemble?.caseUuid &&
+                                                        e.referenceEnsemble?.ensembleName ===
+                                                            elm.referenceEnsemble?.ensembleName
+                                                ).length > 1;
+                                            return (
+                                                <tr
+                                                    key={elm.uuid}
+                                                    className={resolveClassNames(
+                                                        "align-center ",
+
+                                                        {
+                                                            "hover:bg-red-50 odd:bg-red-200 even:bg-red-300":
+                                                                !isDeltaEnsembleValid,
+                                                            "hover:bg-blue-50 odd:bg-blue-200 even:bg-blue-300":
+                                                                isDeltaEnsembleValid && isDuplicateDeltaEnsemble,
+                                                            "hover:bg-slate-100 odd:bg-slate-50":
+                                                                isDeltaEnsembleValid && !isDuplicateDeltaEnsemble,
+                                                        }
+                                                    )}
+                                                >
+                                                    <td className="p-2">
+                                                        <ColorSelect
+                                                            value={elm.color}
+                                                            onChange={(value) =>
+                                                                handleDeltaEnsembleColorChange(elm.uuid, value)
+                                                            }
+                                                        />
+                                                    </td>
+                                                    <td className="p-2">
+                                                        <Input
+                                                            placeholder="Give a custom name..."
+                                                            defaultValue={elm.customName ?? ""}
+                                                            onChange={(e: React.ChangeEvent<HTMLInputElement>) =>
+                                                                handleDeltaEnsembleCustomNameChange(
+                                                                    elm.uuid,
+                                                                    e.target.value
+                                                                )
+                                                            }
+                                                        />
+                                                    </td>
+                                                    <td className="p-2">
+                                                        <Dropdown
+                                                            options={newlySelectedEnsembles.map((elm) => {
+                                                                return {
+                                                                    value: createCaseUuidAndEnsembleNameString(
+                                                                        elm.caseUuid,
+                                                                        elm.ensembleName
+                                                                    ),
+                                                                    label:
+                                                                        elm.customName ??
+                                                                        `${elm.ensembleName} (${elm.caseName})`,
+                                                                };
+                                                            })}
+                                                            value={
+                                                                elm.compareEnsemble
+                                                                    ? createCaseUuidAndEnsembleNameString(
+                                                                          elm.compareEnsemble.caseUuid,
+                                                                          elm.compareEnsemble.ensembleName
+                                                                      )
+                                                                    : undefined
+                                                            }
+                                                            onChange={(newCaseUuidAndEnsembleNameString) => {
+                                                                handleDeltaEnsembleCompareEnsembleChange(
+                                                                    elm.uuid,
+                                                                    newCaseUuidAndEnsembleNameString
+                                                                );
+                                                            }}
+                                                        />
+                                                    </td>
+                                                    <td className="p-2">
+                                                        <Dropdown
+                                                            options={newlySelectedEnsembles.map((elm) => {
+                                                                return {
+                                                                    value: createCaseUuidAndEnsembleNameString(
+                                                                        elm.caseUuid,
+                                                                        elm.ensembleName
+                                                                    ),
+                                                                    label:
+                                                                        elm.customName ??
+                                                                        `${elm.ensembleName} (${elm.caseName})`,
+                                                                };
+                                                            })}
+                                                            value={
+                                                                elm.referenceEnsemble
+                                                                    ? createCaseUuidAndEnsembleNameString(
+                                                                          elm.referenceEnsemble.caseUuid,
+                                                                          elm.referenceEnsemble.ensembleName
+                                                                      )
+                                                                    : undefined
+                                                            }
+                                                            onChange={(value) => {
+                                                                handleDeltaEnsembleReferenceEnsembleChange(
+                                                                    elm.uuid,
+                                                                    value
+                                                                );
+                                                            }}
+                                                        />
+                                                    </td>
+                                                    <td className="p-2">
+                                                        <IconButton
+                                                            onClick={() => handleRemoveDeltaEnsemble(elm.uuid)}
+                                                            color="danger"
+                                                            title="Remove delta ensemble from selection"
+                                                        >
+                                                            <Remove fontSize="small" />
+                                                        </IconButton>{" "}
+                                                    </td>
+                                                </tr>
+                                            );
+                                        })}
+                                    </tbody>
+                                </table>
+                            </div>
+                            {deltaEnsembles.length === 0 && (
+                                <div className="text-gray-500">No delta ensembles created.</div>
+                            )}
+                        </div>
                     </div>
                 </div>
                 {isLoadingEnsembles && <LoadingOverlay />}
             </Dialog>
-            {
-                <Dialog
-                    open={confirmCancel}
-                    onClose={() => setConfirmCancel(false)}
-                    title="Unsaved changes"
-                    modal
-                    actions={
-                        <div className="flex gap-4">
-                            <Button onClick={() => setConfirmCancel(false)}>No, don&apos;t cancel</Button>
-                            <Button onClick={handleClose} color="danger">
-                                Yes, cancel
-                            </Button>
-                        </div>
-                    }
-                >
-                    You have unsaved changes which will be lost. Are you sure you want to cancel?
-                </Dialog>
-            }
+            <Dialog
+                open={confirmCancel}
+                onClose={() => setConfirmCancel(false)}
+                title="Unsaved changes"
+                modal
+                actions={
+                    <div className="flex gap-4">
+                        <Button onClick={() => setConfirmCancel(false)}>No, don&apos;t cancel</Button>
+                        <Button onClick={handleClose} color="danger">
+                            Yes, cancel
+                        </Button>
+                    </div>
+                }
+            >
+                You have unsaved changes which will be lost. Are you sure you want to cancel?
+            </Dialog>
         </>
     );
 };
+
+function createCaseUuidAndEnsembleNameString(caseUuid: string, ensembleName: string): string {
+    return `${caseUuid}${CASE_UUID_ENSEMBLE_NAME_SEPARATOR}${ensembleName}`;
+}
+
+function createCaseUuidAndEnsembleNameFromString(caseUuidAndEnsembleNameString: string): {
+    caseUuid: string;
+    ensembleName: string;
+} {
+    const [caseUuid, ensembleName] = caseUuidAndEnsembleNameString.split(CASE_UUID_ENSEMBLE_NAME_SEPARATOR);
+    if (!caseUuid || !ensembleName) {
+        throw new Error("Invalid caseUuidAndEnsembleNameString");
+    }
+
+    return { caseUuid, ensembleName };
+}
diff --git a/frontend/src/framework/types/inplaceVolumetricsFilter.ts b/frontend/src/framework/types/inplaceVolumetricsFilter.ts
index bcb18b1f7..7a5c462c8 100644
--- a/frontend/src/framework/types/inplaceVolumetricsFilter.ts
+++ b/frontend/src/framework/types/inplaceVolumetricsFilter.ts
@@ -1,8 +1,8 @@
 import { FluidZone_api, InplaceVolumetricsIdentifierWithValues_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 
 export type InplaceVolumetricsFilter = {
-    ensembleIdents: EnsembleIdent[];
+    ensembleIdents: RegularEnsembleIdent[];
     tableNames: string[];
     fluidZones: FluidZone_api[];
     identifiersValues: InplaceVolumetricsIdentifierWithValues_api[];
diff --git a/frontend/src/framework/utils/ensembleIdentUtils.ts b/frontend/src/framework/utils/ensembleIdentUtils.ts
new file mode 100644
index 000000000..abb6963e4
--- /dev/null
+++ b/frontend/src/framework/utils/ensembleIdentUtils.ts
@@ -0,0 +1,68 @@
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
+
+/**
+ * Check if two ensemble idents are equal.
+ */
+export function areEnsembleIdentsEqual(
+    a: RegularEnsembleIdent | DeltaEnsembleIdent | null,
+    b: RegularEnsembleIdent | DeltaEnsembleIdent | null
+): boolean {
+    if (a === null) {
+        return b === null;
+    }
+    return a.equals(b);
+}
+
+/**
+ * Check if two lists of ensemble idents are equal.
+ */
+export function areEnsembleIdentListsEqual(
+    a: (RegularEnsembleIdent | DeltaEnsembleIdent)[],
+    b: (RegularEnsembleIdent | DeltaEnsembleIdent)[]
+): boolean {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (!a[i].equals(b[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * Check if provided EnsembleIdentInterface implementation is of specified type
+ */
+export function isEnsembleIdentOfType<T extends RegularEnsembleIdent | DeltaEnsembleIdent>(
+    ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent,
+    type: new (...args: any[]) => T
+): ensembleIdent is T {
+    return ensembleIdent instanceof type;
+}
+
+/**
+ * Creates a new array of ensemble idents only containing the specified type.
+ *
+ * A list of classes implementing EnsembleIdentInterface, and a type are passed as arguments.
+ *
+ * @param ensembleIdents - List of implemented classes of EnsembleIdentInterface
+ * @param type - The type of the ensemble idents to filter
+ * @returns A new array of ensemble idents that are of the specified type
+ */
+export function filterEnsembleIdentsByType<T extends RegularEnsembleIdent | DeltaEnsembleIdent>(
+    ensembleIdents: (RegularEnsembleIdent | DeltaEnsembleIdent)[],
+    type: new (...args: any[]) => T
+): T[] {
+    return ensembleIdents.filter((ensembleIdent) => isEnsembleIdentOfType(ensembleIdent, type)) as T[];
+}
+
+/**
+ * Generates a regex pattern for a UUID.
+ *
+ * @returns A string that represents a regex pattern for a UUID
+ */
+export function ensembleIdentUuidRegexString(): string {
+    return "[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12}";
+}
diff --git a/frontend/src/framework/utils/ensembleUiHelpers.ts b/frontend/src/framework/utils/ensembleUiHelpers.ts
index 850e2d477..3fe6247b4 100644
--- a/frontend/src/framework/utils/ensembleUiHelpers.ts
+++ b/frontend/src/framework/utils/ensembleUiHelpers.ts
@@ -1,10 +1,11 @@
-import { EnsembleIdent } from "../EnsembleIdent";
+import { DeltaEnsembleIdent } from "../DeltaEnsembleIdent";
 import { EnsembleSet } from "../EnsembleSet";
+import { RegularEnsembleIdent } from "../RegularEnsembleIdent";
 
 export function maybeAssignFirstSyncedEnsemble(
-    currIdent: EnsembleIdent | null,
-    syncedEnsembleValues: EnsembleIdent[] | null
-): EnsembleIdent | null {
+    currIdent: RegularEnsembleIdent | null,
+    syncedEnsembleValues: RegularEnsembleIdent[] | null
+): RegularEnsembleIdent | null {
     if (!syncedEnsembleValues || syncedEnsembleValues.length < 1) {
         return currIdent;
     }
@@ -18,52 +19,101 @@ export function maybeAssignFirstSyncedEnsemble(
 }
 
 /**
- * Validates the the EnsembleIdent specified in currIdent against the contents of the
- * EnsembleSet and fixes the value if it isn't valid.
+ * Validates the the RegularEnsembleIdent or DeltaEnsembleIdent specified in currIdent against the
+ * contents of the EnsembleSet and fixes the value if it isn't valid.
  *
  * Returns null if an empty EnsembleSet is specified.
  *
- * Note that if the specified EnsembleIdent is valid, this function will always return
- * a reference to the exact same object that was passed in currIdent. This means that
- * you can compare the references (fixedIdent !== currIdent) to detect any changes.
+ * Note that if the specified RegularEnsembleIdents and DeltaEnsembleIdents are valid, this function
+ * will always return a reference to the exact same object that was passed in currIdent. This
+ * means that you can compare the references (fixedIdent !== currIdent) to detect any changes.
  */
 export function fixupEnsembleIdent(
-    currIdent: EnsembleIdent | null,
+    currIdent: RegularEnsembleIdent | DeltaEnsembleIdent | null,
     ensembleSet: EnsembleSet | null
-): EnsembleIdent | null {
+): RegularEnsembleIdent | DeltaEnsembleIdent | null {
     if (!ensembleSet?.hasAnyEnsembles()) {
         return null;
     }
 
-    if (currIdent) {
-        if (ensembleSet.hasEnsemble(currIdent)) {
-            return currIdent;
-        }
+    if (currIdent && ensembleSet.hasEnsemble(currIdent)) {
+        return currIdent;
     }
 
-    return ensembleSet.getEnsembleArr()[0].getIdent();
+    return ensembleSet.getEnsembleArray()[0].getIdent();
 }
 
 /**
- * Validates the the EnsembleIdents specified in currIdents against the contents of the
+ * Validates the the RegularEnsembleIdent specified in currIdent against the contents of the
  * EnsembleSet and fixes the value if it isn't valid.
  *
+ * Returns null if specified EnsembleSet does not contain any regular ensembles.
+ *
+ * Note that if the specified RegularEnsembleIdents is valid, this function will always return
+ * a reference to the exact same object that was passed in currIdent. This means that you can
+ * compare the references (fixedIdent !== currIdent) to detect any changes.
+ */
+export function fixupRegularEnsembleIdent(
+    currIdent: RegularEnsembleIdent | null,
+    ensembleSet: EnsembleSet | null
+): RegularEnsembleIdent | null {
+    if (!ensembleSet?.hasAnyRegularEnsembles()) {
+        return null;
+    }
+
+    if (currIdent && ensembleSet.hasEnsemble(currIdent)) {
+        return currIdent;
+    }
+
+    return ensembleSet.getRegularEnsembleArray()[0].getIdent();
+}
+
+/**
+ * Validates the the RegularEnsembleIdents or DeltaEnsembleIdents specified in currIdents
+ * against the contents of the EnsembleSet and fixes the value if it isn't valid.
+ *
  * Returns null if an empty EnsembleSet is specified.
  *
- * Note that if the specified EnsembleIdents are valid, this function will always return
- * a reference to the exact same object that was passed in currIdent. This means that
- * you can compare the references (fixedIdent !== currIdent) to detect any changes.
+ * Note that if the specified RegularEnsembleIdents and DeltaEnsembleIdents are valid, this
+ * function will always return a reference to the exact same object that was passed in
+ * currIdent. This means that you can compare the references (fixedIdent !== currIdent) to
+ * detect any changes.
  */
 export function fixupEnsembleIdents(
-    currIdents: EnsembleIdent[] | null,
+    currIdents: (RegularEnsembleIdent | DeltaEnsembleIdent)[] | null,
     ensembleSet: EnsembleSet | null
-): EnsembleIdent[] | null {
+): (RegularEnsembleIdent | DeltaEnsembleIdent)[] | null {
     if (!ensembleSet?.hasAnyEnsembles()) {
         return null;
     }
 
     if (currIdents === null || currIdents.length === 0) {
-        return [ensembleSet.getEnsembleArr()[0].getIdent()];
+        return [ensembleSet.getEnsembleArray()[0].getIdent()];
+    }
+
+    return currIdents.filter((currIdent) => ensembleSet.hasEnsemble(currIdent));
+}
+
+/**
+ * Validates the the RegularEnsembleIdents specified in currIdents against the contents of the
+ * EnsembleSet and fixes the value if it isn't valid.
+ *
+ * Returns null if an empty EnsembleSet is specified.
+ *
+ * Note that if the specified RegularEnsembleIdents are valid, this function will always return
+ * a reference to the exact same object that was passed in currIdent. This means that you can
+ * compare the references (fixedIdent !== currIdent) to detect any changes.
+ */
+export function fixupRegularEnsembleIdents(
+    currIdents: RegularEnsembleIdent[] | null,
+    ensembleSet: EnsembleSet | null
+): RegularEnsembleIdent[] | null {
+    if (!ensembleSet?.hasAnyRegularEnsembles()) {
+        return null;
+    }
+
+    if (currIdents === null || currIdents.length === 0) {
+        return [ensembleSet.getRegularEnsembleArray()[0].getIdent()];
     }
 
     return currIdents.filter((currIdent) => ensembleSet.hasEnsemble(currIdent));
diff --git a/frontend/src/modules/2DViewer/layers/framework/LayerManager/LayerManager.ts b/frontend/src/modules/2DViewer/layers/framework/LayerManager/LayerManager.ts
index 98208330a..e4aaed2a9 100644
--- a/frontend/src/modules/2DViewer/layers/framework/LayerManager/LayerManager.ts
+++ b/frontend/src/modules/2DViewer/layers/framework/LayerManager/LayerManager.ts
@@ -1,4 +1,4 @@
-import { Ensemble } from "@framework/Ensemble";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
 import {
     EnsembleRealizationFilterFunction,
     WorkbenchSession,
@@ -36,7 +36,7 @@ export type LayerManagerTopicPayload = {
 
 export type GlobalSettings = {
     fieldId: string | null;
-    ensembles: readonly Ensemble[];
+    ensembles: readonly RegularEnsemble[];
     realizationFilterFunction: EnsembleRealizationFilterFunction;
 };
 
@@ -194,7 +194,7 @@ export class LayerManager implements Group, PublishSubscribe<LayerManagerTopic,
     }
 
     private initializeGlobalSettings(): GlobalSettings {
-        const ensembles = this._workbenchSession.getEnsembleSet().getEnsembleArr();
+        const ensembles = this._workbenchSession.getEnsembleSet().getRegularEnsembleArray();
         return {
             fieldId: null,
             ensembles,
@@ -211,7 +211,7 @@ export class LayerManager implements Group, PublishSubscribe<LayerManagerTopic,
     }
 
     private handleEnsembleSetChanged() {
-        const ensembles = this._workbenchSession.getEnsembleSet().getEnsembleArr();
+        const ensembles = this._workbenchSession.getEnsembleSet().getRegularEnsembleArray();
         this._globalSettings.ensembles = ensembles;
 
         this.publishTopic(LayerManagerTopic.GLOBAL_SETTINGS_CHANGED);
diff --git a/frontend/src/modules/2DViewer/layers/layers/implementations/DrilledWellTrajectoriesLayer/types.ts b/frontend/src/modules/2DViewer/layers/layers/implementations/DrilledWellTrajectoriesLayer/types.ts
index b8423380e..622455439 100644
--- a/frontend/src/modules/2DViewer/layers/layers/implementations/DrilledWellTrajectoriesLayer/types.ts
+++ b/frontend/src/modules/2DViewer/layers/layers/implementations/DrilledWellTrajectoriesLayer/types.ts
@@ -1,8 +1,8 @@
 import { WellboreHeader_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { SettingType } from "@modules/2DViewer/layers/settings/settingsTypes";
 
 export type DrilledWellTrajectoriesSettings = {
-    [SettingType.ENSEMBLE]: EnsembleIdent | null;
+    [SettingType.ENSEMBLE]: RegularEnsembleIdent | null;
     [SettingType.SMDA_WELLBORE_HEADERS]: WellboreHeader_api[] | null;
 };
diff --git a/frontend/src/modules/2DViewer/layers/layers/implementations/DrilledWellborePicksLayer/types.ts b/frontend/src/modules/2DViewer/layers/layers/implementations/DrilledWellborePicksLayer/types.ts
index 1796ddad5..d98579004 100644
--- a/frontend/src/modules/2DViewer/layers/layers/implementations/DrilledWellborePicksLayer/types.ts
+++ b/frontend/src/modules/2DViewer/layers/layers/implementations/DrilledWellborePicksLayer/types.ts
@@ -1,9 +1,9 @@
 import { WellboreHeader_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { SettingType } from "@modules/2DViewer/layers/settings/settingsTypes";
 
 export type DrilledWellborePicksSettings = {
-    [SettingType.ENSEMBLE]: EnsembleIdent | null;
+    [SettingType.ENSEMBLE]: RegularEnsembleIdent | null;
     [SettingType.SMDA_WELLBORE_HEADERS]: WellboreHeader_api[] | null;
     [SettingType.SURFACE_NAME]: string | null;
 };
diff --git a/frontend/src/modules/2DViewer/layers/layers/implementations/ObservedSurfaceLayer/ObservedSurfaceSettingsContext.ts b/frontend/src/modules/2DViewer/layers/layers/implementations/ObservedSurfaceLayer/ObservedSurfaceSettingsContext.ts
index 7ea07106a..088fe81fd 100644
--- a/frontend/src/modules/2DViewer/layers/layers/implementations/ObservedSurfaceLayer/ObservedSurfaceSettingsContext.ts
+++ b/frontend/src/modules/2DViewer/layers/layers/implementations/ObservedSurfaceLayer/ObservedSurfaceSettingsContext.ts
@@ -48,7 +48,7 @@ export class ObservedSurfaceSettingsContext implements SettingsContext<ObservedS
             const ensembleSet = workbenchSession.getEnsembleSet();
 
             const ensembleIdents = ensembleSet
-                .getEnsembleArr()
+                .getRegularEnsembleArray()
                 .filter((ensemble) => ensemble.getFieldIdentifier() === fieldIdentifier)
                 .map((ensemble) => ensemble.getIdent());
 
diff --git a/frontend/src/modules/2DViewer/layers/layers/implementations/ObservedSurfaceLayer/types.ts b/frontend/src/modules/2DViewer/layers/layers/implementations/ObservedSurfaceLayer/types.ts
index a4bc063f3..d89905be3 100644
--- a/frontend/src/modules/2DViewer/layers/layers/implementations/ObservedSurfaceLayer/types.ts
+++ b/frontend/src/modules/2DViewer/layers/layers/implementations/ObservedSurfaceLayer/types.ts
@@ -1,8 +1,8 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { SettingType } from "@modules/2DViewer/layers/settings/settingsTypes";
 
 export type ObservedSurfaceSettings = {
-    [SettingType.ENSEMBLE]: EnsembleIdent | null;
+    [SettingType.ENSEMBLE]: RegularEnsembleIdent | null;
     [SettingType.SURFACE_ATTRIBUTE]: string | null;
     [SettingType.SURFACE_NAME]: string | null;
     [SettingType.TIME_OR_INTERVAL]: string | null;
diff --git a/frontend/src/modules/2DViewer/layers/layers/implementations/RealizationGridLayer/types.ts b/frontend/src/modules/2DViewer/layers/layers/implementations/RealizationGridLayer/types.ts
index 2ac9df1c2..a746e527c 100644
--- a/frontend/src/modules/2DViewer/layers/layers/implementations/RealizationGridLayer/types.ts
+++ b/frontend/src/modules/2DViewer/layers/layers/implementations/RealizationGridLayer/types.ts
@@ -1,8 +1,8 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { SettingType } from "@modules/2DViewer/layers/settings/settingsTypes";
 
 export type RealizationGridSettings = {
-    [SettingType.ENSEMBLE]: EnsembleIdent | null;
+    [SettingType.ENSEMBLE]: RegularEnsembleIdent | null;
     [SettingType.REALIZATION]: number | null;
     [SettingType.GRID_ATTRIBUTE]: string | null;
     [SettingType.GRID_NAME]: string | null;
diff --git a/frontend/src/modules/2DViewer/layers/layers/implementations/RealizationPolygonsLayer/types.ts b/frontend/src/modules/2DViewer/layers/layers/implementations/RealizationPolygonsLayer/types.ts
index 1b79a705b..5535d6772 100644
--- a/frontend/src/modules/2DViewer/layers/layers/implementations/RealizationPolygonsLayer/types.ts
+++ b/frontend/src/modules/2DViewer/layers/layers/implementations/RealizationPolygonsLayer/types.ts
@@ -1,9 +1,9 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 
 import { SettingType } from "../../../settings/settingsTypes";
 
 export type RealizationPolygonsSettings = {
-    [SettingType.ENSEMBLE]: EnsembleIdent | null;
+    [SettingType.ENSEMBLE]: RegularEnsembleIdent | null;
     [SettingType.REALIZATION]: number | null;
     [SettingType.POLYGONS_ATTRIBUTE]: string | null;
     [SettingType.POLYGONS_NAME]: string | null;
diff --git a/frontend/src/modules/2DViewer/layers/layers/implementations/RealizationSurfaceLayer/types.ts b/frontend/src/modules/2DViewer/layers/layers/implementations/RealizationSurfaceLayer/types.ts
index 6477cdcc6..d1d1bfed8 100644
--- a/frontend/src/modules/2DViewer/layers/layers/implementations/RealizationSurfaceLayer/types.ts
+++ b/frontend/src/modules/2DViewer/layers/layers/implementations/RealizationSurfaceLayer/types.ts
@@ -1,9 +1,9 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 
 import { SettingType } from "../../../settings/settingsTypes";
 
 export type RealizationSurfaceSettings = {
-    [SettingType.ENSEMBLE]: EnsembleIdent | null;
+    [SettingType.ENSEMBLE]: RegularEnsembleIdent | null;
     [SettingType.REALIZATION]: number | null;
     [SettingType.SURFACE_ATTRIBUTE]: string | null;
     [SettingType.SURFACE_NAME]: string | null;
diff --git a/frontend/src/modules/2DViewer/layers/layers/implementations/StatisticalSurfaceLayer/types.ts b/frontend/src/modules/2DViewer/layers/layers/implementations/StatisticalSurfaceLayer/types.ts
index 639fc8253..adb0a2aa7 100644
--- a/frontend/src/modules/2DViewer/layers/layers/implementations/StatisticalSurfaceLayer/types.ts
+++ b/frontend/src/modules/2DViewer/layers/layers/implementations/StatisticalSurfaceLayer/types.ts
@@ -1,11 +1,11 @@
 import { SurfaceStatisticFunction_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { SettingType } from "@modules/2DViewer/layers/settings/settingsTypes";
 
 import { SensitivityNameCasePair } from "../../../settings/implementations/SensitivitySetting";
 
 export type StatisticalSurfaceSettings = {
-    [SettingType.ENSEMBLE]: EnsembleIdent | null;
+    [SettingType.ENSEMBLE]: RegularEnsembleIdent | null;
     [SettingType.STATISTIC_FUNCTION]: SurfaceStatisticFunction_api;
     [SettingType.SENSITIVITY]: SensitivityNameCasePair | null;
     [SettingType.SURFACE_ATTRIBUTE]: string | null;
diff --git a/frontend/src/modules/2DViewer/layers/settings/implementations/EnsembleSetting.tsx b/frontend/src/modules/2DViewer/layers/settings/implementations/EnsembleSetting.tsx
index de7eeb630..49172a50a 100644
--- a/frontend/src/modules/2DViewer/layers/settings/implementations/EnsembleSetting.tsx
+++ b/frontend/src/modules/2DViewer/layers/settings/implementations/EnsembleSetting.tsx
@@ -1,6 +1,6 @@
 import React from "react";
 
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { EnsembleDropdown } from "@framework/components/EnsembleDropdown";
 
 import { SettingDelegate } from "../../delegates/SettingDelegate";
@@ -8,11 +8,11 @@ import { Setting, SettingComponentProps, ValueToStringArgs } from "../../interfa
 import { SettingRegistry } from "../SettingRegistry";
 import { SettingType } from "../settingsTypes";
 
-export class EnsembleSetting implements Setting<EnsembleIdent | null> {
-    private _delegate: SettingDelegate<EnsembleIdent | null>;
+export class EnsembleSetting implements Setting<RegularEnsembleIdent | null> {
+    private _delegate: SettingDelegate<RegularEnsembleIdent | null>;
 
     constructor() {
-        this._delegate = new SettingDelegate<EnsembleIdent | null>(null, this);
+        this._delegate = new SettingDelegate<RegularEnsembleIdent | null>(null, this);
     }
 
     getType(): SettingType {
@@ -23,20 +23,20 @@ export class EnsembleSetting implements Setting<EnsembleIdent | null> {
         return "Ensemble";
     }
 
-    getDelegate(): SettingDelegate<EnsembleIdent | null> {
+    getDelegate(): SettingDelegate<RegularEnsembleIdent | null> {
         return this._delegate;
     }
 
-    serializeValue(value: EnsembleIdent | null): string {
+    serializeValue(value: RegularEnsembleIdent | null): string {
         return value?.toString() ?? "";
     }
 
-    deserializeValue(serializedValue: string): EnsembleIdent | null {
-        return serializedValue !== "" ? EnsembleIdent.fromString(serializedValue) : null;
+    deserializeValue(serializedValue: string): RegularEnsembleIdent | null {
+        return serializedValue !== "" ? RegularEnsembleIdent.fromString(serializedValue) : null;
     }
 
-    makeComponent(): (props: SettingComponentProps<EnsembleIdent | null>) => React.ReactNode {
-        return function Ensemble(props: SettingComponentProps<EnsembleIdent | null>) {
+    makeComponent(): (props: SettingComponentProps<RegularEnsembleIdent | null>) => React.ReactNode {
+        return function Ensemble(props: SettingComponentProps<RegularEnsembleIdent | null>) {
             const ensembles = props.globalSettings.ensembles.filter((ensemble) =>
                 props.availableValues.includes(ensemble.getIdent())
             );
@@ -53,7 +53,7 @@ export class EnsembleSetting implements Setting<EnsembleIdent | null> {
         };
     }
 
-    valueToString(args: ValueToStringArgs<EnsembleIdent | null>): string {
+    valueToString(args: ValueToStringArgs<RegularEnsembleIdent | null>): string {
         const { value, workbenchSession } = args;
         if (value === null) {
             return "-";
diff --git a/frontend/src/modules/2DViewer/settings/atoms/derivedAtoms.ts b/frontend/src/modules/2DViewer/settings/atoms/derivedAtoms.ts
index 5fc4447f4..ae64f8ba7 100644
--- a/frontend/src/modules/2DViewer/settings/atoms/derivedAtoms.ts
+++ b/frontend/src/modules/2DViewer/settings/atoms/derivedAtoms.ts
@@ -10,9 +10,9 @@ export const selectedFieldIdentifierAtom = atom((get) => {
 
     if (
         !userSelectedField ||
-        !ensembleSet.getEnsembleArr().some((ens) => ens.getFieldIdentifier() === userSelectedField)
+        !ensembleSet.getRegularEnsembleArray().some((ens) => ens.getFieldIdentifier() === userSelectedField)
     ) {
-        return ensembleSet.getEnsembleArr().at(0)?.getFieldIdentifier() ?? null;
+        return ensembleSet.getRegularEnsembleArray().at(0)?.getFieldIdentifier() ?? null;
     }
 
     return userSelectedField;
diff --git a/frontend/src/modules/3DViewer/interfaces.ts b/frontend/src/modules/3DViewer/interfaces.ts
index b74c6fb9f..b4b3352ea 100644
--- a/frontend/src/modules/3DViewer/interfaces.ts
+++ b/frontend/src/modules/3DViewer/interfaces.ts
@@ -1,5 +1,5 @@
 import { BoundingBox3d_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { InterfaceInitialization } from "@framework/UniDirectionalModuleComponentsInterface";
 import { IntersectionType } from "@framework/types/intersection";
 import { ColorScale } from "@lib/utils/ColorScale";
@@ -34,7 +34,7 @@ import {
 } from "./view/atoms/baseAtoms";
 
 export type SettingsToViewInterface = {
-    ensembleIdent: EnsembleIdent | null;
+    ensembleIdent: RegularEnsembleIdent | null;
     highlightedWellboreUuid: string | null;
     customIntersectionPolylineId: string | null;
     intersectionType: IntersectionType;
diff --git a/frontend/src/modules/3DViewer/settings/atoms/baseAtoms.ts b/frontend/src/modules/3DViewer/settings/atoms/baseAtoms.ts
index 72c62537b..d64800670 100644
--- a/frontend/src/modules/3DViewer/settings/atoms/baseAtoms.ts
+++ b/frontend/src/modules/3DViewer/settings/atoms/baseAtoms.ts
@@ -1,4 +1,4 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { IntersectionType } from "@framework/types/intersection";
 import { ColorScale } from "@lib/utils/ColorScale";
 import { GridCellIndexRanges } from "@modules/3DViewer/typesAndEnums";
@@ -16,7 +16,7 @@ export const addCustomIntersectionPolylineEditModeActiveAtom = atom<boolean>(fal
 export const editCustomIntersectionPolylineEditModeActiveAtom = atom<boolean>(false);
 export const currentCustomIntersectionPolylineAtom = atom<number[][]>([]);
 
-export const userSelectedEnsembleIdentAtom = atom<EnsembleIdent | null>(null);
+export const userSelectedEnsembleIdentAtom = atom<RegularEnsembleIdent | null>(null);
 export const userSelectedRealizationAtom = atom<number | null>(null);
 export const userSelectedGridModelNameAtom = atom<string | null>(null);
 export const userSelectedGridModelParameterNameAtom = atom<string | null>(null);
diff --git a/frontend/src/modules/3DViewer/settings/atoms/derivedAtoms.ts b/frontend/src/modules/3DViewer/settings/atoms/derivedAtoms.ts
index a646a9785..d7a221cd1 100644
--- a/frontend/src/modules/3DViewer/settings/atoms/derivedAtoms.ts
+++ b/frontend/src/modules/3DViewer/settings/atoms/derivedAtoms.ts
@@ -1,6 +1,6 @@
 import { Grid3dDimensions_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
-import { EnsembleRealizationFilterFunctionAtom, EnsembleSetAtom } from "@framework/GlobalAtoms";
+import { EnsembleSetAtom, ValidEnsembleRealizationsFunctionAtom } from "@framework/GlobalAtoms";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { IntersectionPolylinesAtom } from "@framework/userCreatedItems/IntersectionPolylines";
 import { GridCellIndexRanges } from "@modules/3DViewer/typesAndEnums";
 
@@ -19,12 +19,12 @@ import {
 } from "./baseAtoms";
 import { drilledWellboreHeadersQueryAtom, gridModelInfosQueryAtom } from "./queryAtoms";
 
-export const selectedEnsembleIdentAtom = atom<EnsembleIdent | null>((get) => {
+export const selectedEnsembleIdentAtom = atom<RegularEnsembleIdent | null>((get) => {
     const ensembleSet = get(EnsembleSetAtom);
     const userSelectedEnsembleIdent = get(userSelectedEnsembleIdentAtom);
 
     if (userSelectedEnsembleIdent === null || !ensembleSet.hasEnsemble(userSelectedEnsembleIdent)) {
-        return ensembleSet.getEnsembleArr()[0]?.getIdent() || null;
+        return ensembleSet.getRegularEnsembleArray()[0]?.getIdent() || null;
     }
 
     return userSelectedEnsembleIdent;
@@ -67,22 +67,14 @@ export const selectedCustomIntersectionPolylineIdAtom = atom((get) => {
 });
 
 export const availableRealizationsAtom = atom((get) => {
-    const ensembleSet = get(EnsembleSetAtom);
     const selectedEnsembleIdent = get(selectedEnsembleIdentAtom);
 
     if (selectedEnsembleIdent === null) {
         return [];
     }
 
-    let ensembleRealizationFilterFunction = get(EnsembleRealizationFilterFunctionAtom);
-
-    if (ensembleRealizationFilterFunction === null) {
-        ensembleRealizationFilterFunction = (ensembleIdent: EnsembleIdent) => {
-            return ensembleSet.findEnsemble(ensembleIdent)?.getRealizations() ?? [];
-        };
-    }
-
-    return ensembleRealizationFilterFunction(selectedEnsembleIdent);
+    const validEnsembleRealizationsFunction = get(ValidEnsembleRealizationsFunctionAtom);
+    return validEnsembleRealizationsFunction(selectedEnsembleIdent);
 });
 
 export const selectedRealizationAtom = atom((get) => {
diff --git a/frontend/src/modules/3DViewer/settings/settings.tsx b/frontend/src/modules/3DViewer/settings/settings.tsx
index 893c80e01..a880310bb 100644
--- a/frontend/src/modules/3DViewer/settings/settings.tsx
+++ b/frontend/src/modules/3DViewer/settings/settings.tsx
@@ -1,8 +1,8 @@
 import React from "react";
 
 import { Grid3dInfo_api, WellboreHeader_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ModuleSettingsProps } from "@framework/Module";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { useSettingsStatusWriter } from "@framework/StatusWriter";
 import { SyncSettingKey, SyncSettingsHelper } from "@framework/SyncSettings";
 import { useIntersectionPolylines } from "@framework/UserCreatedItems";
@@ -77,7 +77,7 @@ export function Settings(props: ModuleSettingsProps<Interfaces>): JSX.Element {
     const setPolylineEditModeActive = useSetAtom(editCustomIntersectionPolylineEditModeActiveAtom);
 
     const [prevSyncedIntersection, setPrevSyncedIntersection] = React.useState<Intersection | null>(null);
-    const [prevSyncedEnsembles, setPrevSyncedEnsembles] = React.useState<EnsembleIdent[] | null>(null);
+    const [prevSyncedEnsembles, setPrevSyncedEnsembles] = React.useState<RegularEnsembleIdent[] | null>(null);
     const [pickSingleGridCellIndexI, setPickSingleGridCellIndexI] = React.useState<boolean>(false);
     const [pickSingleGridCellIndexJ, setPickSingleGridCellIndexJ] = React.useState<boolean>(false);
     const [pickSingleGridCellIndexK, setPickSingleGridCellIndexK] = React.useState<boolean>(false);
@@ -153,7 +153,7 @@ export function Settings(props: ModuleSettingsProps<Interfaces>): JSX.Element {
     const gridModelErrorMessage = usePropagateApiErrorToStatusWriter(gridModelInfos, statusWriter) ?? "";
     const wellHeadersErrorMessage = usePropagateApiErrorToStatusWriter(wellHeaders, statusWriter) ?? "";
 
-    function handleEnsembleSelectionChange(ensembleIdent: EnsembleIdent | null) {
+    function handleEnsembleSelectionChange(ensembleIdent: RegularEnsembleIdent | null) {
         setSelectedEnsembleIdent(ensembleIdent);
         syncHelper.publishValue(
             SyncSettingKey.ENSEMBLE,
@@ -256,7 +256,7 @@ export function Settings(props: ModuleSettingsProps<Interfaces>): JSX.Element {
                 <div className="flex flex-col gap-2">
                     <Label text="Ensemble">
                         <EnsembleDropdown
-                            ensembles={ensembleSet.getEnsembleArr()}
+                            ensembles={ensembleSet.getRegularEnsembleArray()}
                             value={selectedEnsembleIdent}
                             onChange={handleEnsembleSelectionChange}
                             showArrows
diff --git a/frontend/src/modules/3DViewer/view/atoms/baseAtoms.ts b/frontend/src/modules/3DViewer/view/atoms/baseAtoms.ts
index 938939ea9..833ece047 100644
--- a/frontend/src/modules/3DViewer/view/atoms/baseAtoms.ts
+++ b/frontend/src/modules/3DViewer/view/atoms/baseAtoms.ts
@@ -1,4 +1,4 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { IntersectionType } from "@framework/types/intersection";
 
 import { atom } from "jotai";
@@ -6,6 +6,6 @@ import { atom } from "jotai";
 export const intersectionTypeAtom = atom<IntersectionType>(IntersectionType.WELLBORE);
 export const editCustomIntersectionPolylineEditModeActiveAtom = atom<boolean>(false);
 
-export const ensembleIdentAtom = atom<EnsembleIdent | null>(null);
+export const ensembleIdentAtom = atom<RegularEnsembleIdent | null>(null);
 export const highlightedWellboreUuidAtom = atom<string | null>(null);
 export const customIntersectionPolylineIdAtom = atom<string | null>(null);
diff --git a/frontend/src/modules/3DViewer/view/queries/polylineIntersection.ts b/frontend/src/modules/3DViewer/view/queries/polylineIntersection.ts
index 2e82d8608..3faf86049 100644
--- a/frontend/src/modules/3DViewer/view/queries/polylineIntersection.ts
+++ b/frontend/src/modules/3DViewer/view/queries/polylineIntersection.ts
@@ -1,5 +1,5 @@
 import { apiService } from "@framework/ApiService";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import {
     PolylineIntersection_trans,
     transformPolylineIntersection,
@@ -7,7 +7,7 @@ import {
 import { UseQueryResult, useQuery } from "@tanstack/react-query";
 
 export function useGridPolylineIntersection(
-    ensembleIdent: EnsembleIdent | null,
+    ensembleIdent: RegularEnsembleIdent | null,
     gridModelName: string | null,
     gridModelParameterName: string | null,
     gridModelDateOrInterval: string | null,
@@ -38,9 +38,6 @@ export function useGridPolylineIntersection(
         select: transformPolylineIntersection,
         staleTime: 0,
         gcTime: 0,
-        enabled:
-            ensembleIdent && gridModelName && realizationNum !== null && polyline_utm_xy.length && enabled
-                ? true
-                : false,
+        enabled: !!(ensembleIdent && gridModelName && realizationNum !== null && polyline_utm_xy.length && enabled),
     });
 }
diff --git a/frontend/src/modules/DbgWorkbenchSpy/implementation.tsx b/frontend/src/modules/DbgWorkbenchSpy/implementation.tsx
index 301600556..51de61992 100644
--- a/frontend/src/modules/DbgWorkbenchSpy/implementation.tsx
+++ b/frontend/src/modules/DbgWorkbenchSpy/implementation.tsx
@@ -80,7 +80,7 @@ function makeTableRow(label: string, value: any, updatedTS?: string) {
 }
 
 function makeEnsembleSetTable(ensembleSet: EnsembleSet) {
-    const ensembleArr = ensembleSet.getEnsembleArr();
+    const ensembleArr = ensembleSet.getRegularEnsembleArray();
     return (
         <table>
             <tbody>
diff --git a/frontend/src/modules/FlowNetwork/settings/atoms/baseAtoms.ts b/frontend/src/modules/FlowNetwork/settings/atoms/baseAtoms.ts
index aca1a3da5..866554967 100644
--- a/frontend/src/modules/FlowNetwork/settings/atoms/baseAtoms.ts
+++ b/frontend/src/modules/FlowNetwork/settings/atoms/baseAtoms.ts
@@ -1,16 +1,10 @@
 import { Frequency_api, NodeType_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { atomWithCompare } from "@framework/utils/atomUtils";
+import { areEnsembleIdentsEqual } from "@framework/utils/ensembleIdentUtils";
 
 import { atom } from "jotai";
 
-function areEnsembleIdentsEqual(a: EnsembleIdent | null, b: EnsembleIdent | null) {
-    if (a === null) {
-        return b === null;
-    }
-    return a.equals(b);
-}
-
 export const selectedResamplingFrequencyAtom = atom<Frequency_api>(Frequency_api.YEARLY);
 
 export const selectedNodeTypesAtom = atom<Set<NodeType_api>>(
@@ -23,7 +17,7 @@ export const userSelectedRealizationNumberAtom = atom<number | null>(null);
 
 export const validRealizationNumbersAtom = atom<number[] | null>(null);
 
-export const userSelectedEnsembleIdentAtom = atomWithCompare<EnsembleIdent | null>(null, areEnsembleIdentsEqual);
+export const userSelectedEnsembleIdentAtom = atomWithCompare<RegularEnsembleIdent | null>(null, areEnsembleIdentsEqual);
 
 export const userSelectedEdgeKeyAtom = atom<string | null>(null);
 
diff --git a/frontend/src/modules/FlowNetwork/settings/atoms/derivedAtoms.ts b/frontend/src/modules/FlowNetwork/settings/atoms/derivedAtoms.ts
index 3af7858bb..9d86dca9a 100644
--- a/frontend/src/modules/FlowNetwork/settings/atoms/derivedAtoms.ts
+++ b/frontend/src/modules/FlowNetwork/settings/atoms/derivedAtoms.ts
@@ -1,7 +1,7 @@
 import { DatedFlowNetwork_api, FlowNetworkMetadata_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { EnsembleSetAtom } from "@framework/GlobalAtoms";
-import { fixupEnsembleIdent } from "@framework/utils/ensembleUiHelpers";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
+import { fixupRegularEnsembleIdent } from "@framework/utils/ensembleUiHelpers";
 
 import { atom } from "jotai";
 
@@ -21,11 +21,11 @@ export const flowNetworkQueryResultAtom = atom((get) => {
     return get(realizationFlowNetworkQueryAtom);
 });
 
-export const selectedEnsembleIdentAtom = atom<EnsembleIdent | null>((get) => {
+export const selectedEnsembleIdentAtom = atom<RegularEnsembleIdent | null>((get) => {
     const ensembleSet = get(EnsembleSetAtom);
     const userSelectedEnsembleIdent = get(userSelectedEnsembleIdentAtom);
 
-    const validEnsembleIdent = fixupEnsembleIdent(userSelectedEnsembleIdent, ensembleSet);
+    const validEnsembleIdent = fixupRegularEnsembleIdent(userSelectedEnsembleIdent, ensembleSet);
     return validEnsembleIdent;
 });
 
diff --git a/frontend/src/modules/FlowNetwork/settings/settings.tsx b/frontend/src/modules/FlowNetwork/settings/settings.tsx
index d436e1a0c..5bb3ce55e 100644
--- a/frontend/src/modules/FlowNetwork/settings/settings.tsx
+++ b/frontend/src/modules/FlowNetwork/settings/settings.tsx
@@ -1,8 +1,8 @@
 import React from "react";
 
 import { Frequency_api, NodeType_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ModuleSettingsProps } from "@framework/Module";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { useSettingsStatusWriter } from "@framework/StatusWriter";
 import { useEnsembleRealizationFilterFunc, useEnsembleSet } from "@framework/WorkbenchSession";
 import { EnsembleDropdown } from "@framework/components/EnsembleDropdown";
@@ -94,7 +94,7 @@ export function Settings({ workbenchSession, settingsContext }: ModuleSettingsPr
         setUserSelectedEdgeKey(value);
     }
 
-    function handleEnsembleSelectionChange(ensembleIdent: EnsembleIdent | null) {
+    function handleEnsembleSelectionChange(ensembleIdent: RegularEnsembleIdent | null) {
         setUserSelectedEnsembleIdent(ensembleIdent);
     }
 
@@ -142,7 +142,7 @@ export function Settings({ workbenchSession, settingsContext }: ModuleSettingsPr
         <div className="flex flex-col gap-2 overflow-y-auto">
             <CollapsibleGroup expanded={true} title="Ensemble">
                 <EnsembleDropdown
-                    ensembles={ensembleSet.getEnsembleArr()}
+                    ensembles={ensembleSet.getRegularEnsembleArray()}
                     value={selectedEnsembleIdent}
                     onChange={handleEnsembleSelectionChange}
                 />
diff --git a/frontend/src/modules/InplaceVolumetricsPlot/settings/atoms/baseAtoms.ts b/frontend/src/modules/InplaceVolumetricsPlot/settings/atoms/baseAtoms.ts
index 03ef88853..dab411a31 100644
--- a/frontend/src/modules/InplaceVolumetricsPlot/settings/atoms/baseAtoms.ts
+++ b/frontend/src/modules/InplaceVolumetricsPlot/settings/atoms/baseAtoms.ts
@@ -1,5 +1,5 @@
 import { FluidZone_api, InplaceVolumetricResultName_api, InplaceVolumetricsIdentifierWithValues_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { PlotType } from "@modules/InplaceVolumetricsPlot/typesAndEnums";
 import {
     SelectorColumn,
@@ -9,7 +9,7 @@ import {
 
 import { atom } from "jotai";
 
-export const userSelectedEnsembleIdentsAtom = atom<EnsembleIdent[] | null>(null);
+export const userSelectedEnsembleIdentsAtom = atom<RegularEnsembleIdent[] | null>(null);
 export const userSelectedTableNamesAtom = atom<string[] | null>(null);
 export const userSelectedFluidZonesAtom = atom<FluidZone_api[] | null>(null);
 export const userSelectedIdentifiersValuesAtom = atom<InplaceVolumetricsIdentifierWithValues_api[] | null>(null);
diff --git a/frontend/src/modules/InplaceVolumetricsPlot/settings/atoms/derivedAtoms.ts b/frontend/src/modules/InplaceVolumetricsPlot/settings/atoms/derivedAtoms.ts
index 475c9ea1f..e7cc889be 100644
--- a/frontend/src/modules/InplaceVolumetricsPlot/settings/atoms/derivedAtoms.ts
+++ b/frontend/src/modules/InplaceVolumetricsPlot/settings/atoms/derivedAtoms.ts
@@ -1,6 +1,6 @@
 import { FluidZone_api, InplaceVolumetricResultName_api, InplaceVolumetricsIdentifierWithValues_api } from "@api";
 import { EnsembleSetAtom } from "@framework/GlobalAtoms";
-import { fixupEnsembleIdents } from "@framework/utils/ensembleUiHelpers";
+import { fixupRegularEnsembleIdents } from "@framework/utils/ensembleUiHelpers";
 import { fixupUserSelection } from "@lib/utils/fixupUserSelection";
 import { fixupUserSelectedIdentifierValues } from "@modules/_shared/InplaceVolumetrics/fixupUserSelectedIdentifierValues";
 import { RealSelector, SelectorColumn, SourceAndTableIdentifierUnion } from "@modules/_shared/InplaceVolumetrics/types";
@@ -31,17 +31,17 @@ export const selectedEnsembleIdentsAtom = atom((get) => {
     const userSelectedEnsembleIdents = get(userSelectedEnsembleIdentsAtom);
 
     if (!userSelectedEnsembleIdents) {
-        if (ensembleSet.getEnsembleArr().length === 0) {
+        if (ensembleSet.getRegularEnsembleArray().length === 0) {
             return [];
         }
-        return [ensembleSet.getEnsembleArr()[0].getIdent()];
+        return [ensembleSet.getRegularEnsembleArray()[0].getIdent()];
     }
 
     const newSelectedEnsembleIdents = userSelectedEnsembleIdents.filter((ensemble) =>
         ensembleSet.hasEnsemble(ensemble)
     );
 
-    const validatedEnsembleIdents = fixupEnsembleIdents(newSelectedEnsembleIdents, ensembleSet);
+    const validatedEnsembleIdents = fixupRegularEnsembleIdents(newSelectedEnsembleIdents, ensembleSet);
 
     return validatedEnsembleIdents ?? [];
 });
diff --git a/frontend/src/modules/InplaceVolumetricsPlot/settings/atoms/queryAtoms.ts b/frontend/src/modules/InplaceVolumetricsPlot/settings/atoms/queryAtoms.ts
index ada10a2c7..a8a485010 100644
--- a/frontend/src/modules/InplaceVolumetricsPlot/settings/atoms/queryAtoms.ts
+++ b/frontend/src/modules/InplaceVolumetricsPlot/settings/atoms/queryAtoms.ts
@@ -1,6 +1,6 @@
 import { InplaceVolumetricsTableDefinition_api } from "@api";
 import { apiService } from "@framework/ApiService";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { atomWithQueries } from "@framework/utils/atomUtils";
 import { QueryObserverResult } from "@tanstack/query-core";
 
@@ -11,7 +11,7 @@ const CACHE_TIME = 60 * 1000;
 
 export type TableDefinitionsQueryResult = {
     data: {
-        ensembleIdent: EnsembleIdent;
+        ensembleIdent: RegularEnsembleIdent;
         tableDefinitions: InplaceVolumetricsTableDefinition_api[];
     }[];
     isLoading: boolean;
diff --git a/frontend/src/modules/InplaceVolumetricsPlot/view/hooks/usePublishToDataChannels.ts b/frontend/src/modules/InplaceVolumetricsPlot/view/hooks/usePublishToDataChannels.ts
index a025f15e0..e2dc92579 100644
--- a/frontend/src/modules/InplaceVolumetricsPlot/view/hooks/usePublishToDataChannels.ts
+++ b/frontend/src/modules/InplaceVolumetricsPlot/view/hooks/usePublishToDataChannels.ts
@@ -1,8 +1,8 @@
 import { InplaceVolumetricResultName_api } from "@api";
 import { ChannelContentDefinition, ChannelContentMetaData, DataGenerator } from "@framework/DataChannelTypes";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { EnsembleSet } from "@framework/EnsembleSet";
 import { ViewContext } from "@framework/ModuleContext";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { ChannelIds } from "@modules/InplaceVolumetricsPlot/channelDefs";
 import { Interfaces } from "@modules/InplaceVolumetricsPlot/interfaces";
 import { Table } from "@modules/_shared/InplaceVolumetrics/Table";
@@ -11,7 +11,7 @@ import { makeDistinguishableEnsembleDisplayName } from "@modules/_shared/ensembl
 
 function makeDataGeneratorFunc(
     ensembleName: string,
-    ensembleIdent: EnsembleIdent,
+    ensembleIdent: RegularEnsembleIdent,
     tableName: string,
     fluidZone: string,
     table: Table,
@@ -56,8 +56,11 @@ export function usePublishToDataChannels(
     if (table && resultName) {
         const ensembleCollection = table.splitByColumn(SourceIdentifier.ENSEMBLE);
         for (const [ensembleIdentStr, ensembleTable] of ensembleCollection.getCollectionMap()) {
-            const ensembleIdent = EnsembleIdent.fromString(ensembleIdentStr.toString());
-            const ensembleName = makeDistinguishableEnsembleDisplayName(ensembleIdent, ensembleSet.getEnsembleArr());
+            const ensembleIdent = RegularEnsembleIdent.fromString(ensembleIdentStr.toString());
+            const ensembleName = makeDistinguishableEnsembleDisplayName(
+                ensembleIdent,
+                ensembleSet.getRegularEnsembleArray()
+            );
 
             const tableCollection = ensembleTable.splitByColumn(SourceIdentifier.TABLE_NAME);
             for (const [tableName, table] of tableCollection.getCollectionMap()) {
diff --git a/frontend/src/modules/InplaceVolumetricsPlot/view/utils/plotComponentUtils.ts b/frontend/src/modules/InplaceVolumetricsPlot/view/utils/plotComponentUtils.ts
index eba7139f8..14cb21edc 100644
--- a/frontend/src/modules/InplaceVolumetricsPlot/view/utils/plotComponentUtils.ts
+++ b/frontend/src/modules/InplaceVolumetricsPlot/view/utils/plotComponentUtils.ts
@@ -1,5 +1,5 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { EnsembleSet } from "@framework/EnsembleSet";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { ColorSet } from "@lib/utils/ColorSet";
 import { PlotType } from "@modules/InplaceVolumetricsPlot/typesAndEnums";
 import { Table } from "@modules/_shared/InplaceVolumetrics/Table";
@@ -21,10 +21,10 @@ export function makeFormatLabelFunction(
 ): (columnName: string, value: string | number) => string {
     return function formatLabel(columnName: string, value: string | number): string {
         if (columnName === SourceIdentifier.ENSEMBLE) {
-            const ensembleIdent = EnsembleIdent.fromString(value.toString());
+            const ensembleIdent = RegularEnsembleIdent.fromString(value.toString());
             const ensemble = ensembleSet.findEnsemble(ensembleIdent);
             if (ensemble) {
-                return makeDistinguishableEnsembleDisplayName(ensembleIdent, ensembleSet.getEnsembleArr());
+                return makeDistinguishableEnsembleDisplayName(ensembleIdent, ensembleSet.getRegularEnsembleArray());
             }
         }
         return value.toString();
@@ -81,11 +81,14 @@ export function makePlotData(
         for (const [key, table] of collection.getCollectionMap()) {
             let title = key.toString();
             if (colorBy === SourceIdentifier.ENSEMBLE) {
-                const ensembleIdent = EnsembleIdent.fromString(key.toString());
+                const ensembleIdent = RegularEnsembleIdent.fromString(key.toString());
                 const ensemble = ensembleSet.findEnsemble(ensembleIdent);
                 if (ensemble) {
                     color = ensemble.getColor();
-                    title = makeDistinguishableEnsembleDisplayName(ensembleIdent, ensembleSet.getEnsembleArr());
+                    title = makeDistinguishableEnsembleDisplayName(
+                        ensembleIdent,
+                        ensembleSet.getRegularEnsembleArray()
+                    );
                 }
             }
 
diff --git a/frontend/src/modules/InplaceVolumetricsTable/settings/atoms/baseAtoms.ts b/frontend/src/modules/InplaceVolumetricsTable/settings/atoms/baseAtoms.ts
index 325198b30..9079460cb 100644
--- a/frontend/src/modules/InplaceVolumetricsTable/settings/atoms/baseAtoms.ts
+++ b/frontend/src/modules/InplaceVolumetricsTable/settings/atoms/baseAtoms.ts
@@ -4,12 +4,12 @@ import {
     InplaceVolumetricStatistic_api,
     InplaceVolumetricsIdentifierWithValues_api,
 } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { SourceAndTableIdentifierUnion, SourceIdentifier, TableType } from "@modules/_shared/InplaceVolumetrics/types";
 
 import { atom } from "jotai";
 
-export const userSelectedEnsembleIdentsAtom = atom<EnsembleIdent[] | null>(null);
+export const userSelectedEnsembleIdentsAtom = atom<RegularEnsembleIdent[] | null>(null);
 export const userSelectedTableNamesAtom = atom<string[] | null>(null);
 export const userSelectedFluidZonesAtom = atom<FluidZone_api[] | null>(null);
 export const userSelectedIdentifiersValuesAtom = atom<InplaceVolumetricsIdentifierWithValues_api[] | null>(null);
diff --git a/frontend/src/modules/InplaceVolumetricsTable/settings/atoms/derivedAtoms.ts b/frontend/src/modules/InplaceVolumetricsTable/settings/atoms/derivedAtoms.ts
index ed7b2ee99..04cfb02ca 100644
--- a/frontend/src/modules/InplaceVolumetricsTable/settings/atoms/derivedAtoms.ts
+++ b/frontend/src/modules/InplaceVolumetricsTable/settings/atoms/derivedAtoms.ts
@@ -1,6 +1,6 @@
 import { FluidZone_api, InplaceVolumetricResultName_api, InplaceVolumetricsIdentifierWithValues_api } from "@api";
 import { EnsembleSetAtom } from "@framework/GlobalAtoms";
-import { fixupEnsembleIdents } from "@framework/utils/ensembleUiHelpers";
+import { fixupRegularEnsembleIdents } from "@framework/utils/ensembleUiHelpers";
 import { fixupUserSelection } from "@lib/utils/fixupUserSelection";
 import { fixupUserSelectedIdentifierValues } from "@modules/_shared/InplaceVolumetrics/fixupUserSelectedIdentifierValues";
 import { SourceAndTableIdentifierUnion, SourceIdentifier } from "@modules/_shared/InplaceVolumetrics/types";
@@ -26,17 +26,17 @@ export const selectedEnsembleIdentsAtom = atom((get) => {
     const userSelectedEnsembleIdents = get(userSelectedEnsembleIdentsAtom);
 
     if (!userSelectedEnsembleIdents) {
-        if (ensembleSet.getEnsembleArr().length === 0) {
+        if (ensembleSet.getRegularEnsembleArray().length === 0) {
             return [];
         }
-        return [ensembleSet.getEnsembleArr()[0].getIdent()];
+        return [ensembleSet.getRegularEnsembleArray()[0].getIdent()];
     }
 
     const newSelectedEnsembleIdents = userSelectedEnsembleIdents.filter((ensemble) =>
         ensembleSet.hasEnsemble(ensemble)
     );
 
-    const validatedEnsembleIdents = fixupEnsembleIdents(newSelectedEnsembleIdents, ensembleSet);
+    const validatedEnsembleIdents = fixupRegularEnsembleIdents(newSelectedEnsembleIdents, ensembleSet);
 
     return validatedEnsembleIdents ?? [];
 });
diff --git a/frontend/src/modules/InplaceVolumetricsTable/settings/atoms/queryAtoms.ts b/frontend/src/modules/InplaceVolumetricsTable/settings/atoms/queryAtoms.ts
index ada10a2c7..a8a485010 100644
--- a/frontend/src/modules/InplaceVolumetricsTable/settings/atoms/queryAtoms.ts
+++ b/frontend/src/modules/InplaceVolumetricsTable/settings/atoms/queryAtoms.ts
@@ -1,6 +1,6 @@
 import { InplaceVolumetricsTableDefinition_api } from "@api";
 import { apiService } from "@framework/ApiService";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { atomWithQueries } from "@framework/utils/atomUtils";
 import { QueryObserverResult } from "@tanstack/query-core";
 
@@ -11,7 +11,7 @@ const CACHE_TIME = 60 * 1000;
 
 export type TableDefinitionsQueryResult = {
     data: {
-        ensembleIdent: EnsembleIdent;
+        ensembleIdent: RegularEnsembleIdent;
         tableDefinitions: InplaceVolumetricsTableDefinition_api[];
     }[];
     isLoading: boolean;
diff --git a/frontend/src/modules/InplaceVolumetricsTable/view/hooks/useMakeViewStatusWriterMessages.ts b/frontend/src/modules/InplaceVolumetricsTable/view/hooks/useMakeViewStatusWriterMessages.ts
index fd9438c5c..296496c27 100644
--- a/frontend/src/modules/InplaceVolumetricsTable/view/hooks/useMakeViewStatusWriterMessages.ts
+++ b/frontend/src/modules/InplaceVolumetricsTable/view/hooks/useMakeViewStatusWriterMessages.ts
@@ -44,7 +44,7 @@ export function useMakeViewStatusWriterMessages(statusWriter: ViewStatusWriter)
     // Due to no throw in back-end for missing/non-existing result for specific tables, we should compare
     // the retrieved result columns with the requested columns
     for (const tableData of activeQueriesResult.tablesData) {
-        // Per unique volumetric table (EnsembleIdent, tableName) we have a query result
+        // Per unique volumetric table (RegularEnsembleIdent, tableName) we have a query result
         const queryData = tableData.data;
 
         // Result columns across all fluid selections
diff --git a/frontend/src/modules/InplaceVolumetricsTable/view/utils/tableComponentUtils.ts b/frontend/src/modules/InplaceVolumetricsTable/view/utils/tableComponentUtils.ts
index 583afeb51..90a26d57c 100644
--- a/frontend/src/modules/InplaceVolumetricsTable/view/utils/tableComponentUtils.ts
+++ b/frontend/src/modules/InplaceVolumetricsTable/view/utils/tableComponentUtils.ts
@@ -1,6 +1,7 @@
 import { FluidZone_api, InplaceVolumetricStatistic_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { EnsembleSet } from "@framework/EnsembleSet";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { TableHeading, TableRow } from "@lib/components/Table/table";
 import { Column, ColumnType, Row, Table } from "@modules/_shared/InplaceVolumetrics/Table";
 import { sortResultNameStrings } from "@modules/_shared/InplaceVolumetrics/sortResultNames";
@@ -190,10 +191,10 @@ function formatEnsembleIdent(value: string | number | null, ensembleSet: Ensembl
         return "-";
     }
     const ensemble = ensembleSet.findEnsembleByIdentString(value.toString());
-    if (ensemble) {
+    if (ensemble && ensemble instanceof RegularEnsemble) {
         return makeDistinguishableEnsembleDisplayName(
-            EnsembleIdent.fromString(value.toString()),
-            ensembleSet.getEnsembleArr()
+            RegularEnsembleIdent.fromString(value.toString()),
+            ensembleSet.getRegularEnsembleArray()
         );
     }
     return value.toString();
diff --git a/frontend/src/modules/Intersection/settings/atoms/derivedAtoms.ts b/frontend/src/modules/Intersection/settings/atoms/derivedAtoms.ts
index da6749716..26a4bc683 100644
--- a/frontend/src/modules/Intersection/settings/atoms/derivedAtoms.ts
+++ b/frontend/src/modules/Intersection/settings/atoms/derivedAtoms.ts
@@ -21,7 +21,9 @@ export const filteredEnsembleSetAtom = atom((get) => {
         return ensembleSet;
     }
 
-    return new EnsembleSet(ensembleSet.getEnsembleArr().filter((el) => el.getFieldIdentifier() === fieldIdentifier));
+    return new EnsembleSet(
+        ensembleSet.getRegularEnsembleArray().filter((el) => el.getFieldIdentifier() === fieldIdentifier)
+    );
 });
 
 export const selectedFieldIdentifierAtom = atom((get) => {
@@ -29,7 +31,7 @@ export const selectedFieldIdentifierAtom = atom((get) => {
     const selectedFieldIdentifier = get(userSelectedFieldIdentifierAtom);
 
     if (selectedFieldIdentifier === null) {
-        return ensembleSet.getEnsembleArr()[0]?.getFieldIdentifier() || null;
+        return ensembleSet.getRegularEnsembleArray()[0]?.getFieldIdentifier() || null;
     }
 
     return selectedFieldIdentifier;
diff --git a/frontend/src/modules/Intersection/settings/components/layerSettings/gridLayer.tsx b/frontend/src/modules/Intersection/settings/components/layerSettings/gridLayer.tsx
index 7c58eb32a..976dd608a 100644
--- a/frontend/src/modules/Intersection/settings/components/layerSettings/gridLayer.tsx
+++ b/frontend/src/modules/Intersection/settings/components/layerSettings/gridLayer.tsx
@@ -2,8 +2,8 @@ import React from "react";
 
 import { Grid3dInfo_api } from "@api";
 import { apiService } from "@framework/ApiService";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { EnsembleSet } from "@framework/EnsembleSet";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { WorkbenchSession, useEnsembleRealizationFilterFunc } from "@framework/WorkbenchSession";
 import { WorkbenchSettings } from "@framework/WorkbenchSettings";
 import { EnsembleDropdown } from "@framework/components/EnsembleDropdown";
@@ -45,7 +45,7 @@ export function GridLayerSettingsComponent(props: GridLayerSettingsComponentProp
 
     const fixupEnsembleIdent = fixupSetting(
         "ensembleIdent",
-        props.ensembleSet.getEnsembleArr().map((el) => el.getIdent()),
+        props.ensembleSet.getRegularEnsembleArray().map((el) => el.getIdent()),
         newSettings
     );
     if (!isEqual(fixupEnsembleIdent, newSettings.ensembleIdent)) {
@@ -115,7 +115,7 @@ export function GridLayerSettingsComponent(props: GridLayerSettingsComponentProp
         [gridModelInfosQuery.isFetching, props.layer, newSettings]
     );
 
-    function handleEnsembleChange(ensembleIdent: EnsembleIdent | null) {
+    function handleEnsembleChange(ensembleIdent: RegularEnsembleIdent | null) {
         setNewSettings((prev) => ({ ...prev, ensembleIdent }));
     }
 
@@ -166,7 +166,7 @@ export function GridLayerSettingsComponent(props: GridLayerSettingsComponentProp
                 <div className="table-cell">
                     <EnsembleDropdown
                         value={props.layer.getSettings().ensembleIdent}
-                        ensembles={props.ensembleSet.getEnsembleArr()}
+                        ensembles={props.ensembleSet.getRegularEnsembleArray()}
                         onChange={handleEnsembleChange}
                         debounceTimeMs={600}
                     />
@@ -307,7 +307,7 @@ function makeGridParameterDateOrIntervalOptions(datesOrIntervals: (string | null
 const STALE_TIME = 60 * 1000;
 const CACHE_TIME = 60 * 1000;
 
-function useGridModelInfosQuery(ensembleIdent: EnsembleIdent | null, realizationNum: number | null) {
+function useGridModelInfosQuery(ensembleIdent: RegularEnsembleIdent | null, realizationNum: number | null) {
     return useQuery({
         queryKey: ["getGridModelInfos", ensembleIdent?.getCaseUuid(), ensembleIdent?.getEnsembleName(), realizationNum],
         queryFn: () =>
diff --git a/frontend/src/modules/Intersection/settings/components/layerSettings/seismicLayer.tsx b/frontend/src/modules/Intersection/settings/components/layerSettings/seismicLayer.tsx
index 2aea17e88..5fda536d1 100644
--- a/frontend/src/modules/Intersection/settings/components/layerSettings/seismicLayer.tsx
+++ b/frontend/src/modules/Intersection/settings/components/layerSettings/seismicLayer.tsx
@@ -1,8 +1,8 @@
 import React from "react";
 
 import { apiService } from "@framework/ApiService";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { EnsembleSet } from "@framework/EnsembleSet";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { WorkbenchSession, useEnsembleRealizationFilterFunc } from "@framework/WorkbenchSession";
 import { WorkbenchSettings } from "@framework/WorkbenchSettings";
 import { EnsembleDropdown } from "@framework/components/EnsembleDropdown";
@@ -61,7 +61,7 @@ export function SeismicLayerSettingsComponent(props: SeismicLayerSettingsProps):
 
     const fixupEnsembleIdent = fixupSetting(
         "ensembleIdent",
-        props.ensembleSet.getEnsembleArr().map((el) => el.getIdent()),
+        props.ensembleSet.getRegularEnsembleArray().map((el) => el.getIdent()),
         newSettings
     );
     if (!isEqual(fixupEnsembleIdent, newSettings.ensembleIdent)) {
@@ -158,7 +158,7 @@ export function SeismicLayerSettingsComponent(props: SeismicLayerSettingsProps):
         [seismicCubeMetaListQuery.isFetching, props.layer, newSettings]
     );
 
-    function handleEnsembleChange(ensembleIdent: EnsembleIdent | null) {
+    function handleEnsembleChange(ensembleIdent: RegularEnsembleIdent | null) {
         setNewSettings((prev) => ({ ...prev, ensembleIdent }));
     }
 
@@ -198,7 +198,7 @@ export function SeismicLayerSettingsComponent(props: SeismicLayerSettingsProps):
                 <div className="table-cell">
                     <EnsembleDropdown
                         value={props.layer.getSettings().ensembleIdent}
-                        ensembles={props.ensembleSet.getEnsembleArr()}
+                        ensembles={props.ensembleSet.getRegularEnsembleArray()}
                         onChange={handleEnsembleChange}
                         debounceTimeMs={600}
                     />
@@ -341,7 +341,7 @@ function makeDateOrIntervalStringOptions(availableSeismicDateOrIntervalStrings:
 const STALE_TIME = 60 * 1000;
 const CACHE_TIME = 60 * 1000;
 
-function useSeismicCubeMetaListQuery(ensembleIdent: EnsembleIdent | null) {
+function useSeismicCubeMetaListQuery(ensembleIdent: RegularEnsembleIdent | null) {
     return useQuery({
         queryKey: ["getSeismicCubeMetaList", ensembleIdent?.getCaseUuid(), ensembleIdent?.getEnsembleName()],
         queryFn: () =>
diff --git a/frontend/src/modules/Intersection/settings/components/layerSettings/surfaceLayer.tsx b/frontend/src/modules/Intersection/settings/components/layerSettings/surfaceLayer.tsx
index ab274043d..7bd62de78 100644
--- a/frontend/src/modules/Intersection/settings/components/layerSettings/surfaceLayer.tsx
+++ b/frontend/src/modules/Intersection/settings/components/layerSettings/surfaceLayer.tsx
@@ -2,8 +2,8 @@ import React from "react";
 
 import { SurfaceAttributeType_api, SurfaceMetaSet_api } from "@api";
 import { apiService } from "@framework/ApiService";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { EnsembleSet } from "@framework/EnsembleSet";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { WorkbenchSession, useEnsembleRealizationFilterFunc } from "@framework/WorkbenchSession";
 import { WorkbenchSettings } from "@framework/WorkbenchSettings";
 import { EnsembleDropdown } from "@framework/components/EnsembleDropdown";
@@ -49,7 +49,7 @@ export function SurfaceLayerSettingsComponent(props: SurfaceLayerSettingsCompone
 
     const fixupEnsembleIdent = fixupSetting(
         "ensembleIdent",
-        props.ensembleSet.getEnsembleArr().map((el) => el.getIdent()),
+        props.ensembleSet.getRegularEnsembleArray().map((el) => el.getIdent()),
         newSettings
     );
     if (!isEqual(fixupEnsembleIdent, newSettings.ensembleIdent)) {
@@ -119,7 +119,7 @@ export function SurfaceLayerSettingsComponent(props: SurfaceLayerSettingsCompone
         [surfaceDirectoryQuery.isFetching, props.layer, newSettings]
     );
 
-    function handleEnsembleChange(ensembleIdent: EnsembleIdent | null) {
+    function handleEnsembleChange(ensembleIdent: RegularEnsembleIdent | null) {
         setNewSettings((prev) => ({ ...prev, ensembleIdent }));
     }
 
@@ -155,7 +155,7 @@ export function SurfaceLayerSettingsComponent(props: SurfaceLayerSettingsCompone
                 <div className="table-cell">
                     <EnsembleDropdown
                         value={props.layer.getSettings().ensembleIdent}
-                        ensembles={props.ensembleSet.getEnsembleArr()}
+                        ensembles={props.ensembleSet.getRegularEnsembleArray()}
                         onChange={handleEnsembleChange}
                         debounceTimeMs={600}
                     />
diff --git a/frontend/src/modules/Intersection/settings/components/layerSettings/surfacesUncertaintyLayer.tsx b/frontend/src/modules/Intersection/settings/components/layerSettings/surfacesUncertaintyLayer.tsx
index e43c28643..1b8b4a11a 100644
--- a/frontend/src/modules/Intersection/settings/components/layerSettings/surfacesUncertaintyLayer.tsx
+++ b/frontend/src/modules/Intersection/settings/components/layerSettings/surfacesUncertaintyLayer.tsx
@@ -2,8 +2,8 @@ import React from "react";
 
 import { SurfaceAttributeType_api, SurfaceMetaSet_api } from "@api";
 import { apiService } from "@framework/ApiService";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { EnsembleSet } from "@framework/EnsembleSet";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { WorkbenchSession, useEnsembleRealizationFilterFunc } from "@framework/WorkbenchSession";
 import { WorkbenchSettings } from "@framework/WorkbenchSettings";
 import { EnsembleDropdown } from "@framework/components/EnsembleDropdown";
@@ -55,7 +55,7 @@ export function SurfacesUncertaintyLayerSettingsComponent(
 
     const fixupEnsembleIdent = fixupSetting(
         "ensembleIdent",
-        props.ensembleSet.getEnsembleArr().map((el) => el.getIdent()),
+        props.ensembleSet.getRegularEnsembleArray().map((el) => el.getIdent()),
         newSettings
     );
     if (!isEqual(fixupEnsembleIdent, newSettings.ensembleIdent)) {
@@ -120,7 +120,7 @@ export function SurfacesUncertaintyLayerSettingsComponent(
         [surfaceDirectoryQuery.isFetching, props.layer, newSettings]
     );
 
-    function handleEnsembleChange(ensembleIdent: EnsembleIdent | null) {
+    function handleEnsembleChange(ensembleIdent: RegularEnsembleIdent | null) {
         setNewSettings((prev) => ({ ...prev, ensembleIdent }));
     }
 
@@ -156,7 +156,7 @@ export function SurfacesUncertaintyLayerSettingsComponent(
                 <div className="table-cell">
                     <EnsembleDropdown
                         value={props.layer.getSettings().ensembleIdent}
-                        ensembles={props.ensembleSet.getEnsembleArr()}
+                        ensembles={props.ensembleSet.getRegularEnsembleArray()}
                         onChange={handleEnsembleChange}
                         debounceTimeMs={600}
                     />
diff --git a/frontend/src/modules/Intersection/settings/components/layerSettings/wellpicksLayer.tsx b/frontend/src/modules/Intersection/settings/components/layerSettings/wellpicksLayer.tsx
index 9386871a4..2f238fba0 100644
--- a/frontend/src/modules/Intersection/settings/components/layerSettings/wellpicksLayer.tsx
+++ b/frontend/src/modules/Intersection/settings/components/layerSettings/wellpicksLayer.tsx
@@ -1,7 +1,7 @@
 import React from "react";
 
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { EnsembleSet } from "@framework/EnsembleSet";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { WorkbenchSession } from "@framework/WorkbenchSession";
 import { WorkbenchSettings } from "@framework/WorkbenchSettings";
 import { EnsembleDropdown } from "@framework/components/EnsembleDropdown";
@@ -30,7 +30,7 @@ export function WellpicksLayerSettingsComponent(props: WellpicksLayerSettingsCom
 
     const fixupEnsembleIdent = fixupSetting(
         "ensembleIdent",
-        props.ensembleSet.getEnsembleArr().map((el) => el.getIdent()),
+        props.ensembleSet.getRegularEnsembleArray().map((el) => el.getIdent()),
         newSettings
     );
     if (!isEqual(fixupEnsembleIdent, newSettings.ensembleIdent)) {
@@ -45,7 +45,7 @@ export function WellpicksLayerSettingsComponent(props: WellpicksLayerSettingsCom
         [newSettings, props.layer]
     );
 
-    function handleEnsembleChange(ensembleIdent: EnsembleIdent | null) {
+    function handleEnsembleChange(ensembleIdent: RegularEnsembleIdent | null) {
         setNewSettings((prev) => ({ ...prev, ensembleIdent }));
     }
 
@@ -87,7 +87,7 @@ export function WellpicksLayerSettingsComponent(props: WellpicksLayerSettingsCom
                 <div className="table-cell">
                     <EnsembleDropdown
                         value={props.layer.getSettings().ensembleIdent}
-                        ensembles={props.ensembleSet.getEnsembleArr()}
+                        ensembles={props.ensembleSet.getRegularEnsembleArray()}
                         onChange={handleEnsembleChange}
                         debounceTimeMs={600}
                     />
diff --git a/frontend/src/modules/Intersection/utils/layers/GridLayer.ts b/frontend/src/modules/Intersection/utils/layers/GridLayer.ts
index ec65f0b58..a4c446b27 100644
--- a/frontend/src/modules/Intersection/utils/layers/GridLayer.ts
+++ b/frontend/src/modules/Intersection/utils/layers/GridLayer.ts
@@ -1,5 +1,5 @@
 import { apiService } from "@framework/ApiService";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { defaultContinuousSequentialColorPalettes } from "@framework/utils/colorPalettes";
 import { ColorScale, ColorScaleGradientType, ColorScaleType } from "@lib/utils/ColorScale";
 import { ColorScaleWithName } from "@modules/_shared/utils/ColorScaleWithName";
@@ -18,7 +18,7 @@ const STALE_TIME = 60 * 1000;
 const CACHE_TIME = 60 * 1000;
 
 export type GridLayerSettings = {
-    ensembleIdent: EnsembleIdent | null;
+    ensembleIdent: RegularEnsembleIdent | null;
     gridModelName: string | null;
     parameterName: string | null;
     parameterDateOrInterval: string | null;
diff --git a/frontend/src/modules/Intersection/utils/layers/SeismicLayer.ts b/frontend/src/modules/Intersection/utils/layers/SeismicLayer.ts
index 590bcbabb..d0d3eabf2 100644
--- a/frontend/src/modules/Intersection/utils/layers/SeismicLayer.ts
+++ b/frontend/src/modules/Intersection/utils/layers/SeismicLayer.ts
@@ -1,7 +1,7 @@
 import { SeismicFenceData_api } from "@api";
 import { SeismicInfo, findIndexOfSample, getSeismicInfo } from "@equinor/esv-intersection";
 import { apiService } from "@framework/ApiService";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { defaultContinuousDivergingColorPalettes } from "@framework/utils/colorPalettes";
 import { ColorScale, ColorScaleGradientType, ColorScaleType } from "@lib/utils/ColorScale";
 import { Vec2, normalizeVec2, point2Distance } from "@lib/utils/vec2";
@@ -51,7 +51,7 @@ const STALE_TIME = 60 * 1000;
 const CACHE_TIME = 60 * 1000;
 
 export type SeismicLayerSettings = {
-    ensembleIdent: EnsembleIdent | null;
+    ensembleIdent: RegularEnsembleIdent | null;
     realizationNum: number | null;
     polyline: {
         polylineUtmXy: number[];
diff --git a/frontend/src/modules/Intersection/utils/layers/SurfaceLayer.ts b/frontend/src/modules/Intersection/utils/layers/SurfaceLayer.ts
index b2a618356..042c965e2 100644
--- a/frontend/src/modules/Intersection/utils/layers/SurfaceLayer.ts
+++ b/frontend/src/modules/Intersection/utils/layers/SurfaceLayer.ts
@@ -1,6 +1,6 @@
 import { SurfaceIntersectionData_api } from "@api";
 import { apiService } from "@framework/ApiService";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { defaultColorPalettes } from "@framework/utils/colorPalettes";
 import { ColorSet } from "@lib/utils/ColorSet";
 import { Vec2, normalizeVec2, point2Distance } from "@lib/utils/vec2";
@@ -14,7 +14,7 @@ const STALE_TIME = 60 * 1000;
 const CACHE_TIME = 60 * 1000;
 
 export type SurfaceLayerSettings = {
-    ensembleIdent: EnsembleIdent | null;
+    ensembleIdent: RegularEnsembleIdent | null;
     realizationNum: number | null;
     polyline: {
         polylineUtmXy: number[];
diff --git a/frontend/src/modules/Intersection/utils/layers/SurfacesUncertaintyLayer.ts b/frontend/src/modules/Intersection/utils/layers/SurfacesUncertaintyLayer.ts
index ffeef655d..51590ed07 100644
--- a/frontend/src/modules/Intersection/utils/layers/SurfacesUncertaintyLayer.ts
+++ b/frontend/src/modules/Intersection/utils/layers/SurfacesUncertaintyLayer.ts
@@ -1,6 +1,6 @@
 import { SurfaceRealizationSampleValues_api } from "@api";
 import { apiService } from "@framework/ApiService";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { defaultColorPalettes } from "@framework/utils/colorPalettes";
 import { ColorSet } from "@lib/utils/ColorSet";
 import { Vec2, normalizeVec2, point2Distance } from "@lib/utils/vec2";
@@ -14,7 +14,7 @@ const STALE_TIME = 60 * 1000;
 const CACHE_TIME = 60 * 1000;
 
 export type SurfacesUncertaintyLayerSettings = {
-    ensembleIdent: EnsembleIdent | null;
+    ensembleIdent: RegularEnsembleIdent | null;
     realizationNums: number[];
     polyline: {
         polylineUtmXy: number[];
diff --git a/frontend/src/modules/Intersection/utils/layers/WellpicksLayer.ts b/frontend/src/modules/Intersection/utils/layers/WellpicksLayer.ts
index c68ba3a05..6cfa5d29a 100644
--- a/frontend/src/modules/Intersection/utils/layers/WellpicksLayer.ts
+++ b/frontend/src/modules/Intersection/utils/layers/WellpicksLayer.ts
@@ -1,6 +1,6 @@
 import { transformFormationData } from "@equinor/esv-intersection";
 import { apiService } from "@framework/ApiService";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { QueryClient } from "@tanstack/query-core";
 
 import { isEqual } from "lodash";
@@ -13,7 +13,7 @@ const CACHE_TIME = 60 * 1000;
 export type WellpicksLayerSettings = {
     wellboreUuid: string | null;
     fieldIdentifier: string | null;
-    ensembleIdent: EnsembleIdent | null;
+    ensembleIdent: RegularEnsembleIdent | null;
     filterPicks: boolean;
     selectedUnitPicks: string[];
     selectedNonUnitPicks: string[];
diff --git a/frontend/src/modules/Map/settings/settings.tsx b/frontend/src/modules/Map/settings/settings.tsx
index af36a4f6c..9d3875b58 100644
--- a/frontend/src/modules/Map/settings/settings.tsx
+++ b/frontend/src/modules/Map/settings/settings.tsx
@@ -1,13 +1,13 @@
 import React from "react";
 
 import { SurfaceStatisticFunction_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ModuleSettingsProps } from "@framework/Module";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { useSettingsStatusWriter } from "@framework/StatusWriter";
 import { SyncSettingKey, SyncSettingsHelper } from "@framework/SyncSettings";
 import { useEnsembleSet } from "@framework/WorkbenchSession";
 import { EnsembleDropdown } from "@framework/components/EnsembleDropdown";
-import { fixupEnsembleIdent, maybeAssignFirstSyncedEnsemble } from "@framework/utils/ensembleUiHelpers";
+import { fixupRegularEnsembleIdent, maybeAssignFirstSyncedEnsemble } from "@framework/utils/ensembleUiHelpers";
 import { Checkbox } from "@lib/components/Checkbox";
 import { CircularProgress } from "@lib/components/CircularProgress";
 import { Input } from "@lib/components/Input";
@@ -34,7 +34,7 @@ const SurfaceTimeTypeEnumToStringMapping = {
 //-----------------------------------------------------------------------------------------------------------
 export function MapSettings(props: ModuleSettingsProps<Interfaces>) {
     const ensembleSet = useEnsembleSet(props.workbenchSession);
-    const [selectedEnsembleIdent, setSelectedEnsembleIdent] = React.useState<EnsembleIdent | null>(null);
+    const [selectedEnsembleIdent, setSelectedEnsembleIdent] = React.useState<RegularEnsembleIdent | null>(null);
     const [timeType, setTimeType] = React.useState<SurfaceTimeType>(SurfaceTimeType.None);
 
     const statusWriter = useSettingsStatusWriter(props.settingsContext);
@@ -53,7 +53,7 @@ export function MapSettings(props: ModuleSettingsProps<Interfaces>) {
     const syncedValueDate = syncHelper.useValue(SyncSettingKey.DATE, "global.syncValue.date");
 
     const candidateEnsembleIdent = maybeAssignFirstSyncedEnsemble(selectedEnsembleIdent, syncedValueEnsembles);
-    const computedEnsembleIdent = fixupEnsembleIdent(candidateEnsembleIdent, ensembleSet);
+    const computedEnsembleIdent = fixupRegularEnsembleIdent(candidateEnsembleIdent, ensembleSet);
     const realizationSurfacesMetaQuery = useRealizationSurfacesMetadataQuery(
         computedEnsembleIdent?.getCaseUuid(),
         computedEnsembleIdent?.getEnsembleName()
@@ -128,7 +128,7 @@ export function MapSettings(props: ModuleSettingsProps<Interfaces>) {
         setSurfaceAddress(surfaceAddress);
     });
 
-    function handleEnsembleSelectionChange(newEnsembleIdent: EnsembleIdent | null) {
+    function handleEnsembleSelectionChange(newEnsembleIdent: RegularEnsembleIdent | null) {
         console.debug("handleEnsembleSelectionChange()");
         setSelectedEnsembleIdent(newEnsembleIdent);
         if (newEnsembleIdent) {
@@ -227,7 +227,7 @@ export function MapSettings(props: ModuleSettingsProps<Interfaces>) {
                 labelClassName={syncHelper.isSynced(SyncSettingKey.ENSEMBLE) ? "bg-indigo-700 text-white" : ""}
             >
                 <EnsembleDropdown
-                    ensembles={ensembleSet.getEnsembleArr()}
+                    ensembles={ensembleSet.getRegularEnsembleArray()}
                     value={computedEnsembleIdent}
                     onChange={handleEnsembleSelectionChange}
                 />
diff --git a/frontend/src/modules/MyModule2/atoms.ts b/frontend/src/modules/MyModule2/atoms.ts
index fb658d0b0..78a93f33b 100644
--- a/frontend/src/modules/MyModule2/atoms.ts
+++ b/frontend/src/modules/MyModule2/atoms.ts
@@ -1,12 +1,13 @@
 import { apiService } from "@framework/ApiService";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
 import { EnsembleSetAtom } from "@framework/GlobalAtoms";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 
 import { atom } from "jotai";
 import { atomWithQuery } from "jotai-tanstack-query";
 
 export const textAtom = atom<string>("I am an atom with text!");
-export const selectedEnsembleAtom = atom<EnsembleIdent | null>(null);
+export const selectedEnsembleAtom = atom<RegularEnsembleIdent | null>(null);
 export const vectorsAtom = atomWithQuery((get) => ({
     queryKey: ["ensembles", get(selectedEnsembleAtom)?.toString()],
     queryFn: () =>
@@ -30,8 +31,8 @@ export const selectedVectorAtom = atom<string | null>((get) => {
     return vectors.data?.at(0)?.name ?? null;
 });
 
-export const ensembleSetDependentAtom = atom<EnsembleIdent | null>((get) => {
+export const ensembleSetDependentAtom = atom<RegularEnsembleIdent | DeltaEnsembleIdent | null>((get) => {
     const ensembleSet = get(EnsembleSetAtom);
-    const firstEnsemble = ensembleSet.getEnsembleArr()[0];
+    const firstEnsemble = ensembleSet.getEnsembleArray()[0];
     return firstEnsemble?.getIdent() ?? null;
 });
diff --git a/frontend/src/modules/ParameterDistributionMatrix/interfaces.ts b/frontend/src/modules/ParameterDistributionMatrix/interfaces.ts
index f6d9b3f63..14382b094 100644
--- a/frontend/src/modules/ParameterDistributionMatrix/interfaces.ts
+++ b/frontend/src/modules/ParameterDistributionMatrix/interfaces.ts
@@ -1,5 +1,5 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ParameterIdent } from "@framework/EnsembleParameters";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { InterfaceInitialization } from "@framework/UniDirectionalModuleComponentsInterface";
 
 import {
@@ -14,7 +14,7 @@ type SettingsToViewInterface = {
     selectedVisualizationType: ParameterDistributionPlotType;
     showIndividualRealizationValues: boolean;
     showPercentilesAndMeanLines: boolean;
-    selectedEnsembleIdents: EnsembleIdent[];
+    selectedEnsembleIdents: RegularEnsembleIdent[];
     selectedParameterIdents: ParameterIdent[];
 };
 
diff --git a/frontend/src/modules/ParameterDistributionMatrix/settings/atoms/baseAtoms.ts b/frontend/src/modules/ParameterDistributionMatrix/settings/atoms/baseAtoms.ts
index f82dc9dcc..29822d4c4 100644
--- a/frontend/src/modules/ParameterDistributionMatrix/settings/atoms/baseAtoms.ts
+++ b/frontend/src/modules/ParameterDistributionMatrix/settings/atoms/baseAtoms.ts
@@ -1,28 +1,17 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ParameterIdent } from "@framework/EnsembleParameters";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { atomWithCompare } from "@framework/utils/atomUtils";
+import { areEnsembleIdentListsEqual } from "@framework/utils/ensembleIdentUtils";
 import { ParameterDistributionPlotType } from "@modules/ParameterDistributionMatrix/typesAndEnums";
 
 import { atom } from "jotai";
 
-function areEnsembleIdentListsEqual(a: EnsembleIdent[], b: EnsembleIdent[]) {
-    if (a.length !== b.length) {
-        return false;
-    }
-    for (let i = 0; i < a.length; i++) {
-        if (!a[i].equals(b[i])) {
-            return false;
-        }
-    }
-    return true;
-}
-
 export const selectedVisualizationTypeAtom = atom<ParameterDistributionPlotType>(
     ParameterDistributionPlotType.DISTRIBUTION_PLOT
 );
 export const showIndividualRealizationValuesAtom = atom<boolean>(false);
 export const showPercentilesAndMeanLinesAtom = atom<boolean>(false);
 
-export const userSelectedEnsembleIdentsAtom = atomWithCompare<EnsembleIdent[]>([], areEnsembleIdentListsEqual);
+export const userSelectedEnsembleIdentsAtom = atomWithCompare<RegularEnsembleIdent[]>([], areEnsembleIdentListsEqual);
 export const userSelectedParameterIdentsAtom = atom<ParameterIdent[]>([]);
 export const showConstantParametersAtom = atom<boolean>(false);
diff --git a/frontend/src/modules/ParameterDistributionMatrix/settings/atoms/derivedAtoms.ts b/frontend/src/modules/ParameterDistributionMatrix/settings/atoms/derivedAtoms.ts
index f484f7d0b..212c9eb62 100644
--- a/frontend/src/modules/ParameterDistributionMatrix/settings/atoms/derivedAtoms.ts
+++ b/frontend/src/modules/ParameterDistributionMatrix/settings/atoms/derivedAtoms.ts
@@ -15,8 +15,8 @@ export const selectedEnsembleIdentsAtom = atom((get) => {
     const userSelectedEnsembleIdents = get(userSelectedEnsembleIdentsAtom);
 
     let computedEnsembleIdents = userSelectedEnsembleIdents.filter((el) => ensembleSet.hasEnsemble(el));
-    if (computedEnsembleIdents.length === 0 && ensembleSet.getEnsembleArr().length > 0) {
-        computedEnsembleIdents = [ensembleSet.getEnsembleArr()[0].getIdent()];
+    if (computedEnsembleIdents.length === 0 && ensembleSet.getRegularEnsembleArray().length > 0) {
+        computedEnsembleIdents = [ensembleSet.getRegularEnsembleArray()[0].getIdent()];
     }
 
     return computedEnsembleIdents;
diff --git a/frontend/src/modules/ParameterDistributionMatrix/settings/settings.tsx b/frontend/src/modules/ParameterDistributionMatrix/settings/settings.tsx
index 34173d92f..d4acd6153 100644
--- a/frontend/src/modules/ParameterDistributionMatrix/settings/settings.tsx
+++ b/frontend/src/modules/ParameterDistributionMatrix/settings/settings.tsx
@@ -1,6 +1,6 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ParameterIdent } from "@framework/EnsembleParameters";
 import { ModuleSettingsProps } from "@framework/Module";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { useEnsembleSet } from "@framework/WorkbenchSession";
 import { EnsembleSelect } from "@framework/components/EnsembleSelect";
 import { Checkbox } from "@lib/components/Checkbox";
@@ -47,7 +47,7 @@ export function Settings({ workbenchSession }: ModuleSettingsProps<Interfaces>)
     );
     const [showPercentilesAndMeanLines, setShowPercentilesAndMeanLines] = useAtom(showPercentilesAndMeanLinesAtom);
 
-    function handleEnsembleSelectionChange(ensembleIdents: EnsembleIdent[]) {
+    function handleEnsembleSelectionChange(ensembleIdents: RegularEnsembleIdent[]) {
         setSelectedEnsembleIdents(ensembleIdents);
     }
 
@@ -98,7 +98,7 @@ export function Settings({ workbenchSession }: ModuleSettingsProps<Interfaces>)
             </CollapsibleGroup>
             <CollapsibleGroup title="Ensembles" expanded>
                 <EnsembleSelect
-                    ensembles={ensembleSet.getEnsembleArr()}
+                    ensembles={ensembleSet.getRegularEnsembleArray()}
                     onChange={handleEnsembleSelectionChange}
                     value={selectedEnsembleIdents}
                     size={5}
diff --git a/frontend/src/modules/ParameterDistributionMatrix/view/view.tsx b/frontend/src/modules/ParameterDistributionMatrix/view/view.tsx
index 7b717a11d..b047099b3 100644
--- a/frontend/src/modules/ParameterDistributionMatrix/view/view.tsx
+++ b/frontend/src/modules/ParameterDistributionMatrix/view/view.tsx
@@ -1,9 +1,9 @@
 import React from "react";
 
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ParameterIdent, ParameterType } from "@framework/EnsembleParameters";
 import { EnsembleSet } from "@framework/EnsembleSet";
 import { ModuleViewProps } from "@framework/Module";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { EnsembleRealizationFilterFunction, useEnsembleRealizationFilterFunc } from "@framework/WorkbenchSession";
 import { useElementSize } from "@lib/hooks/useElementSize";
 
@@ -51,7 +51,7 @@ export function View(props: ModuleViewProps<Interfaces>) {
 
 function makeParameterDataArr(
     ensembleSet: EnsembleSet,
-    ensembleIdents: EnsembleIdent[],
+    ensembleIdents: RegularEnsembleIdent[],
     parameterIdents: ParameterIdent[],
     filterEnsembleRealizations: EnsembleRealizationFilterFunction
 ): ParameterDataArr[] {
diff --git a/frontend/src/modules/Pvt/interfaces.ts b/frontend/src/modules/Pvt/interfaces.ts
index 4e0020e56..9c248dbfd 100644
--- a/frontend/src/modules/Pvt/interfaces.ts
+++ b/frontend/src/modules/Pvt/interfaces.ts
@@ -1,4 +1,4 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { InterfaceInitialization } from "@framework/UniDirectionalModuleComponentsInterface";
 
 import { selectedColorByAtom, selectedDependentVariablesAtom, selectedPhaseAtom } from "./settings/atoms/baseAtoms";
@@ -10,7 +10,7 @@ type SettingsToViewInterface = {
     selectedPhase: PhaseType;
     selectedColorBy: ColorBy;
     selectedDependentVariables: PressureDependentVariable[];
-    selectedEnsembleIdents: EnsembleIdent[];
+    selectedEnsembleIdents: RegularEnsembleIdent[];
     selectedPvtNums: number[];
     pvtDataQueries: CombinedPvtDataResult;
 };
diff --git a/frontend/src/modules/Pvt/settings/atoms/baseAtoms.ts b/frontend/src/modules/Pvt/settings/atoms/baseAtoms.ts
index 5f7c9cb10..e608cd02f 100644
--- a/frontend/src/modules/Pvt/settings/atoms/baseAtoms.ts
+++ b/frontend/src/modules/Pvt/settings/atoms/baseAtoms.ts
@@ -1,22 +1,11 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { atomWithCompare } from "@framework/utils/atomUtils";
+import { areEnsembleIdentListsEqual } from "@framework/utils/ensembleIdentUtils";
 import { ColorBy, PhaseType, PressureDependentVariable } from "@modules/Pvt/typesAndEnums";
 
 import { atom } from "jotai";
 import { isEqual } from "lodash";
 
-function areEnsembleIdentListsEqual(a: EnsembleIdent[], b: EnsembleIdent[]) {
-    if (a.length !== b.length) {
-        return false;
-    }
-    for (let i = 0; i < a.length; i++) {
-        if (!a[i].equals(b[i])) {
-            return false;
-        }
-    }
-    return true;
-}
-
 export const selectedPhaseAtom = atom<PhaseType>(PhaseType.OIL);
 export const selectedColorByAtom = atom<ColorBy>(ColorBy.ENSEMBLE);
 export const selectedDependentVariablesAtom = atom<PressureDependentVariable[]>([
@@ -26,6 +15,6 @@ export const selectedDependentVariablesAtom = atom<PressureDependentVariable[]>(
     PressureDependentVariable.FLUID_RATIO,
 ]);
 
-export const userSelectedEnsembleIdentsAtom = atomWithCompare<EnsembleIdent[]>([], areEnsembleIdentListsEqual);
+export const userSelectedEnsembleIdentsAtom = atomWithCompare<RegularEnsembleIdent[]>([], areEnsembleIdentListsEqual);
 export const userSelectedRealizationsAtom = atomWithCompare<number[]>([], isEqual);
 export const userSelectedPvtNumsAtom = atomWithCompare<number[]>([], isEqual);
diff --git a/frontend/src/modules/Pvt/settings/atoms/derivedAtoms.ts b/frontend/src/modules/Pvt/settings/atoms/derivedAtoms.ts
index 9238320d5..0bdcd8964 100644
--- a/frontend/src/modules/Pvt/settings/atoms/derivedAtoms.ts
+++ b/frontend/src/modules/Pvt/settings/atoms/derivedAtoms.ts
@@ -1,5 +1,4 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
-import { EnsembleRealizationFilterFunctionAtom, EnsembleSetAtom } from "@framework/GlobalAtoms";
+import { EnsembleSetAtom, ValidEnsembleRealizationsFunctionAtom } from "@framework/GlobalAtoms";
 
 import { atom } from "jotai";
 
@@ -14,26 +13,19 @@ export const selectedEnsembleIdentsAtom = atom((get) => {
     const userSelectedEnsembleIdents = get(userSelectedEnsembleIdentsAtom);
 
     let computedEnsembleIdents = userSelectedEnsembleIdents.filter((el) => ensembleSet.hasEnsemble(el));
-    if (computedEnsembleIdents.length === 0 && ensembleSet.getEnsembleArr().length > 0) {
-        computedEnsembleIdents = [ensembleSet.getEnsembleArr()[0].getIdent()];
+    if (computedEnsembleIdents.length === 0 && ensembleSet.getRegularEnsembleArray().length > 0) {
+        computedEnsembleIdents = [ensembleSet.getRegularEnsembleArray()[0].getIdent()];
     }
 
     return computedEnsembleIdents;
 });
 
 export const selectedRealizationsAtom = atom((get) => {
-    const ensembleSet = get(EnsembleSetAtom);
     const userSelectedRealizations = get(userSelectedRealizationsAtom);
     const selectedEnsembleIdents = get(selectedEnsembleIdentsAtom);
-    let ensembleRealizationFilterFunction = get(EnsembleRealizationFilterFunctionAtom);
-
-    if (ensembleRealizationFilterFunction === null) {
-        ensembleRealizationFilterFunction = (ensembleIdent: EnsembleIdent) => {
-            return ensembleSet.findEnsemble(ensembleIdent)?.getRealizations() ?? [];
-        };
-    }
 
-    const realizations = computeRealizationsIntersection(selectedEnsembleIdents, ensembleRealizationFilterFunction);
+    const validEnsembleRealizationsFunction = get(ValidEnsembleRealizationsFunctionAtom);
+    const realizations = computeRealizationsIntersection(selectedEnsembleIdents, validEnsembleRealizationsFunction);
 
     let computedRealizations = userSelectedRealizations.filter((el) => realizations.includes(el));
     if (computedRealizations.length === 0 && realizations.length > 0) {
diff --git a/frontend/src/modules/Pvt/settings/atoms/queryAtoms.ts b/frontend/src/modules/Pvt/settings/atoms/queryAtoms.ts
index e07665f4c..cd2192d59 100644
--- a/frontend/src/modules/Pvt/settings/atoms/queryAtoms.ts
+++ b/frontend/src/modules/Pvt/settings/atoms/queryAtoms.ts
@@ -1,6 +1,6 @@
 import { ApiError, PvtData_api } from "@api";
 import { apiService } from "@framework/ApiService";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { atomWithQueries } from "@framework/utils/atomUtils";
 import { UseQueryResult } from "@tanstack/react-query";
 
@@ -15,7 +15,7 @@ export const pvtDataQueriesAtom = atomWithQueries((get) => {
     const selectedEnsembleIdents = get(selectedEnsembleIdentsAtom);
     const selectedRealizations = get(selectedRealizationsAtom);
 
-    const ensembleIdentsAndRealizations: { ensembleIdent: EnsembleIdent; realization: number }[] = [];
+    const ensembleIdentsAndRealizations: { ensembleIdent: RegularEnsembleIdent; realization: number }[] = [];
     for (const ensembleIdent of selectedEnsembleIdents) {
         for (const realization of selectedRealizations) {
             ensembleIdentsAndRealizations.push({ ensembleIdent, realization });
diff --git a/frontend/src/modules/Pvt/settings/settings.tsx b/frontend/src/modules/Pvt/settings/settings.tsx
index 77bcc5d08..800cc7b7e 100644
--- a/frontend/src/modules/Pvt/settings/settings.tsx
+++ b/frontend/src/modules/Pvt/settings/settings.tsx
@@ -1,7 +1,7 @@
 import React from "react";
 
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ModuleSettingsProps } from "@framework/Module";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { useEnsembleRealizationFilterFunc, useEnsembleSet } from "@framework/WorkbenchSession";
 import { EnsembleSelect } from "@framework/components/EnsembleSelect";
 import { CollapsibleGroup } from "@lib/components/CollapsibleGroup";
@@ -57,11 +57,11 @@ export function Settings({ workbenchSession }: ModuleSettingsProps<Interfaces>)
     const [selectedDependentVariables, setSelectedPlots] = useAtom(selectedDependentVariablesAtom);
 
     const [selectedMultiEnsembleIdents, setSelectedMultiEnsembleIdents] =
-        React.useState<EnsembleIdent[]>(selectedEnsembleIdents);
+        React.useState<RegularEnsembleIdent[]>(selectedEnsembleIdents);
     const [selectedMultiRealizations, setSelectedMultiRealizations] = React.useState<number[]>(selectedRealizations);
     const [selectedMultiPvtNums, setSelectedMultiPvtNums] = React.useState<number[]>(selectedPvtNums);
 
-    function handleEnsembleSelectionChange(ensembleIdents: EnsembleIdent[]) {
+    function handleEnsembleSelectionChange(ensembleIdents: RegularEnsembleIdent[]) {
         setSelectedEnsembleIdents(ensembleIdents);
         setSelectedMultiEnsembleIdents(ensembleIdents);
     }
@@ -126,7 +126,7 @@ export function Settings({ workbenchSession }: ModuleSettingsProps<Interfaces>)
             </CollapsibleGroup>
             <CollapsibleGroup title="Ensembles" expanded>
                 <EnsembleSelect
-                    ensembles={ensembleSet.getEnsembleArr()}
+                    ensembles={ensembleSet.getRegularEnsembleArray()}
                     onChange={handleEnsembleSelectionChange}
                     value={selectedEnsembleIdents}
                     size={5}
diff --git a/frontend/src/modules/Pvt/settingsToViewInterface.ts b/frontend/src/modules/Pvt/settingsToViewInterface.ts
index 96631ddf1..bf6d41d69 100644
--- a/frontend/src/modules/Pvt/settingsToViewInterface.ts
+++ b/frontend/src/modules/Pvt/settingsToViewInterface.ts
@@ -1,4 +1,4 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { InterfaceInitialization } from "@framework/UniDirectionalModuleComponentsInterface";
 
 import { selectedColorByAtom, selectedDependentVariablesAtom, selectedPhaseAtom } from "./settings/atoms/baseAtoms";
@@ -12,7 +12,7 @@ export type SettingsToViewInterface = {
     selectedPhase: PhaseType;
     selectedColorBy: ColorBy;
     selectedDependentVariables: PressureDependentVariable[];
-    selectedEnsembleIdents: EnsembleIdent[];
+    selectedEnsembleIdents: RegularEnsembleIdent[];
     selectedPvtNums: number[];
     pvtDataQueries: CombinedPvtDataResult;
 };
diff --git a/frontend/src/modules/Pvt/typesAndEnums.ts b/frontend/src/modules/Pvt/typesAndEnums.ts
index 8e30ec40b..04c89eb43 100644
--- a/frontend/src/modules/Pvt/typesAndEnums.ts
+++ b/frontend/src/modules/Pvt/typesAndEnums.ts
@@ -1,5 +1,5 @@
 import { ApiError, PvtData_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 
 export enum ColorBy {
     ENSEMBLE = "ensemble",
@@ -38,7 +38,7 @@ export type Phase = {
 };
 
 export type PvtTableCollection = {
-    ensembleIdent: EnsembleIdent;
+    ensembleIdent: RegularEnsembleIdent;
     realization: number;
     tables: PvtData_api[];
 };
diff --git a/frontend/src/modules/Pvt/utils/PvtPlotBuilder.ts b/frontend/src/modules/Pvt/utils/PvtPlotBuilder.ts
index 231adeb95..9a63f9ca0 100644
--- a/frontend/src/modules/Pvt/utils/PvtPlotBuilder.ts
+++ b/frontend/src/modules/Pvt/utils/PvtPlotBuilder.ts
@@ -1,5 +1,5 @@
 import { PvtData_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { ColorSet } from "@lib/utils/ColorSet";
 import { Size2D } from "@lib/utils/geometry";
 import { Figure, makeSubplots } from "@modules/_shared/Figure";
@@ -25,9 +25,12 @@ export class PvtPlotBuilder {
     private readonly _pvtDataAccessor: PvtDataAccessor;
     private _figure: Figure | null = null;
     private _numPlots = 0;
-    private readonly _makeEnsembleDisplayNameFunc: (ensemble: EnsembleIdent) => string;
+    private readonly _makeEnsembleDisplayNameFunc: (ensemble: RegularEnsembleIdent) => string;
 
-    constructor(pvtDataAccessor: PvtDataAccessor, makeEnsembleDisplayNameFunc: (ensemble: EnsembleIdent) => string) {
+    constructor(
+        pvtDataAccessor: PvtDataAccessor,
+        makeEnsembleDisplayNameFunc: (ensemble: RegularEnsembleIdent) => string
+    ) {
         this._pvtDataAccessor = pvtDataAccessor;
         this._makeEnsembleDisplayNameFunc = makeEnsembleDisplayNameFunc;
     }
@@ -290,7 +293,7 @@ export class PvtPlotBuilder {
         ratios: readonly number[],
         pvtNum: number,
         phase: PhaseType,
-        ensembleIdent: EnsembleIdent,
+        ensembleIdent: RegularEnsembleIdent,
         realization: number
     ): string[] {
         const nameY = PRESSURE_DEPENDENT_VARIABLE_TO_DISPLAY_NAME[dependentVariable];
diff --git a/frontend/src/modules/Pvt/utils/realizationsIntersection.ts b/frontend/src/modules/Pvt/utils/realizationsIntersection.ts
index 4d8009cc6..2295946ac 100644
--- a/frontend/src/modules/Pvt/utils/realizationsIntersection.ts
+++ b/frontend/src/modules/Pvt/utils/realizationsIntersection.ts
@@ -1,8 +1,8 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { EnsembleRealizationFilterFunction } from "@framework/WorkbenchSession";
 
 export function computeRealizationsIntersection(
-    ensembleIdents: EnsembleIdent[],
+    ensembleIdents: RegularEnsembleIdent[],
     filterEnsembleRealizations: EnsembleRealizationFilterFunction
 ) {
     let realizationsIntersection: number[] = [];
diff --git a/frontend/src/modules/Pvt/view.tsx b/frontend/src/modules/Pvt/view.tsx
index f76bc234c..90a00def2 100644
--- a/frontend/src/modules/Pvt/view.tsx
+++ b/frontend/src/modules/Pvt/view.tsx
@@ -1,8 +1,8 @@
 import React from "react";
 
-import { Ensemble } from "@framework/Ensemble";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ModuleViewProps } from "@framework/Module";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { useViewStatusWriter } from "@framework/StatusWriter";
 import { useEnsembleSet } from "@framework/WorkbenchSession";
 import { ApiErrorHelper } from "@framework/utils/ApiErrorHelper";
@@ -69,7 +69,7 @@ export function View({ viewContext, workbenchSettings, workbenchSession }: Modul
             return <ContentMessage type={ContentMessageType.INFO}>No plots selected.</ContentMessage>;
         }
 
-        const selectedEnsembles: Ensemble[] = [];
+        const selectedEnsembles: RegularEnsemble[] = [];
         for (const ensembleIdent of selectedEnsembleIdents) {
             const ensemble = ensembleSet.findEnsemble(ensembleIdent);
             if (ensemble) {
@@ -77,7 +77,7 @@ export function View({ viewContext, workbenchSettings, workbenchSession }: Modul
             }
         }
 
-        function makeEnsembleDisplayName(ensembleIdent: EnsembleIdent): string {
+        function makeEnsembleDisplayName(ensembleIdent: RegularEnsembleIdent): string {
             return makeDistinguishableEnsembleDisplayName(ensembleIdent, selectedEnsembles);
         }
 
diff --git a/frontend/src/modules/Rft/settings.tsx b/frontend/src/modules/Rft/settings.tsx
index 98d127301..a427f427d 100644
--- a/frontend/src/modules/Rft/settings.tsx
+++ b/frontend/src/modules/Rft/settings.tsx
@@ -1,5 +1,7 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import React from "react";
+
 import { ModuleSettingsProps } from "@framework/Module";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { useSettingsStatusWriter } from "@framework/StatusWriter";
 import { useEnsembleRealizationFilterFunc, useEnsembleSet } from "@framework/WorkbenchSession";
 import { EnsembleDropdown } from "@framework/components/EnsembleDropdown";
@@ -69,7 +71,7 @@ export function Settings({ settingsContext, workbenchSession }: ModuleSettingsPr
 
     const rftTableDefErrorMessage = usePropagateApiErrorToStatusWriter(rftTableDefinition, statusWriter) ?? "";
 
-    function handleEnsembleSelectionChange(ensembleIdent: EnsembleIdent | null) {
+    function handleEnsembleSelectionChange(ensembleIdent: RegularEnsembleIdent | null) {
         setUserSelectedEnsembleIdent(ensembleIdent);
     }
     function handleResponseNameChange(responseNames: string[]) {
@@ -86,7 +88,7 @@ export function Settings({ settingsContext, workbenchSession }: ModuleSettingsPr
         <div>
             <CollapsibleGroup expanded={true} title="Ensembles">
                 <EnsembleDropdown
-                    ensembles={ensembleSet.getEnsembleArr()}
+                    ensembles={ensembleSet.getRegularEnsembleArray()}
                     value={selectedEnsembleIdent}
                     onChange={handleEnsembleSelectionChange}
                 />
diff --git a/frontend/src/modules/Rft/settings/atoms/baseAtoms.ts b/frontend/src/modules/Rft/settings/atoms/baseAtoms.ts
index 204f10cc6..11b5d0c65 100644
--- a/frontend/src/modules/Rft/settings/atoms/baseAtoms.ts
+++ b/frontend/src/modules/Rft/settings/atoms/baseAtoms.ts
@@ -1,16 +1,10 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { atomWithCompare } from "@framework/utils/atomUtils";
+import { areEnsembleIdentsEqual } from "@framework/utils/ensembleIdentUtils";
 
 import { atom } from "jotai";
 
-function areEnsembleIdentsEqual(a: EnsembleIdent | null, b: EnsembleIdent | null) {
-    if (a === null) {
-        return b === null;
-    }
-    return a.equals(b);
-}
-
-export const userSelectedEnsembleIdentAtom = atomWithCompare<EnsembleIdent | null>(null, areEnsembleIdentsEqual);
+export const userSelectedEnsembleIdentAtom = atomWithCompare<RegularEnsembleIdent | null>(null, areEnsembleIdentsEqual);
 export const validRealizationNumbersAtom = atom<number[] | null>(null);
 export const userSelectedResponseNameAtom = atom<string | null>(null);
 export const userSelectedWellNameAtom = atom<string | null>(null);
diff --git a/frontend/src/modules/Rft/settings/atoms/derivedAtoms.ts b/frontend/src/modules/Rft/settings/atoms/derivedAtoms.ts
index e43207228..f4994bc36 100644
--- a/frontend/src/modules/Rft/settings/atoms/derivedAtoms.ts
+++ b/frontend/src/modules/Rft/settings/atoms/derivedAtoms.ts
@@ -1,6 +1,6 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { EnsembleSetAtom } from "@framework/GlobalAtoms";
-import { fixupEnsembleIdent } from "@framework/utils/ensembleUiHelpers";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
+import { fixupRegularEnsembleIdent } from "@framework/utils/ensembleUiHelpers";
 
 import { atom } from "jotai";
 
@@ -26,11 +26,11 @@ function fixupSelectedOrFirstValue<T extends string | number>(selectedValue: T |
     return null;
 }
 
-export const selectedEnsembleIdentAtom = atom<EnsembleIdent | null>((get) => {
+export const selectedEnsembleIdentAtom = atom<RegularEnsembleIdent | null>((get) => {
     const ensembleSet = get(EnsembleSetAtom);
     const userSelectedEnsembleIdent = get(userSelectedEnsembleIdentAtom);
 
-    const validEnsembleIdent = fixupEnsembleIdent(userSelectedEnsembleIdent, ensembleSet);
+    const validEnsembleIdent = fixupRegularEnsembleIdent(userSelectedEnsembleIdent, ensembleSet);
     return validEnsembleIdent;
 });
 
diff --git a/frontend/src/modules/SimulationTimeSeries/dataGenerators.ts b/frontend/src/modules/SimulationTimeSeries/dataGenerators.ts
index 7e7047f78..b8d2775b2 100644
--- a/frontend/src/modules/SimulationTimeSeries/dataGenerators.ts
+++ b/frontend/src/modules/SimulationTimeSeries/dataGenerators.ts
@@ -1,18 +1,23 @@
 import { VectorRealizationData_api } from "@api";
 import { ChannelContentMetaData, DataGenerator } from "@framework/DataChannelTypes";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { simulationUnitReformat, simulationVectorDescription } from "@modules/_shared/reservoirSimulationStringUtils";
 
 import { VectorSpec } from "./typesAndEnums";
 
+// As of now, the publish to data channels only supports regular ensembles
+export interface RegularEnsembleVectorSpec extends VectorSpec {
+    ensembleIdent: RegularEnsembleIdent;
+}
+
 export function makeVectorGroupDataGenerator(
-    vectorSpecification: VectorSpec,
-    vectorSpecificationsAndRealizationData: {
-        vectorSpecification: VectorSpec;
+    regularEnsembleVectorSpecification: RegularEnsembleVectorSpec,
+    regularEnsembleVectorSpecificationsAndRealizationData: {
+        vectorSpecification: RegularEnsembleVectorSpec;
         data: VectorRealizationData_api[];
     }[],
     activeTimestampUtcMs: number,
-    makeEnsembleDisplayName: (ensembleIdent: EnsembleIdent) => string
+    makeEnsembleDisplayName: (ensembleIdent: RegularEnsembleIdent) => string
 ): DataGenerator {
     return () => {
         const data: { key: number; value: number }[] = [];
@@ -22,11 +27,12 @@ export function makeVectorGroupDataGenerator(
             displayString: "",
         };
 
-        const vector = vectorSpecificationsAndRealizationData.find(
+        const vector = regularEnsembleVectorSpecificationsAndRealizationData.find(
             (vec) =>
-                vec.vectorSpecification.vectorName === vectorSpecification.vectorName &&
-                vec.vectorSpecification.ensembleIdent.equals(vectorSpecification.ensembleIdent)
+                vec.vectorSpecification.vectorName === regularEnsembleVectorSpecification.vectorName &&
+                vec.vectorSpecification.ensembleIdent.equals(regularEnsembleVectorSpecification.ensembleIdent)
         );
+
         if (vector) {
             let unit = "";
             vector.data.forEach((el) => {
diff --git a/frontend/src/modules/SimulationTimeSeries/interfaces.ts b/frontend/src/modules/SimulationTimeSeries/interfaces.ts
index b1c2d1652..c1e0fbf81 100644
--- a/frontend/src/modules/SimulationTimeSeries/interfaces.ts
+++ b/frontend/src/modules/SimulationTimeSeries/interfaces.ts
@@ -1,6 +1,7 @@
 import { Frequency_api } from "@api";
-import { Ensemble } from "@framework/Ensemble";
+import { DeltaEnsemble } from "@framework/DeltaEnsemble";
 import { ParameterIdent } from "@framework/EnsembleParameters";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
 import { InterfaceInitialization } from "@framework/UniDirectionalModuleComponentsInterface";
 
 import {
@@ -12,7 +13,12 @@ import {
     statisticsSelectionAtom,
     visualizationModeAtom,
 } from "./settings/atoms/baseAtoms";
-import { parameterIdentAtom, selectedEnsemblesAtom, vectorSpecificationsAtom } from "./settings/atoms/derivedAtoms";
+import {
+    parameterIdentAtom,
+    selectedDeltaEnsemblesAtom,
+    selectedRegularEnsemblesAtom,
+    vectorSpecificationsAtom,
+} from "./settings/atoms/derivedAtoms";
 import { GroupBy, StatisticsSelection, VectorSpec, VisualizationMode } from "./typesAndEnums";
 
 export type SettingsToViewInterface = {
@@ -24,7 +30,8 @@ export type SettingsToViewInterface = {
     statisticsSelection: StatisticsSelection;
     colorByParameter: boolean;
     parameterIdent: ParameterIdent | null;
-    selectedEnsembles: Ensemble[];
+    selectedRegularEnsembles: RegularEnsemble[];
+    selectedDeltaEnsembles: DeltaEnsemble[];
     resampleFrequency: Frequency_api | null;
 };
 
@@ -57,8 +64,11 @@ export const settingsToViewInterfaceInitialization: InterfaceInitialization<Sett
     parameterIdent: (get) => {
         return get(parameterIdentAtom);
     },
-    selectedEnsembles: (get) => {
-        return get(selectedEnsemblesAtom);
+    selectedRegularEnsembles: (get) => {
+        return get(selectedRegularEnsemblesAtom);
+    },
+    selectedDeltaEnsembles: (get) => {
+        return get(selectedDeltaEnsemblesAtom);
     },
     resampleFrequency: (get) => {
         return get(resampleFrequencyAtom);
diff --git a/frontend/src/modules/SimulationTimeSeries/settings/atoms/baseAtoms.ts b/frontend/src/modules/SimulationTimeSeries/settings/atoms/baseAtoms.ts
index 2aee400f0..242594030 100644
--- a/frontend/src/modules/SimulationTimeSeries/settings/atoms/baseAtoms.ts
+++ b/frontend/src/modules/SimulationTimeSeries/settings/atoms/baseAtoms.ts
@@ -1,7 +1,9 @@
 import { Frequency_api, StatisticFunction_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
 import { ParameterIdent } from "@framework/EnsembleParameters";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { atomWithCompare } from "@framework/utils/atomUtils";
+import { areEnsembleIdentListsEqual } from "@framework/utils/ensembleIdentUtils";
 
 import { atom } from "jotai";
 import { isEqual } from "lodash";
@@ -25,7 +27,10 @@ export const statisticsSelectionAtom = atom<StatisticsSelection>({
     FanchartStatisticsSelection: Object.values(FanchartStatisticOption),
 });
 
-export const userSelectedEnsembleIdentsAtom = atomWithCompare<EnsembleIdent[]>([], isEqual);
+export const userSelectedEnsembleIdentsAtom = atomWithCompare<(RegularEnsembleIdent | DeltaEnsembleIdent)[]>(
+    [],
+    areEnsembleIdentListsEqual
+);
 
 export const selectedVectorNamesAtom = atomWithCompare<string[]>([], isEqual);
 
diff --git a/frontend/src/modules/SimulationTimeSeries/settings/atoms/derivedAtoms.ts b/frontend/src/modules/SimulationTimeSeries/settings/atoms/derivedAtoms.ts
index 7614ba905..aa2103ca6 100644
--- a/frontend/src/modules/SimulationTimeSeries/settings/atoms/derivedAtoms.ts
+++ b/frontend/src/modules/SimulationTimeSeries/settings/atoms/derivedAtoms.ts
@@ -1,7 +1,10 @@
-import { Ensemble } from "@framework/Ensemble";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { DeltaEnsemble } from "@framework/DeltaEnsemble";
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
 import { Parameter, ParameterIdent, ParameterType } from "@framework/EnsembleParameters";
 import { EnsembleSetAtom } from "@framework/GlobalAtoms";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
+import { filterEnsembleIdentsByType } from "@framework/utils/ensembleIdentUtils";
 import { fixupEnsembleIdents } from "@framework/utils/ensembleUiHelpers";
 import { createVectorSelectorDataFromVectors } from "@modules/_shared/components/VectorSelector";
 
@@ -29,23 +32,24 @@ export const statisticsTypeAtom = atom<StatisticsType>((get) => {
     return StatisticsType.INDIVIDUAL;
 });
 
-export const selectedEnsembleIdentsAtom = atom<EnsembleIdent[]>((get) => {
+export const selectedEnsembleIdentsAtom = atom<(RegularEnsembleIdent | DeltaEnsembleIdent)[]>((get) => {
     const ensembleSet = get(EnsembleSetAtom);
     const selectedEnsembleIdents = get(userSelectedEnsembleIdentsAtom);
 
     const newSelectedEnsembleIdents = selectedEnsembleIdents.filter((ensemble) => ensembleSet.hasEnsemble(ensemble));
-
     const validatedEnsembleIdents = fixupEnsembleIdents(newSelectedEnsembleIdents, ensembleSet);
 
     return validatedEnsembleIdents ?? [];
 });
 
-export const selectedEnsemblesAtom = atom((get) => {
+export const selectedRegularEnsemblesAtom = atom<RegularEnsemble[]>((get) => {
+    // NOTE: Used for view and color by parameter, i.e. not for delta ensembles yet!
     const ensembleSet = get(EnsembleSetAtom);
-    const selectedEnsembleIdents = get(selectedEnsembleIdentsAtom);
+    const allSelectedEnsembleIdents = get(selectedEnsembleIdentsAtom);
 
-    const selectedEnsembles: Ensemble[] = [];
+    const selectedEnsembleIdents = filterEnsembleIdentsByType(allSelectedEnsembleIdents, RegularEnsembleIdent);
 
+    const selectedEnsembles: RegularEnsemble[] = [];
     for (const ensembleIdent of selectedEnsembleIdents) {
         const ensemble = ensembleSet.findEnsemble(ensembleIdent);
         if (ensemble) {
@@ -56,15 +60,36 @@ export const selectedEnsemblesAtom = atom((get) => {
     return selectedEnsembles;
 });
 
-export const continuousAndNonConstantParametersUnionAtom = atom<Parameter[]>((get) => {
+export const selectedDeltaEnsemblesAtom = atom<DeltaEnsemble[]>((get) => {
     const ensembleSet = get(EnsembleSetAtom);
     const selectedEnsembleIdents = get(selectedEnsembleIdentsAtom);
 
-    const continuousAndNonConstantParametersUnion: Parameter[] = [];
+    const selectedDeltaEnsembleIdents = filterEnsembleIdentsByType(selectedEnsembleIdents, DeltaEnsembleIdent);
 
-    for (const ensembleIdent of selectedEnsembleIdents) {
+    const selectedDeltaEnsembles: DeltaEnsemble[] = [];
+    for (const ensembleIdent of selectedDeltaEnsembleIdents) {
         const ensemble = ensembleSet.findEnsemble(ensembleIdent);
+        if (ensemble) {
+            selectedDeltaEnsembles.push(ensemble);
+        }
+    }
+    return selectedDeltaEnsembles;
+});
 
+export const continuousAndNonConstantParametersUnionAtom = atom<Parameter[]>((get) => {
+    const ensembleSet = get(EnsembleSetAtom);
+    const selectedEnsembleIdents = get(selectedEnsembleIdentsAtom);
+
+    // Does not support parameters for delta ensembles yet
+    const hasAnyDeltaEnsembles = filterEnsembleIdentsByType(selectedEnsembleIdents, DeltaEnsembleIdent).length > 0;
+    if (hasAnyDeltaEnsembles) {
+        return [];
+    }
+
+    const continuousAndNonConstantParametersUnion: Parameter[] = [];
+    const regularEnsembleIdents = filterEnsembleIdentsByType(selectedEnsembleIdents, RegularEnsembleIdent);
+    for (const ensembleIdent of regularEnsembleIdents) {
+        const ensemble = ensembleSet.findEnsemble(ensembleIdent);
         if (!ensemble) {
             continue;
         }
@@ -114,7 +139,7 @@ export const vectorSelectorDataAtom = atom((get) => {
     return createVectorSelectorDataFromVectors(availableVectorNames);
 });
 
-export const ensembleVectorListsHelperAtom = atom((get) => {
+export const ensembleVectorListsHelperAtom = atom<EnsembleVectorListsHelper>((get) => {
     const vectorListQueries = get(vectorListQueriesAtom);
     const selectedEnsembleIdents = get(selectedEnsembleIdentsAtom);
 
@@ -128,7 +153,6 @@ export const vectorSpecificationsAtom = atom<VectorSpec[]>((get) => {
     const selectedVectorNames = get(selectedVectorNamesAtom);
 
     const vectorSpecifications: VectorSpec[] = [];
-
     for (const ensembleIdent of selectedEnsembleIdents) {
         for (const vectorName of selectedVectorNames) {
             if (!ensembleVectorListsHelper.isVectorInEnsemble(ensembleIdent, vectorName)) {
@@ -136,7 +160,7 @@ export const vectorSpecificationsAtom = atom<VectorSpec[]>((get) => {
             }
 
             vectorSpecifications.push({
-                ensembleIdent,
+                ensembleIdent: ensembleIdent,
                 color: ensembleSet.findEnsemble(ensembleIdent)?.getColor() ?? null,
                 vectorName,
                 hasHistoricalVector: ensembleVectorListsHelper.hasHistoricalVector(ensembleIdent, vectorName),
diff --git a/frontend/src/modules/SimulationTimeSeries/settings/atoms/queryAtoms.ts b/frontend/src/modules/SimulationTimeSeries/settings/atoms/queryAtoms.ts
index 459b34cfe..100ca533c 100644
--- a/frontend/src/modules/SimulationTimeSeries/settings/atoms/queryAtoms.ts
+++ b/frontend/src/modules/SimulationTimeSeries/settings/atoms/queryAtoms.ts
@@ -1,5 +1,8 @@
 import { apiService } from "@framework/ApiService";
+import { EnsembleSetAtom } from "@framework/GlobalAtoms";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { atomWithQueries } from "@framework/utils/atomUtils";
+import { isEnsembleIdentOfType } from "@framework/utils/ensembleIdentUtils";
 
 import { selectedEnsembleIdentsAtom } from "./derivedAtoms";
 
@@ -7,13 +10,35 @@ const STALE_TIME = 60 * 1000;
 const CACHE_TIME = 60 * 1000;
 
 export const vectorListQueriesAtom = atomWithQueries((get) => {
+    const ensembleSet = get(EnsembleSetAtom);
     const selectedEnsembleIdents = get(selectedEnsembleIdentsAtom);
 
     const queries = selectedEnsembleIdents.map((ensembleIdent) => {
+        // Regular Ensemble
+        if (isEnsembleIdentOfType(ensembleIdent, RegularEnsembleIdent)) {
+            return () => ({
+                queryKey: ["getVectorList", ensembleIdent.toString()],
+                queryFn: () =>
+                    apiService.timeseries.getVectorList(ensembleIdent.getCaseUuid(), ensembleIdent.getEnsembleName()),
+                staleTime: STALE_TIME,
+                gcTime: CACHE_TIME,
+            });
+        }
+
+        // Delta Ensemble
+        const deltaEnsemble = ensembleSet.getEnsemble(ensembleIdent);
+        const compareEnsembleIdent = deltaEnsemble.getCompareEnsembleIdent();
+        const referenceEnsembleIdent = deltaEnsemble.getReferenceEnsembleIdent();
+
         return () => ({
-            queryKey: ["ensembles", ensembleIdent.toString()],
+            queryKey: ["getDeltaEnsembleVectorList", ensembleIdent.toString()],
             queryFn: () =>
-                apiService.timeseries.getVectorList(ensembleIdent.getCaseUuid(), ensembleIdent.getEnsembleName()),
+                apiService.timeseries.getDeltaEnsembleVectorList(
+                    compareEnsembleIdent.getCaseUuid(),
+                    compareEnsembleIdent.getEnsembleName(),
+                    referenceEnsembleIdent.getCaseUuid(),
+                    referenceEnsembleIdent.getEnsembleName()
+                ),
             staleTime: STALE_TIME,
             gcTime: CACHE_TIME,
         });
diff --git a/frontend/src/modules/SimulationTimeSeries/settings/hooks/useMakeSettingsStatusWriterMessages.ts b/frontend/src/modules/SimulationTimeSeries/settings/hooks/useMakeSettingsStatusWriterMessages.ts
index a11d5ed89..8a9d03833 100644
--- a/frontend/src/modules/SimulationTimeSeries/settings/hooks/useMakeSettingsStatusWriterMessages.ts
+++ b/frontend/src/modules/SimulationTimeSeries/settings/hooks/useMakeSettingsStatusWriterMessages.ts
@@ -1,5 +1,6 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
 import { EnsembleSetAtom } from "@framework/GlobalAtoms";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { SettingsStatusWriter } from "@framework/StatusWriter";
 import { joinStringArrayToHumanReadableString } from "@modules/SimulationTimeSeries/utils/stringUtils";
 
@@ -29,7 +30,10 @@ export function useMakeSettingsStatusWriterMessages(statusWriter: SettingsStatus
     }
 
     // Set warning for vector names not existing in a selected ensemble
-    function validateVectorNamesInEnsemble(vectorNames: string[], ensembleIdent: EnsembleIdent) {
+    function validateVectorNamesInEnsemble(
+        vectorNames: string[],
+        ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent
+    ) {
         const existingVectors = vectorNames.filter((vector) =>
             ensembleVectorListsHelper.isVectorInEnsemble(ensembleIdent, vector)
         );
diff --git a/frontend/src/modules/SimulationTimeSeries/settings/settings.tsx b/frontend/src/modules/SimulationTimeSeries/settings/settings.tsx
index e524f8437..eead3602e 100644
--- a/frontend/src/modules/SimulationTimeSeries/settings/settings.tsx
+++ b/frontend/src/modules/SimulationTimeSeries/settings/settings.tsx
@@ -1,9 +1,10 @@
 import React from "react";
 
 import { Frequency_api, StatisticFunction_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
 import { Parameter, ParameterIdent } from "@framework/EnsembleParameters";
 import { ModuleSettingsProps } from "@framework/Module";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { useSettingsStatusWriter } from "@framework/StatusWriter";
 import { useEnsembleSet } from "@framework/WorkbenchSession";
 import { EnsembleSelect } from "@framework/components/EnsembleSelect";
@@ -104,8 +105,8 @@ export function Settings({ settingsContext, workbenchSession }: ModuleSettingsPr
         setUserSelectedParameterIdentStr(null);
     }
 
-    function handleEnsembleSelectChange(ensembleIdentArr: EnsembleIdent[]) {
-        setUserSelectedEnsembleIdents(ensembleIdentArr);
+    function handleEnsembleSelectChange(ensembleIdentArray: (RegularEnsembleIdent | DeltaEnsembleIdent)[]) {
+        setUserSelectedEnsembleIdents(ensembleIdentArray);
     }
 
     function handleVectorSelectionChange(selection: SmartNodeSelectorSelection) {
@@ -249,8 +250,9 @@ export function Settings({ settingsContext, workbenchSession }: ModuleSettingsPr
             </CollapsibleGroup>
             <CollapsibleGroup expanded={true} title="Ensembles">
                 <EnsembleSelect
-                    ensembles={ensembleSet.getEnsembleArr()}
+                    ensembles={ensembleSet.getEnsembleArray()}
                     value={selectedEnsembleIdents}
+                    allowDeltaEnsembles={true}
                     size={5}
                     onChange={handleEnsembleSelectChange}
                 />
diff --git a/frontend/src/modules/SimulationTimeSeries/typesAndEnums.ts b/frontend/src/modules/SimulationTimeSeries/typesAndEnums.ts
index 320daf27e..2ee155d88 100644
--- a/frontend/src/modules/SimulationTimeSeries/typesAndEnums.ts
+++ b/frontend/src/modules/SimulationTimeSeries/typesAndEnums.ts
@@ -1,5 +1,6 @@
 import { Frequency_api, StatisticFunction_api, SummaryVectorObservations_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 
 /**
  * Definition of ensemble vector observation data
@@ -15,7 +16,7 @@ export type EnsembleVectorObservationData = {
 /**
  * Definition of map of ensemble ident and ensemble vector observation data
  */
-export type EnsembleVectorObservationDataMap = Map<EnsembleIdent, EnsembleVectorObservationData>;
+export type EnsembleVectorObservationDataMap = Map<RegularEnsembleIdent, EnsembleVectorObservationData>;
 
 /**
  * Definition of vector observations queries result for combined queries
@@ -27,7 +28,7 @@ export type VectorObservationsQueriesResult = {
 };
 
 export interface VectorSpec {
-    ensembleIdent: EnsembleIdent;
+    ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent;
     color: string | null;
     vectorName: string;
     hasHistoricalVector: boolean;
diff --git a/frontend/src/modules/SimulationTimeSeries/utils/ensemblesVectorListHelper.ts b/frontend/src/modules/SimulationTimeSeries/utils/ensemblesVectorListHelper.ts
index 6afc59107..350e8f406 100644
--- a/frontend/src/modules/SimulationTimeSeries/utils/ensemblesVectorListHelper.ts
+++ b/frontend/src/modules/SimulationTimeSeries/utils/ensemblesVectorListHelper.ts
@@ -1,24 +1,31 @@
 import { VectorDescription_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { UseQueryResult } from "@tanstack/react-query";
 
 /**
  * Helper class for working with ensembles and corresponding vector list query results
+ *
+ * Assuming that the order of ensembles and queries is the same
  */
 export class EnsembleVectorListsHelper {
-    private _ensembleIdents: EnsembleIdent[];
+    private _ensembleIdents: (RegularEnsembleIdent | DeltaEnsembleIdent)[];
     private _queries: UseQueryResult<VectorDescription_api[]>[];
 
-    constructor(ensembles: EnsembleIdent[], vectorListQueryResults: UseQueryResult<VectorDescription_api[]>[]) {
-        if (ensembles.length !== vectorListQueryResults.length) {
+    constructor(
+        ensembleIdents: (RegularEnsembleIdent | DeltaEnsembleIdent)[],
+        vectorListQueryResults: UseQueryResult<VectorDescription_api[]>[]
+    ) {
+        if (ensembleIdents.length !== vectorListQueryResults.length) {
             throw new Error("Number of ensembles and vector list query results must be equal");
         }
 
-        this._ensembleIdents = ensembles;
+        this._ensembleIdents = ensembleIdents;
         this._queries = vectorListQueryResults;
     }
 
     /**
+     * Get number of queries with data results
      *
      * @returns Number of queries with data results
      */
@@ -27,6 +34,7 @@ export class EnsembleVectorListsHelper {
     }
 
     /**
+     * Get union of vector names from all queries
      *
      * @returns Array of unique vector names, as union of all vectors in all queries
      */
@@ -44,13 +52,14 @@ export class EnsembleVectorListsHelper {
     }
 
     /**
+     * Check if vector is in the requested ensembles
      *
-     * @param ensemble - EnsembleIdent to check
+     * @param ensembleIdent - RegularEnsembleIdent or DeltaEnsembleIdent to check
      * @param vector - Vector name to look for
-     * @returns
+     * @returns True if vector is in the ensemble query data, false otherwise
      */
-    isVectorInEnsemble(ensemble: EnsembleIdent, vector: string): boolean {
-        const index = this._ensembleIdents.indexOf(ensemble);
+    isVectorInEnsemble(ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent, vector: string): boolean {
+        const index = this.findIndexOfEnsembleIdent(ensembleIdent);
 
         if (index === -1 || !this._queries[index].data) return false;
 
@@ -58,21 +67,23 @@ export class EnsembleVectorListsHelper {
     }
 
     /**
+     * Check if vector has historical vector in the ensemble
      *
-     * @param ensemble - EnsembleIdent to check
+     * @param ensembleIdent - RegularEnsembleIdent or DeltaEnsembleIdent to check
      * @param vector - Vector name to look for
-     * @returns
+     * @returns True if vector has historical vector in the ensemble query data, false otherwise
      */
-    hasHistoricalVector(ensemble: EnsembleIdent, vector: string): boolean {
-        if (!this.isVectorInEnsemble(ensemble, vector)) return false;
+    hasHistoricalVector(ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent, vector: string): boolean {
+        if (!this.isVectorInEnsemble(ensembleIdent, vector)) return false;
 
-        const index = this._ensembleIdents.indexOf(ensemble);
+        const index = this.findIndexOfEnsembleIdent(ensembleIdent);
         if (index === -1 || !this._queries[index].data) return false;
 
         return this._queries[index].data?.some((vec) => vec.name === vector && vec.has_historical) ?? false;
     }
 
     /**
+     * Check if provided vector has historical vector in one or more of the ensembles
      *
      * @param vectors - Array of vector names to look for
      * @returns True if one or more of the vectors has historical vector in one or more of the ensembles, false otherwise
@@ -82,4 +93,15 @@ export class EnsembleVectorListsHelper {
             vectors.some((vector) => this.hasHistoricalVector(ensemble, vector))
         );
     }
+
+    /**
+     * Find index of the provided ensemble ident in the list of ensembles
+     * @param ensembleIdent - RegularEnsembleIdent or DeltaEnsembleIdent to find
+     * @returns Index of the ensemble ident in the list, or -1 if not found
+     */
+    private findIndexOfEnsembleIdent(ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent): number {
+        return this._ensembleIdents.findIndex((ident) => {
+            return ident.equals(ensembleIdent);
+        });
+    }
 }
diff --git a/frontend/src/modules/SimulationTimeSeries/view/atoms/baseAtoms.ts b/frontend/src/modules/SimulationTimeSeries/view/atoms/baseAtoms.ts
index 8c0d836d5..a7e8c2a78 100644
--- a/frontend/src/modules/SimulationTimeSeries/view/atoms/baseAtoms.ts
+++ b/frontend/src/modules/SimulationTimeSeries/view/atoms/baseAtoms.ts
@@ -1,6 +1,4 @@
 import { Frequency_api } from "@api";
-import { Ensemble } from "@framework/Ensemble";
-import { ParameterIdent } from "@framework/EnsembleParameters";
 import { VectorSpec, VisualizationMode } from "@modules/SimulationTimeSeries/typesAndEnums";
 
 import { atom } from "jotai";
@@ -10,6 +8,3 @@ export const vectorSpecificationsAtom = atom<VectorSpec[]>([]);
 export const resampleFrequencyAtom = atom<Frequency_api | null>(null);
 export const visualizationModeAtom = atom<VisualizationMode>(VisualizationMode.STATISTICAL_FANCHART);
 export const showObservationsAtom = atom<boolean>(true);
-export const interfaceColorByParameterAtom = atom<boolean>(false);
-export const parameterIdentAtom = atom<ParameterIdent | null>(null);
-export const selectedEnsemblesAtom = atom<Ensemble[]>([]);
diff --git a/frontend/src/modules/SimulationTimeSeries/view/atoms/derivedAtoms.ts b/frontend/src/modules/SimulationTimeSeries/view/atoms/derivedAtoms.ts
index a74605348..f0449d017 100644
--- a/frontend/src/modules/SimulationTimeSeries/view/atoms/derivedAtoms.ts
+++ b/frontend/src/modules/SimulationTimeSeries/view/atoms/derivedAtoms.ts
@@ -1,17 +1,11 @@
-import { VisualizationMode } from "@modules/SimulationTimeSeries/typesAndEnums";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
+import { isEnsembleIdentOfType } from "@framework/utils/ensembleIdentUtils";
 
 import { atom } from "jotai";
 
+import { userSelectedActiveTimestampUtcMsAtom, vectorSpecificationsAtom } from "./baseAtoms";
 import {
-    interfaceColorByParameterAtom,
-    parameterIdentAtom,
-    selectedEnsemblesAtom,
-    userSelectedActiveTimestampUtcMsAtom,
-    vectorSpecificationsAtom,
-    visualizationModeAtom,
-} from "./baseAtoms";
-import {
-    historicalVectorDataQueriesAtom,
+    regularEnsembleHistoricalVectorDataQueriesAtom,
     vectorDataQueriesAtom,
     vectorObservationsQueriesAtom,
     vectorStatisticsQueriesAtom,
@@ -22,7 +16,7 @@ import { createLoadedVectorSpecificationAndDataArray } from "../utils/vectorSpec
 export const queryIsFetchingAtom = atom((get) => {
     const vectorDataQueries = get(vectorDataQueriesAtom);
     const vectorStatisticsQueries = get(vectorStatisticsQueriesAtom);
-    const historicalVectorDataQueries = get(historicalVectorDataQueriesAtom);
+    const historicalVectorDataQueries = get(regularEnsembleHistoricalVectorDataQueriesAtom);
     const vectorObservationsQueries = get(vectorObservationsQueriesAtom);
 
     const vectorDataIsFetching = vectorDataQueries.some((query) => query.isFetching);
@@ -39,6 +33,12 @@ export const queryIsFetchingAtom = atom((get) => {
     return isFetching;
 });
 
+export const regularEnsembleVectorSpecificationsAtom = atom((get) => {
+    const vectorSpecifications = get(vectorSpecificationsAtom);
+
+    return vectorSpecifications.filter((elm) => isEnsembleIdentOfType(elm.ensembleIdent, RegularEnsembleIdent));
+});
+
 export const realizationsQueryHasErrorAtom = atom((get) => {
     const vectorDataQueries = get(vectorDataQueriesAtom);
 
@@ -52,9 +52,9 @@ export const statisticsQueryHasErrorAtom = atom((get) => {
 });
 
 export const historicalDataQueryHasErrorAtom = atom((get) => {
-    const historicalVectorDataQueries = get(historicalVectorDataQueriesAtom);
+    const historicalVectorDataQueries = get(regularEnsembleHistoricalVectorDataQueriesAtom);
 
-    return historicalVectorDataQueries.some((query) => query.isError);
+    return historicalVectorDataQueries.some((elm) => elm.isError);
 });
 
 export const loadedVectorSpecificationsAndRealizationDataAtom = atom((get) => {
@@ -71,11 +71,14 @@ export const loadedVectorSpecificationsAndStatisticsDataAtom = atom((get) => {
     return createLoadedVectorSpecificationAndDataArray(vectorSpecifications, vectorStatisticsQueries);
 });
 
-export const loadedVectorSpecificationsAndHistoricalDataAtom = atom((get) => {
-    const historicalVectorDataQueries = get(historicalVectorDataQueriesAtom);
-    const vectorSpecifications = get(vectorSpecificationsAtom);
+export const loadedRegularEnsembleVectorSpecificationsAndHistoricalDataAtom = atom((get) => {
+    const regularEnsembleVectorSpecifications = get(regularEnsembleVectorSpecificationsAtom);
+    const regularEnsembleHistoricalVectorDataQueries = get(regularEnsembleHistoricalVectorDataQueriesAtom);
 
-    return createLoadedVectorSpecificationAndDataArray(vectorSpecifications, historicalVectorDataQueries);
+    return createLoadedVectorSpecificationAndDataArray(
+        regularEnsembleVectorSpecifications,
+        regularEnsembleHistoricalVectorDataQueries
+    );
 });
 
 export const activeTimestampUtcMsAtom = atom<number | null>((get) => {
@@ -95,17 +98,3 @@ export const activeTimestampUtcMsAtom = atom<number | null>((get) => {
 
     return userSelectedActiveTimestampUtcMs;
 });
-
-export const colorByParameterAtom = atom<boolean>((get) => {
-    const colorRealizationsByParameter = get(interfaceColorByParameterAtom);
-    const visualizationMode = get(visualizationModeAtom);
-    const parameterIdent = get(parameterIdentAtom);
-    const selectedEnsembles = get(selectedEnsemblesAtom);
-
-    return (
-        colorRealizationsByParameter &&
-        visualizationMode === VisualizationMode.INDIVIDUAL_REALIZATIONS &&
-        parameterIdent !== null &&
-        selectedEnsembles.some((ensemble) => ensemble.getParameters().hasParameter(parameterIdent))
-    );
-});
diff --git a/frontend/src/modules/SimulationTimeSeries/view/atoms/interfaceEffects.ts b/frontend/src/modules/SimulationTimeSeries/view/atoms/interfaceEffects.ts
index da265b642..bb3c1eb26 100644
--- a/frontend/src/modules/SimulationTimeSeries/view/atoms/interfaceEffects.ts
+++ b/frontend/src/modules/SimulationTimeSeries/view/atoms/interfaceEffects.ts
@@ -2,10 +2,7 @@ import { InterfaceEffects } from "@framework/Module";
 import { SettingsToViewInterface } from "@modules/SimulationTimeSeries/interfaces";
 
 import {
-    interfaceColorByParameterAtom,
-    parameterIdentAtom,
     resampleFrequencyAtom,
-    selectedEnsemblesAtom,
     showObservationsAtom,
     vectorSpecificationsAtom,
     visualizationModeAtom,
@@ -28,16 +25,4 @@ export const settingsToViewInterfaceEffects: InterfaceEffects<SettingsToViewInte
         const showObservations = getInterfaceValue("showObservations");
         setAtomValue(showObservationsAtom, showObservations);
     },
-    (getInterfaceValue, setAtomValue) => {
-        const interfaceColorByParameter = getInterfaceValue("colorByParameter");
-        setAtomValue(interfaceColorByParameterAtom, interfaceColorByParameter);
-    },
-    (getInterfaceValue, setAtomValue) => {
-        const parameterIdent = getInterfaceValue("parameterIdent");
-        setAtomValue(parameterIdentAtom, parameterIdent);
-    },
-    (getInterfaceValue, setAtomValue) => {
-        const selectedEnsembles = getInterfaceValue("selectedEnsembles");
-        setAtomValue(selectedEnsemblesAtom, selectedEnsembles);
-    },
 ];
diff --git a/frontend/src/modules/SimulationTimeSeries/view/atoms/queryAtoms.ts b/frontend/src/modules/SimulationTimeSeries/view/atoms/queryAtoms.ts
index bb57272dd..e7126c78b 100644
--- a/frontend/src/modules/SimulationTimeSeries/view/atoms/queryAtoms.ts
+++ b/frontend/src/modules/SimulationTimeSeries/view/atoms/queryAtoms.ts
@@ -1,7 +1,9 @@
 import { Frequency_api, Observations_api } from "@api";
 import { apiService } from "@framework/ApiService";
 import { ValidEnsembleRealizationsFunctionAtom } from "@framework/GlobalAtoms";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { atomWithQueries } from "@framework/utils/atomUtils";
+import { isEnsembleIdentOfType } from "@framework/utils/ensembleIdentUtils";
 import { EnsembleVectorObservationDataMap, VisualizationMode } from "@modules/SimulationTimeSeries/typesAndEnums";
 import { QueryObserverResult } from "@tanstack/react-query";
 
@@ -11,6 +13,7 @@ import {
     vectorSpecificationsAtom,
     visualizationModeAtom,
 } from "./baseAtoms";
+import { regularEnsembleVectorSpecificationsAtom } from "./derivedAtoms";
 
 const STALE_TIME = 60 * 1000;
 const CACHE_TIME = 60 * 1000;
@@ -26,31 +29,76 @@ export const vectorDataQueriesAtom = atomWithQueries((get) => {
         visualizationMode === VisualizationMode.STATISTICS_AND_REALIZATIONS;
 
     const queries = vectorSpecifications.map((item) => {
+        // Regular Ensemble
+        if (isEnsembleIdentOfType(item.ensembleIdent, RegularEnsembleIdent)) {
+            const realizations = [...validEnsembleRealizationsFunction(item.ensembleIdent)];
+            const vectorSpecification = {
+                ...item,
+                ensembleIdent: item.ensembleIdent,
+            };
+
+            return () => ({
+                queryKey: [
+                    "getRealizationsVectorData",
+                    vectorSpecification.ensembleIdent.getCaseUuid(),
+                    vectorSpecification.ensembleIdent.getEnsembleName(),
+                    vectorSpecification.vectorName,
+                    resampleFrequency,
+                    realizations,
+                ],
+                queryFn: () =>
+                    apiService.timeseries.getRealizationsVectorData(
+                        vectorSpecification.ensembleIdent.getCaseUuid() ?? "",
+                        vectorSpecification.ensembleIdent.getEnsembleName() ?? "",
+                        vectorSpecification.vectorName ?? "",
+                        resampleFrequency,
+                        realizations
+                    ),
+                staleTime: STALE_TIME,
+                gcTime: CACHE_TIME,
+                enabled: !!(
+                    enabled &&
+                    vectorSpecification.vectorName &&
+                    vectorSpecification.ensembleIdent.getCaseUuid() &&
+                    vectorSpecification.ensembleIdent.getEnsembleName()
+                ),
+            });
+        }
+
+        // Delta Ensemble
         const realizations = [...validEnsembleRealizationsFunction(item.ensembleIdent)];
+        const vectorSpecification = { ...item, ensembleIdent: item.ensembleIdent };
         return () => ({
             queryKey: [
-                "getRealizationsVectorData",
-                item.ensembleIdent.getCaseUuid(),
-                item.ensembleIdent.getEnsembleName(),
-                item.vectorName,
+                "getDeltaEnsembleRealizationsVectorData",
+                vectorSpecification.ensembleIdent.getCompareEnsembleIdent().getCaseUuid(),
+                vectorSpecification.ensembleIdent.getCompareEnsembleIdent().getEnsembleName(),
+                vectorSpecification.ensembleIdent.getReferenceEnsembleIdent().getCaseUuid(),
+                vectorSpecification.ensembleIdent.getReferenceEnsembleIdent().getEnsembleName(),
+                vectorSpecification.vectorName,
                 resampleFrequency,
                 realizations,
             ],
             queryFn: () =>
-                apiService.timeseries.getRealizationsVectorData(
-                    item.ensembleIdent.getCaseUuid() ?? "",
-                    item.ensembleIdent.getEnsembleName() ?? "",
-                    item.vectorName ?? "",
-                    resampleFrequency,
+                apiService.timeseries.getDeltaEnsembleRealizationsVectorData(
+                    vectorSpecification.ensembleIdent.getCompareEnsembleIdent().getCaseUuid(),
+                    vectorSpecification.ensembleIdent.getCompareEnsembleIdent().getEnsembleName(),
+                    vectorSpecification.ensembleIdent.getReferenceEnsembleIdent().getCaseUuid(),
+                    vectorSpecification.ensembleIdent.getReferenceEnsembleIdent().getEnsembleName(),
+                    vectorSpecification.vectorName ?? "",
+                    resampleFrequency ?? Frequency_api.YEARLY,
                     realizations
                 ),
             staleTime: STALE_TIME,
             gcTime: CACHE_TIME,
             enabled: !!(
                 enabled &&
-                item.vectorName &&
-                item.ensembleIdent.getCaseUuid() &&
-                item.ensembleIdent.getEnsembleName()
+                resampleFrequency &&
+                vectorSpecification.vectorName &&
+                vectorSpecification.ensembleIdent.getCompareEnsembleIdent().getCaseUuid() &&
+                vectorSpecification.ensembleIdent.getCompareEnsembleIdent().getEnsembleName() &&
+                vectorSpecification.ensembleIdent.getReferenceEnsembleIdent().getCaseUuid() &&
+                vectorSpecification.ensembleIdent.getReferenceEnsembleIdent().getEnsembleName()
             ),
         });
     });
@@ -72,21 +120,63 @@ export const vectorStatisticsQueriesAtom = atomWithQueries((get) => {
         visualizationMode === VisualizationMode.STATISTICS_AND_REALIZATIONS;
 
     const queries = vectorSpecifications.map((item) => {
+        // Regular Ensemble
+        if (isEnsembleIdentOfType(item.ensembleIdent, RegularEnsembleIdent)) {
+            const realizations = [...validEnsembleRealizationsFunction(item.ensembleIdent)];
+            const vectorSpecification = {
+                ...item,
+                ensembleIdent: item.ensembleIdent,
+            };
+            return () => ({
+                queryKey: [
+                    "getStatisticalVectorData",
+                    vectorSpecification.ensembleIdent.getCaseUuid(),
+                    vectorSpecification.ensembleIdent.getEnsembleName(),
+                    vectorSpecification.vectorName,
+                    resampleFrequency,
+                    realizations,
+                ],
+                queryFn: () =>
+                    apiService.timeseries.getStatisticalVectorData(
+                        vectorSpecification.ensembleIdent.getCaseUuid() ?? "",
+                        vectorSpecification.ensembleIdent.getEnsembleName() ?? "",
+                        vectorSpecification.vectorName ?? "",
+                        resampleFrequency ?? Frequency_api.MONTHLY,
+                        undefined,
+                        realizations
+                    ),
+                staleTime: STALE_TIME,
+                gcTime: CACHE_TIME,
+                enabled: !!(
+                    enabled &&
+                    vectorSpecification.vectorName &&
+                    vectorSpecification.ensembleIdent.getCaseUuid() &&
+                    vectorSpecification.ensembleIdent.getEnsembleName()
+                ),
+            });
+        }
+
+        // Delta Ensemble
         const realizations = [...validEnsembleRealizationsFunction(item.ensembleIdent)];
+        const vectorSpecification = { ...item, ensembleIdent: item.ensembleIdent };
         return () => ({
             queryKey: [
-                "getStatisticalVectorData",
-                item.ensembleIdent.getCaseUuid(),
-                item.ensembleIdent.getEnsembleName(),
-                item.vectorName,
+                "getDeltaEnsembleStatisticalVectorData",
+                vectorSpecification.ensembleIdent.getCompareEnsembleIdent().getCaseUuid(),
+                vectorSpecification.ensembleIdent.getCompareEnsembleIdent().getEnsembleName(),
+                vectorSpecification.ensembleIdent.getReferenceEnsembleIdent().getCaseUuid(),
+                vectorSpecification.ensembleIdent.getReferenceEnsembleIdent().getEnsembleName(),
+                vectorSpecification.vectorName,
                 resampleFrequency,
                 realizations,
             ],
             queryFn: () =>
-                apiService.timeseries.getStatisticalVectorData(
-                    item.ensembleIdent.getCaseUuid() ?? "",
-                    item.ensembleIdent.getEnsembleName() ?? "",
-                    item.vectorName ?? "",
+                apiService.timeseries.getDeltaEnsembleStatisticalVectorData(
+                    vectorSpecification.ensembleIdent.getCompareEnsembleIdent().getCaseUuid(),
+                    vectorSpecification.ensembleIdent.getCompareEnsembleIdent().getEnsembleName(),
+                    vectorSpecification.ensembleIdent.getReferenceEnsembleIdent().getCaseUuid(),
+                    vectorSpecification.ensembleIdent.getReferenceEnsembleIdent().getEnsembleName(),
+                    vectorSpecification.vectorName ?? "",
                     resampleFrequency ?? Frequency_api.MONTHLY,
                     undefined,
                     realizations
@@ -95,9 +185,12 @@ export const vectorStatisticsQueriesAtom = atomWithQueries((get) => {
             gcTime: CACHE_TIME,
             enabled: !!(
                 enabled &&
-                item.vectorName &&
-                item.ensembleIdent.getCaseUuid() &&
-                item.ensembleIdent.getEnsembleName()
+                resampleFrequency &&
+                vectorSpecification.vectorName &&
+                vectorSpecification.ensembleIdent.getCompareEnsembleIdent().getCaseUuid() &&
+                vectorSpecification.ensembleIdent.getCompareEnsembleIdent().getEnsembleName() &&
+                vectorSpecification.ensembleIdent.getReferenceEnsembleIdent().getCaseUuid() &&
+                vectorSpecification.ensembleIdent.getReferenceEnsembleIdent().getEnsembleName()
             ),
         });
     });
@@ -107,36 +200,40 @@ export const vectorStatisticsQueriesAtom = atomWithQueries((get) => {
     };
 });
 
-export const historicalVectorDataQueriesAtom = atomWithQueries((get) => {
-    const vectorSpecifications = get(vectorSpecificationsAtom);
+export const regularEnsembleHistoricalVectorDataQueriesAtom = atomWithQueries((get) => {
     const resampleFrequency = get(resampleFrequencyAtom);
+    const regularEnsembleVectorSpecifications = get(regularEnsembleVectorSpecificationsAtom);
 
-    const vectorSpecificationsWithHistoricalData = vectorSpecifications?.filter((vec) => vec.hasHistoricalVector);
-    const enabled = vectorSpecificationsWithHistoricalData?.some((vec) => vec.hasHistoricalVector) ?? false;
+    const enabled = regularEnsembleVectorSpecifications.some((elm) => elm.hasHistoricalVector);
+
+    const queries = regularEnsembleVectorSpecifications.map((item) => {
+        const vectorSpecification = {
+            ...item,
+            ensembleIdent: item.ensembleIdent as RegularEnsembleIdent,
+        };
 
-    const queries = vectorSpecifications.map((item) => {
         return () => ({
             queryKey: [
                 "getHistoricalVectorData",
-                item.ensembleIdent.getCaseUuid(),
-                item.ensembleIdent.getEnsembleName(),
-                item.vectorName,
+                vectorSpecification.ensembleIdent.getCaseUuid(),
+                vectorSpecification.ensembleIdent.getEnsembleName(),
+                vectorSpecification.vectorName,
                 resampleFrequency,
             ],
             queryFn: () =>
                 apiService.timeseries.getHistoricalVectorData(
-                    item.ensembleIdent.getCaseUuid() ?? "",
-                    item.ensembleIdent.getEnsembleName() ?? "",
-                    item.vectorName ?? "",
+                    vectorSpecification.ensembleIdent.getCaseUuid() ?? "",
+                    vectorSpecification.ensembleIdent.getEnsembleName() ?? "",
+                    vectorSpecification.vectorName ?? "",
                     resampleFrequency ?? Frequency_api.MONTHLY
                 ),
             staleTime: STALE_TIME,
             gcTime: CACHE_TIME,
             enabled: !!(
                 enabled &&
-                item.vectorName &&
-                item.ensembleIdent.getCaseUuid() &&
-                item.ensembleIdent.getEnsembleName()
+                vectorSpecification.vectorName &&
+                vectorSpecification.ensembleIdent.getCaseUuid() &&
+                vectorSpecification.ensembleIdent.getEnsembleName()
             ),
         });
     });
@@ -150,7 +247,13 @@ export const vectorObservationsQueriesAtom = atomWithQueries((get) => {
     const showObservations = get(showObservationsAtom);
     const vectorSpecifications = get(vectorSpecificationsAtom);
 
-    const uniqueEnsembleIdents = [...new Set(vectorSpecifications?.map((item) => item.ensembleIdent) ?? [])];
+    const uniqueEnsembleIdents: RegularEnsembleIdent[] = [];
+    for (const { ensembleIdent } of vectorSpecifications) {
+        const isAlreadyAdded = uniqueEnsembleIdents.some((elm) => elm.equals(ensembleIdent));
+        if (!isAlreadyAdded && isEnsembleIdentOfType(ensembleIdent, RegularEnsembleIdent)) {
+            uniqueEnsembleIdents.push(ensembleIdent);
+        }
+    }
 
     const queries = uniqueEnsembleIdents.map((item) => {
         return () => ({
@@ -166,8 +269,9 @@ export const vectorObservationsQueriesAtom = atomWithQueries((get) => {
         queries,
         combine: (results: QueryObserverResult<Observations_api>[]) => {
             const combinedResult: EnsembleVectorObservationDataMap = new Map();
-            if (!vectorSpecifications)
+            if (!vectorSpecifications) {
                 return { isFetching: false, isError: false, ensembleVectorObservationDataMap: combinedResult };
+            }
 
             results.forEach((result, index) => {
                 const ensembleIdent = uniqueEnsembleIdents.at(index);
diff --git a/frontend/src/modules/SimulationTimeSeries/view/hooks/useMakeEnsembleDisplayNameFunc.ts b/frontend/src/modules/SimulationTimeSeries/view/hooks/useMakeEnsembleDisplayNameFunc.ts
index 7ea14fab8..45b76bc28 100644
--- a/frontend/src/modules/SimulationTimeSeries/view/hooks/useMakeEnsembleDisplayNameFunc.ts
+++ b/frontend/src/modules/SimulationTimeSeries/view/hooks/useMakeEnsembleDisplayNameFunc.ts
@@ -1,14 +1,17 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
 import { ViewContext } from "@framework/ModuleContext";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { Interfaces } from "@modules/SimulationTimeSeries/interfaces";
 import { makeDistinguishableEnsembleDisplayName } from "@modules/_shared/ensembleNameUtils";
 
 export function useMakeEnsembleDisplayNameFunc(
     viewContext: ViewContext<Interfaces>
-): (ensembleIdent: EnsembleIdent) => string {
-    const selectedEnsembles = viewContext.useSettingsToViewInterfaceValue("selectedEnsembles");
+): (ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent) => string {
+    const selectedRegularEnsembles = viewContext.useSettingsToViewInterfaceValue("selectedRegularEnsembles");
+    const selectedDeltaEnsembles = viewContext.useSettingsToViewInterfaceValue("selectedDeltaEnsembles");
+    const allSelectedEnsembles = [...selectedRegularEnsembles, ...selectedDeltaEnsembles];
 
-    return function makeEnsembleDisplayName(ensembleIdent: EnsembleIdent) {
-        return makeDistinguishableEnsembleDisplayName(ensembleIdent, selectedEnsembles);
+    return function makeEnsembleDisplayName(ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent): string {
+        return makeDistinguishableEnsembleDisplayName(ensembleIdent, allSelectedEnsembles);
     };
 }
diff --git a/frontend/src/modules/SimulationTimeSeries/view/hooks/useMakeViewStatusWriterMessages.ts b/frontend/src/modules/SimulationTimeSeries/view/hooks/useMakeViewStatusWriterMessages.ts
index a00568236..b4ee58745 100644
--- a/frontend/src/modules/SimulationTimeSeries/view/hooks/useMakeViewStatusWriterMessages.ts
+++ b/frontend/src/modules/SimulationTimeSeries/view/hooks/useMakeViewStatusWriterMessages.ts
@@ -1,6 +1,7 @@
-import { Ensemble } from "@framework/Ensemble";
+import { DeltaEnsemble } from "@framework/DeltaEnsemble";
 import { EnsembleSetAtom } from "@framework/GlobalAtoms";
 import { ViewContext } from "@framework/ModuleContext";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
 import { ViewStatusWriter } from "@framework/StatusWriter";
 import { Interfaces } from "@modules/SimulationTimeSeries/interfaces";
 
@@ -18,7 +19,7 @@ export function useMakeViewStatusWriterMessages(
     viewContext: ViewContext<Interfaces>,
     statusWriter: ViewStatusWriter,
     parameterDisplayName: string | null,
-    ensemblesWithoutParameter: Ensemble[]
+    ensemblesWithoutParameter: (RegularEnsemble | DeltaEnsemble)[]
 ) {
     const ensembleSet = useAtomValue(EnsembleSetAtom);
     const showObservations = viewContext.useSettingsToViewInterfaceValue("showObservations");
diff --git a/frontend/src/modules/SimulationTimeSeries/view/hooks/usePublishToDataChannels.ts b/frontend/src/modules/SimulationTimeSeries/view/hooks/usePublishToDataChannels.ts
index 122bf4b74..bb761cfdd 100644
--- a/frontend/src/modules/SimulationTimeSeries/view/hooks/usePublishToDataChannels.ts
+++ b/frontend/src/modules/SimulationTimeSeries/view/hooks/usePublishToDataChannels.ts
@@ -1,5 +1,8 @@
+import { VectorRealizationData_api } from "@api";
 import { ChannelContentDefinition } from "@framework/DataChannelTypes";
 import { ViewContext } from "@framework/ModuleContext";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
+import { isEnsembleIdentOfType } from "@framework/utils/ensembleIdentUtils";
 import { Interfaces } from "@modules/SimulationTimeSeries/interfaces";
 
 import { useAtomValue } from "jotai";
@@ -7,7 +10,7 @@ import { useAtomValue } from "jotai";
 import { useMakeEnsembleDisplayNameFunc } from "./useMakeEnsembleDisplayNameFunc";
 
 import { ChannelIds } from "../../channelDefs";
-import { makeVectorGroupDataGenerator } from "../../dataGenerators";
+import { RegularEnsembleVectorSpec, makeVectorGroupDataGenerator } from "../../dataGenerators";
 import {
     activeTimestampUtcMsAtom,
     loadedVectorSpecificationsAndRealizationDataAtom,
@@ -21,22 +24,46 @@ export function usePublishToDataChannels(viewContext: ViewContext<Interfaces>) {
 
     const makeEnsembleDisplayName = useMakeEnsembleDisplayNameFunc(viewContext);
 
-    const contents: ChannelContentDefinition[] = loadedVectorSpecificationsAndRealizationData.map((el) => ({
-        contentIdString: `${el.vectorSpecification.vectorName}-::-${el.vectorSpecification.ensembleIdent}`,
-        displayName: `${el.vectorSpecification.vectorName} (${makeEnsembleDisplayName(
-            el.vectorSpecification.ensembleIdent
-        )})`,
-        dataGenerator: makeVectorGroupDataGenerator(
-            el.vectorSpecification,
-            loadedVectorSpecificationsAndRealizationData,
-            activeTimestampUtcMs ?? 0,
-            makeEnsembleDisplayName
-        ),
-    }));
+    // Only publish regular ensemble data to the time series channel
+    const regularEnsembleVectorSpecificationsAndRealizationData: {
+        vectorSpecification: RegularEnsembleVectorSpec;
+        data: VectorRealizationData_api[];
+    }[] = [];
+    for (const elm of loadedVectorSpecificationsAndRealizationData) {
+        if (!isEnsembleIdentOfType(elm.vectorSpecification.ensembleIdent, RegularEnsembleIdent)) {
+            continue;
+        }
+
+        const regularEnsembleVectorSpec: RegularEnsembleVectorSpec = {
+            ...elm.vectorSpecification,
+            ensembleIdent: elm.vectorSpecification.ensembleIdent,
+        };
+
+        regularEnsembleVectorSpecificationsAndRealizationData.push({
+            vectorSpecification: regularEnsembleVectorSpec,
+            data: elm.data,
+        });
+    }
+
+    const contents: ChannelContentDefinition[] = [];
+    for (const elm of regularEnsembleVectorSpecificationsAndRealizationData) {
+        contents.push({
+            contentIdString: `${elm.vectorSpecification.vectorName}-::-${elm.vectorSpecification.ensembleIdent}`,
+            displayName: `${elm.vectorSpecification.vectorName} (${makeEnsembleDisplayName(
+                elm.vectorSpecification.ensembleIdent
+            )})`,
+            dataGenerator: makeVectorGroupDataGenerator(
+                elm.vectorSpecification,
+                regularEnsembleVectorSpecificationsAndRealizationData,
+                activeTimestampUtcMs ?? 0,
+                makeEnsembleDisplayName
+            ),
+        });
+    }
 
     viewContext.usePublishChannelContents({
         channelIdString: ChannelIds.TIME_SERIES,
-        dependencies: [loadedVectorSpecificationsAndRealizationData, activeTimestampUtcMs],
+        dependencies: [regularEnsembleVectorSpecificationsAndRealizationData, activeTimestampUtcMs],
         enabled: !isQueryFetching,
         contents,
     });
diff --git a/frontend/src/modules/SimulationTimeSeries/view/hooks/useSubplotBuilder.ts b/frontend/src/modules/SimulationTimeSeries/view/hooks/useSubplotBuilder.ts
index 26462e576..1564c057d 100644
--- a/frontend/src/modules/SimulationTimeSeries/view/hooks/useSubplotBuilder.ts
+++ b/frontend/src/modules/SimulationTimeSeries/view/hooks/useSubplotBuilder.ts
@@ -12,7 +12,7 @@ import { useMakeEnsembleDisplayNameFunc } from "./useMakeEnsembleDisplayNameFunc
 import { GroupBy, VectorSpec, VisualizationMode } from "../../typesAndEnums";
 import {
     activeTimestampUtcMsAtom,
-    loadedVectorSpecificationsAndHistoricalDataAtom,
+    loadedRegularEnsembleVectorSpecificationsAndHistoricalDataAtom,
     loadedVectorSpecificationsAndRealizationDataAtom,
     loadedVectorSpecificationsAndStatisticsDataAtom,
 } from "../atoms/derivedAtoms";
@@ -41,7 +41,9 @@ export function useSubplotBuilder(
     const vectorObservationsQueries = useAtomValue(vectorObservationsQueriesAtom);
     const loadedVectorSpecificationsAndRealizationData = useAtomValue(loadedVectorSpecificationsAndRealizationDataAtom);
     const loadedVectorSpecificationsAndStatisticsData = useAtomValue(loadedVectorSpecificationsAndStatisticsDataAtom);
-    const loadedVectorSpecificationsAndHistoricalData = useAtomValue(loadedVectorSpecificationsAndHistoricalDataAtom);
+    const loadedRegularEnsembleVectorSpecificationsAndHistoricalData = useAtomValue(
+        loadedRegularEnsembleVectorSpecificationsAndHistoricalDataAtom
+    );
     const colorByParameter = viewContext.useSettingsToViewInterfaceValue("colorByParameter");
     const activeTimestampUtcMs = useAtomValue(activeTimestampUtcMsAtom);
 
@@ -112,7 +114,7 @@ export function useSubplotBuilder(
         subplotBuilder.addStatisticsTraces(selectedVectorsIndividualStatisticData, highlightStatistics);
     }
     if (showHistorical) {
-        subplotBuilder.addHistoryTraces(loadedVectorSpecificationsAndHistoricalData);
+        subplotBuilder.addHistoryTraces(loadedRegularEnsembleVectorSpecificationsAndHistoricalData);
     }
     if (showObservations) {
         subplotBuilder.addObservationsTraces(loadedVectorSpecificationsAndObservationData);
diff --git a/frontend/src/modules/SimulationTimeSeries/view/utils/ensemblesContinuousParameterColoring.ts b/frontend/src/modules/SimulationTimeSeries/view/utils/ensemblesContinuousParameterColoring.ts
index f0d5aafa9..651a49055 100644
--- a/frontend/src/modules/SimulationTimeSeries/view/utils/ensemblesContinuousParameterColoring.ts
+++ b/frontend/src/modules/SimulationTimeSeries/view/utils/ensemblesContinuousParameterColoring.ts
@@ -1,6 +1,6 @@
-import { Ensemble } from "@framework/Ensemble";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ContinuousParameter, ParameterIdent, ParameterType } from "@framework/EnsembleParameters";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { ColorScale } from "@lib/utils/ColorScale";
 import { MinMax } from "@lib/utils/MinMax";
 
@@ -13,14 +13,14 @@ export class EnsemblesContinuousParameterColoring {
      */
 
     private _parameterIdent: ParameterIdent;
-    private _ensembleContinuousParameterMap: Map<EnsembleIdent, ContinuousParameter>;
+    private _ensembleContinuousParameterMap: Map<RegularEnsembleIdent, ContinuousParameter>;
     private _colorScale: ColorScale;
 
-    constructor(selectedEnsembles: Ensemble[], parameterIdent: ParameterIdent, colorScale: ColorScale) {
+    constructor(selectedRegularEnsembles: RegularEnsemble[], parameterIdent: ParameterIdent, colorScale: ColorScale) {
         this._parameterIdent = parameterIdent;
-        this._ensembleContinuousParameterMap = new Map<EnsembleIdent, ContinuousParameter>();
+        this._ensembleContinuousParameterMap = new Map<RegularEnsembleIdent, ContinuousParameter>();
         let minMax = MinMax.createInvalid();
-        for (const ensemble of selectedEnsembles) {
+        for (const ensemble of selectedRegularEnsembles) {
             const ensembleParameters = ensemble.getParameters();
             const parameter = ensembleParameters.findParameter(parameterIdent);
             if (!parameter || parameter.type !== ParameterType.CONTINUOUS) continue;
@@ -45,18 +45,18 @@ export class EnsemblesContinuousParameterColoring {
         return this._colorScale;
     }
 
-    hasParameterForEnsemble(ensembleIdent: EnsembleIdent): boolean {
+    hasParameterForEnsemble(ensembleIdent: RegularEnsembleIdent): boolean {
         return this._ensembleContinuousParameterMap.has(ensembleIdent);
     }
 
-    hasParameterRealizationValue(ensembleIdent: EnsembleIdent, realization: number): boolean {
+    hasParameterRealizationValue(ensembleIdent: RegularEnsembleIdent, realization: number): boolean {
         const parameter = this._ensembleContinuousParameterMap.get(ensembleIdent);
         if (parameter === undefined) return false;
 
         return parameter.realizations.indexOf(realization) !== -1;
     }
 
-    getParameterRealizationValue(ensembleIdent: EnsembleIdent, realization: number): number {
+    getParameterRealizationValue(ensembleIdent: RegularEnsembleIdent, realization: number): number {
         if (!this.hasParameterRealizationValue(ensembleIdent, realization)) {
             throw new Error(
                 `Parameter ${this.getParameterDisplayName()} has no numerical value for realization ${realization} in ensemble ${ensembleIdent.toString()}`
diff --git a/frontend/src/modules/SimulationTimeSeries/view/utils/subplotBuilder.ts b/frontend/src/modules/SimulationTimeSeries/view/utils/subplotBuilder.ts
index 621f42d29..f0694c382 100644
--- a/frontend/src/modules/SimulationTimeSeries/view/utils/subplotBuilder.ts
+++ b/frontend/src/modules/SimulationTimeSeries/view/utils/subplotBuilder.ts
@@ -4,7 +4,9 @@ import {
     VectorRealizationData_api,
     VectorStatisticData_api,
 } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
+import { isEnsembleIdentOfType } from "@framework/utils/ensembleIdentUtils";
 import { timestampUtcMsToCompactIsoString } from "@framework/utils/timestampUtils";
 import { ColorSet } from "@lib/utils/ColorSet";
 import { simulationUnitReformat, simulationVectorDescription } from "@modules/_shared/reservoirSimulationStringUtils";
@@ -45,14 +47,14 @@ export class SubplotBuilder {
     private _subplotOwner: SubplotOwner;
 
     private _addedVectorsLegendTracker: string[] = [];
-    private _addedEnsemblesLegendTracker: EnsembleIdent[] = [];
+    private _addedEnsemblesLegendTracker: (RegularEnsembleIdent | DeltaEnsembleIdent)[] = [];
 
-    private _uniqueEnsembleIdents: EnsembleIdent[] = [];
+    private _uniqueEnsembleIdents: (RegularEnsembleIdent | DeltaEnsembleIdent)[] = [];
     private _uniqueVectorNames: string[] = [];
 
     private _vectorHexColors: HexColorMap = {};
 
-    private _makeEnsembleDisplayName: (ensembleIdent: EnsembleIdent) => string;
+    private _makeEnsembleDisplayName: (ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent) => string;
 
     private _hasRealizationsTracesColoredByParameter = false;
     private _hasHistoryTraces = false;
@@ -79,7 +81,7 @@ export class SubplotBuilder {
     constructor(
         subplotOwner: SubplotOwner,
         selectedVectorSpecifications: VectorSpec[],
-        makeEnsembleDisplayName: (ensembleIdent: EnsembleIdent) => string,
+        makeEnsembleDisplayName: (ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent) => string,
         colorSet: ColorSet,
         width: number,
         height: number,
@@ -288,6 +290,8 @@ export class SubplotBuilder {
             if (subplotIndex === -1) continue;
 
             const ensembleIdent = elm.vectorSpecification.ensembleIdent;
+            if (!isEnsembleIdentOfType(ensembleIdent, RegularEnsembleIdent)) continue;
+
             const hasParameterForEnsemble = this._ensemblesParameterColoring.hasParameterForEnsemble(ensembleIdent);
 
             // Add traces for each realization with color based on parameter value
diff --git a/frontend/src/modules/SimulationTimeSeries/view/view.tsx b/frontend/src/modules/SimulationTimeSeries/view/view.tsx
index 8db2987de..ff5a45955 100644
--- a/frontend/src/modules/SimulationTimeSeries/view/view.tsx
+++ b/frontend/src/modules/SimulationTimeSeries/view/view.tsx
@@ -1,8 +1,9 @@
 import React from "react";
 import Plot from "react-plotly.js";
 
-import { Ensemble } from "@framework/Ensemble";
+import { DeltaEnsemble } from "@framework/DeltaEnsemble";
 import { ModuleViewProps } from "@framework/Module";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
 import { useViewStatusWriter } from "@framework/StatusWriter";
 import { useElementSize } from "@lib/hooks/useElementSize";
 import { ColorScaleGradientType } from "@lib/utils/ColorScale";
@@ -28,7 +29,8 @@ export const View = ({ viewContext, workbenchSettings }: ModuleViewProps<Interfa
 
     const colorByParameter = viewContext.useSettingsToViewInterfaceValue("colorByParameter");
     const parameterIdent = viewContext.useSettingsToViewInterfaceValue("parameterIdent");
-    const selectedEnsembles = viewContext.useSettingsToViewInterfaceValue("selectedEnsembles");
+    const selectedEnsembles = viewContext.useSettingsToViewInterfaceValue("selectedRegularEnsembles");
+    const selectedDeltaEnsembles = viewContext.useSettingsToViewInterfaceValue("selectedDeltaEnsembles");
     const hasRealizationsQueryError = useAtomValue(realizationsQueryHasErrorAtom);
     const hasStatisticsQueryError = useAtomValue(statisticsQueryHasErrorAtom);
 
@@ -46,7 +48,7 @@ export const View = ({ viewContext, workbenchSettings }: ModuleViewProps<Interfa
             ? new EnsemblesContinuousParameterColoring(selectedEnsembles, parameterIdent, parameterColorScale)
             : null;
 
-    const ensemblesWithoutParameter: Ensemble[] = [];
+    const ensemblesWithoutParameter: (RegularEnsemble | DeltaEnsemble)[] = [];
     let parameterDisplayName: string | null = null;
     if (ensemblesParameterColoring) {
         ensemblesWithoutParameter.push(
@@ -55,6 +57,7 @@ export const View = ({ viewContext, workbenchSettings }: ModuleViewProps<Interfa
             )
         );
         parameterDisplayName = ensemblesParameterColoring.getParameterDisplayName();
+        ensemblesWithoutParameter.push(...selectedDeltaEnsembles);
     }
 
     useMakeViewStatusWriterMessages(viewContext, statusWriter, parameterDisplayName, ensemblesWithoutParameter);
diff --git a/frontend/src/modules/SimulationTimeSeriesSensitivity/settings/settings.tsx b/frontend/src/modules/SimulationTimeSeriesSensitivity/settings/settings.tsx
index 4085e7519..69d315d7c 100644
--- a/frontend/src/modules/SimulationTimeSeriesSensitivity/settings/settings.tsx
+++ b/frontend/src/modules/SimulationTimeSeriesSensitivity/settings/settings.tsx
@@ -1,12 +1,12 @@
 import React from "react";
 
 import { Frequency_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ModuleSettingsProps } from "@framework/Module";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { SyncSettingKey, SyncSettingsHelper } from "@framework/SyncSettings";
 import { useEnsembleSet } from "@framework/WorkbenchSession";
 import { EnsembleDropdown } from "@framework/components/EnsembleDropdown";
-import { fixupEnsembleIdent, maybeAssignFirstSyncedEnsemble } from "@framework/utils/ensembleUiHelpers";
+import { fixupRegularEnsembleIdent, maybeAssignFirstSyncedEnsemble } from "@framework/utils/ensembleUiHelpers";
 import { Checkbox } from "@lib/components/Checkbox";
 import { CircularProgress } from "@lib/components/CircularProgress";
 import { CollapsibleGroup } from "@lib/components/CollapsibleGroup";
@@ -37,7 +37,7 @@ import { Interfaces } from "../interfaces";
 export function Settings({ settingsContext, workbenchSession, workbenchServices }: ModuleSettingsProps<Interfaces>) {
     const ensembleSet = useEnsembleSet(workbenchSession);
 
-    const [selectedEnsembleIdent, setSelectedEnsembleIdent] = React.useState<EnsembleIdent | null>(null);
+    const [selectedEnsembleIdent, setSelectedEnsembleIdent] = React.useState<RegularEnsembleIdent | null>(null);
     const [selectedVectorName, setSelectedVectorName] = React.useState<string | null>(null);
     const [selectedVectorTag, setSelectedVectorTag] = React.useState<string | null>(null);
     const [vectorSelectorData, setVectorSelectorData] = React.useState<TreeDataNode[]>([]);
@@ -55,7 +55,7 @@ export function Settings({ settingsContext, workbenchSession, workbenchServices
     const syncedValueSummaryVector = syncHelper.useValue(SyncSettingKey.TIME_SERIES, "global.syncValue.timeSeries");
 
     const candidateEnsembleIdent = maybeAssignFirstSyncedEnsemble(selectedEnsembleIdent, syncedValueEnsembles);
-    const computedEnsembleIdent = fixupEnsembleIdent(candidateEnsembleIdent, ensembleSet);
+    const computedEnsembleIdent = fixupRegularEnsembleIdent(candidateEnsembleIdent, ensembleSet);
 
     const vectorsListQuery = useVectorListQuery(
         computedEnsembleIdent?.getCaseUuid(),
@@ -132,7 +132,7 @@ export function Settings({ settingsContext, workbenchSession, workbenchServices
         [computedEnsembleIdent, computedVectorName, hasComputedVectorName, hasHistoricalVector, setVectorSpec]
     );
 
-    function handleEnsembleSelectionChange(newEnsembleIdent: EnsembleIdent | null) {
+    function handleEnsembleSelectionChange(newEnsembleIdent: RegularEnsembleIdent | null) {
         setSelectedEnsembleIdent(newEnsembleIdent);
         if (newEnsembleIdent) {
             syncHelper.publishValue(SyncSettingKey.ENSEMBLE, "global.syncValue.ensembles", [newEnsembleIdent]);
@@ -158,7 +158,7 @@ export function Settings({ settingsContext, workbenchSession, workbenchServices
         <>
             <CollapsibleGroup expanded={true} title="Ensemble">
                 <EnsembleDropdown
-                    ensembles={ensembleSet.getEnsembleArr()}
+                    ensembles={ensembleSet.getRegularEnsembleArray()}
                     value={computedEnsembleIdent}
                     onChange={handleEnsembleSelectionChange}
                 />
diff --git a/frontend/src/modules/SimulationTimeSeriesSensitivity/typesAndEnums.ts b/frontend/src/modules/SimulationTimeSeriesSensitivity/typesAndEnums.ts
index cdfe45b02..088a4cbbb 100644
--- a/frontend/src/modules/SimulationTimeSeriesSensitivity/typesAndEnums.ts
+++ b/frontend/src/modules/SimulationTimeSeriesSensitivity/typesAndEnums.ts
@@ -1,7 +1,7 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 
 export interface VectorSpec {
-    ensembleIdent: EnsembleIdent;
+    ensembleIdent: RegularEnsembleIdent;
     vectorName: string;
     hasHistorical: boolean;
 }
diff --git a/frontend/src/modules/SubsurfaceMap/settings/settings.tsx b/frontend/src/modules/SubsurfaceMap/settings/settings.tsx
index 3fc07d687..d7f4a5b9b 100644
--- a/frontend/src/modules/SubsurfaceMap/settings/settings.tsx
+++ b/frontend/src/modules/SubsurfaceMap/settings/settings.tsx
@@ -1,12 +1,12 @@
 import React from "react";
 
 import { SurfaceAttributeType_api, SurfaceStatisticFunction_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ModuleSettingsProps } from "@framework/Module";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { SyncSettingKey, SyncSettingsHelper } from "@framework/SyncSettings";
 import { useEnsembleSet } from "@framework/WorkbenchSession";
 import { EnsembleDropdown } from "@framework/components/EnsembleDropdown";
-import { fixupEnsembleIdent, maybeAssignFirstSyncedEnsemble } from "@framework/utils/ensembleUiHelpers";
+import { fixupRegularEnsembleIdent, maybeAssignFirstSyncedEnsemble } from "@framework/utils/ensembleUiHelpers";
 import { Button } from "@lib/components/Button";
 import { Checkbox } from "@lib/components/Checkbox";
 import { CircularProgress } from "@lib/components/CircularProgress";
@@ -65,7 +65,7 @@ export function Settings({ settingsContext, workbenchSession, workbenchServices
     console.debug(`${myInstanceIdStr} -- render TopographicMap settings`);
 
     const ensembleSet = useEnsembleSet(workbenchSession);
-    const [selectedEnsembleIdent, setSelectedEnsembleIdent] = React.useState<EnsembleIdent | null>(null);
+    const [selectedEnsembleIdent, setSelectedEnsembleIdent] = React.useState<RegularEnsembleIdent | null>(null);
     const [selectedMeshSurfaceName, setSelectedMeshSurfaceName] = React.useState<string | null>(null);
     const [selectedMeshSurfaceAttribute, setSelectedMeshSurfaceAttribute] = React.useState<string | null>(null);
     const [usePropertySurface, setUsePropertySurface] = React.useState<boolean>(false);
@@ -99,7 +99,7 @@ export function Settings({ settingsContext, workbenchSession, workbenchServices
     const syncedValueEnsembles = syncHelper.useValue(SyncSettingKey.ENSEMBLE, "global.syncValue.ensembles");
     const syncedValueSurface = syncHelper.useValue(SyncSettingKey.SURFACE, "global.syncValue.surface");
     const candidateEnsembleIdent = maybeAssignFirstSyncedEnsemble(selectedEnsembleIdent, syncedValueEnsembles);
-    const computedEnsembleIdent = fixupEnsembleIdent(candidateEnsembleIdent, ensembleSet);
+    const computedEnsembleIdent = fixupRegularEnsembleIdent(candidateEnsembleIdent, ensembleSet);
     if (computedEnsembleIdent && !computedEnsembleIdent.equals(selectedEnsembleIdent)) {
         setSelectedEnsembleIdent(computedEnsembleIdent);
     }
@@ -379,7 +379,7 @@ export function Settings({ settingsContext, workbenchSession, workbenchServices
 
     let fieldIdentifier: null | string = null;
     if (computedEnsembleIdent) {
-        const ensembleIdent = new EnsembleIdent(
+        const ensembleIdent = new RegularEnsembleIdent(
             computedEnsembleIdent.getCaseUuid(),
             computedEnsembleIdent.getEnsembleName()
         );
@@ -409,7 +409,7 @@ export function Settings({ settingsContext, workbenchSession, workbenchServices
     function hideAllWells() {
         setSelectedWellUuids([]);
     }
-    function handleEnsembleSelectionChange(newEnsembleIdent: EnsembleIdent | null) {
+    function handleEnsembleSelectionChange(newEnsembleIdent: RegularEnsembleIdent | null) {
         setSelectedEnsembleIdent(newEnsembleIdent);
         if (newEnsembleIdent) {
             syncHelper.publishValue(SyncSettingKey.ENSEMBLE, "global.syncValue.ensembles", [newEnsembleIdent]);
@@ -492,7 +492,7 @@ export function Settings({ settingsContext, workbenchSession, workbenchServices
             <CollapsibleGroup expanded={true} title="Ensemble and realization">
                 <Label text="Ensemble" synced={syncHelper.isSynced(SyncSettingKey.ENSEMBLE)}>
                     <EnsembleDropdown
-                        ensembles={ensembleSet.getEnsembleArr()}
+                        ensembles={ensembleSet.getRegularEnsembleArray()}
                         value={computedEnsembleIdent ? computedEnsembleIdent : null}
                         onChange={handleEnsembleSelectionChange}
                     />
diff --git a/frontend/src/modules/SubsurfaceMap/view.tsx b/frontend/src/modules/SubsurfaceMap/view.tsx
index 8e88671cc..dbac5bba6 100644
--- a/frontend/src/modules/SubsurfaceMap/view.tsx
+++ b/frontend/src/modules/SubsurfaceMap/view.tsx
@@ -2,8 +2,8 @@ import React from "react";
 
 import { BoundingBox2d_api, PolygonData_api, SurfaceDef_api, WellboreTrajectory_api } from "@api";
 import { ContinuousLegend } from "@emerson-eps/color-tables";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ModuleViewProps } from "@framework/Module";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { SyncSettingKey, SyncSettingsHelper } from "@framework/SyncSettings";
 import { useEnsembleSet } from "@framework/WorkbenchSession";
 import { Wellbore } from "@framework/types/wellbore";
@@ -103,7 +103,7 @@ export function View({
 
     let fieldIdentifier: null | string = null;
     if (meshSurfAddr) {
-        const ensembleIdent = new EnsembleIdent(meshSurfAddr.caseUuid, meshSurfAddr.ensemble);
+        const ensembleIdent = new RegularEnsembleIdent(meshSurfAddr.caseUuid, meshSurfAddr.ensemble);
         fieldIdentifier = ensembleSet.findEnsemble(ensembleIdent)?.getFieldIdentifier() ?? null;
     }
     const wellTrajectoriesQuery = useFieldWellboreTrajectoriesQuery(fieldIdentifier ?? undefined);
diff --git a/frontend/src/modules/TornadoChart/settings/settings.tsx b/frontend/src/modules/TornadoChart/settings/settings.tsx
index 30e247034..c05db040c 100644
--- a/frontend/src/modules/TornadoChart/settings/settings.tsx
+++ b/frontend/src/modules/TornadoChart/settings/settings.tsx
@@ -1,8 +1,8 @@
 import React from "react";
 
 import { KeyKind } from "@framework/DataChannelTypes";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ModuleSettingsProps } from "@framework/Module";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { Checkbox } from "@lib/components/Checkbox";
 import { CollapsibleGroup } from "@lib/components/CollapsibleGroup";
 import { Dropdown } from "@lib/components/Dropdown";
@@ -53,7 +53,7 @@ export function Settings({ settingsContext, workbenchSession }: ModuleSettingsPr
             const ensembleIdentString = responseReceiver.channel.contents[0].metaData.ensembleIdentString;
             if (typeof ensembleIdentString === "string") {
                 try {
-                    const ensembleIdent = EnsembleIdent.fromString(ensembleIdentString);
+                    const ensembleIdent = RegularEnsembleIdent.fromString(ensembleIdentString);
                     const ensemble = ensembleSet.findEnsemble(ensembleIdent);
                     if (ensemble) {
                         sensitivityNames.push(
diff --git a/frontend/src/modules/TornadoChart/view/view.tsx b/frontend/src/modules/TornadoChart/view/view.tsx
index e09a1449f..2a6369b09 100644
--- a/frontend/src/modules/TornadoChart/view/view.tsx
+++ b/frontend/src/modules/TornadoChart/view/view.tsx
@@ -1,9 +1,9 @@
 import React from "react";
 
 import { KeyKind } from "@framework/DataChannelTypes";
-import { Ensemble } from "@framework/Ensemble";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ModuleViewProps } from "@framework/Module";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { useEnsembleSet } from "@framework/WorkbenchSession";
 import { Tag } from "@lib/components/Tag";
 import { useElementSize } from "@lib/hooks/useElementSize";
@@ -39,7 +39,7 @@ export const View = ({ viewContext, workbenchSession, workbenchSettings }: Modul
 
     const realizations: number[] = [];
     const values: number[] = [];
-    let channelEnsemble: Ensemble | null = null;
+    let channelEnsemble: RegularEnsemble | null = null;
     if (responseReceiver.channel && responseReceiver.channel.contents.length > 0) {
         const data = responseReceiver.channel.contents[0].dataArray;
         if (data) {
@@ -51,7 +51,7 @@ export const View = ({ viewContext, workbenchSession, workbenchSettings }: Modul
         if (responseReceiver.channel.contents[0].metaData.ensembleIdentString) {
             const ensembleIdentString = responseReceiver.channel.contents[0].metaData.ensembleIdentString;
             if (typeof ensembleIdentString === "string") {
-                const ensembleIdent = EnsembleIdent.fromString(ensembleIdentString);
+                const ensembleIdent = RegularEnsembleIdent.fromString(ensembleIdentString);
                 channelEnsemble = ensembleSet.findEnsemble(ensembleIdent);
             }
         }
diff --git a/frontend/src/modules/Vfp/settings/atoms/baseAtoms.ts b/frontend/src/modules/Vfp/settings/atoms/baseAtoms.ts
index 143ea37d3..f3a77e210 100644
--- a/frontend/src/modules/Vfp/settings/atoms/baseAtoms.ts
+++ b/frontend/src/modules/Vfp/settings/atoms/baseAtoms.ts
@@ -1,21 +1,15 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { atomWithCompare } from "@framework/utils/atomUtils";
+import { areEnsembleIdentsEqual } from "@framework/utils/ensembleIdentUtils";
 import { PressureOption, VfpParam } from "@modules/Vfp/types";
 
 import { atom } from "jotai";
 
-function areEnsembleIdentsEqual(a: EnsembleIdent | null, b: EnsembleIdent | null) {
-    if (a === null) {
-        return b === null;
-    }
-    return a.equals(b);
-}
-
 export const userSelectedRealizationNumberAtom = atom<number | null>(null);
 
 export const validRealizationNumbersAtom = atom<number[] | null>(null);
 
-export const userSelectedEnsembleIdentAtom = atomWithCompare<EnsembleIdent | null>(null, areEnsembleIdentsEqual);
+export const userSelectedEnsembleIdentAtom = atomWithCompare<RegularEnsembleIdent | null>(null, areEnsembleIdentsEqual);
 
 export const userSelectedVfpTableNameAtom = atom<string | null>(null);
 
diff --git a/frontend/src/modules/Vfp/settings/atoms/derivedAtoms.ts b/frontend/src/modules/Vfp/settings/atoms/derivedAtoms.ts
index dec737d7b..49f69798f 100644
--- a/frontend/src/modules/Vfp/settings/atoms/derivedAtoms.ts
+++ b/frontend/src/modules/Vfp/settings/atoms/derivedAtoms.ts
@@ -1,6 +1,7 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { EnsembleSetAtom } from "@framework/GlobalAtoms";
-import { fixupEnsembleIdent } from "@framework/utils/ensembleUiHelpers";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
+import { fixupRegularEnsembleIdent } from "@framework/utils/ensembleUiHelpers";
+import { isProdTable } from "@modules/Vfp/utils/vfpTableClassifier";
 
 import { atom } from "jotai";
 
@@ -19,7 +20,6 @@ import {
 import { vfpTableNamesQueryAtom, vfpTableQueryAtom } from "./queryAtoms";
 
 import { PressureOption, VfpParam } from "../../types";
-import { isProdTable } from "@modules/Vfp/utils/vfpTableClassifier";
 
 export const vfpTableNamesQueryResultAtom = atom((get) => {
     return get(vfpTableNamesQueryAtom);
@@ -30,11 +30,11 @@ export const availableVfpTableNamesAtom = atom<string[]>((get) => {
     return vfpTableNamesQueryResult.data?.map((item) => item) ?? [];
 });
 
-export const selectedEnsembleIdentAtom = atom<EnsembleIdent | null>((get) => {
+export const selectedEnsembleIdentAtom = atom<RegularEnsembleIdent | null>((get) => {
     const ensembleSet = get(EnsembleSetAtom);
     const userSelectedEnsembleIdent = get(userSelectedEnsembleIdentAtom);
 
-    const validEnsembleIdent = fixupEnsembleIdent(userSelectedEnsembleIdent, ensembleSet);
+    const validEnsembleIdent = fixupRegularEnsembleIdent(userSelectedEnsembleIdent, ensembleSet);
     return validEnsembleIdent;
 });
 
@@ -93,10 +93,10 @@ export const selectedWfrIndicesAtom = atom<number[] | null>((get) => {
     const vfpTable = get(vfpTableQueryAtom).data;
     const userSelectedWfrIndicies = get(userSelectedWfrIndicesAtom);
     if (vfpTable === undefined) {
-        return null
+        return null;
     }
-    if (!(isProdTable(vfpTable))) {
-        return null
+    if (!isProdTable(vfpTable)) {
+        return null;
     }
     const wfr_values = vfpTable.wfrValues ?? [];
     if (wfr_values.length === 0) {
@@ -104,7 +104,7 @@ export const selectedWfrIndicesAtom = atom<number[] | null>((get) => {
     }
     if (!userSelectedWfrIndicies) {
         return [0];
-    } 
+    }
     return userSelectedWfrIndicies;
 });
 
@@ -112,10 +112,10 @@ export const selectedGfrIndicesAtom = atom<number[] | null>((get) => {
     const vfpTable = get(vfpTableQueryAtom).data;
     const userSelectedGfrIndicies = get(userSelectedGfrIndicesAtom);
     if (vfpTable === undefined) {
-        return null
+        return null;
     }
-    if (!(isProdTable(vfpTable))) {
-        return null
+    if (!isProdTable(vfpTable)) {
+        return null;
     }
     const gfr_values = vfpTable.gfrValues ?? [];
     if (gfr_values.length === 0) {
@@ -131,10 +131,10 @@ export const selectedAlqIndicesAtom = atom<number[] | null>((get) => {
     const vfpTable = get(vfpTableQueryAtom).data;
     const userSelectedAlqIndicies = get(userSelectedAlqIndicesAtom);
     if (vfpTable === undefined) {
-        return null
+        return null;
     }
-    if (!(isProdTable(vfpTable))) {
-        return null
+    if (!isProdTable(vfpTable)) {
+        return null;
     }
     const alq_values = vfpTable.alqValues ?? [];
     if (alq_values.length === 0) {
@@ -159,13 +159,13 @@ export const selectedColorByAtom = atom<VfpParam>((get) => {
     const vfpTable = get(vfpTableQueryAtom).data;
     const userSelectedColorBy = get(userSelectedColorByAtom);
     if (vfpTable === undefined) {
-        return VfpParam.THP
+        return VfpParam.THP;
     }
     if (userSelectedColorBy === null) {
-        return VfpParam.THP
+        return VfpParam.THP;
     }
     if (!isProdTable(vfpTable) && ["WFR", "GFR", "ALQ"].includes(userSelectedColorBy)) {
-        return VfpParam.THP
+        return VfpParam.THP;
     }
-    return userSelectedColorBy
+    return userSelectedColorBy;
 });
diff --git a/frontend/src/modules/Vfp/settings/settings.tsx b/frontend/src/modules/Vfp/settings/settings.tsx
index 27cfee531..529802287 100644
--- a/frontend/src/modules/Vfp/settings/settings.tsx
+++ b/frontend/src/modules/Vfp/settings/settings.tsx
@@ -1,5 +1,5 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ModuleSettingsProps } from "@framework/Module";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { useSettingsStatusWriter } from "@framework/StatusWriter";
 import { useEnsembleRealizationFilterFunc, useEnsembleSet } from "@framework/WorkbenchSession";
 import { EnsembleDropdown } from "@framework/components/EnsembleDropdown";
@@ -84,7 +84,7 @@ export function Settings({ workbenchSession, settingsContext }: ModuleSettingsPr
 
     usePropagateApiErrorToStatusWriter(vfpTableQuery, statusWriter);
 
-    function handleEnsembleSelectionChange(ensembleIdent: EnsembleIdent | null) {
+    function handleEnsembleSelectionChange(ensembleIdent: RegularEnsembleIdent | null) {
         setUserSelectedEnsembleIdent(ensembleIdent);
     }
 
@@ -149,7 +149,7 @@ export function Settings({ workbenchSession, settingsContext }: ModuleSettingsPr
         <div className="flex flex-col gap-2">
             <CollapsibleGroup expanded={true} title="Ensemble">
                 <EnsembleDropdown
-                    ensembles={ensembleSet.getEnsembleArr()}
+                    ensembles={ensembleSet.getRegularEnsembleArray()}
                     value={selectedEnsembleIdent}
                     onChange={handleEnsembleSelectionChange}
                 />
diff --git a/frontend/src/modules/WellCompletions/settings/atoms/baseAtoms.ts b/frontend/src/modules/WellCompletions/settings/atoms/baseAtoms.ts
index 612161372..5b9dbe7f8 100644
--- a/frontend/src/modules/WellCompletions/settings/atoms/baseAtoms.ts
+++ b/frontend/src/modules/WellCompletions/settings/atoms/baseAtoms.ts
@@ -1,11 +1,11 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { ColorSet } from "@lib/utils/ColorSet";
 import { RealizationSelection, TimeAggregationSelection } from "@modules/WellCompletions/typesAndEnums";
 import { SortDirection, SortWellsBy } from "@webviz/well-completions-plot";
 
 import { atom } from "jotai";
 
-export const syncedEnsembleIdentsAtom = atom<EnsembleIdent[] | null>(null);
+export const syncedEnsembleIdentsAtom = atom<RegularEnsembleIdent[] | null>(null);
 export const selectedStratigraphyColorSetAtom = atom<ColorSet | null>(null);
 export const userExcludeWellTextAtom = atom<string>("");
 export const userSearchWellTextAtom = atom<string>("");
@@ -13,7 +13,7 @@ export const userSelectedCompletionDateIndexAtom = atom<number>(0);
 export const userSelectedCompletionDateIndexRangeAtom = atom<[number, number]>([0, 0]);
 export const userSelectedTimeAggregationAtom = atom<TimeAggregationSelection>(TimeAggregationSelection.NONE);
 export const userSelectedHideZeroCompletionsAtom = atom<boolean>(false);
-export const userSelectedEnsembleIdentAtom = atom<EnsembleIdent | null>(null);
+export const userSelectedEnsembleIdentAtom = atom<RegularEnsembleIdent | null>(null);
 export const userSelectedRealizationNumberAtom = atom<number | null>(null);
 export const userSelectedRealizationSelectionAtom = atom<RealizationSelection>(RealizationSelection.AGGREGATED);
 export const userSelectedSortWellsByAtom = atom<SortWellsBy>(SortWellsBy.WELL_NAME);
diff --git a/frontend/src/modules/WellCompletions/settings/atoms/derivedAtoms.ts b/frontend/src/modules/WellCompletions/settings/atoms/derivedAtoms.ts
index c64ab55cb..6d5554870 100644
--- a/frontend/src/modules/WellCompletions/settings/atoms/derivedAtoms.ts
+++ b/frontend/src/modules/WellCompletions/settings/atoms/derivedAtoms.ts
@@ -1,5 +1,5 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { EnsembleSetAtom, ValidEnsembleRealizationsFunctionAtom } from "@framework/GlobalAtoms";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { DataLoadingStatus, TimeAggregationSelection } from "@modules/WellCompletions/typesAndEnums";
 import { WellCompletionsDataAccessor } from "@modules/WellCompletions/utils/wellCompletionsDataAccessor";
 import { PlotData } from "@webviz/well-completions-plot";
@@ -22,7 +22,7 @@ import {
 } from "./baseAtoms";
 import { wellCompletionsQueryAtom } from "./queryAtoms";
 
-export const selectedEnsembleIdentAtom = atom<EnsembleIdent | null>((get) => {
+export const selectedEnsembleIdentAtom = atom<RegularEnsembleIdent | null>((get) => {
     const syncedEnsembleIdents = get(syncedEnsembleIdentsAtom);
     const userSelectedEnsembleIdent = get(userSelectedEnsembleIdentAtom);
     const ensembleSet = get(EnsembleSetAtom);
@@ -31,7 +31,7 @@ export const selectedEnsembleIdentAtom = atom<EnsembleIdent | null>((get) => {
         return syncedEnsembleIdents[0];
     }
     if (userSelectedEnsembleIdent === null || !ensembleSet.hasEnsemble(userSelectedEnsembleIdent)) {
-        return ensembleSet.getEnsembleArr()[0]?.getIdent() || null;
+        return ensembleSet.getRegularEnsembleArray()[0]?.getIdent() || null;
     }
     return userSelectedEnsembleIdent;
 });
diff --git a/frontend/src/modules/WellCompletions/settings/settings.tsx b/frontend/src/modules/WellCompletions/settings/settings.tsx
index 27110da63..229f5f459 100644
--- a/frontend/src/modules/WellCompletions/settings/settings.tsx
+++ b/frontend/src/modules/WellCompletions/settings/settings.tsx
@@ -1,7 +1,7 @@
 import React from "react";
 
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { ModuleSettingsProps } from "@framework/Module";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { useSettingsStatusWriter } from "@framework/StatusWriter";
 import { SyncSettingKey, SyncSettingsHelper } from "@framework/SyncSettings";
 import { useEnsembleSet } from "@framework/WorkbenchSession";
@@ -96,7 +96,7 @@ export const Settings = ({
         userSelectedSortWellsDirectionAtom
     );
 
-    const [prevSyncedEnsembleIdents, setPrevSyncedEnsembleIdents] = React.useState<EnsembleIdent[] | null>(null);
+    const [prevSyncedEnsembleIdents, setPrevSyncedEnsembleIdents] = React.useState<RegularEnsembleIdent[] | null>(null);
     const [prevStratigraphyColorSet, setPrevStratigraphyColorSet] = React.useState<ColorSet | null>(null);
 
     const syncedSettingKeys = settingsContext.useSyncedSettingKeys();
@@ -118,7 +118,7 @@ export const Settings = ({
 
     useMakeSettingsStatusWriterMessages(statusWriter);
 
-    function handleEnsembleSelectionChange(newEnsembleIdent: EnsembleIdent | null) {
+    function handleEnsembleSelectionChange(newEnsembleIdent: RegularEnsembleIdent | null) {
         setUserSelectedEnsembleIdent(newEnsembleIdent);
         if (newEnsembleIdent) {
             syncHelper.publishValue(SyncSettingKey.ENSEMBLE, "global.syncValue.ensembles", [newEnsembleIdent]);
@@ -193,7 +193,7 @@ export const Settings = ({
         <div className="flex flex-col gap-2 overflow-y-auto">
             <CollapsibleGroup expanded={true} title="Ensemble">
                 <EnsembleDropdown
-                    ensembles={ensembleSet.getEnsembleArr()}
+                    ensembles={ensembleSet.getRegularEnsembleArray()}
                     value={selectedEnsembleIdent}
                     onChange={handleEnsembleSelectionChange}
                 />
diff --git a/frontend/src/modules/WellLogViewer/settings/atoms/derivedAtoms.ts b/frontend/src/modules/WellLogViewer/settings/atoms/derivedAtoms.ts
index 77d14b942..9b7a2ab12 100644
--- a/frontend/src/modules/WellLogViewer/settings/atoms/derivedAtoms.ts
+++ b/frontend/src/modules/WellLogViewer/settings/atoms/derivedAtoms.ts
@@ -28,15 +28,15 @@ export type TransformFormationDataResult = ReturnType<typeof transformFormationD
 
 export const firstEnsembleInSelectedFieldAtom = atom((get) => {
     const selectedFieldId = get(userSelectedFieldIdentifierAtom);
-    const ensembleSetArr = get(EnsembleSetAtom).getEnsembleArr();
+    const regularEnsembleArray = get(EnsembleSetAtom).getRegularEnsembleArray();
 
-    if (!ensembleSetArr.length) {
+    if (!regularEnsembleArray.length) {
         return null;
     }
 
-    const selectedEnsemble = ensembleSetArr.find((e) => e.getFieldIdentifier() === selectedFieldId);
+    const selectedEnsemble = regularEnsembleArray.find((e) => e.getFieldIdentifier() === selectedFieldId);
 
-    return selectedEnsemble ?? ensembleSetArr[0];
+    return selectedEnsemble ?? regularEnsembleArray[0];
 });
 
 export const selectedFieldIdentifierAtom = atom((get) => {
diff --git a/frontend/src/modules/_shared/InplaceVolumetrics/Table.ts b/frontend/src/modules/_shared/InplaceVolumetrics/Table.ts
index 59fb53489..9a451ee9d 100644
--- a/frontend/src/modules/_shared/InplaceVolumetrics/Table.ts
+++ b/frontend/src/modules/_shared/InplaceVolumetrics/Table.ts
@@ -1,4 +1,4 @@
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 
 import { TableCollection } from "./TableCollection";
 
@@ -148,7 +148,10 @@ export class Table {
         return row;
     }
 
-    filterRowsByColumn(columnName: string, predicate: (value: string | number | EnsembleIdent) => boolean): Row[] {
+    filterRowsByColumn(
+        columnName: string,
+        predicate: (value: string | number | RegularEnsembleIdent) => boolean
+    ): Row[] {
         const columnIndex = this._columns.findIndex((column) => column.getName() === columnName);
 
         if (columnIndex === -1) {
diff --git a/frontend/src/modules/_shared/InplaceVolumetrics/TableDefinitionsAccessor.ts b/frontend/src/modules/_shared/InplaceVolumetrics/TableDefinitionsAccessor.ts
index b5c9ee994..c9265f20f 100644
--- a/frontend/src/modules/_shared/InplaceVolumetrics/TableDefinitionsAccessor.ts
+++ b/frontend/src/modules/_shared/InplaceVolumetrics/TableDefinitionsAccessor.ts
@@ -4,12 +4,12 @@ import {
     InplaceVolumetricsIdentifierWithValues_api,
     InplaceVolumetricsTableDefinition_api,
 } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 
 import { sortResultNames } from "./sortResultNames";
 
 type TableDefinitionsForEnsembleIdent = {
-    ensembleIdent: EnsembleIdent;
+    ensembleIdent: RegularEnsembleIdent;
     tableDefinitions: InplaceVolumetricsTableDefinition_api[];
 };
 
@@ -48,7 +48,7 @@ export function makeUniqueTableNamesIntersection(
 export class TableDefinitionsAccessor {
     private _tableDefinitions: InplaceVolumetricsTableDefinition_api[];
     private _tableNamesFilter: string[];
-    private _uniqueEnsembleIdents: EnsembleIdent[];
+    private _uniqueEnsembleIdents: RegularEnsembleIdent[];
     private _tableNamesIntersection: string[];
     private _fluidZonesIntersection: FluidZone_api[] = [];
     private _resultNamesIntersection: InplaceVolumetricResultName_api[] = [];
@@ -135,7 +135,7 @@ export class TableDefinitionsAccessor {
         this._identifiersWithIntersectionValues = identifiersWithValuesIntersection.sort();
     }
 
-    getUniqueEnsembleIdents(): EnsembleIdent[] {
+    getUniqueEnsembleIdents(): RegularEnsembleIdent[] {
         return this._uniqueEnsembleIdents;
     }
 
@@ -159,7 +159,7 @@ export class TableDefinitionsAccessor {
         return !this._tablesNotComparable;
     }
 
-    hasEnsembleIdents(ensembleIdents: EnsembleIdent[]): boolean {
+    hasEnsembleIdents(ensembleIdents: RegularEnsembleIdent[]): boolean {
         for (const ensembleIdent of ensembleIdents) {
             if (!this._uniqueEnsembleIdents.includes(ensembleIdent)) {
                 return false;
diff --git a/frontend/src/modules/_shared/InplaceVolumetrics/queryHooks.ts b/frontend/src/modules/_shared/InplaceVolumetrics/queryHooks.ts
index 31d9e1340..39452799d 100644
--- a/frontend/src/modules/_shared/InplaceVolumetrics/queryHooks.ts
+++ b/frontend/src/modules/_shared/InplaceVolumetrics/queryHooks.ts
@@ -7,7 +7,7 @@ import {
     InplaceVolumetricsIdentifier_api,
 } from "@api";
 import { apiService } from "@framework/ApiService";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import {
     InplaceVolumetricsStatisticalTableData,
     InplaceVolumetricsTableData,
@@ -15,7 +15,7 @@ import {
 import { UseQueryResult } from "@tanstack/react-query";
 
 export type EnsembleIdentWithRealizations = {
-    ensembleIdent: EnsembleIdent;
+    ensembleIdent: RegularEnsembleIdent;
     realizations: readonly number[];
 };
 
@@ -48,7 +48,8 @@ export function useGetAggregatedStatisticalTableDataQueries(
     identifiersWithValues: InplaceVolumetricsIdentifierWithValues_api[],
     allowEnable: boolean
 ) {
-    const uniqueSources: { ensembleIdent: EnsembleIdent; realizations: readonly number[]; tableName: string }[] = [];
+    const uniqueSources: { ensembleIdent: RegularEnsembleIdent; realizations: readonly number[]; tableName: string }[] =
+        [];
     for (const el of ensembleIdentsWithRealizations) {
         for (const tableName of tableNames) {
             uniqueSources.push({ ensembleIdent: el.ensembleIdent, realizations: el.realizations, tableName });
@@ -144,7 +145,8 @@ export function useGetAggregatedPerRealizationTableDataQueries(
     identifiersWithValues: InplaceVolumetricsIdentifierWithValues_api[],
     allowEnable: boolean
 ) {
-    const uniqueSources: { ensembleIdent: EnsembleIdent; realizations: readonly number[]; tableName: string }[] = [];
+    const uniqueSources: { ensembleIdent: RegularEnsembleIdent; realizations: readonly number[]; tableName: string }[] =
+        [];
     for (const el of ensembleIdentsWithRealizations) {
         for (const tableName of tableNames) {
             uniqueSources.push({ ensembleIdent: el.ensembleIdent, realizations: el.realizations, tableName });
diff --git a/frontend/src/modules/_shared/InplaceVolumetrics/types.ts b/frontend/src/modules/_shared/InplaceVolumetrics/types.ts
index 880f3bc9d..848d92f19 100644
--- a/frontend/src/modules/_shared/InplaceVolumetrics/types.ts
+++ b/frontend/src/modules/_shared/InplaceVolumetrics/types.ts
@@ -4,18 +4,18 @@ import {
     InplaceVolumetricTableDataPerFluidSelection_api,
     InplaceVolumetricsIdentifier_api,
 } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 
 import { Column } from "./Table";
 
 export type InplaceVolumetricsTableData = {
-    ensembleIdent: EnsembleIdent;
+    ensembleIdent: RegularEnsembleIdent;
     tableName: string;
     data: InplaceVolumetricTableDataPerFluidSelection_api;
 };
 
 export type InplaceVolumetricsStatisticalTableData = {
-    ensembleIdent: EnsembleIdent;
+    ensembleIdent: RegularEnsembleIdent;
     tableName: string;
     data: InplaceStatisticalVolumetricTableDataPerFluidSelection_api;
 };
diff --git a/frontend/src/modules/_shared/Surface/SurfaceAddressBuilder.ts b/frontend/src/modules/_shared/Surface/SurfaceAddressBuilder.ts
index 34ba220a6..cc1a7ef8d 100644
--- a/frontend/src/modules/_shared/Surface/SurfaceAddressBuilder.ts
+++ b/frontend/src/modules/_shared/Surface/SurfaceAddressBuilder.ts
@@ -1,5 +1,5 @@
 import { SurfaceStatisticFunction_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 
 import { SurfaceAddressType } from "./surfaceAddress";
 import { ObservedSurfaceAddress, RealizationSurfaceAddress, StatisticalSurfaceAddress } from "./surfaceAddress";
@@ -22,7 +22,7 @@ export class SurfaceAddressBuilder {
         return this;
     }
 
-    withEnsembleIdent(ensembleIdent: EnsembleIdent): this {
+    withEnsembleIdent(ensembleIdent: RegularEnsembleIdent): this {
         this._caseUuid = ensembleIdent.getCaseUuid();
         this._ensemble = ensembleIdent.getEnsembleName();
         return this;
diff --git a/frontend/src/modules/_shared/components/InplaceVolumetricsFilterComponent/inplaceVolumetricsFilterComponent.tsx b/frontend/src/modules/_shared/components/InplaceVolumetricsFilterComponent/inplaceVolumetricsFilterComponent.tsx
index caf4a56d0..d23937519 100644
--- a/frontend/src/modules/_shared/components/InplaceVolumetricsFilterComponent/inplaceVolumetricsFilterComponent.tsx
+++ b/frontend/src/modules/_shared/components/InplaceVolumetricsFilterComponent/inplaceVolumetricsFilterComponent.tsx
@@ -1,9 +1,9 @@
 import React from "react";
 
 import { FluidZone_api, InplaceVolumetricsIdentifierWithValues_api, InplaceVolumetricsIdentifier_api } from "@api";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
 import { EnsembleSet } from "@framework/EnsembleSet";
 import { SettingsContext } from "@framework/ModuleContext";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 import { SyncSettingKey, SyncSettingsHelper } from "@framework/SyncSettings";
 import { WorkbenchServices } from "@framework/WorkbenchServices";
 import { EnsembleSelect } from "@framework/components/EnsembleSelect";
@@ -21,7 +21,7 @@ export type InplaceVolumetricsFilterComponentProps = {
     availableTableNames: string[];
     availableFluidZones: FluidZone_api[];
     availableIdentifiersWithValues: InplaceVolumetricsIdentifierWithValues_api[];
-    selectedEnsembleIdents: EnsembleIdent[];
+    selectedEnsembleIdents: RegularEnsembleIdent[];
     selectedTableNames: string[];
     selectedFluidZones: FluidZone_api[];
     selectedIdentifiersValues: InplaceVolumetricsIdentifierWithValues_api[];
@@ -34,14 +34,16 @@ export type InplaceVolumetricsFilterComponentProps = {
 };
 
 export function InplaceVolumetricsFilterComponent(props: InplaceVolumetricsFilterComponentProps): React.ReactNode {
-    const [ensembleIdents, setEnsembleIdents] = React.useState<EnsembleIdent[]>(props.selectedEnsembleIdents);
+    const [ensembleIdents, setEnsembleIdents] = React.useState<RegularEnsembleIdent[]>(props.selectedEnsembleIdents);
     const [tableNames, setTableNames] = React.useState<string[]>(props.selectedTableNames);
     const [fluidZones, setFluidZones] = React.useState<FluidZone_api[]>(props.selectedFluidZones);
     const [identifiersValues, setIdentifiersValues] = React.useState<InplaceVolumetricsIdentifierWithValues_api[]>(
         props.selectedIdentifiersValues
     );
 
-    const [prevEnsembleIdents, setPrevEnsembleIdents] = React.useState<EnsembleIdent[]>(props.selectedEnsembleIdents);
+    const [prevEnsembleIdents, setPrevEnsembleIdents] = React.useState<RegularEnsembleIdent[]>(
+        props.selectedEnsembleIdents
+    );
     const [prevTableNames, setPrevTableNames] = React.useState<string[]>(props.selectedTableNames);
     const [prevFluidZones, setPrevFluidZones] = React.useState<string[]>(props.selectedFluidZones);
     const [prevIdentifiersValues, setPrevIdentifiersValues] = React.useState<
@@ -169,7 +171,7 @@ export function InplaceVolumetricsFilterComponent(props: InplaceVolumetricsFilte
         }, props.debounceMs);
     }
 
-    function handleEnsembleIdentsChange(newEnsembleIdents: EnsembleIdent[], publish = true): void {
+    function handleEnsembleIdentsChange(newEnsembleIdents: RegularEnsembleIdent[], publish = true): void {
         setEnsembleIdents(newEnsembleIdents);
         const filter = {
             ensembleIdents: newEnsembleIdents,
@@ -226,7 +228,7 @@ export function InplaceVolumetricsFilterComponent(props: InplaceVolumetricsFilte
         <>
             <CollapsibleGroup title="Ensembles" expanded>
                 <EnsembleSelect
-                    ensembles={props.ensembleSet.getEnsembleArr()}
+                    ensembles={props.ensembleSet.getRegularEnsembleArray()}
                     value={ensembleIdents}
                     onChange={handleEnsembleIdentsChange}
                     size={5}
diff --git a/frontend/src/modules/_shared/ensembleNameUtils.ts b/frontend/src/modules/_shared/ensembleNameUtils.ts
index 7eb62b86c..e68d18c80 100644
--- a/frontend/src/modules/_shared/ensembleNameUtils.ts
+++ b/frontend/src/modules/_shared/ensembleNameUtils.ts
@@ -1,29 +1,29 @@
-import { Ensemble } from "@framework/Ensemble";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { DeltaEnsemble } from "@framework/DeltaEnsemble";
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 
 export function makeDistinguishableEnsembleDisplayName(
-    ensembleIdent: EnsembleIdent,
-    allEnsembles: readonly Ensemble[]
+    ensembleIdent: RegularEnsembleIdent | DeltaEnsembleIdent,
+    allEnsembles: readonly (RegularEnsemble | DeltaEnsemble)[]
 ): string {
     const ensemble = allEnsembles.find((ensemble) => ensemble.getIdent().equals(ensembleIdent));
 
-    if (ensemble) {
-        const customName = ensemble.getCustomName();
-        if (customName) {
-            return customName;
-        }
+    if (!ensemble) {
+        return ensembleIdent.getEnsembleName();
+    }
+
+    const customName = ensemble.getCustomName();
+    if (customName) {
+        return customName;
     }
 
     const ensembleNameCount = allEnsembles.filter(
-        (ensemble) => ensemble.getEnsembleName() === ensembleIdent.getEnsembleName()
+        (elm) => elm.getEnsembleName() === ensembleIdent.getEnsembleName()
     ).length;
     if (ensembleNameCount === 1) {
         return ensembleIdent.getEnsembleName();
     }
 
-    if (!ensemble) {
-        return ensembleIdent.getEnsembleName();
-    }
-
     return ensemble.getDisplayName();
 }
diff --git a/frontend/tests/unit/DeltaEnsemble.test.ts b/frontend/tests/unit/DeltaEnsemble.test.ts
new file mode 100644
index 000000000..f3fbb4824
--- /dev/null
+++ b/frontend/tests/unit/DeltaEnsemble.test.ts
@@ -0,0 +1,123 @@
+import { DeltaEnsemble } from "@framework/DeltaEnsemble";
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
+import { EnsembleParameters, ParameterType } from "@framework/EnsembleParameters";
+import { SensitivityType } from "@framework/EnsembleSensitivities";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
+
+import { describe, expect, test } from "vitest";
+
+describe("DeltaEnsemble", () => {
+    const COMPARE_ENSEMBLE = new RegularEnsemble(
+        "field1",
+        "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa",
+        "case1",
+        "ensemble1",
+        "stratigraphicColumn1",
+        [1, 2, 3, 4],
+        [
+            {
+                type: ParameterType.CONTINUOUS,
+                name: "param1",
+                groupName: null,
+                description: "desc_param1",
+                isConstant: false,
+                isLogarithmic: false,
+                realizations: [0, 1, 2],
+                values: [11, 12, 19],
+            },
+        ],
+        [{ name: "sens1", type: SensitivityType.MONTECARLO, cases: [] }],
+        "blue",
+        "Custom Name First Ensemble"
+    );
+
+    const REFERENCE_ENSEMBLE = new RegularEnsemble(
+        "field1",
+        "22222222-aaaa-4444-aaaa-aaaaaaaaaaaa",
+        "case2",
+        "ensemble2",
+        "stratigraphicColumn2",
+        [3, 4, 5, 6],
+        [
+            {
+                type: ParameterType.CONTINUOUS,
+                name: "param1",
+                groupName: null,
+                description: "desc_param1",
+                isConstant: false,
+                isLogarithmic: false,
+                realizations: [0, 1, 2],
+                values: [11, 12, 19],
+            },
+        ],
+        [{ name: "sens1", type: SensitivityType.MONTECARLO, cases: [] }],
+        "green",
+        "Custom Name Second Ensemble"
+    );
+
+    const DELTA_ENSEMBLE = new DeltaEnsemble(COMPARE_ENSEMBLE, REFERENCE_ENSEMBLE, "red", "Custom Name Delta Ensemble");
+
+    test("should create a DeltaEnsemble instance", () => {
+        expect(DELTA_ENSEMBLE).toBeInstanceOf(DeltaEnsemble);
+    });
+
+    test("should return the correct ident", () => {
+        expect(DELTA_ENSEMBLE.getIdent()).toEqual(
+            new DeltaEnsembleIdent(COMPARE_ENSEMBLE.getIdent(), REFERENCE_ENSEMBLE.getIdent())
+        );
+    });
+
+    test("should return the correct display name", () => {
+        expect(DELTA_ENSEMBLE.getDisplayName()).toBe("Custom Name Delta Ensemble");
+
+        // Use display name of compare and reference ensemble if no custom name is provided
+        const DeltaEnsembleWithoutCustomName = new DeltaEnsemble(COMPARE_ENSEMBLE, REFERENCE_ENSEMBLE, "red");
+        expect(DeltaEnsembleWithoutCustomName.getDisplayName()).toBe(
+            "(Custom Name First Ensemble) - (Custom Name Second Ensemble)"
+        );
+    });
+
+    test("should return the correct ensemble name", () => {
+        const expectedEnsembleName = `(${COMPARE_ENSEMBLE.getIdent().getEnsembleName()}) - (${REFERENCE_ENSEMBLE.getIdent().getEnsembleName()})`;
+        expect(DELTA_ENSEMBLE.getEnsembleName()).toBe(expectedEnsembleName);
+    });
+
+    test("should return the correct realizations", () => {
+        expect(DELTA_ENSEMBLE.getRealizations()).toEqual([3, 4]);
+    });
+
+    test("should return the correct realization count", () => {
+        expect(DELTA_ENSEMBLE.getRealizationCount()).toBe(2);
+    });
+
+    test("should return the correct max realization number", () => {
+        expect(DELTA_ENSEMBLE.getMaxRealizationNumber()).toBe(4);
+    });
+
+    test("should return the correct color", () => {
+        expect(DELTA_ENSEMBLE.getColor()).toBe("red");
+    });
+
+    test("should return the correct custom name", () => {
+        expect(DELTA_ENSEMBLE.getCustomName()).toBe("Custom Name Delta Ensemble");
+    });
+
+    test("should return the correct parameters", () => {
+        // The DeltaEnsemble does not support parameters yet, i.e. the parameters array is empty
+        expect(DELTA_ENSEMBLE.getParameters()).toBeInstanceOf(EnsembleParameters);
+        expect(DELTA_ENSEMBLE.getParameters().getParameterArr.length).toBe(0);
+    });
+
+    test("should return the correct sensitivities", () => {
+        // The DeltaEnsemble does not support sensitivities yet, i.e. the sensitivity array is empty
+        expect(DELTA_ENSEMBLE.getSensitivities()).toBeNull();
+    });
+
+    test("should return the correct compare ensemble ident", () => {
+        expect(DELTA_ENSEMBLE.getCompareEnsembleIdent().equals(COMPARE_ENSEMBLE.getIdent())).toBe(true);
+    });
+
+    test("should return the correct reference ensemble ident", () => {
+        expect(DELTA_ENSEMBLE.getReferenceEnsembleIdent().equals(REFERENCE_ENSEMBLE.getIdent())).toBe(true);
+    });
+});
diff --git a/frontend/tests/unit/DeltaEnsembleIdent.test.ts b/frontend/tests/unit/DeltaEnsembleIdent.test.ts
new file mode 100644
index 000000000..9ce424afd
--- /dev/null
+++ b/frontend/tests/unit/DeltaEnsembleIdent.test.ts
@@ -0,0 +1,85 @@
+import { describe, expect, test } from "vitest";
+
+import { DeltaEnsembleIdent } from "../../src/framework/DeltaEnsembleIdent";
+import { RegularEnsembleIdent } from "../../src/framework/RegularEnsembleIdent";
+
+describe("DeltaEnsembleIdent", () => {
+    const compareEnsembleIdent = new RegularEnsembleIdent(
+        "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa",
+        "compare-ensemble-name"
+    );
+    const referenceEnsembleIdent = new RegularEnsembleIdent(
+        "22222222-aaaa-4444-aaaa-aaaaaaaaaaaa",
+        "reference-ensemble-name"
+    );
+
+    test("should create a valid DeltaEnsembleIdent instance", () => {
+        const deltaEnsembleIdent = new DeltaEnsembleIdent(compareEnsembleIdent, referenceEnsembleIdent);
+        expect(deltaEnsembleIdent.getCompareEnsembleIdent()).toBe(compareEnsembleIdent);
+        expect(deltaEnsembleIdent.getReferenceEnsembleIdent()).toBe(referenceEnsembleIdent);
+        expect(deltaEnsembleIdent.getEnsembleName()).toBe("(compare-ensemble-name) - (reference-ensemble-name)");
+    });
+    test("should convert compare and reference ensemble idents to a string", () => {
+        const result = DeltaEnsembleIdent.compareEnsembleIdentAndReferenceEnsembleIdentToString(
+            compareEnsembleIdent,
+            referenceEnsembleIdent
+        );
+        expect(result).toBe(`~@@~${compareEnsembleIdent.toString()}~@@~${referenceEnsembleIdent.toString()}~@@~`);
+    });
+
+    test("should get ensemble ident string matching uuid and ensembles string with separator", () => {
+        const compareEnsembleIdentString = compareEnsembleIdent.toString();
+        const referenceEnsembleIdentString = referenceEnsembleIdent.toString();
+        const deltaEnsemble = new DeltaEnsembleIdent(compareEnsembleIdent, referenceEnsembleIdent);
+        const result = deltaEnsemble.toString();
+        expect(result).toBe(`~@@~${compareEnsembleIdentString}~@@~${referenceEnsembleIdentString}~@@~`);
+    });
+
+    test("should create DeltaEnsembleIdent instance from string", () => {
+        const deltaEnsembleIdentString = `~@@~${compareEnsembleIdent.toString()}~@@~${referenceEnsembleIdent.toString()}~@@~`;
+        const deltaEnsembleIdent = DeltaEnsembleIdent.fromString(deltaEnsembleIdentString);
+        expect(deltaEnsembleIdent.getCompareEnsembleIdent().equals(compareEnsembleIdent)).toBe(true);
+        expect(deltaEnsembleIdent.getReferenceEnsembleIdent().equals(referenceEnsembleIdent)).toBe(true);
+    });
+
+    test("should convert to string and back correctly", () => {
+        const deltaEnsembleIdent = new DeltaEnsembleIdent(compareEnsembleIdent, referenceEnsembleIdent);
+        const deltaEnsembleIdentString = deltaEnsembleIdent.toString();
+        const parsedDeltaEnsembleIdent = DeltaEnsembleIdent.fromString(deltaEnsembleIdentString);
+        expect(parsedDeltaEnsembleIdent.equals(deltaEnsembleIdent)).toBe(true);
+    });
+
+    test("should validate a correct DeltaEnsembleIdent string", () => {
+        const deltaEnsembleIdent = new DeltaEnsembleIdent(compareEnsembleIdent, referenceEnsembleIdent);
+        const deltaEnsembleIdentString = deltaEnsembleIdent.toString();
+        expect(DeltaEnsembleIdent.isValidEnsembleIdentString(deltaEnsembleIdentString)).toBe(true);
+    });
+
+    test("should invalidate an incorrect DeltaEnsembleIdent string", () => {
+        const invalidString = "invalid-string";
+        const regularEnsembleString = compareEnsembleIdent.toString();
+        expect(DeltaEnsembleIdent.isValidEnsembleIdentString(invalidString)).toBe(false);
+        expect(DeltaEnsembleIdent.isValidEnsembleIdentString(regularEnsembleString)).toBe(false);
+    });
+
+    test("should correctly compare two DeltaEnsembleIdent instances", () => {
+        const deltaEnsembleIdent1 = new DeltaEnsembleIdent(compareEnsembleIdent, referenceEnsembleIdent);
+        const deltaEnsembleIdent2 = new DeltaEnsembleIdent(compareEnsembleIdent, referenceEnsembleIdent);
+        expect(deltaEnsembleIdent1.equals(deltaEnsembleIdent2)).toBe(true);
+    });
+
+    test("should correctly identify non-equal DeltaEnsembleIdent instances", () => {
+        const deltaEnsembleIdent1 = new DeltaEnsembleIdent(compareEnsembleIdent, referenceEnsembleIdent);
+        const deltaEnsembleIdent2 = new DeltaEnsembleIdent(
+            compareEnsembleIdent,
+            new RegularEnsembleIdent("33333333-aaaa-4444-aaaa-aaaaaaaaaaaa", "NewReferenceEnsemble")
+        );
+        expect(deltaEnsembleIdent1.equals(deltaEnsembleIdent2)).toBe(false);
+    });
+
+    test("should return false when comparing with a different type", () => {
+        const deltaEnsembleIdent = new DeltaEnsembleIdent(compareEnsembleIdent, referenceEnsembleIdent);
+        const regularEnsembleIdent = new RegularEnsembleIdent("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens1");
+        expect(deltaEnsembleIdent.equals(regularEnsembleIdent)).toBe(false);
+    });
+});
diff --git a/frontend/tests/unit/EnsembleSet.test.ts b/frontend/tests/unit/EnsembleSet.test.ts
index ec5f26dcc..7828a3675 100644
--- a/frontend/tests/unit/EnsembleSet.test.ts
+++ b/frontend/tests/unit/EnsembleSet.test.ts
@@ -1,81 +1,174 @@
-import { Ensemble } from "@framework/Ensemble";
-import { EnsembleIdent } from "@framework/EnsembleIdent";
+import { DeltaEnsemble } from "@framework/DeltaEnsemble";
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
 import { EnsembleSet } from "@framework/EnsembleSet";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
 
 import { describe, expect, test } from "vitest";
 
-const ensembleArr = [
-    new Ensemble(
-        "DROGON",
-        "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa",
-        "case1",
-        "ens1",
-        "DROGON_HAS_NO_STRAT_COLUMN",
-        [],
-        [],
-        null,
-        ""
-    ),
-    new Ensemble(
-        "DROGON",
-        "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa",
-        "case1",
-        "ens2",
-        "DROGON_HAS_NO_STRAT_COLUMN",
-        [],
-        [],
-        null,
-        ""
-    ),
-    new Ensemble(
-        "DROGON",
-        "22222222-aaaa-4444-aaaa-aaaaaaaaaaaa",
-        "case2",
-        "ens1",
-        "DROGON_HAS_NO_STRAT_COLUMN",
-        [],
-        [],
-        null,
-        ""
-    ),
+const regularEnsembleArray = [
+    new RegularEnsemble("DROGON", "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "case1", "ens1", "sc1", [], [], null, ""),
+    new RegularEnsemble("DROGON", "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "case1", "ens2", "sc2", [], [], null, ""),
+    new RegularEnsemble("DROGON", "22222222-aaaa-4444-aaaa-aaaaaaaaaaaa", "case2", "ens1", "sc3", [], [], null, ""),
 ];
 
+const deltaEnsembleArray = [
+    new DeltaEnsemble(regularEnsembleArray[0], regularEnsembleArray[1], "", null),
+    new DeltaEnsemble(regularEnsembleArray[0], regularEnsembleArray[2], "", null),
+];
+const nonExistingDeltaEnsemble = new DeltaEnsemble(regularEnsembleArray[1], regularEnsembleArray[2], "", null);
+
 describe("EnsembleSet tests", () => {
     test("access empty EnsembleSet", () => {
         const ensSet = new EnsembleSet([]);
+        expect(ensSet.hasAnyRegularEnsembles()).toBe(false);
+        expect(ensSet.hasAnyDeltaEnsembles()).toBe(false);
         expect(ensSet.hasAnyEnsembles()).toBe(false);
-        expect(ensSet.getEnsembleArr().length).toBe(0);
-        expect(ensSet.findEnsemble(new EnsembleIdent("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens1"))).toBeNull();
+        expect(ensSet.getRegularEnsembleArray().length).toBe(0);
+        expect(ensSet.getDeltaEnsembleArray().length).toBe(0);
+        expect(ensSet.getEnsembleArray().length).toBe(0);
+        expect(
+            ensSet.findEnsemble(new RegularEnsembleIdent("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens1"))
+        ).toBeNull();
+    });
+
+    test("has any regular ensembles", () => {
+        const ensSet = new EnsembleSet(regularEnsembleArray);
+        expect(ensSet.hasAnyRegularEnsembles()).toBe(true);
+        expect(ensSet.hasAnyDeltaEnsembles()).toBe(false);
+        expect(ensSet.hasAnyEnsembles()).toBe(true);
+    });
+
+    test("has any delta ensembles", () => {
+        const ensSet = new EnsembleSet([], deltaEnsembleArray);
+        expect(ensSet.hasAnyRegularEnsembles()).toBe(false);
+        expect(ensSet.hasAnyDeltaEnsembles()).toBe(true);
+        expect(ensSet.hasAnyEnsembles()).toBe(true);
     });
 
-    test("has by EnsembleIdent", () => {
-        const ensSet = new EnsembleSet(ensembleArr);
+    test("has any regular ensembles or delta ensembles", () => {
+        const ensSet = new EnsembleSet(regularEnsembleArray, deltaEnsembleArray);
+        expect(ensSet.hasAnyRegularEnsembles()).toBe(true);
+        expect(ensSet.hasAnyDeltaEnsembles()).toBe(true);
         expect(ensSet.hasAnyEnsembles()).toBe(true);
-        expect(ensSet.hasEnsemble(new EnsembleIdent("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens1"))).toBe(true);
-        expect(ensSet.hasEnsemble(new EnsembleIdent("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens99"))).toBe(false);
-        expect(ensSet.hasEnsemble(new EnsembleIdent("99999999-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens1"))).toBe(false);
     });
 
-    test("find by EnsembleIdent", () => {
-        const ensSet = new EnsembleSet(ensembleArr);
+    test("get regular ensembles", () => {
+        const ensSet = new EnsembleSet(regularEnsembleArray);
+        expect(ensSet.getRegularEnsembleArray()).toEqual(regularEnsembleArray);
+        expect(ensSet.getDeltaEnsembleArray().length).toBe(0);
+        expect(ensSet.getEnsembleArray()).toEqual(regularEnsembleArray);
+    });
+
+    test("get delta ensembles", () => {
+        const ensSet = new EnsembleSet([], deltaEnsembleArray);
+        expect(ensSet.getRegularEnsembleArray().length).toBe(0);
+        expect(ensSet.getDeltaEnsembleArray()).toEqual(deltaEnsembleArray);
+        expect(ensSet.getEnsembleArray()).toEqual(deltaEnsembleArray);
+    });
+
+    test("get regular ensembles and delta ensembles", () => {
+        const ensSet = new EnsembleSet(regularEnsembleArray, deltaEnsembleArray);
+        expect(ensSet.getRegularEnsembleArray()).toEqual(regularEnsembleArray);
+        expect(ensSet.getDeltaEnsembleArray()).toEqual(deltaEnsembleArray);
+        expect(ensSet.getEnsembleArray()).toEqual([...regularEnsembleArray, ...deltaEnsembleArray]);
+    });
+
+    test("has by RegularEnsembleIdent", () => {
+        const ensSet = new EnsembleSet(regularEnsembleArray);
+        expect(ensSet.hasAnyRegularEnsembles()).toBe(true);
+        expect(ensSet.hasAnyDeltaEnsembles()).toBe(false);
         expect(ensSet.hasAnyEnsembles()).toBe(true);
-        expect(ensSet.findEnsemble(new EnsembleIdent("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens1"))).toBeInstanceOf(
-            Ensemble
+        expect(ensSet.hasEnsemble(new RegularEnsembleIdent("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens1"))).toBe(true);
+        expect(ensSet.hasEnsemble(new RegularEnsembleIdent("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens99"))).toBe(
+            false
+        );
+        expect(ensSet.hasEnsemble(new RegularEnsembleIdent("99999999-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens1"))).toBe(
+            false
         );
-        expect(ensSet.findEnsemble(new EnsembleIdent("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens99"))).toBeNull();
-        expect(ensSet.findEnsemble(new EnsembleIdent("99999999-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens1"))).toBeNull();
     });
 
-    test("find by EnsembleIdentString", () => {
-        const ensSet = new EnsembleSet(ensembleArr);
+    test("has by DeltaEnsembleIdent", () => {
+        const ensSet = new EnsembleSet(regularEnsembleArray, deltaEnsembleArray);
+        expect(ensSet.hasAnyRegularEnsembles()).toBe(true);
+        expect(ensSet.hasAnyDeltaEnsembles()).toBe(true);
         expect(ensSet.hasAnyEnsembles()).toBe(true);
-        expect(ensSet.findEnsembleByIdentString("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa::ens1")).toBeInstanceOf(Ensemble);
+        expect(ensSet.hasEnsemble(deltaEnsembleArray[0].getIdent())).toBe(true);
+        expect(ensSet.hasEnsemble(deltaEnsembleArray[1].getIdent())).toBe(true);
+        expect(ensSet.hasEnsemble(nonExistingDeltaEnsemble.getIdent())).toBe(false);
+    });
+
+    test("find by RegularEnsembleIdent", () => {
+        const ensSet = new EnsembleSet(regularEnsembleArray, deltaEnsembleArray);
+        expect(ensSet.hasAnyRegularEnsembles()).toBe(true);
+        expect(
+            ensSet.findEnsemble(new RegularEnsembleIdent("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens1"))
+        ).toBeInstanceOf(RegularEnsemble);
+        expect(
+            ensSet.findEnsemble(new RegularEnsembleIdent("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens99"))
+        ).toBeNull();
+        expect(
+            ensSet.findEnsemble(new RegularEnsembleIdent("99999999-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens1"))
+        ).toBeNull();
+    });
+
+    test("find by DeltaEnsembleIdent", () => {
+        const ensSet = new EnsembleSet(regularEnsembleArray, deltaEnsembleArray);
+        expect(ensSet.hasAnyRegularEnsembles()).toBe(true);
+        expect(ensSet.findEnsemble(deltaEnsembleArray[0].getIdent())).toBeInstanceOf(DeltaEnsemble);
+        expect(ensSet.findEnsemble(deltaEnsembleArray[1].getIdent())).toBeInstanceOf(DeltaEnsemble);
+        expect(ensSet.findEnsemble(nonExistingDeltaEnsemble.getIdent())).toBeNull();
+    });
+
+    test("get by RegularEnsembleIdent", () => {
+        const ensSet = new EnsembleSet(regularEnsembleArray, deltaEnsembleArray);
+        expect(ensSet.hasAnyRegularEnsembles()).toBe(true);
+        expect(
+            ensSet.getEnsemble(new RegularEnsembleIdent("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens1"))
+        ).toBeInstanceOf(RegularEnsemble);
+    });
+
+    test("get by DeltaEnsembleIdent", () => {
+        const ensSet = new EnsembleSet(regularEnsembleArray, deltaEnsembleArray);
+        expect(ensSet.hasAnyDeltaEnsembles()).toBe(true);
+        expect(ensSet.getEnsemble(deltaEnsembleArray[0].getIdent())).toBeInstanceOf(DeltaEnsemble);
+    });
+
+    test("getEnsemble throws error if not found", () => {
+        const ensSet = new EnsembleSet(regularEnsembleArray, deltaEnsembleArray);
+        expect(() =>
+            ensSet.getEnsemble(new RegularEnsembleIdent("99999999-aaaa-4444-aaaa-aaaaaaaaaaaa", "ens1"))
+        ).toThrow("Ensemble not found in EnsembleSet: 99999999-aaaa-4444-aaaa-aaaaaaaaaaaa::ens1");
+        expect(() =>
+            ensSet.getEnsemble(
+                new DeltaEnsembleIdent(regularEnsembleArray[1].getIdent(), regularEnsembleArray[2].getIdent())
+            )
+        ).toThrow(`Ensemble not found in EnsembleSet: ${nonExistingDeltaEnsemble.getIdent().toString()}`);
+    });
+
+    test("find by EnsembleIdentString", () => {
+        const ensSet = new EnsembleSet(regularEnsembleArray, deltaEnsembleArray);
+        expect(ensSet.hasAnyRegularEnsembles()).toBe(true);
+        expect(ensSet.findEnsembleByIdentString("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa::ens1")).toBeInstanceOf(
+            RegularEnsemble
+        );
         expect(ensSet.findEnsembleByIdentString("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa::ens99")).toBeNull();
         expect(ensSet.findEnsembleByIdentString("99999999-aaaa-4444-aaaa-aaaaaaaaaaaa::ens1")).toBeNull();
     });
 
+    test("find by DeltaEnsembleIdentString", () => {
+        const ensSet = new EnsembleSet(regularEnsembleArray, deltaEnsembleArray);
+        expect(ensSet.hasAnyDeltaEnsembles()).toBe(true);
+        const firstString = deltaEnsembleArray[0].getIdent().toString();
+        const secondString = deltaEnsembleArray[1].getIdent().toString();
+        const invalidDeltaEnsembleIdentString = nonExistingDeltaEnsemble.getIdent().toString();
+        expect(ensSet.findEnsembleByIdentString(firstString)).toBeInstanceOf(DeltaEnsemble);
+        expect(ensSet.findEnsembleByIdentString(secondString)).toBeInstanceOf(DeltaEnsemble);
+        expect(ensSet.findEnsembleByIdentString(invalidDeltaEnsembleIdentString)).toBeNull();
+    });
+
     test("find by EnsembleIdentString containing invalid UUID", () => {
-        const ensSet = new EnsembleSet(ensembleArr);
+        const ensSet = new EnsembleSet(regularEnsembleArray, deltaEnsembleArray);
         expect(ensSet.findEnsembleByIdentString("")).toBeNull();
         expect(ensSet.findEnsembleByIdentString("")).toBeNull();
         expect(ensSet.findEnsembleByIdentString("QQQQQQQQ-aaaa-4444-aaaa-aaaaaaaaaaaa::ens99")).toBeNull();
diff --git a/frontend/tests/unit/RealizationFilter.test.ts b/frontend/tests/unit/RealizationFilter.test.ts
index 8722f5557..fc9719612 100644
--- a/frontend/tests/unit/RealizationFilter.test.ts
+++ b/frontend/tests/unit/RealizationFilter.test.ts
@@ -1,4 +1,3 @@
-import { Ensemble } from "@framework/Ensemble";
 import {
     ContinuousParameter,
     DiscreteParameter,
@@ -8,6 +7,7 @@ import {
     ParameterType,
 } from "@framework/EnsembleParameters";
 import { RealizationFilter } from "@framework/RealizationFilter";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
 import {
     IncludeExcludeFilter,
     NumberRange,
@@ -41,12 +41,12 @@ const SECOND_PARAMETER: Parameter = {
     values: [10, 10, 20, 25, 20, 30, 30, 30, 30, 40, 40],
 };
 
-const FIRST_ENSEMBLE = new Ensemble(
+const FIRST_ENSEMBLE = new RegularEnsemble(
     "DROGON",
-    "First ensemble UUID",
+    "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa",
     "First case",
     "First ensemble",
-    "DROGON_HAS_NO_STRAT_COLUMN",
+    "firstStratigraphicColumn",
     FIRST_ENSEMBLE_REALIZATIONS,
     [FIRST_PARAMETER, SECOND_PARAMETER],
     null,
diff --git a/frontend/tests/unit/RealizationFilterSet.test.ts b/frontend/tests/unit/RealizationFilterSet.test.ts
new file mode 100644
index 000000000..07df2d180
--- /dev/null
+++ b/frontend/tests/unit/RealizationFilterSet.test.ts
@@ -0,0 +1,99 @@
+import { DeltaEnsemble } from "@framework/DeltaEnsemble";
+import { EnsembleSet } from "@framework/EnsembleSet";
+import { RealizationFilterSet } from "@framework/RealizationFilterSet";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
+
+import { describe, expect, test } from "vitest";
+
+describe("RealizationFilterSet tests", () => {
+    const regularEnsembleArray = [
+        new RegularEnsemble("DROGON", "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "case1", "ens1", "sc1", [], [], null, ""),
+        new RegularEnsemble("DROGON", "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "case1", "ens2", "sc2", [], [], null, ""),
+        new RegularEnsemble("DROGON", "22222222-aaaa-4444-aaaa-aaaaaaaaaaaa", "case2", "ens1", "sc3", [], [], null, ""),
+    ];
+
+    const deltaEnsembleArray = [
+        new DeltaEnsemble(regularEnsembleArray[0], regularEnsembleArray[1], "", null),
+        new DeltaEnsemble(regularEnsembleArray[0], regularEnsembleArray[2], "", null),
+    ];
+
+    const nonExistingRegularEnsemble = new RegularEnsemble(
+        "DROGON",
+        "33333333-aaaa-4444-aaaa-aaaaaaaaaaaa",
+        "case3",
+        "ens3",
+        "sc4",
+        [],
+        [],
+        null,
+        ""
+    );
+    const nonExistingDeltaEnsemble = new DeltaEnsemble(regularEnsembleArray[1], regularEnsembleArray[2], "", null);
+
+    // Ensemble set and filter set for testing
+    const ENSEMBLE_SET = new EnsembleSet(regularEnsembleArray, deltaEnsembleArray);
+    const REALIZATION_FILTER_SET = new RealizationFilterSet();
+
+    test("should return filter for regular ensemble", () => {
+        // Sync realization filter set with ensemble set
+        REALIZATION_FILTER_SET.synchronizeWithEnsembleSet(ENSEMBLE_SET);
+
+        const wantedEnsembleIdent = regularEnsembleArray[0].getIdent();
+        const realizationFilter = REALIZATION_FILTER_SET.getRealizationFilterForEnsembleIdent(wantedEnsembleIdent);
+        expect(realizationFilter.getAssignedEnsembleIdent().equals(wantedEnsembleIdent)).toBe(true);
+    });
+
+    test("should return filter for delta ensemble", () => {
+        // Sync realization filter set with ensemble set
+        REALIZATION_FILTER_SET.synchronizeWithEnsembleSet(ENSEMBLE_SET);
+
+        const wantedEnsembleIdent = deltaEnsembleArray[0].getIdent();
+        const realizationFilter = REALIZATION_FILTER_SET.getRealizationFilterForEnsembleIdent(wantedEnsembleIdent);
+        expect(realizationFilter.getAssignedEnsembleIdent().equals(wantedEnsembleIdent)).toBe(true);
+    });
+
+    test("should throw error for non-existing regular ensemble", () => {
+        // Sync realization filter set with ensemble set
+        REALIZATION_FILTER_SET.synchronizeWithEnsembleSet(ENSEMBLE_SET);
+
+        const wantedEnsembleIdent = nonExistingRegularEnsemble.getIdent();
+        expect(() => REALIZATION_FILTER_SET.getRealizationFilterForEnsembleIdent(wantedEnsembleIdent)).toThrowError(
+            `We expect all ensembles to have a filter instance. No filter found for ${wantedEnsembleIdent.toString()}`
+        );
+    });
+
+    test("should throw error for non-existing delta ensemble", () => {
+        // Sync realization filter set with ensemble set
+        REALIZATION_FILTER_SET.synchronizeWithEnsembleSet(ENSEMBLE_SET);
+
+        const wantedEnsembleIdent = nonExistingDeltaEnsemble.getIdent();
+        expect(() => REALIZATION_FILTER_SET.getRealizationFilterForEnsembleIdent(wantedEnsembleIdent)).toThrowError(
+            `We expect all ensembles to have a filter instance. No filter found for ${wantedEnsembleIdent.toString()}`
+        );
+    });
+
+    test("Create new set including non-existing regular ensemble and without delta ensembles", () => {
+        // Sync realization filter set with ensemble set
+        REALIZATION_FILTER_SET.synchronizeWithEnsembleSet(ENSEMBLE_SET);
+
+        const wantedDeltaEnsembleIdent = deltaEnsembleArray[0].getIdent();
+        let realizationFilter = REALIZATION_FILTER_SET.getRealizationFilterForEnsembleIdent(wantedDeltaEnsembleIdent);
+        expect(realizationFilter.getAssignedEnsembleIdent().equals(wantedDeltaEnsembleIdent)).toBe(true);
+
+        // Add non-existing regular ensemble
+        const newRegularEnsembleArray = [...regularEnsembleArray, nonExistingRegularEnsemble];
+        const newEnsembleSet = new EnsembleSet(newRegularEnsembleArray);
+        REALIZATION_FILTER_SET.synchronizeWithEnsembleSet(newEnsembleSet);
+
+        const wantedEnsembleIdent = nonExistingRegularEnsemble.getIdent();
+        realizationFilter = REALIZATION_FILTER_SET.getRealizationFilterForEnsembleIdent(wantedEnsembleIdent);
+        expect(realizationFilter.getAssignedEnsembleIdent().equals(wantedEnsembleIdent)).toBe(true);
+
+        // Delta ensemble should no longer be in the filter set
+        expect(() =>
+            REALIZATION_FILTER_SET.getRealizationFilterForEnsembleIdent(wantedDeltaEnsembleIdent)
+        ).toThrowError(
+            `We expect all ensembles to have a filter instance. No filter found for ${wantedDeltaEnsembleIdent.toString()}`
+        );
+    });
+});
diff --git a/frontend/tests/unit/RegularEnsemble.test.ts b/frontend/tests/unit/RegularEnsemble.test.ts
new file mode 100644
index 000000000..e4a5fb7bd
--- /dev/null
+++ b/frontend/tests/unit/RegularEnsemble.test.ts
@@ -0,0 +1,121 @@
+import { EnsembleParameters, Parameter, ParameterType } from "@framework/EnsembleParameters";
+import { EnsembleSensitivities, Sensitivity, SensitivityType } from "@framework/EnsembleSensitivities";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
+
+import { describe, expect, test } from "vitest";
+
+describe("RegularEnsemble", () => {
+    const fieldIdentifier = "field1";
+    const caseUuid = "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa";
+    const caseName = "case1";
+    const ensembleName = "ensemble1";
+    const stratigraphicColumnIdentifier = "stratigraphicColumn1";
+    const realizationsArray = [5, 1, 2];
+    const parameterArray: Parameter[] = [
+        {
+            type: ParameterType.CONTINUOUS,
+            name: "param1",
+            groupName: null,
+            description: "desc_param1",
+            isConstant: false,
+            isLogarithmic: false,
+            realizations: [0, 1, 2],
+            values: [11, 12, 19],
+        },
+    ];
+    const sensitivityArray: Sensitivity[] = [{ name: "sens1", type: SensitivityType.MONTECARLO, cases: [] }];
+    const color = "red";
+    const customName = "customName1";
+
+    const TEST_ENSEMBLE = new RegularEnsemble(
+        fieldIdentifier,
+        caseUuid,
+        caseName,
+        ensembleName,
+        stratigraphicColumnIdentifier,
+        realizationsArray,
+        parameterArray,
+        sensitivityArray,
+        color,
+        customName
+    );
+
+    test("should create an instance of RegularEnsemble", () => {
+        expect(TEST_ENSEMBLE).toBeInstanceOf(RegularEnsemble);
+    });
+
+    test("should return the correct field identifier", () => {
+        expect(TEST_ENSEMBLE.getFieldIdentifier()).toBe(fieldIdentifier);
+    });
+
+    test("should return the correct stratigraphic column identifier", () => {
+        expect(TEST_ENSEMBLE.getStratigraphicColumnIdentifier()).toBe(stratigraphicColumnIdentifier);
+    });
+
+    test("should return the correct display name", () => {
+        expect(TEST_ENSEMBLE.getDisplayName()).toBe(customName);
+    });
+
+    test("should return the correct case UUID", () => {
+        expect(TEST_ENSEMBLE.getCaseUuid()).toBe(caseUuid);
+    });
+
+    test("should return the correct ensemble name", () => {
+        expect(TEST_ENSEMBLE.getEnsembleName()).toBe(ensembleName);
+    });
+
+    test("should return the correct case name", () => {
+        expect(TEST_ENSEMBLE.getCaseName()).toBe(caseName);
+    });
+
+    test("should return the sorted realizations array", () => {
+        expect(TEST_ENSEMBLE.getRealizations()).toEqual([1, 2, 5]);
+    });
+
+    test("should return the correct realization count", () => {
+        expect(TEST_ENSEMBLE.getRealizationCount()).toBe(3);
+    });
+
+    test("should return the correct max realization number", () => {
+        expect(TEST_ENSEMBLE.getMaxRealizationNumber()).toBe(5);
+    });
+
+    test("should return the correct parameters", () => {
+        const ensembleParameters = TEST_ENSEMBLE.getParameters();
+
+        expect(ensembleParameters).toBeInstanceOf(EnsembleParameters);
+        expect(ensembleParameters.getParameterArr()).toEqual(parameterArray);
+    });
+
+    test("should return the correct sensitivities", () => {
+        const ensembleSensitivities = TEST_ENSEMBLE.getSensitivities();
+
+        expect(ensembleSensitivities).toBeInstanceOf(EnsembleSensitivities);
+        expect(ensembleSensitivities).not.toBeNull();
+        expect(ensembleSensitivities?.getSensitivityArr()).toEqual(sensitivityArray);
+    });
+
+    test("should return the correct color", () => {
+        expect(TEST_ENSEMBLE.getColor()).toBe(color);
+    });
+
+    test("should return the correct custom name", () => {
+        expect(TEST_ENSEMBLE.getCustomName()).toBe(customName);
+    });
+
+    test("should return display name if custom name is not set", () => {
+        const ensemble = new RegularEnsemble(
+            fieldIdentifier,
+            caseUuid,
+            caseName,
+            ensembleName,
+            stratigraphicColumnIdentifier,
+            realizationsArray,
+            parameterArray,
+            sensitivityArray,
+            color
+        );
+        expect(ensemble.getDisplayName()).toBe(`${ensembleName} (${caseName})`);
+        expect(ensemble.getCustomName()).toBeNull();
+    });
+});
diff --git a/frontend/tests/unit/RegularEnsembleIdent.test.ts b/frontend/tests/unit/RegularEnsembleIdent.test.ts
new file mode 100644
index 000000000..adf354dd4
--- /dev/null
+++ b/frontend/tests/unit/RegularEnsembleIdent.test.ts
@@ -0,0 +1,80 @@
+import { describe, expect, test } from "vitest";
+
+import { RegularEnsembleIdent } from "../../src/framework/RegularEnsembleIdent";
+
+describe("RegularEnsembleIdent", () => {
+    test("should create an instance from caseUuid and ensembleName", () => {
+        const caseUuid = "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa";
+        const ensembleName = "testEnsemble";
+        const ensembleIdent = new RegularEnsembleIdent(caseUuid, ensembleName);
+        expect(ensembleIdent.getCaseUuid()).toBe(caseUuid);
+        expect(ensembleIdent.getEnsembleName()).toBe(ensembleName);
+    });
+
+    test("should create an instance from a string", () => {
+        const caseUuid = "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa";
+        const ensembleName = "testEnsemble";
+        const ensembleIdentString = `${caseUuid}::${ensembleName}`;
+        const ensembleIdent = RegularEnsembleIdent.fromString(ensembleIdentString);
+        expect(ensembleIdent.getCaseUuid()).toBe(caseUuid);
+        expect(ensembleIdent.getEnsembleName()).toBe(ensembleName);
+    });
+
+    test("should convert caseUuid and ensembleName to string", () => {
+        const caseUuid = "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa";
+        const ensembleName = "testEnsemble";
+        const ensembleIdentString = RegularEnsembleIdent.caseUuidAndEnsembleNameToString(caseUuid, ensembleName);
+        expect(ensembleIdentString).toBe(`${caseUuid}::${ensembleName}`);
+    });
+
+    test("should validate a correct ensemble ident string", () => {
+        const ensembleIdentString = "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa::testEnsemble";
+        const isValid = RegularEnsembleIdent.isValidEnsembleIdentString(ensembleIdentString);
+        expect(isValid).toBe(true);
+    });
+
+    test("should invalidate an incorrect ensemble ident string", () => {
+        const ensembleIdentString = "invalidString";
+        const isValid = RegularEnsembleIdent.isValidEnsembleIdentString(ensembleIdentString);
+        expect(isValid).toBe(false);
+    });
+
+    test("should throw an error for an invalid ensemble ident string", () => {
+        const ensembleIdentString = "invalidString";
+        expect(() => RegularEnsembleIdent.fromString(ensembleIdentString)).toThrowError(
+            `Invalid ensemble ident: ${ensembleIdentString}`
+        );
+    });
+
+    test("should return the correct string representation", () => {
+        const caseUuid = "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa";
+        const ensembleName = "testEnsemble";
+        const ensembleIdent = new RegularEnsembleIdent(caseUuid, ensembleName);
+        expect(ensembleIdent.toString()).toBe(`${caseUuid}::${ensembleName}`);
+    });
+
+    test("should correctly compare two equal EnsembleIdent instances", () => {
+        const caseUuid = "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa";
+        const ensembleName = "testEnsemble";
+        const ensembleIdent1 = new RegularEnsembleIdent(caseUuid, ensembleName);
+        const ensembleIdent2 = new RegularEnsembleIdent(caseUuid, ensembleName);
+        expect(ensembleIdent1.equals(ensembleIdent2)).toBe(true);
+    });
+
+    test("should correctly compare two different EnsembleIdent instances", () => {
+        const ensembleIdent1 = new RegularEnsembleIdent("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "testEnsemble1");
+        const ensembleIdent2 = new RegularEnsembleIdent("22222222-aaaa-4444-aaaa-aaaaaaaaaaaa", "testEnsemble2");
+        expect(ensembleIdent1.equals(ensembleIdent2)).toBe(false);
+    });
+
+    test("should return false when comparing with null", () => {
+        const ensembleIdent = new RegularEnsembleIdent("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "testEnsemble");
+        expect(ensembleIdent.equals(null)).toBe(false);
+    });
+
+    test("should return false when comparing with a different type", () => {
+        const ensembleIdent = new RegularEnsembleIdent("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "testEnsemble");
+        const differentType = { _caseUuid: "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", _ensembleName: "testEnsemble" };
+        expect(ensembleIdent.equals(differentType as any)).toBe(false);
+    });
+});
diff --git a/frontend/tests/unit/ensembleIdentUtils.test.ts b/frontend/tests/unit/ensembleIdentUtils.test.ts
new file mode 100644
index 000000000..1fb5ed9ad
--- /dev/null
+++ b/frontend/tests/unit/ensembleIdentUtils.test.ts
@@ -0,0 +1,199 @@
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
+import {
+    areEnsembleIdentListsEqual,
+    areEnsembleIdentsEqual,
+    ensembleIdentUuidRegexString,
+    filterEnsembleIdentsByType,
+    isEnsembleIdentOfType,
+} from "@framework/utils/ensembleIdentUtils";
+
+import { describe, expect, test } from "vitest";
+
+describe("isEnsembleIdentOfType", () => {
+    const REGULAR_ENSEMBLE_IDENT_1 = new RegularEnsembleIdent(
+        "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa",
+        "regular-ensemble-name"
+    );
+    const REGULAR_ENSEMBLE_IDENT_2 = new RegularEnsembleIdent(
+        "22222222-aaaa-4444-aaaa-aaaaaaaaaaaa",
+        "regular-ensemble-name-2"
+    );
+
+    const DELTA_ENSEMBLE_IDENT_1 = new DeltaEnsembleIdent(
+        new RegularEnsembleIdent("11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "compare-ensemble-name"),
+        new RegularEnsembleIdent("22222222-aaaa-4444-aaaa-aaaaaaaaaaaa", "reference-ensemble-name")
+    );
+
+    const DELTA_ENSEMBLE_IDENT_2 = new DeltaEnsembleIdent(
+        new RegularEnsembleIdent("33333333-aaaa-4444-aaaa-aaaaaaaaaaaa", "compare-ensemble-name"),
+        new RegularEnsembleIdent("44444444-aaaa-4444-aaaa-aaaaaaaaaaaa", "reference-ensemble-name")
+    );
+
+    test("should return true when both ensemble idents are null", () => {
+        const result = areEnsembleIdentsEqual(null, null);
+        expect(result).toBe(true);
+    });
+
+    test("should return false when one ensemble ident is null", () => {
+        const result1 = areEnsembleIdentsEqual(REGULAR_ENSEMBLE_IDENT_1, null);
+        const result2 = areEnsembleIdentsEqual(null, REGULAR_ENSEMBLE_IDENT_1);
+        expect(result1).toBe(false);
+        expect(result2).toBe(false);
+    });
+
+    test("should return true when both ensemble idents are equal", () => {
+        const result = areEnsembleIdentsEqual(REGULAR_ENSEMBLE_IDENT_1, REGULAR_ENSEMBLE_IDENT_1);
+        expect(result).toBe(true);
+    });
+
+    test("should return false when both ensemble idents are not equal", () => {
+        const result = areEnsembleIdentsEqual(REGULAR_ENSEMBLE_IDENT_1, REGULAR_ENSEMBLE_IDENT_2);
+        expect(result).toBe(false);
+    });
+
+    test("should return true when both delta ensemble idents are equal", () => {
+        const result = areEnsembleIdentsEqual(DELTA_ENSEMBLE_IDENT_1, DELTA_ENSEMBLE_IDENT_1);
+        expect(result).toBe(true);
+    });
+
+    test("should return false when both delta ensemble idents are not equal", () => {
+        const result = areEnsembleIdentsEqual(DELTA_ENSEMBLE_IDENT_1, DELTA_ENSEMBLE_IDENT_2);
+        expect(result).toBe(false);
+    });
+
+    test("should return true when both lists are empty", () => {
+        const result = areEnsembleIdentListsEqual([], []);
+        expect(result).toBe(true);
+    });
+
+    test("should return false when lists have different lengths", () => {
+        const result = areEnsembleIdentListsEqual([REGULAR_ENSEMBLE_IDENT_1], []);
+        expect(result).toBe(false);
+    });
+
+    test("should return true when both lists have the same RegularEnsembleIdent instances", () => {
+        const result = areEnsembleIdentListsEqual(
+            [REGULAR_ENSEMBLE_IDENT_1, REGULAR_ENSEMBLE_IDENT_2],
+            [REGULAR_ENSEMBLE_IDENT_1, REGULAR_ENSEMBLE_IDENT_2]
+        );
+        expect(result).toBe(true);
+    });
+
+    test("should return false when lists have different RegularEnsembleIdent instances", () => {
+        const result = areEnsembleIdentListsEqual(
+            [REGULAR_ENSEMBLE_IDENT_1, REGULAR_ENSEMBLE_IDENT_2],
+            [REGULAR_ENSEMBLE_IDENT_2, REGULAR_ENSEMBLE_IDENT_1]
+        );
+        expect(result).toBe(false);
+    });
+
+    test("should return true when both lists have the same DeltaEnsembleIdent instances", () => {
+        const result = areEnsembleIdentListsEqual(
+            [DELTA_ENSEMBLE_IDENT_1, DELTA_ENSEMBLE_IDENT_2],
+            [DELTA_ENSEMBLE_IDENT_1, DELTA_ENSEMBLE_IDENT_2]
+        );
+        expect(result).toBe(true);
+    });
+
+    test("should return false when lists have different DeltaEnsembleIdent instances", () => {
+        const result = areEnsembleIdentListsEqual(
+            [DELTA_ENSEMBLE_IDENT_1, DELTA_ENSEMBLE_IDENT_2],
+            [DELTA_ENSEMBLE_IDENT_2, DELTA_ENSEMBLE_IDENT_1]
+        );
+        expect(result).toBe(false);
+    });
+
+    test("should return false when lists have different types of EnsembleIdent instances", () => {
+        const result = areEnsembleIdentListsEqual(
+            [REGULAR_ENSEMBLE_IDENT_1, DELTA_ENSEMBLE_IDENT_1],
+            [REGULAR_ENSEMBLE_IDENT_1, REGULAR_ENSEMBLE_IDENT_2]
+        );
+        expect(result).toBe(false);
+    });
+
+    test("should return true for RegularEnsembleIdent type", () => {
+        const result = isEnsembleIdentOfType(REGULAR_ENSEMBLE_IDENT_1, RegularEnsembleIdent);
+        expect(result).toBe(true);
+    });
+
+    test("should return false for RegularEnsembleIdent type when DeltaEnsembleIdent is passed", () => {
+        const result = isEnsembleIdentOfType(DELTA_ENSEMBLE_IDENT_1, RegularEnsembleIdent);
+        expect(result).toBe(false);
+    });
+
+    test("should return true for DeltaEnsembleIdent type", () => {
+        const result = isEnsembleIdentOfType(DELTA_ENSEMBLE_IDENT_1, DeltaEnsembleIdent);
+        expect(result).toBe(true);
+    });
+
+    test("should return false for DeltaEnsembleIdent type when RegularEnsembleIdent is passed", () => {
+        const result = isEnsembleIdentOfType(REGULAR_ENSEMBLE_IDENT_1, DeltaEnsembleIdent);
+        expect(result).toBe(false);
+    });
+
+    test("should return only RegularEnsembleIdent instances", () => {
+        const ensembleIdents = [
+            REGULAR_ENSEMBLE_IDENT_1,
+            DELTA_ENSEMBLE_IDENT_1,
+            REGULAR_ENSEMBLE_IDENT_2,
+            DELTA_ENSEMBLE_IDENT_2,
+        ];
+        const result = filterEnsembleIdentsByType(ensembleIdents, RegularEnsembleIdent);
+        expect(result).toEqual([REGULAR_ENSEMBLE_IDENT_1, REGULAR_ENSEMBLE_IDENT_2]);
+    });
+
+    test("should return only DeltaEnsembleIdent instances", () => {
+        const ensembleIdents = [
+            REGULAR_ENSEMBLE_IDENT_1,
+            REGULAR_ENSEMBLE_IDENT_2,
+            DELTA_ENSEMBLE_IDENT_2,
+            DELTA_ENSEMBLE_IDENT_1,
+        ];
+        const result = filterEnsembleIdentsByType(ensembleIdents, DeltaEnsembleIdent);
+        expect(result).toEqual([DELTA_ENSEMBLE_IDENT_2, DELTA_ENSEMBLE_IDENT_1]);
+    });
+
+    test("should return an empty array when no instances match the type", () => {
+        const ensembleIdents = [REGULAR_ENSEMBLE_IDENT_1, REGULAR_ENSEMBLE_IDENT_2];
+        const result = filterEnsembleIdentsByType(ensembleIdents, DeltaEnsembleIdent);
+        expect(result).toEqual([]);
+    });
+
+    test("should return an empty array when the input array is empty", () => {
+        const ensembleIdents: (RegularEnsembleIdent | DeltaEnsembleIdent)[] = [];
+        const result = filterEnsembleIdentsByType(ensembleIdents, RegularEnsembleIdent);
+        expect(result).toEqual([]);
+    });
+
+    test("should return a valid UUID regex pattern", () => {
+        const regexString = ensembleIdentUuidRegexString();
+        const regex = new RegExp(`^${regexString}$`);
+
+        const validUuids = [
+            "123e4567-e89b-12d3-a456-426614174000",
+            "987f6543-e21b-45d3-b456-426614174001",
+            "11111111-2222-3333-4444-555555555555",
+        ];
+
+        validUuids.forEach((uuid) => {
+            expect(regex.test(uuid)).toBe(true);
+        });
+    });
+
+    test("should not match invalid UUIDs", () => {
+        const regexString = ensembleIdentUuidRegexString();
+        const regex = new RegExp(`^${regexString}$`);
+
+        const invalidUuids = [
+            "123e4567-e89b-12d3-a456-42661417400", // too short
+            "123e4567-e89b-12d3-a456-4266141740000", // too long
+            "123e4567-e89b-12d3-a456-42661417400z", // invalid character
+            "g23e4567-e89b-12d3-a456-426614174000", // invalid character
+        ];
+
+        invalidUuids.forEach((uuid) => {
+            expect(regex.test(uuid)).toBe(false);
+        });
+    });
+});
diff --git a/frontend/tests/unit/ensembleUiHelpers.test.ts b/frontend/tests/unit/ensembleUiHelpers.test.ts
new file mode 100644
index 000000000..b5d859124
--- /dev/null
+++ b/frontend/tests/unit/ensembleUiHelpers.test.ts
@@ -0,0 +1,252 @@
+import { DeltaEnsemble } from "@framework/DeltaEnsemble";
+import { DeltaEnsembleIdent } from "@framework/DeltaEnsembleIdent";
+import { EnsembleSet } from "@framework/EnsembleSet";
+import { RegularEnsemble } from "@framework/RegularEnsemble";
+import { RegularEnsembleIdent } from "@framework/RegularEnsembleIdent";
+import {
+    fixupEnsembleIdent,
+    fixupEnsembleIdents,
+    fixupRegularEnsembleIdent,
+    fixupRegularEnsembleIdents,
+} from "@framework/utils/ensembleUiHelpers";
+
+import { describe, expect, test } from "vitest";
+
+const ensembleArray = [
+    new RegularEnsemble("DROGON", "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "case1", "ens1", "sc1", [], [], null, ""),
+    new RegularEnsemble("DROGON", "11111111-aaaa-4444-aaaa-aaaaaaaaaaaa", "case1", "ens2", "sc2", [], [], null, ""),
+    new RegularEnsemble("DROGON", "22222222-aaaa-4444-aaaa-aaaaaaaaaaaa", "case2", "ens1", "sc3", [], [], null, ""),
+];
+
+const deltaEnsembleArray = [
+    new DeltaEnsemble(ensembleArray[0], ensembleArray[1], "", null),
+    new DeltaEnsemble(ensembleArray[0], ensembleArray[2], "", null),
+];
+
+const ENSEMBLE_SET = new EnsembleSet(ensembleArray, deltaEnsembleArray);
+
+describe("fixupEnsembleIdent", () => {
+    test("should return null if ensembleSet is null or has no ensembles", () => {
+        const currIdent = ensembleArray[0].getIdent();
+        const emptyEnsembleSet = new EnsembleSet([]);
+
+        expect(fixupEnsembleIdent(currIdent, null)).toBeNull();
+        expect(fixupEnsembleIdent(currIdent, emptyEnsembleSet)).toBeNull();
+    });
+
+    test("should return currIdent if it is valid in the ensembleSet", () => {
+        const regularEnsembleIdent = ensembleArray[1].getIdent();
+        const deltaEnsembleIdent = deltaEnsembleArray[0].getIdent();
+
+        expect(fixupEnsembleIdent(regularEnsembleIdent, ENSEMBLE_SET)).toBe(regularEnsembleIdent);
+        expect(fixupEnsembleIdent(deltaEnsembleIdent, ENSEMBLE_SET)).toBe(deltaEnsembleIdent);
+    });
+
+    test("should return first regular ensemble ident if currIdent is invalid regular ensemble ident", () => {
+        const nonExistingRegularEnsembleIdent = new RegularEnsembleIdent(
+            "55555555-aaaa-4444-aaaa-aaaaaaaaaaaa",
+            "ens4"
+        );
+        // Fixup non-existing regular ensemble ident
+        expect(fixupEnsembleIdent(nonExistingRegularEnsembleIdent, ENSEMBLE_SET)).toBe(ensembleArray[0].getIdent());
+    });
+
+    test("should return first regular ensemble ident if currIdent is invalid delta ensemble ident", () => {
+        const nonExistingDeltaEnsembleIdent = new DeltaEnsembleIdent(
+            ensembleArray[2].getIdent(),
+            ensembleArray[1].getIdent()
+        );
+
+        // Fixup non-existing delta ensemble ident
+        expect(fixupEnsembleIdent(nonExistingDeltaEnsembleIdent, ENSEMBLE_SET)).toBe(ensembleArray[0].getIdent());
+    });
+
+    test("should return the first regular ensemble ident if currIdent is null and regular ensembles are available", () => {
+        const regularEnsembleIdent = ensembleArray[0].getIdent();
+
+        expect(fixupEnsembleIdent(null, ENSEMBLE_SET)).toBe(regularEnsembleIdent);
+    });
+
+    test("should return the first delta ensemble ident if currIdent is a non-existing DeltaEnsembleIdent or no regular ensembles are available", () => {
+        const ensembleSetWithoutRegularEnsembles = new EnsembleSet([], deltaEnsembleArray);
+
+        const nonExistingDeltaEnsembleIdent = new DeltaEnsembleIdent(
+            ensembleArray[2].getIdent(),
+            ensembleArray[1].getIdent()
+        );
+
+        // Fetch existing delta ensemble ident
+        expect(fixupEnsembleIdent(deltaEnsembleArray[1].getIdent(), ensembleSetWithoutRegularEnsembles)).toBe(
+            deltaEnsembleArray[1].getIdent()
+        );
+
+        // Fixup non-existing delta ensemble ident (pick first delta ensemble)
+        expect(fixupEnsembleIdent(nonExistingDeltaEnsembleIdent, ensembleSetWithoutRegularEnsembles)).toBe(
+            deltaEnsembleArray[0].getIdent()
+        );
+
+        // Fixup regular ensemble ident (pick first delta ensemble)
+        expect(fixupEnsembleIdent(ensembleArray[0].getIdent(), ensembleSetWithoutRegularEnsembles)).toBe(
+            deltaEnsembleArray[0].getIdent()
+        );
+    });
+
+    test("should return the first regular ensemble ident if currIdent is null or a DeltaEnsembleIdent and no delta ensembles are available", () => {
+        const ensembleSetWithoutDeltaEnsembles = new EnsembleSet(ensembleArray);
+
+        // Fetch existing regular ensemble ident
+        expect(fixupEnsembleIdent(ensembleArray[1].getIdent(), ensembleSetWithoutDeltaEnsembles)).toBe(
+            ensembleArray[1].getIdent()
+        );
+
+        // Fixup null
+        expect(fixupEnsembleIdent(null, ensembleSetWithoutDeltaEnsembles)).toBe(ensembleArray[0].getIdent());
+
+        // Fixup DeltaEnsembleIdent
+        expect(fixupEnsembleIdent(deltaEnsembleArray[0].getIdent(), ensembleSetWithoutDeltaEnsembles)).toBe(
+            ensembleArray[0].getIdent()
+        );
+    });
+});
+
+describe("fixupRegularEnsembleIdent", () => {
+    test("should return null if ensembleSet is null or has no ensembles", () => {
+        const currIdent = ensembleArray[0].getIdent();
+        const emptyEnsembleSet = new EnsembleSet([]);
+
+        expect(fixupRegularEnsembleIdent(currIdent, null)).toBeNull();
+        expect(fixupRegularEnsembleIdent(currIdent, emptyEnsembleSet)).toBeNull();
+    });
+
+    test("should return currIdent if it is valid in the ensembleSet", () => {
+        const regularEnsembleIdent = ensembleArray[1].getIdent();
+
+        expect(fixupRegularEnsembleIdent(regularEnsembleIdent, ENSEMBLE_SET)).toBe(regularEnsembleIdent);
+    });
+
+    test("should return currIdent if it exist", () => {
+        const regularEnsembleIdent = ensembleArray[1].getIdent();
+
+        expect(fixupRegularEnsembleIdent(regularEnsembleIdent, ENSEMBLE_SET)).toBe(regularEnsembleIdent);
+    });
+
+    test("should return null if currIdent is a RegularEnsembleIdent and no regular ensembles are available", () => {
+        const ensembleSetWithoutRegularEnsembles = new EnsembleSet([], deltaEnsembleArray);
+
+        // Non-existing delta ensemble ident
+        expect(fixupRegularEnsembleIdent(ensembleArray[0].getIdent(), ensembleSetWithoutRegularEnsembles)).toBeNull();
+    });
+
+    test("should return the first regular ensemble ident if currIdent is null and regular ensembles are available", () => {
+        const regularEnsembleIdent = ensembleArray[0].getIdent();
+
+        expect(fixupRegularEnsembleIdent(null, ENSEMBLE_SET)).toBe(regularEnsembleIdent);
+    });
+});
+
+describe("fixupEnsembleIdents", () => {
+    test("should return null if ensembleSet is null or has no ensembles", () => {
+        const currIdents = [ensembleArray[0].getIdent()];
+        const emptyEnsembleSet = new EnsembleSet([]);
+
+        expect(fixupEnsembleIdents(currIdents, null)).toBeNull();
+        expect(fixupEnsembleIdents(currIdents, emptyEnsembleSet)).toBeNull();
+    });
+
+    test("should return currIdents if they are valid in the ensembleSet", () => {
+        const regularEnsembleIdents = [ensembleArray[2].getIdent(), ensembleArray[1].getIdent()];
+        const deltaEnsembleIdents = [deltaEnsembleArray[0].getIdent()];
+
+        expect(fixupEnsembleIdents(regularEnsembleIdents, ENSEMBLE_SET)).toEqual(regularEnsembleIdents);
+        expect(fixupEnsembleIdents(deltaEnsembleIdents, ENSEMBLE_SET)).toEqual(deltaEnsembleIdents);
+    });
+
+    test("should return the first regular ensemble ident if currIdents is null or empty and regular ensembles are available", () => {
+        const regularEnsembleIdent = ensembleArray[0].getIdent();
+
+        expect(fixupEnsembleIdents(null, ENSEMBLE_SET)).toEqual([regularEnsembleIdent]);
+        expect(fixupEnsembleIdents([], ENSEMBLE_SET)).toEqual([regularEnsembleIdent]);
+    });
+
+    test("should return the first delta ensemble ident if currIdents is null or empty and no regular ensembles are available", () => {
+        const ensembleSetWithoutRegularEnsembles = new EnsembleSet([], deltaEnsembleArray);
+        const deltaEnsembleIdent = deltaEnsembleArray[0].getIdent();
+
+        expect(fixupEnsembleIdents(null, ensembleSetWithoutRegularEnsembles)).toEqual([deltaEnsembleIdent]);
+        expect(fixupEnsembleIdents([], ensembleSetWithoutRegularEnsembles)).toEqual([deltaEnsembleIdent]);
+    });
+
+    test("should filter out non-existing idents from currIdents", () => {
+        const validRegularEnsembleIdent = ensembleArray[0].getIdent();
+        const validDeltaEnsembleIdent = deltaEnsembleArray[0].getIdent();
+
+        const nonExistingRegularEnsembleIdent = new RegularEnsembleIdent(
+            "55555555-aaaa-4444-aaaa-aaaaaaaaaaaa",
+            "ens4"
+        );
+        const nonExistingDeltaEnsembleIdent = new DeltaEnsembleIdent(
+            ensembleArray[2].getIdent(),
+            ensembleArray[1].getIdent()
+        );
+
+        expect(fixupEnsembleIdents([validRegularEnsembleIdent, nonExistingRegularEnsembleIdent], ENSEMBLE_SET)).toEqual(
+            [validRegularEnsembleIdent]
+        );
+
+        expect(fixupEnsembleIdents([validDeltaEnsembleIdent, nonExistingDeltaEnsembleIdent], ENSEMBLE_SET)).toEqual([
+            validDeltaEnsembleIdent,
+        ]);
+
+        expect(
+            fixupEnsembleIdents(
+                [validDeltaEnsembleIdent, nonExistingDeltaEnsembleIdent, validRegularEnsembleIdent],
+                ENSEMBLE_SET
+            )
+        ).toEqual([validDeltaEnsembleIdent, validRegularEnsembleIdent]);
+    });
+});
+
+describe("fixupRegularEnsembleIdents", () => {
+    test("should return null if ensembleSet is null or has no ensembles", () => {
+        const currIdents = [ensembleArray[0].getIdent()];
+        const emptyEnsembleSet = new EnsembleSet([]);
+
+        expect(fixupRegularEnsembleIdents(currIdents, null)).toBeNull();
+        expect(fixupRegularEnsembleIdents(currIdents, emptyEnsembleSet)).toBeNull();
+    });
+
+    test("should return currIdents if they are valid in the ensembleSet", () => {
+        const regularEnsembleIdents = [ensembleArray[2].getIdent(), ensembleArray[1].getIdent()];
+
+        expect(fixupRegularEnsembleIdents(regularEnsembleIdents, ENSEMBLE_SET)).toEqual(regularEnsembleIdents);
+    });
+
+    test("should return the first regular ensemble ident if currIdents is null or empty and regular ensembles are available", () => {
+        const regularEnsembleIdent = ensembleArray[0].getIdent();
+
+        expect(fixupRegularEnsembleIdents(null, ENSEMBLE_SET)).toEqual([regularEnsembleIdent]);
+        expect(fixupRegularEnsembleIdents([], ENSEMBLE_SET)).toEqual([regularEnsembleIdent]);
+    });
+
+    test("should return null if currIdents is null or empty and no regular ensembles are available", () => {
+        const regularEnsembleIdents = [ensembleArray[2].getIdent(), ensembleArray[1].getIdent()];
+        const ensembleSetWithoutRegularEnsembles = new EnsembleSet([], deltaEnsembleArray);
+
+        expect(fixupRegularEnsembleIdents(regularEnsembleIdents, ensembleSetWithoutRegularEnsembles)).toBeNull();
+        expect(fixupRegularEnsembleIdents(null, ensembleSetWithoutRegularEnsembles)).toBeNull();
+        expect(fixupRegularEnsembleIdents([], ensembleSetWithoutRegularEnsembles)).toBeNull();
+    });
+
+    test("should filter out non-existing idents from currIdents", () => {
+        const validRegularEnsembleIdent = ensembleArray[0].getIdent();
+        const nonExistingRegularEnsembleIdent = new RegularEnsembleIdent(
+            "55555555-aaaa-4444-aaaa-aaaaaaaaaaaa",
+            "ens4"
+        );
+
+        expect(fixupRegularEnsembleIdents([nonExistingRegularEnsembleIdent], ENSEMBLE_SET)).toEqual([]);
+        expect(
+            fixupRegularEnsembleIdents([validRegularEnsembleIdent, nonExistingRegularEnsembleIdent], ENSEMBLE_SET)
+        ).toEqual([validRegularEnsembleIdent]);
+    });
+});