diff --git a/src/Humanizer.Tests/AmbientCulture.cs b/src/Humanizer.Tests/AmbientCulture.cs
index 4d857cd8d..c99735618 100644
--- a/src/Humanizer.Tests/AmbientCulture.cs
+++ b/src/Humanizer.Tests/AmbientCulture.cs
@@ -6,11 +6,11 @@ namespace Humanizer.Tests
 {
     public class AmbientCulture : IDisposable
     {
-        private readonly CultureInfo _culture;
+        private readonly CultureInfo _callerCulture;
 
         public AmbientCulture(CultureInfo culture)
         {
-            _culture = Thread.CurrentThread.CurrentUICulture;
+            _callerCulture = Thread.CurrentThread.CurrentUICulture;
             Thread.CurrentThread.CurrentCulture = culture;
             Thread.CurrentThread.CurrentUICulture = culture;
         }
@@ -22,7 +22,8 @@ public AmbientCulture(string cultureName)
 
         public void Dispose()
         {
-            Thread.CurrentThread.CurrentUICulture = _culture;
+            Thread.CurrentThread.CurrentCulture = _callerCulture;
+            Thread.CurrentThread.CurrentUICulture = _callerCulture;
         }
     }
 }
\ No newline at end of file
diff --git a/src/Humanizer.Tests/DateHumanizeTests.cs b/src/Humanizer.Tests/DateHumanizeTests.cs
index 9ff961f2e..9342e47d3 100644
--- a/src/Humanizer.Tests/DateHumanizeTests.cs
+++ b/src/Humanizer.Tests/DateHumanizeTests.cs
@@ -4,33 +4,8 @@
 
 namespace Humanizer.Tests
 {
-    public class DateHumanizeTests
+    public class DateHumanizeTests : DateHumanizeTestsBase
     {
-        static void VerifyWithCurrentDate(string expectedString, TimeSpan deltaFromNow)
-        {
-            var utcNow = DateTime.UtcNow;
-            var localNow = DateTime.Now;
-
-            // feels like the only way to avoid breaking tests because CPU ticks over is to inject the base date
-            Assert.Equal(expectedString, utcNow.Add(deltaFromNow).Humanize(utcDate: true, dateToCompareAgainst: utcNow));
-            Assert.Equal(expectedString, localNow.Add(deltaFromNow).Humanize(utcDate: false, dateToCompareAgainst: localNow));
-        }
-
-        static void VerifyWithDateInjection(string expectedString, TimeSpan deltaFromNow)
-        {
-            var utcNow = new DateTime(2013, 6, 20, 9, 58, 22, DateTimeKind.Utc);
-            var now = new DateTime(2013, 6, 20, 11, 58, 22, DateTimeKind.Local);
-
-            Assert.Equal(expectedString, utcNow.Add(deltaFromNow).Humanize(dateToCompareAgainst: utcNow));
-            Assert.Equal(expectedString, now.Add(deltaFromNow).Humanize(false, now));
-        }
-
-        static void Verify(string expectedString, TimeSpan deltaFromNow)
-        {
-            VerifyWithCurrentDate(expectedString, deltaFromNow);
-            VerifyWithDateInjection(expectedString, deltaFromNow);
-        }
-
         [Fact]
         public void OneSecondFromNow()
         {
diff --git a/src/Humanizer.Tests/DateHumanizeTestsBase.cs b/src/Humanizer.Tests/DateHumanizeTestsBase.cs
new file mode 100644
index 000000000..706de5b7c
--- /dev/null
+++ b/src/Humanizer.Tests/DateHumanizeTestsBase.cs
@@ -0,0 +1,43 @@
+using System;
+using Humanizer.Configuration;
+using Humanizer.DistanceOfTimeCalculators;
+using Xunit;
+
+namespace Humanizer.Tests
+{
+    public abstract class DateHumanizeTestsBase : IDisposable
+    {
+        private readonly IDistanceOfTimeInWords previousCalculator;
+
+        protected DateHumanizeTestsBase()
+        {
+            previousCalculator = Configurator.DistanceOfTimeInWords;
+        }
+
+        public void Dispose()
+        {
+            Configurator.DistanceOfTimeInWords = previousCalculator;
+        }
+
+        protected static void Verify(string expectedString, TimeSpan deltaFromNow)
+        {
+            VerifyWithCurrentDate(expectedString, deltaFromNow);
+            VerifyWithDateInjection(expectedString, deltaFromNow);
+        }
+
+        private static void VerifyWithCurrentDate(string expectedString, TimeSpan deltaFromNow)
+        {
+            Assert.Equal(expectedString, DateTime.UtcNow.Add(deltaFromNow).Humanize());
+            Assert.Equal(expectedString, DateTime.Now.Add(deltaFromNow).Humanize(false));
+        }
+
+        private static void VerifyWithDateInjection(string expectedString, TimeSpan deltaFromNow)
+        {
+            var utcNow = new DateTime(2013, 6, 20, 9, 58, 22, DateTimeKind.Utc);
+            var now = new DateTime(2013, 6, 20, 11, 58, 22, DateTimeKind.Local);
+
+            Assert.Equal(expectedString, utcNow.Add(deltaFromNow).Humanize(dateToCompareAgainst: utcNow));
+            Assert.Equal(expectedString, now.Add(deltaFromNow).Humanize(false, now));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Humanizer.Tests/DistanceOfTimeCalculators/DefaultPrecisionBoundaries.cs b/src/Humanizer.Tests/DistanceOfTimeCalculators/DefaultPrecisionBoundaries.cs
new file mode 100644
index 000000000..c23f033d6
--- /dev/null
+++ b/src/Humanizer.Tests/DistanceOfTimeCalculators/DefaultPrecisionBoundaries.cs
@@ -0,0 +1,99 @@
+using System;
+using Humanizer.DistanceOfTimeCalculators;
+using Humanizer.Localisation;
+using Xunit;
+
+namespace Humanizer.Tests.DistanceOfTimeCalculators
+{
+    public class DefaultPrecisionBoundaries
+    {
+        readonly PrecisionBasedDistanceOfTime _calculator = new PrecisionBasedDistanceOfTime();
+
+        private readonly string justNow = GetJustNow();
+        private readonly string secondFromNow = GetResource(TimeUnit.Second, 1);
+        private readonly string minuteFromNow = GetResource(TimeUnit.Minute, 1);
+        private readonly string hourFromNow = GetResource(TimeUnit.Hour, 1);
+        private readonly string dayFromNow = GetResource(TimeUnit.Day, 1);
+        private readonly string monthFromNow = GetResource(TimeUnit.Month, 1);
+        private readonly string yearFromNow = GetResource(TimeUnit.Year, 1);
+
+        [Fact]
+        public void MillisecondsBorder()
+        {
+            const int millisecondsBoder = 750;
+            VerifyBorder(TimeSpan.FromMilliseconds, millisecondsBoder, justNow, secondFromNow);
+        }
+
+        [Fact]
+        public void FourtyFiveSecondsBorder()
+        {
+            const int secondsBorder = 45;
+            VerifyBorder(TimeSpan.FromSeconds, secondsBorder,
+                GetResource(TimeUnit.Second, secondsBorder - 1),
+                minuteFromNow);
+        }
+
+        [Fact]
+        public void FourtyFiveMinutesBorder()
+        {
+            const int minutesBorder = 45;
+            VerifyBorder(TimeSpan.FromMinutes, minutesBorder,
+                GetResource(TimeUnit.Minute, minutesBorder - 1),
+                hourFromNow);
+        }
+
+        [Fact]
+        public void EighteenHoursBorder()
+        {
+            const int hoursBorder = 18;
+            VerifyBorder(TimeSpan.FromHours, 18,
+                GetResource(TimeUnit.Hour, hoursBorder - 1),
+                dayFromNow);
+        }
+
+        [Fact]
+        public void TwentyThreeDaysBorder()
+        {
+            const int monthBorderInDays = 23;
+            VerifyBorder(TimeSpan.FromDays, monthBorderInDays,
+                GetResource(TimeUnit.Day, monthBorderInDays - 1),
+                monthFromNow);
+        }
+
+        [Fact]
+        public void TwoHundredAndFourDaysBorder()
+        {
+            const int yearBorderInDays = 274;
+            VerifyBorder(TimeSpan.FromDays, yearBorderInDays,
+                GetResource(TimeUnit.Month, 9),
+                yearFromNow);
+        }
+
+        private void VerifyBorder(Func<double, TimeSpan> timeSpanFunc, int border, string beforeBorder, string afterBorder)
+        {
+            var date = DateTime.UtcNow;
+            var date1 = date.Add(timeSpanFunc(border - 1));
+            var date2 = date.Add(timeSpanFunc(border));
+            var date3 = date.Add(timeSpanFunc(border + 1));
+
+            var actual1 = _calculator.Calculate(date1, date);
+            var actual2 = _calculator.Calculate(date2, date);
+            var actual3 = _calculator.Calculate(date3, date);
+
+            Assert.Equal(beforeBorder, actual1);
+            Assert.Equal(afterBorder, actual2);
+            Assert.Equal(afterBorder, actual3);
+        }
+
+        private static string GetResource(TimeUnit timeUnit, int count)
+        {
+            string resourceKey = ResourceKeys.DateHumanize.GetResourceKey(timeUnit, TimeUnitTense.Future, count);
+            return Resources.GetResource(resourceKey).FormatWith(count);
+        }
+
+        private static string GetJustNow()
+        {
+            return Resources.GetResource(ResourceKeys.DateHumanize.Now);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Humanizer.Tests/DistanceOfTimeCalculators/PrecisionBasedDistanceOfTimeTests.cs b/src/Humanizer.Tests/DistanceOfTimeCalculators/PrecisionBasedDistanceOfTimeTests.cs
new file mode 100644
index 000000000..47fd24813
--- /dev/null
+++ b/src/Humanizer.Tests/DistanceOfTimeCalculators/PrecisionBasedDistanceOfTimeTests.cs
@@ -0,0 +1,205 @@
+using System;
+using Humanizer.Configuration;
+using Humanizer.DistanceOfTimeCalculators;
+using Humanizer.Localisation;
+using Xunit;
+
+namespace Humanizer.Tests.DistanceOfTimeCalculators
+{
+    public class PrecisionBasedDistanceOfTimeTests : DateHumanizeTestsBase
+    {
+        public PrecisionBasedDistanceOfTimeTests()
+        {
+            Configurator.DistanceOfTimeInWords = new PrecisionBasedDistanceOfTime();
+        }
+
+        [Fact]
+        public void OneSecondFromNow()
+        {
+            var oneSecondFromNow = Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Second, TimeUnitTense.Future));
+            Verify(oneSecondFromNow, new TimeSpan(0, 0, 0, 1));
+        }
+
+        [Fact]
+        public void SecondsFromNow()
+        {
+            var secsFromNow = string.Format(Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Second, TimeUnitTense.Future, 10)), 10);
+            Verify(secsFromNow, new TimeSpan(0, 0, 0, 10));
+        }
+
+        [Fact]
+        public void OneMinuteFromNow()
+        {
+            var oneMinFromNow = Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Minute, TimeUnitTense.Future));
+            Verify(oneMinFromNow, new TimeSpan(0, 0, 1, 1));
+        }
+
+        [Fact]
+        public void AFewMinutesFromNow()
+        {
+            var minsFromNow = string.Format(Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Minute, TimeUnitTense.Future, 10)), 10);
+            Verify(minsFromNow, new TimeSpan(0, 0, 10, 0));
+        }
+
+        [Fact]
+        public void AnHourFromNow()
+        {
+            var anHourFromNow = Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Hour, TimeUnitTense.Future));
+            Verify(anHourFromNow, new TimeSpan(0, 1, 10, 0));
+        }
+
+        [Fact]
+        public void HoursFromNow()
+        {
+            var hoursFromNow = string.Format(Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Hour, TimeUnitTense.Future, 10)), 10);
+            Verify(hoursFromNow, new TimeSpan(0, 10, 0, 0));
+        }
+
+        [Fact]
+        public void Tomorrow()
+        {
+            var tomorrow = Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Day, TimeUnitTense.Future));
+            Verify(tomorrow, new TimeSpan(1, 10, 0, 0));
+        }
+
+        [Fact]
+        public void AFewDaysFromNow()
+        {
+            var daysFromNow = string.Format(Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Day, TimeUnitTense.Future, 10)), 10);
+            Verify(daysFromNow, new TimeSpan(10, 1, 0, 0));
+        }
+
+        [Fact]
+        public void OneMonthFromNow()
+        {
+            var oneMonthFromNow = Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Month, TimeUnitTense.Future));
+            Verify(oneMonthFromNow, new TimeSpan(31, 1, 0, 0));
+        }
+
+        [Fact]
+        public void AFewMonthsFromNow()
+        {
+            var monthsFromNow = string.Format(Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Month, TimeUnitTense.Future, 2)), 2);
+            Verify(monthsFromNow, new TimeSpan(62, 1, 0, 0));
+        }
+
+        [Fact]
+        public void OneYearFromNowIsNotAccureate()
+        {
+            var aYearFromNow = Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Year, TimeUnitTense.Future));
+            Verify(aYearFromNow, new TimeSpan(360, 0, 0, 0));
+        }
+
+        [Fact]
+        public void OneYearFromNow()
+        {
+            var aYearFromNow = Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Year, TimeUnitTense.Future));
+            Verify(aYearFromNow, new TimeSpan(400, 0, 0, 0));
+        }
+
+        [Fact]
+        public void FewYearsFromNow()
+        {
+            var fewYearsFromNow = string.Format(Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Year, TimeUnitTense.Future, 2)), 2);
+            Verify(fewYearsFromNow, new TimeSpan(900, 0, 0, 0));
+        }
+
+        [Fact]
+        public void JustNow()
+        {
+            var now = Resources.GetResource(ResourceKeys.DateHumanize.Now);
+            Verify(now, new TimeSpan(0, 0, 0, 0));
+        }
+
+        [Fact]
+        public void OneSecondAgo()
+        {
+            var aSecAgo = Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Second, TimeUnitTense.Past));
+            Verify(aSecAgo, new TimeSpan(0, 0, 0, -1));
+        }
+
+        [Fact]
+        public void SecondsAgo()
+        {
+            var secondsAgo = string.Format(Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Second, TimeUnitTense.Past, 10)), 10);
+            Verify(secondsAgo, new TimeSpan(0, 0, 0, -10));
+        }
+
+        [Fact]
+        public void OneMinuteAgo()
+        {
+            var aMinuteAgo = Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Minute, TimeUnitTense.Past));
+            Verify(aMinuteAgo, new TimeSpan(0, 0, -1, -10));
+        }
+
+        [Fact]
+        public void AFewMinutesAgo()
+        {
+            var minsAgo = string.Format(Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Minute, TimeUnitTense.Past, 10)), 10);
+            Verify(minsAgo, new TimeSpan(0, 0, -10, 0));
+        }
+
+        [Fact]
+        public void AnHourAgo()
+        {
+            var anHourAgo = Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Hour, TimeUnitTense.Past));
+            Verify(anHourAgo, new TimeSpan(0, -1, -10, 0));
+        }
+
+        [Fact]
+        public void HoursAgo()
+        {
+            var hoursAgo = string.Format(Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Hour, TimeUnitTense.Past, 10)), 10);
+            Verify(hoursAgo, new TimeSpan(0, -10, 0, 0));
+        }
+
+        [Fact]
+        public void Yesterday()
+        {
+            var yesterday = Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Day, TimeUnitTense.Past));
+            Verify(yesterday, new TimeSpan(-1, -10, 0, 0));
+        }
+
+        [Fact]
+        public void AFewDaysAgo()
+        {
+            var fewDaysAgo = string.Format(Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Day, TimeUnitTense.Past, 10)), 10);
+            Verify(fewDaysAgo, new TimeSpan(-10, -1, 0, 0));
+        }
+
+        [Fact]
+        public void OneMonthAgo()
+        {
+            var aMonthAgo = Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Month, TimeUnitTense.Past));
+            Verify(aMonthAgo, new TimeSpan(-31, -1, 0, 0));
+        }
+
+        [Fact]
+        public void AFewMonthsAgo()
+        {
+            var monthsAgo = string.Format(Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Month, TimeUnitTense.Past, 2)), 2);
+            Verify(monthsAgo, new TimeSpan(-62, -1, 0, 0));
+        }
+
+        [Fact]
+        public void OneYearAgoIsNotAccureate()
+        {
+            var aYearAgo = Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Year, TimeUnitTense.Past));
+            Verify(aYearAgo, new TimeSpan(-360, 0, 0, 0));
+        }
+
+        [Fact]
+        public void OneYearAgo()
+        {
+            var aYearAgo = Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Year, TimeUnitTense.Past));
+            Verify(aYearAgo, new TimeSpan(-400, 0, 0, 0));
+        }
+
+        [Fact]
+        public void FewYearsAgo()
+        {
+            var yearsAgo = string.Format(Resources.GetResource(ResourceKeys.DateHumanize.GetResourceKey(TimeUnit.Year, TimeUnitTense.Past, 2)), 2);
+            Verify(yearsAgo, new TimeSpan(-900, 0, 0, 0));
+        }
+    }
+}
diff --git a/src/Humanizer.Tests/Humanizer.Tests.csproj b/src/Humanizer.Tests/Humanizer.Tests.csproj
index 7d6f04165..d281dc9ea 100644
--- a/src/Humanizer.Tests/Humanizer.Tests.csproj
+++ b/src/Humanizer.Tests/Humanizer.Tests.csproj
@@ -75,6 +75,9 @@
     <Compile Include="Bytes\ParsingTests.cs" />
     <Compile Include="Bytes\ToStringTests.cs" />
     <Compile Include="CasingTests.cs" />
