diff --git a/Compiler/BackEnd/BackendDAE.mo b/Compiler/BackEnd/BackendDAE.mo
index e9e4734548e..85955ec0630 100644
--- a/Compiler/BackEnd/BackendDAE.mo
+++ b/Compiler/BackEnd/BackendDAE.mo
@@ -77,7 +77,7 @@ uniontype BackendDAEType
 end BackendDAEType;
 
 public
-uniontype VarKind "- Variabile kind"
+uniontype VarKind "variable kind"
   record VARIABLE end VARIABLE;
   record STATE
     Integer index "how often this states was differentiated";
@@ -94,7 +94,7 @@ uniontype VarKind "- Variabile kind"
   record JAC_DIFF_VAR end JAC_DIFF_VAR;
 end VarKind;
 
-uniontype Var "- Variables"
+uniontype Var "variables"
   record VAR
     .DAE.ComponentRef varName "varName ; variable name" ;
     VarKind varKind "varKind ; Kind of variable" ;
diff --git a/Compiler/Util/Flags.mo b/Compiler/Util/Flags.mo
index 60e2d08c366..b9332cf00e0 100644
--- a/Compiler/Util/Flags.mo
+++ b/Compiler/Util/Flags.mo
@@ -522,7 +522,8 @@ constant ConfigFlag PRE_OPT_MODULES = CONFIG_FLAG(12, "preOptModules",
     "replaceEdgeChange",
     "inlineArrayEqn",
     "removeSimpleEquations"
-}),
+    // "addInitialStmtsToAlgorithms"
+    }),
   SOME(STRING_DESC_OPTION({
     ("removeSimpleEquations", removeSimpleEquationDesc),
     ("removeAllSimpleEquations", removeSimpleEquationDesc),
@@ -542,7 +543,9 @@ constant ConfigFlag PRE_OPT_MODULES = CONFIG_FLAG(12, "preOptModules",
     ("expandDerOperator", Util.notrans("DESCRIBE ME")),
     ("simplifyIfEquations", Util.gettext("Tries to simplify if equations by use of information from evaluated parameters.")),
     ("replaceEdgeChange", Util.gettext("Replace edge(b) = b and not pre(b) and change(b) = v <> pre(v).")),
-    ("residualForm", Util.gettext("Transforms simple equations x=y to zero-sum equations 0=y-x."))})),
+    ("residualForm", Util.gettext("Transforms simple equations x=y to zero-sum equations 0=y-x.")),
+    ("addInitialStmtsToAlgorithms", Util.gettext("Expands all algorithms with initial statements for outputs."))
+    })),
   Util.gettext("Sets the pre optimization modules to use in the back end. See +help=optmodules for more info."));
 
 constant ConfigFlag CHEAPMATCHING_ALGORITHM = CONFIG_FLAG(13, "cheapmatchingAlgorithm",
@@ -596,11 +599,11 @@ constant ConfigFlag POST_OPT_MODULES = CONFIG_FLAG(16, "postOptModules",
     "removeUnusedFunctions",
     "inputDerivativesUsed",
     "detectJacobianSparsePattern",
-//    "generateSymbolicJacobian",
+    // "generateSymbolicJacobian",
     "removeConstants"
-//    "partitionIndependentBlocks",
-//    "addInitialStmtsToAlgorithms"
-  }),
+    // "partitionIndependentBlocks",
+    // "addInitialStmtsToAlgorithms"
+    }),
   SOME(STRING_DESC_OPTION({
     ("encapsulateWhenConditions", Util.gettext("Replace each when-condition with an discrete variable.")),
     ("lateInlineFunction", Util.gettext("Perform function inlining for function with annotation LateInline=true.")),
diff --git a/SimulationRuntime/c/simulation/simulation_runtime.cpp b/SimulationRuntime/c/simulation/simulation_runtime.cpp
index 1864631bb44..a2c93e4674b 100644
--- a/SimulationRuntime/c/simulation/simulation_runtime.cpp
+++ b/SimulationRuntime/c/simulation/simulation_runtime.cpp
@@ -644,83 +644,45 @@ int callSolver(DATA* simData, string result_file_cstr, string init_initMethod,
     string init_optiMethod, string init_file, double init_time, int lambda_steps, string outputVariablesAtEnd, int cpuTime)
 {
   int retVal = -1;
+  long i;
+  long solverID = S_UNKNOWN;
   const char* outVars = (outputVariablesAtEnd.size() == 0) ? NULL : outputVariablesAtEnd.c_str();
 
   if (initializeResultData(simData, result_file_cstr, cpuTime))
     return -1;
 
-  if(simData->simulationInfo.solverMethod == std::string("")) {
-    INFO(LOG_SOLVER, " | No solver is set, using dassl.");
-    retVal = solver_main(simData, init_initMethod.c_str(), init_optiMethod.c_str(), init_file.c_str(), init_time, lambda_steps, 3, outVars);
-  } else if(simData->simulationInfo.solverMethod == std::string("euler")) {
-    INFO1(LOG_SOLVER, " | Recognized solver: %s.", simData->simulationInfo.solverMethod);
-    retVal = solver_main(simData, init_initMethod.c_str(), init_optiMethod.c_str(), init_file.c_str(), init_time, lambda_steps, 1, outVars);
-  /*} else if(simData->simulationInfo.solverMethod == std::string("optimization")){
-    INFO1(LOG_SOLVER, " | Recognized solver: %s.", simData->simulationInfo.solverMethod);
-    retVal = solver_main(simData, init_initMethod.c_str(), init_optiMethod.c_str(), init_file.c_str(), init_time, lambda_steps, 5, outVars); */
-  } else if(simData->simulationInfo.solverMethod == std::string("rungekutta")) {
-    INFO1(LOG_SOLVER, " | Recognized solver: %s.", simData->simulationInfo.solverMethod);
-    retVal = solver_main(simData, init_initMethod.c_str(), init_optiMethod.c_str(), init_file.c_str(), init_time, lambda_steps, 2, outVars);
-#ifdef WITH_SUNDIALS
-  } else if(simData->simulationInfo.solverMethod == std::string("radau5")) {
-    INFO1(LOG_SOLVER, " | Recognized solver: %s.", simData->simulationInfo.solverMethod);
-    retVal = solver_main(simData, init_initMethod.c_str(), init_optiMethod.c_str(), init_file.c_str(), init_time, lambda_steps, 6, outVars);
-  } else if(simData->simulationInfo.solverMethod == std::string("radau3")) {
-    INFO1(LOG_SOLVER, " | Recognized solver: %s.", simData->simulationInfo.solverMethod);
-    retVal = solver_main(simData, init_initMethod.c_str(), init_optiMethod.c_str(), init_file.c_str(), init_time, lambda_steps, 7, outVars);
-  } else if(simData->simulationInfo.solverMethod == std::string("radau1")) {
-    INFO1(LOG_SOLVER, " | Recognized solver: %s.", simData->simulationInfo.solverMethod);
-    retVal = solver_main(simData, init_initMethod.c_str(), init_optiMethod.c_str(), init_file.c_str(), init_time, lambda_steps, 8, outVars);
-  } else if(simData->simulationInfo.solverMethod == std::string("lobatto2")) {
-    INFO1(LOG_SOLVER, " | Recognized solver: %s.", simData->simulationInfo.solverMethod);
-    retVal = solver_main(simData, init_initMethod.c_str(), init_optiMethod.c_str(), init_file.c_str(), init_time, lambda_steps, 9, outVars);
-  } else if(simData->simulationInfo.solverMethod == std::string("lobatto4")) {
-    INFO1(LOG_SOLVER, " | Recognized solver: %s.", simData->simulationInfo.solverMethod);
-    retVal = solver_main(simData, init_initMethod.c_str(), init_optiMethod.c_str(), init_file.c_str(), init_time, lambda_steps, 10, outVars);
-  } else if(simData->simulationInfo.solverMethod == std::string("lobatto6")) {
-    INFO1(LOG_SOLVER, " | Recognized solver: %s.", simData->simulationInfo.solverMethod);
-    retVal = solver_main(simData, init_initMethod.c_str(), init_optiMethod.c_str(), init_file.c_str(), init_time, lambda_steps, 11, outVars);
-#endif
-  } else if(simData->simulationInfo.solverMethod == std::string("dassl") ||
-              simData->simulationInfo.solverMethod == std::string("dasslwort")  ||
-              simData->simulationInfo.solverMethod == std::string("dassltest")  ||
-              simData->simulationInfo.solverMethod == std::string("dasslSymJac") ||
-              simData->simulationInfo.solverMethod == std::string("dasslNumJac") ||
-              simData->simulationInfo.solverMethod == std::string("dasslColorSymJac") ||
-              simData->simulationInfo.solverMethod == std::string("dasslInternalNumJac")) {
-
-    INFO1(LOG_SOLVER, " | Recognized solver: %s.", simData->simulationInfo.solverMethod);
-    retVal = solver_main(simData, init_initMethod.c_str(), init_optiMethod.c_str(), init_file.c_str(), init_time, lambda_steps, 3, outVars);
-  } else if(simData->simulationInfo.solverMethod == std::string("inline-euler")) {
-    if(!_omc_force_solver || std::string(_omc_force_solver) != std::string("inline-euler")) {
-      INFO1(LOG_SOLVER, " | Recognized solver: %s, but the executable was not compiled with support for it. Compile with -D_OMC_INLINE_EULER.", simData->simulationInfo.solverMethod);
-      retVal = 1;
-    } else {
-      INFO1(LOG_SOLVER, " | Recognized solver: %s.", simData->simulationInfo.solverMethod);
-      retVal = solver_main(simData, init_initMethod.c_str(), init_optiMethod.c_str(), init_file.c_str(), init_time, lambda_steps, 4, outVars);
-    }
-  } else if(simData->simulationInfo.solverMethod == std::string("inline-rungekutta")) {
-    if(!_omc_force_solver || std::string(_omc_force_solver) != std::string("inline-rungekutta")) {
-      INFO1(LOG_SOLVER, " | Recognized solver: %s, but the executable was not compiled with support for it. Compile with -D_OMC_INLINE_RK.", simData->simulationInfo.solverMethod);
-      retVal = 1;
-    } else {
-      INFO1(LOG_SOLVER, " | Recognized solver: %s.", simData->simulationInfo.solverMethod);
-      retVal = solver_main(simData, init_initMethod.c_str(), init_optiMethod.c_str(), init_file.c_str(), init_time, lambda_steps, 4, outVars);
-    }
+  if(std::string("") == simData->simulationInfo.solverMethod)
+    solverID = S_DASSL;
+  else
+  {
+    for(i=1; i<S_MAX; ++i)
+      if(std::string(SOLVER_METHOD_NAME[i]) == simData->simulationInfo.solverMethod)
+        solverID = i;
+  }
+  
+  if(S_UNKNOWN == solverID)
+  {
+    WARNING1(LOG_STDOUT, "unrecognized option -s %s", simData->simulationInfo.solverMethod);
+    WARNING(LOG_STDOUT, "current options are:");
+    for(i=1; i<S_MAX; ++i)
+      WARNING2(LOG_STDOUT, "| %-18s [%s]", SOLVER_METHOD_NAME[i], SOLVER_METHOD_DESC[i]);
+    THROW("see last warning");
+    retVal = 1;
+  }
+  else
+  {
+    INFO1(LOG_SOLVER, "recognized solver: %s", SOLVER_METHOD_NAME[solverID]);
+    /* special solvers */
 #ifdef _OMC_QSS_LIB
-  } else if(simData->simulationInfo.solverMethod == std::string("qss")) {
-    INFO1(LOG_SOLVER, " | Recognized solver: %s.", simData->simulationInfo.solverMethod);
-    retVal = qss_main(argc, argv, simData->simulationInfo.startTime,
-                      simData->simulationInfo.stopTime, simData->simulationInfo.stepSize,
-                      simData->simulationInfo.numSteps, simData->simulationInfo.tolerance, 3);
-#endif
-  } else {
-    INFO1(LOG_STDOUT, " | Unrecognized solver: %s.", simData->simulationInfo.solverMethod);
-    INFO(LOG_STDOUT, " | valid solvers are: dassl, euler, rungekutta, inline-euler, inline-rungekutta, dasslwort, dasslSymJac, dasslNumJac, dasslColorSymJac, dasslInternalNumJac, qss, radau1, radau3, radau5, lobatto2, lobatto4 or lobatto6");
-#ifndef WITH_SUNDIALS
-    INFO(LOG_STDOUT, " |note: radau1, radau3, radau5, lobatto2, lobatto4 and lobatto6 use (KINSOL/SUNDIALS)!!!");
+    if(S_QSS == solverID)
+    {
+      retVal = qss_main(argc, argv, simData->simulationInfo.startTime,
+                        simData->simulationInfo.stopTime, simData->simulationInfo.stepSize,
+                        simData->simulationInfo.numSteps, simData->simulationInfo.tolerance, 3);
+    }
+    else /* standard solver interface */
 #endif
-    retVal = 1;
+      retVal = solver_main(simData, init_initMethod.c_str(), init_optiMethod.c_str(), init_file.c_str(), init_time, lambda_steps, solverID, outVars);
   }
 
   sim_result.free(&sim_result, simData);
@@ -791,7 +753,8 @@ int initRuntimeAndSimulation(int argc, char**argv, DATA *data)
           break;
           
         case FLAG_S:
-          /* TODO */
+          for(j=1; j<S_MAX; ++j)
+            INFO2(LOG_STDOUT, "| %-18s [%s]", SOLVER_METHOD_NAME[j], SOLVER_METHOD_DESC[j]);
           break;
         }
         RELEASE(LOG_STDOUT);
diff --git a/SimulationRuntime/c/simulation/solver/solver_main.c b/SimulationRuntime/c/simulation/solver/solver_main.c
index 760143b5afe..a6d8c0e97cb 100644
--- a/SimulationRuntime/c/simulation/solver/solver_main.c
+++ b/SimulationRuntime/c/simulation/solver/solver_main.c
@@ -486,23 +486,55 @@ int finishSimulation(DATA* data, SOLVER_INFO* solverInfo, const char* outputVari
  *  \param [in]  [pInitFile] extra argument for initialization-method "file"
  *  \param [in]  [initTime] extra argument for initialization-method "file"
  *  \param [in]  [lambda_steps] ???
- *  \param [in]  [flag] selects the ode solver
+ *  \param [in]  [solverID] selects the ode solver
  *  \param [in]  [outputVariablesAtEnd] ???
  *
- *  This is the main function of the solver it perform
- *  the simulation.
- *
+ *  This is the main function of the solver it perform the simulation.
  */
 int solver_main(DATA* data, const char* init_initMethod,
     const char* init_optiMethod, const char* init_file, double init_time,
-    int lambda_steps, int flag, const char* outputVariablesAtEnd)
+    int lambda_steps, int solverID, const char* outputVariablesAtEnd)
 {
   int i, retVal = 0;
   unsigned int ui;
   SOLVER_INFO solverInfo;
   SIMULATION_INFO *simInfo = &(data->simulationInfo);
 
-  solverInfo.solverMethod = flag;
+  solverInfo.solverMethod = solverID;
+  
+  /* do some solver specific checks */
+  switch(solverInfo.solverMethod)
+  {
+  case S_DASSLWORT:
+  case S_DASSLTEST:
+  case S_DASSLSYMJAC:
+  case S_DASSLNUMJAC:
+  case S_DASSLCOLORSYMJAC:
+  case S_DASSLINTERNALNUMJAC:
+    solverInfo.solverMethod = S_DASSL;
+    break;
+    
+  case S_OPTIMIZATION:
+    WARNING(LOG_STDOUT, "not supported yet");
+    return 1;
+    
+  case S_INLINE_EULER:
+    if(!_omc_force_solver || strcmp(_omc_force_solver, "inline-euler"))
+    {
+      INFO(LOG_SOLVER, "Recognized solver: inline-euler, but the executable was not compiled with support for it. Compile with -D_OMC_INLINE_EULER.");
+      return 1;
+    }
+    break;
+    
+  case S_INLINE_RUNGEKUTTA:
+    if(!_omc_force_solver || strcmp(_omc_force_solver, "inline-rungekutta"))
+    {
+      INFO(LOG_SOLVER, "Recognized solver: inline-rungekutta, but the executable was not compiled with support for it. Compile with -D_OMC_INLINE_RK.");
+      return 1;
+    }
+    solverInfo.solverMethod = S_INLINE_EULER;
+    break;
+  }
 
   /* allocate SolverInfo memory */
   retVal = initializeSolverData(data, &solverInfo);
diff --git a/SimulationRuntime/c/simulation/solver/solver_main.h b/SimulationRuntime/c/simulation/solver/solver_main.h
index aeb52689b18..e10323b21cd 100644
--- a/SimulationRuntime/c/simulation/solver/solver_main.h
+++ b/SimulationRuntime/c/simulation/solver/solver_main.h
@@ -68,9 +68,81 @@ typedef struct SOLVER_INFO
   extern "C" {
 #endif
 
+  enum SOLVER_METHOD
+  {
+    S_UNKNOWN = 0,
+    
+    S_EULER,         /*  1 */
+    S_RUNGEKUTTA,    /*  2 */
+    S_DASSL,         /*  3 */
+    S_INLINE_EULER,  /*  4 */
+    S_OPTIMIZATION,  /*  5 */
+    S_RADAU5,        /*  6 */
+    S_RADAU3,        /*  7 */
+    S_RADAU1,        /*  8 */
+    S_LOBATTO2,      /*  9 */
+    S_LOBATTO4,      /* 10 */
+    S_LOBATTO6,      /* 11 */
+    S_DASSLWORT,
+    S_DASSLTEST,
+    S_DASSLSYMJAC,
+    S_DASSLNUMJAC,
+    S_DASSLCOLORSYMJAC,
+    S_DASSLINTERNALNUMJAC,
+    S_INLINE_RUNGEKUTTA,
+    S_QSS,
+    
+    S_MAX
+  };
+
+  static const char *SOLVER_METHOD_NAME[S_MAX] = {
+    "unknown",
+    "euler",
+    "rungekutta",
+    "dassl",
+    "inline-euler",
+    "optimization",
+    "radau5",
+    "radau3",
+    "radau1",
+    "lobatto2",
+    "lobatto4",
+    "lobatto6",
+    "dasslwort",
+    "dassltest",
+    "dasslSymJac",
+    "dasslNumJac",
+    "dasslColorSymJac",
+    "dasslInternalNumJac",
+    "inline-rungekutta",
+    "qss"
+  };
+  static const char *SOLVER_METHOD_DESC[S_MAX] = {
+    "unknown",
+    "euler",
+    "rungekutta",
+    "dassl with colored numerical jacobian, with interval root finding - default",
+    "inline-euler",
+    "optimization",
+    "radau5 [sundial/kinsol needed]",
+    "radau3 [sundial/kinsol needed]",
+    "radau1 [sundial/kinsol needed]",
+    "lobatto2 [sundial/kinsol needed]",
+    "lobatto4 [sundial/kinsol needed]",
+    "lobatto6 [sundial/kinsol needed]",
+    "dassl without internal root finding",
+    "dassl for debug propose",
+    "dassl with symbolic jacobian",
+    "dassl with numerical jacobian",
+    "dassl with colored symbolic jacobian",
+    "dassl with internal numerical jacobian",
+    "inline-rungekutta",
+    "qss"
+  };
+
 extern int solver_main(DATA* data, const char* init_initMethod,
     const char* init_optiMethod, const char* init_file, double init_time,
-    int lambda_steps, int flag, const char* outputVariablesAtEnd);
+    int lambda_steps, int solverID, const char* outputVariablesAtEnd);
 
 /* Provide solver interface to interactive stuff */
 extern int initializeSolverData(DATA* data, SOLVER_INFO* solverInfo);