diff --git a/README.md b/README.md
index c6df671..330a5af 100644
--- a/README.md
+++ b/README.md
@@ -1,13 +1,9 @@
 # Welcome to state.cs
 
-The current stable release is 5.1.3.
+The current stable release is 5.2.0.
 
 If you're using state.cs I'd love to hear about it; please e-mail me at mesmo@steelbreeze.net 
 
-## Version 5.0 notes
-Version 5.0 is a complete re-write of the state machine. It makes large use of multicast delegates to pre-evaulate the steps required to perform state transitions. This leads to considerable performance benefits no evaluations are made relating to the structure of the model at runtime as it does not change at runtime.
-
-
 ## Introduction
 State.js provides a hierarchical state machine capable of managing orthogonal regions; a variety of pseudo state kinds are implemented including initial, shallow & deep history, choice, junction and entry & exit points.
 
diff --git a/RELEASES.md b/RELEASES.md
new file mode 100644
index 0000000..4f1a77e
--- /dev/null
+++ b/RELEASES.md
@@ -0,0 +1,21 @@
+# Release notes
+
+# Version 5.0.0
+Version 5.0 is a complete re-write of the state machine. It makes large use of multicast delegates to pre-evaulate the steps required to perform state transitions. This leads to considerable performance benefits no evaluations are made relating to the structure of the model at runtime as it does not change at runtime.
+
+# Version 5.2.0
+Renamed IContext to IActiveStateConfiguration
+
+Renamed Context to StateMachineInstance
+
+Renamed ContextBase to StateMachineInstanceBase
+
+Removed XContext and XContextBase
+
+Added Create... extension methods to main classes to faciltate simpler model building.
+
+Changed StateMachine to inherit from State 
+
+Added a visitor pattern implementation
+
+Moved the bootstrapping to use the visitor
\ No newline at end of file
diff --git a/examples/Player.cs b/examples/Player.cs
index e23a2cc..934edd1 100644
--- a/examples/Player.cs
+++ b/examples/Player.cs
@@ -6,8 +6,7 @@
 using System;
 using System.Xml.Linq;
 
