# better-douyin: the open shell of a Douyin desktop app, with a mock backend

> better-douyin is a Rust and Tauri desktop client for Douyin whose public repository ships only the frontend UI, a mock bridge, a dependency free mock backend and the collaboration boundaries, while the working application is distributed as a release build under a non commercial licence. It is aimed at contributors who want to work on the interface and at developers who want to plug their own services into the same contract.

**anYuJia/better-douyin** — 打造更好用的douyin，支持作者级下载、播放、点赞收藏、私信、通知、mcp服务接入ai控制，内置ai可以在私信与好友ai聊天。douyin download

- Repository: https://github.com/anYuJia/better-douyin
- Website: https://douyin.yhan.fun/
- Stars: 1,061 · Forks: 109
- Language: TypeScript
- License: NOASSERTION
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/anyujia-better-douyin

## What is open and what is not

The clearest thing in this repository is the boundary it draws, and the README draws it in the open rather than burying it.

The public source is described as an Open Shell. It keeps the frontend UI, the mock bridge, the mock backend and the collaboration boundaries, while the complete usable application is to be downloaded from Releases. The README states that the public source does not include real platform connectors, signing, cookies, encryption, real interfaces, download parsing or release keys.

That list is specific enough to be useful. What is missing is exactly the part that touches the platform: the code that authenticates, the code that signs requests, the code that parses a share link into a real media URL, and the keys used for publishing. The repository is the interface and the seams; the release build is the application.

The project description says the same from the other direction. It lists author level download, playback, likes and favourites, private messages, notifications, MCP service access for AI control, and a built-in AI for chatting in private messages and with friends.

The README also positions the project as the Rust and Tauri desktop version, focused on a lighter runtime, more stable local playback, a smoother desktop experience and more reliable cross platform distribution. The badges match: Rust 1.80 or newer, Tauri 2, a frontend of React, Vite and TypeScript, and a backend labelled Node.js Mock.

## A frontend shell plus a mock backend

The repository layout is small and says the design out loud. There is a `frontend/` directory, a `backend/` directory, `docs/` with preview screenshots, `scripts/`, a `package.json`, a `LICENSE`, an `OPEN_SOURCE.md` and a `SECURITY_BOUNDARY.md`.

The two documents at the top are the ones to read first. `SECURITY_BOUNDARY.md` names the boundary explicitly, and `OPEN_SOURCE.md` states what the open code is for. The README lists the same four intents for the public source: understanding the product interface, interactions and frontend architecture, improving the UI and UX, themes, components, responsiveness and accessibility, giving other AI tools or collaborators safe context, and connecting services you are entitled to maintain to the same frontend contract.

That last point is the interesting one for a developer. The public shell is a working contract. The frontend talks to a bridge, the bridge talks to a backend, and the mock backend implements that backend's API with demo data. If you maintain a service of your own, you can implement the same endpoints and the UI works against it.

The mock backend is deliberately trivial. `backend/server.mjs` is a Node.js mock backend with no third party dependencies, providing only local demo APIs: `GET /api/health`, `GET /api/config`, `GET /api/account`, `GET /api/videos`, `GET /api/downloads`, `POST /api/ai/suggest`, and `GET /` which serves the built `dist/` output statically. The README states that it does not read cookies, does not access the real platform, does not generate signatures, does not upload credentials and does not contain any real interface information.

## Four npm commands and a demo

Running the public shell is four commands, and the README presents them as the quick path.

For local development:

```bash
npm --prefix frontend install
npm run dev
```

To build the frontend:

```bash
npm run build
```

To start the mock backend and preview the build output:

```bash
npm run server
```

And one command to build and start the public demo together:

```bash
npm run demo
```

The root package.json is the script host, and it is marked `"private": true` with `"type": "module"`. The scripts map onto the frontend and the backend: `dev`, `build` and `preview` all delegate to `npm --prefix frontend run ...`, `server` is `node backend/server.mjs`, `server:check` is the same file with a `--check` argument, and `demo` is `npm run build && npm run server`.

