diff --git a/src/storm-pars-cli/storm-pars.cpp b/src/storm-pars-cli/storm-pars.cpp
index 8546f81d1..ff7c075f8 100644
--- a/src/storm-pars-cli/storm-pars.cpp
+++ b/src/storm-pars-cli/storm-pars.cpp
@@ -41,6 +41,69 @@ namespace storm {
             return result;
         }
         
+        template <typename ValueType>
+        std::map<typename utility::parametric::VariableType<ValueType>::type, std::vector<typename utility::parametric::CoefficientType<ValueType>::type>> parseSamples(std::shared_ptr<storm::models::ModelBase> const& model, std::string const& sampleString) {
+            STORM_LOG_THROW(model->isSparseModel(), storm::exceptions::NotSupportedException, "Sampling is only supported for sparse models.");
+
+            std::map<typename utility::parametric::VariableType<ValueType>::type, std::vector<typename utility::parametric::CoefficientType<ValueType>::type>> samplesForVariables;
+            if (sampleString.empty()) {
+                return samplesForVariables;
+            }
+            
+            // Get all parameters from the model.
+            std::set<typename utility::parametric::VariableType<ValueType>::type> modelParameters;
+            auto const& sparseModel = *model->as<storm::models::sparse::Model<ValueType>>();
+            modelParameters = storm::models::sparse::getProbabilityParameters(sparseModel);
+            auto rewParameters = storm::models::sparse::getRewardParameters(sparseModel);
+            modelParameters.insert(rewParameters.begin(), rewParameters.end());
+            
+            // Get the values string for each variable.
+            std::vector<std::string> valuesForVariables;
+            boost::split(valuesForVariables, sampleString, boost::is_any_of(","));
+            for (auto& values : valuesForVariables) {
+                boost::trim(values);
+            }
+            
+            std::set<typename utility::parametric::VariableType<ValueType>::type> encounteredParameters;
+            for (auto const& varValues : valuesForVariables) {
+                auto equalsPosition = varValues.find("=");
+                STORM_LOG_THROW(equalsPosition != varValues.npos, storm::exceptions::WrongFormatException, "Incorrect format of samples.");
+                std::string variableName = varValues.substr(0, equalsPosition);
+                boost::trim(variableName);
+                std::string values = varValues.substr(equalsPosition + 1);
+                boost::trim(values);
+                
+                bool foundParameter = false;
+                typename utility::parametric::VariableType<ValueType>::type theParameter;
+                for (auto const& parameter : modelParameters) {
+                    std::stringstream parameterStream;
+                    parameterStream << parameter;
+                    std::cout << parameterStream.str() << " vs " << variableName << std::endl;
+                    if (parameterStream.str() == variableName) {
+                        foundParameter = true;
+                        theParameter = parameter;
+                        encounteredParameters.insert(parameter);
+                    }
+                }
+                STORM_LOG_THROW(foundParameter, storm::exceptions::WrongFormatException, "Unknown parameter '" << variableName << "'.");
+                
+                std::vector<std::string> splitValues;
+                boost::split(splitValues, values, boost::is_any_of(":"));
+                STORM_LOG_THROW(!splitValues.empty(), storm::exceptions::WrongFormatException, "Expecting at least one value per parameter.");
+                
+                auto& list = samplesForVariables[theParameter];
+                for (auto& value : splitValues) {
+                    boost::trim(value);
+                    
+                    list.push_back(storm::utility::convertNumber<typename utility::parametric::CoefficientType<ValueType>::type>(value));
+                }
+            }
+            
+            STORM_LOG_THROW(encounteredParameters == modelParameters, storm::exceptions::WrongFormatException, "Variables for all parameters are required when providing samples.")
+            
+            return samplesForVariables;
+        }
+        
         template <typename ValueType>
         std::pair<std::shared_ptr<storm::models::ModelBase>, bool> preprocessSparseModel(std::shared_ptr<storm::models::sparse::Model<ValueType>> const& model, SymbolicInput const& input) {
             auto generalSettings = storm::settings::getModule<storm::settings::modules::GeneralSettings>();
@@ -152,23 +215,65 @@ namespace storm {
         }
         
         template <typename ValueType>
-        void verifyPropertiesWithSparseEngine(std::shared_ptr<storm::models::sparse::Model<ValueType>> const& model, SymbolicInput const& input) {
-            verifyProperties<ValueType>(input.properties,
-                                        [&model] (std::shared_ptr<storm::logic::Formula const> const& formula) {
-                                            std::unique_ptr<storm::modelchecker::CheckResult> result = storm::api::verifyWithSparseEngine<ValueType>(model, storm::api::createTask<ValueType>(formula, true));
-                                            if (result) {
-                                                result->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
-                                            }
-                                            return result;
-                                        },
-                                        [&model] (std::unique_ptr<storm::modelchecker::CheckResult> const& result) {
-                                            auto parametricSettings = storm::settings::getModule<storm::settings::modules::ParametricSettings>();
-                                            if (parametricSettings.exportResultToFile() && model->isOfType(storm::models::ModelType::Dtmc)) {
-                                                auto dtmc = model->template as<storm::models::sparse::Dtmc<ValueType>>();
-												boost::optional<ValueType> rationalFunction = result->asExplicitQuantitativeCheckResult<ValueType>()[*model->getInitialStates().begin()];
-                                                storm::api::exportParametricResultToFile(rationalFunction, storm::analysis::ConstraintCollector<ValueType>(*dtmc), parametricSettings.exportResultPath());
-                                            }
-                                        });
+        void verifyPropertiesWithSparseEngine(std::shared_ptr<storm::models::sparse::Model<ValueType>> const& model, SymbolicInput const& input, std::map<typename utility::parametric::VariableType<ValueType>::type, std::vector<typename utility::parametric::CoefficientType<ValueType>::type>> const& samples) {
+            
+            if (samples.empty()) {
+                verifyProperties<ValueType>(input.properties,
+                                            [&model] (std::shared_ptr<storm::logic::Formula const> const& formula) {
+                                                std::unique_ptr<storm::modelchecker::CheckResult> result = storm::api::verifyWithSparseEngine<ValueType>(model, storm::api::createTask<ValueType>(formula, true));
+                                                if (result) {
+                                                    result->filter(storm::modelchecker::ExplicitQualitativeCheckResult(model->getInitialStates()));
+                                                }
+                                                return result;
+                                            },
+                                            [&model] (std::unique_ptr<storm::modelchecker::CheckResult> const& result) {
+                                                auto parametricSettings = storm::settings::getModule<storm::settings::modules::ParametricSettings>();
+                                                if (parametricSettings.exportResultToFile() && model->isOfType(storm::models::ModelType::Dtmc)) {
+                                                    auto dtmc = model->template as<storm::models::sparse::Dtmc<ValueType>>();
+                                                    boost::optional<ValueType> rationalFunction = result->asExplicitQuantitativeCheckResult<ValueType>()[*model->getInitialStates().begin()];
+                                                    storm::api::exportParametricResultToFile(rationalFunction, storm::analysis::ConstraintCollector<ValueType>(*dtmc), parametricSettings.exportResultPath());
+                                                }
+                                            });
+            } else {
+                STORM_LOG_THROW(model->isOfType(storm::models::ModelType::Dtmc), storm::exceptions::NotSupportedException, "Sampling is currently only supported for DTMCs.");
+                
+                // When samples are provided, we create an instantiation model checker.
+                std::unique_ptr<storm::modelchecker::SparseDtmcInstantiationModelChecker<storm::models::sparse::Dtmc<ValueType>, double>> modelchecker(*model->template as<storm::models::sparse::Dtmc<ValueType>>());
+                
+                for (auto const& property : input.properties) {
+                    storm::cli::printModelCheckingProperty(property);
+
+                    modelchecker->specifyFormula(property.getRawFormula(storm::api::createTask<ValueType>(property.getRawFormula(), true)));
+                    
+                    // TODO: check.
+                    modelchecker->setInstantiationsAreGraphPreserving(true);
+                    
+                    storm::utility::parametric::Valuation<ValueType> valuation;
+
+                    // Enumerate all sample points.
+                    for () {
+                        bool first = true;
+                        std::stringstream ss;
+                        ss << "Treating instance [";
+                        for (auto const& entry : valuation) {
+                            if (!first) {
+                                ss << ", ";
+                            } else {
+                                first = false;
+                            }
+                            ss << entry.first << ": " << entry.second;
+                        }
+                        ss << "]...";
+                        STORM_PRINT_AND_LOG(ss.str());
+                        
+                        storm::utility::Stopwatch watch(true);
+                        std::unique_ptr<storm::modelchecker::CheckResult> result = modelchecker->check(Environment(), valuation);
+                        watch.stop();
+
+                        printInitialStatesResult<ValueType>(result, property, &watch);
+                    }
+                }
+            }
         }
         
         template <typename ValueType>
@@ -226,18 +331,18 @@ namespace storm {
         }
         
         template <typename ValueType>
-        void verifyWithSparseEngine(std::shared_ptr<storm::models::sparse::Model<ValueType>> const& model, SymbolicInput const& input, std::vector<storm::storage::ParameterRegion<ValueType>> const& regions) {
+        void verifyWithSparseEngine(std::shared_ptr<storm::models::sparse::Model<ValueType>> const& model, SymbolicInput const& input, std::vector<storm::storage::ParameterRegion<ValueType>> const& regions, std::map<typename utility::parametric::VariableType<ValueType>::type, std::vector<typename utility::parametric::CoefficientType<ValueType>::type>> const& samples) {
             if (regions.empty()) {
-                storm::pars::verifyPropertiesWithSparseEngine(model, input);
+                storm::pars::verifyPropertiesWithSparseEngine(model, input, samples);
             } else {
                 storm::pars::verifyRegionsWithSparseEngine(model, input, regions);
             }
         }
         
         template <storm::dd::DdType DdType, typename ValueType>
-        void verifyParametricModel(std::shared_ptr<storm::models::ModelBase> const& model, SymbolicInput const& input, std::vector<storm::storage::ParameterRegion<ValueType>> const& regions) {
+        void verifyParametricModel(std::shared_ptr<storm::models::ModelBase> const& model, SymbolicInput const& input, std::vector<storm::storage::ParameterRegion<ValueType>> const& regions, std::map<typename utility::parametric::VariableType<ValueType>::type, std::vector<typename utility::parametric::CoefficientType<ValueType>::type>> const& samples) {
             STORM_LOG_ASSERT(model->isSparseModel(), "Unexpected model type.");
-            storm::pars::verifyWithSparseEngine<ValueType>(model->as<storm::models::sparse::Model<ValueType>>(), input, regions);
+            storm::pars::verifyWithSparseEngine<ValueType>(model->as<storm::models::sparse::Model<ValueType>>(), input, regions, samples);
         }
         
         template <storm::dd::DdType DdType, typename ValueType>
@@ -271,9 +376,8 @@ namespace storm {
             }
             
             std::vector<storm::storage::ParameterRegion<ValueType>> regions = parseRegions<ValueType>(model);
-
-
-
+            std::map<typename utility::parametric::VariableType<ValueType>::type, std::vector<typename utility::parametric::CoefficientType<ValueType>::type>> samples = parseSamples<ValueType>(model, parSettings.getSamples());
+            
             if (model) {
                 storm::cli::exportModel<DdType, ValueType>(model, input);
             }
@@ -285,7 +389,7 @@ namespace storm {
             }
 
             if (model) {
-                verifyParametricModel<DdType, ValueType>(model, input, regions);
+                verifyParametricModel<DdType, ValueType>(model, input, regions, samples);
             }
         }
         
diff --git a/src/storm-pars/settings/modules/ParametricSettings.cpp b/src/storm-pars/settings/modules/ParametricSettings.cpp
index 28975aa5c..a02851dac 100644
--- a/src/storm-pars/settings/modules/ParametricSettings.cpp
+++ b/src/storm-pars/settings/modules/ParametricSettings.cpp
@@ -18,6 +18,7 @@ namespace storm {
             const std::string ParametricSettings::transformContinuousOptionName = "transformcontinuous";
             const std::string ParametricSettings::transformContinuousShortOptionName = "tc";
             const std::string ParametricSettings::onlyWellformednessConstraintsOptionName = "onlyconstraints";
+            const std::string ParametricSettings::samplesOptionName = "samples";
             
             ParametricSettings::ParametricSettings() : ModuleSettings(moduleName) {
                 this->addOption(storm::settings::OptionBuilder(moduleName, exportResultOptionName, false, "A path to a file where the parametric result should be saved.")
@@ -25,6 +26,8 @@ namespace storm {
                 this->addOption(storm::settings::OptionBuilder(moduleName, derivativesOptionName, false, "Sets whether to generate the derivatives of the resulting rational function.").build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, transformContinuousOptionName, false, "Sets whether to transform a continuous time input model to a discrete time model.").setShortName(transformContinuousShortOptionName).build());
                 this->addOption(storm::settings::OptionBuilder(moduleName, onlyWellformednessConstraintsOptionName, false, "Sets whether you only want to obtain the wellformedness constraints").build());
+                this->addOption(storm::settings::OptionBuilder(moduleName, samplesOptionName, false, "The points at which to sample the model.")
+                                .addArgument(storm::settings::ArgumentBuilder::createStringArgument("samples", "The samples given in the form 'Var1=Val1:Val2:...:Valk,Var2=...").setDefaultValueString("").build()).build());
             }
             
             bool ParametricSettings::exportResultToFile() const {
@@ -46,7 +49,11 @@ namespace storm {
             bool ParametricSettings::onlyObtainConstraints() const {
                 return this->getOption(onlyWellformednessConstraintsOptionName).getHasOptionBeenSet();
             }
-
+            
+            std::string ParametricSettings::getSamples() const {
+                return this->getOption(samplesOptionName).getArgumentByName("samples").getValueAsString();
+            }
+            
         } // namespace modules
     } // namespace settings
 } // namespace storm
diff --git a/src/storm-pars/settings/modules/ParametricSettings.h b/src/storm-pars/settings/modules/ParametricSettings.h
index e610f033d..195b0936c 100644
--- a/src/storm-pars/settings/modules/ParametricSettings.h
+++ b/src/storm-pars/settings/modules/ParametricSettings.h
@@ -47,6 +47,13 @@ namespace storm {
                  */
                 bool onlyObtainConstraints() const;
 				
+                /*!
+                 * Retrieves the samples as a comma-separated list of samples for each (relevant) variable, where the
+                 * samples are colon-separated values. For example, 'N=1:2:3,K=2:4' means that N takes the values 1 to
+                 * 3 and K either 2 or 4.
+                 */
+                std::string getSamples() const;
+                
                 const static std::string moduleName;
                 
             private:
@@ -55,6 +62,7 @@ namespace storm {
                 const static std::string transformContinuousOptionName;
                 const static std::string transformContinuousShortOptionName;
                 const static std::string onlyWellformednessConstraintsOptionName;
+                const static std::string samplesOptionName;
             };
             
         } // namespace modules