diff --git a/index.html b/index.html
index 040ceaa2c..10fce56f4 100644
--- a/index.html
+++ b/index.html
@@ -80,6 +80,10 @@ <h3>Options</h3>
       <input id=partial type="checkbox">
       Handle Partial (reloads player)
     </label>
+    <label>
+      <input id=llhls type="checkbox">
+      [EXPERIMENTAL] Enables support for ll-hls (reloads player)
+    </label>
     <label>
       <input id=buffer-water type="checkbox">
       [EXPERIMENTAL] Use Buffer Level for ABR (reloads player)
diff --git a/scripts/index-demo-page.js b/scripts/index-demo-page.js
index c09cb8bbe..924d681d9 100644
--- a/scripts/index-demo-page.js
+++ b/scripts/index-demo-page.js
@@ -233,6 +233,7 @@
     'sync-workers',
     'liveui',
     'partial',
+    'llhls',
     'url',
     'type',
     'keysystems',
@@ -292,6 +293,13 @@
       window.videojs.log.level(event.target.checked ? 'debug' : 'info');
     });
 
+    stateEls.llhls.addEventListener('change', function(event) {
+      saveState();
+
+      // reload the player and scripts
+      stateEls.minified.dispatchEvent(newEvent('change'));
+    });
+
     stateEls.partial.addEventListener('change', function(event) {
       saveState();
 
@@ -369,7 +377,8 @@
             vhs: {
               overrideNative: getInputValue(stateEls['override-native']),
               handlePartialData: getInputValue(stateEls.partial),
-              experimentalBufferBasedABR: getInputValue(stateEls['buffer-water'])
+              experimentalBufferBasedABR: getInputValue(stateEls['buffer-water']),
+              llhls: getInputValue(stateEls.llhls)
             }
           }
         });
