diff --git a/src/Umbraco.Core/Resolving/ManyWeightedResolved.cs b/src/Umbraco.Core/Resolving/ManyWeightedResolved.cs
new file mode 100644
index 0000000000..c8d56b8c67
--- /dev/null
+++ b/src/Umbraco.Core/Resolving/ManyWeightedResolved.cs
@@ -0,0 +1,159 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Umbraco.Core.Resolving
+{
+	public class ManyWeightedResolved<TResolved>
+	{
+		List<TResolved> _resolved = new List<TResolved>();
+		Dictionary<Type, int> _weights = new Dictionary<Type, int>();
+
+		public ManyWeightedResolved()
+		{
+			Resolution.Frozen += (sender, e) =>
+				{
+					_resolved = _resolved.OrderBy(r => _weights[r.GetType()]).ToList();
+					_weights = null;
+				};
+		}
+
+		public ManyWeightedResolved(IEnumerable<TResolved> resolved)
+			: this()
+		{
+			_resolved.AddRange(resolved);
+			foreach (var type in _resolved.Select(r => r.GetType()))
+				_weights.Add(type, ResolutionWeightAttribute.ReadWeight(type));
+		}
+
+		public IEnumerable<TResolved> Values
+		{
+			get { return _resolved; }
+		}
+
+		#region Manage collection
+
+		public void Add(TResolved value)
+		{
+			Resolution.EnsureNotFrozen();
+
+			var type = value.GetType();
+			EnsureNotExists(type);
+			_resolved.Add(value);
+			_weights[type] = ResolutionWeightAttribute.ReadWeight(type);
+		}
+
+		public void Add(TResolved value, int weight)
+		{
+			Resolution.EnsureNotFrozen();
+
+			var type = value.GetType();
+			EnsureNotExists(type);
+			_resolved.Add(value);
+			_weights[type] = weight;
+		}
+
+		public void AddRange(IEnumerable<TResolved> values)
+		{
+			Resolution.EnsureNotFrozen();
+
+			foreach (var value in values)
+			{
+				var type = value.GetType();
+				EnsureNotExists(type);
+				_resolved.Add(value);
+				_weights[type] = ResolutionWeightAttribute.ReadWeight(type);
+			}
+		}
+
+		//public void SetWeight(TResolved value, int weight)
+		//{
+		//    Resolution.EnsureNotFrozen();
+
+		//    var type = value.GetType();
+		//    EnsureExists(type);
+		//    _weights[type] = weight;
+		//}
+
+		public void SetWeight<TResolving>(int weight)
+		{
+			Resolution.EnsureNotFrozen();
+
+			var type = typeof(TResolving);
+			EnsureExists(type);
+			_weights[type] = weight;
+		}
+
+		//public int GetWeight(TResolved value)
+		//{
+		//    var type = value.GetType();
+		//    EnsureExists(type);
+		//    return _weights[value.GetType()];
+		//}
+
+		public int GetWeight<TResolving>()
+		{
+			var type = typeof(TResolving);
+			EnsureExists(type);
+			return _weights[type];
+		}
+
+		//public void Remove(TResolved value)
+		//{
+		//    Resolution.EnsureNotFrozen();
+
+		//    var type = value.GetType();
+		//    var remove = _resolved.SingleOrDefault(r => r.GetType() == type);
+		//    if (remove != null)
+		//    {
+		//        _resolved.Remove(remove);
+		//        _weights.Remove(remove.GetType());
+		//    }
+		//}
+
+		public void Remove<TResolving>()
+		{
+			Resolution.EnsureNotFrozen();
+
+			var type = typeof(TResolving);
+			var remove = _resolved.SingleOrDefault(r => r.GetType() == type);
+			if (remove != null)
+			{
+				_resolved.Remove(remove);
+				_weights.Remove(remove.GetType());
+			}
+		}
+
+		public void Clear()
+		{
+			Resolution.EnsureNotFrozen();
+
+			_resolved = new List<TResolved>();
+			_weights = new Dictionary<Type, int>();
+		}
+
+		#endregion
+
+		#region Utilities
+
+		public bool Exists(Type type)
+		{
+			return _resolved.Any(r => r.GetType() == type);
+		}
+
+		void EnsureExists(Type type)
+		{
+			if (!Exists(type))
+				throw new InvalidOperationException("There is not value of that type in the collection.");
+		}
+
+		void EnsureNotExists(Type type)
+		{
+			if (Exists(type))
+				throw new InvalidOperationException("A value of that type already exists in the collection.");
+		}
+
+		#endregion
+	}
+}
diff --git a/src/Umbraco.Core/Resolving/ManyWeightedResolverBase.cs b/src/Umbraco.Core/Resolving/ManyWeightedResolverBase.cs
new file mode 100644
index 0000000000..fb68db0d47
--- /dev/null
+++ b/src/Umbraco.Core/Resolving/ManyWeightedResolverBase.cs
@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Umbraco.Core.Resolving
+{
+	public abstract class ManyWeightedResolverBase<TResolver, TResolved> : ResolverBase<TResolver>
+	{
+		ManyWeightedResolved<TResolved> _resolved;
+
+		protected ManyWeightedResolverBase()
+		{
+			_resolved = new ManyWeightedResolved<TResolved>();
+		}
+
+		protected ManyWeightedResolverBase(IEnumerable<TResolved> values)
+		{
+			_resolved = new ManyWeightedResolved<TResolved>(values);
+		}
+
+		protected IEnumerable<TResolved> Values
+		{
+			get { return _resolved.Values; }
+		}
+
+		#region Manage collection
+
+		public void Add(TResolved value)
+		{
+			_resolved.Add(value);
+		}
+
+		public void Add(TResolved value, int weight)
+		{
+			_resolved.Add(value, weight);
+		}
+
+		public void AddRange(IEnumerable<TResolved> values)
+		{
+			_resolved.AddRange(values);
+		}
+
+		public void SetWeight<TResolving>(int weight)
+		{
+			_resolved.SetWeight<TResolving>(weight);
+		}
+
+		public int GetWeight<TResolving>()
+		{
+			return _resolved.GetWeight<TResolving>();
+		}
+
+		public void Remove<TResolving>()
+		{
+			_resolved.Remove<TResolving>();
+		}
+
+		public void Clear()
+		{
+			_resolved.Clear();
+		}
+
+		#endregion
+	}
+}
diff --git a/src/Umbraco.Core/Resolving/Resolution.cs b/src/Umbraco.Core/Resolving/Resolution.cs
new file mode 100644
index 0000000000..96349d645b
--- /dev/null
+++ b/src/Umbraco.Core/Resolving/Resolution.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Umbraco.Core.Resolving
+{
+	// notes: nothing in Resolving is thread-safe because everything should happen when the app is starting
+
+	public class Resolution
+	{
+		public static event EventHandler Freezing;
+		public static event EventHandler Frozen;
+
+		public static bool IsFrozen { get; private set; }
+
+		public static void EnsureNotFrozen()
+		{
+			if (Resolution.IsFrozen)
+				throw new InvalidOperationException("Resolution is frozen. It is not possible to modify resolvers once resolution is frozen.");
+		}
+
+		public static void Freeze()
+		{
+			if (Resolution.IsFrozen)
+				throw new InvalidOperationException("Resolution is frozen. It is not possible to freeze it again.");
+			if (Freezing != null)
+				Freezing(null, null);
+			IsFrozen = true;
+			if (Frozen != null)
+				Frozen(null, null);
+		}
+	}
+}
diff --git a/src/Umbraco.Core/Resolving/ResolutionWeightAttribute.cs b/src/Umbraco.Core/Resolving/ResolutionWeightAttribute.cs
new file mode 100644
index 0000000000..c31e0a6b66
--- /dev/null
+++ b/src/Umbraco.Core/Resolving/ResolutionWeightAttribute.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Umbraco.Core.Resolving
+{
+	[AttributeUsage(AttributeTargets.Class, AllowMultiple=false, Inherited=false)]
+	public class ResolutionWeightAttribute : Attribute
+	{
+		public const int DefaultWeight = 100;
+
+		public ResolutionWeightAttribute(int weight)
+		{
+			this.Weight = weight;
+		}
+
+		public int Weight { get; private set; }
+
+		public static int ReadWeight(Type type)
+		{
+			var attr = type.GetCustomAttribute<ResolutionWeightAttribute>(false);
+			return attr != null ? attr.Weight : DefaultWeight;
+		}
+	}
+}
diff --git a/src/Umbraco.Core/Resolving/ResolverBase.cs b/src/Umbraco.Core/Resolving/ResolverBase.cs
new file mode 100644
index 0000000000..023eaecdc7
--- /dev/null
+++ b/src/Umbraco.Core/Resolving/ResolverBase.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Threading;
+
+namespace Umbraco.Core.Resolving
+{
+	public abstract class ResolverBase<TResolver>
+	{
+		static TResolver _resolver;
+		static readonly ReaderWriterLockSlim ResolversLock = new ReaderWriterLockSlim();
+
+		public static TResolver Current
+		{
+			get
+			{
+				using (new ReadLock(ResolversLock))
+				{
+					if (_resolver == null)
+						throw new InvalidOperationException("Current has not been initialized. You must initialize Current before trying to read it.");
+					return _resolver;
+				}
+			}
+
+			set
+			{
+				using (new WriteLock(ResolversLock))
+				{
+					if (value == null)
+						throw new ArgumentNullException("value");
+					if (_resolver != null)
+						throw new InvalidOperationException("Current has already been initialized. It is not possible to re-initialize Current once it has been initialized.");
+					_resolver = value;
+				}
+			}
+		}
+	}
+}
diff --git a/src/Umbraco.Core/Resolving/SingleResolved.cs b/src/Umbraco.Core/Resolving/SingleResolved.cs
new file mode 100644
index 0000000000..065ad30898
--- /dev/null
+++ b/src/Umbraco.Core/Resolving/SingleResolved.cs
@@ -0,0 +1,48 @@
+using System;
+
+namespace Umbraco.Core.Resolving
+{
+	public class SingleResolved<TResolved>
+	{
+		TResolved _resolved;
+		bool _canBeNull;
+
+		public SingleResolved()
+			: this(false)
+		{ }
+
+		public SingleResolved(TResolved value)
+			: this(false)
+		{
+			_resolved = value;
+		}
+
+		public SingleResolved(bool canBeNull)
+		{
+			_canBeNull = canBeNull;
+		}
+
+		public SingleResolved(TResolved value, bool canBeNull)
+		{
+			_resolved = value;
+			_canBeNull = canBeNull;
+		}
+
+		public TResolved Value
+		{
+			get
+			{
+				return _resolved;
+			}
+
+			set
+			{
+				Resolution.EnsureNotFrozen();
+
+				if (!_canBeNull && value == null)
+					throw new ArgumentNullException("value");
+				_resolved = value;
+			}
+		}
+	}
+}
diff --git a/src/Umbraco.Core/Resolving/SingleResolverBase.cs b/src/Umbraco.Core/Resolving/SingleResolverBase.cs
new file mode 100644
index 0000000000..7ca86b1cb3
--- /dev/null
+++ b/src/Umbraco.Core/Resolving/SingleResolverBase.cs
@@ -0,0 +1,48 @@
+using System;
+
+namespace Umbraco.Core.Resolving
+{
+	public abstract class SingleResolverBase<TResolver, TResolved> : ResolverBase<TResolver>
+	{
+		TResolved _resolved;
+		bool _canBeNull;
+
+		protected SingleResolverBase()
+			: this(false)
+		{ }
+
+		protected SingleResolverBase(TResolved value)
+			: this(false)
+		{
+			_resolved = value;
+		}
+
+		protected SingleResolverBase(bool canBeNull)
+		{
+			_canBeNull = canBeNull;
+		}
+
+		protected SingleResolverBase(TResolved value, bool canBeNull)
+		{
+			_resolved = value;
+			_canBeNull = canBeNull;
+		}
+
+		protected TResolved Value
+		{
+			get
+			{
+				return _resolved;
+			}
+
+			set
+			{
+				Resolution.EnsureNotFrozen();
+
+				if (!_canBeNull && value == null)
+					throw new ArgumentNullException("value");
+				_resolved = value;
+			}
+		}
+	}
+}
diff --git a/src/Umbraco.Core/TypeExtensions.cs b/src/Umbraco.Core/TypeExtensions.cs
new file mode 100644
index 0000000000..4813f23243
--- /dev/null
+++ b/src/Umbraco.Core/TypeExtensions.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Umbraco.Core
+{
+	public static class TypeExtensions
+	{
+		public static IEnumerable<T> GetCustomAttributes<T>(this Type type, bool inherit)
+		{
+			return type.GetCustomAttributes(typeof(T), inherit).Cast<T>();
+		}
+
+		public static T GetCustomAttribute<T>(this Type type, bool inherit)
+		{
+			return type.GetCustomAttributes<T>(inherit).SingleOrDefault();
+		}
+	}
+}
diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj
index 9c5101ff36..50e972ac1a 100644
--- a/src/Umbraco.Core/Umbraco.Core.csproj
+++ b/src/Umbraco.Core/Umbraco.Core.csproj
@@ -45,6 +45,14 @@
       <Link>Properties\SolutionInfo.cs</Link>
     </Compile>
     <Compile Include="ApplicationContext.cs" />
