diff --git a/SofaRegressionProgram/SofaRegressionProgram.py b/SofaRegressionProgram/SofaRegressionProgram.py
index 58d960d..a9b470d 100644
--- a/SofaRegressionProgram/SofaRegressionProgram.py
+++ b/SofaRegressionProgram/SofaRegressionProgram.py
@@ -16,12 +16,12 @@
 import SofaRuntime # importing SofaRuntime will add the py3 loader to the scene loaders
 import tools.RegressionSceneList as RegressionSceneList
 import tools.RegressionWorker as RegressionWorker
-from tools.RegressionHelper import writeMessage
+from tools.RegressionHelper import writeMessage, writeWarning
 
 regression_file_extension = ".regression-tests"
 
 class RegressionProgram:
-    def __init__(self, input_folders, filter = None, disable_progress_bar = False, verbose = 1, nbr_jobs = 1, logs_output = None):
+    def __init__(self, input_folders, filter = None, reg_type = 'ALL',  disable_progress_bar = False, verbose = 1, nbr_jobs = 1, logs_output = None):
         """Initialize the RegressionProgram
 
         Args:
@@ -37,6 +37,7 @@ def __init__(self, input_folders, filter = None, disable_progress_bar = False, v
         self.legacy_mode = False
         self.nbr_jobs = RegressionWorker.resolve_nbr_jobs(nbr_jobs)
         self.logs_output = logs_output
+        self.reg_type = reg_type
 
         err_logs_stream = None
         if self.logs_output is not None :
@@ -46,9 +47,10 @@ def __init__(self, input_folders, filter = None, disable_progress_bar = False, v
             for directory in input_folders :
                 for root, dirs, files in os.walk(directory):
                     for file in files:
-                        if file.endswith(regression_file_extension):
-                            file_path = os.path.join(root, file)
+                        file_path = os.path.join(root, file)
 
+                        #Warning lazy or in the end, if not lazy then this breaks
+                        if file.endswith(regression_file_extension) and (reg_type == 'ALL' or RegressionSceneList.RegressionSceneList.RegressionType[reg_type].value[0] in file) :
                             scene_list = RegressionSceneList.RegressionSceneList(file_path, filter, self.disable_progress_bar, verbose, self.nbr_jobs)
 
                             if err_logs_stream is not None:
@@ -60,6 +62,9 @@ def __init__(self, input_folders, filter = None, disable_progress_bar = False, v
                                 print("", file=err_logs_stream)
 
                             self.scene_sets.append(scene_list)
+                        elif file.endswith(regression_file_extension):
+                            writeWarning(f"Regression file {file_path} skipped because of selected regression type {reg_type}", self.verbose)
+
         finally:
             if self.logs_output is not None :
                 with open(Path(self.logs_output) / "parse_errors_logs.txt", 'w', encoding="utf-8") as summary_file:
@@ -120,8 +125,11 @@ def compare_all_sets_references(self):
         return self.run_all_sets("compare", "Compare All sets")
 
     def replay_references(self, id_scene, id_set=0):
-        scene_list = self.scene_sets[id_set]
-        scene_list.replay_references(id_scene)
+        if(self.scene_sets[id_set].regression_type is not None and self.scene_sets[id_set].regression_type.value[1].is_replay_available()):
+            scene_list = self.scene_sets[id_set]
+            scene_list.replay_references(id_scene)
+        else:
+            raise ValueError(f"Replay is not available for regression type {self.scene_sets[id_set].regression_type}")
 
 
 
@@ -140,6 +148,15 @@ def make_parser():
                         default=[],
                         type=str)
 
+    regression_type_choices = ['ALL', *(reg_type.name for reg_type in RegressionSceneList.RegressionSceneList.RegressionType)]
+    parser.add_argument('--regression-type',
+                        dest='reg_type',
+                        choices=regression_type_choices,
+                        help=f"The regression type from {regression_type_choices}. Default value is ALL.",
+                        type=str,
+                        default='ALL')
+
+
     parser.add_argument('--filter',
                         dest='filter',
                         help="A regex filter to select scenes to test (e.g., '^demo.*.scn$')",
@@ -222,7 +239,7 @@ def make_parser():
 
     # 2- Process file
     if args.input:
-        reg_prog = RegressionProgram(args.input, args.filter, args.progress_bar_is_disabled, verbose, args.jobs, logs_output = args.output)
+        reg_prog = RegressionProgram(args.input, args.filter, args.reg_type, args.progress_bar_is_disabled, verbose, args.jobs, logs_output = args.output)
     else:
         parser.print_help()
         exit("Error: Argument is required ! Quitting.")
diff --git a/SofaRegressionProgram/tools/ReferenceFileIO.py b/SofaRegressionProgram/tools/ReferenceFileIO.py
index cd014e8..b5448f1 100644
--- a/SofaRegressionProgram/tools/ReferenceFileIO.py
+++ b/SofaRegressionProgram/tools/ReferenceFileIO.py
@@ -82,7 +82,7 @@ def read_JSON_reference_file(file_path):
         keyframes = []
         for key in decoded_array:
             keyframes.append(float(key))
-    
+
         return decoded_array, keyframes
 
 # --------------------------------------------------
@@ -109,7 +109,7 @@ def read_legacy_reference(filename, mechanical_object):
             if line.startswith("T="):
                 current_time = float(line.split("=", 1)[1])
                 times.append(current_time)
-         
+
             # Positions
             elif line.startswith("X="):
                 if current_time is None:
@@ -137,3 +137,74 @@ def read_legacy_reference(filename, mechanical_object):
         )
 
     return times, values
+
+# --------------------------------------------------
+# Helper: read the legacy topology reference format
+# --------------------------------------------------
+# Written by the former C++ WriteTopology component, one block per timestep:
+#   T= <time>
+#     Edges= <nbr>
+#   <raw edges list, 2 ints each, space separated, on one line (blank if nbr==0)>
+#     Triangles= <nbr>
+#   <raw triangles list, 3 ints each, space separated, on one line (blank if nbr==0)>
+#     Quads= <nbr>
+#   <raw quads list, 4 ints each, space separated, on one line (blank if nbr==0)>
+#     Tetrahedra= <nbr>
+#   <raw tetrahedra list, 4 ints each, space separated, on one line (blank if nbr==0)>
+#     Hexahedra= <nbr>
+#   <raw hexahedra list, 8 ints each, space separated, on one line (blank if nbr==0)>
+_legacy_topology_categories = (
+    ("Edges=", "edges", 2),
+    ("Triangles=", "triangles", 3),
+    ("Quads=", "quads", 4),
+    ("Tetrahedra=", "tetrahedra", 4),
+    ("Hexahedra=", "hexahedra", 8),
+)
+
+
+def read_legacy_topology_reference(filename):
+    times = []
+    values = []
+    current_entry = None
+
+    with gzip.open(filename, "rt") as f:
+        for line in f:
+            stripped = line.strip()
+            if not stripped:
+                continue
+
+            if stripped.startswith("T="):
+                if current_entry is not None:
+                    values.append(current_entry)
+                times.append(float(stripped.split("=", 1)[1]))
+                current_entry = {key: [] for _, key, _ in _legacy_topology_categories}
+                continue
+
+            for label, key, arity in _legacy_topology_categories:
+                if not stripped.startswith(label):
+                    continue
+
+                nbr = int(stripped.split("=", 1)[1].strip())
+                if nbr > 0:
+                    raw = next(f).split()
+                    if len(raw) != nbr * arity:
+                        raise ValueError(
+                            f"Legacy topology reference corrupted in {filename}: "
+                            f"expected {nbr * arity} values for '{key}', got {len(raw)}"
+                        )
+                    current_entry[key] = [
+                        tuple(int(v) for v in raw[i * arity:(i + 1) * arity])
+                        for i in range(nbr)
+                    ]
+                break
+
+    if current_entry is not None:
+        values.append(current_entry)
+
+    if len(times) != len(values):
+        raise RuntimeError(
+            f"Legacy topology reference corrupted in {filename}: "
+            f"{len(times)} times vs {len(values)} entries"
+        )
+
+    return times, values
diff --git a/SofaRegressionProgram/tools/RegressionSceneData.py b/SofaRegressionProgram/tools/RegressionSceneData.py
index 4095a6e..e9679fa 100644
--- a/SofaRegressionProgram/tools/RegressionSceneData.py
+++ b/SofaRegressionProgram/tools/RegressionSceneData.py
@@ -1,3 +1,4 @@
+import dataclasses
 import time
 import numpy as np
 import pathlib
@@ -80,12 +81,10 @@ def __init__(self, file_scene_path: str = None, file_ref_path: str = None, steps
         self.epsilon = float(epsilon)
         self.meca_in_mapping = bool(meca_in_mapping)
         self.dump_number_step = int(dump_number_step)
-        self.meca_objs = []
         self.filenames = []
         self.mins = []
         self.maxs = []
         self.total_error = []
-        self.error_by_dof = []
         self.nbr_tested_frame = 0
         self.regression_failed = False
         self.root_node = None
@@ -97,6 +96,37 @@ def print_info(self):
         helper.writeLog("Test scene: " + self.file_scene_path + " vs " + self.file_ref_path + " using: " + str(self.steps)
               + " " + str(self.epsilon), self.verbose)
 
+    def log_errors(self, log_prefix='', err_log_stream=None):
+        pass
+
+    def apply_worker_result(self, result):
+        pass
+
+    def parse_node(self, node, level = 0):
+        pass
+
+    def load_scene(self, format = "JSON"):
+        pass
+
+    def write_references(self, format = "JSON"):
+        pass
+
+    def compare_references(self, format = "JSON"):
+        pass
+
+    def compare_legacy_references(self):
+        pass
+
+
+class StateRegressionSceneData(RegressionSceneData):
+    def __init__(self, file_scene_path: str = None, file_ref_path: str = None, steps = 1000,
+                 epsilon = 0.0001, meca_in_mapping = True, dump_number_step = 1, disable_progress_bar = False, verbose = 1):
+
+        RegressionSceneData.__init__(self, file_scene_path, file_ref_path, steps, epsilon, meca_in_mapping, dump_number_step, disable_progress_bar, verbose)
+
+        self.meca_objs = []
+        self.error_by_dof = []
+
     def log_errors(self, log_prefix='', err_log_stream=None):
         if self.regression_failed:
             helper.writeError(
@@ -541,6 +571,9 @@ def compare_legacy_references(self):
 
         return True
 
+    @staticmethod
+    def is_replay_available():
+        return True
 
     def replay_references(self):
 
@@ -552,3 +585,356 @@ def replay_references(self):
         Sofa.Gui.GUIManager.SetDimension(1920, 1080)
         Sofa.Gui.GUIManager.MainLoop(self.root_node)
         Sofa.Gui.GUIManager.closeGUI()
+
+class TopologyRegressionSceneData(RegressionSceneData):
+
+    # Categories checked by the legacy CompareTopology visitor, in the order
+    # they were written to the reference files.
+    topology_categories = (("edge", "edges"), ("edge", "triangles"), ("quad", "quads"),
+                           ("tetrahedron", "tetrahedra"), ("hexahedron", "hexahedra"),
+                           ("prism", "prisms"), ("pyramid", "pyramids"))
+    #When the support is complete
+    # "quadratic_edges", "quadratic_triangles", "quadratic_quads", "quadratic_tetrahedra", "quadratic_hexahedra", "quadratic_prisms", "quadratic_pyramids"
+
+
+    def __init__(self, file_scene_path: str = None, file_ref_path: str = None, steps = 1000,
+                 epsilon = 0.0001, meca_in_mapping = True, dump_number_step = 1, disable_progress_bar = False, verbose = 1):
+
+        RegressionSceneData.__init__(self, file_scene_path, file_ref_path, steps, epsilon, meca_in_mapping, dump_number_step, disable_progress_bar, verbose)
+
+        self.error_topology = {elemType[1] : [] for elemType in TopologyRegressionSceneData.topology_categories}
+        self.topology = []
+
+    @staticmethod
+    def is_replay_available():
+        return False
+
+    def log_errors(self, log_prefix='', err_log_stream=None):
+        if self.regression_failed:
+            body = ""
+            for topo_type in TopologyRegressionSceneData.topology_categories:
+                if len(self.error_topology[topo_type[1]]) > 0 :
+                    body += f"\n        {topo_type[1].replace('_',' ').capitalize()}: {self.error_topology[topo_type[1]]}"
+            helper.writeError(
+                                f"{self.file_scene_path} | Number of key frames compared: {self.nbr_tested_frame} | run time: {self.total_run_time/1e9} seconds. "
+                                f"\n    ### Errors by topology container:"
+                                f"{body}"
+                                f"\n    ### Total Error: {self.total_error} > Threshold: {self.epsilon}",
+                                self.verbose,
+                                log_prefix,
+                                err_log_stream = err_log_stream
+                            )
+        elif self.nbr_tested_frame == 0:
+            helper.writeError(f"No frames were tested for {self.file_scene_path}",
+                              self.verbose,
+                              log_prefix,
+                              err_log_stream = err_log_stream)
+        else:
+            helper.writeSuccess(f"{self.file_scene_path} | Number of key frames compared: {self.nbr_tested_frame} | run time: {self.total_run_time/1e9} seconds. ",
+                                self.verbose,
+                                log_prefix)
+
+    def apply_worker_result(self, result):
+        """Copy the fields reported by an isolated worker process back onto this
+        object so that log_errors() and error counting behave as if the scene had
+        been compared in-process."""
+        self.regression_failed = bool(result.get("regression_failed", False))
+        self.nbr_tested_frame = int(result.get("nbr_tested_frame", 0))
+        self.total_run_time = result.get("total_run_time", 0)
+        self.error_topology = result.get("error_topology", {})
+
+
+
+    def parse_node(self, node, level = 0):
+        # Mirrors CompareTopologyCreator::processNodeTopDown: only a topology
+        # container attached directly to this node is considered (not one
+        # inherited from a parent), so the same physical container is never
+        # tested twice through two different nodes.
+        topo = node.getMeshTopology(Sofa.Core.BaseContext.SearchDirection.Local)
+        if topo is not None and (self.meca_in_mapping is True or is_mapped(node) is False):
+                self.topology.append(topo)
+                helper.writeLog("  " * level + f"- Adding Topology: {topo.name.value} from Node: {node.name.value}", self.verbose)
+
+        # recursively check children
+        for child in node.children:
+            self.parse_node(child, level + 1)
+
+
+    @staticmethod
+    def _get_topology_structure(topo):
+        """Snapshot of a BaseMeshTopology's element containers, read directly
+        through the python bindings (no WriteTopology/ReadTopology component
+        added to the scene)."""
+        return {topo_type[1] : [tuple(topo.__getattribute__(f"get{topo_type[0].capitalize()}")(i)) for i in range(topo.__getattribute__(f"getNb{topo_type[1].capitalize()}")())] for topo_type in TopologyRegressionSceneData.topology_categories}
+
+    @staticmethod
+    def _compare_topology_structure(ref_state, current_state):
+        """Reproduce CompareTopology::processCompareTopology: for each
+        category, a count mismatch adds the absolute difference in count as
+        the error; otherwise every element is compared and each mismatching
+        one adds 1. A reference count of 0 means the category was never
+        recorded for this frame (the legacy writer always writes the count,
+        even when null, but the legacy reader/comparator only acts on it when
+        non-zero), so it is skipped rather than compared against 0.
+        """
+        errors = {}
+        for category in TopologyRegressionSceneData.topology_categories:
+            ref_elements = ref_state.get(category[1], [])
+            ref_count = len(ref_elements)
+
+            if ref_count == 0:
+                errors[category[1]] = 0
+                continue
+
+            cur_elements = current_state[category[1]]
+            cur_count = len(cur_elements)
+
+            if ref_count != cur_count:
+                errors[category[1]] = abs(ref_count - cur_count)
+            else:
+                errors[category[1]] = sum(
+                    1 for ref_elem, cur_elem in zip(ref_elements, cur_elements)
+                    if list(ref_elem) != list(cur_elem)
+                )
+        return errors
+
+
+    def load_scene(self, format = "JSON"):
+        helper.writeLog(f"Loading scene: {self.file_scene_path}", self.verbose)
+        self.root_node = Sofa.Simulation.load(self.file_scene_path)
+        if not self.root_node: # error while loading
+            raise RuntimeError(f"While trying to load {self.file_scene_path}")
+        else:
+            helper.writeLog("Initializing root node", self.verbose)
+            Sofa.Simulation.initRoot(self.root_node)
+
+            # prepare ref files per topology container:
+            self.parse_node(self.root_node, 0)
+            counter = 0
+            for topo in self.topology:
+                if format != "JSON":
+                    raise ValueError(f"Unsupported format for TOPOLOGY regression: {format}")
+                _filename = self.file_ref_path + ".reference_topology_" + str(counter) + "_" + topo.name.value + ".json.gz"
+                self.filenames.append(_filename)
+                counter = counter + 1
+
+
+    def write_references(self, format = "JSON"):
+        if format != "JSON":
+            raise ValueError(f"Unsupported format for TOPOLOGY regression: {format}")
+
+        pbar_simu = pbh.ProgressBarHandler(total=self.steps, disable=self.disable_progress_bar)
+        pbar_simu.set_description("Simulate: " + self.file_scene_path)
+
+        dt = self.root_node.dt.value
+        nbr_topo = len(self.topology)
+        numpy_data = [dict() for _ in range(nbr_topo)] # List<map>
+
+        # Store the topology structure at each time step to catch potential topological changes during the simulation
+        for step in range(self.steps):
+            Sofa.Simulation.animate(self.root_node, dt)
+            pbar_simu.update(1)
+
+            t = dt * step
+            for topo_id in range(nbr_topo):
+                numpy_data[topo_id][t] = TopologyRegressionSceneData._get_topology_structure(self.topology[topo_id])
+
+        pbar_simu.close()
+
+        # write reference files
+        for topo_id in range(nbr_topo):
+            output_file = pathlib.Path(self.filenames[topo_id])
+            output_file.parent.mkdir(exist_ok=True, parents=True)
+            reference_io.write_JSON_reference_file(self.filenames[topo_id], numpy_data[topo_id])
+
+        Sofa.Simulation.unload(self.root_node)
+
+
+    def compare_references(self, format = "JSON"):
+        if format != "JSON":
+            helper.writeError(f"Unsupported format: {format}", self.verbose)
+            raise ValueError(f"Unsupported format: {format}")
+
+        pbar_simu = pbh.ProgressBarHandler(total=float(self.steps), disable=self.disable_progress_bar)
+        pbar_simu.set_description("compare_references: " + self.file_scene_path)
+
+        nbr_topo = len(self.topology)
+
+        # Reference data
+        keyframes = [] # shared timeline
+        numpy_data = [] # List<map>
+
+        # Outputs init
+        self.total_error = [0.0] * nbr_topo
+        for topo_type in self.error_topology:
+            self.error_topology[topo_type] = [0.0] * nbr_topo
+        self.nbr_tested_frame = 0
+        self.regression_failed = False
+
+        # --------------------------------------------------
+        # Load reference files
+        # --------------------------------------------------
+        for topo_id in range(nbr_topo):
+            try:
+                decoded_array, decoded_keyframes = reference_io.read_JSON_reference_file(self.filenames[topo_id])
+            except KeyError as e:
+                e.add_note(f"Missing metadata key {e} in reference file: {self.file_ref_path}")
+                raise
+            numpy_data.append(decoded_array)
+
+            # Keep timeline from first topology container
+            if topo_id == 0:
+                keyframes = decoded_keyframes
+
+        # --------------------------------------------------
+        # Simulation + comparison
+        # --------------------------------------------------
+        nbr_frames = len(keyframes)
+        dt = self.root_node.dt.value
+
+        if nbr_frames != self.steps:
+            helper.writeWarning(f"Number of frames saved in reference file ({nbr_frames}) does not match the number of required steps ({self.steps})", self.verbose)
+
+        for step in range(self.steps):
+            start_time = time.time_ns()
+            Sofa.Simulation.animate(self.root_node, dt)
+            self.total_run_time += time.time_ns() - start_time
+
+            pbar_simu.update(1)
+
+            # Sample right after animate(): see the comment in write_references()
+            # for why this mirrors the legacy AnimateBeginEvent-based sampling.
+            if step < nbr_frames:
+                for topo_id in range(nbr_topo):
+                    ref_state = numpy_data[topo_id][str(keyframes[step])]
+                    current_state = TopologyRegressionSceneData._get_topology_structure(self.topology[topo_id])
+
+                    errors = TopologyRegressionSceneData._compare_topology_structure(ref_state, current_state)
+
+                    helper.writeLog(
+                        f"{step} | {self.topology[topo_id].name.value} | errors: {errors}",
+                        self.verbose
+                    )
+
+                    for topo_type in self.error_topology:
+                        self.error_topology[topo_type][topo_id] += errors[topo_type]
+
+                    self.total_error[topo_id] += sum(errors.values())
+
+                self.nbr_tested_frame += 1
+        pbar_simu.close()
+
+        # Final regression returns value
+        for topo_id in range(nbr_topo):
+            if not np.isfinite(self.total_error[topo_id]):
+                self.regression_failed = True
+                return False
+            if self.total_error[topo_id] > self.epsilon:
+                self.regression_failed = True
+                return False
+
+        return True
+
+
+    def compare_legacy_references(self):
+        pbar_simu = pbh.ProgressBarHandler(total=float(self.steps), disable=self.disable_progress_bar)
+        pbar_simu.set_description("compare_legacy_references: " + self.file_scene_path)
+
+        nbr_topo = len(self.topology)
+
+        # Reference data
+        ref_times = []  # shared timeline
+        ref_values = [] # List[List[dict category -> list[tuple]]]
+
+        self.total_error = [0.0] * nbr_topo
+        for topo_type in self.error_topology:
+            self.error_topology[topo_type] = [0.0] * nbr_topo
+        self.nbr_tested_frame = 0
+        self.regression_failed = False
+
+        if nbr_topo == 0:
+            self.regression_failed = True
+            return False
+
+        # --------------------------------------------------
+        # Load legacy reference files
+        # --------------------------------------------------
+        for topo_id in range(nbr_topo):
+            legacy_filename = (self.file_ref_path + ".reference_" + str(topo_id) + "_"
+                                + self.topology[topo_id].name.value + "_topology.txt.gz")
+            try:
+                times, values = reference_io.read_legacy_topology_reference(legacy_filename)
+            except Exception as e:
+                e.add_note(
+                        f"While reading legacy topology references for container "
+                        f"'{self.topology[topo_id].name.value}'"
+                    )
+                raise
+
+            # Keep timeline from first topology container
+            if topo_id == 0:
+                ref_times = times
+            else:
+                if len(times) != len(ref_times):
+                    raise ValueError(
+                        f"Reference timeline mismatch for file {self.file_scene_path}, "
+                        f"Topology {topo_id}",
+                        self.verbose
+                    )
+
+            ref_values.append(values)
+
+        # --------------------------------------------------
+        # Simulation + comparison
+        # --------------------------------------------------
+        frame_step = 0
+        nbr_frames = len(ref_times)
+        dt = self.root_node.dt.value
+
+        if nbr_frames != self.steps:
+            helper.writeWarning(f"Number of steps saved in reference file ({nbr_frames}) does not match the number of required steps ({self.steps})", self.verbose)
+
+        for step in range(self.steps):
+            Sofa.Simulation.animate(self.root_node, dt)
+            pbar_simu.update(1)
+
+            # Sample right after animate(): see the comment in write_references()
+            # for why this mirrors the legacy AnimateBeginEvent-based sampling.
+            simu_time = dt * step
+
+            # Use tolerance for float comparison
+            if frame_step < nbr_frames and abs(simu_time - ref_times[frame_step]) < dt / 2.0:
+                for topo_id in range(nbr_topo):
+                    ref_state = ref_values[topo_id][frame_step]
+                    current_state = TopologyRegressionSceneData._get_topology_structure(self.topology[topo_id])
+
+                    errors = TopologyRegressionSceneData._compare_topology_structure(ref_state, current_state)
+
+                    helper.writeLog(
+                        f"    {step} | {self.topology[topo_id].name.value} | errors: {errors}",
+                        self.verbose
+                    )
+
+                    for topo_type in self.error_topology:
+                        self.error_topology[topo_type][topo_id] += errors[topo_type]
+
+                    self.total_error[topo_id] += sum(errors.values())
+
+                frame_step += 1
+                self.nbr_tested_frame += 1
+
+                # security exit if simulation steps exceed nbr_frames
+                if frame_step == nbr_frames:
+                    break
+        pbar_simu.close()
+
+        # Final regression returns value
+        for topo_id in range(nbr_topo):
+            if not np.isfinite(self.total_error[topo_id]):
+                self.regression_failed = True
+                return False
+            if self.total_error[topo_id] > self.epsilon:
+                self.regression_failed = True
+                return False
+
+        return True
diff --git a/SofaRegressionProgram/tools/RegressionSceneList.py b/SofaRegressionProgram/tools/RegressionSceneList.py
index 7b6a3f7..3fdebb5 100644
--- a/SofaRegressionProgram/tools/RegressionSceneList.py
+++ b/SofaRegressionProgram/tools/RegressionSceneList.py
@@ -1,21 +1,39 @@
+from enum import Enum
 import os
 import math
 import tools.RegressionSceneData as RegressionSceneData
 import tools.RegressionHelper as helper
 import tools.RegressionWorker as RegressionWorker
 import sys
+from pathlib import Path
 
 import re
 
 ## This class is responsible for loading a file.regression-tests to gather the list of scene to test with all arguments
 ## It will provide the API to launch the tests or write refs on all scenes contained in this file
 class RegressionSceneList:
+
+    class RegressionType(Enum):
+        STATE = ("RegressionStateScenes", RegressionSceneData.StateRegressionSceneData)
+        TOPOLOGY = ("RegressionTopologyScenes", RegressionSceneData.TopologyRegressionSceneData)
+
+
     def __init__(self, file_path, filter, disable_progress_bar = False, verbose = 1, nbr_jobs = 1):
         """
         /// Path to the file.regression-tests containing the list of scene to tests with all arguments
         std::string filePath;
         """
         self.file_path = file_path
+
+        self.regression_type = None
+        for reg_type in RegressionSceneList.RegressionType:
+           if reg_type.value[0] in Path(self.file_path).name:
+               self.regression_type = reg_type
+               break
+
+        if self.regression_type is None:
+            raise ValueError(f"Regression type {Path(self.file_path).name} not recognize, can be of types {[reg_type.value[0] for reg_type in RegressionSceneList.RegressionType]}.")
+
         self.filter = filter
         self.file_dir = os.path.dirname(file_path)
         self.scenes_data_sets = [] # List<RegressionSceneData>
@@ -155,7 +173,7 @@ def parse_scene_line(self, values, line_number, err_log_stream = None):
 
         full_ref_file_path = os.path.normpath(os.path.join(self.ref_dir_path, values[0]))
 
-        return RegressionSceneData.RegressionSceneData(full_file_path, full_ref_file_path,
+        return self.regression_type.value[1](full_file_path, full_ref_file_path,
                                                        steps, epsilon, meca_in_mapping, dump_number_step,
                                                        self.disable_progress_bar, self.verbose)
 
@@ -301,6 +319,10 @@ def compare_references(self, id_scene):
     def compare_all_references(self):
         return self._run_tasks("compare", "Compare all scenes from: " + self.file_path)
 
+    def is_replay_available(self):
+        if self.regression_type is not None:
+            return self.regression_type.value[1].is_replay_available()
+        return False
 
     def replay_references(self, id_scene):
         if (id_scene < 0 or id_scene >= len(self.scenes_data_sets)):
diff --git a/SofaRegressionProgram/tools/RegressionWorker.py b/SofaRegressionProgram/tools/RegressionWorker.py
index 1aa1b6d..6c749c1 100644
--- a/SofaRegressionProgram/tools/RegressionWorker.py
+++ b/SofaRegressionProgram/tools/RegressionWorker.py
@@ -53,7 +53,7 @@ def _safe_remove(path):
 # --------------------------------------------------
 # Parent side: spawn one child process for one scene
 # --------------------------------------------------
-def run_scene_in_subprocess(scene_data, mode, legacy=False,
+def run_scene_in_subprocess(scene_data, mode, scene_list = None, legacy=False,
                             disable_progress_bar=False, verbose=1,
                             format="JSON", python_exe=None,
                             capture_output=False):
@@ -92,6 +92,7 @@ def run_scene_in_subprocess(scene_data, mode, legacy=False,
         "--ref", str(scene_data.file_ref_path),
         "--steps", str(scene_data.steps),
         "--epsilon", repr(scene_data.epsilon),
+        "--regression-type", scene_list.regression_type.name,
         "--meca-in-mapping", "1" if scene_data.meca_in_mapping else "0",
         "--dump-number-step", str(scene_data.dump_number_step),
         "--format", format,
@@ -198,6 +199,7 @@ def _run(task):
             task["scene_data"],
             mode=task["mode"],
             legacy=task.get("legacy", False),
+            scene_list= task["scene_list"],
             # In parallel the per-step progress bars of the children are
             # captured along with their output: they would only produce noise.
             disable_progress_bar=disable_progress_bar or nbr_jobs > 1,
@@ -260,8 +262,9 @@ def _run(task):
                     executor.shutdown(wait=False, cancel_futures=True)
                     raise
     finally:
-        with open(Path(logs_output) / "run_errors_logs.txt", 'w', encoding="utf-8") as error_logs_file:
-            error_logs_file.write(stream_out.getvalue())
+        if logs_output is not None:
+            with open(Path(logs_output) / "run_errors_logs.txt", 'w', encoding="utf-8") as error_logs_file:
+                error_logs_file.write(stream_out.getvalue())
 
     return len(tasks)
 
@@ -276,6 +279,7 @@ def _make_worker_parser():
     parser.add_argument("--ref", required=True)
     parser.add_argument("--steps", type=int, required=True)
     parser.add_argument("--epsilon", type=float, required=True)
+    parser.add_argument("--regression-type", dest="regression_type", type=str, required=True)
     parser.add_argument("--meca-in-mapping", dest="meca_in_mapping", choices=["0", "1"], required=True)
     parser.add_argument("--dump-number-step", dest="dump_number_step", type=int, required=True)
     parser.add_argument("--format", default="JSON")
@@ -307,8 +311,13 @@ def _worker_main():
         import Sofa
         import SofaRuntime  # noqa: F401  (registers the py3 scene loader)
         import tools.RegressionSceneData as RegressionSceneData
+        import tools.RegressionSceneList as RegressionSceneList
+        import numpy as np
 
-        scene = RegressionSceneData.RegressionSceneData(
+        np.set_printoptions(legacy='1.25') # revert printing floating-point type in numpy (concretely remove np.array when displaying a list of np.float)
+
+
+        scene = RegressionSceneList.RegressionSceneList.RegressionType[args.regression_type].value[1](
             file_scene_path=args.scene,
             file_ref_path=args.ref,
             steps=args.steps,
@@ -333,13 +342,15 @@ def _worker_main():
             result = {
                 "ok": True,
                 "result": bool(passed),
-                "regression_failed": bool(scene.regression_failed),
-                "nbr_tested_frame": int(scene.nbr_tested_frame),
-                "total_run_time": int(scene.total_run_time),
-                "error_by_dof": [float(v) for v in scene.error_by_dof],
-                "total_error": [float(v) for v in scene.total_error],
                 "error": None,
+                **scene.__dict__
             }
+            ## Remove data that break json. Not every regression type carries
+            ## every one of these attributes (e.g. TopologyRegressionSceneData
+            ## has no "meca_objs"), so remove them only if present.
+            for key in ("meca_objs", "root_node", "topology"):
+                result.pop(key, None)
+
     except Exception as e:
         import traceback
         result = {"ok": False, "error": str(e), "traceback": traceback.format_exc()}