diff --git a/Splat/Logging.cs b/Splat/Logging.cs
new file mode 100644
index 000000000..2706e96bc
--- /dev/null
+++ b/Splat/Logging.cs
@@ -0,0 +1,611 @@
+using System;
+using System.ComponentModel;
+using System.Reflection;
+using System.Globalization;
+using System.Text;
+using System.Threading;
+using System.Diagnostics;
+using System.Diagnostics.Contracts;
+
+namespace Splat
+{
+    /*    
+     * Interfaces
+     */
+
+    public enum LogLevel {
+        Debug = 1, Info, Warn, Error, Fatal,
+    }
+
+    public interface ILogger
+    {
+        void Write([Localizable(false)] string message, LogLevel logLevel);
+        LogLevel Level { get; set; }
+    }
+
+    public interface IFullLogger : ILogger
+    {
+        void Debug<T>(T value);
+        void Debug<T>(IFormatProvider formatProvider, T value);
+        void DebugException([Localizable(false)] string message, Exception exception);
+        void Debug(IFormatProvider formatProvider, [Localizable(false)] string message, params object[] args);
+        void Debug([Localizable(false)] string message);
+        void Debug([Localizable(false)] string message, params object[] args);
+        void Debug<TArgument>(IFormatProvider formatProvider, [Localizable(false)] string message, TArgument argument);
+        void Debug<TArgument>([Localizable(false)] string message, TArgument argument);
+        void Debug<TArgument1, TArgument2>(IFormatProvider formatProvider, [Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2);
+        void Debug<TArgument1, TArgument2>([Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2);
+        void Debug<TArgument1, TArgument2, TArgument3>(IFormatProvider formatProvider, [Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3);
+        void Debug<TArgument1, TArgument2, TArgument3>([Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3);
+
+        void Info<T>(T value);
+        void Info<T>(IFormatProvider formatProvider, T value);
+        void InfoException([Localizable(false)] string message, Exception exception);
+        void Info(IFormatProvider formatProvider, [Localizable(false)] string message, params object[] args);
+        void Info([Localizable(false)] string message);
+        void Info([Localizable(false)] string message, params object[] args);
+        void Info<TArgument>(IFormatProvider formatProvider, [Localizable(false)] string message, TArgument argument);
+        void Info<TArgument>([Localizable(false)] string message, TArgument argument);
+        void Info<TArgument1, TArgument2>(IFormatProvider formatProvider, [Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2);
+        void Info<TArgument1, TArgument2>([Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2);
+        void Info<TArgument1, TArgument2, TArgument3>(IFormatProvider formatProvider, [Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3);
+        void Info<TArgument1, TArgument2, TArgument3>([Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3);
+
+        void Warn<T>(T value);
+        void Warn<T>(IFormatProvider formatProvider, T value);
+        void WarnException([Localizable(false)] string message, Exception exception);
+        void Warn(IFormatProvider formatProvider, [Localizable(false)] string message, params object[] args);
+        void Warn([Localizable(false)] string message);
+        void Warn([Localizable(false)] string message, params object[] args);
+        void Warn<TArgument>(IFormatProvider formatProvider, [Localizable(false)] string message, TArgument argument);
+        void Warn<TArgument>([Localizable(false)] string message, TArgument argument);
+        void Warn<TArgument1, TArgument2>(IFormatProvider formatProvider, [Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2);
+        void Warn<TArgument1, TArgument2>([Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2);
+        void Warn<TArgument1, TArgument2, TArgument3>(IFormatProvider formatProvider, [Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3);
+        void Warn<TArgument1, TArgument2, TArgument3>([Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3);
+
+        void Error<T>(T value);
+        void Error<T>(IFormatProvider formatProvider, T value);
+        void ErrorException([Localizable(false)] string message, Exception exception);
+        void Error(IFormatProvider formatProvider, [Localizable(false)] string message, params object[] args);
+        void Error([Localizable(false)] string message);
+        void Error([Localizable(false)] string message, params object[] args);
+        void Error<TArgument>(IFormatProvider formatProvider, [Localizable(false)] string message, TArgument argument);
+        void Error<TArgument>([Localizable(false)] string message, TArgument argument);
+        void Error<TArgument1, TArgument2>(IFormatProvider formatProvider, [Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2);
+        void Error<TArgument1, TArgument2>([Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2);
+        void Error<TArgument1, TArgument2, TArgument3>(IFormatProvider formatProvider, [Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3);
+        void Error<TArgument1, TArgument2, TArgument3>([Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3);
+
+        void Fatal<T>(T value);
+        void Fatal<T>(IFormatProvider formatProvider, T value);
+        void FatalException([Localizable(false)] string message, Exception exception);
+        void Fatal(IFormatProvider formatProvider, [Localizable(false)] string message, params object[] args);
+        void Fatal([Localizable(false)] string message);
+        void Fatal([Localizable(false)] string message, params object[] args);
+        void Fatal<TArgument>(IFormatProvider formatProvider, [Localizable(false)] string message, TArgument argument);
+        void Fatal<TArgument>([Localizable(false)] string message, TArgument argument);
+        void Fatal<TArgument1, TArgument2>(IFormatProvider formatProvider, [Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2);
+        void Fatal<TArgument1, TArgument2>([Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2);
+        void Fatal<TArgument1, TArgument2, TArgument3>(IFormatProvider formatProvider, [Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3);
+        void Fatal<TArgument1, TArgument2, TArgument3>([Localizable(false)] string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3);
+    }
+
+    public interface ILogManager
+    {
+        IFullLogger GetLogger(Type type);
+    }
+
+    class DefaultLogManager : ILogManager
+    {
+        readonly MemoizingMRUCache<Type, IFullLogger> loggerCache;
+
+        public DefaultLogManager(IDependencyResolver dependencyResolver = null)
+        {
+            dependencyResolver = dependencyResolver ?? Locator.Current;
+
+            loggerCache = new MemoizingMRUCache<Type, IFullLogger>((type, _) => {
+                var ret = dependencyResolver.GetService<ILogger>();
+                if (ret == null) {
+                    throw new Exception("Couldn't find an ILogger. This should never happen, your dependency resolver is probably broken.");
+                }
+
+                return new WrappingFullLogger(ret, type);
+            }, 64);
+        }
+
+        static readonly IFullLogger nullLogger = new WrappingFullLogger(new NullLogger(), typeof(MemoizingMRUCache<Type, IFullLogger>));
+        public IFullLogger GetLogger(Type type)
+        {
+            if (LogHost.suppressLogging) return nullLogger;
+            if (type == typeof(MemoizingMRUCache<Type, IFullLogger>)) return nullLogger;
+
+            lock (loggerCache) {
+                return loggerCache.Get(type);
+            }
+        }
+    }
+
+    public class FuncLogManager : ILogManager
+    {
+        readonly Func<Type, IFullLogger> _inner;
+        public FuncLogManager(Func<Type, IFullLogger> getLogger)
+        {
+            _inner = getLogger;
+        }
+
+        public IFullLogger GetLogger(Type type)
+        {
+            return _inner(type);
+        }
+    }
+
+    public static class LogManagerMixin
+    {
+        public static IFullLogger GetLogger<T>(this ILogManager This)
+        {
+            return This.GetLogger(typeof(T));
+        }
+    }
+
+    public class NullLogger : ILogger
+    {
+        public void Write(string message, LogLevel logLevel) {}
+        public LogLevel Level { get; set; }
+    }
+
+    public class DebugLogger : ILogger
+    {
+        public void Write(string message, LogLevel logLevel)
+        {
+            if ((int)logLevel < (int)Level) return;
+            Debug.WriteLine(message);
+        }
+
+        public LogLevel Level { get; set; }
+    }
+
+
+    /*    
+     * LogHost / Logging Mixin
+     */
+
+    /// <summary>
+    /// "Implement" this interface in your class to get access to the Log() 
+    /// Mixin, which will give you a Logger that includes the class name in the
+    /// log.
+    /// </summary>
+    public interface IEnableLogger { }
+
+    public static class LogHost
+    {
+        static internal bool suppressLogging = false;
+        static readonly IFullLogger nullLogger = new WrappingFullLogger(new NullLogger(), typeof(string));
+
+        /// <summary>
+        /// Use this logger inside miscellaneous static methods where creating
+        /// a class-specific logger isn't really worth it.
+        /// </summary>
+        public static IFullLogger Default {
+            get {
+                if (suppressLogging) return nullLogger;
+
+                var factory = Locator.Current.GetService<ILogManager>();
+                if (factory == null) {
+                    throw new Exception("ILogManager is null. This should never happen, your dependency resolver is broken");
+                }
+                return factory.GetLogger(typeof(LogHost));
+            }
+        }
+
+        /// <summary>
+        /// Call this method to write log entries on behalf of the current 
+        /// class.
+        /// </summary>
+        public static IFullLogger Log<T>(this T This) where T : IEnableLogger
+        {
+            if (suppressLogging) return nullLogger;
+
+            var factory = Locator.Current.GetService<ILogManager>();
+            if (factory == null) {
+                throw new Exception("ILogManager is null. This should never happen, your dependency resolver is broken");
+            }
+
+            return factory.GetLogger<T>();
+        }
+    }
+
+    #region Extremely Dull Code Ahead
+    internal class WrappingFullLogger : IFullLogger
+    {
+        readonly ILogger _inner;
+        readonly string prefix;
+        readonly MethodInfo stringFormat;
+
+        public WrappingFullLogger(ILogger inner, Type callingType)
+        {
+            _inner = inner;
+            prefix = String.Format(CultureInfo.InvariantCulture, "{0}: ", callingType.Name);
+
+            stringFormat = typeof (String).GetMethod("Format", new[] {typeof (IFormatProvider), typeof (string), typeof (object[])});
+            Contract.Requires(inner != null);
+            Contract.Requires(stringFormat != null);
+        }
+
+        public void Debug<T>(T value)
+        {
+            _inner.Write(prefix + value, LogLevel.Debug);
+        }
+
+        public void Debug<T>(IFormatProvider formatProvider, T value)
+        {
+            _inner.Write(String.Format(formatProvider, "{0}{1}", prefix, value), LogLevel.Debug);
+        }
+
+        public void DebugException(string message, Exception exception)
+        {
+            _inner.Write(String.Format("{0}{1}: {2}", prefix, message, exception), LogLevel.Debug);
+        }
+
+        public void Debug(IFormatProvider formatProvider, string message, params object[] args)
+        {
+            var sfArgs = new object[args.Length + 2];
+            sfArgs[0] = formatProvider; sfArgs[1] = message;
+            Array.Copy(args, 0, sfArgs, 2, args.Length);
+            string result = (string)stringFormat.Invoke(null, sfArgs);
+
+            _inner.Write(prefix + result, LogLevel.Debug);
+        }
+
+        public void Debug(string message)
+        {
+            _inner.Write(prefix + message, LogLevel.Debug);
+        }
+
+        public void Debug(string message, params object[] args)
+        {
+            var sfArgs = new object[args.Length + 2];
+            sfArgs[0] = CultureInfo.InvariantCulture; sfArgs[1] = message;
+            Array.Copy(args, 0, sfArgs, 2, args.Length);
+            string result = (string)stringFormat.Invoke(null, sfArgs);
+
+            _inner.Write(prefix + result, LogLevel.Debug);
+        }
+
+        public void Debug<TArgument>(IFormatProvider formatProvider, string message, TArgument argument)
+        {
+            _inner.Write(prefix + String.Format(formatProvider, message, argument), LogLevel.Debug);
+        }
+
+        public void Debug<TArgument>(string message, TArgument argument)
+        {
+            _inner.Write(prefix + String.Format(CultureInfo.InvariantCulture, message, argument), LogLevel.Debug);
+        }
+
+        public void Debug<TArgument1, TArgument2>(IFormatProvider formatProvider, string message, TArgument1 argument1, TArgument2 argument2)
+        {
+            _inner.Write(prefix + String.Format(formatProvider, message, argument1, argument2), LogLevel.Debug);
+        }
+
+        public void Debug<TArgument1, TArgument2>(string message, TArgument1 argument1, TArgument2 argument2)
+        {
+            _inner.Write(prefix + String.Format(CultureInfo.InvariantCulture, message, argument1, argument2), LogLevel.Debug);
+        }
+
+        public void Debug<TArgument1, TArgument2, TArgument3>(IFormatProvider formatProvider, string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3)
+        {
+            _inner.Write(prefix + String.Format(formatProvider, message, argument1, argument2, argument3), LogLevel.Debug);
+        }
+
+        public void Debug<TArgument1, TArgument2, TArgument3>(string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3)
+        {
+            _inner.Write(prefix + String.Format(CultureInfo.InvariantCulture, message, argument1, argument2, argument3), LogLevel.Debug);
+        }
+
+        public void Info<T>(T value)
+        {
+            _inner.Write(prefix + value, LogLevel.Info);
+        }
+
+        public void Info<T>(IFormatProvider formatProvider, T value)
+        {
+            _inner.Write(String.Format(formatProvider, "{0}{1}", prefix, value), LogLevel.Info);
+        }
+
+        public void InfoException(string message, Exception exception)
+        {
+            _inner.Write(String.Format("{0}{1}: {2}", prefix, message, exception), LogLevel.Info);
+        }
+
+        public void Info(IFormatProvider formatProvider, string message, params object[] args)
+        {
+            var sfArgs = new object[args.Length + 2];
+            sfArgs[0] = formatProvider; sfArgs[1] = message;
+            Array.Copy(args, 0, sfArgs, 2, args.Length);
+            string result = (string)stringFormat.Invoke(null, sfArgs);
+
+            _inner.Write(prefix + result, LogLevel.Info);
+        }
+
+        public void Info(string message)
+        {
+            _inner.Write(prefix + message, LogLevel.Info);
+        }
+
+        public void Info(string message, params object[] args)
+        {
+            var sfArgs = new object[args.Length + 2];
+            sfArgs[0] = CultureInfo.InvariantCulture; sfArgs[1] = message;
+            Array.Copy(args, 0, sfArgs, 2, args.Length);
+            string result = (string)stringFormat.Invoke(null, sfArgs);
+
+            _inner.Write(prefix + result, LogLevel.Info);
+        }
+
+        public void Info<TArgument>(IFormatProvider formatProvider, string message, TArgument argument)
+        {
+            _inner.Write(prefix + String.Format(formatProvider, message, argument), LogLevel.Info);
+        }
+
+        public void Info<TArgument>(string message, TArgument argument)
+        {
+            _inner.Write(prefix + String.Format(CultureInfo.InvariantCulture, message, argument), LogLevel.Info);
+        }
+
+        public void Info<TArgument1, TArgument2>(IFormatProvider formatProvider, string message, TArgument1 argument1, TArgument2 argument2)
+        {
+            _inner.Write(prefix + String.Format(formatProvider, message, argument1, argument2), LogLevel.Info);
+        }
+
+        public void Info<TArgument1, TArgument2>(string message, TArgument1 argument1, TArgument2 argument2)
+        {
+            _inner.Write(prefix + String.Format(CultureInfo.InvariantCulture, message, argument1, argument2), LogLevel.Info);
+        }
+
+        public void Info<TArgument1, TArgument2, TArgument3>(IFormatProvider formatProvider, string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3)
+        {
+            _inner.Write(prefix + String.Format(formatProvider, message, argument1, argument2, argument3), LogLevel.Info);
+        }
+
+        public void Info<TArgument1, TArgument2, TArgument3>(string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3)
+        {
+            _inner.Write(prefix + String.Format(CultureInfo.InvariantCulture, message, argument1, argument2, argument3), LogLevel.Info);
+        }
+
+        public void Warn<T>(T value)
+        {
+            _inner.Write(prefix + value, LogLevel.Warn);
+        }
+
+        public void Warn<T>(IFormatProvider formatProvider, T value)
+        {
+            _inner.Write(String.Format(formatProvider, "{0}{1}", prefix, value), LogLevel.Warn);
+        }
+
+        public void WarnException(string message, Exception exception)
+        {
+            _inner.Write(String.Format("{0}{1}: {2}", prefix, message, exception), LogLevel.Warn);
+        }
+
+        public void Warn(IFormatProvider formatProvider, string message, params object[] args)
+        {
+            var sfArgs = new object[args.Length + 2];
+            sfArgs[0] = formatProvider; sfArgs[1] = message;
+            Array.Copy(args, 0, sfArgs, 2, args.Length);
+            string result = (string)stringFormat.Invoke(null, sfArgs);
+
+            _inner.Write(prefix + result, LogLevel.Warn);
+        }
+
+        public void Warn(string message)
+        {
+            _inner.Write(prefix + message, LogLevel.Warn);
+        }
+
+        public void Warn(string message, params object[] args)
+        {
+            var sfArgs = new object[args.Length + 2];
+            sfArgs[0] = CultureInfo.InvariantCulture; sfArgs[1] = message;
+            Array.Copy(args, 0, sfArgs, 2, args.Length);
+            string result = (string)stringFormat.Invoke(null, sfArgs);
+
+            _inner.Write(prefix + result, LogLevel.Warn);
+        }
+
+        public void Warn<TArgument>(IFormatProvider formatProvider, string message, TArgument argument)
+        {
+            _inner.Write(prefix + String.Format(formatProvider, message, argument), LogLevel.Warn);
+        }
+
+        public void Warn<TArgument>(string message, TArgument argument)
+        {
+            _inner.Write(prefix + String.Format(CultureInfo.InvariantCulture, message, argument), LogLevel.Warn);
+        }
+
+        public void Warn<TArgument1, TArgument2>(IFormatProvider formatProvider, string message, TArgument1 argument1, TArgument2 argument2)
+        {
+            _inner.Write(prefix + String.Format(formatProvider, message, argument1, argument2), LogLevel.Warn);
+        }
+
+        public void Warn<TArgument1, TArgument2>(string message, TArgument1 argument1, TArgument2 argument2)
+        {
+            _inner.Write(prefix + String.Format(CultureInfo.InvariantCulture, message, argument1, argument2), LogLevel.Warn);
+        }
+
+        public void Warn<TArgument1, TArgument2, TArgument3>(IFormatProvider formatProvider, string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3)
+        {
+            _inner.Write(prefix + String.Format(formatProvider, message, argument1, argument2, argument3), LogLevel.Warn);
+        }
+
+        public void Warn<TArgument1, TArgument2, TArgument3>(string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3)
+        {
+            _inner.Write(prefix + String.Format(CultureInfo.InvariantCulture, message, argument1, argument2, argument3), LogLevel.Warn);
+        }
+
+
+        public void Error<T>(T value)
+        {
+            _inner.Write(prefix + value, LogLevel.Error);
+        }
+
+        public void Error<T>(IFormatProvider formatProvider, T value)
+        {
+            _inner.Write(String.Format(formatProvider, "{0}{1}", prefix, value), LogLevel.Error);
+        }
+
+        public void ErrorException(string message, Exception exception)
+        {
+            _inner.Write(String.Format("{0}{1}: {2}", prefix, message, exception), LogLevel.Error);
+        }
+
+        public void Error(IFormatProvider formatProvider, string message, params object[] args)
+        {
+            var sfArgs = new object[args.Length + 2];
+            sfArgs[0] = formatProvider; sfArgs[1] = message;
+            Array.Copy(args, 0, sfArgs, 2, args.Length);
+            string result = (string)stringFormat.Invoke(null, sfArgs);
+
+            _inner.Write(prefix + result, LogLevel.Error);
+        }
+
+        public void Error(string message)
+        {
+            _inner.Write(prefix + message, LogLevel.Error);
+        }
+
+        public void Error(string message, params object[] args)
+        {
+            var sfArgs = new object[args.Length + 2];
+            sfArgs[0] = CultureInfo.InvariantCulture; sfArgs[1] = message;
+            Array.Copy(args, 0, sfArgs, 2, args.Length);
+            string result = (string)stringFormat.Invoke(null, sfArgs);
+
+            _inner.Write(prefix + result, LogLevel.Error);
+        }
+
+        public void Error<TArgument>(IFormatProvider formatProvider, string message, TArgument argument)
+        {
+            _inner.Write(prefix + String.Format(formatProvider, message, argument), LogLevel.Error);
+        }
+
+        public void Error<TArgument>(string message, TArgument argument)
+        {
+            _inner.Write(prefix + String.Format(CultureInfo.InvariantCulture, message, argument), LogLevel.Error);
+        }
+
+        public void Error<TArgument1, TArgument2>(IFormatProvider formatProvider, string message, TArgument1 argument1, TArgument2 argument2)
+        {
+            _inner.Write(prefix + String.Format(formatProvider, message, argument1, argument2), LogLevel.Error);
+        }
+
+        public void Error<TArgument1, TArgument2>(string message, TArgument1 argument1, TArgument2 argument2)
+        {
+            _inner.Write(prefix + String.Format(CultureInfo.InvariantCulture, message, argument1, argument2), LogLevel.Error);
+        }
+
+        public void Error<TArgument1, TArgument2, TArgument3>(IFormatProvider formatProvider, string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3)
+        {
+            _inner.Write(prefix + String.Format(formatProvider, message, argument1, argument2, argument3), LogLevel.Error);
+        }
+
+        public void Error<TArgument1, TArgument2, TArgument3>(string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3)
+        {
+            _inner.Write(prefix + String.Format(CultureInfo.InvariantCulture, message, argument1, argument2, argument3), LogLevel.Error);
+        }
+
+
+        public void Fatal<T>(T value)
+        {
+            _inner.Write(prefix + value, LogLevel.Fatal);
+        }
+
+        public void Fatal<T>(IFormatProvider formatProvider, T value)
+        {
+            _inner.Write(String.Format(formatProvider, "{0}{1}", prefix, value), LogLevel.Fatal);
+        }
+
+        public void FatalException(string message, Exception exception)
+        {
+            _inner.Write(String.Format("{0}{1}: {2}", prefix, message, exception), LogLevel.Fatal);
+        }
+
+        public void Fatal(IFormatProvider formatProvider, string message, params object[] args)
+        {
+            var sfArgs = new object[args.Length + 2];
+            sfArgs[0] = formatProvider; sfArgs[1] = message;
+            Array.Copy(args, 0, sfArgs, 2, args.Length);
+            string result = (string)stringFormat.Invoke(null, sfArgs);
+
+            _inner.Write(prefix + result, LogLevel.Fatal);
+        }
+
+        public void Fatal(string message)
+        {
+            _inner.Write(prefix + message, LogLevel.Fatal);
+        }
+
+        public void Fatal(string message, params object[] args)
+        {
+            var sfArgs = new object[args.Length + 2];
+            sfArgs[0] = CultureInfo.InvariantCulture; sfArgs[1] = message;
+            Array.Copy(args, 0, sfArgs, 2, args.Length);
+            string result = (string)stringFormat.Invoke(null, sfArgs);
+
+            _inner.Write(prefix + result, LogLevel.Fatal);
+        }
+
+        public void Fatal<TArgument>(IFormatProvider formatProvider, string message, TArgument argument)
+        {
+            _inner.Write(prefix + String.Format(formatProvider, message, argument), LogLevel.Fatal);
+        }
+
+        public void Fatal<TArgument>(string message, TArgument argument)
+        {
+            _inner.Write(prefix + String.Format(CultureInfo.InvariantCulture, message, argument), LogLevel.Fatal);
+        }
+
+        public void Fatal<TArgument1, TArgument2>(IFormatProvider formatProvider, string message, TArgument1 argument1, TArgument2 argument2)
+        {
+            _inner.Write(prefix + String.Format(formatProvider, message, argument1, argument2), LogLevel.Fatal);
+        }
+
+        public void Fatal<TArgument1, TArgument2>(string message, TArgument1 argument1, TArgument2 argument2)
+        {
+            _inner.Write(prefix + String.Format(CultureInfo.InvariantCulture, message, argument1, argument2), LogLevel.Fatal);
+        }
+
+        public void Fatal<TArgument1, TArgument2, TArgument3>(IFormatProvider formatProvider, string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3)
+        {
+            _inner.Write(prefix + String.Format(formatProvider, message, argument1, argument2, argument3), LogLevel.Fatal);
+        }
+
+        public void Fatal<TArgument1, TArgument2, TArgument3>(string message, TArgument1 argument1, TArgument2 argument2, TArgument3 argument3)
+        {
+            _inner.Write(prefix + String.Format(CultureInfo.InvariantCulture, message, argument1, argument2, argument3), LogLevel.Fatal);
+        }
+
+        public void Write([Localizable(false)] string message, LogLevel logLevel)
+        {
+            _inner.Write(message, logLevel);
+        }
+
+        public LogLevel Level {
+            get { return _inner.Level; }
+            set { _inner.Level = value; }
+        }
+    }
+    #endregion
+
+    #if PORTABLE
+    [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
+    public sealed class LocalizableAttribute : Attribute
+    {
+        // This is a positional argument
+        public LocalizableAttribute(bool isLocalizable)
+        {
+        }
+    }
+    #endif
+}
+
+// vim: tw=120 ts=4 sw=4 et :
\ No newline at end of file
diff --git a/Splat/MemoizingMRUCache.cs b/Splat/MemoizingMRUCache.cs
new file mode 100644
index 000000000..c51f21759
--- /dev/null
+++ b/Splat/MemoizingMRUCache.cs
@@ -0,0 +1,165 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Diagnostics.Contracts;
+
+namespace Splat
+{
+    /// <summary>
+    /// This data structure is a representation of a memoizing cache - i.e. a
+    /// class that will evaluate a function, but keep a cache of recently
+    /// evaluated parameters.
+    ///
+    /// Since this is a memoizing cache, it is important that this function be a
+    /// "pure" function in the mathematical sense - that a key *always* maps to
+    /// a corresponding return value.
+    /// </summary>
+    /// <typeparam name="TParam">The type of the parameter to the calculation function.</typeparam>
+    /// <typeparam name="TVal">The type of the value returned by the calculation
+    /// function.</typeparam>
+    public class MemoizingMRUCache<TParam, TVal>
+    {
+        private readonly Func<TParam, object, TVal> calculationFunction;
+        private readonly Action<TVal> releaseFunction;
+        private readonly int maxCacheSize;
+
+        private LinkedList<TParam> cacheMRUList;
+        private Dictionary<TParam, Tuple<LinkedListNode<TParam>, TVal>> cacheEntries;
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="calculationFunc">The function whose results you want to cache,
+        /// which is provided the key value, and an Tag object that is
+        /// user-defined</param>
+        /// <param name="maxSize">The size of the cache to maintain, after which old
+        /// items will start to be thrown out.</param>
+        /// <param name="onRelease">A function to call when a result gets
+        /// evicted from the cache (i.e. because Invalidate was called or the
+        /// cache is full)</param>
+        public MemoizingMRUCache(Func<TParam, object, TVal> calculationFunc, int maxSize, Action<TVal> onRelease = null)
+        {
+            Contract.Requires(calculationFunc != null);
+            Contract.Requires(maxSize > 0);
+
+            calculationFunction = calculationFunc;
+            releaseFunction = onRelease;
+            maxCacheSize = maxSize;
+            InvalidateAll();
+        }
+
+        public TVal Get(TParam key) { return Get(key, null); }
+
+        /// <summary>
+        /// Evaluates the function provided, returning the cached value if possible
+        /// </summary>
+        /// <param name="key">The value to pass to the calculation function.</param>
+        /// <param name="context">An additional optional user-specific parameter.</param>
+        /// <returns></returns>
+        public TVal Get(TParam key, object context = null)
+        {
+            Contract.Requires(key != null);
+
+            if (cacheEntries.ContainsKey(key)) {
+                var found = cacheEntries[key];
+                cacheMRUList.Remove(found.Item1);
+                cacheMRUList.AddFirst(found.Item1);
+                return found.Item2;
+            }
+
+            var result = calculationFunction(key, context);
+
+            var node = new LinkedListNode<TParam>(key);
+            cacheMRUList.AddFirst(node);
+            cacheEntries[key] = new Tuple<LinkedListNode<TParam>, TVal>(node, result);
+            maintainCache();
+
+            return result;
+        }
+
+        public bool TryGet(TParam key, out TVal result)
+        {
+            Contract.Requires(key != null);
+
+            Tuple<LinkedListNode<TParam>, TVal> output;
+            var ret = cacheEntries.TryGetValue(key, out output);
+            if (ret && output != null) {
+                cacheMRUList.Remove(output.Item1);
+                cacheMRUList.AddFirst(output.Item1);
+                result = output.Item2;
+            } else {
+                result = default(TVal);
+            }
+            return ret;
+        }
+
+        /// <summary>
+        /// Ensure that the next time this key is queried, the calculation
+        /// function will be called.
+        /// </summary>
+        public void Invalidate(TParam key)
+        {
+            Contract.Requires(key != null);
+
+            if (!cacheEntries.ContainsKey(key))
+                return;
+
+            var to_remove = cacheEntries[key];
+            if (releaseFunction != null)
+                releaseFunction(to_remove.Item2);
+
+            cacheMRUList.Remove(to_remove.Item1);
+            cacheEntries.Remove(key);
+        }
+
+        /// <summary>
+        /// Invalidate all items in the cache
+        /// </summary>
+        public void InvalidateAll()
+        {
+            if (releaseFunction == null || cacheEntries == null) {
+                cacheMRUList = new LinkedList<TParam>();
+                cacheEntries = new Dictionary<TParam, Tuple<LinkedListNode<TParam>, TVal>>();
+                return;
+            }
+
+            if (cacheEntries.Count == 0)
+                return;
+
+            /*             We have to remove them one-by-one to call the release function
+             * We ToArray() this so we don't get a "modifying collection while
+             * enumerating" exception. */
+            foreach (var v in cacheEntries.Keys.ToArray()) { Invalidate(v); }
+        }
+
+        /// <summary>
+        /// Returns all values currently in the cache
+        /// </summary>
+        /// <returns></returns>
+        public IEnumerable<TVal> CachedValues()
+        {
+            return cacheEntries.Select(x => x.Value.Item2);
+        }
+
+        void maintainCache()
+        {
+            while (cacheMRUList.Count > maxCacheSize) {
+                var to_remove = cacheMRUList.Last.Value;
+                if (releaseFunction != null)
+                    releaseFunction(cacheEntries[to_remove].Item2);
+
+                cacheEntries.Remove(cacheMRUList.Last.Value);
+                cacheMRUList.RemoveLast();
+            }
+        }
+
+        [ContractInvariantMethod]
+        void Invariants()
+        {
+            Contract.Invariant(cacheEntries.Count == cacheMRUList.Count);
+            Contract.Invariant(cacheEntries.Count <= maxCacheSize);
+        }
+    }
+}
+
+// vim: tw=120 ts=4 sw=4 et :
\ No newline at end of file
diff --git a/Splat/Splat-Net45.csproj b/Splat/Splat-Net45.csproj
index bfb558d31..766335223 100644
--- a/Splat/Splat-Net45.csproj
+++ b/Splat/Splat-Net45.csproj
@@ -54,6 +54,8 @@
     <Compile Include="RectangleExtensions.cs" />
     <Compile Include="ReflectionStubs.cs" />
     <Compile Include="ServiceLocation.cs" />
+    <Compile Include="Logging.cs" />
+    <Compile Include="MemoizingMRUCache.cs" />
     <Compile Include="SizeExtensions.cs" />
     <Compile Include="TypeForwardedSystemDrawing.cs" />
     <Compile Include="Xaml\Bitmaps.cs" />
diff --git a/Splat/Splat-NetCore45.csproj b/Splat/Splat-NetCore45.csproj
index 498f98df1..5e8c14b77 100644
--- a/Splat/Splat-NetCore45.csproj
+++ b/Splat/Splat-NetCore45.csproj
@@ -121,6 +121,8 @@
     <Compile Include="RectangleExtensions.cs" />
     <Compile Include="ReflectionStubs.cs" />
     <Compile Include="ServiceLocation.cs" />
+    <Compile Include="Logging.cs" />
+    <Compile Include="MemoizingMRUCache.cs" />
     <Compile Include="SizeExtensions.cs" />
     <Compile Include="WinRT\Bitmaps.cs" />
     <Compile Include="WinRT\Color.cs" />
diff --git a/Splat/Splat-Portable.csproj b/Splat/Splat-Portable.csproj
index f1c72ea23..43a86bbc5 100644
--- a/Splat/Splat-Portable.csproj
+++ b/Splat/Splat-Portable.csproj
@@ -22,15 +22,14 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\Portable-Net45+WinRT45+WP8\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DefineConstants>DEBUG;TRACE;PORTABLE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\Portable-Net45+WinRT45+WP8\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
+    <DefineConstants>TRACE;PORTABLE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
@@ -58,6 +57,8 @@
     <Compile Include="ReflectionStubs.cs" />
     <Compile Include="SizeExtensions.cs" />
     <Compile Include="ServiceLocation.cs" />
+    <Compile Include="Logging.cs" />
+    <Compile Include="MemoizingMRUCache.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/Splat/Splat-monoandroid.csproj b/Splat/Splat-monoandroid.csproj
index a1c64df5b..9c18fd470 100644
--- a/Splat/Splat-monoandroid.csproj
+++ b/Splat/Splat-monoandroid.csproj
@@ -58,6 +58,8 @@
     <Compile Include="ServiceLocation.cs" />
     <Compile Include="SizeExtensions.cs" />
     <Compile Include="TypeForwardedSystemDrawing.cs" />
+    <Compile Include="Logging.cs" />
+    <Compile Include="MemoizingMRUCache.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="Resources\AboutResources.txt" />
diff --git a/Splat/Splat-monomac.csproj b/Splat/Splat-monomac.csproj
index d9125c510..48da0216b 100644
--- a/Splat/Splat-monomac.csproj
+++ b/Splat/Splat-monomac.csproj
@@ -58,6 +58,8 @@
     <Compile Include="ServiceLocation.cs" />
     <Compile Include="SizeExtensions.cs" />
     <Compile Include="TypeForwardedSystemDrawing.cs" />
+    <Compile Include="Logging.cs" />
+    <Compile Include="MemoizingMRUCache.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/Splat/Splat-monotouch.csproj b/Splat/Splat-monotouch.csproj
index c20f592bb..8ef4e67c7 100644
--- a/Splat/Splat-monotouch.csproj
+++ b/Splat/Splat-monotouch.csproj
@@ -59,5 +59,7 @@
     <Compile Include="Colors\KnownColor.cs" />
     <Compile Include="Colors\KnownColors.cs" />
     <Compile Include="ServiceLocation.cs" />
+    <Compile Include="Logging.cs" />
+    <Compile Include="MemoizingMRUCache.cs" />
   </ItemGroup>
 </Project>
diff --git a/Splat/Splat-wp8.csproj b/Splat/Splat-wp8.csproj
index 1faaffd23..e0ce7905d 100644
--- a/Splat/Splat-wp8.csproj
+++ b/Splat/Splat-wp8.csproj
@@ -103,6 +103,8 @@
     <Compile Include="RectangleExtensions.cs" />
     <Compile Include="ReflectionStubs.cs" />
     <Compile Include="ServiceLocation.cs" />
+    <Compile Include="Logging.cs" />
+    <Compile Include="MemoizingMRUCache.cs" />
     <Compile Include="SizeExtensions.cs" />
     <Compile Include="Xaml\Bitmaps.cs" />
     <Compile Include="Xaml\Color.cs" />