diff --git a/OMPython/ModelicaSystem.py b/OMPython/ModelicaSystem.py
index 067fed24..3f15c372 100644
--- a/OMPython/ModelicaSystem.py
+++ b/OMPython/ModelicaSystem.py
@@ -4,9 +4,9 @@
 """
 
 import logging
+import numbers
 import os
 import pathlib
-import platform
 from typing import Any, Optional
 import warnings
 
@@ -16,10 +16,14 @@
     ModelExecutionConfig,
     ModelExecutionException,
 )
+from OMPython.om_session_abc import (
+    OMPathABC,
+)
 from OMPython.om_session_omc import (
     OMCSessionLocal,
 )
 from OMPython.modelica_system_abc import (
+    LinearizationResult,
     ModelicaSystemError,
 )
 from OMPython.modelica_system_omc import (
@@ -73,8 +77,73 @@ def __init__(
     def setCommandLineOptions(self, commandLineOptions: str):
         super().set_command_line_options(command_line_option=commandLineOptions)
 
-    def _set_compatibility_helper(
+    def simulate_cmd(  # type: ignore[override]
+            self,
+            result_file: OMPathABC,
+            simflags: Optional[str] = None,
+            simargs: Optional[dict[str, Optional[str | dict[str, Any] | numbers.Number]]] = None,
+    ) -> ModelExecutionConfig:
+        """
+        Compatibility layer for OMPython v4.0.0 - keep simflags available and use ModelicaSystemCmd!
+        """
+
+        if simargs is None:
+            simargs = {}
+
+        if simflags is not None:
+            simargs_extra = parse_simflags(simflags=simflags)
+            simargs = simargs | simargs_extra
+
+        return super().simulate_cmd(
+            result_file=result_file,
+            simargs=simargs,
+        )
+
+    def simulate(  # type: ignore[override]
+            self,
+            resultfile: Optional[str | os.PathLike] = None,
+            simflags: Optional[str] = None,
+            simargs: Optional[dict[str, Optional[str | dict[str, Any] | numbers.Number]]] = None,
+    ) -> None:
+        """
+        Compatibility layer for OMPython v4.0.0 - keep simflags available and use ModelicaSystemCmd!
+        """
+
+        if simargs is None:
+            simargs = {}
+
+        if simflags is not None:
+            simargs_extra = parse_simflags(simflags=simflags)
+            simargs = simargs | simargs_extra
+
+        return super().simulate(
+            resultfile=resultfile,
+            simargs=simargs,
+        )
+
+    def linearize(  # type: ignore[override]
             self,
+            lintime: Optional[float] = None,
+            simflags: Optional[str] = None,
+            simargs: Optional[dict[str, Optional[str | dict[str, Any] | numbers.Number]]] = None,
+    ) -> LinearizationResult:
+        """
+        Compatibility layer for OMPython v4.0.0 - keep simflags available and use ModelicaSystemCmd!
+        """
+        if simargs is None:
+            simargs = {}
+
+        if simflags is not None:
+            simargs_extra = parse_simflags(simflags=simflags)
+            simargs = simargs | simargs_extra
+
+        return super().linearize(
+            lintime=lintime,
+            simargs=simargs,
+        )
+
+    @staticmethod
+    def _set_compatibility_helper(
             pkey: str,
             args: Any,
             kwargs: dict[str, Any],
@@ -330,7 +399,12 @@ class ModelicaSystemDoE(ModelicaDoEOMC):
 @depreciated_class(msg="Please use class ModelExecutionConfig instead!")
 class ModelicaSystemCmd(ModelExecutionConfig):
     """
