diff --git a/osu-framework b/osu-framework
index 8c79c94aa7..036b124eb2 160000
--- a/osu-framework
+++ b/osu-framework
@@ -1 +1 @@
-Subproject commit 8c79c94aa71711cf9c8bb169f684df2e35596f9d
+Subproject commit 036b124eb2387dde29af56e06391c42063ec85e2
diff --git a/osu.Desktop.VisualTests/Tests/TestCaseGamefield.cs b/osu.Desktop.VisualTests/Tests/TestCaseGamefield.cs
index 767fb0dffb..aff2903078 100644
--- a/osu.Desktop.VisualTests/Tests/TestCaseGamefield.cs
+++ b/osu.Desktop.VisualTests/Tests/TestCaseGamefield.cs
@@ -48,6 +48,7 @@ namespace osu.Desktop.VisualTests.Tests
                 HitObjects = objects,
                 BeatmapInfo = new BeatmapInfo
                 {
+                    BaseDifficulty = new BaseDifficulty(),
                     Metadata = new BeatmapMetadata
                     {
                         Artist = @"Unknown",
diff --git a/osu.Desktop.VisualTests/Tests/TestCaseHitObjects.cs b/osu.Desktop.VisualTests/Tests/TestCaseHitObjects.cs
index b5c7ddeb27..37e223d7a8 100644
--- a/osu.Desktop.VisualTests/Tests/TestCaseHitObjects.cs
+++ b/osu.Desktop.VisualTests/Tests/TestCaseHitObjects.cs
@@ -1,20 +1,21 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System.Collections.Generic;
-using osu.Framework.Screens.Testing;
-using osu.Framework.Graphics;
-using osu.Framework.Timing;
 using OpenTK;
+using OpenTK.Graphics;
 using osu.Framework.Configuration;
-using osu.Game.Modes.Objects.Drawables;
-using osu.Game.Modes.Osu.Objects;
-using osu.Game.Modes.Osu.Objects.Drawables;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Modes.Osu.Judgements;
-using OpenTK.Graphics;
+using osu.Framework.Screens.Testing;
+using osu.Framework.Timing;
+using osu.Game.Modes.Objects;
+using osu.Game.Modes.Objects.Drawables;
+using osu.Game.Modes.Osu.Objects;
+using osu.Game.Modes.Osu.Objects.Drawables;
+using System.Collections.Generic;
 
 namespace osu.Desktop.VisualTests.Tests
 {
@@ -61,12 +62,15 @@ namespace osu.Desktop.VisualTests.Tests
                     add(new DrawableSlider(new Slider
                     {
                         StartTime = framedClock.CurrentTime + 600,
-                        ControlPoints = new List<Vector2>
+                        CurveObject = new CurvedHitObject
                         {
-                            new Vector2(-200, 0),
-                            new Vector2(400, 0),
+                            ControlPoints = new List<Vector2>
+                            {
+                                new Vector2(-200, 0),
+                                new Vector2(400, 0),
+                            },
+                            Distance = 400
                         },
-                        Length = 400,
                         Position = new Vector2(-200, 0),
                         Velocity = 1,
                         TickDistance = 100,
@@ -76,7 +80,7 @@ namespace osu.Desktop.VisualTests.Tests
                     add(new DrawableSpinner(new Spinner
                     {
                         StartTime = framedClock.CurrentTime + 600,
-                        Length = 1000,
+                        EndTime = framedClock.CurrentTime + 1600,
                         Position = new Vector2(0, 0),
                     }));
                     break;
diff --git a/osu.Desktop.VisualTests/Tests/TestCasePlayer.cs b/osu.Desktop.VisualTests/Tests/TestCasePlayer.cs
index ee58d934a4..0d32532f09 100644
--- a/osu.Desktop.VisualTests/Tests/TestCasePlayer.cs
+++ b/osu.Desktop.VisualTests/Tests/TestCasePlayer.cs
@@ -6,7 +6,6 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Screens.Testing;
 using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.Formats;
 using OpenTK;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Beatmaps.IO;
@@ -61,13 +60,12 @@ namespace osu.Desktop.VisualTests.Tests
                     time += 500;
                 }
 
-                var decoder = new ConstructableBeatmapDecoder();
-
                 Beatmap b = new Beatmap
                 {
                     HitObjects = objects,
                     BeatmapInfo = new BeatmapInfo
                     {
+                        BaseDifficulty = new BaseDifficulty(),
                         Metadata = new BeatmapMetadata
                         {
                             Artist = @"Unknown",
@@ -77,8 +75,6 @@ namespace osu.Desktop.VisualTests.Tests
                     }
                 };
 
-                decoder.Process(b);
-
                 beatmap = new TestWorkingBeatmap(b);
             }
 
diff --git a/osu.Desktop.VisualTests/packages.config b/osu.Desktop.VisualTests/packages.config
index c3f267ac89..5a30c50600 100644
--- a/osu.Desktop.VisualTests/packages.config
+++ b/osu.Desktop.VisualTests/packages.config
@@ -1,5 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
-
 <!--
 Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
diff --git a/osu.Game.Modes.Catch/Beatmaps/CatchBeatmapProcessor.cs b/osu.Game.Modes.Catch/Beatmaps/CatchBeatmapProcessor.cs
new file mode 100644
index 0000000000..ef585e2675
--- /dev/null
+++ b/osu.Game.Modes.Catch/Beatmaps/CatchBeatmapProcessor.cs
@@ -0,0 +1,19 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Beatmaps;
+using osu.Game.Modes.Catch.Objects;
+
+namespace osu.Game.Modes.Catch.Beatmaps
+{
+    internal class CatchBeatmapProcessor : IBeatmapProcessor<CatchBaseHit>
+    {
+        public void SetDefaults(CatchBaseHit hitObject, Beatmap<CatchBaseHit> beatmap)
+        {
+        }
+
+        public void PostProcess(Beatmap<CatchBaseHit> beatmap)
+        {
+        }
+    }
+}
diff --git a/osu.Game.Modes.Catch/CatchRuleset.cs b/osu.Game.Modes.Catch/CatchRuleset.cs
index ecef1ea42c..cb695aaabe 100644
--- a/osu.Game.Modes.Catch/CatchRuleset.cs
+++ b/osu.Game.Modes.Catch/CatchRuleset.cs
@@ -7,7 +7,6 @@ using osu.Game.Graphics;
 using osu.Game.Modes.Catch.Mods;
 using osu.Game.Modes.Catch.UI;
 using osu.Game.Modes.Mods;
-using osu.Game.Modes.Objects;
 using osu.Game.Modes.UI;
 using osu.Game.Screens.Play;
 using System.Collections.Generic;
@@ -90,8 +89,6 @@ namespace osu.Game.Modes.Catch
 
         public override ScoreProcessor CreateScoreProcessor(int hitObjectCount = 0) => null;
 
-        public override HitObjectParser CreateHitObjectParser() => new NullHitObjectParser();
-
         public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap) => new CatchDifficultyCalculator(beatmap);
     }
 }
diff --git a/osu.Game.Modes.Catch/Objects/CatchBaseHit.cs b/osu.Game.Modes.Catch/Objects/CatchBaseHit.cs
index 79769710a7..ee66894d31 100644
--- a/osu.Game.Modes.Catch/Objects/CatchBaseHit.cs
+++ b/osu.Game.Modes.Catch/Objects/CatchBaseHit.cs
@@ -7,6 +7,6 @@ namespace osu.Game.Modes.Catch.Objects
 {
     public abstract class CatchBaseHit : HitObject
     {
-        public float Position;
+        public float Position { get; set; }
     }
 }
diff --git a/osu.Game.Modes.Catch/Objects/Drawable/DrawableFruit.cs b/osu.Game.Modes.Catch/Objects/Drawable/DrawableFruit.cs
index 542bdeb3c3..5d19d902b1 100644
--- a/osu.Game.Modes.Catch/Objects/Drawable/DrawableFruit.cs
+++ b/osu.Game.Modes.Catch/Objects/Drawable/DrawableFruit.cs
@@ -29,8 +29,10 @@ namespace osu.Game.Modes.Catch.Objects.Drawable
         {
             Texture = textures.Get(@"Menu/logo");
 
+            double duration = 0;
+
             Transforms.Add(new TransformPosition { StartTime = h.StartTime - 200, EndTime = h.StartTime, StartValue = new Vector2(h.Position, -0.1f), EndValue = new Vector2(h.Position, 0.9f) });
-            Transforms.Add(new TransformAlpha { StartTime = h.StartTime + h.Duration + 200, EndTime = h.StartTime + h.Duration + 400, StartValue = 1, EndValue = 0 });
+            Transforms.Add(new TransformAlpha { StartTime = h.StartTime + duration + 200, EndTime = h.StartTime + duration + 400, StartValue = 1, EndValue = 0 });
             Expire(true);
         }
     }
diff --git a/osu.Game.Modes.Catch/UI/CatchHitRenderer.cs b/osu.Game.Modes.Catch/UI/CatchHitRenderer.cs
index b537ec6e8a..e68cf756c2 100644
--- a/osu.Game.Modes.Catch/UI/CatchHitRenderer.cs
+++ b/osu.Game.Modes.Catch/UI/CatchHitRenderer.cs
@@ -19,8 +19,10 @@ namespace osu.Game.Modes.Catch.UI
 
         protected override IBeatmapConverter<CatchBaseHit> CreateBeatmapConverter() => new CatchBeatmapConverter();
 
+        protected override IBeatmapProcessor<CatchBaseHit> CreateBeatmapProcessor() => new CatchBeatmapProcessor();
         protected override Playfield<CatchBaseHit, CatchJudgementInfo> CreatePlayfield() => new CatchPlayfield();
 
+
         protected override DrawableHitObject<CatchBaseHit, CatchJudgementInfo> GetVisualRepresentation(CatchBaseHit h) => null;// new DrawableFruit(h);
     }
 }
diff --git a/osu.Game.Modes.Catch/osu.Game.Modes.Catch.csproj b/osu.Game.Modes.Catch/osu.Game.Modes.Catch.csproj
index d7c3a9f828..e6861b54ef 100644
--- a/osu.Game.Modes.Catch/osu.Game.Modes.Catch.csproj
+++ b/osu.Game.Modes.Catch/osu.Game.Modes.Catch.csproj
@@ -48,6 +48,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Beatmaps\CatchBeatmapConverter.cs" />
+    <Compile Include="Beatmaps\CatchBeatmapProcessor.cs" />
     <Compile Include="CatchDifficultyCalculator.cs" />
     <Compile Include="Judgements\CatchJudgementInfo.cs" />
     <Compile Include="Objects\CatchBaseHit.cs" />
diff --git a/osu.Game.Modes.Mania/Beatmaps/ManiaBeatmapProcessor.cs b/osu.Game.Modes.Mania/Beatmaps/ManiaBeatmapProcessor.cs
new file mode 100644
index 0000000000..5e85a8f864
--- /dev/null
+++ b/osu.Game.Modes.Mania/Beatmaps/ManiaBeatmapProcessor.cs
@@ -0,0 +1,19 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Beatmaps;
+using osu.Game.Modes.Mania.Objects;
+
+namespace osu.Game.Modes.Mania.Beatmaps
+{
+    internal class ManiaBeatmapProcessor : IBeatmapProcessor<ManiaBaseHit>
+    {
+        public void SetDefaults(ManiaBaseHit hitObject, Beatmap<ManiaBaseHit> beatmap)
+        {
+        }
+
+        public void PostProcess(Beatmap<ManiaBaseHit> beatmap)
+        {
+        }
+    }
+}
diff --git a/osu.Game.Modes.Mania/ManiaRuleset.cs b/osu.Game.Modes.Mania/ManiaRuleset.cs
index e1e954fb45..5b12e621d2 100644
--- a/osu.Game.Modes.Mania/ManiaRuleset.cs
+++ b/osu.Game.Modes.Mania/ManiaRuleset.cs
@@ -6,7 +6,6 @@ using osu.Game.Graphics;
 using osu.Game.Modes.Mania.Mods;
 using osu.Game.Modes.Mania.UI;
 using osu.Game.Modes.Mods;
-using osu.Game.Modes.Objects;
 using osu.Game.Modes.UI;
 using osu.Game.Screens.Play;
 using System.Collections.Generic;
@@ -105,8 +104,6 @@ namespace osu.Game.Modes.Mania
 
         public override ScoreProcessor CreateScoreProcessor(int hitObjectCount = 0) => null;
 
-        public override HitObjectParser CreateHitObjectParser() => new NullHitObjectParser();
-
         public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap) => new ManiaDifficultyCalculator(beatmap);
     }
 }