diff --git a/src/manifest.js b/src/manifest.js
index 532d3e02a..887de822a 100644
--- a/src/manifest.js
+++ b/src/manifest.js
@@ -26,7 +26,8 @@ export const parseManifest = ({
   oninfo,
   manifestString,
   customTagParsers = [],
-  customTagMappers = []
+  customTagMappers = [],
+  llhls
 }) => {
   const parser = new M3u8Parser();
 
@@ -43,7 +44,35 @@ export const parseManifest = ({
   parser.push(manifestString);
   parser.end();
 
-  return parser.manifest;
+  const manifest = parser.manifest;
+
+  // remove llhls features from the parsed manifest
+  if (!llhls) {
+    [
+      'preloadSegment',
+      'skip',
+      'serverControl',
+      'renditionReports',
+      'partInf',
+      'partTargetDuration'
+    ].forEach(function(k) {
+      if (manifest.hasOwnProperty(k)) {
+        delete manifest[k];
+      }
+    });
+
+    if (manifest.segments) {
+      manifest.segments.forEach(function(segment) {
+        ['parts', 'preloadHints'].forEach(function(k) {
+          if (segment.hasOwnProperty(k)) {
+            delete segment[k];
+          }
+        });
+      });
+    }
+  }
+
+  return manifest;
 };
 
 /**
diff --git a/src/media-segment-request.js b/src/media-segment-request.js
index 53f629c6b..7f3284437 100644
--- a/src/media-segment-request.js
+++ b/src/media-segment-request.js
@@ -971,7 +971,7 @@ export const mediaSegmentRequest = ({
   }
 
   const segmentRequestOptions = videojs.mergeOptions(xhrOptions, {
-    uri: segment.resolvedUri,
+    uri: segment.part && segment.part.resolvedUri || segment.resolvedUri,
     responseType: 'arraybuffer',
     headers: segmentXhrHeaders(segment)
   });
diff --git a/src/playlist-loader.js b/src/playlist-loader.js
index 2f77b3400..49964869b 100644
--- a/src/playlist-loader.js
+++ b/src/playlist-loader.js
@@ -34,19 +34,36 @@ const { mergeOptions, EventTarget } = videojs;
   * @return a list of merged segment objects
   */
 export const updateSegments = (original, update, offset) => {
+  const oldSegments = original.slice();
   const result = update.slice();
 
   offset = offset || 0;
   const length = Math.min(original.length, update.length + offset);
 
   for (let i = offset; i < length; i++) {
-    result[i - offset] = mergeOptions(original[i], result[i - offset]);
+    const newIndex = i - offset;
+
+    // merge parts
+    if (result[newIndex] && result[newIndex].parts && oldSegments[i] && oldSegments[i].parts) {
+      for (let p = 0; p < result[newIndex].parts; p++) {
+        result[newIndex].parts[p] = mergeOptions(oldSegments[i].parts[p], result[newIndex].parts[p]);
+      }
+    }
+
+    // part merging happens above. If the new playlist has no parts for
+    // a segment, they are no longer valid for requsting
+    if (oldSegments[i] && oldSegments[i].parts) {
+      delete oldSegments[i].parts;
+    }
+    result[newIndex] = mergeOptions(original[i], result[i - offset]);
   }
   return result;
 };
 
 export const resolveSegmentUris = (segment, baseUri) => {
-  if (!segment.resolvedUri) {
+  // preloadSegments will not have a uri at all
+  // as the segment isn't actually in the manifest yet, only parts
+  if (!segment.resolvedUri && segment.uri) {
     segment.resolvedUri = resolveUrl(baseUri, segment.uri);
   }
   if (segment.key && !segment.key.resolvedUri) {
@@ -55,6 +72,23 @@ export const resolveSegmentUris = (segment, baseUri) => {
   if (segment.map && !segment.map.resolvedUri) {
     segment.map.resolvedUri = resolveUrl(baseUri, segment.map.uri);
   }
+  if (segment.parts && segment.parts.length) {
+    segment.parts.forEach((p) => {
+      if (p.resolvedUri) {
+        return;
+      }
+      p.resolvedUri = resolveUrl(baseUri, p.URI);
+    });
+  }
+
+  if (segment.preloadHints && segment.preloadHints.length) {
+    segment.preloadHints.forEach((p) => {
+      if (p.resolvedUri) {
+        return;
+      }
+      p.resolvedUri = resolveUrl(baseUri, p.URI);
+    });
+  }
 };
 
 // consider the playlist unchanged if the playlist object is the same or
@@ -173,6 +207,7 @@ export default class PlaylistLoader extends EventTarget {
 
     this.customTagParsers = (vhsOptions && vhsOptions.customTagParsers) || [];
     this.customTagMappers = (vhsOptions && vhsOptions.customTagMappers) || [];
+    this.llhls = (vhsOptions && vhsOptions.llhls) || false;
 
     // initialize the loader state
     this.state = 'HAVE_NOTHING';
@@ -254,7 +289,8 @@ export default class PlaylistLoader extends EventTarget {
       oninfo: ({message}) => this.logger_(`m3u8-parser info for ${id}: ${message}`),
       manifestString: playlistString,
       customTagParsers: this.customTagParsers,
-      customTagMappers: this.customTagMappers
+      customTagMappers: this.customTagMappers,
+      llhls: this.llhls
     });
 
     playlist.lastRequest = Date.now();
@@ -562,7 +598,8 @@ export default class PlaylistLoader extends EventTarget {
       const manifest = parseManifest({
         manifestString: req.responseText,
         customTagParsers: this.customTagParsers,
-        customTagMappers: this.customTagMappers
+        customTagMappers: this.customTagMappers,
+        llhls: this.llhls
       });
 
       this.setupInitialPlaylist(manifest);
diff --git a/src/segment-loader.js b/src/segment-loader.js
index 36eee38d4..c826390e8 100644
--- a/src/segment-loader.js
+++ b/src/segment-loader.js
@@ -453,6 +453,7 @@ export default class SegmentLoader extends videojs.EventTarget {
     this.roundTrip = NaN;
     this.resetStats_();
     this.mediaIndex = null;
+    this.partIndex = null;
 
     // private settings
     this.hasPlayed_ = settings.hasPlayed;
@@ -975,6 +976,22 @@ export default class SegmentLoader extends videojs.EventTarget {
     // equal to the last appended mediaIndex
     if (this.mediaIndex !== null) {
       this.mediaIndex -= mediaSequenceDiff;
+
+      // mediaIndex is invalid, set it to null
+      if (this.mediaIndex < 0) {
+        this.mediaIndex = null;
+        this.partIndex = null;
+      } else {
+        const segment = this.playlist_.segments[this.mediaIndex];
+
+        // partIndex should remain the same for the same segment
+        // unless parts fell off of the playlist for this segment.
+        // In that case we need to reset partIndex and resync
+        if (this.partIndex && (!segment.parts || !segment.parts.length || !segment.parts[this.partIndex])) {
+          this.logger_(`part fell off on part ${this.partIndex}`);
+          this.resetLoader();
+        }
+      }
     }
 
     // update the mediaIndex on the SegmentInfo object
@@ -989,6 +1006,10 @@ export default class SegmentLoader extends videojs.EventTarget {
       if (segmentInfo.mediaIndex >= 0) {
         segmentInfo.segment = newPlaylist.segments[segmentInfo.mediaIndex];
       }
+
+      if (segmentInfo.partIndex >= 0 && segmentInfo.segment.parts) {
+        segmentInfo.part = segmentInfo.segment.parts[segmentInfo.partIndex];
+      }
     }
 
     this.syncController_.saveExpiredSegmentInfo(oldPlaylist, newPlaylist);
@@ -1065,6 +1086,7 @@ export default class SegmentLoader extends videojs.EventTarget {
       segmentTransmuxer.reset(this.transmuxer_);
     }
     this.mediaIndex = null;
+    this.partIndex = null;
     this.syncPoint_ = null;
     this.isPendingTimestampOffset_ = false;
     this.callQueue_ = [];
@@ -1209,7 +1231,8 @@ export default class SegmentLoader extends videojs.EventTarget {
       this.mediaIndex,
       this.hasPlayed_(),
       this.currentTime_(),
-      this.syncPoint_
+      this.syncPoint_,
+      this.partIndex
     );
 
     if (!segmentInfo) {
@@ -1245,18 +1268,25 @@ export default class SegmentLoader extends videojs.EventTarget {
    * @param {Object} [playlist] a media playlist object
    * @return {boolean} do we need to call endOfStream on the MediaSource
    */
-  isEndOfStream_(mediaIndex = this.mediaIndex, playlist = this.playlist_) {
+  isEndOfStream_(mediaIndex = this.mediaIndex, playlist = this.playlist_, partIndex = this.partIndex) {
     if (!playlist || !this.mediaSource_) {
       return false;
     }
 
+    const segment = typeof mediaIndex === 'number' && playlist.segments[mediaIndex];
+
     // mediaIndex is zero based but length is 1 based
     const appendedLastSegment = (mediaIndex + 1) === playlist.segments.length;
+    // true if there are no parts, or this is the last part.
+    const appendedLastPart = !segment || !segment.parts || (partIndex + 1) === segment.parts.length;
 
     // if we've buffered to the end of the video, we need to call endOfStream
     // so that MediaSources can trigger the `ended` event when it runs out of
     // buffered data instead of waiting for me
-    return playlist.endList && this.mediaSource_.readyState === 'open' && appendedLastSegment;
+    return playlist.endList &&
+      this.mediaSource_.readyState === 'open' &&
+      appendedLastSegment &&
+      appendedLastPart;
   }
 
   /**
@@ -1271,7 +1301,7 @@ export default class SegmentLoader extends videojs.EventTarget {
    * @param {Object} syncPoint - a segment info object that describes the
    * @return {Object} a segment request object that describes the segment to load
    */
-  checkBuffer_(buffered, playlist, currentMediaIndex, hasPlayed, currentTime, syncPoint) {
+  checkBuffer_(buffered, playlist, currentMediaIndex, hasPlayed, currentTime, syncPoint, currentPartIndex) {
     let lastBufferedEnd = 0;
 
     if (buffered.length) {
@@ -1296,6 +1326,7 @@ export default class SegmentLoader extends videojs.EventTarget {
       return null;
     }
 
+    let nextPartIndex = typeof currentPartIndex === 'number' ? currentPartIndex + 1 : 0;
     let nextMediaIndex = null;
     let startOfSegment;
     let isSyncRequest = false;
@@ -1317,7 +1348,12 @@ export default class SegmentLoader extends videojs.EventTarget {
         startOfSegment = lastBufferedEnd;
       }
 
-      nextMediaIndex = currentMediaIndex + 1;
+      if (!segment || !segment.parts || !segment.parts.length || !segment.parts[nextPartIndex]) {
+        nextMediaIndex = currentMediaIndex + 1;
+        nextPartIndex = 0;
+      } else {
+        nextMediaIndex = currentMediaIndex;
+      }
 
     // There is a sync-point but the lack of a mediaIndex indicates that
     // we need to make a good conservative guess about which segment to
@@ -1346,7 +1382,7 @@ export default class SegmentLoader extends videojs.EventTarget {
       startOfSegment = mediaSourceInfo.startTime;
     }
 
-    const segmentInfo = this.generateSegmentInfo_(playlist, nextMediaIndex, startOfSegment, isSyncRequest);
+    const segmentInfo = this.generateSegmentInfo_(playlist, nextMediaIndex, startOfSegment, isSyncRequest, nextPartIndex);
 
     if (!segmentInfo) {
       return;
@@ -1388,12 +1424,8 @@ export default class SegmentLoader extends videojs.EventTarget {
     }
 
     const segmentIndexArray = playlist.segments
-      .map((s, i) => {
-        return {
-          timeline: s.timeline,
-          segmentIndex: i
-        };
-      }).filter(s => s.timeline === this.currentTimeline_);
+      .map((s, i) => ({timeline: s.timeline, segmentIndex: i}))
+      .filter(s => s.timeline === this.currentTimeline_);
 
     if (segmentIndexArray.length) {
       return segmentIndexArray[Math.min(segmentIndexArray.length - 1, 1)].segmentIndex;
@@ -1402,12 +1434,19 @@ export default class SegmentLoader extends videojs.EventTarget {
     return Math.max(playlist.segments.length - 1, 0);
   }
 
-  generateSegmentInfo_(playlist, mediaIndex, startOfSegment, isSyncRequest) {
+  generateSegmentInfo_(playlist, mediaIndex, startOfSegment, isSyncRequest, partIndex) {
     if (mediaIndex < 0 || mediaIndex >= playlist.segments.length) {
       return null;
     }
 
     const segment = playlist.segments[mediaIndex];
+
+    if (segment.parts && segment.parts.length && partIndex >= segment.parts.length) {
+      return null;
+    }
+
+    const part = segment.parts && segment.parts.length && segment.parts[partIndex];
+
     const audioBuffered = this.sourceUpdater_.audioBuffered();
     const videoBuffered = this.sourceUpdater_.videoBuffered();
     let audioAppendStart;
@@ -1433,9 +1472,10 @@ export default class SegmentLoader extends videojs.EventTarget {
     return {
       requestId: 'segment-loader-' + Math.random(),
       // resolve the segment URL relative to the playlist
-      uri: segment.resolvedUri,
+      uri: part && part.resolvedUri || segment.resolvedUri,
       // the segment's mediaIndex at the time it was requested
       mediaIndex,
+      partIndex: part ? partIndex : null,
       // whether or not to update the SegmentLoader's state with this
       // segment's mediaIndex
       isSyncRequest,
@@ -1455,6 +1495,7 @@ export default class SegmentLoader extends videojs.EventTarget {
       duration: segment.duration,
       // retain the segment in case the playlist updates while doing an async process
       segment,
+      part,
       byteLength: 0,
       transmuxer: this.transmuxer_,
       audioAppendStart,
@@ -2210,7 +2251,11 @@ export default class SegmentLoader extends videojs.EventTarget {
     }
 
     const simpleSegment = this.createSimplifiedSegmentObj_(segmentInfo);
-    const isEndOfStream = this.isEndOfStream_(segmentInfo.mediaIndex, segmentInfo.playlist);
+    const isEndOfStream = this.isEndOfStream_(
+      segmentInfo.mediaIndex,
+      segmentInfo.playlist,
+      segmentInfo.partIndex
+    );
     const isWalkingForward = this.mediaIndex !== null;
     const isDiscontinuity = segmentInfo.timeline !== this.currentTimeline_ &&
       // currentTimeline starts at -1, so we shouldn't end the timeline switching to 0,
@@ -2279,13 +2324,16 @@ export default class SegmentLoader extends videojs.EventTarget {
    */
   createSimplifiedSegmentObj_(segmentInfo) {
     const segment = segmentInfo.segment;
+    const part = segmentInfo.part;
+
     const simpleSegment = {
-      resolvedUri: segment.resolvedUri,
-      byterange: segment.byterange,
+      resolvedUri: part ? part.resolvedUri : segment.resolvedUri,
+      byterange: part ? part.byterange : segment.byterange,
       requestId: segmentInfo.requestId,
       transmuxer: segmentInfo.transmuxer,
       audioAppendStart: segmentInfo.audioAppendStart,
-      gopsToAlignWith: segmentInfo.gopsToAlignWith
+      gopsToAlignWith: segmentInfo.gopsToAlignWith,
+      part: segmentInfo.part
     };
 
     const previousSegment = segmentInfo.playlist.segments[segmentInfo.mediaIndex - 1];
@@ -2795,11 +2843,12 @@ export default class SegmentLoader extends videojs.EventTarget {
     this.trigger('progress');
 
     this.mediaIndex = segmentInfo.mediaIndex;
+    this.partIndex = segmentInfo.partIndex;
 
     // any time an update finishes and the last segment is in the
     // buffer, end the stream. this ensures the "ended" event will
     // fire if playback reaches that point.
-    if (this.isEndOfStream_(segmentInfo.mediaIndex, segmentInfo.playlist)) {
+    if (this.isEndOfStream_(segmentInfo.mediaIndex, segmentInfo.playlist, segmentInfo.partIndex)) {
       this.endOfStream();
     }
 
diff --git a/src/videojs-http-streaming.js b/src/videojs-http-streaming.js
index fa656f1a4..7f8065454 100644
--- a/src/videojs-http-streaming.js
+++ b/src/videojs-http-streaming.js
@@ -665,7 +665,8 @@ class VhsHandler extends Component {
       'playlistSelector',
       'initialPlaylistSelector',
       'experimentalBufferBasedABR',
-      'liveRangeSafeTimeDelta'
+      'liveRangeSafeTimeDelta',
+      'llhls'
     ].forEach((option) => {
       if (typeof this.source_[option] !== 'undefined') {
         this.options_[option] = this.source_[option];
diff --git a/test/loader-common.js b/test/loader-common.js
index 94238dd52..4c2a3c902 100644
--- a/test/loader-common.js
+++ b/test/loader-common.js
@@ -802,6 +802,151 @@ export const LoaderCommonFactory = ({
       });
     });
 
+    // only main/fmp4 segment loaders use parts/partIndex
+    if (usesAsyncAppends) {
+      QUnit.test('mediaIndex and partIndex are used', function(assert) {
+        const appendPart = (segmentIndex, partIndex) => {
+          this.clock.tick(1);
+
+          assert.equal(
+            this.requests[0].url,
+            `segment${segmentIndex}.part${partIndex}.ts`,
+            `requested mediaIndex #${segmentIndex} partIndex #${partIndex}`
+          );
+          standardXHRResponse(this.requests.shift(), testData());
+
+          if (usesAsyncAppends) {
+            return new Promise((resolve, reject) => {
+              loader.one('appended', resolve);
+              loader.one('error', reject);
+            });
+          }
+
+          return Promise.resolve();
+        };
+
+        return setupMediaSource(loader.mediaSource_, loader.sourceUpdater_).then(() => {
+          loader.playlist(playlistWithDuration(50, {
+            mediaSequence: 0,
+            endList: false,
+            llhls: true
+          }));
+
+          loader.load();
+          loader.mediaIndex = 2;
+          return Promise.resolve();
+        }).then(() => appendPart(2, 0))
+          .then(() => appendPart(2, 1))
+          .then(() => appendPart(2, 2))
+          .then(() => appendPart(2, 3))
+          .then(() => appendPart(2, 4))
+          .then(() => appendPart(3, 0));
+      });
+
+      QUnit.test('mediaIndex and partIndex survive playlist change', function(assert) {
+        const appendPart = (segmentIndex, partIndex) => {
+          this.clock.tick(1);
+
+          assert.equal(
+            this.requests[0].url,
+            `segment${segmentIndex}.part${partIndex}.ts`,
+            `requested mediaIndex #${segmentIndex} partIndex #${partIndex}`
+          );
+          standardXHRResponse(this.requests.shift(), testData());
+
+          if (usesAsyncAppends) {
+            return new Promise((resolve, reject) => {
+              loader.one('appended', resolve);
+              loader.one('error', reject);
+            });
+          }
+
+          return Promise.resolve();
+        };
+
+        return setupMediaSource(loader.mediaSource_, loader.sourceUpdater_).then(() => {
+          loader.playlist(playlistWithDuration(50, {
+            mediaSequence: 0,
+            endList: false,
+            llhls: true
+          }));
+
+          loader.load();
+          loader.mediaIndex = 4;
+          return Promise.resolve();
+        }).then(() => appendPart(4, 0))
+          .then(() => appendPart(4, 1))
+          .then(() => appendPart(4, 2))
+          .then(() => {
+
+            // Update the playlist shifting the mediaSequence by 2 which will result
+            // in a decrement of the mediaIndex by 2 to 1
+            loader.playlist(playlistWithDuration(50, {
+              mediaSequence: 2,
+              endList: false,
+              llhls: true
+            }));
+            // verify that we still try to append the next part for that segment.
+            return appendPart(2, 3);
+          }).then(() => appendPart(2, 4));
+      });
+
+      QUnit.test('drops partIndex if playlist update drops parts', function(assert) {
+        const appendPart = (segmentIndex, partIndex) => {
+          this.clock.tick(1);
+
+          assert.equal(
+            this.requests[0].url,
+            `segment${segmentIndex}.part${partIndex}.ts`,
+            `requested mediaIndex #${segmentIndex} partIndex #${partIndex}`
+          );
+          standardXHRResponse(this.requests.shift(), testData());
+
+          if (usesAsyncAppends) {
+            return new Promise((resolve, reject) => {
+              loader.one('appended', resolve);
+              loader.one('error', reject);
+            });
+          }
+
+          return Promise.resolve();
+        };
+
+        return setupMediaSource(loader.mediaSource_, loader.sourceUpdater_).then(() => {
+          loader.playlist(playlistWithDuration(50, {
+            mediaSequence: 0,
+            endList: false,
+            llhls: true
+          }));
+
+          loader.load();
+          loader.mediaIndex = 4;
+          return Promise.resolve();
+        }).then(() => appendPart(4, 0))
+          .then(() => appendPart(4, 1))
+          .then(() => appendPart(4, 2))
+          .then(() => {
+
+            // Update the playlist shifting the mediaSequence by 2 which will result
+            // in a decrement of the mediaIndex by 2 to 1
+            loader.playlist(playlistWithDuration(50, {
+              mediaSequence: 4,
+              endList: false,
+              llhls: true
+            }));
+
+            assert.equal(loader.partIndex, null, 'partIndex was dropped');
+            this.clock.tick(1);
+
+            assert.equal(
+              this.requests[0].url,
+              '1.ts',
+              'requested mediaIndex 1 only'
+            );
+          });
+      });
+    }
+
     QUnit.test('segment 404s should trigger an error', function(assert) {
       const errors = [];
 
diff --git a/test/segment-loader.test.js b/test/segment-loader.test.js
index 746c7175f..1c07e21b8 100644
--- a/test/segment-loader.test.js
+++ b/test/segment-loader.test.js
@@ -997,6 +997,7 @@ QUnit.module('SegmentLoader', function(hooks) {
         this.clock.tick(1);
 
         assert.equal(loader.mediaIndex, null, 'mediaIndex reset by seek to seekable');
+        assert.equal(loader.partIndex, null, 'partIndex reset by seek to seekable');
         assert.equal(syncInfoUpdates, 1, 'syncinfoupdate was triggered');
       });
     });
diff --git a/test/test-helpers.js b/test/test-helpers.js
index a88e42b74..ced0b5d00 100644
--- a/test/test-helpers.js
+++ b/test/test-helpers.js
@@ -433,10 +433,14 @@ export const playlistWithDuration = function(time, conf) {
     attributes: conf && typeof conf.attributes !== 'undefined' ? conf.attributes : {}
   };
 
+  if (conf && conf.llhls) {
+    result.partTargetDuration = conf.llhls.partTargetDuration || (targetDuration / 5);
+  }
+
   result.id = result.uri;
 
-  const count = Math.floor(time / targetDuration);
   const remainder = time % targetDuration;
+  const count = Math.floor(time / targetDuration) + (remainder ? 1 : 0);
   let i;
   const isEncrypted = conf && conf.isEncrypted;
   const extension = conf && conf.extension ? conf.extension : '.ts';
@@ -455,7 +459,8 @@ export const playlistWithDuration = function(time, conf) {
     const segment = {
       uri: i + extension,
       resolvedUri: i + extension,
-      duration: targetDuration,
+      // last segment will be less then 10 if duration is uneven
+      duration: (i + 1 === count && remainder) ? remainder : targetDuration,
       timeline
     };
 
@@ -470,15 +475,23 @@ export const playlistWithDuration = function(time, conf) {
       segment.discontinuity = true;
     }
 
+    // add parts for the the last 3 segments in llhls playlists
+    if (conf && conf.llhls && (count - i) <= 3) {
+      segment.parts = [];
+      for (let z = 0; z < 5; z++) {
+        const uri = `segment${i}.part${z}${extension}`;
+
+        segment.parts.push({
+          uri,
+          resolvedUri: uri,
+          duration: result.partTargetDuration
+        });
+      }
+    }
+
     result.segments.push(segment);
   }
-  if (remainder) {
-    result.segments.push({
-      uri: i + extension,
-      duration: remainder,
-      timeline: result.discontinuitySequence
-    });
-  }
+
   return result;
 };