Danmaku Anywhere puts bullet comments on almost any video site

One extension, many sites, and a separate web app

Danmaku Anywhere is an open source project whose aim is to add danmaku to almost every video website you like. The Chinese name translates as danmaku anywhere, and the project describes itself as an open source solution to add danmaku to almost every video website.

The danmaku format, the scrolling comments that overlay a video, was invented for a Chinese video site and spread from there. The problem this project addresses is that those comments are tied to the site that holds them: they exist in one ecosystem and not another, so a show you watch on a streaming platform has no comments and a show in your own media library has none either.

The extension covers the first problem. The README lists the sites it aims at in two groups: self hosted media servers such as Plex, Emby, Jellyfin and a Chinese NAS product, and streaming platforms such as YouTube and Crunchyroll, plus other video sites. The stated design is a pure browser experience with no desktop client required, which is the practical constraint that makes it work on a media server you run yourself.

The second part of the project is a web application, and the README is careful to label it as an experimental project. It aims to provide Kazumi-like functionality in the browser, meaning you can watch video from one site through rules that fetch it from another, and it can play local video files. It supports PWA, so it installs to a home screen.

The important dependency is that the web app needs the extension installed before it can be used. That is an unusual dependency between two parts of one project, and it is worth understanding before you try the web app alone: it is not a standalone player, it is a front end that leans on the extension to do the fetching and the comment rendering.

The project is TypeScript, the last push was on 2026-10-20, and the recent releases are all nightly preview builds, nightly-39189218761 from 2026-10-19, nightly-39089314337 from 2026-10-18 and nightly-38669895111 from 2026-10-15.

Where the comments come from

The extension does not host comments itself. It fetches them from existing danmaku sources, and the README lists the ones currently supported.

The first is Dandanplay, the service that aggregates danmaku across Chinese video sites and is the closest thing to a general-purpose danmaku API. Then Bilibili, then Tencent, then MacCMS in its Vod variant, which covers the large family of self hosted video sites built on that content management system. The last category is any service compatible with the Dandanplay API, and the README links danmu-api as an example of one.

That last point is the important one for anyone self hosting. Because the extension speaks the Dandanplay API, you are not limited to the listed providers. If you run a compatible service, you can point the extension at it and use your own comment data.

Two features handle the case where the automatic sources fail. Manual import supports bringing in local danmaku files in `.xml` format, and export does the reverse, writing the comments you have watched as `.xml` files. So the format is a portable artefact rather than a locked-in database, which means a library of comments is something you own.

Matching is the other half. The extension supports custom matching rules, and an AI matching feature. The automatic matching searches for danmaku based on the video being played, and it can also automatically associate a local danmaku file with the same name. That second behaviour is the one that matters for a media server, where your files have names and the comment file for a show is named the same way.

So there are three ways a comment track reaches the screen: an automatic search against a remote source, an automatic association with a local file of the same name, and a manual import. The custom rules are there to make the first one work when the title on your server does not match the title in the comment database.

Installing it, and what is not supported

The installation is a browser store listing per browser, and the support table is worth reading carefully because two entries are negative.

For desktop, Chrome, Edge and Opera install from their respective stores, and Firefox installs from Firefox Add-ons. Safari is marked as not supported.

For mobile, Android works through Kiwi, Lemur or Edge Canary, using the `.crx` or `.zip` download from the documentation site or from a GitHub release. iOS is marked as not supported, with the reason given in the table as being limited by the platform.

The mobile route is different in kind from the desktop one, since those Android browsers can load an unpacked or packaged extension, which is why the download is a `.crx` or a `.zip` rather than a store link.

There is also a preview channel. The README says that if you want to try the latest unreleased version you can download a pre-release from the download page or from the GitHub releases. Given that the recent release tags in the repository are all named nightly builds with a build number, the preview channel is where most of the recent work is visible, and the stable releases are where you want to be if you are not chasing features.

The first use is four steps. Install the extension. Open a video site, such as Plex. Right click on an empty area of the site and choose the option to add a configuration for the current site. Then click the extension icon in the lower left of the site, and let it match or search for danmaku automatically.

The right-click configuration step is the one that is unusual, and it is there because the extension has to be told what it is looking at: the site, the player and whatever the local conventions are for naming things. Once that configuration exists for a site, the extension icon in the corner handles matching from then on.

The full documentation is at docs.danmaku.weeblify.app, with the getting started page as the entry point.

The monorepo, and how a contributor works in it

