diff --git a/python/scripts/generate_enums.py b/python/scripts/generate_enums.py
index e07b12eb8..bfc02897b 100644
--- a/python/scripts/generate_enums.py
+++ b/python/scripts/generate_enums.py
@@ -12,7 +12,7 @@ import subprocess
 from parse import remove_comments
 
 allow_bitwise_op = ["M3_GainCaps"]
-allow_bitwise_op = ["ethernetInterface"]
+allow_bitwise_op = ["streamingInterface"]
 
 op_key = {"operator|": "__or__", 
           "operator&" : "__and__"}
@@ -23,7 +23,7 @@ def single_line_enum(line):
 
 def extract_enums(lines):
 
-    # deal with enum class ethernetInterface : int32_t
+    # deal with enum class streamingInterface : int32_t
     # and normal enum burstMode {
 
     line_iter = iter(lines)
@@ -90,7 +90,7 @@ def generate_enum_string(enums):
 
         #Here add the operators 
         for op in operators:
-            data.append(f"\n\t.def(\"{op_key[op]}\", py::overload_cast< const slsDetectorDefs::ethernetInterface&,  const slsDetectorDefs::ethernetInterface&>(&{op}))")
+            data.append(f"\n\t.def(\"{op_key[op]}\", py::overload_cast< const slsDetectorDefs::streamingInterface&,  const slsDetectorDefs::streamingInterface&>(&{op}))")
 
 
         data.append(';\n\n')
diff --git a/python/slsdet/detector.py b/python/slsdet/detector.py
index 79ea86c38..21cea81f6 100755
--- a/python/slsdet/detector.py
+++ b/python/slsdet/detector.py
@@ -7,7 +7,7 @@ timingMode = slsDetectorDefs.timingMode
 speedLevel = slsDetectorDefs.speedLevel
 dacIndex = slsDetectorDefs.dacIndex
 detectorType = slsDetectorDefs.detectorType
-ethernetInterface = slsDetectorDefs.ethernetInterface
+streamingInterface = slsDetectorDefs.streamingInterface
 
 defs = slsDetectorDefs
 
@@ -2435,7 +2435,7 @@ class Detector(CppDetectorApi):
         Note
         ----
         Default: both off
-        Options: NONE, I3GBE, 10GBE (debugging)
+        Options: NONE, LOW_LATENCY_LINK, 10GBE (debugging)
         Debugging interface also enables second interface in receiver (separate file), which also restarts zmq streaming if enabled.
         """
         return self.getVetoStream()
@@ -2451,10 +2451,10 @@ class Detector(CppDetectorApi):
         """[Gotthard2] Algorithm used for veto
         Example
         ----------