diff --git a/osu.Game.Modes.Mania/Objects/Drawable/DrawableNote.cs b/osu.Game.Modes.Mania/Objects/Drawable/DrawableNote.cs
index 92e73191a4..9fd39e2f45 100644
--- a/osu.Game.Modes.Mania/Objects/Drawable/DrawableNote.cs
+++ b/osu.Game.Modes.Mania/Objects/Drawable/DrawableNote.cs
@@ -26,8 +26,10 @@ namespace osu.Game.Modes.Mania.Objects.Drawable
         {
             Texture = textures.Get(@"Menu/logo");
 
+            double duration = 0;
+
             Transforms.Add(new TransformPositionY { StartTime = note.StartTime - 200, EndTime = note.StartTime, StartValue = -0.1f, EndValue = 0.9f });
-            Transforms.Add(new TransformAlpha { StartTime = note.StartTime + note.Duration + 200, EndTime = note.StartTime + note.Duration + 400, StartValue = 1, EndValue = 0 });
+            Transforms.Add(new TransformAlpha { StartTime = note.StartTime + duration + 200, EndTime = note.StartTime + duration + 400, StartValue = 1, EndValue = 0 });
             Expire(true);
         }
     }
diff --git a/osu.Game.Modes.Mania/UI/ManiaHitRenderer.cs b/osu.Game.Modes.Mania/UI/ManiaHitRenderer.cs
index 52b35d5032..60c9d4376e 100644
--- a/osu.Game.Modes.Mania/UI/ManiaHitRenderer.cs
+++ b/osu.Game.Modes.Mania/UI/ManiaHitRenderer.cs
@@ -22,8 +22,10 @@ namespace osu.Game.Modes.Mania.UI
 
         protected override IBeatmapConverter<ManiaBaseHit> CreateBeatmapConverter() => new ManiaBeatmapConverter();
 
+        protected override IBeatmapProcessor<ManiaBaseHit> CreateBeatmapProcessor() => new ManiaBeatmapProcessor();
         protected override Playfield<ManiaBaseHit, ManiaJudgementInfo> CreatePlayfield() => new ManiaPlayfield(columns);
 