There are also two maintenance scripts worth knowing about, `docs:sponsors` running `node scripts/sync-sponsors.mjs` and `docs:sponsors:image` running `node scripts/generate-sponsors.mjs`, which is how the sponsor section of the documentation is regenerated.

Note the naming. The package is called `better-douyin-private-public-shell` and its version field reads 1.1.5, while the tagged releases are in the v1.1.3x range. The private shell and the published application are versioned and released separately, which is consistent with the shell being a published artefact rather than the product itself.

## What the released application does

The feature list in the README describes the full release build, and it is worth reading as a specification of what a Douyin desktop client does today.

For content and browsing, the home screen offers search for users, link parsing, recommended videos and favourite videos, plus local download statistics. You can search by nickname, Douyin ID or UID and view a user's profile, works, follower and following counts and likes. Share links, short links and full work URLs can be pasted to resolve a single video, an image set or some Live Photo content. There is browsing of user works, recommended videos, liked videos, favourite videos, favourite collections and the works inside a collection, with a recommendation feed supporting featured and recommended switching, scroll browsing, quick playback, one click download and batch download.

For downloading, there are queues with progress, live logs, pause, resume and cancel, failure prompts and skipping of duplicate files. Downloads can be archived by author or collection, with configurable download directories, author directory rules, file naming templates, concurrency and quality. My Downloads offers a file view and a work view, with search, filtering, pagination, playback, locating a file, deleting files and directory synchronisation.

The player is described as immersive, with video and image set switching, progress control, volume, speed, quality switching, autoplay of the next item and retry on failure. Inside it you can download, like, favourite, share, view comments, jump to a comment from a notification and generate a comment draft. There is a notification centre for likes, comments and follows, a friends module with presence, following lists, private message conversations, history sync, unread reminders and share cards, and AI interaction through OpenAI Compatible providers for comments, private message replies and content analysis.

The automation section is the part to read carefully, because the README is explicit that it needs the user to switch it on: with explicit user enabling, it can perform automatic commenting and private message drafts, automatic likes, automatic favourites, follow back after a follow, and sending media back after a share. Automatic monitoring covers the recommendation feed, friend private messages, notifications, the comment area and creator work updates, with keyword filters, thresholds, scan intervals, per round limits and an automatic action log.

## A local HTTP MCP service and an explicit confirmation model

One feature stands out among the rest, and it is the one most likely to matter to a reader with an AI tooling interest.

The application provides a local HTTP MCP service that lets AI tools such as Codex, Claude Code and OpenClaw read content, control download tasks and perform write operations with explicit confirmation, under user authorisation.

That is a different model from most integrations of this kind. The service is local, it is HTTP rather than a bespoke protocol, and the write side requires explicit confirmation. In a tool that can like and comment on your behalf, being able to gate writes is the difference between a feature you would enable and one you would not.

The rest of the desktop and distribution notes cover the practical side. Cookies, accounts, configuration, download history, cache and local files are all kept on your own machine. There is built-in login, manual cookie entry, account state validation, multi account switching and account deletion. The Rust and Tauri build gives a lighter desktop runtime, native windows, a sidebar that expands and collapses, small screen adaptation and a more stable local playback experience. Distribution covers cross platform releases, automatic updates, an update proxy, checksum verification of release builds and a startup integrity notice.

The activation arrangement is described at the top of the README. The project tools are always free, activation codes are distributed through a QQ group message thread, and the purpose of the code is stated as preventing secondary resale and abuse. So the tooling is free, but the working application behind the release downloads is gated behind an activation code.

## The licence forbids the commercial path outright

The licence is the most consequential fact about this project, and the README is unusually direct about it.