-    Compatibility class; in the new version it is renamed as ModelExecutionConfig.
+    Compatibility class; not much content.
+
+    Missing definitions:
+    * get_exe() - see self.definition.cmd_model_executable
+    * get_cmd() - use self.get_cmd_args() or self.definition().get_cmd()
+    * run() - use self.definition().run()
     """
 
     def __init__(
@@ -346,35 +420,44 @@ def __init__(
             model_name=modelname,
         )
 
-    def get_exe(self) -> pathlib.Path:
-        """Get the path to the compiled model executable."""
-
-        path_run = pathlib.Path(self._runpath)
-        if platform.system() == "Windows":
-            path_exe = path_run / f"{self._model_name}.exe"
-        else:
-            path_exe = path_run / self._model_name
 
-        if not path_exe.exists():
-            raise ModelicaSystemError(f"Application file path not found: {path_exe}")
-
-        return path_exe
-
-    def get_cmd(self) -> list:
-        """
-        Get a list with the path to the executable and all command line args.
-
-        This can later be used as an argument for subprocess.run().
-        """
-
-        cmdl = [self.get_exe().as_posix()] + self.get_cmd_args()
-
-        return cmdl
+def parse_simflags(simflags: str) -> dict[str, Optional[str | dict[str, Any] | numbers.Number]]:
+    """
+    Parse a simflag definition; this is deprecated!
 
