diff --git a/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs b/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs
index 27a9b63e9a..0de2060e2d 100644
--- a/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs
+++ b/osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs
@@ -42,7 +42,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                         LegacyLastTickOffset = (obj as IHasLegacyLastTickOffset)?.LegacyLastTickOffset ?? 0
                     }.Yield();
 
-                case IHasEndTime endTime:
+                case IHasDuration endTime:
                     return new BananaShower
                     {
                         StartTime = obj.StartTime,
diff --git a/osu.Game.Rulesets.Catch/Objects/BananaShower.cs b/osu.Game.Rulesets.Catch/Objects/BananaShower.cs
index 3a0b5ace53..04a995c77e 100644
--- a/osu.Game.Rulesets.Catch/Objects/BananaShower.cs
+++ b/osu.Game.Rulesets.Catch/Objects/BananaShower.cs
@@ -7,7 +7,7 @@ using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Rulesets.Catch.Objects
 {
-    public class BananaShower : CatchHitObject, IHasEndTime
+    public class BananaShower : CatchHitObject, IHasDuration
     {
         public override FruitVisualRepresentation VisualRepresentation => FruitVisualRepresentation.Banana;
 
diff --git a/osu.Game.Rulesets.Catch/Objects/JuiceStream.cs b/osu.Game.Rulesets.Catch/Objects/JuiceStream.cs
index 24090e233a..2c96ee2b19 100644
--- a/osu.Game.Rulesets.Catch/Objects/JuiceStream.cs
+++ b/osu.Game.Rulesets.Catch/Objects/JuiceStream.cs
@@ -115,15 +115,15 @@ namespace osu.Game.Rulesets.Catch.Objects
             }
         }
 
-        public double EndTime
+        public float EndX => X + this.CurvePositionAt(1).X / CatchPlayfield.BASE_WIDTH;
+
+        public double Duration
         {
-            get => StartTime + this.SpanCount() * Path.Distance / Velocity;
+            get => this.SpanCount() * Path.Distance / Velocity;
             set => throw new System.NotSupportedException($"Adjust via {nameof(RepeatCount)} instead"); // can be implemented if/when needed.
         }
 
-        public float EndX => X + this.CurvePositionAt(1).X / CatchPlayfield.BASE_WIDTH;
-
-        public double Duration => EndTime - StartTime;
+        public double EndTime => StartTime + Duration;
 
         private readonly SliderPath path = new SliderPath();
 
diff --git a/osu.Game.Rulesets.Mania.Tests/TestSceneNotes.cs b/osu.Game.Rulesets.Mania.Tests/TestSceneNotes.cs
index ea6a1e2e6a..dd5fd93710 100644
--- a/osu.Game.Rulesets.Mania.Tests/TestSceneNotes.cs
+++ b/osu.Game.Rulesets.Mania.Tests/TestSceneNotes.cs
@@ -156,7 +156,7 @@ namespace osu.Game.Rulesets.Mania.Tests
 
                 foreach (var obj in content.OfType<DrawableHitObject>())
                 {
-                    if (!(obj.HitObject is IHasEndTime endTime))
+                    if (!(obj.HitObject is IHasDuration endTime))
                         continue;
 
                     foreach (var nested in obj.NestedHitObjects)
diff --git a/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs b/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs
index 1c8116754f..32abf5e7f9 100644
--- a/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs
+++ b/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs
@@ -54,7 +54,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             }
             else
             {
-                float percentSliderOrSpinner = (float)beatmap.HitObjects.Count(h => h is IHasEndTime) / beatmap.HitObjects.Count;
+                float percentSliderOrSpinner = (float)beatmap.HitObjects.Count(h => h is IHasDuration) / beatmap.HitObjects.Count;
                 if (percentSliderOrSpinner < 0.2)
                     TargetColumns = 7;
                 else if (percentSliderOrSpinner < 0.3 || roundedCircleSize >= 5)
@@ -175,7 +175,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
                     break;
                 }
 
-                case IHasEndTime endTimeData:
+                case IHasDuration endTimeData:
                 {
                     conversion = new EndTimeObjectPatternGenerator(Random, original, beatmap, originalBeatmap);
 
@@ -231,7 +231,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
                 var pattern = new Pattern();
 
-                if (HitObject is IHasEndTime endTimeData)
+                if (HitObject is IHasDuration endTimeData)
                 {
                     pattern.Add(new HoldNote
                     {
diff --git a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/EndTimeObjectPatternGenerator.cs b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/EndTimeObjectPatternGenerator.cs
index 907bed0d65..d5286a3779 100644
--- a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/EndTimeObjectPatternGenerator.cs
+++ b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/EndTimeObjectPatternGenerator.cs
@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         public EndTimeObjectPatternGenerator(FastRandom random, HitObject hitObject, ManiaBeatmap beatmap, IBeatmap originalBeatmap)
             : base(random, hitObject, beatmap, new Pattern(), originalBeatmap)
         {
-            endTime = (HitObject as IHasEndTime)?.EndTime ?? 0;
+            endTime = (HitObject as IHasDuration)?.EndTime ?? 0;
         }
 
         public override IEnumerable<Pattern> Generate()
diff --git a/osu.Game.Rulesets.Mania/Objects/HoldNote.cs b/osu.Game.Rulesets.Mania/Objects/HoldNote.cs
index e6f722a8a9..a100c9a58e 100644
--- a/osu.Game.Rulesets.Mania/Objects/HoldNote.cs
+++ b/osu.Game.Rulesets.Mania/Objects/HoldNote.cs
@@ -15,7 +15,7 @@ namespace osu.Game.Rulesets.Mania.Objects
     /// <summary>
     /// Represents a hit object which requires pressing, holding, and releasing a key.
     /// </summary>
-    public class HoldNote : ManiaHitObject, IHasEndTime
+    public class HoldNote : ManiaHitObject, IHasDuration
     {
         public double EndTime
         {
diff --git a/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapConverter.cs b/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapConverter.cs
index 060a3919bd..fcad356a1c 100644
--- a/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapConverter.cs
+++ b/osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapConverter.cs
@@ -46,7 +46,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                         TickDistanceMultiplier = beatmap.BeatmapInfo.BeatmapVersion < 8 ? 1f / beatmap.ControlPointInfo.DifficultyPointAt(original.StartTime).SpeedMultiplier : 1
                     }.Yield();
 
-                case IHasEndTime endTimeData:
+                case IHasDuration endTimeData:
                     return new Spinner
                     {
                         StartTime = original.StartTime,
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModRelax.cs b/osu.Game.Rulesets.Osu/Mods/OsuModRelax.cs
index 7b1941b7f9..5d191119b9 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModRelax.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModRelax.cs
@@ -70,7 +70,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                     break;
 
                 // already hit or beyond the hittable end time.
-                if (h.IsHit || (h.HitObject is IHasEndTime hasEnd && time > hasEnd.EndTime))
+                if (h.IsHit || (h.HitObject is IHasDuration hasEnd && time > hasEnd.EndTime))
                     continue;
 
                 switch (h)
diff --git a/osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs b/osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs
index 297a0fea79..3cad52faeb 100644
--- a/osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs
+++ b/osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs
@@ -61,7 +61,7 @@ namespace osu.Game.Rulesets.Osu.Mods
             }
 
             // Keep wiggling sliders and spinners for their duration
-            if (!(osuObject is IHasEndTime endTime))
+            if (!(osuObject is IHasDuration endTime))
                 return;
 
             amountWiggles = (int)(endTime.Duration / wiggle_duration);
diff --git a/osu.Game.Rulesets.Osu/Objects/Slider.cs b/osu.Game.Rulesets.Osu/Objects/Slider.cs
index 713d1a61f8..705e88040f 100644
--- a/osu.Game.Rulesets.Osu/Objects/Slider.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Slider.cs
@@ -19,14 +19,14 @@ namespace osu.Game.Rulesets.Osu.Objects
 {
     public class Slider : OsuHitObject, IHasPathWithRepeats
     {
-        public double EndTime
+        public double EndTime => StartTime + this.SpanCount() * Path.Distance / Velocity;
+
+        public double Duration
         {
-            get => StartTime + this.SpanCount() * Path.Distance / Velocity;
+            get => EndTime - StartTime;
             set => throw new System.NotSupportedException($"Adjust via {nameof(RepeatCount)} instead"); // can be implemented if/when needed.
         }
 
-        public double Duration => EndTime - StartTime;
-
         private readonly Cached<Vector2> endPositionCache = new Cached<Vector2>();
 
         public override Vector2 EndPosition => endPositionCache.IsValid ? endPositionCache.Value : endPositionCache.Value = Position + this.CurvePositionAt(1);
diff --git a/osu.Game.Rulesets.Osu/Objects/Spinner.cs b/osu.Game.Rulesets.Osu/Objects/Spinner.cs
index 0b8d03d118..418375c090 100644
--- a/osu.Game.Rulesets.Osu/Objects/Spinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Spinner.cs
@@ -11,7 +11,7 @@ using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
-    public class Spinner : OsuHitObject, IHasEndTime
+    public class Spinner : OsuHitObject, IHasDuration
     {
         public double EndTime
         {
diff --git a/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs b/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs
index 1a47be2282..78550ed270 100644
--- a/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs
+++ b/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs
@@ -150,7 +150,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                     break;
                 }
 
-                case IHasEndTime endTimeData:
+                case IHasDuration endTimeData:
                 {
                     double hitMultiplier = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty, 3, 5, 7.5) * swell_hit_multiplier;
 
diff --git a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwell.cs b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwell.cs
index 32f7acadc8..7294587b10 100644
--- a/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwell.cs
+++ b/osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableSwell.cs
@@ -237,7 +237,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
                 case ArmedState.Miss:
                 case ArmedState.Hit:
-                    using (BeginAbsoluteSequence(Time.Current, true))
+                    using (BeginDelayedSequence(HitObject.Duration, true))
                     {
                         this.FadeOut(transition_duration, Easing.Out);
                         bodyContainer.ScaleTo(1.4f, transition_duration);
diff --git a/osu.Game.Rulesets.Taiko/Objects/Swell.cs b/osu.Game.Rulesets.Taiko/Objects/Swell.cs
index 390f8d1f3b..8a63a89951 100644
--- a/osu.Game.Rulesets.Taiko/Objects/Swell.cs
+++ b/osu.Game.Rulesets.Taiko/Objects/Swell.cs
@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Taiko.Judgements;
 
 namespace osu.Game.Rulesets.Taiko.Objects
 {
-    public class Swell : TaikoHitObject, IHasEndTime
+    public class Swell : TaikoHitObject, IHasDuration
     {
         public double EndTime
         {
diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneDrawableScrollingRuleset.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneDrawableScrollingRuleset.cs
index b25b81c9af..bd7e894cf8 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneDrawableScrollingRuleset.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneDrawableScrollingRuleset.cs
@@ -281,7 +281,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                 yield return new TestHitObject
                 {
                     StartTime = original.StartTime,
-                    EndTime = (original as IHasEndTime)?.EndTime ?? (original.StartTime + 100)
+                    Duration = (original as IHasDuration)?.Duration ?? 100
                 };
             }
         }
@@ -290,11 +290,11 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         #region HitObject
 
-        private class TestHitObject : ConvertHitObject, IHasEndTime
+        private class TestHitObject : ConvertHitObject, IHasDuration
         {
-            public double EndTime { get; set; }
+            public double EndTime => StartTime + Duration;
 
-            public double Duration => EndTime - StartTime;
+            public double Duration { get; set; }
         }
 
         private class DrawableTestHitObject : DrawableHitObject<TestHitObject>
diff --git a/osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs b/osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs
index ab1b8aecfd..cefb47893c 100644
--- a/osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs
+++ b/osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs
@@ -240,7 +240,7 @@ namespace osu.Game.Beatmaps.Formats
             }
             else
             {
-                if (hitObject is IHasEndTime)
+                if (hitObject is IHasDuration)
                     addEndTimeData(writer, hitObject);
 
                 writer.Write(getSampleBank(hitObject.Samples));
@@ -267,7 +267,7 @@ namespace osu.Game.Beatmaps.Formats
                     type |= LegacyHitObjectType.Slider;
                     break;
 
-                case IHasEndTime _:
+                case IHasDuration _:
                     if (beatmap.BeatmapInfo.RulesetID == 3)
                         type |= LegacyHitObjectType.Hold;
                     else
@@ -352,7 +352,7 @@ namespace osu.Game.Beatmaps.Formats
 
         private void addEndTimeData(TextWriter writer, HitObject hitObject)
         {
-            var endTimeData = (IHasEndTime)hitObject;
+            var endTimeData = (IHasDuration)hitObject;
             var type = getObjectType(hitObject);
 
             char suffix = ',';
diff --git a/osu.Game/Beatmaps/WorkingBeatmap.cs b/osu.Game/Beatmaps/WorkingBeatmap.cs
index 8126311cbd..ac399e37c4 100644
--- a/osu.Game/Beatmaps/WorkingBeatmap.cs
+++ b/osu.Game/Beatmaps/WorkingBeatmap.cs
@@ -63,7 +63,7 @@ namespace osu.Game.Beatmaps
                     length = emptyLength;
                     break;
 
-                case IHasEndTime endTime:
+                case IHasDuration endTime:
                     length = endTime.EndTime + excess_length;
                     break;
 
diff --git a/osu.Game/Rulesets/Objects/HitObject.cs b/osu.Game/Rulesets/Objects/HitObject.cs
index 6f9053d7cb..e2cc98813a 100644
--- a/osu.Game/Rulesets/Objects/HitObject.cs
+++ b/osu.Game/Rulesets/Objects/HitObject.cs
@@ -175,10 +175,10 @@ namespace osu.Game.Rulesets.Objects
         /// Returns the end time of this object.
         /// </summary>
         /// <remarks>
-        /// This returns the <see cref="IHasEndTime.EndTime"/> where available, falling back to <see cref="HitObject.StartTime"/> otherwise.
+        /// This returns the <see cref="IHasDuration.EndTime"/> where available, falling back to <see cref="HitObject.StartTime"/> otherwise.
         /// </remarks>
         /// <param name="hitObject">The object.</param>
         /// <returns>The end time of this object.</returns>
-        public static double GetEndTime(this HitObject hitObject) => (hitObject as IHasEndTime)?.EndTime ?? hitObject.StartTime;
+        public static double GetEndTime(this HitObject hitObject) => (hitObject as IHasDuration)?.EndTime ?? hitObject.StartTime;
     }
 }
diff --git a/osu.Game/Rulesets/Objects/Legacy/Catch/ConvertHitObjectParser.cs b/osu.Game/Rulesets/Objects/Legacy/Catch/ConvertHitObjectParser.cs
index 43e8d01297..c10c8dc30f 100644
--- a/osu.Game/Rulesets/Objects/Legacy/Catch/ConvertHitObjectParser.cs
+++ b/osu.Game/Rulesets/Objects/Legacy/Catch/ConvertHitObjectParser.cs
@@ -56,7 +56,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Catch
             };
         }
 
-        protected override HitObject CreateSpinner(Vector2 position, bool newCombo, int comboOffset, double endTime)
+        protected override HitObject CreateSpinner(Vector2 position, bool newCombo, int comboOffset, double duration)
         {
             // Convert spinners don't create the new combo themselves, but force the next non-spinner hitobject to create a new combo
             // Their combo offset is still added to that next hitobject's combo index
@@ -65,11 +65,11 @@ namespace osu.Game.Rulesets.Objects.Legacy.Catch
 
             return new ConvertSpinner
             {
-                EndTime = endTime
+                Duration = duration
             };
         }
 
-        protected override HitObject CreateHold(Vector2 position, bool newCombo, int comboOffset, double endTime)
+        protected override HitObject CreateHold(Vector2 position, bool newCombo, int comboOffset, double duration)
         {
             return null;
         }
diff --git a/osu.Game/Rulesets/Objects/Legacy/Catch/ConvertSpinner.cs b/osu.Game/Rulesets/Objects/Legacy/Catch/ConvertSpinner.cs
index 9de311c9d7..014494ec54 100644
--- a/osu.Game/Rulesets/Objects/Legacy/Catch/ConvertSpinner.cs
+++ b/osu.Game/Rulesets/Objects/Legacy/Catch/ConvertSpinner.cs
@@ -8,11 +8,11 @@ namespace osu.Game.Rulesets.Objects.Legacy.Catch
     /// <summary>
     /// Legacy osu!catch Spinner-type, used for parsing Beatmaps.
     /// </summary>
-    internal sealed class ConvertSpinner : ConvertHitObject, IHasEndTime, IHasXPosition, IHasCombo
+    internal sealed class ConvertSpinner : ConvertHitObject, IHasDuration, IHasXPosition, IHasCombo
     {
-        public double EndTime { get; set; }
+        public double EndTime => StartTime + Duration;
 
-        public double Duration => EndTime - StartTime;
+        public double Duration { get; set; }
 
         public float X => 256; // Required for CatchBeatmapConverter
 
diff --git a/osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs b/osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs
index 9a60a0a75c..9e936c7717 100644
--- a/osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs
+++ b/osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs
@@ -189,9 +189,9 @@ namespace osu.Game.Rulesets.Objects.Legacy
             }
             else if (type.HasFlag(LegacyHitObjectType.Spinner))
             {
-                double endTime = Math.Max(startTime, Parsing.ParseDouble(split[5]) + Offset);
+                double duration = Math.Max(0, Parsing.ParseDouble(split[5]) + Offset - startTime);
 
-                result = CreateSpinner(new Vector2(512, 384) / 2, combo, comboOffset, endTime);
+                result = CreateSpinner(new Vector2(512, 384) / 2, combo, comboOffset, duration);
 
                 if (split.Length > 6)
                     readCustomSampleBanks(split[6], bankInfo);
@@ -209,7 +209,7 @@ namespace osu.Game.Rulesets.Objects.Legacy
                     readCustomSampleBanks(string.Join(":", ss.Skip(1)), bankInfo);
                 }
 
-                result = CreateHold(pos, combo, comboOffset, endTime + Offset);
+                result = CreateHold(pos, combo, comboOffset, endTime + Offset - startTime);
             }
 
             if (result == null)
@@ -321,9 +321,9 @@ namespace osu.Game.Rulesets.Objects.Legacy
         /// <param name="position">The position of the hit object.</param>
         /// <param name="newCombo">Whether the hit object creates a new combo.</param>
         /// <param name="comboOffset">When starting a new combo, the offset of the new combo relative to the current one.</param>
-        /// <param name="endTime">The spinner end time.</param>
+        /// <param name="duration">The spinner duration.</param>
         /// <returns>The hit object.</returns>
-        protected abstract HitObject CreateSpinner(Vector2 position, bool newCombo, int comboOffset, double endTime);
+        protected abstract HitObject CreateSpinner(Vector2 position, bool newCombo, int comboOffset, double duration);
 
         /// <summary>
         /// Creates a legacy Hold-type hit object.
@@ -331,8 +331,8 @@ namespace osu.Game.Rulesets.Objects.Legacy
         /// <param name="position">The position of the hit object.</param>
         /// <param name="newCombo">Whether the hit object creates a new combo.</param>
         /// <param name="comboOffset">When starting a new combo, the offset of the new combo relative to the current one.</param>
-        /// <param name="endTime">The hold end time.</param>
-        protected abstract HitObject CreateHold(Vector2 position, bool newCombo, int comboOffset, double endTime);
+        /// <param name="duration">The hold duration.</param>
+        protected abstract HitObject CreateHold(Vector2 position, bool newCombo, int comboOffset, double duration);
 
         private List<HitSampleInfo> convertSoundType(LegacyHitSoundType type, SampleBankInfo bankInfo)
         {
diff --git a/osu.Game/Rulesets/Objects/Legacy/ConvertSlider.cs b/osu.Game/Rulesets/Objects/Legacy/ConvertSlider.cs
index c946e43df3..c522dc623c 100644
--- a/osu.Game/Rulesets/Objects/Legacy/ConvertSlider.cs
+++ b/osu.Game/Rulesets/Objects/Legacy/ConvertSlider.cs
@@ -29,13 +29,13 @@ namespace osu.Game.Rulesets.Objects.Legacy
         public List<IList<HitSampleInfo>> NodeSamples { get; set; }
         public int RepeatCount { get; set; }
 
-        public double EndTime
+        public double Duration
         {
-            get => StartTime + this.SpanCount() * Distance / Velocity;
+            get => this.SpanCount() * Distance / Velocity;
             set => throw new System.NotSupportedException($"Adjust via {nameof(RepeatCount)} instead"); // can be implemented if/when needed.
         }
 
-        public double Duration => EndTime - StartTime;
+        public double EndTime => StartTime + Duration;
 
         public double Velocity = 1;
 
diff --git a/osu.Game/Rulesets/Objects/Legacy/Mania/ConvertHitObjectParser.cs b/osu.Game/Rulesets/Objects/Legacy/Mania/ConvertHitObjectParser.cs
index f94c4aaa75..bc64518f40 100644
--- a/osu.Game/Rulesets/Objects/Legacy/Mania/ConvertHitObjectParser.cs
+++ b/osu.Game/Rulesets/Objects/Legacy/Mania/ConvertHitObjectParser.cs
@@ -37,21 +37,21 @@ namespace osu.Game.Rulesets.Objects.Legacy.Mania
             };
         }
 
-        protected override HitObject CreateSpinner(Vector2 position, bool newCombo, int comboOffset, double endTime)
+        protected override HitObject CreateSpinner(Vector2 position, bool newCombo, int comboOffset, double duration)
         {
             return new ConvertSpinner
             {
                 X = position.X,
-                EndTime = endTime
+                Duration = duration
             };
         }
 
-        protected override HitObject CreateHold(Vector2 position, bool newCombo, int comboOffset, double endTime)
+        protected override HitObject CreateHold(Vector2 position, bool newCombo, int comboOffset, double duration)
         {
             return new ConvertHold
             {
                 X = position.X,
-                EndTime = endTime
+                Duration = duration
             };
         }
     }
diff --git a/osu.Game/Rulesets/Objects/Legacy/Mania/ConvertHold.cs b/osu.Game/Rulesets/Objects/Legacy/Mania/ConvertHold.cs
index 1d92d638dd..2fa4766c1d 100644
--- a/osu.Game/Rulesets/Objects/Legacy/Mania/ConvertHold.cs
+++ b/osu.Game/Rulesets/Objects/Legacy/Mania/ConvertHold.cs
@@ -5,12 +5,12 @@ using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Rulesets.Objects.Legacy.Mania
 {
-    internal sealed class ConvertHold : ConvertHitObject, IHasXPosition, IHasEndTime
+    internal sealed class ConvertHold : ConvertHitObject, IHasXPosition, IHasDuration
     {
         public float X { get; set; }
 
-        public double EndTime { get; set; }
+        public double Duration { get; set; }
 
-        public double Duration => EndTime - StartTime;
+        public double EndTime => StartTime + Duration;
     }
 }
diff --git a/osu.Game/Rulesets/Objects/Legacy/Mania/ConvertSpinner.cs b/osu.Game/Rulesets/Objects/Legacy/Mania/ConvertSpinner.cs
index 7dc13e27cd..c05aaceb9c 100644
--- a/osu.Game/Rulesets/Objects/Legacy/Mania/ConvertSpinner.cs
+++ b/osu.Game/Rulesets/Objects/Legacy/Mania/ConvertSpinner.cs
@@ -8,11 +8,11 @@ namespace osu.Game.Rulesets.Objects.Legacy.Mania
     /// <summary>
     /// Legacy osu!mania Spinner-type, used for parsing Beatmaps.
     /// </summary>
-    internal sealed class ConvertSpinner : ConvertHitObject, IHasEndTime, IHasXPosition
+    internal sealed class ConvertSpinner : ConvertHitObject, IHasDuration, IHasXPosition
     {
-        public double EndTime { get; set; }
+        public double Duration { get; set; }
 
-        public double Duration => EndTime - StartTime;
+        public double EndTime => StartTime + Duration;
 
         public float X { get; set; }
     }
diff --git a/osu.Game/Rulesets/Objects/Legacy/Osu/ConvertHitObjectParser.cs b/osu.Game/Rulesets/Objects/Legacy/Osu/ConvertHitObjectParser.cs
index b95ec703b6..75ecab0b8f 100644
--- a/osu.Game/Rulesets/Objects/Legacy/Osu/ConvertHitObjectParser.cs
+++ b/osu.Game/Rulesets/Objects/Legacy/Osu/ConvertHitObjectParser.cs
@@ -56,7 +56,7 @@ namespace osu.Game.Rulesets.Objects.Legacy.Osu
             };
         }
 
-        protected override HitObject CreateSpinner(Vector2 position, bool newCombo, int comboOffset, double endTime)
+        protected override HitObject CreateSpinner(Vector2 position, bool newCombo, int comboOffset, double duration)
         {
             // Convert spinners don't create the new combo themselves, but force the next non-spinner hitobject to create a new combo
             // Their combo offset is still added to that next hitobject's combo index
@@ -66,11 +66,11 @@ namespace osu.Game.Rulesets.Objects.Legacy.Osu
             return new ConvertSpinner
             {
                 Position = position,
-                EndTime = endTime
+                Duration = duration
             };
         }
 
-        protected override HitObject CreateHold(Vector2 position, bool newCombo, int comboOffset, double endTime)
+        protected override HitObject CreateHold(Vector2 position, bool newCombo, int comboOffset, double duration)
         {
             return null;
         }
diff --git a/osu.Game/Rulesets/Objects/Legacy/Osu/ConvertSpinner.cs b/osu.Game/Rulesets/Objects/Legacy/Osu/ConvertSpinner.cs
index 8b21aab411..e9e5ca8c94 100644
--- a/osu.Game/Rulesets/Objects/Legacy/Osu/ConvertSpinner.cs
+++ b/osu.Game/Rulesets/Objects/Legacy/Osu/ConvertSpinner.cs
@@ -9,11 +9,11 @@ namespace osu.Game.Rulesets.Objects.Legacy.Osu
     /// <summary>
     /// Legacy osu! Spinner-type, used for parsing Beatmaps.
     /// </summary>
-    internal sealed class ConvertSpinner : ConvertHitObject, IHasEndTime, IHasPosition, IHasCombo
+    internal sealed class ConvertSpinner : ConvertHitObject, IHasDuration, IHasPosition, IHasCombo
     {
-        public double EndTime { get; set; }
+        public double Duration { get; set; }
 
-        public double Duration => EndTime - StartTime;
+        public double EndTime => StartTime + Duration;
 
         public Vector2 Position { get; set; }
 
diff --git a/osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertHitObjectParser.cs b/osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertHitObjectParser.cs
index db65a61c90..13e3e84c6a 100644
--- a/osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertHitObjectParser.cs
+++ b/osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertHitObjectParser.cs
@@ -33,15 +33,15 @@ namespace osu.Game.Rulesets.Objects.Legacy.Taiko
             };
         }
 
-        protected override HitObject CreateSpinner(Vector2 position, bool newCombo, int comboOffset, double endTime)
+        protected override HitObject CreateSpinner(Vector2 position, bool newCombo, int comboOffset, double duration)
         {
             return new ConvertSpinner
             {
-                EndTime = endTime
+                Duration = duration
             };
         }
 
-        protected override HitObject CreateHold(Vector2 position, bool newCombo, int comboOffset, double endTime)
+        protected override HitObject CreateHold(Vector2 position, bool newCombo, int comboOffset, double duration)
         {
             return null;
         }
diff --git a/osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertSpinner.cs b/osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertSpinner.cs
index 8e28487f2f..1d5ecb1ef3 100644
--- a/osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertSpinner.cs
+++ b/osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertSpinner.cs
@@ -8,10 +8,10 @@ namespace osu.Game.Rulesets.Objects.Legacy.Taiko
     /// <summary>
     /// Legacy osu!taiko Spinner-type, used for parsing Beatmaps.
     /// </summary>
-    internal sealed class ConvertSpinner : ConvertHitObject, IHasEndTime
+    internal sealed class ConvertSpinner : ConvertHitObject, IHasDuration
     {
-        public double EndTime { get; set; }
+        public double Duration { get; set; }
 
-        public double Duration => EndTime - StartTime;
+        public double EndTime => StartTime + Duration;
     }
 }
diff --git a/osu.Game/Rulesets/Objects/Types/IHasDistance.cs b/osu.Game/Rulesets/Objects/Types/IHasDistance.cs
index e7f552115e..b497ca5da3 100644
--- a/osu.Game/Rulesets/Objects/Types/IHasDistance.cs
+++ b/osu.Game/Rulesets/Objects/Types/IHasDistance.cs
@@ -6,7 +6,7 @@ namespace osu.Game.Rulesets.Objects.Types
     /// <summary>
     /// A HitObject that has a positional length.
     /// </summary>
-    public interface IHasDistance : IHasEndTime
+    public interface IHasDistance : IHasDuration
     {
         /// <summary>
         /// The positional length of the HitObject.
diff --git a/osu.Game/Rulesets/Objects/Types/IHasDuration.cs b/osu.Game/Rulesets/Objects/Types/IHasDuration.cs
new file mode 100644
index 0000000000..185fd5977b
--- /dev/null
+++ b/osu.Game/Rulesets/Objects/Types/IHasDuration.cs
@@ -0,0 +1,34 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using Newtonsoft.Json;
+
+namespace osu.Game.Rulesets.Objects.Types
+{
+    /// <summary>
+    /// A HitObject that ends at a different time than its start time.
+    /// </summary>
+#pragma warning disable 618
+    public interface IHasDuration : IHasEndTime
+#pragma warning restore 618
+    {
+        double IHasEndTime.EndTime
+        {
+            get => EndTime;
+            set => Duration = (Duration - EndTime) + value;
+        }
+
+        double IHasEndTime.Duration => Duration;
+
+        /// <summary>
+        /// The time at which the HitObject ends.
+        /// </summary>
+        new double EndTime { get; }
+
+        /// <summary>
+        /// The duration of the HitObject.
+        /// </summary>
+        [JsonIgnore]
+        new double Duration { get; set; }
+    }
+}
diff --git a/osu.Game/Rulesets/Objects/Types/IHasEndTime.cs b/osu.Game/Rulesets/Objects/Types/IHasEndTime.cs
index bc7103c60d..c3769c5909 100644
--- a/osu.Game/Rulesets/Objects/Types/IHasEndTime.cs
+++ b/osu.Game/Rulesets/Objects/Types/IHasEndTime.cs
@@ -1,6 +1,7 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using Newtonsoft.Json;
 
 namespace osu.Game.Rulesets.Objects.Types
@@ -8,6 +9,7 @@ namespace osu.Game.Rulesets.Objects.Types
     /// <summary>
     /// A HitObject that ends at a different time than its start time.
     /// </summary>
+    [Obsolete("Use IHasDuration instead.")] // can be removed 20201126
     public interface IHasEndTime
     {
         /// <summary>
diff --git a/osu.Game/Rulesets/Objects/Types/IHasRepeats.cs b/osu.Game/Rulesets/Objects/Types/IHasRepeats.cs
index 256b1f3963..7a3fb16196 100644
--- a/osu.Game/Rulesets/Objects/Types/IHasRepeats.cs
+++ b/osu.Game/Rulesets/Objects/Types/IHasRepeats.cs
@@ -9,7 +9,7 @@ namespace osu.Game.Rulesets.Objects.Types
     /// <summary>
     /// A HitObject that spans some length.
     /// </summary>
-    public interface IHasRepeats : IHasEndTime
+    public interface IHasRepeats : IHasDuration
     {
         /// <summary>
         /// The amount of times the HitObject repeats.
diff --git a/osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs b/osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs
index c817d84d5c..0dc3324559 100644
--- a/osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs
+++ b/osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs
@@ -270,7 +270,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
         // Cant use AddOnce() since the delegate is re-constructed every invocation
         private void computeInitialStateRecursive(DrawableHitObject hitObject) => hitObject.Schedule(() =>
         {
-            if (hitObject.HitObject is IHasEndTime e)
+            if (hitObject.HitObject is IHasDuration e)
             {
                 switch (direction.Value)
                 {
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs
index dd2f7a833e..b95b3842b3 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineHitObjectBlueprint.cs
@@ -72,7 +72,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
 
             shadowComponents.Add(circle);
 
-            if (hitObject is IHasEndTime)
+            if (hitObject is IHasDuration)
             {
                 DragBar dragBarUnderlay;
                 Container extensionBar;
@@ -290,13 +290,13 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                             repeatHitObject.RepeatCount = proposedCount;
                             break;
 
-                        case IHasEndTime endTimeHitObject:
+                        case IHasDuration endTimeHitObject:
                             var snappedTime = Math.Max(hitObject.StartTime, beatSnapProvider.SnapTime(time));
 
                             if (endTimeHitObject.EndTime == snappedTime)
                                 return;
 
-                            endTimeHitObject.EndTime = snappedTime;
+                            endTimeHitObject.Duration = snappedTime - hitObject.StartTime;
                             break;
                     }