+    <Compile Include="Resolving\ManyWeightedResolved.cs" />
+    <Compile Include="Resolving\ManyWeightedResolverBase.cs" />
+    <Compile Include="Resolving\Resolution.cs" />
+    <Compile Include="Resolving\ResolutionWeightAttribute.cs" />
+    <Compile Include="Resolving\ResolverBase.cs" />
+    <Compile Include="Resolving\SingleResolved.cs" />
+    <Compile Include="Resolving\SingleResolverBase.cs" />
+    <Compile Include="TypeExtensions.cs" />
     <Compile Include="UpgradeableReadLock.cs" />
     <Compile Include="ReadLock.cs" />
     <Compile Include="DelegateEqualityComparer.cs" />
@@ -63,6 +71,7 @@
       <Name>umbraco.businesslogic</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/src/Umbraco.Web/Routing/DocumentRequest.cs b/src/Umbraco.Web/Routing/DocumentRequest.cs
index 99b42b7263..d02d95c793 100644
--- a/src/Umbraco.Web/Routing/DocumentRequest.cs
+++ b/src/Umbraco.Web/Routing/DocumentRequest.cs
@@ -202,7 +202,7 @@ namespace Umbraco.Web.Routing
             // the first successful resolver, if any, will set this.Node, and may also set this.Template
             // some lookups may implement caching
             Trace.TraceInformation("{0}Begin resolvers", tracePrefix);
