Index: branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Datastructures/IntegerParameterConfiguration.cs
===================================================================
--- branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Datastructures/IntegerParameterConfiguration.cs	(revision 10856)
+++ branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Datastructures/IntegerParameterConfiguration.cs	(revision 11363)
@@ -74,5 +74,5 @@
       if (min.Count != max.Count) throw new ArgumentException("min must be of the same length as max", "min");
       if (step != null && min.Count != step.Count) throw new ArgumentException("step must be of the same length as min or null", "step");
-      if (min.Zip(max, (mi, ma) => mi >= ma).Any()) throw new ArgumentException("min must be less than max in each dimension", "min");
+      if (min.Zip(max, (mi, ma) => mi >= ma).Any(x => x)) throw new ArgumentException("min must be less than max in each dimension", "min");
       this.length = new IntValue(length);
       bounds = new IntMatrix(min.Count, step != null ? 3 : 2);
Index: branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Datastructures/ParameterVector.cs
===================================================================
--- branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Datastructures/ParameterVector.cs	(revision 10856)
+++ branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Datastructures/ParameterVector.cs	(revision 11363)
@@ -22,4 +22,5 @@
 using System.Collections.Generic;
 using System.Linq;
+using HeuristicLab.Common;
 using HeuristicLab.Encodings.BinaryVectorEncoding;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
