diff --git a/demo/index.html b/demo/index.html
index d23eda7a7..409e994ca 100644
--- a/demo/index.html
+++ b/demo/index.html
@@ -48,6 +48,9 @@
       href="https://cdn.plyr.io/static/fonts/gordita-bold.woff2"
     />
 
+    <!-- MPEG-DASH -->
+    <script src="https://cdn.dashjs.org/latest/dash.all.min.js"></script>
+
     <!-- Google Analytics-->
     <script async src="https://www.googletagmanager.com/gtag/js?id=UA-132699580-1"></script>
     <script>
@@ -92,7 +95,7 @@ <h1>Pl<span>a</span>y<span>e</span>r</h1>
               ></path></svg
             >YouTube
           </button>
-          and
+          ,
           <button type="button" class="faux-link" data-source="vimeo">
             <svg class="icon" role="presentation">
               <title>Vimeo</title>
@@ -103,6 +106,21 @@ <h1>Pl<span>a</span>y<span>e</span>r</h1>
               ></path></svg
             >Vimeo
           </button>
+          and
+          <button type="button" class="faux-link" data-source="mpd">
+            <svg class="icon" role="presentation"><title>MPEG-DASH</title>
+              <path d="M0,2.16h4.85v5.21h-4.85Z" />
+              <path d="M11.15,2.16h4.85v5.21h-4.85Z" />
+              <path d="M5.57,2.16h4.85v5.21h-4.85Z" />
+              <path d="M0,8.09h4.85v3.06h-4.85Z" />
+              <path d="M11.15,8.09h4.85v3.06h-4.85Z" />
+              <path d="M5.57,8.09h4.85v3.06h-4.85Z" />
+              <path d="M0,11.87h4.85v1.98h-4.85Z" />
+              <path d="M11.15,11.87h4.85v1.98h-4.85Z" />
+              <path d="M5.57,11.87h4.85v1.98h-4.85Z" />
+            </svg>
+            MPEG-DASH
+          </button>
         </p>
 
         <div class="call-to-action">
@@ -229,6 +247,23 @@ <h1>Pl<span>a</span>y<span>e</span>r</h1>
               </span>
             </small>
           </li>
+          <li class="plyr__cite plyr__cite--mpd" hidden>
+            <small>
+              <svg class="icon" role="presentation"><title>MPEG-DASH</title>
+                <path d="M0,2.16h4.85v5.21h-4.85Z" />
+                <path d="M11.15,2.16h4.85v5.21h-4.85Z" />
+                <path d="M5.57,2.16h4.85v5.21h-4.85Z" />
+                <path d="M0,8.09h4.85v3.06h-4.85Z" />
+                <path d="M11.15,8.09h4.85v3.06h-4.85Z" />
+                <path d="M5.57,8.09h4.85v3.06h-4.85Z" />
+                <path d="M0,11.87h4.85v1.98h-4.85Z" />
+                <path d="M11.15,11.87h4.85v1.98h-4.85Z" />
+                <path d="M5.57,11.87h4.85v1.98h-4.85Z" />
+              </svg>
+              <a href="https://mango.blender.org/" target="_blank">Tears of Steel</a>
+              &copy; Blender
+            </small>
+          </li>
         </ul>
       </main>
     </div>
diff --git a/demo/src/js/sources.js b/demo/src/js/sources.js
index e21885af7..977ebf387 100644
--- a/demo/src/js/sources.js
+++ b/demo/src/js/sources.js
@@ -76,6 +76,15 @@ const sources = {
       },
     ],
   },
+  mpd: {
+    type: 'video',
+    sources: [
+      {
+        src: 'https://media.axprod.net/TestVectors/Cmaf/clear_1080p_h264/manifest.mpd',
+        provider: 'mpd',
+      },
+    ],
+  },
 };
 
 export default sources;
diff --git a/src/js/captions.js b/src/js/captions.js
index 856baccf4..9fd24ab64 100644
--- a/src/js/captions.js
+++ b/src/js/captions.js
@@ -31,7 +31,7 @@ const captions = {
     }
 
     // Only Vimeo and HTML5 video supported at this point