The public version is licensed under the Better Douyin Non-Commercial License in the root LICENSE file, and it permits only personal, non commercial use, copying, learning, modification and testing for learning, research, academic discussion and testing. Without prior written permission from the copyright holder, it prohibits any form of commercial distribution, paid downloads or download on behalf, paid mirrors, hosting, SaaS or deployment on behalf services, commercial integration, data sale, and any other direct or indirect profit seeking use.

That is broader than the usual open source grant and narrower than a permissive licence in effect. There is no copyleft obligation to publish your changes; instead you simply may not use it commercially at all. The repository licence field is correspondingly classified as a custom licence that GitHub cannot classify, and the badge reads License: Non-Commercial.

The README also puts the platform obligations on the user rather than offering help. Users should follow the relevant platform rules themselves, and bear the consequences of their own account environment, request rate and platform policy changes, which include account anomalies, risk control verification, throttling, bans, unavailable content and data loss. The author explicitly does not provide support for evading platform risk control, unbanning, account recovery or circumventing restrictions.

That last sentence is the one to keep in mind when reading the automation feature list. The project documents what the application can do, and it explicitly declines to help with the part of the problem that arises when a platform notices.

## Conclusion

Adopt the public better-douyin repository if you want to contribute to the interface of a Douyin desktop client or build your own services against the same frontend contract, and you can accept that the platform connectors are absent. Skip it if you need the working application from source, because the README states that the public code contains no real platform connectors, signing, cookies, encryption, real interfaces, download parsing or release keys, and the actual app comes as a release download. Verify first that the non commercial terms in the LICENSE file match your intended use, since commercial distribution, paid mirrors, hosted deployment and data sale are all prohibited without written permission. The last push was on 2026-10-09, and the tagged releases are v1.1.31, v1.1.32 and v1.1.34 from September and October 2026.

## FAQ

### What does the better-douyin repository actually contain?

The public source is an Open Shell that keeps the frontend UI, the mock bridge, the mock backend and the collaboration boundaries. The README states it does not include real platform connectors, signing, cookies, encryption, real interfaces, download parsing or release keys, and the complete application is distributed through Releases.

### How do I run the better-douyin public shell locally?

Run `npm --prefix frontend install` and then `npm run dev` for development, `npm run build` to build the frontend, `npm run server` to start the mock backend and preview the build output, or `npm run demo` to build and start the demo in one command.

### What does the mock backend in better-douyin provide?

`backend/server.mjs` is a Node.js mock backend with no third party dependencies that offers local demo APIs: `GET /api/health`, `GET /api/config`, `GET /api/account`, `GET /api/videos`, `GET /api/downloads`, `POST /api/ai/suggest`, and `GET /` serving the built `dist/` output. It does not read cookies, access the real platform, generate signatures or upload credentials.

### What can the better-douyin MCP service do?

It provides a local HTTP MCP service that lets tools such as Codex, Claude Code and OpenClaw read content, control download tasks and execute write operations with explicit confirmation, under user authorisation. The README also notes the author does not support evading platform risk control, unbanning, account recovery or circumventing restrictions.

### What licence does better-douyin use?

The public version is licensed under the Better Douyin Non-Commercial License in the root LICENSE file, permitting personal non commercial learning, research, academic discussion and testing. Commercial distribution, paid downloads or mirrors, hosted, SaaS or deployment services, commercial integration and data sale all require prior written permission.

### How current is better-douyin?

The tagged releases are v1.1.31 on 2026-09-28, v1.1.32 on 2026-10-03 and v1.1.34 on 2026-10-08, with the last push on 2026-10-09. The root package.json is named `better-douyin-private-public-shell` and reads version 1.1.5, and the badges show Rust 1.80 or newer and Tauri 2.

## Sources

- [anYuJia/better-douyin on GitHub](https://github.com/anYuJia/better-douyin)
- [Issues](https://github.com/anYuJia/better-douyin/issues)
- [Project website](https://douyin.yhan.fun/)
- [README](https://github.com/anYuJia/better-douyin/blob/main/README.md)
- [Releases](https://github.com/anYuJia/better-douyin/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/anyujia-better-douyin