@@ -28,9 +29,9 @@
 
 namespace HeuristicLab.Problems.Programmable {
-  public class ParameterVector {
-    protected Dictionary<string, BinaryVector> BinaryParameters;
-    protected Dictionary<string, IntegerVector> IntegerParameters;
-    protected Dictionary<string, RealVector> RealParameters;
-    protected Dictionary<string, Permutation> PermutationParameters;
+  public sealed class ParameterVector : IDeepCloneable {
+    private Dictionary<string, BinaryVector> BinaryParameters;
+    private Dictionary<string, IntegerVector> IntegerParameters;
+    private Dictionary<string, RealVector> RealParameters;
+    private Dictionary<string, Permutation> PermutationParameters;
 
     public ParameterVector(IEnumerable<KeyValuePair<string, BinaryVector>> binaryVectors = null,
@@ -42,4 +43,35 @@
       if (realVectors != null) RealParameters = realVectors.ToDictionary(x => x.Key, x => x.Value);
       if (permutations != null) PermutationParameters = permutations.ToDictionary(x => x.Key, x => x.Value);
+    }
+    private ParameterVector(ParameterVector original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      if (original.BinaryParameters != null) {
+        BinaryParameters = new Dictionary<string, BinaryVector>(original.BinaryParameters.Comparer);
+        foreach (var param in original.BinaryParameters)
+          BinaryParameters[param.Key] = cloner.Clone(param.Value);
+      }
+      if (original.IntegerParameters != null) {
+        IntegerParameters = new Dictionary<string, IntegerVector>(original.IntegerParameters.Comparer);
+        foreach (var param in original.IntegerParameters)
+          IntegerParameters[param.Key] = cloner.Clone(param.Value);
+      }
+      if (original.RealParameters != null) {
+        RealParameters = new Dictionary<string, RealVector>(original.RealParameters.Comparer);
+        foreach (var param in original.RealParameters)
+          RealParameters[param.Key] = cloner.Clone(param.Value);
+      }
+      if (original.PermutationParameters != null) {
+        PermutationParameters = new Dictionary<string, Permutation>(original.PermutationParameters.Comparer);
+        foreach (var param in original.PermutationParameters)
+          PermutationParameters[param.Key] = cloner.Clone(param.Value);
+      }
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+
+    public IDeepCloneable Clone(Cloner cloner) {
+      return new ParameterVector(this, cloner);
     }
 
@@ -53,5 +85,5 @@
 
     public IEnumerable<string> BinaryNames {
-      get { return BinaryParameters.Keys; }
+      get { return BinaryParameters != null ? BinaryParameters.Keys : Enumerable.Empty<string>(); }
     }
 
@@ -65,5 +97,5 @@
 
     public IEnumerable<string> IntegerNames {
-      get { return IntegerParameters.Keys; }
+      get { return IntegerParameters != null ? IntegerParameters.Keys : Enumerable.Empty<string>(); }
     }
 
@@ -77,5 +109,5 @@
 
     public IEnumerable<string> RealNames {
-      get { return RealParameters.Keys; }
+      get { return RealParameters != null ? RealParameters.Keys : Enumerable.Empty<string>(); }
     }
 
@@ -85,5 +117,5 @@
 
     public IEnumerable<string> PermutationNames {
-      get { return PermutationParameters.Keys; }
+      get { return PermutationParameters != null ? PermutationParameters.Keys : Enumerable.Empty<string>(); }
     }
   }
Index: branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Datastructures/RealParameterConfiguration.cs
===================================================================
--- branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Datastructures/RealParameterConfiguration.cs	(revision 10856)
+++ branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Datastructures/RealParameterConfiguration.cs	(revision 11363)
@@ -71,5 +71,5 @@
       if (min.Count == 0) throw new ArgumentException("Bounds must be given for the real parameters.");
       if (min.Count != max.Count) throw new ArgumentException("min must be of the same length as max", "min");
-      if (min.Zip(max, (mi, ma) => mi >= ma).Any()) throw new ArgumentException("min must be less than max in each dimension", "min");
+      if (min.Zip(max, (mi, ma) => mi >= ma).Any(x => x)) throw new ArgumentException("min must be less than max in each dimension", "min");
       this.length = new IntValue(length);
       bounds = new DoubleMatrix(min.Count, 2);
Index: branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj
===================================================================
--- branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj	(revision 10856)
+++ branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/HeuristicLab.Problems.Programmable-3.3.csproj	(revision 11363)
@@ -121,9 +121,4 @@
       <Private>False</Private>
     </Reference>
-    <Reference Include="SimSharp, Version=3.0.3.0, Culture=neutral, PublicKeyToken=4222a9c6c8b27052, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\..\trunk\sources\bin\SimSharp.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -143,7 +138,11 @@
     <Compile Include="Datastructures\ParameterConfiguration.cs" />
     <Compile Include="Datastructures\ParameterVector.cs" />
+    <Compile Include="Interfaces\IParameterVectorMoveOperator.cs" />
     <Compile Include="Interfaces\ISingleObjectiveProgrammableProblemEvaluator.cs" />
     <Compile Include="Operators\ParameterVectorManipulator.cs" />
     <Compile Include="Operators\ParameterVectorCrossover.cs" />
+    <Compile Include="Operators\ParameterVectorMoveEvaluator.cs" />
+    <Compile Include="Operators\ParameterVectorMoveGenerator.cs" />
+    <Compile Include="Operators\ParameterVectorMoveMaker.cs" />
     <Compile Include="Operators\SingleObjectiveEvaluator.cs" />
     <Compile Include="Operators\ParameterVectorCreater.cs" />
Index: branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Interfaces/IParameterVectorMoveOperator.cs
===================================================================
--- branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Interfaces/IParameterVectorMoveOperator.cs	(revision 11363)
+++ branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Interfaces/IParameterVectorMoveOperator.cs	(revision 11363)
@@ -0,0 +1,6 @@
+﻿using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.Programmable {
+  public interface IParameterVectorMoveOperator : IMoveOperator {
+  }
+}
Index: branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProblemDefinition.cs
===================================================================
--- branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProblemDefinition.cs	(revision 10856)
+++ branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Interfaces/ISingleObjectiveProblemDefinition.cs	(revision 11363)
@@ -20,4 +20,5 @@
 #endregion
 
+using System.Collections.Generic;
 using HeuristicLab.Core;
 
@@ -26,4 +27,5 @@
     bool IsMaximizationProblem { get; }
     double Evaluate(IRandom random, ParameterVector vector);
+    IEnumerable<ParameterVector> GetNeighbors(IRandom random, ParameterVector vector);
   }
 }
Index: branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Operators/ParameterVectorMoveEvaluator.cs
===================================================================
--- branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Operators/ParameterVectorMoveEvaluator.cs	(revision 11363)
+++ branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Operators/ParameterVectorMoveEvaluator.cs	(revision 11363)
@@ -0,0 +1,117 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("ParameterVectorMoveEvaluator", "Evaluates a parameter vector that results from a move.")]
+  [StorableClass]
+  public class ParameterVectorMoveEvaluator : InstrumentedOperator, IParameterVectorMoveOperator, ISingleObjectiveMoveEvaluator, IStochasticOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public ILookupParameter<SingleObjectiveScript> ScriptParameter {
+      get { return (ILookupParameter<SingleObjectiveScript>)Parameters["Script"]; }
+    }
+
+    public ILookupParameter<Configuration> ConfigurationParameter {
+      get { return (ILookupParameter<Configuration>)Parameters["Configuration"]; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+
+    [StorableConstructor]
+    protected ParameterVectorMoveEvaluator(bool deserializing) : base(deserializing) { }
+    protected ParameterVectorMoveEvaluator(ParameterVectorMoveEvaluator original, Cloner cloner) : base(original, cloner) { }
+    public ParameterVectorMoveEvaluator() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new LookupParameter<SingleObjectiveScript>("Script", "The script that will execute the evaluation function and define the parameter vector."));
+      Parameters.Add(new LookupParameter<Configuration>("Configuration", "An item that holds the problem's configuration."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the parameter vector."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the move."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ParameterVectorMoveEvaluator(this, cloner);
+    }
+
+    public override IOperation InstrumentedApply() {
+      var random = RandomParameter.ActualValue;
+      var runner = ScriptParameter.ActualValue;
+      if (runner.Instance == null) throw new InvalidOperationException("Script instance is null, maybe the code doesn't compile.");
+      var config = ConfigurationParameter.ActualValue;
+      var binDict = new Dictionary<string, BinaryVector>();
+      var intDict = new Dictionary<string, IntegerVector>();
+      var realDict = new Dictionary<string, RealVector>();
+      var permDict = new Dictionary<string, Permutation>();
+      foreach (var param in config.Parameters) {
+        var binConfig = param.Value as BinaryParameterConfiguration;
+        if (binConfig != null) {
+          binDict.Add(param.Key, (BinaryVector)ExecutionContext.Scope.Variables[param.Key].Value);
+          continue;
+        }
+        var intConfig = param.Value as IntegerParameterConfiguration;
+        if (intConfig != null) {
+          intDict.Add(param.Key, (IntegerVector)ExecutionContext.Scope.Variables[param.Key].Value);
+          continue;
+        }
+        var realConfig = param.Value as RealParameterConfiguration;
+        if (realConfig != null) {
+          realDict.Add(param.Key, (RealVector)ExecutionContext.Scope.Variables[param.Key].Value);
+          continue;
+        }
+        var permConfig = param.Value as PermutationParameterConfiguration;
+        if (permConfig != null) {
+          permDict.Add(param.Key, (Permutation)ExecutionContext.Scope.Variables[param.Key].Value);
+          continue;
+        }
+        throw new InvalidOperationException("Parameter " + param.Key + " not found.");
+      }
+      var vector = new ParameterVector(
+        binaryVectors: binDict.Count > 0 ? binDict : null,
+        integerVectors: intDict.Count > 0 ? intDict : null,
+        realVectors: realDict.Count > 0 ? realDict : null,
+        permutations: permDict.Count > 0 ? permDict : null);
+      MoveQualityParameter.ActualValue = new DoubleValue(runner.Instance.Evaluate(random, vector));
+      return base.InstrumentedApply();
+    }
+  }
+}
Index: branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Operators/ParameterVectorMoveGenerator.cs
===================================================================
--- branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Operators/ParameterVectorMoveGenerator.cs	(revision 11363)
+++ branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Operators/ParameterVectorMoveGenerator.cs	(revision 11363)
@@ -0,0 +1,133 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("ParameterVectorMoveGenerator", "Calls the GetNeighbors method of the programmable definition to obtain the moves.")]
+  [StorableClass]
+  public class ParameterVectorMoveGenerator : InstrumentedOperator, IParameterVectorMoveOperator, IMultiMoveGenerator, IStochasticOperator {
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public IValueLookupParameter<IntValue> SampleSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SampleSize"]; }
+    }
+
+    public ILookupParameter<SingleObjectiveScript> ScriptParameter {
+      get { return (ILookupParameter<SingleObjectiveScript>)Parameters["Script"]; }
+    }
+
+    public ILookupParameter<Configuration> ConfigurationParameter {
+      get { return (ILookupParameter<Configuration>)Parameters["Configuration"]; }
+    }
+
+    [StorableConstructor]
+    protected ParameterVectorMoveGenerator(bool deserializing) : base(deserializing) { }
+    protected ParameterVectorMoveGenerator(ParameterVectorMoveGenerator original, Cloner cloner)
+      : base(original, cloner) { }
+    public ParameterVectorMoveGenerator() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SampleSize", "The number of moves to sample."));
+      Parameters.Add(new LookupParameter<SingleObjectiveScript>("Script", "The script that will execute the evaluation function and define the parameter vector."));
+      Parameters.Add(new LookupParameter<Configuration>("Configuration", "An item that holds the problem's configuration."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ParameterVectorMoveGenerator(this, cloner);
+    }
+
+    public override IOperation InstrumentedApply() {
+      var random = RandomParameter.ActualValue;
+      var runner = ScriptParameter.ActualValue;
+      if (runner.Instance == null) throw new InvalidOperationException("Script instance is null, maybe the code doesn't compile.");
+      var sampleSize = SampleSizeParameter.ActualValue.Value;
+      var config = ConfigurationParameter.ActualValue;
+      var binDict = new Dictionary<string, BinaryVector>();
+      var intDict = new Dictionary<string, IntegerVector>();
+      var realDict = new Dictionary<string, RealVector>();
+      var permDict = new Dictionary<string, Permutation>();
+      foreach (var param in config.Parameters) {
+        var binConfig = param.Value as BinaryParameterConfiguration;
+        if (binConfig != null) {
+          binDict.Add(param.Key, (BinaryVector)ExecutionContext.Scope.Variables[param.Key].Value);
+          continue;
+        }
+        var intConfig = param.Value as IntegerParameterConfiguration;
+        if (intConfig != null) {
+          intDict.Add(param.Key, (IntegerVector)ExecutionContext.Scope.Variables[param.Key].Value);
+          continue;
+        }
+        var realConfig = param.Value as RealParameterConfiguration;
+        if (realConfig != null) {
+          realDict.Add(param.Key, (RealVector)ExecutionContext.Scope.Variables[param.Key].Value);
+          continue;
+        }
+        var permConfig = param.Value as PermutationParameterConfiguration;
+        if (permConfig != null) {
+          permDict.Add(param.Key, (Permutation)ExecutionContext.Scope.Variables[param.Key].Value);
+          continue;
+        }
+        throw new InvalidOperationException("Parameter " + param.Key + " not found.");
+      }
+      var vector = new ParameterVector(
+        binaryVectors: binDict.Count > 0 ? binDict : null,
+        integerVectors: intDict.Count > 0 ? intDict : null,
+        realVectors: realDict.Count > 0 ? realDict : null,
+        permutations: permDict.Count > 0 ? permDict : null);
+      var nbhood = runner.Instance.GetNeighbors(random, vector).Take(sampleSize).ToList();
+
+      var moveScopes = new Scope[nbhood.Count];
+      for (int i = 0; i < moveScopes.Length; i++) {
+        moveScopes[i] = new Scope(i.ToString());
+        foreach (var param in nbhood[i].BinaryNames)
+          moveScopes[i].Variables.Add(new Variable(param, nbhood[i].Binary(param)));
+
+        foreach (var param in nbhood[i].IntegerNames)
+          moveScopes[i].Variables.Add(new Variable(param, nbhood[i].Integer(param)));
+
+        foreach (var param in nbhood[i].RealNames)
+          moveScopes[i].Variables.Add(new Variable(param, nbhood[i].Real(param)));
+
+        foreach (var param in nbhood[i].PermutationNames)
+          moveScopes[i].Variables.Add(new Variable(param, nbhood[i].Permutation(param)));
+      }
+      ExecutionContext.Scope.SubScopes.AddRange(moveScopes);
+
+      return base.InstrumentedApply();
+    }
+  }
+}
Index: branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Operators/ParameterVectorMoveMaker.cs
===================================================================
--- branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Operators/ParameterVectorMoveMaker.cs	(revision 11363)
+++ branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Operators/ParameterVectorMoveMaker.cs	(revision 11363)
@@ -0,0 +1,85 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2014 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.Programmable {
+  [Item("ParameterVectorMoveMaker", "Applies a move.")]
+  [StorableClass]
+  public class ParameterVectorMoveMaker : InstrumentedOperator, IParameterVectorMoveOperator, IMoveMaker {
+    public ILookupParameter<Configuration> ConfigurationParameter {
+      get { return (ILookupParameter<Configuration>)Parameters["Configuration"]; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    public ILookupParameter<DoubleValue> MoveQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["MoveQuality"]; }
+    }
+
+    [StorableConstructor]
+    protected ParameterVectorMoveMaker(bool deserializing) : base(deserializing) { }
+    protected ParameterVectorMoveMaker(ParameterVectorMoveMaker original, Cloner cloner) : base(original, cloner) { }
+    public ParameterVectorMoveMaker() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new LookupParameter<SingleObjectiveScript>("Script", "The script that will execute the evaluation function and define the parameter vector."));
+      Parameters.Add(new LookupParameter<Configuration>("Configuration", "An item that holds the problem's configuration."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality of the parameter vector."));
+      Parameters.Add(new LookupParameter<DoubleValue>("MoveQuality", "The quality of the move."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ParameterVectorMoveMaker(this, cloner);
+    }
+
+    public override IOperation InstrumentedApply() {
+      var config = ConfigurationParameter.ActualValue;
+      var name = config.Parameters.First().Key;
+
+      var scope = ExecutionContext.Scope.Parent;
+      while (!scope.Variables.ContainsKey(name)) {
+        if (scope.Parent == null) throw new InvalidOperationException("Scope with solution could not be found!");
+        scope = scope.Parent;
+      }
+
+      foreach (var param in config.Parameters) {
+        if (!scope.Variables.ContainsKey(param.Key) || !ExecutionContext.Scope.Variables.ContainsKey(param.Key))
+          throw new InvalidOperationException("Parameter " + param.Key + " not found.");
+        scope.Variables[param.Key].Value = ExecutionContext.Scope.Variables[param.Key].Value;
+      }
+
+      if (MoveQualityParameter.ActualValue == null) throw new InvalidOperationException("Move has not been evaluated!");
+      if (QualityParameter.ActualValue == null) QualityParameter.ActualValue = new DoubleValue(MoveQualityParameter.ActualValue.Value);
+      else QualityParameter.ActualValue.Value = MoveQualityParameter.ActualValue.Value;
+      return base.InstrumentedApply();
+    }
+  }
+}
Index: branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs
===================================================================
--- branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs	(revision 10856)
+++ branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveProgrammableProblem.cs	(revision 11363)
@@ -138,4 +138,5 @@
         UpdateMultiVectorEncodingOperators(solutionCreators, configuration);
       }
+      UpdateMoveOperators();
     }
 