-namespace Steelbreeze.Behavior.StateMachines.Examples
-{
+namespace Steelbreeze.Behavior.StateMachines.Examples {
 	/// <summary>
 	/// A controller for a simple cassette player
 	/// </summary>
@@ -15,76 +14,72 @@ namespace Steelbreeze.Behavior.StateMachines.Examples
 	/// The player now inherits from a Region, so can be used in isolation, or as a region in a larger device.
 	/// The player now implements an 'operational' composite state so the off command can be used while in any sub-state.
 	/// </remarks>
-	public class Player
-	{
-		static void Main() {
-			// create the state machine model
-			var model = new StateMachine<XContext>( "player" );
-			var initial = new PseudoState<XContext>( "initial", model, PseudoStateKind.Initial );
-			var operational = new State<XContext>( "operational", model );
-			var choice = new PseudoState<XContext>( "choice", model, PseudoStateKind.Choice );
-			var final = new FinalState<XContext>( "final", model );
+	public class Player {
+		public static StateMachine<StateMachineInstance> Model;
 
-			var history = new PseudoState<XContext>( "history", operational, PseudoStateKind.DeepHistory );
-			var stopped = new State<XContext>( "stopped", operational );
-			var active = new State<XContext>( "active", operational ).Entry( EngageHead ).Exit( DisengageHead );
+		static Player () {
+			// create the state machine model
+			Model = new StateMachine<StateMachineInstance> ("model");
 
-			var running = new State<XContext>( "running", active ).Entry( StartMotor ).Exit( StopMotor );
-			var paused = new State<XContext>( "paused", active );
+			// create the vertices within the model
+			var initial = Model.CreatePseudoState ("initial", PseudoStateKind.Initial);
+			var operational = Model.CreateState ("operational");
+			var choice = Model.CreatePseudoState ("choice", PseudoStateKind.Choice);
+			var final = Model.CreateFinalState ("final");
+			var history = operational.CreatePseudoState ("history", PseudoStateKind.DeepHistory);
+			var stopped = operational.CreateState ("stopped");
+			var active = operational.CreateState ("active").Entry (EngageHead).Exit (DisengageHead);
+			var running = active.CreateState ("running").Entry (StartMotor).Exit (StopMotor);
+			var paused = active.CreateState ("paused");
 
 			// create the transitions between vertices of the model
-			initial.To( operational ).Effect( DisengageHead, StartMotor );
-			history.To( stopped );
-			stopped.To( running ).When<String>( command => command == "play" );
-			active.To( stopped ).When<String>( command => command == "stop" );
-			running.To( paused ).When<String>( command => command == "pause" );
-			paused.To( running ).When<String>( command => command == "play" );
-			operational.To( final ).When<String>( command => command == "off" );
-			operational.To( choice ).When<String>( command => command == "rand" );
-			choice.To( operational ).Effect( () => Console.WriteLine( "- transition A back to operational" ) );
-			choice.To( operational ).Effect( () => Console.WriteLine( "- transition B back to operational" ) );
-
-			// add an internal transition to show the current state at any time			
-			operational.When<String>( command => command == "current" ).Effect( state => Console.WriteLine( state.XElement ) );
+			initial.To (operational).Effect (DisengageHead, StartMotor);
+			history.To (stopped);
+			stopped.To (running).When<String> (command => command == "play");
+			active.To (stopped).When<String> (command => command == "stop");
+			running.To (paused).When<String> (command => command == "pause");
+			paused.To (running).When<String> (command => command == "play");
+			operational.To (final).When<String> (command => command == "off");
+			operational.To (choice).When<String> (command => command == "rand");
+			choice.To (operational).Effect (() => Console.WriteLine ("- transition A back to operational"));
+			choice.To (operational).Effect (() => Console.WriteLine ("- transition B back to operational"));
+		}
 
+		static void Main () {
 			// create an instance of the state machine state
-			var context = new XContext();
+			var instance = new StateMachineInstance ("player");
 
 			// initialises the state machine state (enters the region for the first time, causing transition from the initial PseudoState)
-			model.Initialise( context );
+			Model.Initialise (instance);
 
 			// main event loop
-			while( !model.IsComplete( context ) ) {
+			while (!Model.IsComplete (instance)) {
 				// write a prompt
-				Console.Write( "alamo> " );
+				Console.Write ("alamo> ");
 
 				// process lines read from the console
-				if( !model.Evaluate( Console.ReadLine(), context ) )
-					Console.WriteLine( "unknown command" );
+				if (!Model.Evaluate (Console.ReadLine (), instance))
+					Console.WriteLine ("unknown command");
 			}
 
-			Console.WriteLine( "Press any key to quit" );
-			Console.ReadKey();
+			Console.WriteLine ("Press any key to quit");
+			Console.ReadKey ();
 		}
 
-		private static void EngageHead()
-		{
-			Console.WriteLine( "- engaging head" );
+		private static void EngageHead () {
+			Console.WriteLine ("- engaging head");
 		}
 
-		private static void DisengageHead()
-		{
-			Console.WriteLine( "- disengaging head" );
+		private static void DisengageHead () {
+			Console.WriteLine ("- disengaging head");
 		}
 
-		private static void StartMotor()
-		{
-			Console.WriteLine( "- starting motor" );
+		private static void StartMotor () {
+			Console.WriteLine ("- starting motor");
 		}
 
-		private static void StopMotor()
-		{
-			Console.WriteLine( "- stopping motor" );
+		private static void StopMotor () {
+			Console.WriteLine ("- stopping motor");
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/Bootstrap.cs b/src/Bootstrap.cs
new file mode 100644
index 0000000..3d7f46c
--- /dev/null
+++ b/src/Bootstrap.cs
@@ -0,0 +1,202 @@
+/* State v5 finite state machine library
+ * http://www.steelbreeze.net/state.cs
+ * Copyright (c) 2014-5 Steelbreeze Limited
+ * Licensed under MIT and GPL v3 licences
+ */
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+
+namespace Steelbreeze.Behavior.StateMachines {
+	/// <summary>
+	/// Bootstraps a state machine model.
+	/// </summary>
+	/// <typeparam name="TInstance">The type of the state machine instnce.</typeparam>
+	/// <remarks>Bootstrapping a state machine model pre-determines all operations and evaluations required when traversing a transition; the results are then cached within the transition.</remarks>
+	internal class Bootstrap<TInstance> : Visitor<TInstance, Boolean> where TInstance : class, IActiveStateConfiguration<TInstance> {
+		private class Actions {
+			internal Action<Object, TInstance, Boolean> Leave;
+			internal Action<Object, TInstance, Boolean> BeginEnter;
+			internal Action<Object, TInstance, Boolean> EndEnter;
+			internal Action<Object, TInstance, Boolean> Enter;
+		}
+
+		/// <summary>
+		/// Cache of the behaviour required within the state machine model.
+		/// </summary>
+		private Dictionary<Element<TInstance>, Actions> behaviour;
+
+		/// <summary>
+		/// Returns the behaviour for a given element within the state machine model.
+		/// </summary>
+		/// <param name="element">The element to return the behaviour for.</param>
+		/// <returns>The state machine behaviour for a given model element.</returns>
+		private Actions Behaviour (Element<TInstance> element) {
+			Actions result = null;
+
+			if (!behaviour.TryGetValue (element, out result))
+				behaviour.Add (element, result = new Actions ());
+
+			return result;
+		}
+
+		public override void VisitElement (Element<TInstance> element, Boolean deepHistoryAbove) {
+#if DEBUG
+			Behaviour (element).Leave += (message, instance, history) => Console.WriteLine ("{0} leave {1}", instance, element);
+			Behaviour (element).BeginEnter += (message, instance, history) => Console.WriteLine ("{0} enter {1}", instance, element);
+#endif
+		}
+
+		public override void VisitRegion (Region<TInstance> region, Boolean deepHistoryAbove) {
+			foreach (var vertex in region.Vertices)
+				vertex.Accept (this, deepHistoryAbove || (region.Initial != null && region.Initial.Kind == PseudoStateKind.DeepHistory));
+
+			Behaviour (region).Leave += (message, instance, history) => {
+				State<TInstance> current = instance[ region ];
+
+				if (Behaviour (current).Leave != null) {
+					Behaviour (current).Leave (message, instance, history);
+				}
+			};
+
+			if (deepHistoryAbove || region.Initial == null || region.Initial.IsHistory) {
+				Behaviour (region).EndEnter += (message, instance, history) => {
+					Vertex<TInstance> initial = region.Initial;
+
+					if (history || region.Initial.IsHistory) {
+						initial = instance[ region ];
+
+						if (initial == null)
+							initial = region.Initial;
+					}
+
+					Behaviour (initial).Enter (message, instance, history || region.Initial.Kind == PseudoStateKind.DeepHistory);
+				};
+			} else
+				Behaviour (region).EndEnter += Behaviour (region.Initial).Enter;
+
+			this.VisitElement (region, deepHistoryAbove);
+
+			Behaviour (region).Enter = Behaviour (region).BeginEnter + Behaviour (region).EndEnter;
+		}
+
+		public override void VisitVertex (Vertex<TInstance> vertex, Boolean deepHistoryAbove) {
+			this.VisitElement (vertex, deepHistoryAbove);
+	
+			Behaviour (vertex).EndEnter += vertex.Completion;
+			Behaviour (vertex).Enter = Behaviour (vertex).BeginEnter + Behaviour (vertex).EndEnter;
+		}
+
+		public override void VisitPseudoState (PseudoState<TInstance> pseudoState, Boolean deepHistoryAbove) {
+			this.VisitVertex (pseudoState, deepHistoryAbove);
+
+			if (pseudoState.Kind == PseudoStateKind.Terminate)
+				Behaviour (pseudoState).Enter += (message, instance, history) => instance.IsTerminated = true;
+		}
+
+		public override void VisitState (State<TInstance> state, Boolean deepHistoryAbove) {
+			foreach (var region in state.Regions) {
+				region.Accept (this, deepHistoryAbove);
+
+				Behaviour (state).Leave += Behaviour (region).Leave;
+				Behaviour (state).EndEnter += Behaviour (region).Enter;
+			}
+
+			this.VisitVertex (state, deepHistoryAbove);
+
+			if (state.exit != null)
+				Behaviour (state).Leave += state.OnExit;
+
+			if (state.entry != null)
+				Behaviour (state).BeginEnter += state.OnEntry;
+
+			Behaviour (state).BeginEnter += (message, instance, history) => {
+				if (state.Region != null)
+					instance[ state.Region ] = state;
+			};
+
+			Behaviour (state).Enter = Behaviour (state).BeginEnter + Behaviour (state).EndEnter;
+		}
+
+		public override void VisitStateMachine (StateMachine<TInstance> stateMachine, bool param) {
+			behaviour = new Dictionary<Element<TInstance>, Actions> ();
+
+			base.VisitStateMachine (stateMachine, param);
+
+			stateMachine.initialise = Behaviour (stateMachine).Enter;
+		}
+
+		public override void VisitTransition (Transition<TInstance> transition, Boolean deepHistoryAbove) {
+			// reset the traverse operation to cater for re-initialisation
+			transition.Traverse = null;
+
+			// internal transitions
+			if (transition.Target == null) {
+				// just perform the transition effect; no actual transition
+				if (transition.effect != null)
+					transition.Traverse += transition.OnEffect;
+
+				// local transitions
+			} else if (transition.Target.Region == transition.Source.Region) {
+				// leave the source
+				transition.Traverse += Behaviour (transition.Source).Leave;
+
+				// perform the transition effect
+				if (transition.effect != null)
+					transition.Traverse += transition.OnEffect;
+
+				// enter the target
+				transition.Traverse += Behaviour (transition.Target).Enter;
+
+				// complex (external) transitions
+			} else {
+				var sourceAncestors = transition.Source.Ancestors;
+				var targetAncestors = transition.Target.Ancestors;
+				var sourceAncestorsCount = sourceAncestors.Count ();
+				var targetAncestorsCount = targetAncestors.Count ();
+				int i = 0, l = Math.Min (sourceAncestorsCount, sourceAncestorsCount);
+
+				// find the index of the first uncommon ancestor
+				while ((i < l) && sourceAncestors.ElementAt (i) == targetAncestors.ElementAt (i)) ++i;
+
+				// validation rule (not in the UML spec currently)
+				Trace.Assert (sourceAncestors.ElementAt (i) is Region<TInstance> == false, "Transitions may not cross sibling orthogonal regions");
+
+				// leave the first uncommon ancestor
+				transition.Traverse = Behaviour (i < sourceAncestorsCount ? sourceAncestors.ElementAt (i) : transition.Source).Leave;
+
+				// perform the transition effect
+				if (transition.effect != null)
+					transition.Traverse += transition.OnEffect;
+
+				// edge case when transitioning to a state in the vertex ancestry
+				if (i >= targetAncestorsCount)
+					transition.Traverse += Behaviour (transition.Target).BeginEnter;
+
+				// enter the target ancestry
+				while (i < targetAncestorsCount) {
+					var element = targetAncestors.ElementAt (i++);
+					var next = i < targetAncestorsCount ? targetAncestors.ElementAt (i) : null;
+
+					transition.Traverse += Behaviour (element).BeginEnter;
+
+					if (element is State<TInstance>) {
+						var state = element as State<TInstance>;
+
+						if (state.IsOrthogonal) {
+							foreach (var region in state.Regions) {
+								if (region != next) {
+									transition.Traverse += Behaviour (region).Enter;
+								}
+							}
+						}
+					}
+				}
+
+				// trigger cascade
+				transition.Traverse += Behaviour (transition.Target).EndEnter;
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/DictionaryContext.cs b/src/DictionaryContext.cs
deleted file mode 100644
index 36ea8e9..0000000
--- a/src/DictionaryContext.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-/* State v5 finite state machine library
- * http://www.steelbreeze.net/state.cs
- * Copyright (c) 2014-5 Steelbreeze Limited
- * Licensed under MIT and GPL v3 licences
- */
-using System;
-using System.Collections.Generic;
-
-namespace Steelbreeze.Behavior.StateMachines {
-	/// <summary>
-	/// A simple sample of an object to extend as a base for a state machine context object.
-	/// </summary>
-	public class DictionaryContext : DictionaryContextBase<DictionaryContext> {	}
-}
\ No newline at end of file
diff --git a/src/Element.cs b/src/Element.cs
index 6cd22ba..e385028 100644
--- a/src/Element.cs
+++ b/src/Element.cs
@@ -10,8 +10,9 @@ namespace Steelbreeze.Behavior.StateMachines {
 	/// <summary>
 	/// A structural element of a state machine model.
 	/// </summary>
-	/// <typeparam name="TContext">The type of the state machine instance.</typeparam>
-	public abstract class Element<TContext> where TContext : IContext<TContext> {
+	/// <typeparam name="TInstance">The type of the state machine instance.</typeparam>
+	public abstract class Element<TInstance> where TInstance : class, IActiveStateConfiguration<TInstance> {
+		#region Static members
 		/// <summary>
 		/// The string used to seperate names within a fully qualified namespace.
 		/// </summary>
@@ -20,9 +21,10 @@ public abstract class Element<TContext> where TContext : IContext<TContext> {
 		/// <summary>
 		/// Initialises the static members of NamedElement.
 		/// </summary>
-		static Element() {
+		static Element () {
 			NamespaceSeperator = ".";
 		}
+		#endregion
 
 		/// <summary>
 		/// The name of the NamedElement
@@ -38,72 +40,73 @@ static Element() {
 		public readonly String QualifiedName;
 
 		/// <summary>
-		/// The name of the type without generic considerations
+		/// Creates a new instance of a subtype of the Element class.
 		/// </summary>
-		public abstract String Type { get; }
-	
-		/// <summary>
-		/// Returns the elements parent.
-		/// </summary>
-		public abstract Element<TContext> Parent { get; }
+		/// <param name="name">The name of the element.</param>
+		/// <param name="parent">The parent of the element.</param>
+		internal protected Element (String name, Element<TInstance> parent = null) {
+			this.Name = name;
+			this.QualifiedName = parent != null ? parent.QualifiedName + NamespaceSeperator + name : name;
+		}
 
 		/// <summary>
-		/// The parent state machine that this element forms a part of.
+		/// Returns the elements parent element.
 		/// </summary>
-		public StateMachine<TContext> Root { get; protected set; }
+		public abstract Element<TInstance> Parent { get; }
 
 		/// <summary>
-		/// Returns the elements ancestors.
+		/// Returns the state machine model root element.
 		/// </summary>
-		public IEnumerable<Element<TContext>> Ancestors { get { if( this.Parent != null ) foreach( var namedElement in this.Parent.Ancestors ) yield return namedElement; yield return this; } } // yield! please...
-
-		internal Action<Object, TContext, Boolean> Leave;
-		internal Action<Object, TContext, Boolean> BeginEnter;
-		internal Action<Object, TContext, Boolean> EndEnter;
-		internal Action<Object, TContext, Boolean> Enter;
-
-		internal Element( String name, Element<TContext> parent ) {
-			this.Name = name;
-			this.QualifiedName = parent != null ? parent.QualifiedName + NamespaceSeperator + name : name;
-
-			if( parent != null )
-				this.Root = parent.Root;
+		public virtual StateMachine<TInstance> Root {
+			get {
+				return this.Parent.Root;
+			}
 		}
 
-		internal void Reset() {
-			this.Leave = null;
-			this.BeginEnter = null;
-			this.EndEnter = null;
-			this.Enter = null;
+		/// <summary>
+		/// Returns the elements ancestors back from the state machines root element.
+		/// </summary>
+		public IEnumerable<Element<TInstance>> Ancestors {
+			get {
+				if (this.Parent != null)
+					foreach (var namedElement in this.Parent.Ancestors) // yield! would be great...
+						yield return namedElement;
+
+				yield return this;
+			}
 		}
 
 		/// <summary>
 		/// Tests the element to determine if it is part of the current active state confuguration
 		/// </summary>
-		/// <param name="context">The state machine context.</param>
+		/// <param name="instance">The state machine instance.</param>
 		/// <returns>True if the element is active.</returns>
-		internal protected abstract Boolean IsActive( IContext<TContext> context );
+		/// <remarks>An element is part of the active state configuration if it has been entered but not yet exited.</remarks>
+		public abstract Boolean IsActive (TInstance instance);
 
-		internal virtual void BootstrapElement( Boolean deepHistoryAbove ) {
-#if DEBUG
-			this.Leave += ( message, context, history ) => Console.WriteLine( "{0} leave {1}", context, this.QualifiedName );
-			this.BeginEnter += ( message, context, history ) => Console.WriteLine( "{0} enter {1}", context, this.QualifiedName );
-#endif
-			this.Enter = this.BeginEnter + this.EndEnter;
-		}
-
-		internal abstract void BootstrapTransitions();
+		/// <summary>
+		/// Tests the element to determine if it is deemed to be complete.
+		/// </summary>
+		/// <param name="instance">The state machine instance.</param>
+		/// <returns>True if the element is complete.</returns>
+		public abstract Boolean IsComplete (TInstance instance);
 
-		internal virtual void BootstrapEnter( ref Action<Object, TContext, Boolean> traverse, Element<TContext> next ) {
-			traverse += this.BeginEnter;
-		}
+		/// <summary>
+		/// Accepts a visitor
+		/// </summary>
+		/// <param name="visitor">The visitor to visit.</param>
+		/// <param name="param">A parameter passed to the visitor when visiting elements.</param>
+		/// <remarks>
+		/// A visitor will walk the state machine model from this element to all child elements including transitions calling the approritate visit method on the visitor.
+		/// </remarks>
+		public abstract void Accept<TParam> (Visitor<TInstance, TParam> visitor, TParam param);
 
 		/// <summary>
 		/// Returns a string representation of the element.
 		/// </summary>
 		/// <returns>Returns the fully qualified name of the element.</returns>
-		public override String ToString() {
+		public override String ToString () {
 			return this.QualifiedName;
 		}
 	}
-}
+}
\ No newline at end of file
diff --git a/src/Extensions.cs b/src/Extensions.cs
new file mode 100644
index 0000000..ab790d8
--- /dev/null
+++ b/src/Extensions.cs
@@ -0,0 +1,95 @@
+/* State v5 finite state machine library
+ * http://www.steelbreeze.net/state.cs
+ * Copyright (c) 2014-5 Steelbreeze Limited
+ * Licensed under MIT and GPL v3 licences
+ */
+using System;
+
+namespace Steelbreeze.Behavior.StateMachines {
+	/// <summary>
+	/// Set of extension methods to facilitate easier model building
+	/// </summary>
+	public static class Extensions {
+		/// <summary>
+		/// Creates a new instance of the Region class under the parent State.
+		/// </summary>
+		/// <typeparam name="TInstance">The type of the state machine instance.</typeparam>
+		/// <param name="state">The parent state of the new Region.</param>
+		/// <param name="name">The name of the Region.</param>
+		/// <returns>The newly created Region.</returns>
+		public static Region<TInstance> CreateRegion<TInstance> (this State<TInstance> state, String name) where TInstance : class, IActiveStateConfiguration<TInstance> {
+			return new Region<TInstance> (name, state);
+		}
+
+		/// <summary>
+		/// Creates a new instance of the PseudoState class under the parent Region.
+		/// </summary>
+		/// <typeparam name="TInstance">The type of the state machine instance.</typeparam>
+		/// <param name="region">The parent region of the new PseudoState.</param>
+		/// <param name="name">The name of the PseudoState.</param>
+		/// <param name="kind">The kind of the PseudoState.</param>
+		/// <returns>The newly created PseudoState.</returns>
+		public static PseudoState<TInstance> CreatePseudoState<TInstance> (this Region<TInstance> region, String name, PseudoStateKind kind = PseudoStateKind.Initial) where TInstance : class, IActiveStateConfiguration<TInstance> {
+			return new PseudoState<TInstance> (name, region, kind);
+		}
+
+		/// <summary>
+		/// Creates a new instance of the PseudoState class under the parent State.
+		/// </summary>
+		/// <typeparam name="TInstance">The type of the state machine instance.</typeparam>
+		/// <param name="state">The parent state of the new PseudoState.</param>
+		/// <param name="name">The name of the PseudoState.</param>
+		/// <param name="kind">The kind of the PseudoState.</param>
+		/// <returns>The newly created PseudoState.</returns>
+		/// <remarks>Note that the PseudoState will be created under the parent state's default region.</remarks>
+		public static PseudoState<TInstance> CreatePseudoState<TInstance> (this State<TInstance> state, String name, PseudoStateKind kind = PseudoStateKind.Initial) where TInstance : class, IActiveStateConfiguration<TInstance> {
+			return new PseudoState<TInstance> (name, state, kind);
+		}
+
+		/// <summary>
+		/// Creates a new instance of the State class under the parent Region.
+		/// </summary>
+		/// <typeparam name="TInstance">The type of the state machine instance.</typeparam>
+		/// <param name="region">The parent region of the new State.</param>
+		/// <param name="name">The name of the State.</param>
+		/// <returns>The newly created State.</returns>
+		public static State<TInstance> CreateState<TInstance> (this Region<TInstance> region, String name) where TInstance : class, IActiveStateConfiguration<TInstance> {
+			return new State<TInstance> (name, region);
+		}
+
+		/// <summary>
+		/// Creates a new instance of the State class under the parent State.
+		/// </summary>
+		/// <typeparam name="TInstance">The type of the state machine instance.</typeparam>
+		/// <param name="state">The parent state of the new State.</param>
+		/// <param name="name">The name of the State.</param>
+		/// <returns>The newly created State.</returns>
+		/// <remarks>Note that the State will be created under the parent state's default region.</remarks>
+		public static State<TInstance> CreateState<TInstance> (this State<TInstance> state, String name) where TInstance : class, IActiveStateConfiguration<TInstance> {
+			return new State<TInstance> (name, state);
+		}
+
+		/// <summary>
+		/// Creates a new instance of the FinalState class under the parent Region.
+		/// </summary>
+		/// <typeparam name="TInstance">The type of the state machine instance.</typeparam>
+		/// <param name="region">The parent region of the new FinalState.</param>
+		/// <param name="name">The name of the FinalState.</param>
+		/// <returns>The newly created FinalState.</returns>
+		public static FinalState<TInstance> CreateFinalState<TInstance> (this Region<TInstance> region, String name) where TInstance : class, IActiveStateConfiguration<TInstance> {
+			return new FinalState<TInstance> (name, region);
+		}
+
+		/// <summary>
+		/// Creates a new instance of the FinalState class under the parent State.
+		/// </summary>
+		/// <typeparam name="TInstance">The type of the state machine instance.</typeparam>
+		/// <param name="state">The parent state of the new FinalState.</param>
+		/// <param name="name">The name of the FinalState.</param>
+		/// <returns>The newly created FinalState.</returns>
+		/// <remarks>Note that the FinalState will be created under the parent state's default region.</remarks>
+		public static FinalState<TInstance> CreateFinalState<TInstance> (this State<TInstance> state, String name) where TInstance : class, IActiveStateConfiguration<TInstance> {
+			return new FinalState<TInstance> (name, state);
+		}
+	}
+}
diff --git a/src/FinalState.cs b/src/FinalState.cs
index a76f4f5..1ab4de5 100644
--- a/src/FinalState.cs
+++ b/src/FinalState.cs
@@ -10,44 +10,73 @@ namespace Steelbreeze.Behavior.StateMachines {
 	/// <summary>
 	/// A special kind of State signifying that its parent Region is completed.
 	/// </summary>
-	/// <typeparam name="TContext">The type of the state machine context.</typeparam>
+	/// <typeparam name="TInstance">The type of the state machine instance.</typeparam>
 	/// <remarks>To be complete, final states cannot have any child model structure beneath them (Region's) or outgoing transitions.</remarks>
-	public sealed class FinalState<TContext> : State<TContext> where TContext : IContext<TContext> {
-		/// <summary>
-		/// The name of the type without generic considerations
-		/// </summary>
-		public override string Type { get { return "finalState"; } }
-
+	public sealed class FinalState<TInstance> : State<TInstance> where TInstance : class, IActiveStateConfiguration<TInstance> {
 		/// <summary>
 		/// Initializes a new instance of a FinalState within the parent Region.
 		/// </summary>
 		/// <param name="name">The name of the FinalState.</param>
 		/// <param name="parent">The parent Region of the FinalState.</param>
-		public FinalState( String name, Region<TContext> parent ) : base( name, parent, Transition<TContext>.Terminate ){
-			Trace.Assert( name != null, "FinalStates must have a name" );
-			Trace.Assert( parent != null, "FinalStates must have a parent Region" );
+		public FinalState (String name, Region<TInstance> parent)
+			: base (name, parent) {
+			Trace.Assert (name != null, "FinalStates must have a name");
+			Trace.Assert (parent != null, "FinalStates must have a parent Region");
 		}
 
-		// override State's implementation of IsComplete
-		internal override Boolean IsComplete( TContext context ) {
+		/// <summary>
+		/// Tests the final state to determine if it is deemed to be complete.
+		/// </summary>
+		/// <param name="instance">The state machine instance.</param>
+		/// <returns>True if the final state is complete</returns>
+		/// <remarks>FinalStates are always deemed to be complete.</remarks>
+		public override Boolean IsComplete (TInstance instance) {
 			return true;
 		}
 
-		// do not allow FinalState's to become composite
-		internal override void Add( Region<TContext> region ) {
-			throw new NotSupportedException( "A FinalState may not be the parent of a Region" );
+		/// <summary>
+		/// Adds a region to the state.
+		/// </summary>
+		/// <param name="region">The region to add to the state.</param>
+		/// <exception cref="System.NotSupportedException">Final states cannot be composite states so Add will always throw this exception.</exception>
+		internal override void Add (Region<TInstance> region) {
+			throw new NotSupportedException ("A FinalState may not be the parent of a Region");
 		}
 
 		/// <summary>
 		/// Creates a new transition from this Vertex.
 		/// </summary>
 		/// <param name="target">The Vertex to transition to.</param>
-		/// <returns>An intance of the Transition class.</returns>
+		/// <returns>This implementation of To will not return a value.</returns>
+		/// <exception cref="System.NotSupportedException"></exception>
+		/// <remarks>
+		/// As final states may not have outbound transitions, this implementation will always throw an exception.
+		/// </remarks>
+		public override Transition<TInstance> To (Vertex<TInstance> target) {
+			throw new NotSupportedException ("A FinalState may not have outbound transitions");
+		}
+
+		/// <summary>
+		/// Selects a transition for a given message and state machine instance for the final state.
+		/// </summary>
+		/// <param name="message">The message that may trigger a transition.</param>
+		/// <param name="instance">The state machine instance.</param>
+		/// <returns>Always returns null.</returns>
+		/// <remarks>As a final state cannot have transitions, this implementation of Select will always return null.</remarks>
+		protected internal override Transition<TInstance> Select (object message, TInstance instance) {
+			return null;
+		}
+
+		/// <summary>
+		/// Accepts a visitor
+		/// </summary>
+		/// <param name="visitor">The visitor to visit.</param>
+		/// <param name="param">A parameter passed to the visitor when visiting elements.</param>
 		/// <remarks>
-		/// FinalState's are not permitted to have outgoing transitions; this method will therefore throw an exception.
+		/// A visitor will walk the state machine model from this element to all child elements including transitions calling the approritate visit method on the visitor.
 		/// </remarks>
-		public override Transition<TContext> To( Vertex<TContext> target ) {
-			throw new NotSupportedException( "Transitions my not originate from a FinalState" );
+		public override void Accept<TParam> (Visitor<TInstance, TParam> visitor, TParam param) {
+			visitor.VisitFinalState (this, param);
 		}
 	}
-}
+}
\ No newline at end of file
diff --git a/src/IContext.cs b/src/IActiveStateConfiguration.cs
similarity index 68%
rename from src/IContext.cs
rename to src/IActiveStateConfiguration.cs
index 7f5ab63..0a37ceb 100644
--- a/src/IContext.cs
+++ b/src/IActiveStateConfiguration.cs
@@ -4,20 +4,19 @@
  * Licensed under MIT and GPL v3 licences
  */
 using System;
-using System.Linq;
 
 namespace Steelbreeze.Behavior.StateMachines {
 	/// <summary>
-	/// The interface required of state machine context objects.
+	/// The interface required of state machine instances to manage the active state configuration.
 	/// </summary>
-	/// <typeparam name="TContext">The type of the derived class.</typeparam>
+	/// <typeparam name="TInstance">The type of the derived class.</typeparam>
 	/// <remarks>
 	/// By passing the type of the derived class into this base, it allows the callbacks generated by the state machine to pass the fully typed derived class.
 	/// This interface is intended for internal use only.
 	/// </remarks>
-	public interface IContext<TContext> where TContext : IContext<TContext> {
+	public interface IActiveStateConfiguration<TInstance> where TInstance : class, IActiveStateConfiguration<TInstance> {
 		/// <summary>
-		/// Indicates that the state machine context has been terminated.
+		/// Indicates that the state machine intance has been terminated.
 		/// </summary>
 		/// <remarks>A state machine is only deemed terminated if a transitions target is a Terminate PseudoState.</remarks>
 		Boolean IsTerminated { get; set; }
@@ -27,6 +26,6 @@ public interface IContext<TContext> where TContext : IContext<TContext> {
 		/// </summary>
 		/// <param name="region">The Regions to get/set the current state for.</param>
 		/// <returns>The current state of the Region or null if no value has previously been set.</returns>
-		Vertex<TContext> this[ Region<TContext> region ] { get; set; }
+		State<TInstance> this[ Region<TInstance> region ] { get; set; }
 	}
-}
+}
\ No newline at end of file
diff --git a/src/PseudoState.cs b/src/PseudoState.cs
index 3fd7fd4..d98900e 100644
--- a/src/PseudoState.cs
+++ b/src/PseudoState.cs
@@ -11,16 +11,17 @@ namespace Steelbreeze.Behavior.StateMachines {
 	/// <summary>
 	/// A PseudoState is an abstraction that encompasses different types of transient vertices in the state machine.
 	/// </summary>
-	/// <typeparam name="TContext">The type of the state machine instance.</typeparam>
+	/// <typeparam name="TInstance">The type of the state machine instance.</typeparam>
 	/// <remarks>
 	/// Pseudostates are typically used to connect multiple transitions into more complex state transitions path.
 	/// </remarks>
-	public sealed class PseudoState<TContext> : Vertex<TContext> where TContext : IContext<TContext> {
+	public sealed class PseudoState<TInstance> : Vertex<TInstance> where TInstance : class, IActiveStateConfiguration<TInstance> {
+		#region Static members
 		/// <summary>
-		/// The name of the type without generic considerations
+		/// For use in Choice pseudo states where multiple outbound transitions guards evaluate true.
 		/// </summary>
-		public override string Type { get { return "pseudoState"; } }
-
+		private static readonly Random random = new Random ();
+		#endregion
 		/// <summary>
 		/// Determines the precise type of the Pseudostate.
 		/// </summary>
@@ -29,7 +30,14 @@ public sealed class PseudoState<TContext> : Vertex<TContext> where TContext : IC
 		/// </remarks>
 		public readonly PseudoStateKind Kind;
 
+		/// <summary>
+		/// True if the pseudo state is a DeepHistory or ShallowHistory kinds.
+		/// </summary>
 		internal Boolean IsHistory { get { return this.Kind == PseudoStateKind.DeepHistory || this.Kind == PseudoStateKind.ShallowHistory; } }
+
+		/// <summary>
+		/// True if the pseudo state is an Initial, DeepHistory or ShallowHistory kinds.
+		/// </summary>
 		internal Boolean IsInitial { get { return this.Kind == PseudoStateKind.Initial || this.IsHistory; } }
 
 		/// <summary>
@@ -41,32 +49,88 @@ public sealed class PseudoState<TContext> : Vertex<TContext> where TContext : IC
 		/// <remarks>
 		/// The kind of the PseudoState dictates is use and semantics; see the documentation of PseudoStateKind.
 		/// </remarks>
-		public PseudoState( String name, Region<TContext> parent, PseudoStateKind kind = PseudoStateKind.Initial )
-			: base( name, parent, Transition<TContext>.PseudoState( kind ) ) {
-			Trace.Assert( name != null, "PseudoStates must have a name" );
-			Trace.Assert( parent != null, "PseudoStates must have a parent Region" );
+		public PseudoState (String name, Region<TInstance> parent, PseudoStateKind kind = PseudoStateKind.Initial)
+			: base (name, parent) {
+			Trace.Assert (name != null, "PseudoStates must have a name");
+			Trace.Assert (parent != null, "PseudoStates must have a parent Region");
 
 			this.Kind = kind;
 
-			if( this.IsInitial )
+			if (this.IsInitial)
 				this.Region.Initial = this;
 		}
 
 		/// <summary>
-		/// Creates a new transition from this PseudoState.
+		/// Tests the vertex to determine if it is part of the current active state confuguration
 		/// </summary>
-		/// <param name="target">The Vertex to transition to.</param>
-		/// <returns>An intance of the Transition class.</returns>
-		public override Transition<TContext> To( Vertex<TContext> target ) {
-			Trace.Assert( target != null, "Transitions from PseudoStates must have a target" );
-			return base.To( target );
+		/// <param name="instance">The state machine instance.</param>
+		/// <returns>True if the element is active.</returns>
+		public override Boolean IsActive (TInstance instance) {
+			return this.Parent.IsActive (instance);
 		}
 
-		internal override void BootstrapElement( bool deepHistoryAbove ) {
-			base.BootstrapElement( deepHistoryAbove );
+		/// <summary>
+		/// Tests the pseudo state to determine if it is deemed to be complete.
+		/// </summary>
+		/// <param name="instance">The state machine instance.</param>
+		/// <returns>True if the pseudo state is complete.</returns>
+		/// <remarks>Pseudo states are always deemed to be complete.</remarks>
+		public override bool IsComplete (TInstance instance) {
+			return true;
+		}
+
+		/// <summary>
+		/// Selects a transition for a given message and state machine instance for the pseudo state.
+		/// </summary>
+		/// <param name="message">The message that may trigger a transition.</param>
+		/// <param name="instance">The state machine instance.</param>
+		/// <returns>The selected transition.</returns>
+		/// <exception cref="System.ArgumentNullException">This exception is thown if no transition is found from the pseudo state.</exception>
+		protected internal override Transition<TInstance> Select (object message, TInstance instance) {
+			switch (this.Kind) {
+				case PseudoStateKind.Initial:
+				case PseudoStateKind.DeepHistory:
+				case PseudoStateKind.ShallowHistory:
+					return this.Transitions.Single ();
+
+				case PseudoStateKind.Choice:
+				case PseudoStateKind.Junction:
+					var transitions = this.Transitions.Where (t => t.Predicate (message, instance));
 
-			if( this.Kind == PseudoStateKind.Terminate )
-				this.Enter += ( message, context, history ) => context.IsTerminated = true;
+					switch (transitions.Count ()) {
+						case 1:
+							return transitions.Single ();
+
+						case 0:
+							transitions = this.Transitions.Where (t => t.Predicate.Equals( Transition<TInstance>.IsElse));
+
+							if( transitions.Count() == 0 )
+								throw new Exception (String.Format ("No transitions found from {0} for message {1} on instance {2}", this, message, instance));
+
+							return transitions.Single ();
+
+						default:
+							if( this.Kind == PseudoStateKind.Junction )
+								throw new Exception( String.Format( "Multiple transitions possble from {0} for message {1} on instance {2}", this, message, instance));
+
+							return transitions.ElementAt (random.Next (transitions.Count ()));
+					}
+
+				default:
+					return null;
+			}
+		}
+
+		/// <summary>
+		/// Accepts a visitor
+		/// </summary>
+		/// <param name="visitor">The visitor to visit.</param>
+		/// <param name="param">A parameter passed to the visitor when visiting elements.</param>
+		/// <remarks>
+		/// A visitor will walk the state machine model from this element to all child elements including transitions calling the approritate visit method on the visitor.
+		/// </remarks>
+		public override void Accept<TParam> (Visitor<TInstance, TParam> visitor, TParam param) {
+			visitor.VisitPseudoState (this, param);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/PseudoStateKind.cs b/src/PseudoStateKind.cs
index 820e483..0802a0c 100644
--- a/src/PseudoStateKind.cs
+++ b/src/PseudoStateKind.cs
@@ -24,10 +24,6 @@ public enum PseudoStateKind {
 		/// </summary>
 		DeepHistory,
 
-		// TODO: EntryPoint
-
-		// TODO: ExitPoint
-
 		/// <summary>
 		/// ShallowHistory represents the most recent active substate of its containing state (but not the substates of that substate).
 		/// A Region can have at most one shallow history vertex.
@@ -52,11 +48,11 @@ public enum PseudoStateKind {
 		/// Choice vertices should be distinguished from static branch points that are based on junction points.
 		/// </summary>
 		Choice,
-		
+
 		/// <summary>
-		/// Entering a Terminate pseudostate implies that the execution of this state machine by means of its context object is terminated.
+		/// Entering a Terminate pseudostate implies that the execution of this state machine instance is terminated.
 		/// The state machine does not exit any states nor does it perform any exit actions other than those associated with the transition leading to the terminate pseudostate.
 		/// </summary>
 		Terminate
 	}
-}
+}
\ No newline at end of file
diff --git a/src/RELEASES.md b/src/RELEASES.md
new file mode 100644
index 0000000..dfe1e0c
--- /dev/null
+++ b/src/RELEASES.md
@@ -0,0 +1,21 @@
+# Release notes
+
+# Version 5.0.0
+Version 5.0 is a complete re-write of the state machine. It makes large use of multicast delegates to pre-evaulate the steps required to perform state transitions. This leads to considerable performance benefits no evaluations are made relating to the structure of the model at runtime as it does not change at runtime.
+
+# Version 5.2.0
+Renamed IContext to IActiveStateConfiguration: this is more in line with the terminology in the UML specification.
+
+Renamed Context to StateMachineInstance and ContextBase to StateMachineInstanceBase.
+
+Removed XContext and XContextBase. While an interesting example of another type of state machine instance information management, it wasn't fully serializable so of little interest going forward.
+
+Added Create... extension methods to main classes to faciltate simpler model building. This removes the need for many template parameters in model building.
+
+Changed StateMachine to inherit from State. This is intented for a potential future enhancement to allow one state machine to be used within another.
+
+Implemented a Visitor patten with the introcuction of the Visitor class and Accept methods on the Transition and all Element classes.
+
+Moved the bootstrapping code to use the visitor and refactored a little.
+
+Migrated array-based code to use HashSets for simpler, cleaner code.
diff --git a/src/Region.cs b/src/Region.cs
index b558887..b4e89a4 100644
--- a/src/Region.cs
+++ b/src/Region.cs
@@ -12,11 +12,11 @@ namespace Steelbreeze.Behavior.StateMachines {
 	/// <summary>
 	/// A container of vertices within a state machine model.
 	/// </summary>
-	/// <typeparam name="TContext">The type of the state machine instance.</typeparam>
+	/// <typeparam name="TInstance">The type of the state machine instance.</typeparam>
 	/// <remarks>
 	/// All state machines and composite states will contain at least one Region; orthogonal composite states will contain more than one.
 	/// </remarks>
-	public sealed class Region<TContext> : Element<TContext> where TContext : IContext<TContext> {
+	public sealed class Region<TInstance> : Element<TInstance> where TInstance : class, IActiveStateConfiguration<TInstance> {
 		#region Static members
 		/// <summary>
 		/// The name used for default regions.
@@ -27,22 +27,10 @@ public sealed class Region<TContext> : Element<TContext> where TContext : IConte
 		public static String DefaultName { get; set; }
 
 		// Initialise the static members.
-		static Region() {
+		static Region () {
 			DefaultName = "default";
 		}
 
-		/// <summary>
-		/// Provides an implicit conversion from a StateMachine to a Region, initialising a new instance of the Region class if required under this State.
-		/// </summary>
-		/// <param name="stateMachine">The StateMachine to return the default region for.</param>
-		/// <returns>The default Region of the StateMAchine.</returns>
-		/// <remarks>
-		/// The default Region of a StateMachine is one that has the same name as defined by Region.DefaultName.
-		/// </remarks>
-		public static implicit operator Region<TContext>( StateMachine<TContext> stateMachine ) {
-			return ( stateMachine.regions == null ? null : stateMachine.regions.SingleOrDefault( r => r.Name == Region<TContext>.DefaultName ) ) ?? new Region<TContext>( Region<TContext>.DefaultName, stateMachine );
-		}
-
 		/// <summary>
 		/// Provides an implicit conversion from a State to a Region, initialising a new instance of the Region class if required under this State.
 		/// </summary>
@@ -51,51 +39,25 @@ public static implicit operator Region<TContext>( StateMachine<TContext> stateMa
 		/// <remarks>
 		/// The default Region of a composite State is one that has the same name as defined by Region.DefaultName.
 		/// </remarks>
-		public static implicit operator Region<TContext>( State<TContext> state ) {
-			if( state.regions != null ) {
-				var region = state.regions.SingleOrDefault( r => r.Name == Region<TContext>.DefaultName );
-
-				if( region != null )
-					return region;
-			}
-
-			return new Region<TContext>( Region<TContext>.DefaultName, state );
+		public static implicit operator Region<TInstance> (State<TInstance> state) {
+			return state.Regions.SingleOrDefault (r => r.Name == Region<TInstance>.DefaultName) ?? new Region<TInstance> (Region<TInstance>.DefaultName, state);
 		}
 		#endregion
 		/// <summary>
-		/// The name of the type without generic considerations
-		/// </summary>
-		public override string Type { get { return "region"; } }
-	
-		/// <summary>
-		/// Returns the Region's parent element.
+		/// The initial stating state for the region.
 		/// </summary>
-		public override Element<TContext> Parent { get { return this.parent; } }
+		/// <remarks>Note that all regions do not have to have an initial state if all entry is via external transitions.</remarks>
+		internal PseudoState<TInstance> Initial = null;
 
 		/// <summary>
-		/// The child Vertices
+		/// The vertices owned by this region.
 		/// </summary>
-		public IEnumerable<Vertex<TContext>> Vertices { get { return this.vertices; } }
-
-		internal PseudoState<TContext> Initial = null;
-
-		private readonly HashSet<Vertex<TContext>> vertices = new HashSet<Vertex<TContext>>();
-		private readonly Element<TContext> parent;
+		private readonly HashSet<Vertex<TInstance>> vertices = new HashSet<Vertex<TInstance>> ();
 
 		/// <summary>
-		/// Initialises a new instance of the Region class within a StateMachine.
+		/// The regions parement state.
 		/// </summary>
-		/// <param name="name">The name of the Region.</param>
-		/// <param name="parent">The parent StateMachine.</param>
-		public Region( String name, StateMachine<TContext> parent )
-			: base( name, parent ) {
-			Trace.Assert( name != null, "Regions must have a name" );
-			Trace.Assert( parent != null, "Regions must have a parent" );
-
-			this.parent = parent;
-
-			parent.Add( this );
-		}
+		private readonly State<TInstance> parent;
 
 		/// <summary>
 		/// Initialises a new instance of the Region class within a composite State.
@@ -105,61 +67,90 @@ public Region( String name, StateMachine<TContext> parent )
 		/// <remarks>
 		/// Adding a Region to a State makes the State a composite State.
 		/// </remarks>
-		public Region( String name, State<TContext> parent )
-			: base( name, parent ) {
-			Trace.Assert( name != null, "Regions must have a name" );
-			Trace.Assert( parent != null, "Regions must have a parent" );
+		public Region (String name, State<TInstance> parent)
+			: base (name, parent) {
+			Trace.Assert (name != null, "Regions must have a name");
+			Trace.Assert (parent != null, "Regions must have a parent");
 
-			this.Root = parent.Root;
 			this.parent = parent;
 
-			parent.Add( this );
+			parent.Add (this);
 		}
 
+
 		/// <summary>
-		/// Tests the Region to determine if it is part of the current active state confuguration
+		/// Returns the Region's parent element.
 		/// </summary>
-		/// <param name="context">The state machine context.</param>
-		/// <returns>True if the element is active.</returns>
-		internal protected override Boolean IsActive( IContext<TContext> context ) {
-			return this.Parent.IsActive( context );
+		public override Element<TInstance> Parent {
+			get {
+				return this.parent;
+			}
 		}
 
-		internal void Add( Vertex<TContext> vertex ) {
-			Trace.Assert( vertex != null, "Cannot add a null vertex" );
-			Trace.Assert( this.vertices.Where( v => v.Name == vertex.Name ).Count() == 0, "Vertices must have a unique name within the scope of their parent Region" );
-
-			this.vertices.Add( vertex );
-
-			vertex.Root.Clean = false;
+		/// <summary>
+		/// The child Vertices
+		/// </summary>
+		public IEnumerable<Vertex<TInstance>> Vertices {
+			get {
+				return this.vertices;
+			}
 		}
 
-		internal Boolean IsComplete( TContext context ) {
-			return context[ this ].IsFinal;
+		/// <summary>
+		/// Tests the Region to determine if it is part of the current active state confuguration
+		/// </summary>
+		/// <param name="instance">The state machine instance.</param>
+		/// <returns>True if the element is active.</returns>
+		public override Boolean IsActive (TInstance instance) {
+			return this.Parent.IsActive (instance);
 		}
 
-		internal override void BootstrapElement( Boolean deepHistoryAbove ) {
-			foreach( var vertex in this.vertices ) {
-				vertex.Reset();
-				vertex.BootstrapElement( deepHistoryAbove || ( this.Initial != null && this.Initial.Kind == PseudoStateKind.DeepHistory ) );
-			}
+		/// <summary>
+		/// Adds a child vertex to the region
+		/// </summary>
+		/// <param name="vertex"></param>
+		internal void Add (Vertex<TInstance> vertex) {
+			// some validation
+			Trace.Assert (vertex != null, "Cannot add a null vertex");
+			Trace.Assert (this.vertices.Where (v => v.Name == vertex.Name).Count () == 0, "Vertices must have a unique name within the scope of their parent Region");
 
-			this.Leave += ( message, context, history ) => { var current = context[ this ]; if( current.Leave != null ) current.Leave( message, context, history ); };
+			// add the vertex
+			this.vertices.Add (vertex);
 
-			if( deepHistoryAbove || this.Initial == null || this.Initial.IsHistory )
-				this.EndEnter += ( message, context, history ) => ( history || this.Initial.IsHistory ? context[ this ] ?? this.Initial : this.Initial ).Enter( message, context, history || this.Initial.Kind == PseudoStateKind.DeepHistory );
-			else this.EndEnter += this.Initial.Enter;
+			// invalidate the model
+			vertex.Root.Clean = false;
+		}
 
-			base.BootstrapElement( deepHistoryAbove );
+		/// <summary>
+		/// Tests the region to determine if it is deemed to be complete.
+		/// </summary>
+		/// <param name="instance">The state machine instance.</param>
+		/// <returns>True if the region is complete.</returns>
+		/// <remarks>A region is deemed to be complete if it current active state is complete.</remarks>
+		public override Boolean IsComplete (TInstance instance) {
+			return instance[ this ].IsFinal;
 		}
 
-		internal override void BootstrapTransitions() {
-			foreach( var vertex in this.vertices )
-				vertex.BootstrapTransitions();
+		/// <summary>
+		/// Evaluate a message to trigger a state transition.
+		/// </summary>
+		/// <param name="message">The messaege that may trigger a state transition.</param>
+		/// <param name="instance">The state machine instance.</param>
+		/// <returns>True if a transition was triggered.</returns>
+		internal Boolean Evaluate (Object message, TInstance instance) {
+			return instance[ this ].Evaluate (message, instance);
 		}
 
-		internal Boolean Evaluate( Object message, TContext context ) {
-			return context[ this ].Evaluate( message, context );
+		/// <summary>
+		/// Accepts a visitor
+		/// </summary>
+		/// <param name="visitor">The visitor to visit.</param>
+		/// <param name="param">A parameter passed to the visitor when visiting elements.</param>
+		/// <remarks>
+		/// A visitor will walk the state machine model from this element to all child elements including transitions calling the approritate visit method on the visitor.
+		/// </remarks>
+		public override void Accept<TParam> (Visitor<TInstance, TParam> visitor, TParam param) {
+			visitor.VisitRegion (this, param);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/State.cs b/src/State.cs
index 75e0ffa..dd02e61 100644
--- a/src/State.cs
+++ b/src/State.cs
@@ -12,15 +12,44 @@ namespace Steelbreeze.Behavior.StateMachines {
 	/// <summary>
 	/// A state models a situation during which some (usually implicit) invariant condition holds.
 	/// </summary>
-	/// <typeparam name="TContext">The type of the state machine instance.</typeparam>
+	/// <typeparam name="TInstance">The type of the state machine instance.</typeparam>
 	/// <remarks>
 	/// The invariant may represent a static situation such as an object waiting for some external event to occur.
 	/// </remarks>
-	public class State<TContext> : Vertex<TContext> where TContext : IContext<TContext> {
+	public class State<TInstance> : Vertex<TInstance> where TInstance : class, IActiveStateConfiguration<TInstance> {
 		/// <summary>
-		/// The name of the type without generic considerations
+		/// The child Regions where the State is composite.
+		/// </summary>
+		private readonly HashSet<Region<TInstance>> regions = new HashSet<Region<TInstance>>();
+
+		/// <summary>
+		/// The behaviour to execute when exiting the state.
+		/// </summary>
+		internal Action<Object, TInstance> exit;
+
+		/// <summary>
+		/// The behaviour to execute when entering the state.
+		/// </summary>
+		internal Action<Object, TInstance> entry;
+
+		/// <summary>
+		/// Creates a new instance of the State class.
+		/// </summary>
+		/// <param name="name">The name of the state.</param>
+		/// <param name="parent">The parent Region.</param>
+		public State (String name, Region<TInstance> parent)
+			: base (name, parent) {
+			Trace.Assert (name != null, "States must have a name");
+		}
+
+		/// <summary>
+		/// The child Regions where the State is composite.
 		/// </summary>
-		public override string Type { get { return "state"; } }
+		public IEnumerable<Region<TInstance>> Regions {
+			get {
+				return this.regions;
+			}
+		}
 
 		/// <summary>
 		/// True if the State is a simple State.
@@ -28,7 +57,11 @@ public class State<TContext> : Vertex<TContext> where TContext : IContext<TConte
 		/// <remarks>
 		/// A simple State is one that has no child Regions.
 		/// </remarks>
-		public Boolean IsSimple { get { return this.regions == null || this.regions.Length == 0; } }
+		public Boolean IsSimple {
+			get {
+				return this.regions == null || this.regions.Count == 0;
+			}
+		}
 
 		/// <summary>
 		/// True if the State is a composite State.
@@ -36,7 +69,11 @@ public class State<TContext> : Vertex<TContext> where TContext : IContext<TConte
 		/// <remarks>
 		/// A composite State is one that has one or more child Regions.
 		/// </remarks>
-		public Boolean IsComposite { get { return this.regions != null && this.regions.Length > 0; } }
+		public Boolean IsComposite {
+			get {
+				return this.regions != null && this.regions.Count > 0;
+			}
+		}
 
 		/// <summary>
 		/// True if the State is an orthogonal State.
@@ -44,51 +81,42 @@ public class State<TContext> : Vertex<TContext> where TContext : IContext<TConte
 		/// <remarks>
 		/// A composite State is one that has more than one child Regions.
 		/// </remarks>
-		public Boolean IsOrthogonal { get { return this.regions != null && this.regions.Length > 1; } }
-
-		/// <summary>
-		/// The child Regions where the State is composite.
-		/// </summary>
-		public IEnumerable<Region<TContext>> Regions { get { return this.regions; } }
-
-		internal Region<TContext>[] regions;
-
-		private event Action<Object, TContext> exit;
-		private event Action<Object, TContext> entry;
+		public Boolean IsOrthogonal {
+			get {
+				return this.regions != null && this.regions.Count > 1;
+			}
+		}
 
 		/// <summary>
-		/// Creates a new instance of the State class.
+		/// Test the state to see if it is a final state
 		/// </summary>
-		/// <param name="name">The name of the state.</param>
-		/// <param name="parent">The parent Region.</param>
-		public State( String name, Region<TContext> parent )
-			: base( name, parent, Transition<TContext>.State ) {
-			Trace.Assert( name != null, "States must have a name" );
-			Trace.Assert( parent != null, "States must have a parent Region" );
+		/// <remarks>Final states are oned that have no outbound transitions.</remarks>
+		public Boolean IsFinal {
+			get {
+				return this.Transitions.Count () == 0;
+			}
 		}
 
-		// Constructor used by FinalState
-		internal State( String name, Region<TContext> parent, Func<Transition<TContext>[], Object, TContext, Transition<TContext>> selector ) : base( name, parent, selector ) { }
 
 		/// <summary>
 		/// Tests the state to determine if it is part of the current active state confuguration
 		/// </summary>
-		/// <param name="context">The state machine context.</param>
+		/// <param name="instance">The state machine instance.</param>
 		/// <returns>True if the element is active.</returns>
-		internal protected override Boolean IsActive( IContext<TContext> context ) {
-			return base.IsActive( context ) && context[ this.Region ] == this;
+		public override Boolean IsActive (TInstance instance) {
+			return this.Parent.IsActive (instance) && instance[ this.Region ] == this;
 		}
 
 		/// <summary>
 		/// Sets optional exit behavior that is called when leaving the State.
 		/// </summary>
 		/// <typeparam name="TMessage">The type of the message that triggered the state transition.</typeparam>
-		/// <param name="behavior">One or more actions that take both the state machine context and the triggering message as parameters.</param>
+		/// <param name="behavior">One or more actions that take both the state machine instance and the triggering message as parameters.</param>
 		/// <returns>Returns the State itself.</returns>
 		/// <remarks>If the type of the triggering message does not match TMessage the behavior will not be called.</remarks>
-		public State<TContext> Exit<TMessage>( params Action<TMessage, TContext>[] behavior ) where TMessage : class {
-			foreach( var exit in behavior )
-				this.exit += ( message, context ) => { if( message is TMessage ) exit( message as TMessage, context ); };
+		public State<TInstance> Exit<TMessage> (params Action<TMessage, TInstance>[] behavior) where TMessage : class {
+			foreach (var exit in behavior)
+				this.exit += (message, instance) => { if (message is TMessage) exit (message as TMessage, instance); };
 
 			this.Root.Clean = false;
 
@@ -102,9 +130,9 @@ public State<TContext> Exit<TMessage>( params Action<TMessage, TContext>[] behav
 		/// <param name="behavior">One or more actions that takes the triggering message as a parameter.</param>
 		/// <returns></returns>
 		/// <remarks>If the type of the triggering message does not match TMessage the behavior will not be called.</remarks>
-		public State<TContext> Exit<TMessage>( params Action<TMessage>[] behavior ) where TMessage : class {
-			foreach( var exit in behavior )
-				this.exit += ( message, context ) => { if( message is TMessage ) exit( message as TMessage ); };
+		public State<TInstance> Exit<TMessage> (params Action<TMessage>[] behavior) where TMessage : class {
+			foreach (var exit in behavior)
+				this.exit += (message, instance) => { if (message is TMessage) exit (message as TMessage); };
 
 			this.Root.Clean = false;
 
@@ -114,11 +142,11 @@ public State<TContext> Exit<TMessage>( params Action<TMessage>[] behavior ) wher
 		/// <summary>
 		/// Sets optional exit behabiour that is called when leaving the State.
 		/// </summary>
-		/// <param name="behavior">One or more actions that takes the state machine context as a parameter.</param>
+		/// <param name="behavior">One or more actions that takes the state machine instance as a parameter.</param>
 		/// <returns>Returns the State itself.</returns>
-		public State<TContext> Exit( params Action<TContext>[] behavior ) {
-			foreach( var exit in behavior )
-				this.exit += ( message, context ) => exit( context );
+		public State<TInstance> Exit (params Action<TInstance>[] behavior) {
+			foreach (var exit in behavior)
+				this.exit += (message, instance) => exit (instance);
 
 			this.Root.Clean = false;
 
@@ -130,9 +158,9 @@ public State<TContext> Exit( params Action<TContext>[] behavior ) {
 		/// </summary>
 		/// <param name="behavior">One or more actions that take no parameters.</param>
 		/// <returns>Returns the State itself.</returns>
-		public State<TContext> Exit( params Action[] behavior ) {
-			foreach( var exit in behavior )
-				this.exit += ( message, context ) => exit();
+		public State<TInstance> Exit (params Action[] behavior) {
+			foreach (var exit in behavior)
+				this.exit += (message, instance) => exit ();
 
 			this.Root.Clean = false;
 
@@ -143,12 +171,12 @@ public State<TContext> Exit( params Action[] behavior ) {
 		/// Sets optional entry behavior that is called when entering the State.
 		/// </summary>
 		/// <typeparam name="TMessage">The type of the message that triggered the state transition.</typeparam>
-		/// <param name="behavior">One or more actions that take both the state machine context and the triggering message as parameters.</param>
+		/// <param name="behavior">One or more actions that take both the state machine instance and the triggering message as parameters.</param>
 		/// <returns>Returns the State itself.</returns>
 		/// <remarks>If the type of the triggering message does not match TMessage the behavior will not be called.</remarks>
-		public State<TContext> Entry<TMessage>( params Action<TMessage, TContext>[] behavior ) where TMessage : class {
-			foreach( var entry in behavior )
-				this.entry += ( message, context ) => { if( message is TMessage ) entry( message as TMessage, context ); };
+		public State<TInstance> Entry<TMessage> (params Action<TMessage, TInstance>[] behavior) where TMessage : class {
+			foreach (var entry in behavior)
+				this.entry += (message, instance) => { if (message is TMessage) entry (message as TMessage, instance); };
 
 			this.Root.Clean = false;
 
@@ -162,9 +190,9 @@ public State<TContext> Entry<TMessage>( params Action<TMessage, TContext>[] beha
 		/// <param name="behavior">One or more actions that takes the triggering message as a parameter.</param>
 		/// <returns>Returns the State itself.</returns>
 		/// <remarks>If the type of the triggering message does not match TMessage the behavior will not be called.</remarks>
-		public State<TContext> Entry<TMessage>( params Action<TMessage>[] behavior ) where TMessage : class {
-			foreach( var entry in behavior )
-				this.entry += ( message, context ) => { if( message is TMessage ) entry( message as TMessage ); };
+		public State<TInstance> Entry<TMessage> (params Action<TMessage>[] behavior) where TMessage : class {
+			foreach (var entry in behavior)
+				this.entry += (message, instance) => { if (message is TMessage) entry (message as TMessage); };
 
 			this.Root.Clean = false;
 
@@ -174,11 +202,11 @@ public State<TContext> Entry<TMessage>( params Action<TMessage>[] behavior ) whe
 		/// <summary>
 		/// Sets optional entry behavior that is called when entering the State.
 		/// </summary>
-		/// <param name="behavior">One or more actions that takes the state machine context as a parameter.</param>
+		/// <param name="behavior">One or more actions that takes the state machine instance as a parameter.</param>
 		/// <returns>Returns the State itself.</returns>
-		public State<TContext> Entry( params Action<TContext>[] behavior ) {
-			foreach( var entry in behavior )
-				this.entry += ( message, context ) => entry( context );
+		public State<TInstance> Entry (params Action<TInstance>[] behavior) {
+			foreach (var entry in behavior)
+				this.entry += (message, instance) => entry (instance);
 
 			this.Root.Clean = false;
 
@@ -190,9 +218,9 @@ public State<TContext> Entry( params Action<TContext>[] behavior ) {
 		/// </summary>
 		/// <param name="behavior">One or more actions that takes no parameters.</param>
 		/// <returns>Returns the State itself.</returns>
-		public State<TContext> Entry( params Action[] behavior ) {
-			foreach( var entry in behavior )
-				this.entry += ( message, context ) => entry();
+		public State<TInstance> Entry (params Action[] behavior) {
+			foreach (var entry in behavior)
+				this.entry += (message, instance) => entry ();
 
 			this.Root.Clean = false;
 
@@ -208,8 +236,8 @@ public State<TContext> Entry( params Action[] behavior ) {
 		/// <remarks>
 		/// An internal transition does not exit or enter any states, however the transitions effect will be invoked if the guard condition of the transition is met
 		/// </remarks>
-		public Transition<TContext> When<TMessage>( Func<TMessage, TContext, Boolean> guard ) where TMessage : class {
-			return this.To( null ).When( guard );
+		public Transition<TInstance> When<TMessage> (Func<TMessage, TInstance, Boolean> guard) where TMessage : class {
+			return this.To (null).When (guard);
 		}
 
 		/// <summary>
@@ -218,109 +246,95 @@ public Transition<TContext> When<TMessage>( Func<TMessage, TContext, Boolean> gu
 		/// <typeparam name="TMessage">The type of the messaage that the internal transition will react to.</typeparam>
 		/// <param name="guard">The guard condition that must be met for hte transition to be traversed.</param>
 		/// <returns>The internal transition.</returns>
-		public Transition<TContext> When<TMessage>( Func<TMessage, Boolean> guard ) where TMessage : class {
-			return this.To( null ).When( guard );
+		public Transition<TInstance> When<TMessage> (Func<TMessage, Boolean> guard) where TMessage : class {
+			return this.To (null).When (guard);
 		}
 
 		/// <summary>
 		/// Invokes the Exit behavior upon exiting a State.
 		/// </summary>
-		/// <param name="context">The state machine context.</param>
+		/// <param name="instance">The state machine instance.</param>
 		/// <param name="message">The message that triggered the state transition.</param>
 		/// <param name="history">A flag denoting if history semantics were in play during the transition.</param>
-		protected virtual void OnExit( Object message, TContext context, Boolean history ) {
-			this.exit( message, context );
+		public virtual void OnExit (Object message, TInstance instance, Boolean history) {
+			this.exit (message, instance);
 		}
 
 		/// <summary>
 		/// Invokes the Entry behavior upon entering a State.
 		/// </summary>
-		/// <param name="context">The state machine context.</param>
+		/// <param name="instance">The state machine instance.</param>
 		/// <param name="message">The message that triggered the state transition.</param>
 		/// <param name="history">A flag denoting if history semantics were in play during the transition.</param>
-		protected virtual void OnEntry( Object message, TContext context, Boolean history ) {
-			this.entry( message, context );
+		public virtual void OnEntry (Object message, TInstance instance, Boolean history) {
+			this.entry (message, instance);
 		}
 
-		internal override Boolean IsComplete( TContext context ) {
-			return this.IsSimple || this.regions.All( region => region.IsComplete( context ) );
+		/// <summary>
+		/// Tests the element to determine if it is deemed to be complete.
+		/// </summary>
+		/// <param name="instance">The state machine instance.</param>
+		/// <returns>True if the state is complete</returns>
+		/// <remarks>Simple states are always deemed to be complete; composite states are complete if all child regions are complete.</remarks>
+		public override Boolean IsComplete (TInstance instance) {
+			return this.IsSimple || this.regions.All (region => region.IsComplete (instance));
 		}
 
-		internal virtual void Add( Region<TContext> region ) {
-			if( this.regions == null )
-				this.regions = new Region<TContext>[ 1 ] { region };
-			else {
-				Trace.Assert( this.regions.Where( r => r.Name == region.Name ).Count() == 0, "Regions must have a unique name within the scope of their parent State" );
-
-				var regions = new Region<TContext>[ this.regions.Length + 1 ];
-
-				this.regions.CopyTo( regions, 0 );
-
-				regions[ this.regions.Length ] = region;
-
-				this.regions = regions;
-			}
+		/// <summary>
+		/// Adds a new child region to the state.
+		/// </summary>
+		/// <param name="region">The child region to add to the state.</param>
+		/// <remarks>Adding regions to a state turns the state in to a composite state.</remarks>
+		internal virtual void Add (Region<TInstance> region) {
+			this.regions.Add (region);
 
 			region.Root.Clean = false;
 		}
 
-		internal override void BootstrapElement( Boolean deepHistoryAbove ) {
-			if( this.IsComposite ) {
-				foreach( var region in this.regions ) {
-					region.Reset();
-					region.BootstrapElement( deepHistoryAbove );
-
-					this.Leave += ( message, context, history ) => region.Leave( message, context, history );
-					this.EndEnter += region.Enter;
-				}
-			}
-
-			base.BootstrapElement( deepHistoryAbove );
-
-			if( this.exit != null )
-				this.Leave += this.OnExit;
-
-			if( this.entry != null )
-				this.BeginEnter += this.OnEntry;
-
-			this.BeginEnter += ( message, context, history ) => context[ this.Region ] = this;
-
-			this.Enter = this.BeginEnter + this.EndEnter;
-		}
-
-		internal override void BootstrapTransitions() {
-			if( this.IsComposite )
-				foreach( var region in this.regions )
-					region.BootstrapTransitions();
-
-			base.BootstrapTransitions();
-		}
-
-		internal override void BootstrapEnter( ref Action<Object, TContext, Boolean> traverse, Element<TContext> next ) {
-			base.BootstrapEnter( ref traverse, next );
-
-			if( this.IsOrthogonal )
-				foreach( var region in this.regions )
-					if( region != next )
-						traverse += region.Enter;
+		/// <summary>
+		/// Algorithm for selecting the transitions
+		/// </summary>
+		/// <param name="message">The message that may trigger a transition.</param>
+		/// <param name="instance">The state machine instance.</param>
+		/// <returns>Returns a single transition whose predicate evaluates true for the message and state machine instance, or null.</returns>
+		/// <exception cref="System.ArgumentNullException">If more than one transitions predicate evaluates true the model is deemed to be malformed.</exception>
+		protected internal override Transition<TInstance> Select (object message, TInstance instance) {
+			return this.Transitions.SingleOrDefault( t => t.Predicate( message, instance ) );
 		}
 
-		internal override Boolean Evaluate( Object message, TContext context ) {
+		/// <summary>
+		/// Evaluates a state to determine if a transition should be traversed.
+		/// </summary>
+		/// <param name="message">The message that may cause a state transition.</param>
+		/// <param name="instance">The state machine instance.</param>
+		/// <returns>True if a state transition occured.</returns>
+		internal override Boolean Evaluate (Object message, TInstance instance) {
 			var processed = false;
 
-			if( this.IsComposite )
-				for( int i = 0, l = this.regions.Length; i < l; ++i )
-					if( this.IsActive( context ) == true )
-						if( this.regions[ i ].Evaluate( message, context ) )
-							processed = true;
+			foreach (var region in this.regions)
+				if (this.IsActive (instance) == true)
+					if (region.Evaluate (message, instance))
+						processed = true;
 
-			if( !processed )
-				processed = base.Evaluate( message, context );
+			if (!processed)
+				processed = base.Evaluate (message, instance);
 
-			if( processed == true && message != this )
-				this.EvaluateCompletions( this, context, false );
+			if (processed == true && message != this)
+				this.Completion (this, instance, false);
 
 			return processed;
 		}
+
+		/// <summary>
+		/// Accepts a visitor
+		/// </summary>
+		/// <param name="visitor">The visitor to visit.</param>
+		/// <param name="param">A parameter passed to the visitor when visiting elements.</param>
+		/// <remarks>
+		/// A visitor will walk the state machine model from this element to all child elements including transitions calling the approritate visit method on the visitor.
+		/// </remarks>
+		public override void Accept<TParam> (Visitor<TInstance, TParam> visitor, TParam param) {
+			visitor.VisitState (this, param);
+		}
 	}
-}
+}
\ No newline at end of file
diff --git a/src/StateMachine.cs b/src/StateMachine.cs
index 0807b3d..759a735 100644
--- a/src/StateMachine.cs
+++ b/src/StateMachine.cs
@@ -4,75 +4,63 @@
  * Licensed under MIT and GPL v3 licences
  */
 using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
+//using System.Collections.Generic;
 
-// TODO: inherit from State (thereby enabling a machine to be used in another region if required)
 namespace Steelbreeze.Behavior.StateMachines {
 	/// <summary>
 	/// A StateMachine is the root node of a hierarchical state machine model.
 	/// </summary>
-	/// <typeparam name="TContext">The type of the state machine context.</typeparam>
-	public sealed class StateMachine<TContext> : Element<TContext> where TContext : IContext<TContext> {
+	/// <typeparam name="TInstance">The type of the state machine instance.</typeparam>
+	public class StateMachine<TInstance> : State<TInstance> where TInstance : class, IActiveStateConfiguration<TInstance> {
+		#region Static members
 		/// <summary>
-		/// The name of the type without generic considerations
+		/// The visitor used to bootstrap the state machine model.
 		/// </summary>
-		public override string Type { get { return "stateMachineModel"; } }
-	
+		private static Bootstrap<TInstance> Bootstrap = new Bootstrap<TInstance> ();
+		#endregion
+		
 		/// <summary>
-		/// The child Regions.
+		/// Initialises a state machine instance to its initial state.
 		/// </summary>
-		public IEnumerable<Region<TContext>> Regions { get { return this.regions; } }
-	
-		internal Boolean Clean { get; set; }
-		internal Region<TContext>[] regions;
-	
+		internal Action<Object, TInstance, Boolean> initialise = null;
+
 		/// <summary>
-		/// Returns the elements parent.
+		/// Flag to denote that a state machine model requires bootstrapping.
 		/// </summary>
-		/// <remarks>
-		/// A StateMachine will have no parent; this value will always be null.
-		/// </remarks>
-		public override Element<TContext> Parent { get { return null; } }
+		internal Boolean Clean { get; set; }
 
 		/// <summary>
 		/// Initialises a new instance of the StateMachine class.
 		/// </summary>
 		/// <param name="name">The name of the StateMachine.</param>
-		public StateMachine( String name )
-			: base( name, null ) {
-
-			Trace.Assert( name != null, "StateMachines must have a name" );
-
-			this.Root = this;
+		public StateMachine (String name)
+			: base (name, null) {
 		}
 
 		/// <summary>
-		/// Tests the StateMachine  to determine if it is part of the current active state confuguration
+		/// The parent state machine that this element forms a part of.
 		/// </summary>
-		/// <param name="context">The state machine context.</param>
-		/// <returns>True if the element is active.</returns>
-		internal protected override Boolean IsActive( IContext<TContext> context ) {
-			return true;
+		public override StateMachine<TInstance> Root {
+			get {
+				return Parent == null ? this : Parent.Root;
+			}
 		}
 
-		internal void Add( Region<TContext> region ) {
-			if( this.regions == null )
-				this.regions = new Region<TContext>[ 1 ] { region };
-			else {
-				Trace.Assert( this.regions.Where( r => r.Name == region.Name ).Count() == 0, "Regions must have a unique name within the scope of their parent StateMachine" );
-
-				var regions = new Region<TContext>[ this.regions.Length + 1 ];
-
-				this.regions.CopyTo( regions, 0 );
-
-				regions[ this.regions.Length ] = region;
-
-				this.regions = regions;
-			}
+		/// <summary>
+		/// Returns the elements parent.
+		/// </summary>
+		/// <remarks>
+		/// A StateMachine will have no parent; this value will always be null.
+		/// </remarks>
+		public override Element<TInstance> Parent { get { return null; } }
 
-			this.Clean = false;
+		/// <summary>
+		/// Tests the element to determine if it is part of the current active state confuguration
+		/// </summary>
+		/// <param name="instance">The state machine instance.</param>
+		/// <returns>True if the element is active.</returns>
+		public override bool IsActive (TInstance instance) {
+			return Parent == null ? true : base.IsActive (instance);
 		}
 
 		/// <summary>
@@ -80,81 +68,57 @@ internal void Add( Region<TContext> region ) {
 		/// </summary>
 		/// <remarks>
 		/// Initialising a state machine model pre-compiles all the transitions.
-		/// This process will be triggered automatically on any call to StateMachine.Initialise( TContext context ) or StateMachine.Process if the model structure has changed.
-		/// If you want to take greater control of when this happens, pass autoInitialise = false to StateMachine.Initialise( TContext context ) or StateMachine.Process and call Initialise as required instead.
+		/// This process will be triggered automatically on any call to StateMachine.Initialise or StateMachine.Process if the model structure has changed.
+		/// If you want to take greater control of when this happens, pass autoInitialise = false to StateMachine.Initialise or StateMachine.Process and call Initialise as required instead.
 		/// </remarks>
-		public void Initialise() {
-			this.Reset();
+		public void Initialise () {
 			this.Clean = true;
 
-			this.BootstrapElement( false );
-			this.BootstrapTransitions();
+			this.Accept (Bootstrap, false);
 		}
 
 		/// <summary>
-		/// Initialises a state machine context to its initial state; this causes the state machine context to enter its initial state.
+		/// Initialises a state machine instance to its initial state; this causes the state machine instance to enter its initial state.
 		/// </summary>
-		/// <param name="context">The state machine context.</param>
-		/// <param name="autoInitialise">True if you wish to automatically re-initialise the state machine model prior to initialising the state machine context.</param>
-		public void Initialise( TContext context, Boolean autoInitialise = true ) {
-			if( !this.Clean && autoInitialise )
-				this.Initialise();
-
-			this.Enter( null, context, false );
-		}
+		/// <param name="instance">The state machine instance.</param>
+		/// <param name="autoInitialise">True if you wish to automatically re-initialise the state machine model prior to initialising the state machine instance.</param>
+		public void Initialise (TInstance instance, Boolean autoInitialise = true) {
+			if (!this.Clean && autoInitialise)
+				this.Initialise ();
 
-		/// <summary>
-		/// Determines if the state machine context has completed its processsing.
-		/// </summary>
-		/// <param name="context">The state machine context to test completeness for.</param>
-		/// <returns>True if the state machine context has completed.</returns>
-		/// <remarks>
-		/// A state machine context is deemed complete when all its child Regions are complete.
-		/// A Region is deemed complete if its current state is a FinalState (States are also considered to be FinalStates if there are no outbound transitions).
-		/// In addition, if a state machine context is terminated (by virtue of a transition to a Terminate PseudoState) it is also deemed to be completed.
-		/// </remarks>
-		public Boolean IsComplete( TContext context ) {
-			return context.IsTerminated || this.regions.All( region => region.IsComplete( context ) );
+			this.initialise (null, instance, false);
 		}
 
 		/// <summary>
-		/// Pass a message to a state machine context for evaluation.
+		/// Pass a message to a state machine instance for evaluation.
 		/// </summary>
-		/// <param name="context">The state machine context to evaluate the message against.</param>
+		/// <param name="instance">The state machine instance to evaluate the message against.</param>
 		/// <param name="message">The message to evaluate.</param>
 		/// <param name="autoInitialise">True if you wish to automatically re-initialise the state machine model prior to evaluating the message.</param>
 		/// <returns>True if the message triggered a state transition.</returns>
 		/// <remarks>
 		/// Note that due to the potential for orthogonal Regions in composite States, it is possible for multiple transitions to be triggered.
 		/// </remarks>
-		public Boolean Evaluate( Object message, TContext context, Boolean autoInitialise = true ) {
-			if( !this.Clean && autoInitialise )
-				this.Initialise();
+		public Boolean Evaluate (Object message, TInstance instance, Boolean autoInitialise = true) {
+			if (!this.Clean && autoInitialise)
+				this.Initialise ();
 
-			Boolean processed = false;
+			if (instance.IsTerminated)
+				return false;
 
-			if( !context.IsTerminated )
-				for( int i = 0, l = this.regions.Length; i < l; ++i )
-					if( this.regions[ i ].Evaluate( message, context ) )
-						processed = true;
-
-			return processed;
-		}
-
-		internal override void BootstrapElement( Boolean deepHistoryAbove ){
-			foreach( var region in this.regions ) {
-				region.Reset();
-				region.BootstrapElement( deepHistoryAbove );
-
-				this.EndEnter += region.Enter;
-			}
-
-			base.BootstrapElement( deepHistoryAbove);
+			return base.Evaluate (message, instance);
 		}
 
-		internal override void BootstrapTransitions() {
-			foreach( var region in this.regions )
-				region.BootstrapTransitions();
+		/// <summary>
+		/// Accepts a visitor
+		/// </summary>
+		/// <param name="visitor">The visitor to visit.</param>
+		/// <param name="param">A parameter passed to the visitor when visiting elements.</param>
+		/// <remarks>
+		/// A visitor will walk the state machine model from this element to all child elements including transitions calling the approritate visit method on the visitor.
+		/// </remarks>
+		public override void Accept<TParam> (Visitor<TInstance, TParam> visitor, TParam param) {
+			visitor.VisitStateMachine (this, param);
 		}
 	}
-}
+}
\ No newline at end of file
diff --git a/src/StateMachineInstance.cs b/src/StateMachineInstance.cs
new file mode 100644
index 0000000..ad0b28f
--- /dev/null
+++ b/src/StateMachineInstance.cs
@@ -0,0 +1,34 @@
+/* State v5 finite state machine library
+ * http://www.steelbreeze.net/state.cs
+ * Copyright (c) 2014-5 Steelbreeze Limited
+ * Licensed under MIT and GPL v3 licences
+ */
+using System;
+
+namespace Steelbreeze.Behavior.StateMachines {
+	/// <summary>
+	/// A simple class to extend as a base for state machine intsances.
+	/// </summary>
+	public class StateMachineInstance : StateMachineInstanceBase<StateMachineInstance> {
+		/// <summary>
+		/// The name of the state machine instance
+		/// </summary>
+		public readonly String Name;
+
+		/// <summary>
+		/// Create a new instance of hte StateMachineInstance class.
+		/// </summary>
+		/// <param name="name">The name of the state machin instance</param>
+		public StateMachineInstance (String name) {
+			this.Name = name;
+		}
+
+		/// <summary>
+		/// Returns the name of the state machine instance
+		/// </summary>
+		/// <returns>The name of the state machine instance</returns>
+		public override string ToString () {
+			return this.Name;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/DictionaryContextBase.cs b/src/StateMachineInstanceBase.cs
similarity index 54%
rename from src/DictionaryContextBase.cs
rename to src/StateMachineInstanceBase.cs
index 3eee60d..f3a5937 100644
--- a/src/DictionaryContextBase.cs
+++ b/src/StateMachineInstanceBase.cs
@@ -8,34 +8,34 @@
 
 namespace Steelbreeze.Behavior.StateMachines {
 	/// <summary>
-	/// A simple sample of an object to extend as a base for a state machine context object.
+	/// A simple abstract class to extend as a base for a state machine instances.
 	/// </summary>
-	/// <typeparam name="TContext">The type of the derived context class.</typeparam>
+	/// <typeparam name="TInstance">The type of the derived IActiveStateConfiguration class.</typeparam>
 	/// <remarks>
 	/// By passing the type of the derived class into this base, it allows the callbacks generated by the state machine to pass the fully typed derived class.
 	/// Note that properties and methods have been explicitly implemented to hide the members from use other than via the IContext interface.
-	/// Should you need persistence, or other such behaviour relating to the context class, implement another class implementing IContext.
+	/// Should you need persistence, or other such behaviour relating to the instance class, create a custom class implementing IActiveStateConfiguration.
 	/// </remarks>
-	public abstract class DictionaryContextBase<TContext> : IContext<TContext> where TContext : IContext<TContext> {
+	public abstract class StateMachineInstanceBase<TInstance> : IActiveStateConfiguration<TInstance> where TInstance : class, IActiveStateConfiguration<TInstance> {
 		// use a dictionary to store the last known state of a Region
-		private readonly Dictionary<Region<TContext>, Vertex<TContext>> last = new Dictionary<Region<TContext>, Vertex<TContext>>();
+		private readonly Dictionary<Region<TInstance>, State<TInstance>> active = new Dictionary<Region<TInstance>, State<TInstance>> ();
 
 		/// <summary>
-		/// Indicates that the state machine context has been terminated.
+		/// Indicates that the state machine instance has been terminated.
 		/// </summary>
 		/// <remarks>A state machine is only deemed terminated if a transitions target is a Terminate PseudoState.</remarks>
 		public Boolean IsTerminated { get; set; }
 
 		// sets and gets the current state of a specified Region
-		Vertex<TContext> IContext<TContext>.this[ Region<TContext> region ] {
+		State<TInstance> IActiveStateConfiguration<TInstance>.this[ Region<TInstance> region ] {
 			set {
-				last[ region ] = value;
+				this.active[ region ] = value;
 			}
 
 			get {
-				var value = default( Vertex<TContext> );
+				var value = default (State<TInstance>);
 
-				last.TryGetValue( region, out value );
+				this.active.TryGetValue (region, out value);
 
 				return value;
 			}
diff --git a/src/TODO (DMM-WIN7's conflicted copy 2015-03-23).md b/src/TODO (DMM-WIN7's conflicted copy 2015-03-23).md
new file mode 100644
index 0000000..a5dfd47
--- /dev/null
+++ b/src/TODO (DMM-WIN7's conflicted copy 2015-03-23).md	
@@ -0,0 +1,6 @@
+Visitor pattern
+- implement bootstrapEnter as visitor
+
+Let bootstrapper create a materialised view of myTransitions
+
+Move fluent interface into Extensions
\ No newline at end of file
diff --git a/src/Transition.cs b/src/Transition.cs
index 4ffe551..6eb5ac9 100644
--- a/src/Transition.cs
+++ b/src/Transition.cs
@@ -4,117 +4,70 @@
  * Licensed under MIT and GPL v3 licences
  */
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
 
 namespace Steelbreeze.Behavior.StateMachines {
 	/// <summary>
 	/// A Transition describes a valid path from one Vertex in a state machine to another, and the trigger that will cause it to be followed.
 	/// </summary>
-	/// <typeparam name="TContext">The type of the state machine instance.</typeparam>
+	/// <typeparam name="TInstance">The type of the state machine instance.</typeparam>
 	/// <remarks>
 	/// There are two types of transition, completion transitions and message based transitions.
 	/// Completion transitions are evaluated when a vertex has been entered and is deemed to be complete; this is the default for newly created transitions.
-	/// Message based transitions have an additional guard condition that a message (event) and the current state machine context will be evaluated against; this is defined by the Transition.When method thereby turning a completion transition into a message based transition.
+	/// Message based transitions have an additional guard condition that a message (event) and the current state machine instance will be evaluated against; this is defined by the Transition.When method thereby turning a completion transition into a message based transition.
 	/// </remarks>
-	public class Transition<TContext> where TContext : IContext<TContext> {
+	public class Transition<TInstance> where TInstance : class, IActiveStateConfiguration<TInstance> {
 		#region Static members
-		private static Func<Object, TContext, Boolean> IsElse = ( message, context ) => false;
-
-		internal static Func<Transition<TContext>[], Object, TContext, Transition<TContext>> PseudoState( PseudoStateKind kind ) {
-			switch( kind ) {
-				case PseudoStateKind.Initial:
-				case PseudoStateKind.DeepHistory:
-				case PseudoStateKind.ShallowHistory:
-					return Transition<TContext>.Initial;
-
-				case PseudoStateKind.Junction:
-					return Transition<TContext>.Junction;
-				
-				case PseudoStateKind.Choice:
-					return Transition<TContext>.Choice;
-	
-				case PseudoStateKind.Terminate:
-					return Transition<TContext>.Terminate;
-
-				default: // NOTE: all PseudoStateKinds dealt with above so should not be an issue
-					return null;
-			}
-		}
-
-		internal static Transition<TContext> State( Transition<TContext>[] transitions, Object message, TContext context ) {
-			Transition<TContext> result = null;
-
-			if( transitions != null ) {
-				for( int i = 0, l = transitions.Length; i < l; ++i ) {
-					if( transitions[ i ].Predicate( message, context ) ) {
-						if( result != null )
-							throw new InvalidOperationException( "Multiple outbound transitions evaluated true" );
-
-						result = transitions[ i ];
-					}
-				}
-			}
-
-			return result;
-		}
-
-		private static Transition<TContext> Initial( Transition<TContext>[] transitions, Object message, TContext context ) {
-			if( transitions.Length == 1 )
-				return transitions[ 0 ];
-			else
-				throw new InvalidOperationException( "Initial transition must have a single outbound transition" );
-		}
-
-		private static Transition<TContext> Junction( Transition<TContext>[] transitions, Object message, TContext context ) {
-			return transitions.SingleOrDefault( t => t.Predicate( message, context ) ) ?? transitions.Single( transition => transition.Predicate.Equals( Transition<TContext>.IsElse ) );
-		}
-
-		private static readonly Random random = new Random();
-
-		private static Transition<TContext> Choice( Transition<TContext>[] transitions, Object message, TContext context ) {
-			var transition = default( Transition<TContext> );
-			var items = transitions.Where( t => t.Predicate( message, context ) );
-			var count = items.Count();
-
-			if( count == 1 )
-				transition = items.First();
+		internal static Func<Object, TInstance, Boolean> IsElse = (message, instance) => false;
+		#endregion
+		/// <summary>
+		/// The source vertex of the transition.
+		/// </summary>
+		public readonly Vertex<TInstance> Source;
 
-			else if( count > 1 )
-				transition = items.ElementAt( random.Next( count ) );
+		/// <summary>
+		/// The target vertex of the transition. 
+		/// </summary>
+		/// <remarks>The target may be null for internal transitions.</remarks>
+		public readonly Vertex<TInstance> Target;
 
-			return transition ?? transitions.Single( t => t.Predicate.Equals( Transition<TContext>.IsElse ) );
-		}
+		/// <summary>
+		/// The predicate that must evaluate true before a transition may be traversed.
+		/// </summary>
+		public Func<Object, TInstance, Boolean> Predicate;
 
-		internal static Transition<TContext> Terminate( Transition<TContext>[] transitions, Object message, TContext context ) {
-			return null;
-		}
-		#endregion
-		internal readonly Vertex<TContext> Source;
-		internal readonly Vertex<TContext> Target;
-		internal Func<Object, TContext, Boolean> Predicate;
-		internal Action<Object, TContext, Boolean> Traverse;
+		/// <summary>
+		/// The complete bootstrapped behaviour performed when traversing a transition.
+		/// </summary>
+		internal Action<Object, TInstance, Boolean> Traverse;
 
-		private event Action<Object, TContext> effect;
+		/// <summary>
+		/// The user defined behaviour for transition traversal.
+		/// </summary>
+		internal Action<Object, TInstance> effect;
 
-		internal Transition( Vertex<TContext> source, Vertex<TContext> target ) {
-			Trace.Assert( source != null, "Transitions must have a source Vertex" );
+		/// <summary>
+		/// Creates a new instance of the Transition class
+		/// </summary>
+		/// <param name="source">The source vertex</param>
+		/// <param name="target">The target vertex</param>
+		public Transition (Vertex<TInstance> source, Vertex<TInstance> target = null) {
+			Trace.Assert (source != null, "Transitions must have a source Vertex");
 
 			this.Source = source;
 			this.Target = target;
 
-			this.Completion();
+			this.Completion ();
 		}
 
 		/// <summary>
-		/// Adds a typed guard condition to a transition that can evaluate both the state machine context and the triggering message.
+		/// Adds a typed guard condition to a transition that can evaluate both the state machine instance and the triggering message.
 		/// </summary>
 		/// <typeparam name="TMessage">The type of the message that can trigger the transition.</typeparam>
-		/// <param name="guard">The guard condition taking both the state machine context and the message that must evaluate true for the transition to be traversed.</param>
+		/// <param name="guard">The guard condition taking both the state machine instance and the message that must evaluate true for the transition to be traversed.</param>
 		/// <returns>Returns the transition.</returns>
-		public Transition<TContext> When<TMessage>( Func<TMessage, TContext, Boolean> guard ) where TMessage : class {
-			this.Predicate = ( message, context ) => message is TMessage && guard( message as TMessage, context );
+		public Transition<TInstance> When<TMessage> (Func<TMessage, TInstance, Boolean> guard) where TMessage : class {
+			this.Predicate = (message, instance) => message is TMessage && guard (message as TMessage, instance);
 
 			return this;
 		}
@@ -125,8 +78,8 @@ public Transition<TContext> When<TMessage>( Func<TMessage, TContext, Boolean> gu
 		/// <typeparam name="TMessage">The type of the message that can trigger the transition.</typeparam>
 		/// <param name="guard">A guard condition taking the message that must evaluate true for the transition to be traversed.</param>
 		/// <returns>Returns the transition.</returns>
-		public Transition<TContext> When<TMessage>( Func<TMessage, Boolean> guard ) where TMessage : class {
-			this.Predicate = ( message, context ) => message is TMessage && guard( message as TMessage );
+		public Transition<TInstance> When<TMessage> (Func<TMessage, Boolean> guard) where TMessage : class {
+			this.Predicate = (message, instance) => message is TMessage && guard (message as TMessage);
 
 			return this;
 		}
@@ -134,10 +87,10 @@ public Transition<TContext> When<TMessage>( Func<TMessage, Boolean> guard ) wher
 		/// <summary>
 		/// Adds a guard condition to a transition that can evaluate the triggering message.
 		/// </summary>
-		/// <param name="guard">A guard condition, taking just the state machine context, that must evaluate true for the transition to be traversed.</param>
+		/// <param name="guard">A guard condition, taking just the state machine instance, that must evaluate true for the transition to be traversed.</param>
 		/// <returns>Returns the transition.</returns>
-		public Transition<TContext> When( Func<TContext, Boolean> guard ) {
-			this.Predicate = ( message, context ) => guard( context );
+		public Transition<TInstance> When (Func<TInstance, Boolean> guard) {
+			this.Predicate = (message, instance) => guard (instance);
 
 			return this;
 		}
@@ -149,8 +102,8 @@ public Transition<TContext> When( Func<TContext, Boolean> guard ) {
 		/// <remarks>
 		/// All transitions are completion tansitions when initially created; this method can be used to return a transition to be a completion transition if prior calls to When or Else have been made.
 		/// </remarks>
-		public Transition<TContext> Completion() {
-			this.Predicate = ( message, context ) => message == this.Source;
+		public Transition<TInstance> Completion () {
+			this.Predicate = (message, instance) => message == this.Source;
 
 			return this;
 		}
@@ -159,10 +112,10 @@ public Transition<TContext> Completion() {
 		/// Creates an else transition for use with Choice and Junction PseudoStates.
 		/// </summary>
 		/// <returns>Returns the transition.</returns>
-		public Transition<TContext> Else() {
-			Trace.Assert( this.Source is PseudoState<TContext> && ( ( this.Source as PseudoState<TContext> ).Kind == PseudoStateKind.Choice || ( this.Source as PseudoState<TContext> ).Kind == PseudoStateKind.Junction ), "Else is only allowed for transitions from Choice or Junction PseudoStates" );
+		public Transition<TInstance> Else () {
+			Trace.Assert (this.Source is PseudoState<TInstance> && ((this.Source as PseudoState<TInstance>).Kind == PseudoStateKind.Choice || (this.Source as PseudoState<TInstance>).Kind == PseudoStateKind.Junction), "Else is only allowed for transitions from Choice or Junction PseudoStates");
 
-			this.Predicate = Transition<TContext>.IsElse;
+			this.Predicate = Transition<TInstance>.IsElse;
 
 			return this;
 		}
@@ -171,17 +124,17 @@ public Transition<TContext> Else() {
 		/// Adds behavior to a transition.
 		/// </summary>
 		/// <typeparam name="TMessage">The type of the message that triggered the transition.</typeparam>
-		/// <param name="behavior">An Action that takes the state machine context and triggering messages as parameters.</param>
+		/// <param name="behavior">An Action that takes the state machine instance and triggering messages as parameters.</param>
 		/// <returns>Returns the transition.</returns>
 		/// <remarks>
 		/// If the type of the message that triggers the transition does not match TMessage, the behavior will not be called.
 		/// </remarks>
-		public Transition<TContext> Effect<TMessage>( params Action<TMessage, TContext>[] behavior ) where TMessage : class {
-			foreach( var effect in behavior )
-				this.effect += ( message, context ) => { if( message is TMessage ) effect( message as TMessage, context ); };
+		public Transition<TInstance> Effect<TMessage> (params Action<TMessage, TInstance>[] behavior) where TMessage : class {
+			foreach (var effect in behavior)
+				this.effect += (message, instance) => { if (message is TMessage) effect (message as TMessage, instance); };
 
 			this.Source.Root.Clean = false;
-			
+
 			return this;
 		}
 
@@ -194,26 +147,26 @@ public Transition<TContext> Effect<TMessage>( params Action<TMessage, TContext>[
 		/// <remarks>
 		/// If the type of the message that triggers the transition does not match TMessage, the behavior will not be called.
 		/// </remarks>
-		public Transition<TContext> Effect<TMessage>( params Action<TMessage>[] behavior ) where TMessage : class {
-			foreach( var effect in behavior )
-				this.effect += ( message, context ) => { if( message is TMessage ) effect( message as TMessage ); };
+		public Transition<TInstance> Effect<TMessage> (params Action<TMessage>[] behavior) where TMessage : class {
+			foreach (var effect in behavior)
+				this.effect += (message, instance) => { if (message is TMessage) effect (message as TMessage); };
 
 			this.Source.Root.Clean = false;
-			
+
 			return this;
 		}
 
 		/// <summary>
 		/// Adds behavior to a transition.
 		/// </summary>
-		/// <param name="behavior">An Action that takes the state machine context as a parameter.</param>
+		/// <param name="behavior">An Action that takes the state machine instance as a parameter.</param>
 		/// <returns>Returns the transition.</returns>
-		public Transition<TContext> Effect( params Action<TContext>[] behavior ) {
-			foreach( var effect in behavior )
-				this.effect += ( message, context ) => effect( context );
+		public Transition<TInstance> Effect (params Action<TInstance>[] behavior) {
+			foreach (var effect in behavior)
+				this.effect += (message, instance) => effect (instance);
 
 			this.Source.Root.Clean = false;
-			
+
 			return this;
 		}
 
@@ -222,82 +175,26 @@ public Transition<TContext> Effect( params Action<TContext>[] behavior ) {
 		/// </summary>
 		/// <param name="behavior">An Action that takes no parameters.</param>
 		/// <returns>Returns the transition.</returns>
-		public Transition<TContext> Effect( params Action[] behavior ) {
-			foreach( var effect in behavior )
-				this.effect += ( message, context ) => effect();
+		public Transition<TInstance> Effect (params Action[] behavior) {
+			foreach (var effect in behavior)
+				this.effect += (message, instance) => effect ();
 
 			this.Source.Root.Clean = false;
-		
+
 			return this;
 		}
 
 		/// <summary>
 		/// Invokes the transition behavior upon traversing a transition.
 		/// </summary>
-		/// <param name="context">The state machine context.</param>
 		/// <param name="message">The message that triggered the state transition.</param>
+		/// <param name="instance">The state machine instance.</param>
 		/// <param name="history">A flag denoting if history semantics were in play during the transition.</param>
 		/// <remarks>
 		/// For completion transitions, the message is the source vertex that was completed.
 		/// </remarks>
-		protected void OnEffect( Object message, TContext context, Boolean history ) {
-			this.effect( message, context );
-		}
-
-		internal void BootstrapTransitions() {
-			// reset the traverse operation to cater for re-initialisation
-			this.Traverse = null;
-
-			// internal transitions
-			if( this.Target == null ) {
-				// just perform the transition effect; no actual transition
-				if( this.effect != null )
-					this.Traverse += this.OnEffect;
-
-				// local transitions
-			} else if( this.Target.Region == this.Source.Region ) {
-				// leave the source
-				this.Traverse += this.Source.Leave;
-
-				// perform the transition effect
-				if( this.effect != null )
-					this.Traverse += this.OnEffect;
-
-				// enter the target
-				this.Traverse += this.Target.Enter;
-
-				// complex (external) transitions
-			} else {
-				var sourceAncestors = this.Source.Ancestors;
-				var targetAncestors = this.Target.Ancestors;
-				var sourceAncestorsCount = sourceAncestors.Count();
-				var targetAncestorsCount = targetAncestors.Count();
-				int i = 0, l = Math.Min( sourceAncestorsCount, sourceAncestorsCount );
-
-				// find the index of the first uncommon ancestor
-				while( ( i < l ) && sourceAncestors.ElementAt( i ) == targetAncestors.ElementAt( i ) ) ++i;
-
-				// validation rule (not in the UML spec currently)
-				Trace.Assert( sourceAncestors.ElementAt( i ) is Region<TContext> == false, "Transitions may not cross sibling orthogonal regions" );
-
-				// leave the first uncommon ancestor
-				this.Traverse = ( i < sourceAncestorsCount ? sourceAncestors.ElementAt( i ) : this.Source ).Leave;
-
-				// perform the transition effect
-				if( this.effect != null )
-					this.Traverse += this.OnEffect;
-
-				// edge case when transitioning to a state in the vertex ancestry
-				if( i >= targetAncestorsCount )
-					this.Traverse += this.Target.BeginEnter;
-
-				// enter the target ancestry
-				while( i < targetAncestorsCount )
-					targetAncestors.ElementAt( i++ ).BootstrapEnter( ref this.Traverse, i < targetAncestorsCount ? targetAncestors.ElementAt( i ) : null );
-
-				// trigger cascade
-				this.Traverse += this.Target.EndEnter;
-			}
+		public void OnEffect (Object message, TInstance instance, Boolean history) { // TODO: sort out protection models 
+			this.effect (message, instance);
 		}
 	}
-}
+}
\ No newline at end of file
diff --git a/src/Vertex.cs b/src/Vertex.cs
index bee0e34..d95b4db 100644
--- a/src/Vertex.cs
+++ b/src/Vertex.cs
@@ -4,39 +4,44 @@
  * Licensed under MIT and GPL v3 licences
  */
 using System;
+using System.Collections.Generic;
 
 namespace Steelbreeze.Behavior.StateMachines {
 	/// <summary>
 	/// A Vertex is an abstraction of a node in a state machine graph; it can be the source or destination of any number of transitions.
 	/// </summary>
-	/// <typeparam name="TContext">The type of the state machine instance.</typeparam>
-	public abstract class Vertex<TContext> : Element<TContext> where TContext : IContext<TContext> {
-		internal readonly Region<TContext> Region;
-		internal Boolean IsFinal { get { return this.transitions == null; } }
-
-		private Transition<TContext>[] transitions; // trading off model building performance for runtime performance
-		private readonly Func<Transition<TContext>[], Object, TContext, Transition<TContext>> selector;
-
+	/// <typeparam name="TInstance">The type of the state machine instance.</typeparam>
+	public abstract class Vertex<TInstance> : Element<TInstance> where TInstance : class, IActiveStateConfiguration<TInstance> {
 		/// <summary>
-		/// Returns the Vertex's parent element.
+		/// The parent region that owns this Vertex.
 		/// </summary>
-		public override Element<TContext> Parent { get { return this.Region; } }
+		internal readonly Region<TInstance> Region;
 
-		internal Vertex( String name, Region<TContext> parent, Func<Transition<TContext>[], Object, TContext, Transition<TContext>> selector )
-			: base( name, parent ) {			
-			this.Region = parent;
-			this.selector = selector;
+		/// <summary>
+		/// The outgoing transitions from the vertex.
+		/// </summary>
+		internal protected readonly HashSet<Transition<TInstance>> Transitions = new HashSet<Transition<TInstance>> ();
 
-			parent.Add( this );
+		/// <summary>
+		/// Creates a new instance of a the Vertex abstract class.
+		/// </summary>
+		/// <param name="name">The name of the vertex.</param>
+		/// <param name="region">The parent region that the new vertex is a child of.</param>
+		internal protected Vertex (String name, Region<TInstance> region = null)
+			: base (name, region) {
+			this.Region = region;
+
+			if (region != null)
+				region.Add (this);
 		}
 
 		/// <summary>
-		/// Tests the vertex to determine if it is part of the current active state confuguration
+		/// Returns the Vertex's parent element.
 		/// </summary>
-		/// <param name="context">The state machine context.</param>
-		/// <returns>True if the element is active.</returns>
-		internal protected override Boolean IsActive( IContext<TContext> context ) {
-			return this.Parent.IsActive( context );
+		public override Element<TInstance> Parent {
+			get {
+				return this.Region;
+			}
 		}
 
 		/// <summary>
@@ -47,57 +52,50 @@ internal protected override Boolean IsActive( IContext<TContext> context ) {
 		/// <remarks>
 		/// To specify an internal transition, specify a null target.
 		/// </remarks>
-		public virtual Transition<TContext> To( Vertex<TContext> target ) {
-			var transition = new Transition<TContext>( this, target );
-
-			if( this.transitions == null )
-				this.transitions = new Transition<TContext>[ 1 ] { transition };
-			else {
-				var transitions = new Transition<TContext>[ this.transitions.Length + 1 ];
+		public virtual Transition<TInstance> To (Vertex<TInstance> target) {
+			var transition = new Transition<TInstance> (this, target);
 
-				this.transitions.CopyTo( transitions, 0 );
-
-				transitions[ this.transitions.Length ] = transition;
-
-				this.transitions = transitions;
-			}
+			this.Transitions.Add (transition);
 
 			this.Root.Clean = false;
 
 			return transition;
 		}
 
-		internal override void BootstrapElement( Boolean deepHistoryAbove ) {
-			base.BootstrapElement( deepHistoryAbove );
-
-			this.EndEnter += this.EvaluateCompletions;
-			this.Enter = this.BeginEnter + this.EndEnter;
-		}
-
-		internal override void BootstrapTransitions() {
-			if( this.transitions != null )
-				foreach( var transition in this.transitions )
-					transition.BootstrapTransitions();
-		}
-
-		internal void EvaluateCompletions( Object message, TContext context, Boolean history ) {
-			if( this.IsComplete( context ) )
-				this.Evaluate( this, context );
+		/// <summary>
+		/// Triggers completion events if the vertex is deemed to be complete.
+		/// </summary>
+		/// <param name="message">The origional message that caused the vertex to be entered.</param>
+		/// <param name="instance">The state machine instance.</param>
+		/// <param name="history">The history semantic that was in force when the vertex was entered.</param>
+		internal void Completion (Object message, TInstance instance, Boolean history) {
+			if (this.IsComplete (instance))
+				this.Evaluate (this, instance);
 		}
 
-		internal virtual Boolean IsComplete( TContext context ) {
-			return true;
-		}
+		/// <summary>
+		/// Selects a transition for a given message and state machine instance for the vertex.
+		/// </summary>
+		/// <param name="message">The message that may trigger a transition.</param>
+		/// <param name="instance">The state machine instance.</param>
+		/// <returns>A transition if found, or null.</returns>
+		internal protected abstract Transition<TInstance> Select (Object message, TInstance instance);
 
-		internal virtual Boolean Evaluate( Object message, TContext context ) {
-			var transition = this.selector( this.transitions, message, context );
+		/// <summary>
+		/// Evaluates a message to determine if a state transition is viable.
+		/// </summary>
+		/// <param name="message">The message that may trigger a state transition.</param>
+		/// <param name="instance">The state machine instance.</param>
+		/// <returns>True if the message triggered a state transition.</returns>
+		internal virtual Boolean Evaluate (Object message, TInstance instance) {
+			var transition = this.Select( message, instance);
 
-			if( transition == null )
+			if (transition == null)
 				return false;
 
-			transition.Traverse( message, context, false );
+			transition.Traverse (message, instance, false);
 
 			return true;
 		}
 	}
-}
+}
\ No newline at end of file
diff --git a/src/Visitor.cs b/src/Visitor.cs
new file mode 100644
index 0000000..3f5de5b
--- /dev/null
+++ b/src/Visitor.cs
@@ -0,0 +1,111 @@
+/* State v5 finite state machine library
+ * http://www.steelbreeze.net/state.cs
+ * Copyright (c) 2014-5 Steelbreeze Limited
+ * Licensed under MIT and GPL v3 licences
+ */
+
+namespace Steelbreeze.Behavior.StateMachines {
+	/// <summary>
+	/// Implementation of a visitor pattern for the state machine.
+	/// </summary>
+	/// <typeparam name="TInstance">The type of the state machine instance.</typeparam>
+	/// <typeparam name="TParam">The type of the parameter to pass through the visitor.</typeparam>
+	public class Visitor<TInstance, TParam> where TInstance : class, IActiveStateConfiguration<TInstance> {
+
+		/// <summary>
+		/// Visits an element within a state machine model.
+		/// </summary>
+		/// <param name="element">The element to visit.</param>
+		/// <param name="param">The parameter passed to the visitor.</param>
+		public virtual void VisitElement (Element<TInstance> element, TParam param) {
+		}
+
+		/// <summary>
+		/// Visits a region within a state machine model.
+		/// </summary>
+		/// <param name="region">The region to visit</param>
+		/// <param name="param">The parameter passed to the visitor.</param>
+		public virtual void VisitRegion (Region<TInstance> region, TParam param) {
+			this.VisitElement (region, param);
+
+			foreach (var vertex in region.Vertices)
+				vertex.Accept (this, param);
+		}
+
+		/// <summary>
+		/// Visits a vertex within a state machine model.
+		/// </summary>
+		/// <param name="vertex">The vertex to visit.</param>
+		/// <param name="param">The parameter passed to the visitor.</param>
+		public virtual void VisitVertex (Vertex<TInstance> vertex, TParam param) {
+			this.VisitElement (vertex, param);
+		}
+
+		/// <summary>
+		/// Visits a pseudo state within a state machine model.
+		/// </summary>
+		/// <param name="pseudoState">The pseudostate to visit.</param>
+		/// <param name="param">The parameter passed to the visitor.</param>
+		public virtual void VisitPseudoState (PseudoState<TInstance> pseudoState, TParam param) {
+			this.VisitVertex (pseudoState, param);
+		}
+
+		/// <summary>
+		/// Visits a state within a state machine model.
+		/// </summary>
+		/// <param name="state">The state to visit.</param>
+		/// <param name="param">The parameter passed to the visitor.</param>
+		public virtual void VisitState (State<TInstance> state, TParam param) {
+			this.VisitVertex (state, param);
+
+			foreach (var region in state.Regions)
+				region.Accept (this, param);
+		}
+
+		/// <summary>
+		/// Visits a final state within a state machine model.
+		/// </summary>
+		/// <param name="finalState">The final state to visit.</param>
+		/// <param name="param">The parameter passed to the visitor.</param>
+		public virtual void VisitFinalState (FinalState<TInstance> finalState, TParam param) {
+			this.VisitState (finalState, param);
+		}
+
+		/// <summary>
+		/// Visits the root state machine within a state machine model.
+		/// </summary>
+		/// <param name="stateMachine">The state machine to visit.</param>
+		/// <param name="param">The parameter passed to the visitor.</param>
+		public virtual void VisitStateMachine (StateMachine<TInstance> stateMachine, TParam param) {
+			this.VisitState (stateMachine, param);
+
+			this.VisitTransition (stateMachine as Vertex<TInstance>, param);
+		}
+
+		private void VisitTransition (Region<TInstance> region, TParam param) {
+			foreach (var vertex in region.Vertices)
+				this.VisitTransition (vertex, param);
+		}
+
+		private void VisitTransition (Vertex<TInstance> vertex, TParam param) {
+			foreach (var transition in vertex.Transitions)
+				this.VisitTransition (transition, param);
+
+			if (vertex is State<TInstance>) {
+				var state = vertex as State<TInstance>;
+
+				if (state.IsComposite)
+					foreach (var region in state.Regions)
+						this.VisitTransition (region, param);
+			}
+		}
+
+		/// <summary>
+		/// Visits a transition within a state machine model.
+		/// </summary>
+		/// <param name="transition">The transition to visit.</param>
+		/// <param name="param">A parameter passed to the visitor when visiting elements.</param>
+		public virtual void VisitTransition (Transition<TInstance> transition, TParam param) {
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/XContext.cs b/src/XContext.cs
deleted file mode 100644
index 73bd097..0000000
--- a/src/XContext.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-/* State v5 finite state machine library
- * http://www.steelbreeze.net/state.cs
- * Copyright (c) 2014-5 Steelbreeze Limited
- * Licensed under MIT and GPL v3 licences
- */using System;
-using System.Linq;
-using System.Xml.Linq;
-
-namespace Steelbreeze.Behavior.StateMachines {
-	/// <summary>
-	/// A sample of an object to extend as a base for a state machine context objects based on an XElement.
-	/// </summary>
-	public class XContext : XContextBase<XContext> { }
-}
diff --git a/src/XContextBase.cs b/src/XContextBase.cs
deleted file mode 100644
index f99bb0e..0000000
--- a/src/XContextBase.cs
+++ /dev/null
@@ -1,93 +0,0 @@
-/* State v5 finite state machine library
- * http://www.steelbreeze.net/state.cs
- * Copyright (c) 2014-5 Steelbreeze Limited
- * Licensed under MIT and GPL v3 licences
- */using System;
-using System.Linq;
-using System.Xml.Linq;
-
-namespace Steelbreeze.Behavior.StateMachines {
-	/// <summary>
-	/// A sample of an object to extend as a base for a state machine context objects based on an XElement.
-	/// </summary>
-	/// <typeparam name="TContext">The type of the derived context class.</typeparam>
-	/// <remarks>
-	/// By passing the type of the derived class into this base, it allows the callbacks generated by the state machine to pass the fully typed derived class.
-	/// Note that properties and methods have been explicitly implemented to hide the members from use other than via the IContext interface.
-	/// Should you need persistence, or other such behaviour relating to the context class, implement another class implementing IContext.
-	/// </remarks>
-	public abstract class XContextBase<TContext> : IContext<TContext> where TContext : IContext<TContext> {
-		/// <summary>
-		/// The XElement that stores the context information.
-		/// </summary>
-		/// <remarks>
-		/// The context information stored is not a full representation of the state machine model, but just enough to store the current state.
-		/// </remarks>
-		public XElement XElement { get; private set; }
-
-		/// <summary>
-		/// Creates a new instance of the XmlContext class.
-		/// </summary>
-		/// <param name="content">Any additional XML structure that you may need under the root element.</param>
-		public XContextBase( params object[] content ) {
-			this.XElement = new XElement( "stateMachineContext", content );
-
-			this.XElement.Add( new XAttribute( "terminated", false ) );
-		}
-
-		/// <summary>
-		/// Indicates that the state machine context has been terminated.
-		/// </summary>
-		/// <remarks>A state machine is only deemed terminated if a transitions target is a Terminate PseudoState.</remarks>
-		public Boolean IsTerminated {
-			set {
-				XElement.Attribute( "terminated" ).Value = Convert.ToString( value );
-			}
-
-			get {
-				return Convert.ToBoolean( XElement.Attribute( "terminated" ).Value );
-			}
-		}
-
-		Vertex<TContext> IContext<TContext>.this[ Region<TContext> region ] {
-			set {
-				XElement element = this[ region ];
-				XAttribute attribute = element.Attribute( "last" );
-
-				if( attribute == null )
-					element.Add( new XAttribute( "last", value.Name ) );
-				else
-					attribute.Value = Convert.ToString( value.Name );
-			}
-
-			get {
-				var value = default( Vertex<TContext> );
-
-				XElement element = this[ region ];
-				XAttribute attribute = element.Attribute( "last" );
-
-				if( attribute != null )
-					value = region.Vertices.Single( vertex => vertex.Name == Convert.ToString( attribute.Value ) );
-
-				return value;
-			}
-		}
-
-		private XElement this[ Region<TContext> region ] {
-			get {
-				var value = this.XElement;
-
-				foreach( var stateMachineElement in region.Ancestors ) {
-					var element = value.Elements().SingleOrDefault( e => e.Attribute( "name" ).Value == stateMachineElement.Name );
-
-					if( element == null )
-						value.Add( element = new XElement( stateMachineElement.Type, new XAttribute( "name", stateMachineElement.Name ) ) );
-
-					value = element;
-				}
-
-				return value;
-			}
-		}
-	}
-}
diff --git a/tests/History/Shallow.cs b/tests/History/Shallow.cs
index 1ecb413..5e8280d 100644
--- a/tests/History/Shallow.cs
+++ b/tests/History/Shallow.cs
@@ -8,34 +8,34 @@
 
 namespace Steelbreeze.Behavior.StateMachines.Tests.History {
 	public class Shallow {
-		public static void Test() {
-			var model = new StateMachine<DictionaryContext>( "history" );
+		public static void Test () {
+			var model = new StateMachine<StateMachineInstance> ("model");
 
-			var initial = new PseudoState<DictionaryContext>( "initial", model );
-			var shallow = new State<DictionaryContext>( "shallow", model );
-			var deep = new State<DictionaryContext>( "deep", model );
-			var final = new FinalState<DictionaryContext>( "final", model );
+			var initial = model.CreatePseudoState ("initial", PseudoStateKind.Initial);
+			var shallow = model.CreateState ("shallow");
+			var deep = model.CreateState ("deep");
+			var final = model.CreateFinalState ("final");
 
-			var s1 = new State<DictionaryContext>( "s1", shallow );
-			var s2 = new State<DictionaryContext>( "s2", shallow );
+			var s1 = shallow.CreateState ("s1");
+			var s2 = shallow.CreateState ("s2");
 
-			initial.To( shallow );
-			new PseudoState<DictionaryContext>( "shallow", shallow, PseudoStateKind.ShallowHistory ).To( s1 );
-			s1.To( s2 ).When<String>( c => c == "move" );
-			shallow.To( deep ).When<String>( c => c == "go deep" );
-			deep.To( shallow ).When<String>( c => c == "go shallow" );
-			s2.To( final ).When<String>( c => c == "end" );
+			initial.To (shallow);
+			shallow.CreatePseudoState ("shallow", PseudoStateKind.ShallowHistory).To (s1);
+			s1.To (s2).When<String> (c => c == "move");
+			shallow.To (deep).When<String> (c => c == "go deep");
+			deep.To (shallow).When<String> (c => c == "go shallow");
+			s2.To (final).When<String> (c => c == "end");
 
-			var instance = new DictionaryContext();
+			var instance = new StateMachineInstance ("history");
 
-			model.Initialise( instance );
+			model.Initialise (instance);
 
-			Trace.Assert( model.Evaluate( "move", instance ) );
-			Trace.Assert( model.Evaluate( "go deep", instance ) );
-			Trace.Assert( model.Evaluate( "go shallow", instance ) );
-			Trace.Assert( !model.Evaluate( "go shallow", instance ) );
-			Trace.Assert( model.Evaluate( "end", instance ) );
-			Trace.Assert( model.IsComplete( instance ) );
+			Trace.Assert (model.Evaluate ("move", instance));
+			Trace.Assert (model.Evaluate ("go deep", instance));
+			Trace.Assert (model.Evaluate ("go shallow", instance));
+			Trace.Assert (!model.Evaluate ("go shallow", instance));
+			Trace.Assert (model.Evaluate ("end", instance));
+			Trace.Assert (model.IsComplete (instance));
 		}
 	}
-}
+}
\ No newline at end of file
diff --git a/tests/Program.cs b/tests/Program.cs
index 333d7e9..e58c178 100644
--- a/tests/Program.cs
+++ b/tests/Program.cs
@@ -6,22 +6,17 @@
 using System;
 using System.Diagnostics;
 
-namespace Steelbreeze.Behavior.StateMachines.Tests
-{
-	public class Program
-	{
-		public static void Main( String[] args )
-		{
-			Trace.WriteLine( "Running unit tests for Steelbreeze.Alamo.StateMachines" );
-
+namespace Steelbreeze.Behavior.StateMachines.Tests {
+	public class Program {
+		public static void Main (String[] args) {
 			// TODO: add more transition tests (incl. else)
-			Transitions.Completions.Test();
-			History.Shallow.Test();
+			Transitions.Completions.Test ();
+			History.Shallow.Test ();
 
 			// user test cases
-			Users.Muximise1.Test();
-			Users.Brice1.Test();
-			Users.P3pp3r.Test();
+			Users.Muximise1.Test ();
+			Users.Brice1.Test ();
+			Users.P3pp3r.Test ();
 		}
 	}
 }
\ No newline at end of file
diff --git a/tests/Transitions/Completion.cs b/tests/Transitions/Completion.cs
index 822f624..a941a4a 100644
--- a/tests/Transitions/Completion.cs
+++ b/tests/Transitions/Completion.cs
@@ -6,48 +6,46 @@
 using System;
 using System.Diagnostics;
 
-namespace Steelbreeze.Behavior.StateMachines.Tests.Transitions
-{
-	public class Completions
-	{
-		public class Activity<TState> : State<TState> where TState : class, IContext<TState>
-		{
-			public Activity( String name, Region<TState> region )
-				: base(  name, region )
-			{
-				new PseudoState<TState>( "initial", this ).To( new FinalState<TState>( "final", this ) );
-			}
+namespace Steelbreeze.Behavior.StateMachines.Tests.Transitions {
+	public class Activity<TInstance> : State<TInstance> where TInstance : class, IActiveStateConfiguration<TInstance> {
+		public Activity (String name, Region<TInstance> region)
+			: base (name, region) {
+			this.CreatePseudoState ("initial", PseudoStateKind.Initial).To (this.CreateFinalState ("final"));
+		}
+	}
+
+	public static class ActivityEx {
+		public static Activity<TInstance> CreateActivity<TInstance> (this StateMachine<TInstance> stateMachine, String name) where TInstance : class, IActiveStateConfiguration<TInstance> {
+			return new Activity<TInstance> (name, stateMachine);
 		}
+	}
 
-		public static void Test()
-		{
-			try
-			{
-				var model = new StateMachine<DictionaryContext>( "continuation" );
-				var initial = new PseudoState<DictionaryContext>( "initial", model );
-				var activity1 = new State<DictionaryContext>( "activity1", model );
-				var activity2 = new Activity<DictionaryContext>( "activity2", model );
-				var junction1 = new PseudoState<DictionaryContext>( "junction1", model, PseudoStateKind.Junction );
-				var junction2 = new PseudoState<DictionaryContext>( "junction2", model, PseudoStateKind.Junction );
-				var activity3 = new State<DictionaryContext>( "activity3", model );
-				var final = new FinalState<DictionaryContext>( "final", model );
+	public class Completions {
+		public static void Test () {
+			try {
+				var model = new StateMachine<StateMachineInstance> ("model");
+				var initial = model.CreatePseudoState("initial");
+				var activity1 = model.CreateState ("activity1");
+				var activity2 = model.CreateActivity ("activity2");
+				var junction1 = model.CreatePseudoState("junction1", PseudoStateKind.Junction);
+				var junction2 = model.CreatePseudoState ("junction2", PseudoStateKind.Junction);
+				var activity3 = model.CreateState ("activity3");
+				var final = model.CreateFinalState ("final");
 
-				initial.To( activity1 );
-				activity1.To( activity2 );
-				activity2.To( junction1 );
-				junction1.To( junction2 );
-				junction2.To( activity3 );
-				activity3.To( final );
+				initial.To (activity1);
+				activity1.To (activity2);
+				activity2.To (junction1);
+				junction1.To (junction2);
+				junction2.To (activity3);
+				activity3.To (final);
 
-				var instance = new DictionaryContext();
+				var instance = new StateMachineInstance ("completion");
 
-				model.Initialise( instance );
+				model.Initialise (instance);
 
-				Trace.Assert( model.IsComplete( instance ) );
-			}
-			catch( Exception x )
-			{
-				Trace.Fail( x.Message );
+				Trace.Assert (model.IsComplete (instance));
+			} catch (Exception x) {
+				Trace.Fail (x.Message);
 			}
 		}
 	}
diff --git a/tests/Users/Brice1.cs b/tests/Users/Brice1.cs
index 7d5452f..988cd57 100644
--- a/tests/Users/Brice1.cs
+++ b/tests/Users/Brice1.cs
@@ -8,28 +8,28 @@
 
 namespace Steelbreeze.Behavior.StateMachines.Tests.Users {
 	public class Brice1 {
-		public static void Test() {
-			var model = new StateMachine<DictionaryContext>( "brice1" );
+		public static void Test () {
+			var model = new StateMachine<StateMachineInstance> ("model");
 
-			var initial1 = new PseudoState<DictionaryContext>( "initial", model );
-			var myComposite1 = new State<DictionaryContext>( "myComposite1", model );
-			var myComposite2 = new State<DictionaryContext>( "myComposite2", model );
+			var initial1 = model.CreatePseudoState ("initial");
+			var myComposite1 = model.CreateState ("myComposite1");
+			var myComposite2 = model.CreateState ("myComposite2");
 
-			var initial2 = new PseudoState<DictionaryContext>( "initial", myComposite1 );
-			var myState1 = new State<DictionaryContext>( "myState1", myComposite1 );
-			var myState2 = new State<DictionaryContext>( "myState2", myComposite1 );
+			var initial2 = myComposite1.CreatePseudoState ("initial");
+			var myState1 = myComposite1.CreateState ("myState1");
+			var myState2 = myComposite1.CreateState ("myState2");
 
-			initial1.To( myComposite1 );
-			initial2.To( myState1 );
+			initial1.To (myComposite1);
+			initial2.To (myState1);
 
-			myComposite1.To( myComposite2 ).When<String>( message => message == "A" ).Effect( () => System.Diagnostics.Trace.Fail( "Outer transition fired" ) );
-			myState1.To( myState2 ).When<String>( message => message == "A" );
+			myComposite1.To (myComposite2).When<String> (message => message == "A").Effect (() => System.Diagnostics.Trace.Fail ("Outer transition fired"));
+			myState1.To (myState2).When<String> (message => message == "A");
 
-			var instance = new DictionaryContext();
+			var instance = new StateMachineInstance ("brice1");
 
-			model.Initialise( instance );
+			model.Initialise (instance);
 
-			model.Evaluate( "A", instance );
+			model.Evaluate ("A", instance);
 		}
 	}
 }
\ No newline at end of file
diff --git a/tests/Users/Muximise1.cs b/tests/Users/Muximise1.cs
index 79509d7..2f8f635 100644
--- a/tests/Users/Muximise1.cs
+++ b/tests/Users/Muximise1.cs
@@ -8,47 +8,52 @@
 
 namespace Steelbreeze.Behavior.StateMachines.Tests.Users {
 	public class Muximise1 {
-		public static void Test() {
-			var model = new StateMachine<DictionaryContext>( "muximise1" );
+		public static StateMachine<StateMachineInstance> Model { get; private set; }
 
-			var initial = new PseudoState<DictionaryContext>( "initial", model );
-			var ortho = new State<DictionaryContext>( "ortho", model );
-			var simple = new State<DictionaryContext>( "simple", model );
-			var final = new FinalState<DictionaryContext>( "final", model );
+		static Muximise1 () {
+			Model = new StateMachine<StateMachineInstance> ("model");
 
-			var r1 = new Region<DictionaryContext>( "r1", ortho );
-			var r2 = new Region<DictionaryContext>( "r2", ortho );
+			var initial = Model.CreatePseudoState ("initial");
+			var ortho = Model.CreateState ("ortho");
+			var simple = Model.CreateState ("simple");
+			var final = Model.CreateFinalState ("final");
 
-			var i1 = new PseudoState<DictionaryContext>( "initial", r1, PseudoStateKind.ShallowHistory );
-			var i2 = new PseudoState<DictionaryContext>( "initial", r2, PseudoStateKind.ShallowHistory );
+			var r1 = ortho.CreateRegion ("r1");
+			var r2 = ortho.CreateRegion ("r2");
 
-			var s1 = new State<DictionaryContext>( "s1", r1 );
-			var s2 = new State<DictionaryContext>( "s2", r2 );
 
-			var f1 = new FinalState<DictionaryContext>( "f1", r1 );
-			var f2 = new FinalState<DictionaryContext>( "f2", r2 );
+			var i1 = r1.CreatePseudoState ("initial", PseudoStateKind.ShallowHistory);
+			var i2 = r2.CreatePseudoState ("initial", PseudoStateKind.ShallowHistory);
 
-			initial.To( ortho );
+			var s1 = r1.CreateState ("s1");
+			var s2 = r2.CreateState ("s2");
 
-			i1.To( s1 );
-			i2.To( s2 );
+			var f1 = r1.CreateFinalState ("f1");
+			var f2 = r2.CreateFinalState ("f2");
 
-			ortho.To( final ); // This should happen once all regions in ortho are complete?
+			initial.To (ortho);
 
-			s1.To( f1 ).When<String>( c => c == "complete1" );
-			s2.To( f2 ).When<String>( c => c == "complete2" );
+			i1.To (s1);
+			i2.To (s2);
 
-			ortho.To( simple ).When<String>( c => c == "jump" );
-			simple.To( ortho ).When<String>( c => c == "back" );
+			ortho.To (final); // This should happen once all regions in ortho are complete?
 
-			var instance = new DictionaryContext();
+			s1.To (f1).When<String> (c => c == "complete1");
+			s2.To (f2).When<String> (c => c == "complete2");
 
-			model.Initialise( instance );
+			ortho.To (simple).When<String> (c => c == "jump");
+			simple.To (ortho).When<String> (c => c == "back");
+		}
+
+		public static void Test () {
+			var instance = new StateMachineInstance ("muximise1");
+
+			Model.Initialise (instance);
 
-			model.Evaluate( "complete1", instance );
-			model.Evaluate( "complete2", instance );
+			Model.Evaluate ("complete1", instance);
+			Model.Evaluate ("complete2", instance);
 
-			Trace.Assert( model.IsComplete( instance ) );
+			Trace.Assert (Model.IsComplete (instance));
 		}
 	}
 }
\ No newline at end of file
diff --git a/tests/Users/P3pp3r.cs b/tests/Users/P3pp3r.cs
index e54bc22..2932cdd 100644
--- a/tests/Users/P3pp3r.cs
+++ b/tests/Users/P3pp3r.cs
@@ -11,46 +11,46 @@ namespace Steelbreeze.Behavior.StateMachines.Tests.Users {
 	/// Test relating to external transitions and orthogonal regions; a transition in one region renders a potential transition in another region obsolete
 	/// </summary>
 	public class P3pp3r {
-		public static void Test() {
-			var main = new StateMachine<DictionaryContext>( "p3pp3r" );
-			var initial = new PseudoState<DictionaryContext>( "initial", main, PseudoStateKind.Initial );
-			var state1 = new State<DictionaryContext>( "state1", main );
-			var state2 = new State<DictionaryContext>( "state2", main );
-
-			var regionA = new Region<DictionaryContext>( "regionA", state1 );
-			var initialA = new PseudoState<DictionaryContext>( "initialA", regionA, PseudoStateKind.Initial );
-			var state3 = new State<DictionaryContext>( "state3", regionA );
-			var state8 = new State<DictionaryContext>( "state8", regionA );
-
-			var regionB = new Region<DictionaryContext>( "regionB", state1 );
-			var initialB = new PseudoState<DictionaryContext>( "initialB", regionB, PseudoStateKind.Initial );
-			var state4 = new State<DictionaryContext>( "state4", regionB );
-			var state5 = new State<DictionaryContext>( "state5", regionB );
-
-			var regionBa = new Region<DictionaryContext>( "regionBa", state4 );
-			var initialBa = new PseudoState<DictionaryContext>( "initialBa", regionBa, PseudoStateKind.Initial );
-			var state6 = new State<DictionaryContext>( "state6", regionBa );
-
-			var regionBb = new Region<DictionaryContext>( "regionBb", state4 );
-			var initialBb = new PseudoState<DictionaryContext>( "initialBb", regionBb, PseudoStateKind.Initial );
-			var state7 = new State<DictionaryContext>( "state7", regionBb );
-
-			initial.To( state1 );
-			initialA.To( state3 );
-			initialB.To( state4 );
-			initialBa.To( state6 );
-			initialBb.To( state7 );
-
-			state3.To( state2 ).When<String>( c => c == "event2" );
-			state3.To( state8 ).When<String>( c => c == "event1" );
-
-			state7.To( state5 ).When<String>( c => c == "event2" ).Effect( () => Trace.TraceError("p3pp3r test failed") );
-			state7.To( state5 ).When<String>( c => c == "event1" );
-
-			var sms = new DictionaryContext();
-			main.Initialise( sms );
-
-			main.Evaluate( "event2", sms );
+		public static void Test () {
+			var model = new StateMachine<StateMachineInstance> ("model");
+			var initial = model.CreatePseudoState ("initial", PseudoStateKind.Initial);
+			var state1 = model.CreateState ("state1");
+			var state2 = model.CreateState ("state2");
+
+			var regionA = state1.CreateRegion ("regionA");
+			var initialA = regionA.CreatePseudoState ("initialA", PseudoStateKind.Initial);
+			var state3 = regionA.CreateState ("state3");
+			var state8 = regionA.CreateState ("state8");
+
+			var regionB = state1.CreateRegion ("regionB");
+			var initialB = regionB.CreatePseudoState ("initialB", PseudoStateKind.Initial);
+			var state4 = regionB.CreateState ("state4");
+			var state5 = regionB.CreateState ("state5");
+
+			var regionBa = state4.CreateRegion ("regionBa");
+			var initialBa = regionBa.CreatePseudoState ("initialBa", PseudoStateKind.Initial);
+			var state6 = regionBa.CreateState ("state6");
+
+			var regionBb = state4.CreateRegion ("regionBb");
+			var initialBb = regionBb.CreatePseudoState ("initialBb", PseudoStateKind.Initial);
+			var state7 = regionBb.CreateState ("state7");
+
+			initial.To (state1);
+			initialA.To (state3);
+			initialB.To (state4);
+			initialBa.To (state6);
+			initialBb.To (state7);
+
+			state3.To (state2).When<String> (c => c == "event2");
+			state3.To (state8).When<String> (c => c == "event1");
+
+			state7.To (state5).When<String> (c => c == "event2").Effect (() => Trace.TraceError ("p3pp3r test failed"));
+			state7.To (state5).When<String> (c => c == "event1");
+
+			var instance = new StateMachineInstance ("p3pp3r");
+			model.Initialise (instance);
+
+			model.Evaluate ("event2", instance);
 		}
 	}
 }
\ No newline at end of file