The repository is a pnpm workspace, and the root `package.json` shows the shape of the development setup:

  "scripts": {
    "dev:web-app": "pnpm -r -F \"./app/web\" start",
    "dev:extension": "pnpm -r -F \"./packages/danmaku-anywhere\" dev",
    "dev:extension:standalone": "pnpm -r -F \"./packages/danmaku-anywhere\" standalone:dev",
    "build": "pnpm -r build",
    "release-manager": "pnpm --filter @danmaku-anywhere/release-manager dev",
    "build:packages": "pnpm -r -F \"./packages/**\" build",
    "format": "pnpm -r -F \"./packages/**\" format",
    "lint": "pnpm -r -F \"./packages/**\" lint",
    "lint:ci": "pnpm -r lint:ci",
    "test": "pnpm -r test",
    "type-check": "pnpm -r type-check",
    "sync-changelog": "node --experimental-strip-types scripts/sync-changelog.ts Mr-Quin/danmaku-anywhere docs/src/content/docs/change-log.mdx",
    "knip": "knip",
    "prepare": "lefthook install"
  },

The `-F` filters are the interesting part, because they show the packages are independent. The web app lives in `./app/web`, the extension in `./packages/danmaku-anywhere`, and there is a separate release manager package under its own name, `@danmaku-anywhere/release-manager`. So the extension and the web app are developed and built separately even though they live in one repository, which matches the fact that the web app depends on the extension at run time rather than at build time.

The `standalone:dev` script is a separate development mode for the extension, which suggests the extension can be run outside a page, which is how you would work on the comment matching logic without a video to test against.

The tooling is current and opinionated. The package manager is pinned to `[email protected]`, the TypeScript version is 6, the linter and formatter is Biome at 2.4.15, and `knip` is there to find unused files, exports and dependencies, which is a useful guard in a monorepo where packages drift apart. `lefthook` is installed by the `prepare` script, so the git hooks are set up automatically on install.

The rest of the layout follows the monorepo conventions: `packages/` for the published pieces, `app/` for the applications including the web app, `backend/`, `docs/` for the documentation site, `scripts/`, `legacy/` for the older code, and `patches/` for patch files applied to dependencies. There is a `mise.toml` for tool version management, a `.devcontainer/` directory, and a `tsconfig.base.json` with the shared compiler configuration.

Licences differ per package, and the roadmap is on a board

The licensing is worth reading carefully, because it is not uniform.

The README says each package in the project has its own licence, and that in general every package is MIT except the danmaku-anywhere extension, which is AGPL. The details are in the LICENSE file in the repository root.

So the piece you install in your browser, the extension that runs on every site you visit and talks to comment APIs, is the AGPL one, while the web app, the backend and the supporting packages are MIT. If you want to fork the extension and distribute a modified version, the AGPL is the term that applies, and it is a copyleft licence with network use obligations. If you only want to run the web app, the MIT term applies to it.

That split is a deliberate structure rather than an oversight, and it means the answer to whether you can use this commercially depends on which part you take.

The roadmap is a separate matter. The README points at a project board for the to-do items, and lists the recent priorities: support for local AI, intelligent blocking of comments, and watching together. Local AI in that context means the matching step running on your own machine rather than calling a hosted service, which fits the pattern of the rest of the project, where the extension tries to be a pure browser experience with no desktop client and the comment data comes from sources you choose.

Intelligent blocking is the counterpart to the comment overlay. Danmaku can obscure the picture, and the project is planning a way to deal with that automatically rather than leaving it to you to filter by hand.

The contribution guidance is short and generous. The README welcomes contributions of any kind, including code, art assets and documentation, and points contributors with an interest in the project development at the development documentation, which covers the repository structure.

Art assets get their own credit section, naming two artists, which is a reminder that a project with a visual layer of this kind depends on more than code.

Editorial conclusion

Adopt Danmaku Anywhere if you want comment overlays on a self hosted media library or on the streaming sites you already use, and you are willing to install an extension that reaches out to third party comment APIs on your behalf. Do not adopt it on iOS or Safari, which the README lists as unsupported, and note that the extension is AGPL licensed while the other packages are MIT. Verify first which danmaku source you intend to use and that it is one of the listed ones, that the extension and the web app agree on the same setup, and that the version you install is a release rather than one of the nightly preview builds, whose names carry a build number rather than a version.

Frequently asked questions

Official sources

1. Issues
2. Mr-Quin/danmaku-anywhere on GitHub
3. Project website
4. README
5. Releases