-    def run(self) -> int:
-        cmd_definition = self.definition()
-        try:
-            returncode = cmd_definition.run()
-        except ModelExecutionException as exc:
-            raise ModelicaSystemError(f"Cannot execute model: {exc}") from exc
-        return returncode
+    The return data can be used as input for self.args_set().
+    """
+    warnings.warn(
+        message="The argument 'simflags' is depreciated and will be removed in future versions; "
+                "please use 'simargs' instead",
+        category=DeprecationWarning,
+        stacklevel=2,
+    )
+
+    simargs: dict[str, Optional[str | dict[str, Any] | numbers.Number]] = {}
+
+    args = [s for s in simflags.split(' ') if s]
+    for arg in args:
+        if arg[0] != '-':
+            raise ModelExecutionException(f"Invalid simulation flag: {arg}")
+        arg = arg[1:]
+        parts = arg.split('=')
+        if len(parts) == 1:
+            simargs[parts[0]] = None
+        elif parts[0] == 'override':
+            override = '='.join(parts[1:])
+
+            override_dict = {}
+            for item in override.split(','):
+                kv = item.split('=')
+                if not 0 < len(kv) < 3:
+                    raise ModelExecutionException(f"Invalid value for '-override': {override}")
+                if kv[0]:
+                    try:
+                        override_dict[kv[0]] = kv[1]
+                    except (KeyError, IndexError) as ex:
+                        raise ModelExecutionException(f"Invalid value for '-override': {override}") from ex
+
+            simargs[parts[0]] = override_dict
+
+    return simargs
diff --git a/OMPython/OMCSession.py b/OMPython/OMCSession.py
index abc84ae7..974a8170 100644
--- a/OMPython/OMCSession.py
+++ b/OMPython/OMCSession.py
@@ -7,6 +7,7 @@
 
 import logging
 from typing import Any, Optional
+import warnings
 
 import pyparsing
 
@@ -272,7 +273,13 @@ def omcpath_tempdir(self, tempdir_base: Optional[OMPathABC] = None) -> OMPathABC
         return self.omc_process.omcpath_tempdir(tempdir_base=tempdir_base)
 
     def execute(self, command: str):
-        return self.omc_process.execute(command=command)
+        warnings.warn(
+            message="This function is depreciated and will be removed in future versions; "
+                    "please use sendExpression() instead",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.omc_process.sendExpression(expr=command, parsed=False)
 
     def sendExpression(
         self,
diff --git a/OMPython/__init__.py b/OMPython/__init__.py
index f3526da9..848421c5 100644
--- a/OMPython/__init__.py
+++ b/OMPython/__init__.py
@@ -61,8 +61,8 @@
 # the imports below are compatibility functionality (OMPython v4.0.0)
 from OMPython.ModelicaSystem import (
     ModelicaSystem,
-    ModelicaSystemCmd,
     ModelicaSystemDoE,
+    parse_simflags,
 )
 from OMPython.OMCSession import (
     OMCSessionCmd,
@@ -109,9 +109,9 @@
     'OMPathRunnerLocal',
     'OMSessionRunner',
 
-    'ModelicaSystemCmd',
     'ModelicaSystem',
     'ModelicaSystemDoE',
+    'parse_simflags',
 
     'OMCSessionCmd',
 
diff --git a/OMPython/model_execution.py b/OMPython/model_execution.py
index 87fc6bdf..d3b344d1 100644
--- a/OMPython/model_execution.py
+++ b/OMPython/model_execution.py
@@ -12,7 +12,6 @@
 import re
 import subprocess
 from typing import Any, Optional
-import warnings
 
 # define logger using the current module name as ID
 logger = logging.getLogger(__name__)
@@ -314,45 +313,3 @@ def definition(self) -> ModelExecutionRun:
         )
 
         return omc_run_data
-
-    @staticmethod
-    def parse_simflags(simflags: str) -> dict[str, Optional[str | dict[str, Any] | numbers.Number]]:
-        """
-        Parse a simflag definition; this is deprecated!
-
-        The return data can be used as input for self.args_set().
-        """
-        warnings.warn(
-            message="The argument 'simflags' is depreciated and will be removed in future versions; "
-                    "please use 'simargs' instead",
-            category=DeprecationWarning,
-            stacklevel=2,
-        )
-
-        simargs: dict[str, Optional[str | dict[str, Any] | numbers.Number]] = {}
-
-        args = [s for s in simflags.split(' ') if s]
-        for arg in args:
-            if arg[0] != '-':
-                raise ModelExecutionException(f"Invalid simulation flag: {arg}")
-            arg = arg[1:]
-            parts = arg.split('=')
-            if len(parts) == 1:
-                simargs[parts[0]] = None
-            elif parts[0] == 'override':
-                override = '='.join(parts[1:])
-
-                override_dict = {}
-                for item in override.split(','):
-                    kv = item.split('=')
-                    if not 0 < len(kv) < 3:
-                        raise ModelExecutionException(f"Invalid value for '-override': {override}")
-                    if kv[0]:
-                        try:
-                            override_dict[kv[0]] = kv[1]
-                        except (KeyError, IndexError) as ex:
-                            raise ModelExecutionException(f"Invalid value for '-override': {override}") from ex
-
-                simargs[parts[0]] = override_dict
-
-        return simargs
diff --git a/OMPython/modelica_system_abc.py b/OMPython/modelica_system_abc.py
index f3e02ddf..6ddb8f5d 100644
--- a/OMPython/modelica_system_abc.py
+++ b/OMPython/modelica_system_abc.py
@@ -620,7 +620,6 @@ def _process_override_data(
     def simulate_cmd(
             self,
             result_file: OMPathABC,
-            simflags: Optional[str] = None,
             simargs: Optional[dict[str, Optional[str | dict[str, Any] | numbers.Number]]] = None,
     ) -> ModelExecutionConfig:
         """