+
         protected override DrawableHitObject<ManiaBaseHit, ManiaJudgementInfo> GetVisualRepresentation(ManiaBaseHit h)
         {
             return null;
diff --git a/osu.Game.Modes.Mania/osu.Game.Modes.Mania.csproj b/osu.Game.Modes.Mania/osu.Game.Modes.Mania.csproj
index d1b9e2971f..4a5c081e8b 100644
--- a/osu.Game.Modes.Mania/osu.Game.Modes.Mania.csproj
+++ b/osu.Game.Modes.Mania/osu.Game.Modes.Mania.csproj
@@ -48,6 +48,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Beatmaps\ManiaBeatmapConverter.cs" />
+    <Compile Include="Beatmaps\ManiaBeatmapProcessor.cs" />
     <Compile Include="Judgements\ManiaJudgementInfo.cs" />
     <Compile Include="ManiaDifficultyCalculator.cs" />
     <Compile Include="Objects\Drawable\DrawableNote.cs" />
diff --git a/osu.Game.Modes.Osu/Beatmaps/OsuBeatmapConverter.cs b/osu.Game.Modes.Osu/Beatmaps/OsuBeatmapConverter.cs
index df293448b3..ea5143b08a 100644
--- a/osu.Game.Modes.Osu/Beatmaps/OsuBeatmapConverter.cs
+++ b/osu.Game.Modes.Osu/Beatmaps/OsuBeatmapConverter.cs
@@ -7,6 +7,8 @@ using osu.Game.Modes.Objects;
 using osu.Game.Modes.Osu.Objects;
 using osu.Game.Modes.Osu.Objects.Drawables;
 using System.Collections.Generic;
+using osu.Game.Modes.Objects.Types;
+using System.Linq;
 
 namespace osu.Game.Modes.Osu.Beatmaps
 {
@@ -16,28 +18,64 @@ namespace osu.Game.Modes.Osu.Beatmaps
         {
             return new Beatmap<OsuHitObject>(original)
             {
-                HitObjects = convertHitObject(original.HitObjects, original.BeatmapInfo?.StackLeniency ?? 0.7f)
+                HitObjects = convertHitObjects(original.HitObjects, original.BeatmapInfo?.StackLeniency ?? 0.7f)
             };
         }
 
-        private List<OsuHitObject> convertHitObject(List<HitObject> hitObjects, float stackLeniency)
+        private List<OsuHitObject> convertHitObjects(List<HitObject> hitObjects, float stackLeniency)
         {
-            List<OsuHitObject> converted = new List<OsuHitObject>();
-
-            int combo = 0;
-            foreach (HitObject h in hitObjects)
-            {
-                if (h.NewCombo) combo = 0;
-
-                h.ComboIndex = combo++;
-                converted.Add(h as OsuHitObject);
-            }
+            List<OsuHitObject> converted = hitObjects.Select(convertHitObject).ToList();
 
             updateStacking(converted, stackLeniency);
 
             return converted;
         }
 
+        private OsuHitObject convertHitObject(HitObject original)
+        {
+            IHasCurve curveData = original as IHasCurve;
+            IHasEndTime endTimeData = original as IHasEndTime;
+            IHasPosition positionData = original as IHasPosition;
+            IHasCombo comboData = original as IHasCombo;
+
+            if (curveData != null)
+            {
+                return new Slider
+                {
+                    StartTime = original.StartTime,
+                    Sample = original.Sample,
+
+                    CurveObject = curveData,
+
+                    Position = positionData?.Position ?? Vector2.Zero,
+
+                    NewCombo = comboData?.NewCombo ?? false
+                };
+            }
+
+            if (endTimeData != null)
+            {
+                return new Spinner
+                {
+                    StartTime = original.StartTime,
+                    Sample = original.Sample,
+                    Position = new Vector2(512, 384) / 2,
+
+                    EndTime = endTimeData.EndTime
+                };
+            }
+
+            return new HitCircle
+            {
+                StartTime = original.StartTime,
+                Sample = original.Sample,
+
+                Position = positionData?.Position ?? Vector2.Zero,
+
+                NewCombo = comboData?.NewCombo ?? false
+            };
+        }
+
         private void updateStacking(List<OsuHitObject> hitObjects, float stackLeniency, int startIndex = 0, int endIndex = -1)
         {
             if (endIndex == -1)
@@ -61,9 +99,12 @@ namespace osu.Game.Modes.Osu.Beatmaps
                     if (stackBaseObject is Spinner) break;
 
                     OsuHitObject objectN = hitObjects[n];
-                    if (objectN is Spinner) continue;
+                    if (objectN is Spinner)
+                        continue;
 
-                    if (objectN.StartTime - stackBaseObject.EndTime > stackThreshold)
+                    double endTime = (stackBaseObject as IHasEndTime)?.EndTime ?? stackBaseObject.StartTime;
+
+                    if (objectN.StartTime - endTime > stackThreshold)
                         //We are no longer within stacking range of the next object.
                         break;
 
@@ -115,7 +156,9 @@ namespace osu.Game.Modes.Osu.Beatmaps
                         OsuHitObject objectN = hitObjects[n];
                         if (objectN is Spinner) continue;
 
-                        if (objectI.StartTime - objectN.EndTime > stackThreshold)
+                        double endTime = (objectN as IHasEndTime)?.EndTime ?? objectN.StartTime;
+
+                        if (objectI.StartTime - endTime > stackThreshold)
                             //We are no longer within stacking range of the previous object.
                             break;
 
diff --git a/osu.Game.Modes.Osu/Beatmaps/OsuBeatmapProcessor.cs b/osu.Game.Modes.Osu/Beatmaps/OsuBeatmapProcessor.cs
new file mode 100644
index 0000000000..1f7785f174
--- /dev/null
+++ b/osu.Game.Modes.Osu/Beatmaps/OsuBeatmapProcessor.cs
@@ -0,0 +1,37 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Beatmaps;
+using osu.Game.Modes.Osu.Objects;
+
+namespace osu.Game.Modes.Osu.Beatmaps
+{
+    internal class OsuBeatmapProcessor : IBeatmapProcessor<OsuHitObject>
+    {
+        public void SetDefaults(OsuHitObject hitObject, Beatmap<OsuHitObject> beatmap)
+        {
+            hitObject.SetDefaultsFromBeatmap(beatmap);
+        }
+
+        public void PostProcess(Beatmap<OsuHitObject> beatmap)
+        {
+            if (beatmap.ComboColors.Count == 0)
+                return;
+
+            int comboIndex = 0;
+            int colourIndex = 0;
+
+            foreach (var obj in beatmap.HitObjects)
+            {
+                if (obj.NewCombo)
+                {
+                    comboIndex = 0;
+                    colourIndex = (colourIndex + 1) % beatmap.ComboColors.Count;
+                }
+
+                obj.ComboIndex = comboIndex++;
+                obj.ComboColour = beatmap.ComboColors[colourIndex];
+            }
+        }
+    }
+}
diff --git a/osu.Game.Modes.Osu/Objects/Drawables/Connections/FollowPointRenderer.cs b/osu.Game.Modes.Osu/Objects/Drawables/Connections/FollowPointRenderer.cs
index 6ef9bc100a..f45e4226dd 100644
--- a/osu.Game.Modes.Osu/Objects/Drawables/Connections/FollowPointRenderer.cs
+++ b/osu.Game.Modes.Osu/Objects/Drawables/Connections/FollowPointRenderer.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using OpenTK;
+using osu.Game.Modes.Objects.Types;
 
 namespace osu.Game.Modes.Osu.Objects.Drawables.Connections
 {
@@ -63,7 +64,7 @@ namespace osu.Game.Modes.Osu.Objects.Drawables.Connections
                 {
                     Vector2 startPosition = prevHitObject.EndPosition;
                     Vector2 endPosition = currHitObject.Position;
-                    double startTime = prevHitObject.EndTime;
+                    double startTime = (prevHitObject as IHasEndTime)?.EndTime ?? prevHitObject.StartTime;
                     double endTime = currHitObject.StartTime;
 
                     Vector2 distanceVector = endPosition - startPosition;
diff --git a/osu.Game.Modes.Osu/Objects/Drawables/DrawableHitCircle.cs b/osu.Game.Modes.Osu/Objects/Drawables/DrawableHitCircle.cs
index c2717f2d3d..c0ff0e520a 100644
--- a/osu.Game.Modes.Osu/Objects/Drawables/DrawableHitCircle.cs
+++ b/osu.Game.Modes.Osu/Objects/Drawables/DrawableHitCircle.cs
@@ -7,6 +7,7 @@ using osu.Framework.Graphics.Transforms;
 using osu.Game.Modes.Objects.Drawables;
 using osu.Game.Modes.Osu.Objects.Drawables.Pieces;
 using OpenTK;
+using osu.Game.Modes.Objects.Types;
 
 namespace osu.Game.Modes.Osu.Objects.Drawables
 {
@@ -35,11 +36,11 @@ namespace osu.Game.Modes.Osu.Objects.Drawables
             {
                 glow = new GlowPiece
                 {
-                    Colour = osuObject.Colour
+                    Colour = osuObject.ComboColour
                 },
                 circle = new CirclePiece
                 {
-                    Colour = osuObject.Colour,
+                    Colour = osuObject.ComboColour,
                     Hit = () =>
                     {
                         if (Judgement.Result.HasValue) return false;
@@ -57,11 +58,11 @@ namespace osu.Game.Modes.Osu.Objects.Drawables
                 flash = new FlashPiece(),
                 explode = new ExplodePiece
                 {
-                    Colour = osuObject.Colour,
+                    Colour = osuObject.ComboColour,
                 },
                 ApproachCircle = new ApproachCircle
                 {
-                    Colour = osuObject.Colour,
+                    Colour = osuObject.ComboColour,
                 }
             };
 
@@ -116,13 +117,16 @@ namespace osu.Game.Modes.Osu.Objects.Drawables
 
             ApproachCircle.FadeOut();
 
-            glow.Delay(osuObject.Duration);
+            double endTime = (osuObject as IHasEndTime)?.EndTime ?? osuObject.StartTime;
+            double duration = endTime - osuObject.StartTime;
+
+            glow.Delay(duration);
             glow.FadeOut(400);
 
             switch (state)
             {
                 case ArmedState.Idle:
-                    Delay(osuObject.Duration + TIME_PREEMPT);
+                    Delay(duration + TIME_PREEMPT);
                     FadeOut(TIME_FADEOUT);
                     break;
                 case ArmedState.Miss:
diff --git a/osu.Game.Modes.Osu/Objects/Drawables/DrawableSlider.cs b/osu.Game.Modes.Osu/Objects/Drawables/DrawableSlider.cs
index 49aaa893e2..036f12167a 100644
--- a/osu.Game.Modes.Osu/Objects/Drawables/DrawableSlider.cs
+++ b/osu.Game.Modes.Osu/Objects/Drawables/DrawableSlider.cs
@@ -60,7 +60,7 @@ namespace osu.Game.Modes.Osu.Objects.Drawables
                     Position = s.StackedPosition,
                     ComboIndex = s.ComboIndex,
                     Scale = s.Scale,
-                    Colour = s.Colour,
+                    ComboColour = s.ComboColour,
                     Sample = s.Sample,
                 }),
             };
@@ -72,7 +72,7 @@ namespace osu.Game.Modes.Osu.Objects.Drawables
 
             AddNested(initialCircle);
 
-            var repeatDuration = s.Curve.Length / s.Velocity;
+            var repeatDuration = s.Curve.Distance / s.Velocity;
             foreach (var tick in s.Ticks)
             {
                 var repeatStartTime = s.StartTime + tick.RepeatIndex * repeatDuration;
@@ -104,7 +104,7 @@ namespace osu.Game.Modes.Osu.Objects.Drawables
             double progress = MathHelper.Clamp((Time.Current - slider.StartTime) / slider.Duration, 0, 1);
 
             int repeat = slider.RepeatAt(progress);
-            progress = slider.CurveProgressAt(progress);
+            progress = slider.ProgressAt(progress);
 
             if (repeat > currentRepeat)
             {
@@ -125,7 +125,7 @@ namespace osu.Game.Modes.Osu.Objects.Drawables
 
         protected override void CheckJudgement(bool userTriggered)
         {
-            if (!userTriggered && Time.Current >= HitObject.EndTime)
+            if (!userTriggered && Time.Current >= slider.EndTime)
             {
                 var ticksCount = ticks.Children.Count() + 1;
                 var ticksHit = ticks.Children.Count(t => t.Judgement.Result == HitResult.Hit);
@@ -162,7 +162,7 @@ namespace osu.Game.Modes.Osu.Objects.Drawables
 
             ball.FadeIn();
 
-            Delay(HitObject.Duration, true);
+            Delay(slider.Duration, true);
 
             body.FadeOut(160);
             ball.FadeOut(160);
diff --git a/osu.Game.Modes.Osu/Objects/Drawables/DrawableSliderTick.cs b/osu.Game.Modes.Osu/Objects/Drawables/DrawableSliderTick.cs
index 4ef4d18bfc..0400d4a866 100644
--- a/osu.Game.Modes.Osu/Objects/Drawables/DrawableSliderTick.cs
+++ b/osu.Game.Modes.Osu/Objects/Drawables/DrawableSliderTick.cs
@@ -48,7 +48,7 @@ namespace osu.Game.Modes.Osu.Objects.Drawables
                 new Box
                 {
                     RelativeSizeAxes = Axes.Both,
-                    Colour = sliderTick.Colour,
+                    Colour = sliderTick.ComboColour,
                     Alpha = 0.3f,
                 }
             };
diff --git a/osu.Game.Modes.Osu/Objects/Drawables/DrawableSpinner.cs b/osu.Game.Modes.Osu/Objects/Drawables/DrawableSpinner.cs
index 530062da93..be3048a9ba 100644
--- a/osu.Game.Modes.Osu/Objects/Drawables/DrawableSpinner.cs
+++ b/osu.Game.Modes.Osu/Objects/Drawables/DrawableSpinner.cs
@@ -46,7 +46,7 @@ namespace osu.Game.Modes.Osu.Objects.Drawables
                     Alpha = 0,
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    DiscColour = s.Colour
+                    DiscColour = s.ComboColour
                 },
                 circleContainer = new Container
                 {
@@ -80,7 +80,7 @@ namespace osu.Game.Modes.Osu.Objects.Drawables
             if (Progress >= 1)
                 disc.Complete = true;
 
-            if (!userTriggered && Time.Current >= HitObject.EndTime)
+            if (!userTriggered && Time.Current >= spinner.EndTime)
             {
                 if (Progress >= 1)
                 {
@@ -100,7 +100,7 @@ namespace osu.Game.Modes.Osu.Objects.Drawables
                 else
                 {
                     Judgement.Score = OsuScoreResult.Miss;
-                    if (Time.Current >= HitObject.EndTime)
+                    if (Time.Current >= spinner.EndTime)
                         Judgement.Result = HitResult.Miss;
                 }
             }
@@ -138,7 +138,7 @@ namespace osu.Game.Modes.Osu.Objects.Drawables
 
             base.UpdateState(state);
 
-            Delay(HitObject.Duration, true);
+            Delay(spinner.Duration, true);
 
             FadeOut(160);
 
diff --git a/osu.Game.Modes.Osu/Objects/Drawables/Pieces/SliderBall.cs b/osu.Game.Modes.Osu/Objects/Drawables/Pieces/SliderBall.cs
index 49785efd38..0b1a3aa751 100644
--- a/osu.Game.Modes.Osu/Objects/Drawables/Pieces/SliderBall.cs
+++ b/osu.Game.Modes.Osu/Objects/Drawables/Pieces/SliderBall.cs
@@ -51,7 +51,7 @@ namespace osu.Game.Modes.Osu.Objects.Drawables.Pieces
                     {
                         new Box
                         {
-                            Colour = slider.Colour,
+                            Colour = slider.ComboColour,
                             Alpha = 0.4f,
                             Width = width,
                             Height = width,
diff --git a/osu.Game.Modes.Osu/Objects/Drawables/Pieces/SliderBody.cs b/osu.Game.Modes.Osu/Objects/Drawables/Pieces/SliderBody.cs
index 7f7d558294..b923d05713 100644
--- a/osu.Game.Modes.Osu/Objects/Drawables/Pieces/SliderBody.cs
+++ b/osu.Game.Modes.Osu/Objects/Drawables/Pieces/SliderBody.cs
@@ -110,10 +110,10 @@ namespace osu.Game.Modes.Osu.Objects.Drawables.Pieces
                 {
                     progress -= border_portion;
 
-                    bytes[i * 4] = (byte)(slider.Colour.R * 255);
-                    bytes[i * 4 + 1] = (byte)(slider.Colour.G * 255);
-                    bytes[i * 4 + 2] = (byte)(slider.Colour.B * 255);
-                    bytes[i * 4 + 3] = (byte)((opacity_at_edge - (opacity_at_edge - opacity_at_centre) * progress / gradient_portion) * (slider.Colour.A * 255));
+                    bytes[i * 4] = (byte)(slider.ComboColour.R * 255);
+                    bytes[i * 4 + 1] = (byte)(slider.ComboColour.G * 255);
+                    bytes[i * 4 + 2] = (byte)(slider.ComboColour.B * 255);
+                    bytes[i * 4 + 3] = (byte)((opacity_at_edge - (opacity_at_edge - opacity_at_centre) * progress / gradient_portion) * (slider.ComboColour.A * 255));
                 }
             }
 
diff --git a/osu.Game.Modes.Osu/Objects/HitObjectType.cs b/osu.Game.Modes.Osu/Objects/HitObjectType.cs
new file mode 100644
index 0000000000..7d2d84c94c
--- /dev/null
+++ b/osu.Game.Modes.Osu/Objects/HitObjectType.cs
@@ -0,0 +1,13 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Modes.Osu.Objects
+{
+    public enum HitObjectType
+    {
+        Circle,
+        Slider,
+        Spinner,
+        SliderTick
+    }
+}
diff --git a/osu.Game.Modes.Osu/Objects/OsuHitObject.cs b/osu.Game.Modes.Osu/Objects/OsuHitObject.cs
index ddcdae7be0..a3f2222fbb 100644
--- a/osu.Game.Modes.Osu/Objects/OsuHitObject.cs
+++ b/osu.Game.Modes.Osu/Objects/OsuHitObject.cs
@@ -1,15 +1,16 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System;
 using osu.Game.Modes.Objects;
 using OpenTK;
 using osu.Game.Beatmaps;
 using osu.Game.Modes.Osu.Objects.Drawables;
+using osu.Game.Modes.Objects.Types;
+using OpenTK.Graphics;
 
 namespace osu.Game.Modes.Osu.Objects
 {
-    public abstract class OsuHitObject : HitObject
+    public abstract class OsuHitObject : HitObject, IHasCombo, IHasPosition
     {
         public const double OBJECT_RADIUS = 64;
 
@@ -36,6 +37,10 @@ namespace osu.Game.Modes.Osu.Objects
 
         public abstract HitObjectType Type { get; }
 
+        public Color4 ComboColour { get; set; }
+        public virtual bool NewCombo { get; set; }
+        public int ComboIndex { get; set; }
+
         public double HitWindowFor(OsuScoreResult result)
         {
             switch (result)
@@ -62,23 +67,9 @@ namespace osu.Game.Modes.Osu.Objects
             return OsuScoreResult.Miss;
         }
 
-        public override void SetDefaultsFromBeatmap(Beatmap beatmap)
+        public virtual void SetDefaultsFromBeatmap(Beatmap<OsuHitObject> beatmap)
         {
-            base.SetDefaultsFromBeatmap(beatmap);
-
             Scale = (1.0f - 0.7f * (beatmap.BeatmapInfo.BaseDifficulty.CircleSize - 5) / 5) / 2;
         }
     }
-
-    [Flags]
-    public enum HitObjectType
-    {
-        Circle = 1 << 0,
-        Slider = 1 << 1,
-        NewCombo = 1 << 2,
-        Spinner = 1 << 3,
-        ColourHax = 122,
-        Hold = 1 << 7,
-        SliderTick = 1 << 8,
-    }
 }
diff --git a/osu.Game.Modes.Osu/Objects/OsuHitObjectParser.cs b/osu.Game.Modes.Osu/Objects/OsuHitObjectParser.cs
deleted file mode 100644
index 3a8ab00f10..0000000000
--- a/osu.Game.Modes.Osu/Objects/OsuHitObjectParser.cs
+++ /dev/null
@@ -1,105 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using osu.Game.Beatmaps.Samples;
-using osu.Game.Modes.Objects;
-using OpenTK;
-
-namespace osu.Game.Modes.Osu.Objects
-{
-    public class OsuHitObjectParser : HitObjectParser
-    {
-        public override HitObject Parse(string text)
-        {
-            string[] split = text.Split(',');
-            var type = (HitObjectType)int.Parse(split[3]);
-            bool combo = type.HasFlag(HitObjectType.NewCombo);
-            type &= (HitObjectType)0xF;
-            type &= ~HitObjectType.NewCombo;
-            OsuHitObject result;
-            switch (type)
-            {
-                case HitObjectType.Circle:
-                    result = new HitCircle
-                    {
-                        Position = new Vector2(int.Parse(split[0]), int.Parse(split[1]))
-                    };
-                    break;
-                case HitObjectType.Slider:
-                    CurveTypes curveType = CurveTypes.Catmull;
-                    double length = 0;
-                    List<Vector2> points = new List<Vector2> { new Vector2(int.Parse(split[0]), int.Parse(split[1])) };
-
-                    string[] pointsplit = split[5].Split('|');
-                    foreach (string t in pointsplit)
-                    {
-                        if (t.Length == 1)
-                        {
-                            switch (t)
-                            {
-                                case @"C":
-                                    curveType = CurveTypes.Catmull;
-                                    break;
-                                case @"B":
-                                    curveType = CurveTypes.Bezier;
-                                    break;
-                                case @"L":
-                                    curveType = CurveTypes.Linear;
-                                    break;
-                                case @"P":
-                                    curveType = CurveTypes.PerfectCurve;
-                                    break;
-                            }
-                            continue;
-                        }
-
-                        string[] temp = t.Split(':');
-                        Vector2 v = new Vector2(
-                            (int)Convert.ToDouble(temp[0], CultureInfo.InvariantCulture),
-                            (int)Convert.ToDouble(temp[1], CultureInfo.InvariantCulture)
-                        );
-                        points.Add(v);
-                    }
-
-                    int repeatCount = Convert.ToInt32(split[6], CultureInfo.InvariantCulture);
-
-                    if (repeatCount > 9000)
-                        throw new ArgumentOutOfRangeException(nameof(repeatCount), @"Repeat count is way too high");
-
-                    if (split.Length > 7)
-                        length = Convert.ToDouble(split[7], CultureInfo.InvariantCulture);
-
-                    result = new Slider
-                    {
-                        ControlPoints = points,
-                        Length = length,
-                        CurveType = curveType,
-                        RepeatCount = repeatCount,
-                        Position = new Vector2(int.Parse(split[0]), int.Parse(split[1]))
-                    };
-                    break;
-                case HitObjectType.Spinner:
-                    result = new Spinner
-                    {
-                        Length = Convert.ToDouble(split[5], CultureInfo.InvariantCulture) - Convert.ToDouble(split[2], CultureInfo.InvariantCulture),
-                        Position = new Vector2(512, 384) / 2,
-                    };
-                    break;
-                default:
-                    throw new InvalidOperationException($@"Unknown hit object type {type}");
-            }
-            result.StartTime = Convert.ToDouble(split[2], CultureInfo.InvariantCulture);
-            result.Sample = new HitSampleInfo
-            {
-                Type = (SampleType)int.Parse(split[4]),
-                Set = SampleSet.Soft,
-            };
-            result.NewCombo = combo;
-            // TODO: "addition" field
-            return result;
-        }
-    }
-}
diff --git a/osu.Game.Modes.Osu/Objects/Slider.cs b/osu.Game.Modes.Osu/Objects/Slider.cs
index 88abb68d0a..83a5a458c7 100644
--- a/osu.Game.Modes.Osu/Objects/Slider.cs
+++ b/osu.Game.Modes.Osu/Objects/Slider.cs
@@ -5,41 +5,33 @@ using OpenTK;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Samples;
 using osu.Game.Beatmaps.Timing;
+using osu.Game.Modes.Objects.Types;
 using System;
 using System.Collections.Generic;
+using osu.Game.Modes.Objects;
 
 namespace osu.Game.Modes.Osu.Objects
 {
-    public class Slider : OsuHitObject
+    public class Slider : OsuHitObject, IHasCurve
     {
-        public override double EndTime => StartTime + RepeatCount * Curve.Length / Velocity;
+        public IHasCurve CurveObject { get; set; }
+
+        public SliderCurve Curve => CurveObject.Curve;
+
+        public double EndTime => StartTime + RepeatCount * Curve.Distance / Velocity;
+        public double Duration => EndTime - StartTime;
 
         public override Vector2 EndPosition => PositionAt(1);
 
-        /// <summary>
-        /// Computes the position on the slider at a given progress that ranges from 0 (beginning of the slider)
-        /// to 1 (end of the slider). This includes repeat logic.
-        /// </summary>
-        /// <param name="progress">Ranges from 0 (beginning of the slider) to 1 (end of the slider).</param>
-        /// <returns></returns>
-        public Vector2 PositionAt(double progress) => Curve.PositionAt(CurveProgressAt(progress));
+        public Vector2 PositionAt(double progress) => CurveObject.PositionAt(progress);
+        public double ProgressAt(double progress) => CurveObject.ProgressAt(progress);
+        public int RepeatAt(double progress) => CurveObject.RepeatAt(progress);
 
-        /// <summary>
-        /// Find the current progress along the curve, accounting for repeat logic.
-        /// </summary>
-        public double CurveProgressAt(double progress)
-        {
-            var p = progress * RepeatCount % 1;
-            if (RepeatAt(progress) % 2 == 1)
-                p = 1 - p;
-            return p;
-        }
+        public List<Vector2> ControlPoints => CurveObject.ControlPoints;
+        public CurveType CurveType => CurveObject.CurveType;
+        public double Distance => CurveObject.Distance;
 
-        /// <summary>
-        /// Determine which repeat of the slider we are on at a given progress.
-        /// Range is 0..RepeatCount where 0 is the first run.
-        /// </summary>
-        public int RepeatAt(double progress) => (int)(progress * RepeatCount);
+        public int RepeatCount => CurveObject.RepeatCount;
 
         private int stackHeight;
         public override int StackHeight
@@ -52,28 +44,10 @@ namespace osu.Game.Modes.Osu.Objects
             }
         }
 
-        public List<Vector2> ControlPoints
-        {
-            get { return Curve.ControlPoints; }
-            set { Curve.ControlPoints = value; }
-        }
-
-        public double Length
-        {
-            get { return Curve.Length; }
-            set { Curve.Length = value; }
-        }
-
-        public CurveTypes CurveType
-        {
-            get { return Curve.CurveType; }
-            set { Curve.CurveType = value; }
-        }
-
         public double Velocity;
         public double TickDistance;
 
-        public override void SetDefaultsFromBeatmap(Beatmap beatmap)
+        public override void SetDefaultsFromBeatmap(Beatmap<OsuHitObject> beatmap)
         {
             base.SetDefaultsFromBeatmap(beatmap);
 
@@ -88,17 +62,13 @@ namespace osu.Game.Modes.Osu.Objects
             TickDistance = baseVelocity / baseDifficulty.SliderTickRate;
         }
 
-        public int RepeatCount = 1;
-
-        internal readonly SliderCurve Curve = new SliderCurve();
-
         public IEnumerable<SliderTick> Ticks
         {
             get
             {
                 if (TickDistance == 0) yield break;
 
-                var length = Curve.Length;
+                var length = Curve.Distance;
                 var tickDistance = Math.Min(TickDistance, length);
                 var repeatDuration = length / Velocity;
 
@@ -124,7 +94,7 @@ namespace osu.Game.Modes.Osu.Objects
                             Position = Curve.PositionAt(distanceProgress),
                             StackHeight = StackHeight,
                             Scale = Scale,
-                            Colour = Colour,
+                            ComboColour = ComboColour,
                             Sample = new HitSampleInfo
                             {
                                 Type = SampleType.None,
@@ -138,12 +108,4 @@ namespace osu.Game.Modes.Osu.Objects
 
         public override HitObjectType Type => HitObjectType.Slider;
     }
-
-    public enum CurveTypes
-    {
-        Catmull,
-        Bezier,
-        Linear,
-        PerfectCurve
-    }
 }
diff --git a/osu.Game.Modes.Osu/Objects/Spinner.cs b/osu.Game.Modes.Osu/Objects/Spinner.cs
index d55b9eb59c..65e39f30ed 100644
--- a/osu.Game.Modes.Osu/Objects/Spinner.cs
+++ b/osu.Game.Modes.Osu/Objects/Spinner.cs
@@ -1,14 +1,17 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Game.Modes.Objects.Types;
+
 namespace osu.Game.Modes.Osu.Objects
 {
-    public class Spinner : OsuHitObject
+    public class Spinner : OsuHitObject, IHasEndTime
     {
-        public double Length;
-
-        public override double EndTime => StartTime + Length;
+        public double EndTime { get; set; }
+        public double Duration => EndTime - StartTime;
 
         public override HitObjectType Type => HitObjectType.Spinner;
+
+        public override bool NewCombo => true;
     }
 }
diff --git a/osu.Game.Modes.Osu/OsuAutoReplay.cs b/osu.Game.Modes.Osu/OsuAutoReplay.cs
index 3de6106030..6b543cb98f 100644
--- a/osu.Game.Modes.Osu/OsuAutoReplay.cs
+++ b/osu.Game.Modes.Osu/OsuAutoReplay.cs
@@ -10,6 +10,7 @@ using osu.Game.Modes.Osu.Objects.Drawables;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using osu.Game.Modes.Objects.Types;
 
 namespace osu.Game.Modes.Osu
 {
@@ -100,20 +101,22 @@ namespace osu.Game.Modes.Osu
                 {
                     OsuHitObject last = beatmap.HitObjects[i - 1];
 
+                    double endTime = (last as IHasEndTime)?.EndTime ?? last.StartTime;
+
                     //Make the cursor stay at a hitObject as long as possible (mainly for autopilot).
-                    if (h.StartTime - h.HitWindowFor(OsuScoreResult.Miss) > last.EndTime + h.HitWindowFor(OsuScoreResult.Hit50) + 50)
+                    if (h.StartTime - h.HitWindowFor(OsuScoreResult.Miss) > endTime + h.HitWindowFor(OsuScoreResult.Hit50) + 50)
                     {
-                        if (!(last is Spinner) && h.StartTime - last.EndTime < 1000) addFrameToReplay(new LegacyReplayFrame(last.EndTime + h.HitWindowFor(OsuScoreResult.Hit50), last.EndPosition.X, last.EndPosition.Y, LegacyButtonState.None));
+                        if (!(last is Spinner) && h.StartTime - endTime < 1000) addFrameToReplay(new LegacyReplayFrame(endTime + h.HitWindowFor(OsuScoreResult.Hit50), last.EndPosition.X, last.EndPosition.Y, LegacyButtonState.None));
                         if (!(h is Spinner)) addFrameToReplay(new LegacyReplayFrame(h.StartTime - h.HitWindowFor(OsuScoreResult.Miss), h.Position.X, h.Position.Y, LegacyButtonState.None));
                     }
-                    else if (h.StartTime - h.HitWindowFor(OsuScoreResult.Hit50) > last.EndTime + h.HitWindowFor(OsuScoreResult.Hit50) + 50)
+                    else if (h.StartTime - h.HitWindowFor(OsuScoreResult.Hit50) > endTime + h.HitWindowFor(OsuScoreResult.Hit50) + 50)
                     {
-                        if (!(last is Spinner) && h.StartTime - last.EndTime < 1000) addFrameToReplay(new LegacyReplayFrame(last.EndTime + h.HitWindowFor(OsuScoreResult.Hit50), last.EndPosition.X, last.EndPosition.Y, LegacyButtonState.None));
+                        if (!(last is Spinner) && h.StartTime - endTime < 1000) addFrameToReplay(new LegacyReplayFrame(endTime + h.HitWindowFor(OsuScoreResult.Hit50), last.EndPosition.X, last.EndPosition.Y, LegacyButtonState.None));
                         if (!(h is Spinner)) addFrameToReplay(new LegacyReplayFrame(h.StartTime - h.HitWindowFor(OsuScoreResult.Hit50), h.Position.X, h.Position.Y, LegacyButtonState.None));
                     }
-                    else if (h.StartTime - h.HitWindowFor(OsuScoreResult.Hit100) > last.EndTime + h.HitWindowFor(OsuScoreResult.Hit100) + 50)
+                    else if (h.StartTime - h.HitWindowFor(OsuScoreResult.Hit100) > endTime + h.HitWindowFor(OsuScoreResult.Hit100) + 50)
                     {
-                        if (!(last is Spinner) && h.StartTime - last.EndTime < 1000) addFrameToReplay(new LegacyReplayFrame(last.EndTime + h.HitWindowFor(OsuScoreResult.Hit100), last.EndPosition.X, last.EndPosition.Y, LegacyButtonState.None));
+                        if (!(last is Spinner) && h.StartTime - endTime < 1000) addFrameToReplay(new LegacyReplayFrame(endTime + h.HitWindowFor(OsuScoreResult.Hit100), last.EndPosition.X, last.EndPosition.Y, LegacyButtonState.None));
                         if (!(h is Spinner)) addFrameToReplay(new LegacyReplayFrame(h.StartTime - h.HitWindowFor(OsuScoreResult.Hit100), h.Position.X, h.Position.Y, LegacyButtonState.None));
                     }
                 }
@@ -206,8 +209,10 @@ namespace osu.Game.Modes.Osu
 
                 LegacyButtonState button = buttonIndex % 2 == 0 ? LegacyButtonState.Left1 : LegacyButtonState.Right1;
 
+                double hEndTime = (h as IHasEndTime)?.EndTime ?? h.StartTime;
+
                 LegacyReplayFrame newFrame = new LegacyReplayFrame(h.StartTime, targetPosition.X, targetPosition.Y, button);
-                LegacyReplayFrame endFrame = new LegacyReplayFrame(h.EndTime + endDelay, h.EndPosition.X, h.EndPosition.Y, LegacyButtonState.None);
+                LegacyReplayFrame endFrame = new LegacyReplayFrame(hEndTime + endDelay, h.EndPosition.X, h.EndPosition.Y, LegacyButtonState.None);
 
                 // Decrement because we want the previous frame, not the next one
                 int index = findInsertionIndex(newFrame) - 1;
@@ -251,6 +256,8 @@ namespace osu.Game.Modes.Osu
                 // We add intermediate frames for spinning / following a slider here.
                 if (h is Spinner)
                 {
+                    Spinner s = h as Spinner;
+
                     Vector2 difference = targetPosition - spinner_centre;
 
                     float radius = difference.Length;
@@ -258,7 +265,7 @@ namespace osu.Game.Modes.Osu
 
                     double t;
 
-                    for (double j = h.StartTime + frameDelay; j < h.EndTime; j += frameDelay)
+                    for (double j = h.StartTime + frameDelay; j < s.EndTime; j += frameDelay)
                     {
                         t = applyModsToTime(j - h.StartTime) * spinnerDirection;
 
@@ -266,10 +273,10 @@ namespace osu.Game.Modes.Osu
                         addFrameToReplay(new LegacyReplayFrame((int)j, pos.X, pos.Y, button));
                     }
 
-                    t = applyModsToTime(h.EndTime - h.StartTime) * spinnerDirection;
+                    t = applyModsToTime(s.EndTime - h.StartTime) * spinnerDirection;
                     Vector2 endPosition = spinner_centre + circlePosition(t / 20 + angle, spin_radius);
 
-                    addFrameToReplay(new LegacyReplayFrame(h.EndTime, endPosition.X, endPosition.Y, button));
+                    addFrameToReplay(new LegacyReplayFrame(s.EndTime, endPosition.X, endPosition.Y, button));
 
                     endFrame.MouseX = endPosition.X;
                     endFrame.MouseY = endPosition.Y;
@@ -284,7 +291,7 @@ namespace osu.Game.Modes.Osu
                         addFrameToReplay(new LegacyReplayFrame(h.StartTime + j, pos.X, pos.Y, button));
                     }
 
-                    addFrameToReplay(new LegacyReplayFrame(h.EndTime, s.EndPosition.X, s.EndPosition.Y, button));
+                    addFrameToReplay(new LegacyReplayFrame(s.EndTime, s.EndPosition.X, s.EndPosition.Y, button));
                 }
 
                 // We only want to let go of our button if we are at the end of the current replay. Otherwise something is still going on after us so we need to keep the button pressed!
diff --git a/osu.Game.Modes.Osu/OsuRuleset.cs b/osu.Game.Modes.Osu/OsuRuleset.cs
index a5b0b62bbd..370cd53aa2 100644
--- a/osu.Game.Modes.Osu/OsuRuleset.cs
+++ b/osu.Game.Modes.Osu/OsuRuleset.cs
@@ -5,7 +5,6 @@ using OpenTK.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Modes.Mods;
-using osu.Game.Modes.Objects;
 using osu.Game.Modes.Osu.Mods;
 using osu.Game.Modes.Osu.Objects;
 using osu.Game.Modes.Osu.UI;
@@ -96,8 +95,6 @@ namespace osu.Game.Modes.Osu
 
         public override FontAwesome Icon => FontAwesome.fa_osu_osu_o;
 
-        public override HitObjectParser CreateHitObjectParser() => new OsuHitObjectParser();
-
         public override ScoreProcessor CreateScoreProcessor(int hitObjectCount = 0) => new OsuScoreProcessor(hitObjectCount);
 
         public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap) => new OsuDifficultyCalculator(beatmap);
diff --git a/osu.Game.Modes.Osu/UI/OsuHitRenderer.cs b/osu.Game.Modes.Osu/UI/OsuHitRenderer.cs
index 0169e9a0e6..f9aed40a63 100644
--- a/osu.Game.Modes.Osu/UI/OsuHitRenderer.cs
+++ b/osu.Game.Modes.Osu/UI/OsuHitRenderer.cs
@@ -21,8 +21,10 @@ namespace osu.Game.Modes.Osu.UI
 
         protected override IBeatmapConverter<OsuHitObject> CreateBeatmapConverter() => new OsuBeatmapConverter();
 
+        protected override IBeatmapProcessor<OsuHitObject> CreateBeatmapProcessor() => new OsuBeatmapProcessor();
         protected override Playfield<OsuHitObject, OsuJudgementInfo> CreatePlayfield() => new OsuPlayfield();
 
+
         protected override KeyConversionInputManager CreateKeyConversionInputManager() => new OsuKeyConversionInputManager();
 
         protected override DrawableHitObject<OsuHitObject, OsuJudgementInfo> GetVisualRepresentation(OsuHitObject h)
diff --git a/osu.Game.Modes.Osu/osu.Game.Modes.Osu.csproj b/osu.Game.Modes.Osu/osu.Game.Modes.Osu.csproj
index 91ca01c4c8..2c7f3a0916 100644
--- a/osu.Game.Modes.Osu/osu.Game.Modes.Osu.csproj
+++ b/osu.Game.Modes.Osu/osu.Game.Modes.Osu.csproj
@@ -44,8 +44,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Beatmaps\OsuBeatmapConverter.cs" />
-    <Compile Include="Objects\BezierApproximator.cs" />
-    <Compile Include="Objects\CircularArcApproximator.cs" />
+    <Compile Include="Beatmaps\OsuBeatmapProcessor.cs" />
     <Compile Include="Objects\Drawables\DrawableOsuHitObject.cs" />
     <Compile Include="Objects\Drawables\Connections\ConnectionRenderer.cs" />
     <Compile Include="Objects\Drawables\Connections\FollowPointRenderer.cs" />
@@ -68,9 +67,8 @@
     <Compile Include="Objects\Drawables\Pieces\TrianglesPiece.cs" />
     <Compile Include="Objects\Drawables\Pieces\SliderBall.cs" />
     <Compile Include="Objects\Drawables\Pieces\SliderBody.cs" />
+    <Compile Include="Objects\HitObjectType.cs" />
     <Compile Include="Objects\OsuHitObjectDifficulty.cs" />
-    <Compile Include="Objects\OsuHitObjectParser.cs" />
-    <Compile Include="Objects\SliderCurve.cs" />
     <Compile Include="Objects\SliderTick.cs" />
     <Compile Include="OsuAutoReplay.cs" />
     <Compile Include="OsuDifficultyCalculator.cs" />
diff --git a/osu.Game.Modes.Taiko/Beatmaps/TaikoBeatmapProcessor.cs b/osu.Game.Modes.Taiko/Beatmaps/TaikoBeatmapProcessor.cs
new file mode 100644
index 0000000000..9a244cd23e
--- /dev/null
+++ b/osu.Game.Modes.Taiko/Beatmaps/TaikoBeatmapProcessor.cs
@@ -0,0 +1,19 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Beatmaps;
+using osu.Game.Modes.Taiko.Objects;
+
+namespace osu.Game.Modes.Taiko.Beatmaps
+{
+    internal class TaikoBeatmapProcessor : IBeatmapProcessor<TaikoBaseHit>
+    {
+        public void SetDefaults(TaikoBaseHit hitObject, Beatmap<TaikoBaseHit> beatmap)
+        {
+        }
+
+        public void PostProcess(Beatmap<TaikoBaseHit> beatmap)
+        {
+        }
+    }
+}
diff --git a/osu.Game.Modes.Taiko/Objects/Drawable/DrawableTaikoHit.cs b/osu.Game.Modes.Taiko/Objects/Drawable/DrawableTaikoHit.cs
index a6af85b6fe..a54108afda 100644
--- a/osu.Game.Modes.Taiko/Objects/Drawable/DrawableTaikoHit.cs
+++ b/osu.Game.Modes.Taiko/Objects/Drawable/DrawableTaikoHit.cs
@@ -29,8 +29,10 @@ namespace osu.Game.Modes.Taiko.Objects.Drawable
         {
             Texture = textures.Get(@"Menu/logo");
 
+            double duration = 0;
+
             Transforms.Add(new TransformPositionX { StartTime = h.StartTime - 200, EndTime = h.StartTime, StartValue = 1.1f, EndValue = 0.1f });
-            Transforms.Add(new TransformAlpha { StartTime = h.StartTime + h.Duration + 200, EndTime = h.StartTime + h.Duration + 400, StartValue = 1, EndValue = 0 });
+            Transforms.Add(new TransformAlpha { StartTime = h.StartTime + duration + 200, EndTime = h.StartTime + duration + 400, StartValue = 1, EndValue = 0 });
             Expire(true);
         }
     }
diff --git a/osu.Game.Modes.Taiko/TaikoRuleset.cs b/osu.Game.Modes.Taiko/TaikoRuleset.cs
index a1c9015b78..9782606a69 100644
--- a/osu.Game.Modes.Taiko/TaikoRuleset.cs
+++ b/osu.Game.Modes.Taiko/TaikoRuleset.cs
@@ -5,7 +5,6 @@ using OpenTK.Input;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Modes.Mods;
-using osu.Game.Modes.Objects;
 using osu.Game.Modes.Taiko.Mods;
 using osu.Game.Modes.Taiko.UI;
 using osu.Game.Modes.UI;
@@ -91,8 +90,6 @@ namespace osu.Game.Modes.Taiko
 
         public override ScoreProcessor CreateScoreProcessor(int hitObjectCount = 0) => null;
 
-        public override HitObjectParser CreateHitObjectParser() => new NullHitObjectParser();
-
         public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap) => new TaikoDifficultyCalculator(beatmap);
     }
 }
diff --git a/osu.Game.Modes.Taiko/UI/TaikoHitRenderer.cs b/osu.Game.Modes.Taiko/UI/TaikoHitRenderer.cs
index fe1e5b5804..4d8e6bf11b 100644
--- a/osu.Game.Modes.Taiko/UI/TaikoHitRenderer.cs
+++ b/osu.Game.Modes.Taiko/UI/TaikoHitRenderer.cs
@@ -19,8 +19,10 @@ namespace osu.Game.Modes.Taiko.UI
 
         protected override IBeatmapConverter<TaikoBaseHit> CreateBeatmapConverter() => new TaikoBeatmapConverter();
 
+        protected override IBeatmapProcessor<TaikoBaseHit> CreateBeatmapProcessor() => new TaikoBeatmapProcessor();
         protected override Playfield<TaikoBaseHit, TaikoJudgementInfo> CreatePlayfield() => new TaikoPlayfield();
 
+
         protected override DrawableHitObject<TaikoBaseHit, TaikoJudgementInfo> GetVisualRepresentation(TaikoBaseHit h) => null;// new DrawableTaikoHit(h);
     }
 }
diff --git a/osu.Game.Modes.Taiko/osu.Game.Modes.Taiko.csproj b/osu.Game.Modes.Taiko/osu.Game.Modes.Taiko.csproj
index 0a72c663e3..9edb9eaff3 100644
--- a/osu.Game.Modes.Taiko/osu.Game.Modes.Taiko.csproj
+++ b/osu.Game.Modes.Taiko/osu.Game.Modes.Taiko.csproj
@@ -48,6 +48,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Beatmaps\TaikoBeatmapConverter.cs" />
+    <Compile Include="Beatmaps\TaikoBeatmapProcessor.cs" />
     <Compile Include="Judgements\TaikoJudgementInfo.cs" />
     <Compile Include="TaikoDifficultyCalculator.cs" />
     <Compile Include="Objects\Drawable\DrawableTaikoHit.cs" />
diff --git a/osu.Game.Tests/Beatmaps/Formats/OsuLegacyDecoderTest.cs b/osu.Game.Tests/Beatmaps/Formats/OsuLegacyDecoderTest.cs
index e0d17badcd..61638ef25e 100644
--- a/osu.Game.Tests/Beatmaps/Formats/OsuLegacyDecoderTest.cs
+++ b/osu.Game.Tests/Beatmaps/Formats/OsuLegacyDecoderTest.cs
@@ -8,9 +8,9 @@ using OpenTK.Graphics;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Beatmaps.Samples;
 using osu.Game.Modes;
-using osu.Game.Modes.Osu;
-using osu.Game.Modes.Osu.Objects;
 using osu.Game.Tests.Resources;
+using osu.Game.Modes.Osu;
+using osu.Game.Modes.Objects.Legacy;
 
 namespace osu.Game.Tests.Beatmaps.Formats
 {
@@ -133,16 +133,16 @@ namespace osu.Game.Tests.Beatmaps.Formats
             using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
             {
                 var beatmap = decoder.Decode(new StreamReader(stream));
-                var slider = beatmap.HitObjects[0] as Slider;
+                var slider = beatmap.HitObjects[0] as LegacySlider;
                 Assert.IsNotNull(slider);
                 Assert.AreEqual(new Vector2(192, 168), slider.Position);
                 Assert.AreEqual(956, slider.StartTime);
                 Assert.AreEqual(SampleType.None, slider.Sample.Type);
-                var circle = beatmap.HitObjects[1] as HitCircle;
-                Assert.IsNotNull(circle);
-                Assert.AreEqual(new Vector2(304, 56), circle.Position);
-                Assert.AreEqual(1285, circle.StartTime);
-                Assert.AreEqual(SampleType.Clap, circle.Sample.Type);
+                var hit = beatmap.HitObjects[1] as LegacyHit;
+                Assert.IsNotNull(hit);
+                Assert.AreEqual(new Vector2(304, 56), hit.Position);
+                Assert.AreEqual(1285, hit.StartTime);
+                Assert.AreEqual(SampleType.Clap, hit.Sample.Type);
             }
         }
     }
diff --git a/osu.Game/Beatmaps/Beatmap.cs b/osu.Game/Beatmaps/Beatmap.cs
index de869192b9..6dbd605359 100644
--- a/osu.Game/Beatmaps/Beatmap.cs
+++ b/osu.Game/Beatmaps/Beatmap.cs
@@ -19,7 +19,13 @@ namespace osu.Game.Beatmaps
     {
         public BeatmapInfo BeatmapInfo;
         public List<ControlPoint> ControlPoints;
-        public List<Color4> ComboColors;
+        public readonly List<Color4> ComboColors = new List<Color4>
+        {
+            new Color4(17, 136, 170, 255),
+            new Color4(102, 136, 0, 255),
+            new Color4(204, 102, 0, 255),
+            new Color4(121, 9, 13, 255)
+        };
 
         public BeatmapMetadata Metadata => BeatmapInfo?.Metadata ?? BeatmapInfo?.BeatmapSet?.Metadata;
 
@@ -34,9 +40,9 @@ namespace osu.Game.Beatmaps
         /// <param name="original">The original beatmap to use the parameters of.</param>
         public Beatmap(Beatmap original = null)
         {
-            BeatmapInfo = original?.BeatmapInfo;
-            ControlPoints = original?.ControlPoints;
-            ComboColors = original?.ComboColors;
+            BeatmapInfo = original?.BeatmapInfo ?? BeatmapInfo;
+            ControlPoints = original?.ControlPoints ?? ControlPoints;
+            ComboColors = original?.ComboColors ?? ComboColors;
         }
 
         public double BPMMaximum => 60000 / (ControlPoints?.Where(c => c.BeatLength != 0).OrderBy(c => c.BeatLength).FirstOrDefault() ?? ControlPoint.Default).BeatLength;
diff --git a/osu.Game/Beatmaps/Formats/BeatmapDecoder.cs b/osu.Game/Beatmaps/Formats/BeatmapDecoder.cs
index d13cb33554..ba608fb08d 100644
--- a/osu.Game/Beatmaps/Formats/BeatmapDecoder.cs
+++ b/osu.Game/Beatmaps/Formats/BeatmapDecoder.cs
@@ -5,7 +5,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using osu.Game.Modes.Objects;
-using OpenTK.Graphics;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Database;
 
@@ -31,9 +30,7 @@ namespace osu.Game.Beatmaps.Formats
 
         public virtual Beatmap Decode(TextReader stream)
         {
-            Beatmap b = ParseFile(stream);
-            Process(b);
-            return b;
+            return ParseFile(stream);
         }
 
         public virtual void Decode(TextReader stream, Beatmap beatmap)
@@ -41,20 +38,12 @@ namespace osu.Game.Beatmaps.Formats
             ParseFile(stream, beatmap);
         }
 
-        public virtual Beatmap Process(Beatmap beatmap)
-        {
-            ApplyColours(beatmap);
-
-            return beatmap;
-        }
-
         protected virtual Beatmap ParseFile(TextReader stream)
         {
             var beatmap = new Beatmap
             {
                 HitObjects = new List<HitObject>(),
                 ControlPoints = new List<ControlPoint>(),
-                ComboColors = new List<Color4>(),
                 BeatmapInfo = new BeatmapInfo
                 {
                     Metadata = new BeatmapMetadata(),
@@ -65,25 +54,5 @@ namespace osu.Game.Beatmaps.Formats
             return beatmap;
         }
         protected abstract void ParseFile(TextReader stream, Beatmap beatmap);
-
-        public virtual void ApplyColours(Beatmap b)
-        {
-            List<Color4> colours = b.ComboColors ?? new List<Color4> {
-                new Color4(17, 136, 170, 255),
-                new Color4(102, 136, 0, 255),
-                new Color4(204, 102, 0, 255),
-                new Color4(121, 9, 13, 255),
-            };
-
-            if (colours.Count == 0) return;
-
-            int i = -1;
-
-            foreach (HitObject h in b.HitObjects)
-            {
-                if (h.NewCombo || i == -1) i = (i + 1) % colours.Count;
-                h.Colour = colours[i];
-            }
-        }
     }
 }
diff --git a/osu.Game/Beatmaps/Formats/OsuLegacyDecoder.cs b/osu.Game/Beatmaps/Formats/OsuLegacyDecoder.cs
index 9ce5a4cca0..71d26b2c51 100644
--- a/osu.Game/Beatmaps/Formats/OsuLegacyDecoder.cs
+++ b/osu.Game/Beatmaps/Formats/OsuLegacyDecoder.cs
@@ -212,14 +212,23 @@ namespace osu.Game.Beatmaps.Formats
                 beatmap.ControlPoints.Add(cp);
         }
 
-        private void handleColours(Beatmap beatmap, string key, string val)
+        private void handleColours(Beatmap beatmap, string key, string val, ref bool hasCustomColours)
         {
             string[] split = val.Split(',');
+
             if (split.Length != 3)
                 throw new InvalidOperationException($@"Color specified in incorrect format (should be R,G,B): {val}");
+
             byte r, g, b;
             if (!byte.TryParse(split[0], out r) || !byte.TryParse(split[1], out g) || !byte.TryParse(split[2], out b))
                 throw new InvalidOperationException(@"Color must be specified with 8-bit integer components");
+
+            if (!hasCustomColours)
+            {
+                beatmap.ComboColors.Clear();
+                hasCustomColours = true;
+            }
+
             // Note: the combo index specified in the beatmap is discarded
             if (key.StartsWith(@"Combo"))
             {
@@ -237,6 +246,8 @@ namespace osu.Game.Beatmaps.Formats
         {
             HitObjectParser parser = null;
 
+            bool hasCustomColours = false;
+
             var section = Section.None;
             while (true)
             {
@@ -265,7 +276,7 @@ namespace osu.Game.Beatmaps.Formats
                 {
                     case Section.General:
                         handleGeneral(beatmap, key, val);
-                        parser = Ruleset.GetRuleset(beatmap.BeatmapInfo.Mode).CreateHitObjectParser();
+                        parser = new LegacyHitObjectParser();
                         break;
                     case Section.Editor:
                         handleEditor(beatmap, key, val);
@@ -283,16 +294,14 @@ namespace osu.Game.Beatmaps.Formats
                         handleTimingPoints(beatmap, val);
                         break;
                     case Section.Colours:
-                        handleColours(beatmap, key, val);
+                        handleColours(beatmap, key, val, ref hasCustomColours);
                         break;
                     case Section.HitObjects:
                         var obj = parser?.Parse(val);
 
                         if (obj != null)
-                        {
-                            obj.SetDefaultsFromBeatmap(beatmap);
                             beatmap.HitObjects.Add(obj);
-                        }
+
                         break;
                 }
             }
diff --git a/osu.Game/Beatmaps/IBeatmapCoverter.cs b/osu.Game/Beatmaps/IBeatmapCoverter.cs
index da5892c168..72b248cfba 100644
--- a/osu.Game/Beatmaps/IBeatmapCoverter.cs
+++ b/osu.Game/Beatmaps/IBeatmapCoverter.cs
@@ -5,8 +5,17 @@ using osu.Game.Modes.Objects;
 
 namespace osu.Game.Beatmaps
 {
+    /// <summary>
+    /// Converts a Beatmap for another mode.
+    /// </summary>
+    /// <typeparam name="T">The type of HitObject stored in the Beatmap.</typeparam>
     public interface IBeatmapConverter<T> where T : HitObject
     {
+        /// <summary>
+        /// Converts a Beatmap to another mode.
+        /// </summary>
+        /// <param name="original">The original Beatmap.</param>
+        /// <returns>The converted Beatmap.</returns>
         Beatmap<T> Convert(Beatmap original);
     }
 }
diff --git a/osu.Game/Beatmaps/IBeatmapProcessor.cs b/osu.Game/Beatmaps/IBeatmapProcessor.cs
new file mode 100644
index 0000000000..3773f69279
--- /dev/null
+++ b/osu.Game/Beatmaps/IBeatmapProcessor.cs
@@ -0,0 +1,31 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Modes.Objects;
+
+namespace osu.Game.Beatmaps
+{
+    /// <summary>
+    /// Processes a post-converted Beatmap.
+    /// </summary>
+    /// <typeparam name="T">The type of HitObject contained in the Beatmap.</typeparam>
+    public interface IBeatmapProcessor<T>
+        where T : HitObject
+    {
+        /// <summary>
+        /// Sets default values for a HitObject.
+        /// </summary>
+        /// <param name="hitObject">The HitObject to set default values for.</param>
+        /// <param name="beatmap">The Beatmap to extract the default values from.</param>
+        void SetDefaults(T hitObject, Beatmap<T> beatmap);
+
+        /// <summary>
+        /// Post-processes a Beatmap to add mode-specific components that aren't added during conversion.
+        /// <para>
+        /// An example of such a usage is for combo colours.
+        /// </para>
+        /// </summary>
+        /// <param name="beatmap">The Beatmap to process.</param>
+        void PostProcess(Beatmap<T> beatmap);
+    }
+}
diff --git a/osu.Game.Modes.Osu/Objects/BezierApproximator.cs b/osu.Game/Modes/Objects/BezierApproximator.cs
similarity index 97%
rename from osu.Game.Modes.Osu/Objects/BezierApproximator.cs
rename to osu.Game/Modes/Objects/BezierApproximator.cs
index 3cfdb14a5d..b0f17afc7e 100644
--- a/osu.Game.Modes.Osu/Objects/BezierApproximator.cs
+++ b/osu.Game/Modes/Objects/BezierApproximator.cs
@@ -4,7 +4,7 @@
 using System.Collections.Generic;
 using OpenTK;
 
-namespace osu.Game.Modes.Osu.Objects
+namespace osu.Game.Modes.Objects
 {
     public class BezierApproximator
     {
diff --git a/osu.Game.Modes.Osu/Objects/CircularArcApproximator.cs b/osu.Game/Modes/Objects/CircularArcApproximator.cs
similarity index 96%
rename from osu.Game.Modes.Osu/Objects/CircularArcApproximator.cs
rename to osu.Game/Modes/Objects/CircularArcApproximator.cs
index 0f6f335279..af15f99e43 100644
--- a/osu.Game.Modes.Osu/Objects/CircularArcApproximator.cs
+++ b/osu.Game/Modes/Objects/CircularArcApproximator.cs
@@ -1,12 +1,12 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
-using osu.Framework.MathUtils;
 using System;
 using System.Collections.Generic;
+using osu.Framework.MathUtils;
+using OpenTK;
 
-namespace osu.Game.Modes.Osu.Objects
+namespace osu.Game.Modes.Objects
 {
     public class CircularArcApproximator
     {
diff --git a/osu.Game/Modes/Objects/CurvedHitObject.cs b/osu.Game/Modes/Objects/CurvedHitObject.cs
new file mode 100644
index 0000000000..ccb3d2497d
--- /dev/null
+++ b/osu.Game/Modes/Objects/CurvedHitObject.cs
@@ -0,0 +1,49 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+using osu.Game.Modes.Objects.Types;
+using System.Collections.Generic;
+
+namespace osu.Game.Modes.Objects
+{
+    public class CurvedHitObject : HitObject, IHasCurve
+    {
+        public SliderCurve Curve { get; } = new SliderCurve();
+
+        public int RepeatCount { get; set; } = 1;
+
+        public double EndTime => 0;
+        public double Duration => 0;
+
+        public List<Vector2> ControlPoints
+        {
+            get { return Curve.ControlPoints; }
+            set { Curve.ControlPoints = value; }
+        }
+
+        public CurveType CurveType
+        {
+            get { return Curve.CurveType; }
+            set { Curve.CurveType = value; }
+        }
+
+        public double Distance
+        {
+            get { return Curve.Distance; }
+            set { Curve.Distance = value; }
+        }
+
+        public Vector2 PositionAt(double progress) => Curve.PositionAt(ProgressAt(progress));
+
+        public double ProgressAt(double progress)
+        {
+            var p = progress * RepeatCount % 1;
+            if (RepeatAt(progress) % 2 == 1)
+                p = 1 - p;
+            return p;
+        }
+
+        public int RepeatAt(double progress) => (int)(progress * RepeatCount);
+    }
+}
diff --git a/osu.Game/Modes/Objects/Drawables/DrawableHitObject.cs b/osu.Game/Modes/Objects/Drawables/DrawableHitObject.cs
index fd728706cb..41c807ba9e 100644
--- a/osu.Game/Modes/Objects/Drawables/DrawableHitObject.cs
+++ b/osu.Game/Modes/Objects/Drawables/DrawableHitObject.cs
@@ -10,6 +10,7 @@ using osu.Framework.Audio.Sample;
 using osu.Game.Beatmaps.Samples;
 using osu.Game.Modes.Judgements;
 using Container = osu.Framework.Graphics.Containers.Container;
+using osu.Game.Modes.Objects.Types;
 
 namespace osu.Game.Modes.Objects.Drawables
 {
@@ -89,7 +90,9 @@ namespace osu.Game.Modes.Objects.Drawables
             if (Judgement.Result != null)
                 return false;
 
-            Judgement.TimeOffset = Time.Current - HitObject.EndTime;
+            double endTime = (HitObject as IHasEndTime)?.EndTime ?? HitObject.StartTime;
+
+            Judgement.TimeOffset = Time.Current - endTime;
 
             CheckJudgement(userTriggered);
 
diff --git a/osu.Game/Modes/Objects/HitObject.cs b/osu.Game/Modes/Objects/HitObject.cs
index eda6bc7e2a..e43702e2da 100644
--- a/osu.Game/Modes/Objects/HitObject.cs
+++ b/osu.Game/Modes/Objects/HitObject.cs
@@ -1,30 +1,26 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Samples;
-using OpenTK.Graphics;
 
 namespace osu.Game.Modes.Objects
 {
     /// <summary>
-    /// A hitobject describes a point in a beatmap 
+    /// A HitObject describes an object in a Beatmap.
+    /// <para>
+    /// HitObjects may contain more properties for which you should be checking through the IHas* types.
+    /// </para>
     /// </summary>
-    public abstract class HitObject
+    public class HitObject
     {
-        public double StartTime;
-        public virtual double EndTime => StartTime;
+        /// <summary>
+        /// The time at which the HitObject starts.
+        /// </summary>
+        public double StartTime { get; set; }
 
-        public bool NewCombo { get; set; }
-
-        public Color4 Colour = new Color4(17, 136, 170, 255);
-
-        public double Duration => EndTime - StartTime;
-
-        public HitSampleInfo Sample;
-
-        public int ComboIndex;
-
-        public virtual void SetDefaultsFromBeatmap(Beatmap beatmap) { }
+        /// <summary>
+        /// The sample to be played when this HitObject is hit.
+        /// </summary>
+        public HitSampleInfo Sample { get; set; }
     }
 }
diff --git a/osu.Game/Modes/Objects/Legacy/LegacyHit.cs b/osu.Game/Modes/Objects/Legacy/LegacyHit.cs
new file mode 100644
index 0000000000..239c8982da
--- /dev/null
+++ b/osu.Game/Modes/Objects/Legacy/LegacyHit.cs
@@ -0,0 +1,18 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Modes.Objects.Types;
+using OpenTK;
+
+namespace osu.Game.Modes.Objects.Legacy
+{
+    /// <summary>
+    /// Legacy Hit-type, used for parsing Beatmaps.
+    /// </summary>
+    public sealed class LegacyHit : HitObject, IHasPosition, IHasCombo
+    {
+        public Vector2 Position { get; set; }
+
+        public bool NewCombo { get; set; }
+    }
+}
diff --git a/osu.Game/Modes/Objects/Legacy/LegacyHitObjectType.cs b/osu.Game/Modes/Objects/Legacy/LegacyHitObjectType.cs
new file mode 100644
index 0000000000..416e1abe76
--- /dev/null
+++ b/osu.Game/Modes/Objects/Legacy/LegacyHitObjectType.cs
@@ -0,0 +1,18 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+
+namespace osu.Game.Modes.Objects.Legacy
+{
+    [Flags]
+    public enum LegacyHitObjectType
+    {
+        Circle = 1 << 0,
+        Slider = 1 << 1,
+        NewCombo = 1 << 2,
+        Spinner = 1 << 3,
+        ColourHax = 112,
+        Hold = 1 << 7
+    }
+}
\ No newline at end of file
diff --git a/osu.Game/Modes/Objects/Legacy/LegacyHold.cs b/osu.Game/Modes/Objects/Legacy/LegacyHold.cs
new file mode 100644
index 0000000000..4f858c16f1
--- /dev/null
+++ b/osu.Game/Modes/Objects/Legacy/LegacyHold.cs
@@ -0,0 +1,18 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+using osu.Game.Modes.Objects.Types;
+
+namespace osu.Game.Modes.Objects.Legacy
+{
+    /// <summary>
+    /// Legacy Hold-type, used for parsing "specials" in beatmaps.
+    /// </summary>
+    public sealed class LegacyHold : HitObject, IHasPosition, IHasCombo, IHasHold
+    {
+        public Vector2 Position { get; set; }
+
+        public bool NewCombo { get; set; }
+    }
+}
diff --git a/osu.Game/Modes/Objects/Legacy/LegacySlider.cs b/osu.Game/Modes/Objects/Legacy/LegacySlider.cs
new file mode 100644
index 0000000000..bdfebb1983
--- /dev/null
+++ b/osu.Game/Modes/Objects/Legacy/LegacySlider.cs
@@ -0,0 +1,18 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Modes.Objects.Types;
+using OpenTK;
+
+namespace osu.Game.Modes.Objects.Legacy
+{
+    /// <summary>
+    /// Legacy Slider-type, used for parsing Beatmaps.
+    /// </summary>
+    public sealed class LegacySlider : CurvedHitObject, IHasPosition, IHasCombo
+    {
+        public Vector2 Position { get; set; }
+
+        public bool NewCombo { get; set; }
+    }
+}
diff --git a/osu.Game/Modes/Objects/Legacy/LegacySpinner.cs b/osu.Game/Modes/Objects/Legacy/LegacySpinner.cs
new file mode 100644
index 0000000000..8f65d5e8a1
--- /dev/null
+++ b/osu.Game/Modes/Objects/Legacy/LegacySpinner.cs
@@ -0,0 +1,17 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Modes.Objects.Types;
+
+namespace osu.Game.Modes.Objects.Legacy
+{
+    /// <summary>
+    /// Legacy Spinner-type, used for parsing Beatmaps.
+    /// </summary>
+    internal class LegacySpinner : HitObject, IHasEndTime
+    {
+        public double EndTime { get; set; }
+
+        public double Duration => EndTime - StartTime;
+    }
+}
diff --git a/osu.Game/Modes/Objects/LegacyHitObjectParser.cs b/osu.Game/Modes/Objects/LegacyHitObjectParser.cs
new file mode 100644
index 0000000000..ccc5f18822
--- /dev/null
+++ b/osu.Game/Modes/Objects/LegacyHitObjectParser.cs
@@ -0,0 +1,119 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+using osu.Game.Beatmaps.Samples;
+using osu.Game.Modes.Objects.Types;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using osu.Game.Modes.Objects.Legacy;
+
+namespace osu.Game.Modes.Objects
+{
+    internal class LegacyHitObjectParser : HitObjectParser
+    {
+        public override HitObject Parse(string text)
+        {
+            string[] split = text.Split(',');
+            var type = (LegacyHitObjectType)int.Parse(split[3]) & ~LegacyHitObjectType.ColourHax;
+            bool combo = type.HasFlag(LegacyHitObjectType.NewCombo);
+            type &= ~LegacyHitObjectType.NewCombo;
+
+            HitObject result;
+
+            if ((type & LegacyHitObjectType.Circle) > 0)
+            {
+                result = new LegacyHit
+                {
+                    Position = new Vector2(int.Parse(split[0]), int.Parse(split[1])),
+                    NewCombo = combo
+                };
+            }
+            else if ((type & LegacyHitObjectType.Slider) > 0)
+            {
+                CurveType curveType = CurveType.Catmull;
+                double length = 0;
+                List<Vector2> points = new List<Vector2> { new Vector2(int.Parse(split[0]), int.Parse(split[1])) };
+
+                string[] pointsplit = split[5].Split('|');
+                foreach (string t in pointsplit)
+                {
+                    if (t.Length == 1)
+                    {
+                        switch (t)
+                        {
+                            case @"C":
+                                curveType = CurveType.Catmull;
+                                break;
+                            case @"B":
+                                curveType = CurveType.Bezier;
+                                break;
+                            case @"L":
+                                curveType = CurveType.Linear;
+                                break;
+                            case @"P":
+                                curveType = CurveType.PerfectCurve;
+                                break;
+                        }
+                        continue;
+                    }
+
+                    string[] temp = t.Split(':');
+                    Vector2 v = new Vector2(
+                        (int)Convert.ToDouble(temp[0], CultureInfo.InvariantCulture),
+                        (int)Convert.ToDouble(temp[1], CultureInfo.InvariantCulture)
+                    );
+                    points.Add(v);
+                }
+
+                int repeatCount = Convert.ToInt32(split[6], CultureInfo.InvariantCulture);
+
+                if (repeatCount > 9000)
+                    throw new ArgumentOutOfRangeException(nameof(repeatCount), @"Repeat count is way too high");
+
+                if (split.Length > 7)
+                    length = Convert.ToDouble(split[7], CultureInfo.InvariantCulture);
+
+                result = new LegacySlider
+                {
+                    ControlPoints = points,
+                    Distance = length,
+                    CurveType = curveType,
+                    RepeatCount = repeatCount,
+                    Position = new Vector2(int.Parse(split[0]), int.Parse(split[1])),
+                    NewCombo = combo
+                };
+            }
+            else if ((type & LegacyHitObjectType.Spinner) > 0)
+            {
+                result = new LegacySpinner
+                {
+                    EndTime = Convert.ToDouble(split[5], CultureInfo.InvariantCulture)
+                };
+            }
+            else if ((type & LegacyHitObjectType.Hold) > 0)
+            {
+                // Note: Hold is generated by BMS converts
+                result = new LegacyHold
+                {
+                    Position = new Vector2(int.Parse(split[0]), int.Parse(split[1])),
+                    NewCombo = combo
+                };
+            }
+            else
+                throw new InvalidOperationException($@"Unknown hit object type {type}");
+
+            result.StartTime = Convert.ToDouble(split[2], CultureInfo.InvariantCulture);
+            result.Sample = new HitSampleInfo
+            {
+                Type = (SampleType)int.Parse(split[4]),
+                Set = SampleSet.Soft,
+            };
+
+            // TODO: "addition" field
+
+            return result;
+        }
+    }
+}
diff --git a/osu.Game/Modes/Objects/NullHitObjectParser.cs b/osu.Game/Modes/Objects/NullHitObjectParser.cs
deleted file mode 100644
index fdec989632..0000000000
--- a/osu.Game/Modes/Objects/NullHitObjectParser.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-namespace osu.Game.Modes.Objects
-{
-    /// <summary>
-    /// Returns null HitObjects but at least allows us to run.
-    /// </summary>
-    public class NullHitObjectParser : HitObjectParser
-    {
-        public override HitObject Parse(string text) => null;
-    }
-}
diff --git a/osu.Game.Modes.Osu/Objects/SliderCurve.cs b/osu.Game/Modes/Objects/SliderCurve.cs
similarity index 92%
rename from osu.Game.Modes.Osu/Objects/SliderCurve.cs
rename to osu.Game/Modes/Objects/SliderCurve.cs
index 6c65e7fa37..8ab5097257 100644
--- a/osu.Game.Modes.Osu/Objects/SliderCurve.cs
+++ b/osu.Game/Modes/Objects/SliderCurve.cs
@@ -2,19 +2,20 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
-using OpenTK;
 using System.Linq;
 using osu.Framework.MathUtils;
+using osu.Game.Modes.Objects.Types;
+using OpenTK;
 
-namespace osu.Game.Modes.Osu.Objects
+namespace osu.Game.Modes.Objects
 {
     public class SliderCurve
     {
-        public double Length;
+        public double Distance;
 
         public List<Vector2> ControlPoints;
 
-        public CurveTypes CurveType = CurveTypes.PerfectCurve;
+        public CurveType CurveType = CurveType.PerfectCurve;
 
         public Vector2 Offset;
 
@@ -25,9 +26,9 @@ namespace osu.Game.Modes.Osu.Objects
         {
             switch (CurveType)
             {
-                case CurveTypes.Linear:
+                case CurveType.Linear:
                     return subControlPoints;
-                case CurveTypes.PerfectCurve:
+                case CurveType.PerfectCurve:
                     //we can only use CircularArc iff we have exactly three control points and no dissection.
                     if (ControlPoints.Count != 3 || subControlPoints.Count != 3)
                         break;
@@ -82,12 +83,12 @@ namespace osu.Game.Modes.Osu.Objects
 
                 // Shorten slider curves that are too long compared to what's
                 // in the .osu file.
-                if (Length - l < d)
+                if (Distance - l < d)
                 {
-                    calculatedPath[i + 1] = calculatedPath[i] + diff * (float)((Length - l) / d);
+                    calculatedPath[i + 1] = calculatedPath[i] + diff * (float)((Distance - l) / d);
                     calculatedPath.RemoveRange(i + 2, calculatedPath.Count - 2 - i);
 
-                    l = Length;
+                    l = Distance;
                     cumulativeLength.Add(l);
                     break;
                 }
@@ -129,7 +130,7 @@ namespace osu.Game.Modes.Osu.Objects
 
         private double progressToDistance(double progress)
         {
-            return MathHelper.Clamp(progress, 0, 1) * Length;
+            return MathHelper.Clamp(progress, 0, 1) * Distance;
         }
 
         private Vector2 interpolateVertices(int i, double d)
diff --git a/osu.Game/Modes/Objects/Types/CurveType.cs b/osu.Game/Modes/Objects/Types/CurveType.cs
new file mode 100644
index 0000000000..ba5d3f37ac
--- /dev/null
+++ b/osu.Game/Modes/Objects/Types/CurveType.cs
@@ -0,0 +1,13 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Modes.Objects.Types
+{
+    public enum CurveType
+    {
+        Catmull,
+        Bezier,
+        Linear,
+        PerfectCurve
+    }
+}
diff --git a/osu.Game/Modes/Objects/Types/IHasCombo.cs b/osu.Game/Modes/Objects/Types/IHasCombo.cs
new file mode 100644
index 0000000000..1ca381372d
--- /dev/null
+++ b/osu.Game/Modes/Objects/Types/IHasCombo.cs
@@ -0,0 +1,16 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Modes.Objects.Types
+{
+    /// <summary>
+    /// A HitObject that is part of a combo.
+    /// </summary>
+    public interface IHasCombo
+    {
+        /// <summary>
+        /// Whether the HitObject starts a new combo.
+        /// </summary>
+        bool NewCombo { get; }
+    }
+}
diff --git a/osu.Game/Modes/Objects/Types/IHasCurve.cs b/osu.Game/Modes/Objects/Types/IHasCurve.cs
new file mode 100644
index 0000000000..0db799a15f
--- /dev/null
+++ b/osu.Game/Modes/Objects/Types/IHasCurve.cs
@@ -0,0 +1,52 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using OpenTK;
+
+namespace osu.Game.Modes.Objects.Types
+{
+    /// <summary>
+    /// A HitObject that has a curve.
+    /// </summary>
+    public interface IHasCurve : IHasDistance, IHasRepeats
+    {
+        /// <summary>
+        /// The curve.
+        /// </summary>
+        SliderCurve Curve { get; }
+
+        /// <summary>
+        /// The control points that shape the curve.
+        /// </summary>
+        List<Vector2> ControlPoints { get; }
+
+        /// <summary>
+        /// The type of curve.
+        /// </summary>
+        CurveType CurveType { get; }
+
+        /// <summary>
+        /// Computes the position on the curve at a given progress, accounting for repeat logic.
+        /// <para>
+        /// Ranges from [0, 1] where 0 is the beginning of the curve and 1 is the end of the curve.
+        /// </para>
+        /// </summary>
+        /// <param name="progress">[0, 1] where 0 is the beginning of the curve and 1 is the end of the curve.</param>
+        Vector2 PositionAt(double progress);
+
+        /// <summary>
+        /// Finds the progress along the curve, accounting for repeat logic.
+        /// </summary>
+        /// <param name="progress">[0, 1] where 0 is the beginning of the curve and 1 is the end of the curve.</param>
+        /// <returns>[0, 1] where 0 is the beginning of the curve and 1 is the end of the curve.</returns>
+        double ProgressAt(double progress);
+
+        /// <summary>
+        /// Determines which repeat of the curve the progress point is on.
+        /// </summary>
+        /// <param name="progress">[0, 1] where 0 is the beginning of the curve and 1 is the end of the curve.</param>
+        /// <returns>[0, RepeatCount] where 0 is the first run.</returns>
+        int RepeatAt(double progress);
+    }
+}
diff --git a/osu.Game/Modes/Objects/Types/IHasDistance.cs b/osu.Game/Modes/Objects/Types/IHasDistance.cs
new file mode 100644
index 0000000000..87863e64e6
--- /dev/null
+++ b/osu.Game/Modes/Objects/Types/IHasDistance.cs
@@ -0,0 +1,16 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Modes.Objects.Types
+{
+    /// <summary>
+    /// A HitObject that has a positional length.
+    /// </summary>
+    public interface IHasDistance : IHasEndTime
+    {
+        /// <summary>
+        /// The positional length of the HitObject.
+        /// </summary>
+        double Distance { get; }
+    }
+}
diff --git a/osu.Game/Modes/Objects/Types/IHasEndTime.cs b/osu.Game/Modes/Objects/Types/IHasEndTime.cs
new file mode 100644
index 0000000000..e96258812c
--- /dev/null
+++ b/osu.Game/Modes/Objects/Types/IHasEndTime.cs
@@ -0,0 +1,21 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Modes.Objects.Types
+{
+    /// <summary>
+    /// A HitObject that ends at a different time than its start time.
+    /// </summary>
+    public interface IHasEndTime
+    {
+        /// <summary>
+        /// The time at which the HitObject ends.
+        /// </summary>
+        double EndTime { get; }
+
+        /// <summary>
+        /// The duration of the HitObject.
+        /// </summary>
+        double Duration { get; }
+    }
+}
diff --git a/osu.Game/Modes/Objects/Types/IHasHold.cs b/osu.Game/Modes/Objects/Types/IHasHold.cs
new file mode 100644
index 0000000000..b9f4939091
--- /dev/null
+++ b/osu.Game/Modes/Objects/Types/IHasHold.cs
@@ -0,0 +1,12 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Modes.Objects.Types
+{
+    /// <summary>
+    /// A special type of HitObject, mostly used for legacy conversion of "holds".
+    /// </summary>
+    public interface IHasHold
+    {
+    }
+}
diff --git a/osu.Game/Modes/Objects/Types/IHasPosition.cs b/osu.Game/Modes/Objects/Types/IHasPosition.cs
new file mode 100644
index 0000000000..8138bf6662
--- /dev/null
+++ b/osu.Game/Modes/Objects/Types/IHasPosition.cs
@@ -0,0 +1,18 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+
+namespace osu.Game.Modes.Objects.Types
+{
+    /// <summary>
+    /// A HitObject that has a starting position.
+    /// </summary>
+    public interface IHasPosition
+    {
+        /// <summary>
+        /// The starting position of the HitObject.
+        /// </summary>
+        Vector2 Position { get; }
+    }
+}
diff --git a/osu.Game/Modes/Objects/Types/IHasRepeats.cs b/osu.Game/Modes/Objects/Types/IHasRepeats.cs
new file mode 100644
index 0000000000..a34774d0ef
--- /dev/null
+++ b/osu.Game/Modes/Objects/Types/IHasRepeats.cs
@@ -0,0 +1,16 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Modes.Objects.Types
+{
+    /// <summary>
+    /// A HitObject that spans some length.
+    /// </summary>
+    public interface IHasRepeats : IHasEndTime
+    {
+        /// <summary>
+        /// The amount of times the HitObject repeats.
+        /// </summary>
+        int RepeatCount { get; }
+    }
+}
diff --git a/osu.Game/Modes/Ruleset.cs b/osu.Game/Modes/Ruleset.cs
index 5c599c2f2a..8cbfa3fa46 100644
--- a/osu.Game/Modes/Ruleset.cs
+++ b/osu.Game/Modes/Ruleset.cs
@@ -4,7 +4,6 @@
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Modes.Mods;
-using osu.Game.Modes.Objects;
 using osu.Game.Modes.UI;
 using osu.Game.Screens.Play;
 using System;
@@ -34,8 +33,6 @@ namespace osu.Game.Modes
 
         public abstract HitRenderer CreateHitRendererWith(WorkingBeatmap beatmap);
 
-        public abstract HitObjectParser CreateHitObjectParser();
-
         public abstract DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap);
 
         public static void Register(Ruleset ruleset) => availableRulesets.TryAdd(ruleset.PlayMode, ruleset.GetType());
diff --git a/osu.Game/Modes/UI/HitRenderer.cs b/osu.Game/Modes/UI/HitRenderer.cs
index e962ec53bd..54f591b317 100644
--- a/osu.Game/Modes/UI/HitRenderer.cs
+++ b/osu.Game/Modes/UI/HitRenderer.cs
@@ -11,6 +11,7 @@ using osu.Game.Modes.Objects.Drawables;
 using osu.Game.Screens.Play;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using osu.Game.Modes.Judgements;
 
@@ -86,7 +87,12 @@ namespace osu.Game.Modes.UI
 
         protected HitRenderer(WorkingBeatmap beatmap)
         {
+            Debug.Assert(beatmap != null, "HitRenderer initialized with a null beatmap.");
+
+            // Convert + process the beatmap
             Beatmap = CreateBeatmapConverter().Convert(beatmap.Beatmap);
+            Beatmap.HitObjects.ForEach(h => CreateBeatmapProcessor().SetDefaults(h, Beatmap));
+            CreateBeatmapProcessor().PostProcess(Beatmap);
 
             applyMods(beatmap.Mods.Value);
 
diff --git a/osu.Game/Screens/Select/BeatmapInfoWedge.cs b/osu.Game/Screens/Select/BeatmapInfoWedge.cs
index 3add709c5f..f82c35598a 100644
--- a/osu.Game/Screens/Select/BeatmapInfoWedge.cs
+++ b/osu.Game/Screens/Select/BeatmapInfoWedge.cs
@@ -21,6 +21,8 @@ using osu.Game.Database;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Modes;
+using osu.Game.Modes.Objects;
+using osu.Game.Modes.Objects.Types;
 
 namespace osu.Game.Screens.Select
 {
@@ -90,11 +92,14 @@ namespace osu.Game.Screens.Select
 
             if (beatmap.Beatmap != null)
             {
+                HitObject lastObject = beatmap.Beatmap.HitObjects.LastOrDefault();
+                double endTime = (lastObject as IHasEndTime)?.EndTime ?? lastObject?.StartTime ?? 0;
+
                 labels.Add(new InfoLabel(new BeatmapStatistic
                 {
                     Name = "Length",
                     Icon = FontAwesome.fa_clock_o,
-                    Content = beatmap.Beatmap.HitObjects.Count == 0 ? "-" : TimeSpan.FromMilliseconds(beatmap.Beatmap.HitObjects.Last().EndTime - beatmap.Beatmap.HitObjects.First().StartTime).ToString(@"m\:ss"),
+                    Content = beatmap.Beatmap.HitObjects.Count == 0 ? "-" : TimeSpan.FromMilliseconds(endTime - beatmap.Beatmap.HitObjects.First().StartTime).ToString(@"m\:ss"),
                 }));
 
                 labels.Add(new InfoLabel(new BeatmapStatistic
diff --git a/osu.Game/osu.Game.csproj b/osu.Game/osu.Game.csproj
index d2cf09bde4..3ec8b535c7 100644
--- a/osu.Game/osu.Game.csproj
+++ b/osu.Game/osu.Game.csproj
@@ -74,6 +74,7 @@
     <Compile Include="Beatmaps\Drawables\BeatmapBackgroundSprite.cs" />
     <Compile Include="Beatmaps\DifficultyCalculator.cs" />
     <Compile Include="Beatmaps\IBeatmapCoverter.cs" />
+    <Compile Include="Beatmaps\IBeatmapProcessor.cs" />
     <Compile Include="Database\ScoreDatabase.cs" />
     <Compile Include="Graphics\Backgrounds\Triangles.cs" />
     <Compile Include="Graphics\Cursor\CursorTrail.cs" />
@@ -95,10 +96,27 @@
     <Compile Include="Modes\Mods\ModType.cs" />
     <Compile Include="Modes\Objects\Drawables\ArmedState.cs" />
     <Compile Include="Modes\Objects\Drawables\HitResult.cs" />
+    <Compile Include="Modes\Objects\BezierApproximator.cs" />
+    <Compile Include="Modes\Objects\CircularArcApproximator.cs" />
+    <Compile Include="Modes\Objects\CurvedHitObject.cs" />
+    <Compile Include="Modes\Objects\Legacy\LegacyHit.cs" />
+    <Compile Include="Modes\Objects\LegacyHitObjectParser.cs" />
+    <Compile Include="Modes\Objects\Legacy\LegacyHold.cs" />
+    <Compile Include="Modes\Objects\Legacy\LegacySlider.cs" />
+    <Compile Include="Modes\Objects\Legacy\LegacySpinner.cs" />
+    <Compile Include="Modes\Objects\SliderCurve.cs" />
+    <Compile Include="Modes\Objects\Types\CurveType.cs" />
     <Compile Include="Modes\Objects\Drawables\IDrawableHitObjectWithProxiedApproach.cs" />
     <Compile Include="Modes\Judgements\JudgementInfo.cs" />
     <Compile Include="Modes\Objects\HitObjectParser.cs" />
-    <Compile Include="Modes\Objects\NullHitObjectParser.cs" />
+    <Compile Include="Modes\Objects\Types\IHasCombo.cs" />
+    <Compile Include="Modes\Objects\Types\IHasEndTime.cs" />
+    <Compile Include="Modes\Objects\Types\IHasDistance.cs" />
+    <Compile Include="Modes\Objects\Types\IHasCurve.cs" />
+    <Compile Include="Modes\Objects\Types\IHasRepeats.cs" />
+    <Compile Include="Modes\Objects\Types\IHasPosition.cs" />
+    <Compile Include="Modes\Objects\Types\IHasHold.cs" />
+    <Compile Include="Modes\Objects\Legacy\LegacyHitObjectType.cs" />
     <Compile Include="Modes\Replay.cs" />
     <Compile Include="Modes\Score.cs" />
     <Compile Include="Modes\ScoreProcesssor.cs" />