Shaka Player: a browser video player that speaks DASH and HLS without plugins

What Shaka Player solves, and who ends up using it

Browsers do not play DASH or HLS natively in a uniform way. Safari has its own HLS handling, Chrome and Firefox rely on the Media Source Extensions API, and a manifest is not something a video element can consume on its own. Shaka Player sits in that gap. It parses the manifest, picks a representation, and feeds segments to the browser through MSE, so the same JavaScript works across desktop and mobile browsers without a plugin or Flash.

The library is aimed at people shipping video to browsers rather than at people encoding it. The README states the main goal plainly: make adaptive bitrate streaming easy using modern browser technologies, and keep the library light, simple, and free from third-party dependencies. That last part matters in practice. There is no bundled UI framework and no ad SDK to drag along, which is why the player shows up in embedded contexts as well as web pages.

The support matrix is the fastest way to see whether you are in the target audience. Chrome, Firefox, Edge Chromium and Opera are marked Y on Windows, Mac and Linux. Safari is Y on Mac. iOS 9 and later are handled through Apple's native HLS player rather than MSE, which the README describes as setting the video's src element to the manifest. Chromecast, Tizen, WebOS, Xbox One, PlayStation 4 and 5, and several TV operating systems appear in the Other column.

How the player moves a manifest to pixels

The flow has four visible stages. A manifest parser reads the DASH MPD or the HLS playlist. A streaming engine selects an adaptation set and a representation based on the browser's reported capabilities and on your configuration. The player fetches segments and appends them to a SourceBuffer created through MediaSource. For encrypted content, it negotiates a key system through Encrypted Media Extensions, with support for custom ContentProtection schemas and PSSH data carried in the manifest.

Two details in the repository layout show how much of this is pluggable. There is a transmuxer_worker.uncompiled.js at the top level, which indicates that repackaging TS into fMP4 can run in a worker rather than on the main thread. The README also documents a manifest parser plugin, so a custom manifest format does not require forking the library.

The DASH feature list is long but worth reading against your own manifests. Supported items include multi-period content, SegmentTemplate with $Number$ and $Time$, SegmentList, SegmentBase@indexRange, key rotation, trick mode tracks, WebVTT and TTML, and CEA-608/708 captions. MPD Patch updates are supported for SegmentTemplate with $Number$ and for SegmentTimeline with $Number$ or $Time$. On the HLS side the README lists VOD, Live and Event types, plus low-latency streaming with partial segments, preload hints, delta updates and blocking playlist reload.

Installing Shaka Player and playing a stream

The package is published as shaka-player on npm, which is one of the search phrases people use when they are looking for it. The README points at the sources for building and deploying, and the demo directory in the repository contains the reference application. A first use is short: install the package, create a Player against a video element, then call load with a manifest URI.

The README does not give an install command, so the only thing to go on is the package name in package.json. The repository is where the build and deploy instructions live, and the demo application is the working example to copy from.

npm install shaka-player

That is the npm package name from package.json. From there you can import the compiled build in a bundler-based project, or reference a hosted build if you are loading it in a plain page. The README does not spell out the import path, so the demo application and the API documentation are where the exact constructor and load call should be read rather than guessed.

One thing the README does state about load failures is that Shaka surfaces structured errors rather than bare exceptions, which is where the error codes people search for come from. The README does not enumerate those codes, so the API documentation is the place to look them up.

Where the support matrix says no

The DASH section of the README is explicit about what is missing, and it is a more useful list than the feature list. Xlink with actuate=onRequest is not supported, only actuate=onLoad. Manifests with no segment info at all are not supported. Multiple trick mode tracks for the same resolution at varying framerates or bitrates are out. Timescales so large that timestamps cannot be represented as integers in JavaScript, which the README puts at 2^53, are out. Modifying elements with an @schemeIdUri attribute through MPD Patch is unsupported, and so is Xlink dereferencing with MPD Patch.

The manifest format matrix is narrower than the platform matrix. DASH covers Video On-Demand, Live and In-Progress Recording, with Event left blank. HLS covers Video On-Demand, Live and Event, with In-Progress Recording left blank. If your pipeline produces event-type DASH or in-progress-recording HLS, the matrix does not claim support for it.

Platform support has its own caveats. Several entries are marked as expected to work but community-supported and untested by the team, including WebOS, Hisense, Vizio, PlayStation 4 and 5, Titan OS and TiVo OS. Firefox and Edge Chromium on Android are listed as untested. Tizen 2017 is the model the team tests; Tizen 2016 is community-supported. Reading those footnotes before promising a platform to a stakeholder is the difference between a plan and a surprise.

Shaka Player against hls.js, dash.js and Video.js

The comparison that matters is scope. hls.js handles HLS and only HLS. It is a smaller surface to learn if HLS is all you serve, and it does not ask you to think about MPD parsing at all. Shaka Player handles both DASH and HLS in one library, so a service with two manifest formats keeps one player integration instead of two.

dash.js is the mirror image: DASH-focused, with the DASH-IF community behind it. If your manifests are DASH and you want the implementation to track the DASH specification closely, that alignment is the argument for it. Shaka Player's DASH support is broad but, as the unsupported list shows, not complete.

Video.js is a different kind of project. It is a player framework with a plugin ecosystem and a skinning layer, and adaptive streaming arrives through plugins such as videojs-contrib-hls or a DASH plugin. Shaka Player ships no such UI framework; the demo in the repository is a reference, not a product. If you need a styled player with an ecosystem of plugins, Video.js gives you that starting point. If you want the streaming engine and nothing else, Shaka Player is the thinner dependency.

Bitmovin appears in the same search space but is a commercial product rather than a library you install from npm, so the trade-off there is licensing and support rather than code.

Maintenance, releases and the licence

The repository is not archived, and the last push was on 2026-09-21. Releases are frequent and split across lines: v5.2.11, v5.1.24 and v4.16.50 all landed on 2026-09-18. Three maintained lines receiving fixes on the same day is a real commitment to older integrations, and it also means you have a choice to make when you pin a version.

The README defers that choice to maintained-branches.md, which is the file to read before committing to a line. The practical cost sits in the upgrade path: the library is written against Closure Compiler, and the repository carries externs, a build directory and a conditional directory alongside lib. If you consume the published npm package you avoid most of that, but if you build from source you inherit the toolchain. The version in package.json is 5.2.0 while the newest release is v5.2.11, which is normal for a release-please setup and worth knowing if you compare the two numbers.

The licence is Apache-2.0. That permits commercial use and modification, and it includes a patent grant. It also carries notice and attribution obligations, and the repository has an AUTHORS file and an AGENT-ATTRIBUTION.md at the top level. What those obligations mean for your distribution is a question for your own counsel, not something this review can settle.

Editorial conclusion

Adopt Shaka Player if you serve DASH or HLS to browsers and want a dependency-light player you can also embed in a Chromecast receiver or a Tizen 2017 set. Do not adopt it if your target is a plain MP4 progressive download, or if you need the Actuate=onRequest Xlink and MPD Patch combinations the DASH matrix lists as unsupported. Verify first that your manifest format appears in the support matrix, and check maintained-branches.md before you pin a version.

Frequently asked questions

Official sources

1. License: Apache-2.0
2. Project website
3. README
4. Releases
5. shaka-project/shaka-player on GitHub