Index: /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/AlpsSsGeneticAlgorithm.cs
===================================================================
--- /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/AlpsSsGeneticAlgorithm.cs	(revision 12135)
+++ /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/AlpsSsGeneticAlgorithm.cs	(revision 12136)
@@ -43,6 +43,6 @@
       get { return (IValueParameter<IntArray>)Parameters["PopulationSize"]; }
     }
-    private IValueParameter<IntValue> MaximumGenerationsParameter {
-      get { return (IValueParameter<IntValue>)Parameters["MaximumGenerations"]; }
+    private IValueParameter<IntValue> MaximumIterationsParameter {
+      get { return (IValueParameter<IntValue>)Parameters["MaximumIterations"]; }
     }
     public IConstrainedValueParameter<ISelector> SelectorParameter {
@@ -71,7 +71,7 @@
       set { PopulationSizeParameter.Value = value; }
     }
-    public IntValue MaximumGenerations {
-      get { return MaximumGenerationsParameter.Value; }
-      set { MaximumGenerationsParameter.Value = value; }
+    public IntValue MaximumIterations {
+      get { return MaximumIterationsParameter.Value; }
+      set { MaximumIterationsParameter.Value = value; }
     }
 
@@ -116,5 +116,5 @@
       : base() {
       Parameters.Add(new ValueParameter<IntArray>("PopulationSize", "The size of the population of solutions each layer.", new IntArray(new[] { 100 })));
-      Parameters.Add(new ValueParameter<IntValue>("MaximumGenerations", "The maximum number of generations that should be processed.", new IntValue(1000)));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of iterations that should be processed.", new IntValue(1000)));
       Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
       Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
@@ -132,6 +132,8 @@
       var initializeAgeProcessor = new UniformSubScopesProcessor();
       var initializeAge = new VariableCreator() { Name = "Initialize Age" };
-      var initializeLocalEvaluatedSolutions = new SubScopesCounter() { Name = "Initialize LayerEvaluatedSolutions" };
+      var initializeLayerPopulationSize = new SubScopesCounter() { Name = "Init LayerPopulationCounter" };
+      var initializeLocalEvaluatedSolutions = new Assigner() { Name = "Initialize LayerEvaluatedSolutions" };
       var initializeGlobalEvaluatedSolutions = new DataReducer() { Name = "Initialize EvaluatedSolutions" };
+      var initializeCurrentPopulationSize = new Assigner() { Name = "CurrentPopulationSize = EvaluatedSolutions" };
       var resultsCollector = new ResultsCollector();
       var mainLoop = new AlpsSsGeneticAlgorithmMainLoop();
@@ -156,9 +158,14 @@
 
       initializeAgeProcessor.Operator = initializeAge;
-      initializeAgeProcessor.Successor = initializeLocalEvaluatedSolutions;
-
-      initializeAge.CollectedValues.Add(new ValueParameter<IntValue>("Age", new IntValue(0)));
-
-      initializeLocalEvaluatedSolutions.ValueParameter.ActualName = "LayerEvaluatedSolutions";
+      initializeAgeProcessor.Successor = initializeLayerPopulationSize;
+
+      initializeAge.CollectedValues.Add(new ValueParameter<IntValue>("Age", new IntValue(1)));
+
+      initializeLayerPopulationSize.ValueParameter.ActualName = "LayerPopulationSize";
+      initializeLayerPopulationSize.Successor = initializeLocalEvaluatedSolutions;
+
+      initializeLocalEvaluatedSolutions.LeftSideParameter.ActualName = "LayerEvaluatedSolutions";
+      initializeLocalEvaluatedSolutions.RightSideParameter.ActualName = "LayerPopulationSize";
+      initializeLocalEvaluatedSolutions.Successor = null;
 
       initializeGlobalEvaluatedSolutions.ReductionOperation.Value.Value = ReductionOperations.Sum;
@@ -166,7 +173,12 @@
       initializeGlobalEvaluatedSolutions.ParameterToReduce.ActualName = "LayerEvaluatedSolutions";
       initializeGlobalEvaluatedSolutions.TargetParameter.ActualName = "EvaluatedSolutions";
-      initializeGlobalEvaluatedSolutions.Successor = resultsCollector;
+      initializeGlobalEvaluatedSolutions.Successor = initializeCurrentPopulationSize;
+
+      initializeCurrentPopulationSize.LeftSideParameter.ActualName = "CurrentPoulationSize";
+      initializeCurrentPopulationSize.RightSideParameter.ActualName = "EvaluatedSolutions";
+      initializeCurrentPopulationSize.Successor = resultsCollector;
 
       resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Current PopulationSize", null, "CurrentPopulationSize"));
       resultsCollector.Successor = mainLoop;
 
@@ -252,7 +264,7 @@
       if (Problem != null) {
         foreach (var @operator in Problem.Operators.OfType<IIterationBasedOperator>()) {
-          @operator.IterationsParameter.ActualName = "Generations";
+          @operator.IterationsParameter.ActualName = "Iteration";
           @operator.IterationsParameter.Hidden = true;
-          @operator.MaximumIterationsParameter.ActualName = MaximumGenerationsParameter.Name;
+          @operator.MaximumIterationsParameter.ActualName = MaximumIterationsParameter.Name;
           @operator.MaximumIterationsParameter.Hidden = true;
         }
Index: /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/AlpsSsGeneticAlgorithmMainLoop.cs
===================================================================
--- /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/AlpsSsGeneticAlgorithmMainLoop.cs	(revision 12135)
+++ /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/AlpsSsGeneticAlgorithmMainLoop.cs	(revision 12136)
@@ -22,6 +22,10 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Operators;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Selection;
 
 namespace HeuristicLab.Algorithms.ALPS.SteadyState {
@@ -29,4 +33,22 @@
   [StorableClass]
   public class AlpsSsGeneticAlgorithmMainLoop : AlgorithmOperator {
+    #region Parameter Properties
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ILookupParameter<IntValue> MaximumIterationsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["MaximumIterations"]; }
+    }
+    public ILookupParameter<IOperator> AnalyzerParameter {
+      get { return (ILookupParameter<IOperator>)Parameters["Analyzer"]; }
+    }
+    public ILookupParameter<IOperator> LayerAnalyzerParameter {
+      get { return (ILookupParameter<IOperator>)Parameters["LayerAnalyzer"]; }
+    }
+    #endregion
+
     [StorableConstructor]
     private AlpsSsGeneticAlgorithmMainLoop(bool deserializing)
@@ -40,4 +62,149 @@
     public AlpsSsGeneticAlgorithmMainLoop()
       : base() {
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
+      Parameters.Add(new LookupParameter<IntValue>("MaximumIterations", "The maximum number of iterations that the algorithm should process."));
+      Parameters.Add(new LookupParameter<IOperator>("Analyzer", "The operator used to the analyze all individuals."));
+      Parameters.Add(new LookupParameter<IOperator>("LayerAnalyzer", "The operator used to analyze each layer."));
+
+      var variableCreator = new VariableCreator() { Name = "Initialize" };
+      var randomScopeProcessor = new RandomLayerProcessor() { Name = "Select a layer" }; // TODO LayerSubScopeProcessor for Array conversion
+      var isLayerZeroComperator = new Comparator() { Name = "IsLayerZero = Layer == 0" };
+      var isLayerZeroBranch = new ConditionalBranch() { Name = "IsLayerZero?" };
+      var isDoInitBranch = new ConditionalBranch() { Name = "DoInit?" };
+      var setTargetIndedxToNextInit = new Assigner() { Name = "TargetIndex = NextInit" };
+      var incrementNextInit = new IntCounter() { Name = "Incr. NextInit" };
+      var checkInitFinished = new Comparator() { Name = "DoInit = NextInit >= PopulationSize" };
+      var createWorkingScope = new BestSelector();
+      var workingScopeProcessor = new SubScopesProcessor() { Name = "Working Scope Processor" };
+      var createRandomIndividual = new SolutionsCreator() { Name = "Create random Individual" };
+      var initializeAgeProcessor = new UniformSubScopesProcessor();
+      var initializeAge = new Assigner() { Name = "Initialize Age" };
+      var selectRandomTargetIndex = new RandomIntAssigner();
+      var copyLayer = new BestSelector();
+      var copyLayerProcessor = new SubScopesProcessor();
+      var matingPoolCreator = new SteadyStateMatingPoolCreator() { Name = "Create MatingPool" };
+      var matingPoolSize = new SubScopesCounter() { Name = "MatingPoolSize" };
+      var matingPoolSizeMin2 = new Comparator() { Name = "ValidParents = MatingPoolSize >= 2" };
+      var validParentsBranch = new ConditionalBranch() { Name = "ValidParents?" };
+      var mainOperator = new EmptyOperator(); // TODO
+      var reactivateInit = new Assigner() { Name = "DoInit = true" };
+      var resetNextIndex = new Assigner() { Name = "NextInit = 1" };
+      var resetTargetIndex = new Assigner() { Name = "TargetIndex = 0" };
+      var clearMatingPool = new SubScopesRemover() { Name = "Clear WorkingScope" };
+      var tryMoveUp = new EmptyOperator() { Name = "Try Move Up" }; // TODO
+      var setNewIndividual = new EmptyOperator() { Name = "Set New Individual" };
+      var iterationsComparator = new Comparator() { Name = "Iterations >= MaximumIterations" };
+      var terminateBranch = new ConditionalBranch() { Name = "Terminate?" };
+
+
+      OperatorGraph.InitialOperator = variableCreator;
+
+      variableCreator.CollectedValues.Add(new ValueParameter<BoolValue>("DoInit", new BoolValue(false)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("NextInit", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("OpenLayers", new IntValue(1)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("TargetIndex", new IntValue(0)));
+      variableCreator.Successor = randomScopeProcessor;
+
+      randomScopeProcessor.Operator = isLayerZeroComperator;
+
+      isLayerZeroComperator.LeftSideParameter.ActualName = "Layer";
+      isLayerZeroComperator.RightSideParameter.Value = new IntValue(0);
+      isLayerZeroComperator.ResultParameter.ActualName = "IsLayerZero";
+      isLayerZeroComperator.Comparison = new Comparison(ComparisonType.Equal);
+      isLayerZeroComperator.Successor = isLayerZeroBranch;
+
+      isLayerZeroBranch.ConditionParameter.ActualName = "IsLayerZero";
+      isLayerZeroBranch.TrueBranch = isDoInitBranch;
+      isLayerZeroBranch.FalseBranch = selectRandomTargetIndex;
+      isLayerZeroBranch.Successor = tryMoveUp;
+
+      isDoInitBranch.ConditionParameter.ActualName = "DoInit";
+      isDoInitBranch.TrueBranch = setTargetIndedxToNextInit;
+      isDoInitBranch.FalseBranch = selectRandomTargetIndex;
+
+      setTargetIndedxToNextInit.LeftSideParameter.ActualName = "TargetIndex";
+      setTargetIndedxToNextInit.RightSideParameter.ActualName = "NextInit";
+      setTargetIndedxToNextInit.Successor = incrementNextInit;
+
+      incrementNextInit.ValueParameter.ActualName = "NextInit";
+      incrementNextInit.Increment = new IntValue(1);
+      incrementNextInit.Successor = checkInitFinished;
+
+      checkInitFinished.LeftSideParameter.ActualName = "NextInit";
+      checkInitFinished.RightSideParameter.ActualName = "PopulationSize";
+      checkInitFinished.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
+      checkInitFinished.ResultParameter.ActualName = "DoInit";
+      checkInitFinished.Successor = createWorkingScope;
+
+      createWorkingScope.NumberOfSelectedSubScopesParameter.Value = new IntValue(0);
+      createWorkingScope.CopySelected = new BoolValue(false);
+      createWorkingScope.Successor = workingScopeProcessor;
+
+      workingScopeProcessor.Operators.Add(createRandomIndividual);
+      workingScopeProcessor.Operators.Add(new EmptyOperator());
+
+      createRandomIndividual.NumberOfSolutions = new IntValue(1);
+      createRandomIndividual.Successor = initializeAgeProcessor;
+
+      initializeAgeProcessor.Operator = initializeAge;
+
+      initializeAge.LeftSideParameter.ActualName = "EvalsCreated";
+      initializeAge.RightSideParameter.ActualName = "EvaluatedSolutions";
+
+      selectRandomTargetIndex.LeftSideParameter.ActualName = "TargetIndex";
+      selectRandomTargetIndex.MinimumParameter.Value = new IntValue(0);
+      selectRandomTargetIndex.MaximumParameter.ActualName = "PopulationSize";
+      selectRandomTargetIndex.Successor = copyLayer;
+
+      copyLayer.NumberOfSelectedSubScopesParameter.ActualName = "LayerPopulationSize";
+      copyLayer.CopySelected = new BoolValue(true);
+      copyLayer.Successor = copyLayerProcessor;
+
+      copyLayerProcessor.Operators.Add(new EmptyOperator());
+      copyLayerProcessor.Operators.Add(matingPoolCreator);
+
+      matingPoolCreator.Successor = matingPoolSize;
+
+      matingPoolSize.ValueParameter.ActualName = "MatingPoolSize";
+      matingPoolSize.Successor = matingPoolSizeMin2;
+
+      matingPoolSizeMin2.LeftSideParameter.ActualName = "MatingPoolSize";
+      matingPoolSizeMin2.RightSideParameter.Value = new IntValue(2);
+      matingPoolSizeMin2.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
+      matingPoolSizeMin2.ResultParameter.ActualName = "ValidParents";
+      matingPoolSizeMin2.Successor = validParentsBranch;
+
+      validParentsBranch.TrueBranch = mainOperator;
+      validParentsBranch.FalseBranch = reactivateInit;
+
+      reactivateInit.Successor = resetNextIndex;
+      reactivateInit.LeftSideParameter.ActualName = "DoInit";
+      reactivateInit.RightSideParameter.Value = new BoolValue(true);
+
+      resetNextIndex.Successor = resetTargetIndex;
+      resetNextIndex.LeftSideParameter.ActualName = "NextIndex";
+      resetNextIndex.RightSideParameter.Value = new IntValue(1);
+
+      resetTargetIndex.Successor = clearMatingPool;
+      resetTargetIndex.LeftSideParameter.ActualName = "TargetIndex";
+      resetTargetIndex.RightSideParameter.Value = new IntValue(0);
+
+      clearMatingPool.Successor = createRandomIndividual;
+
+      tryMoveUp.Successor = setNewIndividual;
+
+      setNewIndividual.Successor = iterationsComparator;
+
+      iterationsComparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
+      iterationsComparator.LeftSideParameter.ActualName = "Iterations";
+      iterationsComparator.RightSideParameter.ActualName = MaximumIterationsParameter.Name;
+      iterationsComparator.ResultParameter.ActualName = "Terminate";
+      iterationsComparator.Successor = terminateBranch;
+
+      terminateBranch.ConditionParameter.ActualName = "Terminate";
+      terminateBranch.FalseBranch = randomScopeProcessor;
+
+
     }
 
Index: /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/HeuristicLab.Algorithms.ALPS.SteadyState-3.3.csproj
===================================================================
--- /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/HeuristicLab.Algorithms.ALPS.SteadyState-3.3.csproj	(revision 12135)
+++ /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/HeuristicLab.Algorithms.ALPS.SteadyState-3.3.csproj	(revision 12136)
@@ -126,4 +126,5 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
   </ItemGroup>
   <ItemGroup>
@@ -137,4 +138,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Plugin.cs" />
+    <Compile Include="RandomIntAssigner.cs" />
+    <Compile Include="RandomLayerProcessor.cs" />
+    <Compile Include="SteadyStateMatingPoolCreator.cs" />
   </ItemGroup>
   <ItemGroup>
Index: /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/RandomIntAssigner.cs
===================================================================
--- /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/RandomIntAssigner.cs	(revision 12136)
+++ /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/RandomIntAssigner.cs	(revision 12136)
@@ -0,0 +1,72 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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 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.Algorithms.ALPS.SteadyState {
+  [Item("RandomIntAssigner", "An operator which sets a random value to a parameter")]
+  [StorableClass]
+  public class RandomIntAssigner : SingleSuccessorOperator, IStochasticOperator {
+    public LookupParameter<IItem> LeftSideParameter {
+      get { return (LookupParameter<IItem>)Parameters["LeftSide"]; }
+    }
+    public ValueLookupParameter<IntValue> MinimumParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["Minimum"]; }
+    }
+    public ValueLookupParameter<IntValue> MaximumParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["Maximum"]; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    [StorableConstructor]
+    private RandomIntAssigner(bool deserializing) : base(deserializing) { }
+    private RandomIntAssigner(RandomIntAssigner original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public RandomIntAssigner()
+      : base() {
+      Parameters.Add(new LookupParameter<IItem>("LeftSide", "The parameter whose value gets assigned."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Minimum", new IntValue(0)));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Maximum", new IntValue(10)));
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RandomIntAssigner(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var random = RandomParameter.ActualValue;
+      int min = MinimumParameter.ActualValue.Value;
+      int max = MaximumParameter.ActualValue.Value;
+      LeftSideParameter.ActualValue = new IntValue(random.Next(min, max));
+      return base.Apply();
+    }
+  }
+}
Index: /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/RandomLayerProcessor.cs
===================================================================
--- /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/RandomLayerProcessor.cs	(revision 12136)
+++ /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/RandomLayerProcessor.cs	(revision 12136)
@@ -0,0 +1,87 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Algorithms.ALPS.SteadyState {
+  [Item("RandomLayerProcessor", "An operator which applies a specified operator on a random selected sub-scope (layer).")]
+  [StorableClass]
+  public class RandomLayerProcessor : SingleSuccessorOperator, IStochasticOperator {
+    private OperatorParameter OperatorParameter {
+      get { return (OperatorParameter)Parameters["Operator"]; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    private ILookupParameter<IntArray> PopulationSizeParameter {
+      get { return (ILookupParameter<IntArray>)Parameters["PopulationSize"]; }
+    }
+
+    public IOperator Operator {
+      get { return OperatorParameter.Value; }
+      set { OperatorParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    private RandomLayerProcessor(bool deserializing) : base(deserializing) { }
+    private RandomLayerProcessor(RandomLayerProcessor original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public RandomLayerProcessor()
+      : base() {
+      Parameters.Add(new OperatorParameter("Operator", "The operator which should be applied on a random sub-scopes of the current scope."));
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+
+      Parameters.Add(new LookupParameter<IntArray>("PopulationSize"));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RandomLayerProcessor(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var random = RandomParameter.ActualValue;
+
+      var next = new OperationCollection(base.Apply());
+      if (Operator != null) {
+        var subScopes = ExecutionContext.Scope.SubScopes;
+        int index = random.Next(subScopes.Count);
+        var selectedLayer = subScopes[index];
+
+        var layerParameters = new LayerIntermediateParameter {
+            new ValueParameter<IntValue>(PopulationSizeParameter.ActualName, new IntValue(PopulationSizeParameter.ActualValue[Math.Min(index, PopulationSizeParameter.ActualValue.Length - 1)]))
+          };
+        var immediateContext = new ExecutionContext(ExecutionContext.Parent, layerParameters, selectedLayer);
+        next.Insert(0, immediateContext.CreateChildOperation(Operator, selectedLayer));
+      }
+      return next;
+    }
+  }
+}
Index: /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/SteadyStateMatingPoolCreator.cs
===================================================================
--- /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/SteadyStateMatingPoolCreator.cs	(revision 12136)
+++ /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/SteadyStateMatingPoolCreator.cs	(revision 12136)
@@ -0,0 +1,64 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.ALPS.SteadyState {
+  [Item("SteadyStateMatingPoolCreator", "")]
+  [StorableClass]
+  public class SteadyStateMatingPoolCreator : SingleSuccessorOperator {
+
+    [StorableConstructor]
+    private SteadyStateMatingPoolCreator(bool deserializing)
+      : base(deserializing) { }
+    private SteadyStateMatingPoolCreator(SteadyStateMatingPoolCreator original, Cloner cloner)
+      : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SteadyStateMatingPoolCreator(this, cloner);
+    }
+    public SteadyStateMatingPoolCreator()
+      : base() {
+    }
+
+    public override IOperation Apply() {
+      var matingPool = ExecutionContext.Scope;
+      var currentLayer = matingPool.Parent;
+      int layerNumber = ((IntValue)currentLayer.Variables["Layer"].Value).Value;
+
+      if (layerNumber > 0) {
+        var prevLayer = currentLayer.Parent.SubScopes[layerNumber - 1];
+        var prevLayerIndividuals = prevLayer.SubScopes;
+
+        foreach (var individual in prevLayerIndividuals) {
+          matingPool.SubScopes.Add((IScope)individual.Clone());
+        }
+      }
+
+      return base.Apply();
+    }
+  }
+}