+    <Compile Include="DateHumanizeTestsBase.cs" />
+    <Compile Include="DistanceOfTimeCalculators\DefaultPrecisionBoundaries.cs" />
+    <Compile Include="DistanceOfTimeCalculators\PrecisionBasedDistanceOfTimeTests.cs" />
     <Compile Include="Localisation\ar\DateHumanizeTests.cs" />
     <Compile Include="Localisation\ar\NumberToWordsTests.cs" />
     <Compile Include="Localisation\ar\TimeSpanHumanizeTests.cs" />
@@ -130,6 +133,7 @@
   <ItemGroup>
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </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/Humanizer/Configuration/Configurator.cs b/src/Humanizer/Configuration/Configurator.cs
index 463f8e889..564e5de98 100644
--- a/src/Humanizer/Configuration/Configurator.cs
+++ b/src/Humanizer/Configuration/Configurator.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using Humanizer.DistanceOfTimeCalculators;
 using Humanizer.Localisation;
 
 namespace Humanizer.Configuration
@@ -10,7 +11,12 @@ namespace Humanizer.Configuration
     /// </summary>
     public static class Configurator
     {
-        private static readonly IDictionary<string, Func<IFormatter>> FormatterFactories = 
+        static Configurator()
+        {
+            DistanceOfTimeInWords = new DefaultDistanceOfTime();
+        }
+
+        private static readonly IDictionary<string, Func<IFormatter>> FormatterFactories =
             new Dictionary<string, Func<IFormatter>>(StringComparer.OrdinalIgnoreCase)
         {
             { "ro", () => new RomanianFormatter() },
@@ -33,5 +39,18 @@ public static IFormatter Formatter
                 return new DefaultFormatter();
             }
         }