@@ -636,7 +635,6 @@ def simulate_cmd(
         Parameters
         ----------
         result_file
-        simflags
         simargs
 
         Returns
@@ -656,10 +654,6 @@ def simulate_cmd(
         # always define the result file to use
         om_cmd.arg_set(key="r", val=result_file.as_posix())
 
-        # allow runtime simulation flags from user input
-        if simflags is not None:
-            om_cmd.args_set(args=om_cmd.parse_simflags(simflags=simflags))
-
         if simargs:
             om_cmd.args_set(args=simargs)
 
@@ -693,7 +687,6 @@ def simulate_cmd(
     def simulate(
             self,
             resultfile: Optional[str | os.PathLike] = None,
-            simflags: Optional[str] = None,
             simargs: Optional[dict[str, Optional[str | dict[str, Any] | numbers.Number]]] = None,
     ) -> None:
         """Simulate the model according to simulation options.
@@ -702,16 +695,11 @@ def simulate(
 
         Args:
             resultfile: Path to a custom result file
-            simflags: String of extra command line flags for the model binary.
-              This argument is deprecated, use simargs instead.
             simargs: Dict with simulation runtime flags.
 
         Examples:
             mod.simulate()
             mod.simulate(resultfile="a.mat")
-            # set runtime simulation flags, deprecated
-            mod.simulate(simflags="-noEventEmit -noRestart -override=e=0.3,g=10")
-            # using simargs
             mod.simulate(simargs={"noEventEmit": None, "noRestart": None, "override": "override": {"e": 0.3, "g": 10}})
         """
 
@@ -730,7 +718,6 @@ def simulate(
 
         om_cmd = self.simulate_cmd(
             result_file=self._result_file,
-            simflags=simflags,
             simargs=simargs,
         )
 
@@ -1060,7 +1047,6 @@ def _createCSVData(self, csvfile: Optional[OMPathABC] = None) -> OMPathABC:
     def linearize(
             self,
             lintime: Optional[float] = None,
-            simflags: Optional[str] = None,
             simargs: Optional[dict[str, Optional[str | dict[str, Any] | numbers.Number]]] = None,
     ) -> LinearizationResult:
         """Linearize the model according to linearization options.
@@ -1069,8 +1055,6 @@ def linearize(
 
         Args:
             lintime: Override "stopTime" value.
-            simflags: String of extra command line flags for the model binary.
-              This argument is deprecated, use simargs instead.
             simargs: A dict with command line flags and possible options; example: "simargs={'csvInput': 'a.csv'}"
 
         Returns:
@@ -1123,10 +1107,6 @@ def linearize(
                                       f"<= lintime <= {self._linearization_options['stopTime']}")
         om_cmd.arg_set(key="l", val=str(lintime))
 
-        # allow runtime simulation flags from user input
-        if simflags is not None:
-            om_cmd.args_set(args=om_cmd.parse_simflags(simflags=simflags))
-
         if simargs:
             om_cmd.args_set(args=simargs)
 
diff --git a/OMPython/om_session_omc.py b/OMPython/om_session_omc.py
index d7100382..1d021e2c 100644
--- a/OMPython/om_session_omc.py
+++ b/OMPython/om_session_omc.py
@@ -21,7 +21,6 @@
 import time
 from typing import Any, Optional, Tuple
 import uuid
-import warnings
 
 import psutil
 import pyparsing
@@ -387,16 +386,6 @@ def omcpath_tempdir(self, tempdir_base: Optional[OMPathABC] = None) -> OMPathABC
 
         return self._tempdir(tempdir_base=tempdir_base)
 
-    def execute(self, command: str):
-        warnings.warn(
-            message="This function is depreciated and will be removed in future versions; "
-                    "please use sendExpression() instead",
-            category=DeprecationWarning,
-            stacklevel=2,
-        )
-
-        return self.sendExpression(command, parsed=False)
-
     def sendExpression(self, expr: str, parsed: bool = True, raise_on_error: bool = True) -> Any:
         """
         Send an expression to the OMC server and return the result.
diff --git a/tests/test_ModelExecutionCmd.py b/tests/test_ModelExecutionCmd.py
index 71e96fc1..19111070 100644
--- a/tests/test_ModelExecutionCmd.py
+++ b/tests/test_ModelExecutionCmd.py
@@ -38,17 +38,19 @@ def mscmd_firstorder(model_firstorder):
 def test_simflags(mscmd_firstorder):
     mscmd = mscmd_firstorder
 
-    mscmd.args_set({
+    mscmd.args_set(args={
+        "override": {
+            'b': 2,
+            'a': 4,
+        },
+        "noRestart": None,
         "noEventEmit": None,
-        "override": {'b': 2}
     })
-    with pytest.deprecated_call():
-        mscmd.args_set(args=mscmd.parse_simflags(simflags="-noEventEmit -noRestart -override=a=1,x=3"))
 
     assert mscmd.get_cmd_args() == [
         '-noEventEmit',
         '-noRestart',
-        '-override=a=1,b=2,x=3',
+        '-override=a=4,b=2',
     ]
 
     mscmd.args_set({
@@ -58,5 +60,5 @@ def test_simflags(mscmd_firstorder):
     assert mscmd.get_cmd_args() == [
         '-noEventEmit',
         '-noRestart',
-        '-override=a=1,x=3',
+        '-override=a=4',
     ]
diff --git a/tests/test_ZMQ.py b/tests/test_ZMQ.py
index 89a8387b..1ba62cb9 100644
--- a/tests/test_ZMQ.py
+++ b/tests/test_ZMQ.py
@@ -38,14 +38,12 @@ def test_Simulate(omcs, model_time_str):
     assert omcs.sendExpression('res.resultFile')
 
 
-def test_execute(omcs):
-    with pytest.deprecated_call():
-        assert omcs.execute('"HelloWorld!"') == '"HelloWorld!"\n'
+def test_sendExpression(omcs):
     assert omcs.sendExpression('"HelloWorld!"', parsed=False) == '"HelloWorld!"\n'
     assert omcs.sendExpression('"HelloWorld!"', parsed=True) == 'HelloWorld!'
 
 
-def test_omcprocessport_execute(omcs):
+def test_sendExpression_port(omcs):
     port = omcs.get_port()
     omcs2 = OMPython.OMCSessionPort(omc_port=port)
 
@@ -58,7 +56,7 @@ def test_omcprocessport_execute(omcs):
     del omcs2
 
 
-def test_omcprocessport_simulate(omcs, model_time_str):
+def test_Simulate_port(omcs, model_time_str):
     port = omcs.get_port()
     omcs2 = OMPython.OMCSessionPort(omc_port=port)
 
diff --git a/tests_v400/test_ModelicaSystemCmd.py b/tests_v400/test_ModelicaSystemCmd.py
index 3544a1bd..0f4535fd 100644
--- a/tests_v400/test_ModelicaSystemCmd.py
+++ b/tests_v400/test_ModelicaSystemCmd.py
@@ -18,7 +18,11 @@ def model_firstorder(tmp_path):
 @pytest.fixture
 def mscmd_firstorder(model_firstorder):
     mod = OMPython.ModelicaSystem(fileName=model_firstorder.as_posix(), modelName="M")
-    mscmd = OMPython.ModelicaSystemCmd(runpath=mod.getWorkDirectory(), modelname=mod._model_name)
+    mscmd = OMPython.ModelExecutionConfig(
+        runpath=mod.getWorkDirectory(),
+        model_name=mod._model_name,
+        cmd_prefix=[],
+    )
     return mscmd
 
 
@@ -30,10 +34,9 @@ def test_simflags(mscmd_firstorder):
         "override": {'b': 2}
     })
     with pytest.deprecated_call():
-        mscmd.args_set(args=mscmd.parse_simflags(simflags="-noEventEmit -noRestart -override=a=1,x=3"))
+        mscmd.args_set(args=OMPython.parse_simflags(simflags="-noEventEmit -noRestart -override=a=1,x=3"))
 
-    assert mscmd.get_cmd() == [
-        mscmd.get_exe().as_posix(),
+    assert mscmd.get_cmd_args() == [
         '-noEventEmit',
         '-noRestart',
         '-override=a=1,b=2,x=3',
@@ -43,8 +46,7 @@ def test_simflags(mscmd_firstorder):
         "override": {'b': None},
     })
 
-    assert mscmd.get_cmd() == [
-        mscmd.get_exe().as_posix(),
+    assert mscmd.get_cmd_args() == [
         '-noEventEmit',
         '-noRestart',
         '-override=a=1,x=3',