@@ -597,4 +598,23 @@
     }
 
+    protected virtual void UpdateMoveOperators() {
+      Operators.RemoveAll(x => x is IParameterVectorMoveOperator);
+      var generator = new ParameterVectorMoveGenerator();
+      generator.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
+      generator.ScriptParameter.ActualName = ScriptParameter.Name;
+
+      var evaluator = new ParameterVectorMoveEvaluator();
+      evaluator.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
+      evaluator.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+      evaluator.ScriptParameter.ActualName = ScriptParameter.Name;
+
+      var maker = new ParameterVectorMoveMaker();
+      maker.ConfigurationParameter.ActualName = ConfigurationParameter.Name;
+      maker.MoveQualityParameter.ActualName = evaluator.MoveQualityParameter.ActualName;
+      maker.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
+
+      Operators.AddRange(new IItem[] { generator, evaluator, maker });
+    }
+
     // ReSharper disable RedundantNameQualifier
     protected virtual IBinaryVectorCrossover GetDefaultBinaryCrossover(string paramName, Configuration config) {
Index: branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveScript.cs
===================================================================
--- branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveScript.cs	(revision 10856)
+++ branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/SingleObjectiveScript.cs	(revision 11363)
@@ -34,5 +34,8 @@
     protected SingleObjectiveScript(SingleObjectiveScript original, Cloner cloner)
       : base(original, cloner) { }
-    public SingleObjectiveScript() { }
+
+    public SingleObjectiveScript() {
+      Code = CodeTemplate;
+    }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -78,4 +81,16 @@
   }
 
+  public IEnumerable<ParameterVector> GetNeighbors(IRandom random, ParameterVector vector) {
+    // Create new vectors, based on the given one that represent small changes
+    // This method is only called from move-based algorithms (LocalSearch, SimulatedAnnealing, etc.)
+    while (true) {
+      var neighbor = (ParameterVector)vector.Clone();
+      //e.g. make a bit flip in a binary parameter
+      //var bIndex = random.Next(neighbor.Binary(""b"").Length);
+      //neighbor.Binary(""b"")[bIndex] = !neighbor.Binary(""b"")[bIndex];
+      yield return neighbor;
+    }
+  }
+
   // implement further classes and methods
 }";