-    if (!this.isVideo || this.isYouTube || (this.isHTML5 && !support.textTracks)) {
+    if (!this.isVideo || this.isYouTube || ((this.isHTML5 || this.isMPD) && !support.textTracks)) {
       // Clear menu and hide
       if (
         is.array(this.config.controls) &&
@@ -109,6 +109,9 @@ const captions = {
       const trackEvents = this.config.captions.update ? 'addtrack removetrack' : 'removetrack';
       on.call(this, this.media.textTracks, trackEvents, captions.update.bind(this));
     }
+    if (this.isMPD) {
+      on.call(this, this.media.textTracks, 'addtrack removetrack', captions.update.bind(this));
+    }
 
     // Update available languages in list next tick (the event must not be triggered before the listeners)
     setTimeout(captions.update.bind(this), 0);
@@ -122,7 +125,7 @@ const captions = {
     const languageExists = Boolean(tracks.find((track) => track.language === language));
 
     // Handle tracks (add event listener and "pseudo"-default)
-    if (this.isHTML5 && this.isVideo) {
+    if ((this.isHTML5 || this.isMPD) && this.isVideo) {
       tracks
         .filter((track) => !meta.get(track))
         .forEach((track) => {
@@ -276,10 +279,15 @@ const captions = {
       triggerEvent.call(this, this.media, 'languagechange');
     }
 
+    // Load captions for MPEG-DASH
+    if (this.isMPD) {
+      this.dash.setTextTrack(index);
+    }
+
     // Show captions
     captions.toggle.call(this, true, passive);
 
-    if (this.isHTML5 && this.isVideo) {
+    if ((this.isHTML5 || this.isMPD) && this.isVideo) {
       // If we change the active track while a cue is already displayed we need to update it
       captions.updateCues.call(this);
     }
@@ -311,7 +319,7 @@ const captions = {
     // For HTML5, use cache instead of current tracks when it exists (if captions.update is false)
     // Filter out removed tracks and tracks that aren't captions/subtitles (for example metadata)
     return tracks
-      .filter((track) => !this.isHTML5 || update || this.captions.meta.has(track))
+      .filter((track) => !this.isHTML5 || !this.isMPD || update || this.captions.meta.has(track))
       .filter((track) => ['captions', 'subtitles'].includes(track.kind));
   },
 
diff --git a/src/js/config/defaults.js b/src/js/config/defaults.js
index e301022e4..ab386ce8d 100644
--- a/src/js/config/defaults.js
+++ b/src/js/config/defaults.js
@@ -89,6 +89,18 @@ const defaults = {
     options: [0.5, 0.75, 1, 1.25, 1.5, 1.75, 2, 4],
   },
 
+  // Audio Tracks (MPEG-DASH)
+  audioTrack: {
+    options: [],
+    onChange: null,
+  },
+
+  // Video Tracks (MPEG-DASH)
+  videoTrack: {
+    options: [],
+    onChange: null,
+  },
+
   // Keyboard shortcut settings
   keyboard: {
     focused: true,
@@ -145,7 +157,7 @@ const defaults = {
     // 'download',
     'fullscreen',
   ],
-  settings: ['captions', 'quality', 'speed'],
+  settings: ['captions', 'quality', 'speed', 'audioTrack', 'videoTrack'],
 
   // Localisation
   i18n: {
@@ -174,6 +186,8 @@ const defaults = {
     pip: 'PIP',
     menuBack: 'Go back to previous menu',
     speed: 'Speed',
+    audioTrack: 'Audio Track',
+    videoTrack: 'Video Track',
     normal: 'Normal',
     quality: 'Quality',
     loop: 'Loop',
@@ -184,6 +198,7 @@ const defaults = {
     disabled: 'Disabled',
     enabled: 'Enabled',
     advertisement: 'Ad',
+    qualityAuto: 'Auto',
     qualityBadge: {
       2160: '4K',
       1440: 'HD',
@@ -274,6 +289,15 @@ const defaults = {
     // Quality
     'qualitychange',
 
+    // MPEG-DASH
+    'audiotrackchange',
+    'videotrackchange',
+    'qualitylistupdate',
+    'audiotracklistupdate',
+    'videotracklistupdate',
+    'audiotracklabelsupdate',
+    'videotracklabelsupdate',
+
     // Ads
     'adsloaded',
     'adscontentpause',
@@ -317,6 +341,8 @@ const defaults = {
       speed: '[data-plyr="speed"]',
       language: '[data-plyr="language"]',
       quality: '[data-plyr="quality"]',
+      audioTrack: '[data-plyr="audioTrack"]',
+      videoTrack: '[data-plyr="videoTrack"]',
     },
     display: {
       currentTime: '.plyr__time--current',
diff --git a/src/js/config/types.js b/src/js/config/types.js
index 31e488eb8..29b30f84d 100644
--- a/src/js/config/types.js
+++ b/src/js/config/types.js
@@ -6,6 +6,7 @@ export const providers = {
   html5: 'html5',
   youtube: 'youtube',
   vimeo: 'vimeo',
+  mpd: 'mpd',
 };
 
 export const types = {
diff --git a/src/js/controls.js b/src/js/controls.js
index 3044b5b18..3b01e2542 100644
--- a/src/js/controls.js
+++ b/src/js/controls.js
@@ -7,6 +7,7 @@ import RangeTouch from 'rangetouch';
 
 import captions from './captions';
 import html5 from './html5';
+import mpd from './plugins/mpd';
 import support from './support';
 import { repaint, transitionEndEvent } from './utils/animation';
 import { dedupe } from './utils/arrays';
@@ -526,6 +527,14 @@ const controls = {
             this.speed = parseFloat(value);
             break;
 
+          case 'audioTrack':
+            this.audioTrack = value;
+            break;
+
+          case 'videoTrack':
+            this.videoTrack = value;
+            break;
+
           default:
             break;
         }
@@ -824,7 +833,11 @@ const controls = {
     let value = null;
     let list = container;
 
-    if (setting === 'captions') {
+    if (setting === 'audioTrack') {
+      value = this.audioTrack;
+    } else if (setting === 'videoTrack') {
+      value = this.videoTrack;
+    } else if (setting === 'captions') {
       value = this.currentTrack;
     } else {
       value = !is.empty(input) ? input : this[setting];
@@ -872,6 +885,38 @@ const controls = {
   // Translate a value into a nice label
   getLabel(setting, value) {
     switch (setting) {
+      case 'audioTrack': {
+        let label;
+
+        label = i18n.get(`audioTrackLabel.${value}`, this.config);
+        if (label.length) {
+          return label;
+        }
+
+        label = i18n.get(`audioTrackMPDLabel.${value}`, this.config);
+        if (label.length) {
+          return label;
+        }
+
+        return `${value}`;
+      }
+
+      case 'videoTrack': {
+        let label;
+
+        label = i18n.get(`videoTrackLabel.${value}`, this.config);
+        if (label.length) {
+          return label;
+        }
+
+        label = i18n.get(`videoTrackMPDLabel.${value}`, this.config);
+        if (label.length) {
+          return label;
+        }
+
+        return `${value}`;
+      }
+
       case 'speed':
         return value === 1 ? i18n.get('normal', this.config) : `${value}&times;`;
 
@@ -1096,6 +1141,102 @@ const controls = {
     controls.updateSetting.call(this, type, list);
   },
 
+  // Set a list of available audio tracks
+  setAudioTrackMenu(options) {
+    // Menu required
+    if (!is.element(this.elements.settings.panels.audioTrack)) {
+      return;
+    }
+
+    const type = 'audioTrack';
+    const list = this.elements.settings.panels.audioTrack.querySelector('[role="menu"]');
+
+    // Set options if passed and filter based on uniqueness and config
+    if (is.array(options)) {
+      this.options.audioTrack = dedupe(options);
+    }
+
+    // Toggle the pane and tab
+    const toggle = !is.empty(this.options.audioTrack) && this.options.audioTrack.length > 1;
+    controls.toggleMenuButton.call(this, type, toggle);
+
+    // Empty the menu
+    emptyElement(list);
+
+    // Check if we need to toggle the parent
+    controls.checkMenu.call(this);
+
+    // If we're hiding, nothing more to do
+    if (!toggle) {
+      return;
+    }
+
+    // Sort options by the config and then render options
+    this.options.audioTrack
+      .sort((a, b) => {
+        const sorting = this.config.audioTrack.options;
+        return sorting.indexOf(a) > sorting.indexOf(b) ? 1 : -1;
+      })
+      .forEach((audioTrack) => {
+        controls.createMenuItem.call(this, {
+          value: audioTrack,
+          list,
+          type,
+          title: controls.getLabel.call(this, 'audioTrack', audioTrack),
+        });
+      });
+
+    controls.updateSetting.call(this, type, list);
+  },
+
+  // Set a list of available video tracks
+  setVideoTrackMenu(options) {
+    // Menu required
+    if (!is.element(this.elements.settings.panels.videoTrack)) {
+      return;
+    }
+
+    const type = 'videoTrack';
+    const list = this.elements.settings.panels.videoTrack.querySelector('[role="menu"]');
+
+    // Set options if passed and filter based on uniqueness and config
+    if (is.array(options)) {
+      this.options.videoTrack = dedupe(options);
+    }
+
+    // Toggle the pane and tab
+    const toggle = !is.empty(this.options.videoTrack) && this.options.videoTrack.length > 1;
+    controls.toggleMenuButton.call(this, type, toggle);
+
+    // Empty the menu
+    emptyElement(list);
+
+    // Check if we need to toggle the parent
+    controls.checkMenu.call(this);
+
+    // If we're hiding, nothing more to do
+    if (!toggle) {
+      return;
+    }
+
+    // Sort options by the config and then render options
+    this.options.videoTrack
+      .sort((a, b) => {
+        const sorting = this.config.videoTrack.options;
+        return sorting.indexOf(a) > sorting.indexOf(b) ? 1 : -1;
+      })
+      .forEach((videoTrack) => {
+        controls.createMenuItem.call(this, {
+          value: videoTrack,
+          list,
+          type,
+          title: controls.getLabel.call(this, 'videoTrack', videoTrack),
+        });
+      });
+
+    controls.updateSetting.call(this, type, list);
+  },
+
   // Check if we need to hide/show the settings menu
   checkMenu() {
     const { buttons } = this.elements.settings;
@@ -1272,6 +1413,8 @@ const controls = {
       createTime,
       setQualityMenu,
       setSpeedMenu,
+      setAudioTrackMenu,
+      setVideoTrackMenu,
       showMenuPanel,
     } = controls;
     this.elements.controls = null;
@@ -1614,6 +1757,16 @@ const controls = {
       setQualityMenu.call(this, html5.getQualityOptions.call(this));
     }
 
+    if (this.isMPD) {
+      // Get track labels
+      this.config.i18n.audioTrackMPDLabel = mpd.getAudioTrackLabels.call(this);
+      this.config.i18n.videoTrackMPDLabel = mpd.getVideoTrackLabels.call(this);
+      // Set available tracks and quality levels
+      setQualityMenu.call(this, mpd.getQualityOptions.call(this));
+      setAudioTrackMenu.call(this, mpd.getAudioTrackOptions.call(this));
+      setVideoTrackMenu.call(this, mpd.getVideoTrackOptions.call(this));
+    }
+
     setSpeedMenu.call(this);
 
     return container;
@@ -1666,6 +1819,8 @@ const controls = {
         seektime: this.config.seekTime,
         speed: this.speed,
         quality: this.quality,
+        audioTrack: this.audioTrack,
+        videoTrack: this.videoTrack,
         captions: captions.getLabel.call(this),
         // TODO: Looping
         // loop: 'None',
diff --git a/src/js/listeners.js b/src/js/listeners.js
index 38a344007..a2619a4ca 100644
--- a/src/js/listeners.js
+++ b/src/js/listeners.js
@@ -386,7 +386,7 @@ class Listeners {
     // Handle the media finishing
     on.call(player, player.media, 'ended', () => {
       // Show poster on end
-      if (player.isHTML5 && player.isVideo && player.config.resetOnEnd) {
+      if ((player.isHTML5 || player.isMPD) && player.isVideo && player.config.resetOnEnd) {
         // Restart
         player.restart();
 
@@ -493,6 +493,50 @@ class Listeners {
       controls.updateSetting.call(player, 'quality', null, event.detail.quality);
     });
 
+    // Audio track change
+    on.call(player, player.media, 'audiotrackchange', (event) => {
+      // Update UI
+      controls.updateSetting.call(player, 'audioTrack', null, event.detail.audioTrack);
+    });
+
+    // Video track change
+    on.call(player, player.media, 'videotrackchange', (event) => {
+      // Update UI
+      controls.updateSetting.call(player, 'videoTrack', null, event.detail.videoTrack);
+    });
+
+    // Quality list update
+    on.call(player, player.media, 'qualitylistupdate', (event) => {
+      // Update UI
+      controls.setQualityMenu.call(player, event.detail.list);
+    });
+
+    // Audio track list update
+    on.call(player, player.media, 'audiotracklistupdate', (event) => {
+      // Update UI
+      controls.setAudioTrackMenu.call(player, event.detail.list);
+    });
+
+    // Video track list update
+    on.call(player, player.media, 'videotracklistupdate', (event) => {
+      // Update UI
+      controls.setVideoTrackMenu.call(player, event.detail.list);
+    });
+
+    // Audio track labels update
+    on.call(player, player.media, 'audiotracklabelsupdate', (event) => {
+      // Update UI
+      player.config.i18n.audioTrackMPDLabel = event.detail.list;
+      controls.setAudioTrackMenu.call(player, player.options.audioTrack);
+    });
+
+    // Video track labels update
+    on.call(player, player.media, 'videotracklabelsupdate', (event) => {
+      // Update UI
+      player.config.i18n.videoTrackMPDLabel = event.detail.list;
+      controls.setVideoTrackMenu.call(player, player.options.videoTrack);
+    });
+
     // Update download link when ready and if quality changes
     on.call(player, player.media, 'ready qualitychange', () => {
       controls.setDownloadUrl.call(player);
diff --git a/src/js/media.js b/src/js/media.js
index 4584fea35..a89d7d125 100644
--- a/src/js/media.js
+++ b/src/js/media.js
@@ -3,6 +3,7 @@
 // ==========================================================================
 
 import html5 from './html5';
+import mpd from './plugins/mpd';
 import vimeo from './plugins/vimeo';
 import youtube from './plugins/youtube';
 import { createElement, toggleClass, wrap } from './utils/elements';
@@ -48,6 +49,8 @@ const media = {
 
     if (this.isHTML5) {
       html5.setup.call(this);
+    } else if (this.isMPD) {
+      mpd.setup.call(this);
     } else if (this.isYouTube) {
       youtube.setup.call(this);
     } else if (this.isVimeo) {
diff --git a/src/js/plugins/ads.js b/src/js/plugins/ads.js
index 486115fa8..d73716a8c 100644
--- a/src/js/plugins/ads.js
+++ b/src/js/plugins/ads.js
@@ -67,7 +67,7 @@ class Ads {
     const { config } = this;
 
     return (
-      this.player.isHTML5 &&
+      (this.player.isHTML5 || this.player.isMPD) &&
       this.player.isVideo &&
       config.enabled &&
       (!is.empty(config.publisherId) || is.url(config.tagUrl))
diff --git a/src/js/plugins/mpd.js b/src/js/plugins/mpd.js
new file mode 100644
index 000000000..e9319acc4
--- /dev/null
+++ b/src/js/plugins/mpd.js
@@ -0,0 +1,317 @@
+// ==========================================================================
+// Plyr MPEG-DASH helpers
+// ==========================================================================
+
+import { triggerEvent } from '../utils/events';
+import i18n from '../utils/i18n';
+import is from '../utils/is';
+import { setAspectRatio } from '../utils/style';
+
+const mpd = {
+  // Reserved value that must not be the same as other values
+  qualityAutoMagicValue: Infinity,
+
+  // Get name of track
+  getTrackName(track) {
+    if (track.id) {
+      return track.id;
+    }
+    return `_index${track.index}`;
+  },
+
+  // Get human-like name of track
+  getTrackLabel(track) {
+    // Normal label
+    const labelByLanguage = track.labels.find((e) => e.lang && e.lang === navigator.language);
+    if (labelByLanguage) {
+      return labelByLanguage;
+    }
+    if (track.labels[0]) {
+      return track.labels[0].text;
+    }
+
+    // When label doesn't exist
+    const outputStr = [];
+    if (track.lang) {
+      outputStr.push(`Lang: ${track.lang}`);
+    }
+    if (track.id) {
+      outputStr.push(`ID: ${track.id}`);
+    }
+    outputStr.push(`Index: ${track.index}`);
+    return outputStr.join(', ');
+  },
+
+  // Get video labels
+  getVideoTrackLabels() {
+    const labels = {};
+    this.dash.getTracksFor('video').forEach((track) => {
+      const name = mpd.getTrackName.call(this, track);
+      const text = mpd.getTrackLabel.call(this, track);
+      labels[name] = text;
+    });
+    return labels;
+  },
+
+  // Get audio labels
+  getAudioTrackLabels() {
+    const labels = {};
+    this.dash.getTracksFor('audio').forEach((track) => {
+      const name = mpd.getTrackName.call(this, track);
+      const text = mpd.getTrackLabel.call(this, track);
+      labels[name] = text;
+    });
+    return labels;
+  },
+
+  // Get quality levels
+  getQualityOptions() {
+    const qualityList = [];
+    this.dash.getBitrateInfoListFor('video').forEach((bitrate) => {
+      if (!qualityList.includes(bitrate.height)) {
+        qualityList.push(bitrate.height);
+      }
+    });
+    // Sort by DESC
+    qualityList.sort((a, b) => b - a);
+    // "Auto"
+    qualityList.push(mpd.qualityAutoMagicValue);
+    if (this.config.quality.allowOverwrite) {
+      // Update supported options
+      this.config.quality.options = qualityList;
+    }
+    return qualityList;
+  },
+
+  // Get audio tracks
+  getAudioTrackOptions() {
+    const audioTrackList = this.dash.getTracksFor('audio').map((audioTrack) => {
+      return mpd.getTrackName.call(this, audioTrack);
+    });
+    return audioTrackList;
+  },
+
+  // Get video tracks
+  getVideoTrackOptions() {
+    const videoTrackList = this.dash.getTracksFor('video').map((videoTrack) => {
+      return mpd.getTrackName.call(this, videoTrack);
+    });
+    return videoTrackList;
+  },
+
+  setup() {
+    if (!this.isMPD) {
+      return;
+    }
+
+    const player = this;
+
+    // Config hacks
+    if (!player.config.quality.options.includes(mpd.qualityAutoMagicValue)) {
+      player.config.quality.options.push(mpd.qualityAutoMagicValue);
+    }
+    if (!player.config.i18n.qualityLabel) {
+      player.config.i18n.qualityLabel = {};
+    }
+    player.config.i18n.qualityLabel[mpd.qualityAutoMagicValue] = i18n.get('qualityAuto', player.config);
+
+    // Set speed options from config
+    player.options.speed = player.config.speed.options;
+
+    // Set aspect ratio if fixed
+    if (!is.empty(this.config.ratio)) {
+      setAspectRatio.call(player);
+    }
+
+    // Quality
+    Object.defineProperty(player.media, 'quality', {
+      get() {
+        // Check "auto" attribute
+        const settings = player.dash.getSettings();
+        if (
+          settings.streaming &&
+          settings.streaming.abr &&
+          settings.streaming.abr.autoSwitchBitrate &&
+          settings.streaming.abr.autoSwitchBitrate.video
+        ) {
+          return mpd.qualityAutoMagicValue;
+        }
+        // Get quality value
+        const currentIndex = player.dash.getQualityFor('video');
+        const bitrateList = player.dash.getBitrateInfoListFor('video');
+        if (typeof currentIndex === 'number' && bitrateList[currentIndex]) {
+          return bitrateList[currentIndex].height;
+        }
+        return undefined;
+      },
+      set(input) {
+        const dashConfig = {
+          streaming: {
+            abr: {
+              autoSwitchBitrate: {},
+            },
+          },
+        };
+
+        // If "auto"
+        if (input === mpd.qualityAutoMagicValue) {
+          // Enabling auto switch quality
+          dashConfig.streaming.abr.autoSwitchBitrate.video = true;
+          player.dash.updateSettings(dashConfig);
+        } else {
+          // Get quality by height
+          const currentIndex = player.dash.getQualityFor('video');
+          const currentHeight = currentIndex ? player.dash.getBitrateInfoListFor('video')[currentIndex].height : 0;
+          // Sorting bitrates by DESC
+          const bitrateList = player.dash.getBitrateInfoListFor('video');
+          bitrateList.sort((a, b) => b.bitrate - a.bitrate);
+          // Find quality
+          const quality = bitrateList.find((e) => e.height === input);
+          // Disabling auto switch quality
+          dashConfig.streaming.abr.autoSwitchBitrate.video = false;
+          player.dash.updateSettings(dashConfig);
+          // Update quality
+          if (quality) {
+            player.dash.setQualityFor('video', quality.qualityIndex, quality.height > currentHeight);
+          }
+        }
+
+        // If we're using an external handler...
+        if (is.function(player.config.quality.onChange)) {
+          player.config.quality.onChange(input);
+        }
+
+        // Trigger change event
+        triggerEvent.call(player, player.media, 'qualitychange', false, {
+          quality: input,
+        });
+      },
+    });
+
+    // Audio track
+    Object.defineProperty(player.media, 'audioTrack', {
+      get() {
+        if (player.dash.getActiveStream()) {
+          const currentTrack = player.dash.getCurrentTrackFor('audio');
+          if (currentTrack) {
+            return mpd.getTrackName.call(player, currentTrack);
+          }
+        }
+        return undefined;
+      },
+      set(input) {
+        // Replace already buffered frames
+        player.dash.updateSettings({
+          streaming: {
+            trackSwitchMode: {
+              audio: 'alwaysReplace',
+            },
+          },
+        });
+
+        let match;
+        if (typeof input === 'string') {
+          match = input.match(/^_index([0-9]+)$/);
+        }
+        if (match) {
+          // Find by index
+          const index = parseInt(match[1], 10);
+          const track = player.dash.getTracksFor('audio').find((e) => e.index === index);
+          // Update video track
+          if (track) {
+            player.dash.setCurrentTrack(track);
+          }
+        } else {
+          // Find by id
+          const track = player.dash.getTracksFor('audio').find((e) => e.id === input);
+          // Update audio track
+          if (track) {
+            player.dash.setCurrentTrack(track);
+          }
+        }
+
+        // If we're using an external handler...
+        if (is.function(player.config.audioTrack.onChange)) {
+          player.config.audioTrack.onChange(input);
+        }
+
+        // Trigger change event
+        triggerEvent.call(player, player.media, 'audiotrackchange', false, {
+          audioTrack: input,
+        });
+        triggerEvent.call(player, player.media, 'qualitylistupdate', false, {
+          list: mpd.getQualityOptions.call(player),
+        });
+      },
+    });
+
+    // Video track
+    Object.defineProperty(player.media, 'videoTrack', {
+      get() {
+        if (player.dash.getActiveStream()) {
+          const currentTrack = player.dash.getCurrentTrackFor('video');
+          if (currentTrack) {
+            return mpd.getTrackName.call(player, currentTrack);
+          }
+        }
+        return undefined;
+      },
+      set(input) {
+        let match;
+        if (typeof input === 'string') {
+          match = input.match(/^_index([0-9]+)$/);
+        }
+        if (match) {
+          // Find by index
+          const index = parseInt(match[1], 10);
+          const track = player.dash.getTracksFor('video').find((e) => e.index === index);
+          // Update video track
+          if (track) {
+            player.dash.setCurrentTrack(track);
+          }
+        } else {
+          // Find by id
+          const track = player.dash.getTracksFor('video').find((e) => e.id === input);
+          // Update video track
+          if (track) {
+            player.dash.setCurrentTrack(track);
+          }
+        }
+
+        // If we're using an external handler...
+        if (is.function(player.config.videoTrack.onChange)) {
+          player.config.videoTrack.onChange(input);
+        }
+
+        // Trigger change event
+        triggerEvent.call(player, player.media, 'videotrackchange', false, {
+          videoTrack: input,
+        });
+        triggerEvent.call(player, player.media, 'qualitylistupdate', false, {
+          list: mpd.getQualityOptions.call(player),
+        });
+      },
+    });
+
+    // Update settings list when perion changed
+    player.dash.on('periodSwitchCompleted', () => {
+      triggerEvent.call(player, player.media, 'qualitylistupdate', false, {
+        list: mpd.getQualityOptions.call(player),
+      });
+      triggerEvent.call(player, player.media, 'audiotracklistupdate', false, {
+        list: mpd.getAudioTrackOptions.call(player),
+      });
+      triggerEvent.call(player, player.media, 'videotracklistupdate', false, {
+        list: mpd.getVideoTrackOptions.call(player),
+      });
+      triggerEvent.call(player, player.media, 'audiotracklabelsupdate', false, {
+        list: mpd.getAudioTrackLabels.call(player),
+      });
+      triggerEvent.call(player, player.media, 'videotracklabelsupdate', false, {
+        list: mpd.getVideoTrackLabels.call(player),
+      });
+    });
+  },
+};
+
+export default mpd;
diff --git a/src/js/plugins/preview-thumbnails.js b/src/js/plugins/preview-thumbnails.js
index efc678f7c..2f59734a9 100644
--- a/src/js/plugins/preview-thumbnails.js
+++ b/src/js/plugins/preview-thumbnails.js
@@ -100,7 +100,9 @@ class PreviewThumbnails {
   }
 
   get enabled() {
-    return this.player.isHTML5 && this.player.isVideo && this.player.config.previewThumbnails.enabled;
+    return (
+      (this.player.isHTML5 || this.player.isMPD) && this.player.isVideo && this.player.config.previewThumbnails.enabled
+    );
   }
 
   load = () => {
diff --git a/src/js/plyr.d.ts b/src/js/plyr.d.ts
index 70339eb93..19018da98 100644
--- a/src/js/plyr.d.ts
+++ b/src/js/plyr.d.ts
@@ -27,6 +27,11 @@ declare class Plyr {
    */
   readonly isHTML5: boolean;
 
+  /**
+   * Indicates if the current player is MPEG-DASH.
+   */
+  readonly isMPD: boolean;
+
   /**
    * Indicates if the current player is an embedded player.
    */
@@ -97,6 +102,16 @@ declare class Plyr {
    */
   quality: number;
 
+  /**
+   * Gets or sets the audio track for the player. The setter accepts a value from the options specified in your config.
+   */
+  audioTrack: string;
+
+  /**
+   * Gets or sets the video track for the player. The setter accepts a value from the options specified in your config.
+   */
+  videoTrack: string;
+
   /**
    * Gets or sets the current loop state of the player.
    */
@@ -251,7 +266,7 @@ declare class Plyr {
 
 declare namespace Plyr {
   type MediaType = 'audio' | 'video';
-  type Provider = 'html5' | 'youtube' | 'vimeo';
+  type Provider = 'html5' | 'youtube' | 'vimeo' | 'mpd';
   type StandardEventMap = {
     progress: PlyrEvent;
     playing: PlyrEvent;
@@ -514,6 +529,11 @@ declare namespace Plyr {
      */
     youtube?: object;
 
+    /**
+     * MPEG-DASH Player Options.
+     */
+    mpd?: object;
+
     /**
      * Preview Thumbnails Options.
      */
diff --git a/src/js/plyr.js b/src/js/plyr.js
index 89162294e..cbed06f71 100644
--- a/src/js/plyr.js
+++ b/src/js/plyr.js
@@ -50,7 +50,12 @@ class Plyr {
     this.touch = support.touch;
 
     // Set the media element
-    this.media = target;
+    if (window.dashjs && target instanceof window.dashjs.constructor) {
+      this.media = target.getVideoElement();
+      this.dash = target;
+    } else {
+      this.media = target;
+    }
 
     // String selector passed
     if (is.string(this.media)) {
@@ -219,7 +224,7 @@ class Plyr {
       case 'video':
       case 'audio':
         this.type = type;
-        this.provider = providers.html5;
+        this.provider = this.dash ? providers.mpd : providers.html5;
 
         // Get config from attributes
         if (this.media.hasAttribute('crossorigin')) {
@@ -292,7 +297,7 @@ class Plyr {
 
     // Setup interface
     // If embed but not fully supported, build interface now to avoid flash of controls
-    if (this.isHTML5 || (this.isEmbed && !this.supported.ui)) {
+    if (this.isHTML5 || this.isMPD || (this.isEmbed && !this.supported.ui)) {
       ui.build.call(this);
     }
 
@@ -308,10 +313,15 @@ class Plyr {
     }
 
     // Autoplay if required
-    if (this.isHTML5 && this.config.autoplay) {
+    if ((this.isHTML5 || this.isMPD) && this.config.autoplay) {
       this.once('canplay', () => silencePromise(this.play()));
     }
 
+    // playsinline for MPD
+    if (this.isMPD && this.config.playsinline) {
+      this.media.setAttribute('playsinline', '');
+    }
+
     // Seek time will be recorded (in listeners.js) so we can prevent hiding controls for a few seconds after seek
     this.lastSeekTime = 0;
 
@@ -344,6 +354,10 @@ class Plyr {
     return this.provider === providers.vimeo;
   }
 
+  get isMPD() {
+    return this.provider === providers.mpd;
+  }
+
   get isVideo() {
     return this.type === types.video;
   }
@@ -427,7 +441,7 @@ class Plyr {
    * Stop playback
    */
   stop = () => {
-    if (this.isHTML5) {
+    if (this.isHTML5 || this.isMPD) {
       this.pause();
       this.restart();
     } else if (is.function(this.media.stop)) {
@@ -631,7 +645,7 @@ class Plyr {
    */
   get hasAudio() {
     // Assume yes for all non HTML5 (as we can't tell...)
-    if (!this.isHTML5) {
+    if (!this.isHTML5 || !this.isMPD) {
       return true;
     }
 
@@ -724,6 +738,96 @@ class Plyr {
     return 16;
   }
 
+  /**
+   * Set audio track
+   */
+  set audioTrack(input) {
+    const config = this.config.audioTrack;
+    const options = this.options.audioTrack;
+
+    if (!options.length) {
+      return;
+    }
+
+    let audioTrack = [!is.empty(input) && input, this.storage.get('audioTrack'), config.selected, config.default].find(
+      (e) => e,
+    );
+
+    let updateStorage = true;
+
+    if (!options.includes(audioTrack)) {
+      const value = closest(options, audioTrack);
+      this.debug.warn(`Unsupported audioTrack option: ${audioTrack}, using ${value} instead`);
+      audioTrack = value;
+
+      // Don't update storage if quality is not supported
+      updateStorage = false;
+    }
+
+    // Update config
+    config.selected = audioTrack;
+
+    // Set audio track
+    this.media.audioTrack = audioTrack;
+
+    // Save to storage
+    if (updateStorage) {
+      this.storage.set({ audioTrack });
+    }
+  }
+
+  /**
+   * Get current audio track
+   */
+  get audioTrack() {
+    return this.media.audioTrack;
+  }
+
+  /**
+   * Set video track
+   */
+  set videoTrack(input) {
+    const config = this.config.videoTrack;
+    const options = this.options.videoTrack;
+
+    if (!options.length) {
+      return;
+    }
+
+    let videoTrack = [!is.empty(input) && input, this.storage.get('videoTrack'), config.selected, config.default].find(
+      (e) => e,
+    );
+
+    let updateStorage = true;
+
+    if (!options.includes(videoTrack)) {
+      const value = closest(options, videoTrack);
+      this.debug.warn(`Unsupported videoTrack option: ${videoTrack}, using ${value} instead`);
+      videoTrack = value;
+
+      // Don't update storage if quality is not supported
+      updateStorage = false;
+    }
+
+    // Update config
+    config.selected = videoTrack;
+
+    // Set video track
+    this.media.videoTrack = videoTrack;
+
+    // Save to storage
+    if (updateStorage) {
+      this.storage.set({ videoTrack });
+    }
+  }
+
+  /**
+   * Get current video track
+   */
+  get videoTrack() {
+    return this.media.videoTrack;
+  }
+
   /**
    * Set playback quality
    * Currently HTML5 & YouTube only
@@ -1199,7 +1303,7 @@ class Plyr {
     clearTimeout(this.timers.resized);
 
     // Provider specific stuff
-    if (this.isHTML5) {
+    if (this.isHTML5 || this.isMPD) {
       // Restore native video controls
       ui.toggleNativeControls.call(this, true);
 
diff --git a/src/js/source.js b/src/js/source.js
index a62edbba7..f55d9e9ff 100644
--- a/src/js/source.js
+++ b/src/js/source.js
@@ -56,7 +56,7 @@ const source = {
         // Set the type and provider
         const { sources, type } = input;
         const [{ provider = providers.html5, src }] = sources;
-        const tagName = provider === 'html5' ? type : 'div';
+        const tagName = ['html5', 'mpd'].includes(provider) ? type : 'div';
         const attributes = provider === 'html5' ? {} : { src };
 
         Object.assign(this, {
@@ -68,6 +68,15 @@ const source = {
           media: createElement(tagName, attributes),
         });
 
+        // Initialize MPEG-DASH
+        if (this.isMPD && window.dashjs) {
+          const dash = window.dashjs.MediaPlayer().create();
+          dash.initialize(this.media, src, false);
+          Object.assign(this, {
+            dash,
+          });
+        }
+
         // Inject the new element
         this.elements.container.appendChild(this.media);
 
@@ -77,7 +86,7 @@ const source = {
         }
 
         // Set attributes for audio and video
-        if (this.isHTML5) {
+        if (this.isHTML5 || this.isMPD) {
           if (this.config.crossorigin) {
             this.media.setAttribute('crossorigin', '');
           }
@@ -121,7 +130,7 @@ const source = {
         }
 
         // If HTML5 or embed but not fully supported, setupInterface and call ready now
-        if (this.isHTML5 || (this.isEmbed && !this.supported.ui)) {
+        if (this.isHTML5 || this.isMPD || (this.isEmbed && !this.supported.ui)) {
           // Setup interface
           ui.build.call(this);
         }
diff --git a/src/js/support.js b/src/js/support.js
index 9b5d2aa04..3f7af6021 100644
--- a/src/js/support.js
+++ b/src/js/support.js
@@ -26,7 +26,7 @@ const support = {
   // Basic functionality vs full UI
   check(type, provider, playsinline) {
     const canPlayInline = browser.isIPhone && playsinline && support.playsinline;
-    const api = support[type] || provider !== 'html5';
+    const api = support[type] || !['html5', 'mpd'].includes(provider);
     const ui = api && support.rangeInput && (type !== 'video' || !browser.isIPhone || canPlayInline);
 
     return {
diff --git a/src/js/ui.js b/src/js/ui.js
index 31eadf294..762f8b4fa 100644
--- a/src/js/ui.js
+++ b/src/js/ui.js
@@ -20,7 +20,7 @@ const ui = {
 
   // Toggle native HTML5 media controls
   toggleNativeControls(toggle = false) {
-    if (toggle && this.isHTML5) {
+    if (toggle && (this.isHTML5 || this.isMPD)) {
       this.media.setAttribute('controls', '');
     } else {
       this.media.removeAttribute('controls');
@@ -57,7 +57,7 @@ const ui = {
     ui.toggleNativeControls.call(this);
 
     // Setup captions for HTML5
-    if (this.isHTML5) {
+    if (this.isHTML5 || this.isMPD) {
       captions.setup.call(this);
     }
 
@@ -92,7 +92,7 @@ const ui = {
     toggleClass(
       this.elements.container,
       this.config.classNames.pip.supported,
-      support.pip && this.isHTML5 && this.isVideo,
+      support.pip && (this.isHTML5 || this.isMPD) && this.isVideo,
     );
 
     // Check for airplay support
diff --git a/src/js/utils/i18n.js b/src/js/utils/i18n.js
index 708685272..34b2c14c6 100644
--- a/src/js/utils/i18n.js
+++ b/src/js/utils/i18n.js
@@ -13,6 +13,7 @@ const resources = {
   html5: 'HTML5',
   vimeo: 'Vimeo',
   youtube: 'YouTube',
+  mpd: 'MPEG-DASH',
 };
 
 const i18n = {
diff --git a/src/js/utils/style.js b/src/js/utils/style.js
index e05e058f0..134d05922 100644
--- a/src/js/utils/style.js
+++ b/src/js/utils/style.js
@@ -74,7 +74,7 @@ export function getAspectRatio(input) {
   }
 
   // Get from HTML5 video
-  if (ratio === null && this.isHTML5) {
+  if (ratio === null && (this.isHTML5 || this.isMPD)) {
     const { videoWidth, videoHeight } = this.media;
     ratio = [videoWidth, videoHeight];
   }
@@ -115,7 +115,7 @@ export function setAspectRatio(input) {
     } else {
       this.media.style.transform = `translateY(-${offset}%)`;
     }
-  } else if (this.isHTML5) {
+  } else if (this.isHTML5 || this.isMPD) {
     wrapper.classList.add(this.config.classNames.videoFixedRatio);
   }