-			var resolvers = RoutingContext.RouteLookups.GetLookups();
+			var resolvers = RoutingContext.RequestDocumentResolversResolver.RequestDocumentResolvers;
         	resolvers.Any(resolver => resolver.TrySetDocument(this));
             Trace.TraceInformation("{0}End resolvers, {1}", tracePrefix, (this.HasNode ? "a document was found" : "no document was found"));
 
@@ -243,7 +243,8 @@ namespace Umbraco.Web.Routing
                     Trace.TraceInformation("{0}No document, try notFound lookup", tracePrefix);
 
                     // if it fails then give up, there isn't much more that we can do
-					if (RoutingContext.LookupNotFound == null || !RoutingContext.LookupNotFound.TrySetDocument(this))
+					var lastChance = RoutingContext.RequestDocumentResolversResolver.RequestDocumentLastChanceResolver;
+					if (lastChance == null || !lastChance.TrySetDocument(this))
                     {
                         Trace.TraceInformation("{0}Failed to find a document, give up", tracePrefix);
                         break;
@@ -446,7 +447,7 @@ namespace Umbraco.Web.Routing
                     redirectId = -1;
                 string redirectUrl = "#";
                 if (redirectId > 0)
-					redirectUrl = RoutingContext.NiceUrlResolver.GetNiceUrl(redirectId);
+					redirectUrl = RoutingContext.NiceUrlProvider.GetNiceUrl(redirectId);
                 if (redirectUrl != "#")
                     this.RedirectUrl = redirectUrl;
             }