-        >>> d.vetoalg = defs.DEFAULT_ALGORITHM, defs.I10GBE
+        >>> d.vetoalg = defs.DEFAULT_ALGORITHM, defs.ETHERNET_10GB
         """
         result = {}
-        interface = [ethernetInterface.I3GBE, ethernetInterface.I10GBE]
+        interface = [streamingInterface.LOW_LATENCY_LINK, streamingInterface.ETHERNET_10GB]
         for eth in interface:
             result[eth] = element_if_equal(self.getVetoAlgorithm(eth))
         return result
diff --git a/python/src/detector.cpp b/python/src/detector.cpp
index 9088d197d..763b47f6c 100644
--- a/python/src/detector.cpp
+++ b/python/src/detector.cpp
@@ -1137,23 +1137,23 @@ void init_det(py::module &m) {
                  Detector::setVeto,
              py::arg(), py::arg() = Positions{})
         .def("getVetoStream",
-             (Result<defs::ethernetInterface>(Detector::*)(sls::Positions)
+             (Result<defs::streamingInterface>(Detector::*)(sls::Positions)
                   const) &
                  Detector::getVetoStream,
              py::arg() = Positions{})
         .def("setVetoStream",
-             (void (Detector::*)(const defs::ethernetInterface,
+             (void (Detector::*)(const defs::streamingInterface,
                                  sls::Positions)) &
                  Detector::setVetoStream,
              py::arg(), py::arg() = Positions{})
         .def("getVetoAlgorithm",
              (Result<defs::vetoAlgorithm>(Detector::*)(
-                 const defs::ethernetInterface, sls::Positions) const) &
+                 const defs::streamingInterface, sls::Positions) const) &
                  Detector::getVetoAlgorithm,
              py::arg(), py::arg() = Positions{})
         .def("setVetoAlgorithm",
              (void (Detector::*)(const defs::vetoAlgorithm,
-                                 const defs::ethernetInterface,
+                                 const defs::streamingInterface,
                                  sls::Positions)) &
                  Detector::setVetoAlgorithm,
              py::arg(), py::arg(), py::arg() = Positions{})
diff --git a/python/src/enums.cpp b/python/src/enums.cpp
index f3d381a51..7519382fc 100644
--- a/python/src/enums.cpp
+++ b/python/src/enums.cpp
@@ -286,20 +286,20 @@ void init_enums(py::module &m) {
         .value("BOTTOM", slsDetectorDefs::portPosition::BOTTOM)
         .export_values();
 
-    py::enum_<slsDetectorDefs::ethernetInterface>(Defs, "ethernetInterface",
+    py::enum_<slsDetectorDefs::streamingInterface>(Defs, "streamingInterface",
                                                   py::arithmetic())
-        .value("NONE", slsDetectorDefs::ethernetInterface::NONE)
-        .value("I3GBE", slsDetectorDefs::ethernetInterface::I3GBE)
-        .value("I10GBE", slsDetectorDefs::ethernetInterface::I10GBE)
-        .value("ALL", slsDetectorDefs::ethernetInterface::ALL)
+        .value("NONE", slsDetectorDefs::streamingInterface::NONE)
+        .value("LOW_LATENCY_LINK", slsDetectorDefs::streamingInterface::LOW_LATENCY_LINK)
+        .value("ETHERNET_10GB", slsDetectorDefs::streamingInterface::ETHERNET_10GB)
+        .value("ALL", slsDetectorDefs::streamingInterface::ALL)
         .export_values()
         .def("__or__",
-             py::overload_cast<const slsDetectorDefs::ethernetInterface &,
-                               const slsDetectorDefs::ethernetInterface &>(
+             py::overload_cast<const slsDetectorDefs::streamingInterface &,
+                               const slsDetectorDefs::streamingInterface &>(
                  &operator|))
         .def("__and__",
-             py::overload_cast<const slsDetectorDefs::ethernetInterface &,
-                               const slsDetectorDefs::ethernetInterface &>(
+             py::overload_cast<const slsDetectorDefs::streamingInterface &,
+                               const slsDetectorDefs::streamingInterface &>(
                  &operator&));
 
     py::enum_<slsDetectorDefs::vetoAlgorithm>(Defs, "vetoAlgorithm")
diff --git a/slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServer_developer b/slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServer_developer
index 977752522..99b23eb6f 100755
Binary files a/slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServer_developer and b/slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServer_developer differ
diff --git a/slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer b/slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer
index 3e9038579..b9c23d36d 100755
Binary files a/slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer and b/slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer differ
diff --git a/slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer b/slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer
index 18f6c9b22..76eacf039 100755
Binary files a/slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer and b/slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer differ
diff --git a/slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c b/slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c
index 57136a3a3..2ece73d9d 100644
--- a/slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c
+++ b/slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c
@@ -1752,10 +1752,10 @@ int configureMAC() {
                   "\tDest Port   : %d\n\n",
                   src_ip, src_mac, srcport, dst_ip, dst_mac, dstport));
 
-    int i3gbe = getVetoStream();
+    int lll = getVetoStream();
     int i10gbe = (getNumberofUDPInterfaces() == 2 ? 1 : 0);
 
-    if (i3gbe) {
+    if (lll) {
         LOG(logINFOGREEN, ("\tVeto (3GbE) : enabled\n\n"));
     } else {
         LOG(logINFORED, ("\tVeto (3GbE) : disabled\n\n"));
@@ -2642,9 +2642,9 @@ int getVetoStream() {
     return ((bus_r(CONFIG_REG) & CONFIG_VETO_CH_3GB_ENBL_MSK) ? 1 : 0);
 }
 
-enum vetoAlgorithm getVetoAlgorithm(enum ethernetInterface interface) {
+enum vetoAlgorithm getVetoAlgorithm(enum streamingInterface interface) {
     // 3gbe
-    if (interface == I3GBE) {
+    if (interface == LOW_LATENCY_LINK) {
         int retval = ((bus_r(CONFIG_REG) & CONFIG_VETO_CH_3GB_ALG_MSK) >>
                       CONFIG_VETO_CH_3GB_ALG_OFST);
         switch (retval) {
@@ -2669,14 +2669,14 @@ enum vetoAlgorithm getVetoAlgorithm(enum ethernetInterface interface) {
     }
 }
 
-void setVetoAlgorithm(enum ethernetInterface interface,
+void setVetoAlgorithm(enum streamingInterface interface,
                       enum vetoAlgorithm alg) {
     uint32_t addr = CONFIG_REG;
     uint32_t value = bus_r(addr);
     switch (alg) {
         // more to follow
     case DEFAULT_ALGORITHM:
-        if (interface == I3GBE) {
+        if (interface == LOW_LATENCY_LINK) {
             LOG(logINFO, ("Setting default veto algorithm for 3Gbe\n"));
             value &= (~CONFIG_VETO_CH_3GB_ALG_MSK);
             value |= CONFIG_VETO_CH_3GB_ALG_DEFAULT_VAL;
diff --git a/slsDetectorServers/gotthardDetectorServer/bin/gotthardDetectorServer_developer b/slsDetectorServers/gotthardDetectorServer/bin/gotthardDetectorServer_developer
index 4abdc5355..13961bf4e 100755
Binary files a/slsDetectorServers/gotthardDetectorServer/bin/gotthardDetectorServer_developer and b/slsDetectorServers/gotthardDetectorServer/bin/gotthardDetectorServer_developer differ
diff --git a/slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServer_developer b/slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServer_developer
index 8a664f42e..e514224c4 100755
Binary files a/slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServer_developer and b/slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServer_developer differ
diff --git a/slsDetectorServers/moenchDetectorServer/bin/moenchDetectorServer_developer b/slsDetectorServers/moenchDetectorServer/bin/moenchDetectorServer_developer
index 1feac6539..533a6a662 100755
Binary files a/slsDetectorServers/moenchDetectorServer/bin/moenchDetectorServer_developer and b/slsDetectorServers/moenchDetectorServer/bin/moenchDetectorServer_developer differ
diff --git a/slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer b/slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer
index af77a2a5f..150b07189 100755
Binary files a/slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer and b/slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer differ
diff --git a/slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h b/slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h
index f28fcc102..d2b1e1db8 100644
--- a/slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h
+++ b/slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h
@@ -547,8 +547,8 @@ void setVeto(int enable);
 int getVeto();
 void setVetoStream(int value);
 int getVetoStream();
-enum vetoAlgorithm getVetoAlgorithm(enum ethernetInterface interface);
-void setVetoAlgorithm(enum ethernetInterface interface, enum vetoAlgorithm alg);
+enum vetoAlgorithm getVetoAlgorithm(enum streamingInterface interface);
+void setVetoAlgorithm(enum streamingInterface interface, enum vetoAlgorithm alg);
 void setBadChannels(int nch, int *channels);
 int *getBadChannels(int *nch);
 #endif
diff --git a/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c b/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c
index 473d2b26a..315643326 100644
--- a/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c
+++ b/slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c
@@ -8370,7 +8370,7 @@ int set_datastream(int file_des) {
 int get_veto_stream(int file_des) {
     ret = OK;
     memset(mess, 0, sizeof(mess));
-    enum ethernetInterface retval = NONE;
+    enum streamingInterface retval = NONE;
 
     LOG(logDEBUG1, ("Getting veto stream\n"));
 
@@ -8387,7 +8387,7 @@ int get_veto_stream(int file_des) {
 int set_veto_stream(int file_des) {
     ret = OK;
     memset(mess, 0, sizeof(mess));
-    enum ethernetInterface arg = 0;
+    enum streamingInterface arg = 0;
 
     if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
         return printSocketReadError();
@@ -8419,7 +8419,7 @@ int set_veto_stream(int file_des) {
 int get_veto_algorithm(int file_des) {
     ret = OK;
     memset(mess, 0, sizeof(mess));
-    enum ethernetInterface arg = NONE;
+    enum streamingInterface arg = NONE;
     enum vetoAlgorithm retval = DEFAULT_ALGORITHM;
     if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
         return printSocketReadError();
@@ -8430,7 +8430,7 @@ int get_veto_algorithm(int file_des) {
     functionNotImplemented();
 #else
     // get only
-    if (arg != I3GBE && arg != I10GBE) {
+    if (arg != LOW_LATENCY_LINK && arg != ETHERNET_10GB) {
         ret = FAIL;
         sprintf(mess, "Could not get vetoalgorithm. Invalid interface %d.\n",
                 arg);
@@ -8451,7 +8451,7 @@ int set_veto_algorithm(int file_des) {
         return printSocketReadError();
 
     enum vetoAlgorithm alg = args[0];
-    enum ethernetInterface interface = args[1];
+    enum streamingInterface interface = args[1];
     LOG(logDEBUG1, ("Setting vetoalgorithm (interface: %d): %u\n", (int)interface,
                   (int)alg));
 
@@ -8460,7 +8460,7 @@ int set_veto_algorithm(int file_des) {
 #else
     // only set
     if (Server_VerifyLock() == OK) {
-        if (interface != I3GBE && interface != I10GBE) {
+        if (interface != LOW_LATENCY_LINK && interface != ETHERNET_10GB) {
             ret = FAIL;
             sprintf(mess,
                     "Could not set vetoalgorithm. Invalid interface %d.\n",
@@ -8822,4 +8822,4 @@ int set_filter_cell(int file_des) {
     }
 #endif
     return Server_SendResult(file_des, INT32, NULL, 0);
-}
\ No newline at end of file
+}
diff --git a/slsDetectorSoftware/include/sls/Detector.h b/slsDetectorSoftware/include/sls/Detector.h
index 6ad3b0826..5e2d0c3f7 100644
--- a/slsDetectorSoftware/include/sls/Detector.h
+++ b/slsDetectorSoftware/include/sls/Detector.h
@@ -1319,26 +1319,26 @@ class Detector {
     void setVeto(const bool enable, Positions pos = {});
 
     /** [Gotthard2] */
-    Result<defs::ethernetInterface> getVetoStream(Positions pos = {}) const;
+    Result<defs::streamingInterface> getVetoStream(Positions pos = {}) const;
 
-    /** [Gotthard2] Options: NONE (Default), I3GBE, I10GBE (debugging), ALL
+    /** [Gotthard2] Options: NONE (Default), LOW_LATENCY_LINK, ETHERNET_10GB (debugging), ALL
      * Enable or disable the 2 veto streaming interfaces available. Can
-     * concatenate more than one interface. \n3GbE (2.5GbE) is the default
-     * interface to work with. \n10GbE is for debugging and also enables second
+     * concatenate more than one interface. \nLOW_LATENCY_LINK is the default
+     * interface to work with. \nETHERNET_10GB is for debugging and also enables second
      * interface in receiver for listening to veto packets (writes a separate
      * file if writing enabled). Also restarts client and receiver zmq sockets
      * if zmq streaming enabled.*/
-    void setVetoStream(const defs::ethernetInterface value, Positions pos = {});
+    void setVetoStream(const defs::streamingInterface value, Positions pos = {});
 
     /** [Gotthard2] */
     Result<defs::vetoAlgorithm>
-    getVetoAlgorithm(const defs::ethernetInterface value,
+    getVetoAlgorithm(const defs::streamingInterface value,
                      Positions pos = {}) const;
 
     /** [Gotthard2] Options(vetoAlgorithm): DEFAULT_ALGORITHM.
-     * Options(ethernetInterface): I3GBE, I10GBE */
+     * Options(streamingInterface): LOW_LATENCY_LINK, ETHERNET_10GB */
     void setVetoAlgorithm(const defs::vetoAlgorithm alg,
-                          const defs::ethernetInterface value,
+                          const defs::streamingInterface value,
                           Positions pos = {});
 
     /** [Gotthard2] */
diff --git a/slsDetectorSoftware/src/CmdProxy.cpp b/slsDetectorSoftware/src/CmdProxy.cpp
index 3f8b93659..c3a2ffe19 100644
--- a/slsDetectorSoftware/src/CmdProxy.cpp
+++ b/slsDetectorSoftware/src/CmdProxy.cpp
@@ -1945,9 +1945,9 @@ std::string CmdProxy::VetoStreaming(int action) {
     std::ostringstream os;
     os << cmd << ' ';
     if (action == defs::HELP_ACTION) {
-        os << "[none|3gbe|10gbe|...]\n\t[Gotthard2] Enable or disable the 2 "
+        os << "[none|lll|10gbe|...]\n\t[Gotthard2] Enable or disable the 2 "
               "veto streaming interfaces available. Can include more than one "
-              "interface. \n\tDefault: none. 3GbE (2.5GbE) is the default "
+              "interface. \n\tDefault: none. lll (low latency link) is the default "
               "interface to work with. \n\t10GbE is for debugging and also "
               "enables second interface in receiver for listening to veto "
               "packets (writes a separate file if writing enabled). Also "
@@ -1964,7 +1964,7 @@ std::string CmdProxy::VetoStreaming(int action) {
         if (args.empty()) {
             WrongNumberOfParameters(1);
         }
-        defs::ethernetInterface interface = defs::ethernetInterface::NONE;
+        defs::streamingInterface interface = defs::streamingInterface::NONE;
         for (const auto &arg : args) {
             if (arg == "none") {
                 if (args.size() > 1) {
@@ -1975,7 +1975,7 @@ std::string CmdProxy::VetoStreaming(int action) {
                 }
                 break;
             }
-            interface = interface | (StringTo<defs::ethernetInterface>(arg));
+            interface = interface | (StringTo<defs::streamingInterface>(arg));
         }
         det->setVetoStream(interface, std::vector<int>{det_id});
         os << ToString(interface) << '\n';
@@ -1989,16 +1989,16 @@ std::string CmdProxy::VetoAlgorithm(int action) {
     std::ostringstream os;
     os << cmd << ' ';
     if (action == defs::HELP_ACTION) {
-        os << "[default] [3gbe|10gbe]\n\t[Gotthard2] Set the veto "
+        os << "[default] [lll|10gbe]\n\t[Gotthard2] Set the veto "
               "algorithm."
            << '\n';
     } else if (action == defs::GET_ACTION) {
         if (args.size() != 1) {
             WrongNumberOfParameters(1);
         }
-        defs::ethernetInterface interface =
-            StringTo<defs::ethernetInterface>(args[0]);
-        if (interface == defs::ethernetInterface::NONE) {
+        defs::streamingInterface interface =
+            StringTo<defs::streamingInterface>(args[0]);
+        if (interface == defs::streamingInterface::NONE) {
             throw sls::RuntimeError(
                 "Must specify an interface to set algorithm");
         }
@@ -2009,9 +2009,9 @@ std::string CmdProxy::VetoAlgorithm(int action) {
             WrongNumberOfParameters(2);
         }
         defs::vetoAlgorithm alg = StringTo<defs::vetoAlgorithm>(args[0]);
-        defs::ethernetInterface interface =
-            StringTo<defs::ethernetInterface>(args[1]);
-        if (interface == defs::ethernetInterface::NONE) {
+        defs::streamingInterface interface =
+            StringTo<defs::streamingInterface>(args[1]);
+        if (interface == defs::streamingInterface::NONE) {
             throw sls::RuntimeError(
                 "Must specify an interface to set algorithm");
         }
diff --git a/slsDetectorSoftware/src/Detector.cpp b/slsDetectorSoftware/src/Detector.cpp
index ca08d77fb..73c820789 100644
--- a/slsDetectorSoftware/src/Detector.cpp
+++ b/slsDetectorSoftware/src/Detector.cpp
@@ -1644,49 +1644,49 @@ void Detector::setVeto(bool enable, Positions pos) {
     pimpl->Parallel(&Module::setVeto, pos, enable);
 }
 
-Result<defs::ethernetInterface> Detector::getVetoStream(Positions pos) const {
+Result<defs::streamingInterface> Detector::getVetoStream(Positions pos) const {
     // 3gbe
     auto r3 = pimpl->Parallel(&Module::getVetoStream, pos);
     // 10gbe (debugging interface) opens 2nd udp interface in receiver
     auto r10 = pimpl->getNumberofUDPInterfaces(pos);
 
-    Result<defs::ethernetInterface> res(r3.size());
+    Result<defs::streamingInterface> res(r3.size());
     for (unsigned int i = 0; i < res.size(); ++i) {
-        res[i] = (r3[i] ? defs::ethernetInterface::I3GBE
-                        : defs::ethernetInterface::NONE);
+        res[i] = (r3[i] ? defs::streamingInterface::LOW_LATENCY_LINK
+                        : defs::streamingInterface::NONE);
         if (r10[i] == 2) {
-            res[i] = res[i] | defs::ethernetInterface::I10GBE;
+            res[i] = res[i] | defs::streamingInterface::ETHERNET_10GB;
         }
     }
     return res;
 }
 
-void Detector::setVetoStream(defs::ethernetInterface interface, Positions pos) {
+void Detector::setVetoStream(defs::streamingInterface interface, Positions pos) {
     // 3gbe
-    bool i3gbe = ((interface & defs::ethernetInterface::I3GBE) ==
-                  defs::ethernetInterface::I3GBE);
-    pimpl->Parallel(&Module::setVetoStream, pos, i3gbe);
+    bool LOW_LATENCY_LINK = ((interface & defs::streamingInterface::LOW_LATENCY_LINK) ==
+                 defs::streamingInterface::LOW_LATENCY_LINK);
+    pimpl->Parallel(&Module::setVetoStream, pos, LOW_LATENCY_LINK);
 
     // 10gbe (debugging interface) opens 2nd udp interface in receiver
     int old_numinterfaces = pimpl->getNumberofUDPInterfaces(pos).tsquash(
         "retrieved inconsistent number of udp interfaces");
-    int numinterfaces = (((interface & defs::ethernetInterface::I10GBE) ==
-                          defs::ethernetInterface::I10GBE)
-                             ? 2
-                             : 1);
+    int numinterfaces = (((interface & defs::streamingInterface::ETHERNET_10GB) ==
+                         defs::streamingInterface::ETHERNET_10GB)
+                            ? 2
+                            : 1);
     if (numinterfaces != old_numinterfaces) {
         setNumberofUDPInterfaces_(numinterfaces, pos);
     }
 }
 
 Result<defs::vetoAlgorithm>
-Detector::getVetoAlgorithm(const defs::ethernetInterface interface,
+Detector::getVetoAlgorithm(const defs::streamingInterface interface,
                            Positions pos) const {
     return pimpl->Parallel(&Module::getVetoAlgorithm, pos, interface);
 }
 
 void Detector::setVetoAlgorithm(const defs::vetoAlgorithm alg,
-                                defs::ethernetInterface interface,
+                                defs::streamingInterface interface,
                                 Positions pos) {
     pimpl->Parallel(&Module::setVetoAlgorithm, pos, alg, interface);
 }
diff --git a/slsDetectorSoftware/src/Module.cpp b/slsDetectorSoftware/src/Module.cpp
index d32124547..9b124886f 100644
--- a/slsDetectorSoftware/src/Module.cpp
+++ b/slsDetectorSoftware/src/Module.cpp
@@ -1945,14 +1945,14 @@ void Module::setVetoStream(const bool value) {
 }
 
 slsDetectorDefs::vetoAlgorithm Module::getVetoAlgorithm(
-    const slsDetectorDefs::ethernetInterface interface) const {
+    const slsDetectorDefs::streamingInterface interface) const {
     return sendToDetector<vetoAlgorithm>(F_GET_VETO_ALGORITHM,
                                          static_cast<int>(interface));
 }
 
 void Module::setVetoAlgorithm(
     const slsDetectorDefs::vetoAlgorithm alg,
-    const slsDetectorDefs::ethernetInterface interface) {
+    const slsDetectorDefs::streamingInterface interface) {
     int args[]{static_cast<int>(alg), static_cast<int>(interface)};
     sendToDetector(F_SET_VETO_ALGORITHM, args, nullptr);
 }
diff --git a/slsDetectorSoftware/src/Module.h b/slsDetectorSoftware/src/Module.h
index 7dbbbb774..785258e13 100644
--- a/slsDetectorSoftware/src/Module.h
+++ b/slsDetectorSoftware/src/Module.h
@@ -421,9 +421,9 @@ class Module : public virtual slsDetectorDefs {
     bool getVetoStream() const;
     void setVetoStream(const bool value);
     slsDetectorDefs::vetoAlgorithm
-    getVetoAlgorithm(const slsDetectorDefs::ethernetInterface interface) const;
+    getVetoAlgorithm(const slsDetectorDefs::streamingInterface interface) const;
     void setVetoAlgorithm(const slsDetectorDefs::vetoAlgorithm alg,
-                          const slsDetectorDefs::ethernetInterface interface);
+                          const slsDetectorDefs::streamingInterface interface);
     int getADCConfiguration(const int chipIndex, const int adcIndex) const;
     void setADCConfiguration(const int chipIndex, const int adcIndex,
                              int value);
diff --git a/slsDetectorSoftware/tests/test-CmdProxy-gotthard2.cpp b/slsDetectorSoftware/tests/test-CmdProxy-gotthard2.cpp
index 313d0c28a..9fc4e62cb 100644
--- a/slsDetectorSoftware/tests/test-CmdProxy-gotthard2.cpp
+++ b/slsDetectorSoftware/tests/test-CmdProxy-gotthard2.cpp
@@ -627,25 +627,25 @@ TEST_CASE("vetostream", "[.cmd]") {
         }
         {
             std::ostringstream oss;
-            proxy.Call("vetostream", {"3gbe"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "vetostream 3gbe\n");
+            proxy.Call("vetostream", {"lll"}, -1, PUT, oss);
+            REQUIRE(oss.str() == "vetostream lll\n");
         }
         {
             std::ostringstream oss;
             proxy.Call("vetostream", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "vetostream 3gbe\n");
+            REQUIRE(oss.str() == "vetostream lll\n");
         }
         {
             std::ostringstream oss;
-            proxy.Call("vetostream", {"3gbe", "10gbe"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "vetostream 3gbe, 10gbe\n");
+            proxy.Call("vetostream", {"lll", "10gbe"}, -1, PUT, oss);
+            REQUIRE(oss.str() == "vetostream lll, 10gbe\n");
         }
         {
             std::ostringstream oss;
             proxy.Call("vetostream", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "vetostream 3gbe, 10gbe\n");
+            REQUIRE(oss.str() == "vetostream lll, 10gbe\n");
         }
-        REQUIRE_THROWS(proxy.Call("vetostream", {"3gbe", "none"}, -1, PUT));
+        REQUIRE_THROWS(proxy.Call("vetostream", {"lll", "none"}, -1, PUT));
         for (int i = 0; i != det.size(); ++i) {
             det.setVetoStream(prev_val[i], {i});
         }
@@ -661,18 +661,18 @@ TEST_CASE("vetoalg", "[.cmd]") {
     CmdProxy proxy(&det);
     auto det_type = det.getDetectorType().squash();
     if (det_type == defs::GOTTHARD2) {
-        auto prev_val_3g = det.getVetoAlgorithm(defs::ethernetInterface::I3GBE);
+        auto prev_val_3g = det.getVetoAlgorithm(defs::streamingInterface::LOW_LATENCY_LINK);
         auto prev_val_10g =
-            det.getVetoAlgorithm(defs::ethernetInterface::I10GBE);
+            det.getVetoAlgorithm(defs::streamingInterface::ETHERNET_10GB);
         {
             std::ostringstream oss;
-            proxy.Call("vetoalg", {"default", "3gbe"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "vetoalg default 3gbe\n");
+            proxy.Call("vetoalg", {"default", "lll"}, -1, PUT, oss);
+            REQUIRE(oss.str() == "vetoalg default lll\n");
         }
         {
             std::ostringstream oss;
-            proxy.Call("vetoalg", {"3gbe"}, -1, GET, oss);
-            REQUIRE(oss.str() == "vetoalg default 3gbe\n");
+            proxy.Call("vetoalg", {"lll"}, -1, GET, oss);
+            REQUIRE(oss.str() == "vetoalg default lll\n");
         }
         {
             std::ostringstream oss;
@@ -685,16 +685,16 @@ TEST_CASE("vetoalg", "[.cmd]") {
             REQUIRE(oss.str() == "vetoalg default 10gbe\n");
         }
         REQUIRE_THROWS(
-            proxy.Call("vetoalg", {"default", "3gbe", "10gbe"}, -1, PUT));
+            proxy.Call("vetoalg", {"default", "lll", "10gbe"}, -1, PUT));
         REQUIRE_THROWS(proxy.Call("vetoalg", {"default", "none"}, -1, PUT));
         for (int i = 0; i != det.size(); ++i) {
-            det.setVetoAlgorithm(prev_val_3g[i], defs::ethernetInterface::I3GBE,
+            det.setVetoAlgorithm(prev_val_3g[i], defs::streamingInterface::LOW_LATENCY_LINK,
                                  {i});
             det.setVetoAlgorithm(prev_val_10g[i],
-                                 defs::ethernetInterface::I10GBE, {i});
+                                 defs::streamingInterface::ETHERNET_10GB, {i});
         }
     } else {
-        REQUIRE_THROWS(proxy.Call("vetoalg", {"3gbe"}, -1, GET));
+        REQUIRE_THROWS(proxy.Call("vetoalg", {"lll"}, -1, GET));
         REQUIRE_THROWS(proxy.Call("vetoalg", {"none"}, -1, PUT));
     }
     REQUIRE_THROWS(proxy.Call("vetoalg", {"dfgd"}, -1, GET));
diff --git a/slsSupportLib/include/sls/ToString.h b/slsSupportLib/include/sls/ToString.h
index f10760621..a515b51be 100644
--- a/slsSupportLib/include/sls/ToString.h
+++ b/slsSupportLib/include/sls/ToString.h
@@ -36,9 +36,13 @@ std::string ToString(const defs::dacIndex s);
 std::string ToString(const std::vector<defs::dacIndex> &vec);
 std::string ToString(const defs::burstMode s);
 std::string ToString(const defs::timingSourceType s);
+<<<<<<< HEAD
 std::string ToString(const defs::M3_GainCaps s);
 std::string ToString(const defs::portPosition s);
 std::string ToString(const defs::ethernetInterface s);
+=======
+std::string ToString(const defs::streamingInterface s);
+>>>>>>> 5.2.0-rc
 std::string ToString(const defs::vetoAlgorithm s);
 std::string ToString(const defs::gainMode s);
 
@@ -304,7 +308,7 @@ template <> defs::burstMode StringTo(const std::string &s);
 template <> defs::timingSourceType StringTo(const std::string &s);
 template <> defs::M3_GainCaps StringTo(const std::string &s);
 template <> defs::portPosition StringTo(const std::string &s);
-template <> defs::ethernetInterface StringTo(const std::string &s);
+template <> defs::streamingInterface StringTo(const std::string &s);
 template <> defs::vetoAlgorithm StringTo(const std::string &s);
 template <> defs::gainMode StringTo(const std::string &s);
 
diff --git a/slsSupportLib/include/sls/sls_detector_defs.h b/slsSupportLib/include/sls/sls_detector_defs.h
index 348b36648..f8dbe0e8d 100644
--- a/slsSupportLib/include/sls/sls_detector_defs.h
+++ b/slsSupportLib/include/sls/sls_detector_defs.h
@@ -403,14 +403,14 @@ typedef struct {
     enum portPosition { LEFT, RIGHT, TOP, BOTTOM };
 
 #ifdef __cplusplus
-    enum class ethernetInterface {
+    enum class streamingInterface {
 #else
-    enum ethernetInterface {
+    enum streamingInterface {
 #endif
         NONE = 0,
-        I3GBE = 1 << 0,
-        I10GBE = 1 << 1,
-        ALL = I3GBE | I10GBE
+        LOW_LATENCY_LINK = 1 << 0,
+        ETHERNET_10GB = 1 << 1,
+        ALL = LOW_LATENCY_LINK | ETHERNET_10GB
     };
 
     enum vetoAlgorithm { DEFAULT_ALGORITHM };
@@ -517,17 +517,17 @@ typedef struct {
 
 #ifdef __cplusplus
 };
-inline slsDetectorDefs::ethernetInterface
-operator|(const slsDetectorDefs::ethernetInterface &a,
-          const slsDetectorDefs::ethernetInterface &b) {
-    return slsDetectorDefs::ethernetInterface(static_cast<int32_t>(a) |
+inline slsDetectorDefs::streamingInterface
+operator|(const slsDetectorDefs::streamingInterface &a,
+          const slsDetectorDefs::streamingInterface &b) {
+    return slsDetectorDefs::streamingInterface(static_cast<int32_t>(a) |
                                               static_cast<int32_t>(b));
 };
 
-inline slsDetectorDefs::ethernetInterface
-operator&(const slsDetectorDefs::ethernetInterface &a,
-          const slsDetectorDefs::ethernetInterface &b) {
-    return slsDetectorDefs::ethernetInterface(static_cast<int32_t>(a) &
+inline slsDetectorDefs::streamingInterface
+operator&(const slsDetectorDefs::streamingInterface &a,
+          const slsDetectorDefs::streamingInterface &b) {
+    return slsDetectorDefs::streamingInterface(static_cast<int32_t>(a) &
                                               static_cast<int32_t>(b));
 };
 #endif
diff --git a/slsSupportLib/include/sls/versionAPI.h b/slsSupportLib/include/sls/versionAPI.h
index 4299573fd..fd73c4535 100644
--- a/slsSupportLib/include/sls/versionAPI.h
+++ b/slsSupportLib/include/sls/versionAPI.h
@@ -3,10 +3,11 @@
 #define APILIB       0x210225
 #define APIRECEIVER  0x210225
 #define APIGUI       0x210225
-#define APICTB 0x210729
-#define APIGOTTHARD 0x210729
-#define APIMYTHEN3 0x210729
-#define APIMOENCH 0x210729
-#define APIEIGER 0x210729
-#define APIJUNGFRAU 0x210802
+
+#define APIEIGER 0x210806
+#define APICTB 0x210806
+#define APIGOTTHARD 0x210806
 #define APIGOTTHARD2 0x210806
+#define APIJUNGFRAU 0x210806
+#define APIMYTHEN3 0x210806
+#define APIMOENCH 0x210806
diff --git a/slsSupportLib/src/ToString.cpp b/slsSupportLib/src/ToString.cpp
index 2755f320d..049a4db5f 100644
--- a/slsSupportLib/src/ToString.cpp
+++ b/slsSupportLib/src/ToString.cpp
@@ -553,18 +553,18 @@ std::string ToString(const defs::portPosition s) {
     }
 }
 
-std::string ToString(const defs::ethernetInterface s) {
+std::string ToString(const defs::streamingInterface s) {
     std::ostringstream os;
     std::string rs;
     switch (s) {
-    case defs::ethernetInterface::NONE:
+    case defs::streamingInterface::NONE:
         return std::string("none");
     default:
-        if ((s & defs::ethernetInterface::I3GBE) !=
-            defs::ethernetInterface::NONE)
-            os << "3gbe, ";
-        if ((s & defs::ethernetInterface::I10GBE) !=
-            defs::ethernetInterface::NONE)
+        if ((s & defs::streamingInterface::LOW_LATENCY_LINK) !=
+            defs::streamingInterface::NONE)
+            os << "lll, ";
+        if ((s & defs::streamingInterface::ETHERNET_10GB) !=
+            defs::streamingInterface::NONE)
             os << "10gbe, ";
         auto rs = os.str();
         rs.erase(rs.end() - 2, rs.end());
@@ -966,17 +966,17 @@ template <> defs::portPosition StringTo(const std::string &s) {
     throw sls::RuntimeError("Unknown port position " + s);
 }
 
-template <> defs::ethernetInterface StringTo(const std::string &s) {
+template <> defs::streamingInterface StringTo(const std::string &s) {
     std::string rs = s;
     if (s.find(',') != std::string::npos)
         rs.erase(rs.find(','));
     if (rs == "none")
-        return defs::ethernetInterface::NONE;
-    if (rs == "3gbe")
-        return defs::ethernetInterface::I3GBE;
+        return defs::streamingInterface::NONE;
+    if (rs == "lll")
+        return defs::streamingInterface::LOW_LATENCY_LINK;
     if (rs == "10gbe")
-        return defs::ethernetInterface::I10GBE;
-    throw sls::RuntimeError("Unknown ethernetInterface type " + s);
+        return defs::streamingInterface::ETHERNET_10GB;
+    throw sls::RuntimeError("Unknown streamingInterface type " + s);
 }
 
 template <> defs::vetoAlgorithm StringTo(const std::string &s) {
diff --git a/slsSupportLib/tests/test-ToString.cpp b/slsSupportLib/tests/test-ToString.cpp
index c8e720734..1fcddb2da 100644
--- a/slsSupportLib/tests/test-ToString.cpp
+++ b/slsSupportLib/tests/test-ToString.cpp
@@ -324,10 +324,10 @@ TEST_CASE("Print a member of patternParameters") {
     REQUIRE(ToString(pat->limits) == "[4, 100]");
 }
 
-TEST_CASE("ethernetInterface") {
-    REQUIRE(ToString(sls::defs::ethernetInterface::NONE) == "none");
-    REQUIRE(ToString(sls::defs::ethernetInterface::I10GBE) == "10gbe");
-    REQUIRE(ToString(sls::defs::ethernetInterface::I3GBE) == "3gbe");
-    REQUIRE(ToString(sls::defs::ethernetInterface::I3GBE |
-                     sls::defs::ethernetInterface::I10GBE) == "3gbe, 10gbe");
+TEST_CASE("streamingInterface") {
+    REQUIRE(ToString(sls::defs::streamingInterface::NONE) == "none");
+    REQUIRE(ToString(sls::defs::streamingInterface::ETHERNET_10GB) == "10gbe");
+    REQUIRE(ToString(sls::defs::streamingInterface::LOW_LATENCY_LINK) == "lll");
+    REQUIRE(ToString(sls::defs::streamingInterface::LOW_LATENCY_LINK |
+                     sls::defs::streamingInterface::ETHERNET_10GB) == "lll, 10gbe");
 }
\ No newline at end of file