+
+        /// <summary>
+        /// The distance of time in words (DOTIW) calculator
+        /// </summary>
+        public static IDistanceOfTimeInWords DistanceOfTimeInWords { get; set; }
+
+        /// <summary>
+        /// Default precision used to calculate DOTIW.
+        /// </summary>
+        public static double DefaultPrecision
+        {
+            get { return 0.75; }
+        }
     }
 }
diff --git a/src/Humanizer/DateHumanizeExtensions.cs b/src/Humanizer/DateHumanizeExtensions.cs
index 90d054f6a..9824b3359 100644
--- a/src/Humanizer/DateHumanizeExtensions.cs
+++ b/src/Humanizer/DateHumanizeExtensions.cs
@@ -1,6 +1,5 @@
 using System;
 using Humanizer.Configuration;
-using Humanizer.Localisation;
 
 namespace Humanizer
 {
@@ -9,69 +8,21 @@ namespace Humanizer
     /// </summary>
     public static class DateHumanizeExtensions
     {
-        // http://stackoverflow.com/questions/11/how-do-i-calculate-relative-time
         /// <summary>
         /// Turns the current or provided date into a human readable sentence
         /// </summary>
         /// <param name="input">The date to be humanized</param>
         /// <param name="utcDate">Boolean value indicating whether the date is in UTC or local</param>
         /// <param name="dateToCompareAgainst">Date to compare the input against. If null, current date is used as base</param>
-        /// <returns></returns>
+        /// <returns>distance of time in words</returns>
         public static string Humanize(this DateTime input, bool utcDate = true, DateTime? dateToCompareAgainst = null)
         {
-            if (dateToCompareAgainst == null)
-                dateToCompareAgainst = DateTime.UtcNow;
-
-            var formatter = Configurator.Formatter;
-            var comparisonBase = dateToCompareAgainst.Value;
+            var comparisonBase = dateToCompareAgainst ?? DateTime.UtcNow;
 
             if (!utcDate)
                 comparisonBase = comparisonBase.ToLocalTime();
 
-            if (input <= comparisonBase && comparisonBase.Subtract(input) < TimeSpan.FromMilliseconds(500))
-                return formatter.DateHumanize_Now();
-
-            var timeUnitTense = input > comparisonBase ? TimeUnitTense.Future : TimeUnitTense.Past;
-            var ts = new TimeSpan(Math.Abs(comparisonBase.Ticks - input.Ticks));
-
-            if (ts.TotalSeconds < 60)
-                return formatter.DateHumanize(TimeUnit.Second, timeUnitTense, ts.Seconds);
-
-            if (ts.TotalSeconds < 120)
-                return formatter.DateHumanize(TimeUnit.Minute, timeUnitTense, 1);
-
-            if (ts.TotalMinutes < 45)
-                return formatter.DateHumanize(TimeUnit.Minute, timeUnitTense, ts.Minutes);
-
-            if (ts.TotalMinutes < 90)
-                return formatter.DateHumanize(TimeUnit.Hour, timeUnitTense, 1);
-
-            if (ts.TotalHours < 24)
-                return formatter.DateHumanize(TimeUnit.Hour, timeUnitTense, ts.Hours);
-
-            if (ts.TotalHours < 48)
-                return formatter.DateHumanize(TimeUnit.Day, timeUnitTense, 1);
-
-            if (ts.TotalDays < 28)
-                return formatter.DateHumanize(TimeUnit.Day, timeUnitTense, ts.Days);
-
-            if (ts.TotalDays >= 28 && ts.TotalDays < 30)
-            {
-                if (comparisonBase.Date.AddMonths(timeUnitTense == TimeUnitTense.Future ? 1 : -1) == input.Date)
-                    return formatter.DateHumanize(TimeUnit.Month, timeUnitTense, 1);
-
-                return formatter.DateHumanize(TimeUnit.Day, timeUnitTense, ts.Days);
-            }
-
-            if (ts.TotalDays < 345)
-            {
-                int months = Convert.ToInt32(Math.Floor(ts.TotalDays / 29.5));
-                return formatter.DateHumanize(TimeUnit.Month, timeUnitTense, months);
-            }
-
-            int years = Convert.ToInt32(Math.Floor(ts.TotalDays / 365));
-            if (years == 0) years = 1;
-            return formatter.DateHumanize(TimeUnit.Year, timeUnitTense, years);
+            return Configurator.DistanceOfTimeInWords.Calculate(input, comparisonBase);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Humanizer/DistanceOfTimeCalculators/DefaultDistanceOfTime.cs b/src/Humanizer/DistanceOfTimeCalculators/DefaultDistanceOfTime.cs
new file mode 100644
index 000000000..2184c07c5
--- /dev/null
+++ b/src/Humanizer/DistanceOfTimeCalculators/DefaultDistanceOfTime.cs
@@ -0,0 +1,74 @@
+using System;
+using System.Diagnostics;
+using Humanizer.Configuration;
+using Humanizer.Localisation;
+
+namespace Humanizer.DistanceOfTimeCalculators
+{
+    /// <summary>
+    ///     The default distance of time in works calculator
+    /// </summary>
+    public class DefaultDistanceOfTime : IDistanceOfTimeInWords
+    {
+        // http://stackoverflow.com/questions/11/how-do-i-calculate-relative-time
+        /// <summary>
+        ///     Calculates the distance of time in words between two provided dates
+        /// </summary>
+        /// <param name="date1">date 1</param>
+        /// <param name="date2">date 2</param>
+        /// <returns></returns>
+        public string Calculate(DateTime date1, DateTime date2)
+        {
+            Debug.WriteLine("Using DefaultDistanceOfTime");
+            return Configurator.Formatter.Humanize(Compute(date1, date2));
+        }
+
+        private static DistanceOfTime Compute(DateTime date1, DateTime date2)
+        {
+            var timeUnitTense = date1 > date2 ? TimeUnitTense.Future : TimeUnitTense.Past;
+            var ts = new TimeSpan(Math.Abs(date2.Ticks - date1.Ticks));
+
+            if (ts.TotalMilliseconds < 500)
+                return DistanceOfTime.Create(TimeUnit.Millisecond, timeUnitTense, count: 0);
+
+            if (ts.TotalSeconds < 60)
+                return DistanceOfTime.Create(TimeUnit.Second, timeUnitTense, count: ts.Seconds);
+
+            if (ts.TotalSeconds < 120)
+                return DistanceOfTime.Create(TimeUnit.Minute, timeUnitTense);
+
+            if (ts.TotalMinutes < 45)
+                return DistanceOfTime.Create(TimeUnit.Minute, timeUnitTense, count: ts.Minutes);
+
+            if (ts.TotalMinutes < 90)
+                return DistanceOfTime.Create(TimeUnit.Hour, timeUnitTense);
+
+            if (ts.TotalHours < 24)
+                return DistanceOfTime.Create(TimeUnit.Hour, timeUnitTense, count: ts.Hours);
+
+            if (ts.TotalHours < 48)
+                return DistanceOfTime.Create(TimeUnit.Day, timeUnitTense);
+
+            if (ts.TotalDays < 28)
+                return DistanceOfTime.Create(TimeUnit.Day, timeUnitTense, count: ts.Days);
+
+            if (ts.TotalDays >= 28 && ts.TotalDays < 30)
+            {
+                if (date2.Date.AddMonths(timeUnitTense == TimeUnitTense.Future ? 1 : -1) == date1.Date)
+                    return DistanceOfTime.Create(TimeUnit.Month, timeUnitTense);
+                return DistanceOfTime.Create(TimeUnit.Day, timeUnitTense, count: ts.Days);
+            }
+
+            if (ts.TotalDays < 345)
+            {
+                int months = Convert.ToInt32(Math.Floor(ts.TotalDays / 29.5));
+                return DistanceOfTime.Create(TimeUnit.Month, timeUnitTense, count: months);
+            }
+
+            int years = Convert.ToInt32(Math.Floor(ts.TotalDays / 365));
+            if (years == 0) years = 1;
+
+            return DistanceOfTime.Create(TimeUnit.Year, timeUnitTense, count: years);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Humanizer/DistanceOfTimeCalculators/DistanceOfTime.cs b/src/Humanizer/DistanceOfTimeCalculators/DistanceOfTime.cs
new file mode 100644
index 000000000..97c4b9171
--- /dev/null
+++ b/src/Humanizer/DistanceOfTimeCalculators/DistanceOfTime.cs
@@ -0,0 +1,29 @@
+using Humanizer.Localisation;
+
+namespace Humanizer.DistanceOfTimeCalculators
+{
+    /// <summary>
+    /// This structure is used to express the distance of time calculation
+    /// </summary>
+    public class DistanceOfTime
+    {
+        public int Count { get; set; }
+        public TimeUnit Unit { get; set; }
+        public TimeUnitTense Tense { get; set; }
+        public TimeStructure Structure { get; set; }
+
+        public static DistanceOfTime Create(
+            TimeUnit timeUnit,
+            TimeUnitTense timeUnitTense = TimeUnitTense.Past,
+            TimeStructure timeStructure = TimeStructure.DateTime,
+            int count = 1)
+        {
+            return new DistanceOfTime {
+                Count = count,
+                Structure = timeStructure,
+                Tense = timeUnitTense,
+                Unit = timeUnit
+            };
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Humanizer/DistanceOfTimeCalculators/IDistanceOfTimeInWords.cs b/src/Humanizer/DistanceOfTimeCalculators/IDistanceOfTimeInWords.cs
new file mode 100644
index 000000000..ad8975773
--- /dev/null
+++ b/src/Humanizer/DistanceOfTimeCalculators/IDistanceOfTimeInWords.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace Humanizer.DistanceOfTimeCalculators
+{
+    /// <summary>
+    /// Distance of time in works calculator
+    /// </summary>
+    public interface IDistanceOfTimeInWords
+    {
+        string Calculate(DateTime date1, DateTime date2);
+    }
+}
\ No newline at end of file
diff --git a/src/Humanizer/DistanceOfTimeCalculators/PrecisionBasedDistanceOfTime.cs b/src/Humanizer/DistanceOfTimeCalculators/PrecisionBasedDistanceOfTime.cs
new file mode 100644
index 000000000..0f32ad228
--- /dev/null
+++ b/src/Humanizer/DistanceOfTimeCalculators/PrecisionBasedDistanceOfTime.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Diagnostics;
+using Humanizer.Configuration;
+using Humanizer.Localisation;
+
+namespace Humanizer.DistanceOfTimeCalculators
+{
+    /// <summary>
+    /// Precision-based distance of time in works calculator
+    /// </summary>
+    public class PrecisionBasedDistanceOfTime : IDistanceOfTimeInWords
+    {
+        /// <summary>
+        /// Calculates the DOTIW between two dates.
+        /// </summary>
+        /// <param name="date1">date 1</param>
+        /// <param name="date2">date 2</param>
+        /// <returns>Distance of time in words (DOTIW)</returns>
+        public string Calculate(DateTime date1, DateTime date2)
+        {
+            Debug.WriteLine("Using PrecisionBasedDistanceOfTime");
+
+            var ts = new TimeSpan(Math.Abs(date2.Ticks - date1.Ticks));
+            var timeUnitTense = date1 > date2 ? TimeUnitTense.Future : TimeUnitTense.Past;
+            var distanceOfTime = Compute(ts, timeUnitTense, TimeStructure.DateTime);
+
+            return Configurator.Formatter.Humanize(distanceOfTime);
+        }
+
+        private static DistanceOfTime Compute(TimeSpan ts, TimeUnitTense tense, TimeStructure structure)
+        {
+            //Note: Calculation has magic numbers but it'll be much difficult with variables. I did try :)
+
+            double precision = Configurator.DefaultPrecision;
+
+            int seconds = ts.Seconds, minutes = ts.Minutes, hours = ts.Hours, days = ts.Days;
+            int years = 0, months = 0;
+
+            // start approximate from smaller units towards bigger ones
+            if (ts.Milliseconds >= 999 * precision) seconds += 1;
+            if (seconds >= 59 * precision) minutes += 1;
+            if (minutes >= 59 * precision) hours += 1;
+            if (hours >= 23 * precision) days += 1;
+
+            // month calculation 
+            if (days >= 30 * precision & days <= 31) months = 1;
+            if (days > 31 && days < 365 * precision)
+            {
+                int factor = Convert.ToInt32(Math.Floor((double)days / 30));
+                int maxMonths = Convert.ToInt32(Math.Ceiling((double)days / 30));
+                months = (days >= 30 * (factor + precision)) ? maxMonths : maxMonths - 1;
+            }
+
+            // year calculation
+            if (days >= 365 * precision && days <= 366) years = 1;
+            if (days > 365)
+            {
+                int factor = Convert.ToInt32(Math.Floor((double)days / 365));
+                int maxMonths = Convert.ToInt32(Math.Ceiling((double)days / 365));
+                years = (days >= 365 * (factor + precision)) ? maxMonths : maxMonths - 1;
+            }
+
+            // start computing result from larger units to smaller ones
+            if (years > 0) return DistanceOfTime.Create(TimeUnit.Year, tense, structure, years);
+            if (months > 0) return DistanceOfTime.Create(TimeUnit.Month, tense, structure, months);
+            if (days > 0) return DistanceOfTime.Create(TimeUnit.Day, tense, structure, days);
+            if (hours > 0) return DistanceOfTime.Create(TimeUnit.Hour, tense, structure, hours);
+            if (minutes > 0) return DistanceOfTime.Create(TimeUnit.Minute, tense, structure, minutes);
+            if (seconds > 0) return DistanceOfTime.Create(TimeUnit.Second, tense, structure, seconds);
+            return DistanceOfTime.Create(TimeUnit.Millisecond, tense, structure, 0);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Humanizer/Humanizer.csproj b/src/Humanizer/Humanizer.csproj
index e58bc7aea..787fc78a5 100644
--- a/src/Humanizer/Humanizer.csproj
+++ b/src/Humanizer/Humanizer.csproj
@@ -75,6 +75,11 @@
     <Compile Include="CasingExtensions.cs" />
     <Compile Include="Configuration\Configurator.cs" />
     <Compile Include="DateHumanizeExtensions.cs" />
+    <Compile Include="DistanceOfTimeCalculators\DefaultDistanceOfTime.cs" />
+    <Compile Include="DistanceOfTimeCalculators\DistanceOfTime.cs" />
+    <Compile Include="DistanceOfTimeCalculators\IDistanceOfTimeInWords.cs" />
+    <Compile Include="DistanceOfTimeCalculators\PrecisionBasedDistanceOfTime.cs" />
+    <Compile Include="Localisation\TimeStructure.cs" />
     <Compile Include="Localisation\TimeUnitTense.cs" />
     <Compile Include="TimeSpanHumanizeExtensions.cs" />
     <Compile Include="FluentDate\In.SomeTimeFrom.cs">
diff --git a/src/Humanizer/Localisation/DefaultFormatter.cs b/src/Humanizer/Localisation/DefaultFormatter.cs
index c1a8a949e..4a274d579 100644
--- a/src/Humanizer/Localisation/DefaultFormatter.cs
+++ b/src/Humanizer/Localisation/DefaultFormatter.cs
@@ -1,4 +1,6 @@
-namespace Humanizer.Localisation
+using Humanizer.DistanceOfTimeCalculators;
+
+namespace Humanizer.Localisation
 {
     /// <summary>
     /// Default implementation of IFormatter interface.
@@ -33,6 +35,13 @@ public virtual string TimeSpanHumanize(TimeUnit timeUnit, int unit)
             return GetResourceForTimeSpan(timeUnit, unit);
         }
 
+        public virtual string Humanize(DistanceOfTime distanceOfTime)
+        {
+            return distanceOfTime.Structure == TimeStructure.DateTime
+                ? DateHumanize(distanceOfTime.Unit, distanceOfTime.Tense, distanceOfTime.Count)
+                : TimeSpanHumanize(distanceOfTime.Unit, distanceOfTime.Count);
+        }
+
         private string GetResourceForDate(TimeUnit unit, TimeUnitTense timeUnitTense, int count)
         {
             string resourceKey = ResourceKeys.DateHumanize.GetResourceKey(unit, timeUnitTense: timeUnitTense, count: count);
diff --git a/src/Humanizer/Localisation/IFormatter.cs b/src/Humanizer/Localisation/IFormatter.cs
index d280fdc36..999c93c1c 100644
--- a/src/Humanizer/Localisation/IFormatter.cs
+++ b/src/Humanizer/Localisation/IFormatter.cs
@@ -1,4 +1,6 @@
-namespace Humanizer.Localisation
+using Humanizer.DistanceOfTimeCalculators;
+
+namespace Humanizer.Localisation
 {
     /// <summary>
     /// Implement this interface if your language has complex rules around dealing with numbers. 
@@ -12,5 +14,7 @@ public interface IFormatter
         
         string TimeSpanHumanize_Zero();
         string TimeSpanHumanize(TimeUnit timeUnit, int unit);
+
+        string Humanize(DistanceOfTime timeUnit);
     }
 }
diff --git a/src/Humanizer/Localisation/TimeStructure.cs b/src/Humanizer/Localisation/TimeStructure.cs
new file mode 100644
index 000000000..c824e1be6
--- /dev/null
+++ b/src/Humanizer/Localisation/TimeStructure.cs
@@ -0,0 +1,8 @@
+namespace Humanizer.Localisation
+{
+    public enum TimeStructure
+    {
+        DateTime,
+        TimeSpan
+    }
+}
\ No newline at end of file