diff --git a/src/Umbraco.Web/Routing/IRoutesCache.cs b/src/Umbraco.Web/Routing/IRoutesCache.cs
index 0f4a1044ec..0771fa556f 100644
--- a/src/Umbraco.Web/Routing/IRoutesCache.cs
+++ b/src/Umbraco.Web/Routing/IRoutesCache.cs
@@ -1,5 +1,13 @@
 namespace Umbraco.Web.Routing
 {
+	// this is a bi-directional cache that contains
+	// - nodeId to route (used for NiceUrl)
+	// - route to nodeId (used for inbound requests)
+	//
+	// a route is [rootId]/path/to/node
+	// where rootId is the id of the "site root" node
+	//
+
 	internal interface IRoutesCache
 	{
 		void Store(int nodeId, string route);
diff --git a/src/Umbraco.Web/NiceUrlResolver.cs b/src/Umbraco.Web/Routing/NiceUrlProvider.cs
similarity index 73%
rename from src/Umbraco.Web/NiceUrlResolver.cs
rename to src/Umbraco.Web/Routing/NiceUrlProvider.cs
index dec04e8a52..00a72b264c 100644
--- a/src/Umbraco.Web/NiceUrlResolver.cs
+++ b/src/Umbraco.Web/Routing/NiceUrlProvider.cs
@@ -10,14 +10,14 @@ using umbraco;
 using umbraco.IO;
 using umbraco.cms.businesslogic.web;
 
-namespace Umbraco.Web
+namespace Umbraco.Web.Routing
 {
 	/// <summary>
 	/// Resolves NiceUrls for a given node id
 	/// </summary>
-    internal class NiceUrlResolver
+    internal class NiceUrlProvider
     {
-		public NiceUrlResolver(ContentStore contentStore, UmbracoContext umbracoContext)
+		public NiceUrlProvider(ContentStore contentStore, UmbracoContext umbracoContext)
         {
             _umbracoContext = umbracoContext;
             _contentStore = contentStore;
@@ -31,11 +31,25 @@ namespace Umbraco.Web
 
 		#region GetNiceUrl
 
+		/// <summary>
+		/// Gets the nice url of a node.
+		/// </summary>
+		/// <param name="nodeId">The node id.</param>
+		/// <returns>The nice url for the node.</returns>
+		/// <remarks>The url is absolute or relative depending on the current url.</remarks>
 		public string GetNiceUrl(int nodeId)
 		{
 			return GetNiceUrl(nodeId, _umbracoContext.UmbracoUrl, false);
 		}
 
+		/// <summary>
+		/// Gets the nice url of a node.
+		/// </summary>
+		/// <param name="nodeId">The node id.</param>
+		/// <param name="current">The current url.</param>
+		/// <param name="absolute">A value indicating whether the url should be absolute in any case.</param>
+		/// <returns>The nice url for the node.</returns>
+		/// <remarks>The url is absolute or relative depending on the current url, unless absolute is true, and then it is always absolute.</remarks>
 		public string GetNiceUrl(int nodeId, Uri current, bool absolute)
         {
         	string path;
@@ -86,6 +100,19 @@ namespace Umbraco.Web
 			return AssembleUrl(domainUri, path, current, absolute).ToString();
 		}
 
+		/// <summary>
+		/// Gets the nice urls of a node.
+		/// </summary>
+		/// <param name="nodeId">The node id.</param>
+		/// <returns>An enumeration of all valid urls for the node.</returns>
+		/// <remarks>The urls are absolute. A node can have more than one url if more than one domain is defined.</remarks>
+		public IEnumerable<string> GetNiceUrls(int nodeId)
+		{
+			// fixme - to be implemented
+			// this is for editContent.aspx which currently has its own, highly buggy, implementation of NiceUrl...
+			throw new NotImplementedException();
+		}
+
 		Uri AssembleUrl(Uri domain, string path, Uri current, bool absolute)
 		{
 			Uri uri;
diff --git a/src/Umbraco.Web/Routing/RequestDocumentResolverWeightAttribute.cs b/src/Umbraco.Web/Routing/RequestDocumentResolverWeightAttribute.cs
deleted file mode 100644
index c76d7d5cf6..0000000000
--- a/src/Umbraco.Web/Routing/RequestDocumentResolverWeightAttribute.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-using System;
-
-namespace Umbraco.Web.Routing
-{
-    /// <summary>
-    /// Specifies the relative weight of an <c>IRequestDocumentResolver</c> implementation.
-    /// </summary>
-    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
-    internal class RequestDocumentResolverWeightAttribute : Attribute
-    {
-        /// <summary>
-        /// Gets the default weight.
-        /// </summary>
-        public const int DefaultWeight = 100;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="RequestDocumentResolverWeightAttribute"/> class with the weight.
-        /// </summary>
-        /// <param name="weight">The weight.</param>
-        public RequestDocumentResolverWeightAttribute(int weight)
-            : base()
-        {
-            this.Weight = weight;
-        }
-
-        /// <summary>
-        /// Gets the weight.
-        /// </summary>
-        public int Weight { get; private set; }
-    }
-}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/RequestDocumentResolversResolver.cs b/src/Umbraco.Web/Routing/RequestDocumentResolversResolver.cs
new file mode 100644
index 0000000000..07735549e8
--- /dev/null
+++ b/src/Umbraco.Web/Routing/RequestDocumentResolversResolver.cs
@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+
+using Umbraco.Core;
+using Umbraco.Core.Resolving;
+
+namespace Umbraco.Web.Routing
+{
+	class RequestDocumentResolversResolver : ResolverBase<RequestDocumentResolversResolver>
+	{
+		internal RequestDocumentResolversResolver(IEnumerable<IRequestDocumentResolver> resolvers, IRequestDocumentLastChanceResolver lastChanceResolver)
+		{
+			_resolvers.AddRange(resolvers);
+			_lastChanceResolver.Value = lastChanceResolver;
+		}
+
+		#region LastChanceResolver
+
+		SingleResolved<IRequestDocumentLastChanceResolver> _lastChanceResolver = new SingleResolved<IRequestDocumentLastChanceResolver>(true);
+
+		public IRequestDocumentLastChanceResolver RequestDocumentLastChanceResolver
+		{
+			get { return _lastChanceResolver.Value; }
+			set { _lastChanceResolver.Value = value; }
+		}
+
+		#endregion
+
+		#region Resolvers
+
+		ManyWeightedResolved<IRequestDocumentResolver> _resolvers = new ManyWeightedResolved<IRequestDocumentResolver>();
+
+		public IEnumerable<IRequestDocumentResolver> RequestDocumentResolvers
+		{
+			get { return _resolvers.Values; }
+		}
+
+		public ManyWeightedResolved<IRequestDocumentResolver> RequestDocumentResolversResolution
+		{
+			get { return _resolvers; }
+		}
+
+		#endregion
+	}
+}
diff --git a/src/Umbraco.Web/Routing/ResolveByAlias.cs b/src/Umbraco.Web/Routing/ResolveByAlias.cs
index 3f41375309..321ef73bc0 100644
--- a/src/Umbraco.Web/Routing/ResolveByAlias.cs
+++ b/src/Umbraco.Web/Routing/ResolveByAlias.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Xml;
+using Umbraco.Core.Resolving;
 
 namespace Umbraco.Web.Routing
 {
@@ -10,7 +11,7 @@ namespace Umbraco.Web.Routing
     // at the moment aliases are not cleaned up into nice urls
     //
 
-    [RequestDocumentResolverWeight(50)]
+    [ResolutionWeight(50)]
     internal class ResolveByAlias : IRequestDocumentResolver
     {
 		static readonly TraceSource Trace = new TraceSource("ResolveByAlias");
diff --git a/src/Umbraco.Web/Routing/ResolveById.cs b/src/Umbraco.Web/Routing/ResolveById.cs
index 954152a7e2..0e2bfa74e1 100644
--- a/src/Umbraco.Web/Routing/ResolveById.cs
+++ b/src/Umbraco.Web/Routing/ResolveById.cs
@@ -1,13 +1,14 @@
 using System;
 using System.Diagnostics;
 using System.Xml;
+using Umbraco.Core.Resolving;
 
 namespace Umbraco.Web.Routing
 {
 
     // handles /1234 where 1234 is the id of a document
     //
-    [RequestDocumentResolverWeight(20)]
+    [ResolutionWeight(20)]
     internal class ResolveById : IRequestDocumentResolver
     {
 		static readonly TraceSource Trace = new TraceSource("ResolveById");
diff --git a/src/Umbraco.Web/Routing/ResolveByNiceUrl.cs b/src/Umbraco.Web/Routing/ResolveByNiceUrl.cs
index d5d7cb1b8f..4d8ebe0266 100644
--- a/src/Umbraco.Web/Routing/ResolveByNiceUrl.cs
+++ b/src/Umbraco.Web/Routing/ResolveByNiceUrl.cs
@@ -1,12 +1,13 @@
 using System.Diagnostics;
 using System.Xml;
+using Umbraco.Core.Resolving;
 
 namespace Umbraco.Web.Routing
 {
     // handles "/foo/bar" where "/foo/bar" is the path to a document
     //
 
-    [RequestDocumentResolverWeight(10)]
+    [ResolutionWeight(10)]
     internal class ResolveByNiceUrl : IRequestDocumentResolver
     {
 		static readonly TraceSource Trace = new TraceSource("ResolveByNiceUrl");
diff --git a/src/Umbraco.Web/Routing/ResolveByNiceUrlAndTemplate.cs b/src/Umbraco.Web/Routing/ResolveByNiceUrlAndTemplate.cs
index 1ccb043af6..a5a7473fd9 100644
--- a/src/Umbraco.Web/Routing/ResolveByNiceUrlAndTemplate.cs
+++ b/src/Umbraco.Web/Routing/ResolveByNiceUrlAndTemplate.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Xml;
+using Umbraco.Core.Resolving;
 using umbraco.cms.businesslogic.template;
 
 namespace Umbraco.Web.Routing
@@ -8,7 +9,7 @@ namespace Umbraco.Web.Routing
     // handles /foo/bar/<template> where <template> is a valid template alias
     // and /foo/bar the nice url of a document
     //
-    [RequestDocumentResolverWeight(30)]
+    [ResolutionWeight(30)]
     internal class ResolveByNiceUrlAndTemplate : ResolveByNiceUrl, IRequestDocumentResolver
     {
 		static readonly TraceSource Trace = new TraceSource("ResolveByNiceUrlAndTemplate");		
diff --git a/src/Umbraco.Web/Routing/ResolveByProfile.cs b/src/Umbraco.Web/Routing/ResolveByProfile.cs
index dc5f4f7ff2..afd624e8d5 100644
--- a/src/Umbraco.Web/Routing/ResolveByProfile.cs
+++ b/src/Umbraco.Web/Routing/ResolveByProfile.cs
@@ -1,5 +1,6 @@
 using System.Diagnostics;
 using System.Xml;
+using Umbraco.Core.Resolving;
 using umbraco;
 
 namespace Umbraco.Web.Routing
@@ -11,7 +12,7 @@ namespace Umbraco.Web.Routing
     //
     // we're keeping it here only for backward compatibility.
     //
-    [RequestDocumentResolverWeight(40)]
+    [ResolutionWeight(40)]
     internal class ResolveByProfile : ResolveByNiceUrl, IRequestDocumentResolver
     {
 		static readonly TraceSource Trace = new TraceSource("ResolveByProfile");		
diff --git a/src/Umbraco.Web/Routing/RouteLookups.cs b/src/Umbraco.Web/Routing/RouteLookups.cs
deleted file mode 100644
index 6abaa2e7f4..0000000000
--- a/src/Umbraco.Web/Routing/RouteLookups.cs
+++ /dev/null
@@ -1,111 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using Umbraco.Core;
-
-namespace Umbraco.Web.Routing
-{
-	// fixme - this class is broken in various ways
-	// + we can't reproduce that sort of code for everything we need to discover
-
-	/// <summary>
-	/// Represents a collection of ILookup used for routing that are registered in the application
-	/// </summary>
-	internal class RouteLookups
-	{
-		private static readonly List<IRequestDocumentResolver> Lookups = new List<IRequestDocumentResolver>();
-		private static readonly ReaderWriterLockSlim Lock = new ReaderWriterLockSlim();
-
-		/// <summary>
-		/// Singleton accessor
-		/// </summary>
-		public static RouteLookups Current { get; internal set; }
-
-		internal RouteLookups(IEnumerable<IRequestDocumentResolver> lookups)
-		{
-			Lookups.AddRange(SortByWeight(lookups));
-		}
-
-		/// <summary>
-		/// Returns all of the lookups
-		/// </summary>
-		/// <returns></returns>
-		public IEnumerable<IRequestDocumentResolver> GetLookups()
-		{
-			// FIXME - and then, we return a non-thread-safe collection ... WTF?
-
-			return Lookups;
-		} 
-
-		/// <summary>
-		/// Removes an ILookup based on the specified Type
-		/// </summary>
-		/// <typeparam name="T"></typeparam>
-		public void RemoveLookup<T>()
-			where T : IRequestDocumentResolver
-		{
-			using (new WriteLock(Lock))
-			{
-				Lookups.Remove(Lookups.SingleOrDefault(x => x is T));	
-			}			
-		}
-
-	
-		/// <summary>
-		/// Adds a new lookup to the end of the list
-		/// </summary>
-		/// <param name="lookup"></param>
-		public void AddLookup(IRequestDocumentResolver lookup)
-		{
-			using (var l = new UpgradeableReadLock(Lock))
-			{
-				if (CheckExists(lookup))
-					throw new InvalidOperationException(string.Format("The lookup type \"{0}\" already exists in the lookup collection.", lookup));
-				l.UpgradeToWriteLock();
-				Lookups.Add(lookup);
-			}
-		}
-
-		/// <summary>
-		/// Inserts a lookup at the specified index
-		/// </summary>
-		/// <param name="index"></param>
-		/// <param name="lookup"></param>
-		public void InsertLookup(int index, IRequestDocumentResolver lookup)
-		{
-			if (CheckExists(lookup))
-				throw new InvalidOperationException("The lookup type " + lookup + " already exists in the lookup collection");
-			
-			using (new WriteLock(Lock))
-			{
-				Lookups.Insert(index, lookup);
-			}			
-		}
-
-		/// <summary>
-		/// checks if a lookup already exists by type
-		/// </summary>
-		/// <param name="lookup"></param>
-		/// <returns></returns>
-		private static bool CheckExists(IRequestDocumentResolver lookup)
-		{
-			return Lookups.Any(x => x.GetType() == lookup.GetType());
-		}
-
-		/// <summary>
-		/// Sorts the ILookups in the list based on an attribute weight if one is specified
-		/// </summary>
-		/// <param name="lookups"></param>
-		/// <returns></returns>
-		private static IEnumerable<IRequestDocumentResolver> SortByWeight(IEnumerable<IRequestDocumentResolver> lookups)
-		{
-			return lookups.OrderBy(x =>
-				{
-					var attribute = x.GetType().GetCustomAttributes(true).OfType<RequestDocumentResolverWeightAttribute>().SingleOrDefault();
-					return attribute == null ? RequestDocumentResolverWeightAttribute.DefaultWeight : attribute.Weight;
-				}).ToList();
-		}
-
-	}
-}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/RoutesCache.cs b/src/Umbraco.Web/Routing/RoutesCache.cs
deleted file mode 100644
index e46fa9681c..0000000000
--- a/src/Umbraco.Web/Routing/RoutesCache.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-using System;
-
-namespace Umbraco.Web.Routing
-{
-	// this is a bi-directional cache that contains
-	// - nodeId to route (used for NiceUrl)
-	// - route to nodeId (used for inbound requests)
-	//
-	// a route is [rootId]/path/to/node
-	// where rootId is the id of the "site root" node
-	//
-	internal class RoutesCache
-	{
-		private static readonly RoutesCache Instance = new RoutesCache();
-		private static IRoutesCache _provider;
-
-		/// <summary>
-		/// public contructor assigns the DefaultRoutesCache as the default provider
-		/// </summary>
-		public RoutesCache()
-			:this(null)
-		{			
-		}
-
-		/// <summary>
-		/// Constructor sets a custom provider if specified
-		/// </summary>
-		/// <param name="provider"></param>
-		internal RoutesCache(IRoutesCache provider)
-		{
-			_provider = provider ?? new DefaultRoutesCache();
-		}
-
-		/// <summary>
-		/// Set the routes cache provider
-		/// </summary>
-		/// <param name="provider"></param>
-		public static void SetProvider(IRoutesCache provider)
-		{
-			if (provider == null) throw new ArgumentNullException("provider");
-			_provider = provider;
-		}
-
-		/// <summary>
-		/// Singleton accessor
-		/// </summary>
-		public static RoutesCache Current
-		{
-			get { return Instance; }
-		}
-
-		/// <summary>
-		/// Get the current provider
-		/// </summary>
-		/// <returns></returns>
-		public IRoutesCache GetProvider()
-		{
-			return _provider;
-		}
-	}
-}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/RoutesCacheResolver.cs b/src/Umbraco.Web/Routing/RoutesCacheResolver.cs
new file mode 100644
index 0000000000..98d1114866
--- /dev/null
+++ b/src/Umbraco.Web/Routing/RoutesCacheResolver.cs
@@ -0,0 +1,18 @@
+using System;
+using Umbraco.Core.Resolving;
+
+namespace Umbraco.Web.Routing
+{
+	class RoutesCacheResolver : SingleResolverBase<RoutesCacheResolver, IRoutesCache>
+	{
+		internal RoutesCacheResolver(IRoutesCache routesCache)
+			: base(routesCache)
+		{ }
+
+		public IRoutesCache RoutesCache
+		{
+			get { return this.Value; }
+			set { this.Value = value; }
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/RoutingContext.cs b/src/Umbraco.Web/Routing/RoutingContext.cs
index dc75d3451f..33ecdbcd42 100644
--- a/src/Umbraco.Web/Routing/RoutingContext.cs
+++ b/src/Umbraco.Web/Routing/RoutingContext.cs
@@ -12,22 +12,19 @@ namespace Umbraco.Web.Routing
     {
         public RoutingContext(
 			UmbracoContext umbracoContext,
-            RouteLookups lookups,
-            IRequestDocumentLastChanceResolver lookupNotFound,
+			RequestDocumentResolversResolver requestDocumentResolversResolver,
             ContentStore contentStore,
-			NiceUrlResolver niceUrlResolver)
+			NiceUrlProvider niceUrlResolver)
         {
-        	UmbracoContext = umbracoContext;
-        	RouteLookups = lookups;
-            LookupNotFound = lookupNotFound;
-            ContentStore = contentStore;
-        	NiceUrlResolver = niceUrlResolver;
+        	this.UmbracoContext = umbracoContext;
+			this.RequestDocumentResolversResolver = requestDocumentResolversResolver;
+            this.ContentStore = contentStore;
+        	this.NiceUrlProvider = niceUrlResolver;
         }
 
 		public UmbracoContext UmbracoContext { get; private set; }
-		public RouteLookups RouteLookups { get; private set; }
-    	public IRequestDocumentLastChanceResolver LookupNotFound { get; private set; }
+		public RequestDocumentResolversResolver RequestDocumentResolversResolver { get; private set; }
         public ContentStore ContentStore { get; private set; }
-		public NiceUrlResolver NiceUrlResolver { get; private set; }
+		public NiceUrlProvider NiceUrlProvider { get; private set; }
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Web/Umbraco.Web.csproj b/src/Umbraco.Web/Umbraco.Web.csproj
index 7b97dc8436..73874de594 100644
--- a/src/Umbraco.Web/Umbraco.Web.csproj
+++ b/src/Umbraco.Web/Umbraco.Web.csproj
@@ -240,10 +240,10 @@
     <Compile Include="ContentStore.cs" />
     <Compile Include="LegacyRequestInitializer.cs" />
     <Compile Include="Mvc\ControllerExtensions.cs" />
-    <Compile Include="NiceUrlResolver.cs" />
+    <Compile Include="Routing\NiceUrlProvider.cs" />
     <Compile Include="PluginResolverExtensions.cs" />
     <Compile Include="Routing\Domains.cs" />
-    <Compile Include="Routing\RouteLookups.cs" />
+    <Compile Include="Routing\RequestDocumentResolversResolver.cs" />
     <Compile Include="Routing\DocumentRequest.cs" />
     <Compile Include="Routing\IRequestDocumentResolver.cs" />
     <Compile Include="Routing\IRequestDocumentLastChanceResolver.cs" />
@@ -254,9 +254,8 @@
     <Compile Include="Routing\ResolveByNiceUrlAndTemplate.cs" />
     <Compile Include="Routing\ResolveByProfile.cs" />
     <Compile Include="Routing\ResolveLastChance.cs" />
-    <Compile Include="Routing\RequestDocumentResolverWeightAttribute.cs" />
     <Compile Include="Routing\DefaultRoutesCache.cs" />
-    <Compile Include="Routing\RoutesCache.cs" />
+    <Compile Include="Routing\RoutesCacheResolver.cs" />
     <Compile Include="Routing\RoutingContext.cs" />
     <Compile Include="umbraco.presentation\EnsureSystemPathsApplicationStartupHandler.cs" />
     <Compile Include="umbraco.presentation\install\steps\database.ascx.cs">
@@ -1814,7 +1813,9 @@
     <Content Include="umbraco.presentation\umbraco\dialogs\Preview.aspx" />
     <Content Include="umbraco.presentation\umbraco\controls\passwordChanger.ascx" />
     <Content Include="umbraco.presentation\umbraco\controls\ProgressBar.ascx" />
-    <Content Include="umbraco.presentation\umbraco\controls\ContentTypeControlNew.ascx" />
+    <Content Include="umbraco.presentation\umbraco\controls\ContentTypeControlNew.ascx">
+      <SubType>ASPXCodeBehind</SubType>
+    </Content>
     <Content Include="umbraco.presentation\umbraco\controls\GenericProperties\GenericProperty.ascx" />
     <Content Include="umbraco.presentation\umbraco\create\DLRScripting.ascx" />
     <Content Include="umbraco.presentation\umbraco\controls\Images\ImageViewer.ascx" />
diff --git a/src/Umbraco.Web/UmbracoApplication.cs b/src/Umbraco.Web/UmbracoApplication.cs
index 5febadc78a..53447f4698 100644
--- a/src/Umbraco.Web/UmbracoApplication.cs
+++ b/src/Umbraco.Web/UmbracoApplication.cs
@@ -35,8 +35,11 @@ namespace Umbraco.Web
 					IsReady = true	// fixme
 				};
 
-			//create the route lookups singleton
-			RouteLookups.Current = new RouteLookups(ApplicationContext.Current.Plugins.ResolveLookups());
+			// create the resolvers
+			RequestDocumentResolversResolver.Current = new RequestDocumentResolversResolver(ApplicationContext.Current.Plugins.ResolveLookups(), new ResolveLastChance());
+			RoutesCacheResolver.Current = new RoutesCacheResolver(new DefaultRoutesCache());
+
+			Umbraco.Core.Resolving.Resolution.Freeze();
 
 			Trace.TraceInformation("AppDomain is initialized");
 		}
diff --git a/src/Umbraco.Web/UmbracoContext.cs b/src/Umbraco.Web/UmbracoContext.cs
index 46f7f38aa5..806ef7a438 100644
--- a/src/Umbraco.Web/UmbracoContext.cs
+++ b/src/Umbraco.Web/UmbracoContext.cs
@@ -132,7 +132,7 @@ namespace Umbraco.Web
 			set
 			{
 				_requestUrl = value;
-				this.UmbracoUrl = NiceUrlResolver.UriToUmbraco(_requestUrl);
+				this.UmbracoUrl = NiceUrlProvider.UriToUmbraco(_requestUrl);
 			}
 		}
 
diff --git a/src/Umbraco.Web/UmbracoModule.cs b/src/Umbraco.Web/UmbracoModule.cs
index 3881f26b53..49a8f2cc67 100644
--- a/src/Umbraco.Web/UmbracoModule.cs
+++ b/src/Umbraco.Web/UmbracoModule.cs
@@ -45,7 +45,7 @@ namespace Umbraco.Web
             var umbracoContext = new UmbracoContext(
 				new HttpContextWrapper(httpContext), 
 				ApplicationContext.Current,
-				 RoutesCache.Current.GetProvider());
+				 RoutesCacheResolver.Current.RoutesCache);
             UmbracoContext.Current = umbracoContext;
 
 			// NO!
@@ -54,12 +54,11 @@ namespace Umbraco.Web
             //create a content store
             var contentStore = new ContentStore(umbracoContext);            
             //create the nice urls
-            var niceUrls = new NiceUrlResolver(contentStore, umbracoContext);
+            var niceUrls = new NiceUrlProvider(contentStore, umbracoContext);
             //create the RoutingContext (one per http request)
         	var routingContext = new RoutingContext(
         		umbracoContext,
-        		RouteLookups.Current,
-        		new ResolveLastChance(),
+        		RequestDocumentResolversResolver.Current,
         		contentStore,
         		niceUrls);
 			// NOT HERE BUT SEE **THERE** BELOW
diff --git a/src/Umbraco.Web/umbraco.presentation/library.cs b/src/Umbraco.Web/umbraco.presentation/library.cs
index d1df067bae..e899524309 100644
--- a/src/Umbraco.Web/umbraco.presentation/library.cs
+++ b/src/Umbraco.Web/umbraco.presentation/library.cs
@@ -355,10 +355,8 @@ namespace umbraco
         /// <returns>String with a friendly url from a node</returns>
         public static string NiceUrl(int nodeID)
         {
-			// OK, how are we supposed to retrieve the NiceUrlResolver from here,
-			// bearing in mind that we don't want to instanciate a resolver + content store + ...
-			// for every NiceUrl call ?!
-			return Umbraco.Core.UmbracoContainer.Get<Umbraco.Web.Routing.NiceUrls>().GetNiceUrl(nodeID);
+			var niceUrlsProvider = Umbraco.Web.UmbracoContext.Current.DocumentRequest.RoutingContext.NiceUrlProvider;
+			return niceUrlsProvider.GetNiceUrl(nodeID);
         }
 
         /// <summary>
@@ -380,10 +378,8 @@ namespace umbraco
         /// <returns>String with a friendly url with full domain from a node</returns>
         public static string NiceUrlWithDomain(int nodeID)
         {
-			// OK, how are we supposed to retrieve the NiceUrlResolver from here,
-			// bearing in mind that we don't want to instanciate a resolver + content store + ...
-			// for every NiceUrl call ?!
-			return Umbraco.Core.UmbracoContainer.Get<Umbraco.Web.Routing.NiceUrls>().GetNiceUrl(nodeID, Umbraco.Web.UmbracoContext.Current.UmbracoUrl, true);
+			var niceUrlsProvider = Umbraco.Web.UmbracoContext.Current.DocumentRequest.RoutingContext.NiceUrlProvider;
+			return niceUrlsProvider.GetNiceUrl(nodeID, Umbraco.Web.UmbracoContext.Current.UmbracoUrl, true);
         }