# JiwuChat: a Tauri2 and Nuxt3 chat client with AI assistants built in

> JiwuChat is a cross-platform instant messaging client for desktop, Android and the web, built with Tauri2 and Nuxt3 and shipped under AGPL-3.0. The README documents the feature set and a self-hosting path, but not the client build prerequisites or the environment keys.

**KiWi233333/JiwuChat** — JiwuChat 🍂 - A lightweight cross-platform instant messaging app with integrated AI assistants (DeepSeek/Gemini/Kimi). Features real-time messaging, audio/video calls, multi-device sync, and customizable themes. Built with Vue3 & Tauri2 🍒

- Repository: https://github.com/KiWi233333/JiwuChat
- Website: https://blog.jiwuchat.top
- Stars: 748 · Forks: 141
- Language: Vue
- License: AGPL-3.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/kiwi233333-jiwuchat

## What JiwuChat is and who it is aimed at

JiwuChat is a chat application that runs on Windows, macOS, Linux, Android and the web from what the README calls "一套代码，多端适配" (one codebase, multiple platforms). The README states the build is based on Tauri2 and Nuxt3 and describes the package as lightweight, around 10MB. It is not a chat protocol or a server; it is the client, and the README says a separate repository, jiwu-chat-core, provides the backend service with Docker deployment.

The audience is fairly narrow. If you want a self-hosted messenger for a small group and you also want an LLM sitting inside the conversation, this is one of the few clients that treats AI as a first-class participant rather than a plugin. The README lists private AI chat, group AI chat, and multiple AIs talking at once, with DeepSeek, Kimi AI, Gmini and SiliconFlow named as supported model providers. It also lists token counting and a model list inside the AI module. For a team that already pays for one of those providers, the integration is the reason to look.

The feature table is unusually complete by open source chat app standards. It covers message recall, quoted replies, @mentions, read receipts, pinned and hidden conversations, group administration, friend requests, desktop notifications, system tray alerts and a do-not-disturb mode. Voice and video calls plus screen sharing are built on WebRTC. Themes include light, dark and system-follow. None of this is exotic, but the breadth matters: a chat client is judged on the long tail of small behaviours, and the README claims most of them.

## The Tauri2 plus Nuxt3 split, and where the backend lives

The architecture visible in the repository is a two-layer client. Nuxt3 handles the application layer: routing, state, the chat UI, the AI conversation views and the extension surfaces. Tauri2 wraps that web application into native binaries for desktop and Android, which is why the same codebase can produce a 10MB desktop app rather than shipping a full browser runtime. The repository root carries nuxt.config.ts, a src-tauri/ directory, and a package.json whose scripts split cleanly along that line: build:nuxt runs nuxi generate, build:tauri runs tauri build, and build chains the two.

Environment configuration is split by target through .env.development, .env.production and .env.test at the repository root, with the dev:nuxt script pointing at .env.development.local via --dotenv. The README does not list the keys those files contain, so the actual backend endpoint, API base URL and any provider credentials are not documented in the files available. That is a real gap for anyone planning a deployment.

The messaging and AI features themselves do not run in the client. The README directs self-hosters to jiwu-chat-core, which it describes as supporting one-click Docker deployment. Real-time messaging, multi-device sync and read-state sync therefore depend on that service. The client repository alone will render the interface, but the README's feature table describes behaviour that only works against a running backend. Treat the two repositories as one system with two licences to check.

## Building JiwuChat from source on desktop

The README does not include an install walkthrough, so the only build instructions available are the scripts in package.json. The engines field pins Node to 20.0.0 or higher and pnpm to 10.0.0 or higher, and a postinstall hook runs node scripts/check-env.js, which suggests the project verifies the environment before continuing. Install dependencies with pnpm first:

```bash
pnpm install
```

The prepare script runs husky install and nuxi prepare as part of that step, so expect Git hooks to be registered in your clone. To run the desktop application in development mode, the package.json defines dev:tauri as tauri dev, which requires the Rust toolchain and the Tauri prerequisites for your platform, neither of which the README documents:

```bash
pnpm dev:tauri
```

If you only want the web layer, dev:nuxt runs nuxt dev with the .env.development.local file and a host binding. That is the faster loop for UI work, and it does not need Rust:

```bash
pnpm dev:nuxt
```

For a release build, the build script generates the Nuxt output with the production environment file and then runs the Tauri build:

```bash
pnpm build
```

Android has its own path. The scripts include android-init, which runs pnpm tauri plugin android init, and dev:android and build:android for the Tauri Android targets. The README does not describe the Android SDK or NDK requirements, so budget time for that. The README also lists a hosted demo at jiwuchat.top with the account ikun233 and password 123456, described as a test account without permission to upload files, change profile information or change the password. Use that to evaluate the interface before building anything.

## Where JiwuChat stops short

The most concrete limitation is documentation of the client itself. The README is a feature showcase with screenshots and a capability table; it does not describe the backend API contract, the environment variables the .env files expect, the Tauri prerequisites per platform, or how to point the client at your own jiwu-chat-core instance. The self-hosting section is one sentence and a link. If your team needs a reproducible deployment from the README alone, you will be reading source instead.

AI provider configuration is another boundary. The README names DeepSeek, Kimi AI, Gmini and SiliconFlow and mentions token counting and a model list, but it does not document where API keys are stored, whether they live in the client or the backend, or what happens to conversation content sent to those providers. For a self-hosted messenger, that is the question that decides whether you can use it at all. Nothing in the README answers it.

Calls carry the usual WebRTC constraints. The README lists voice, video and screen sharing plus call records, but WebRTC needs STUN and TURN infrastructure to work across restrictive networks, and nothing in the README says whether the backend supplies that or whether you configure it. Screen sharing on mobile is listed in the screenshots as a removed desktop feature, which suggests platform parity is not absolute.

Finally, the project is under AGPL-3.0. That is a strong copyleft licence, and if you modify the client and expose it to users over a network, the AGPL's network clause applies. The README does not discuss this, and the backend repository's licence is not stated in the README, so check both before you plan a hosted deployment.

## How JiwuChat differs from Mattermost and Rocket.Chat

The obvious comparison is with established self-hosted messengers. Mattermost and Rocket.Chat are server-first projects: a mature backend with channels, permissions, compliance tooling and a long release history, plus clients that follow the server's lead. Their AI features arrive as plugins or bots bolted onto that core. JiwuChat inverts the order. The client is the product, the AI assistant is a participant in private and group chats by design, and the backend is a separate repository that the README describes in a single line.

That inversion explains the trade-offs. JiwuChat gives you a small native client, an AI conversation surface that feels native rather than bolted on, and one codebase covering desktop, Android and web. What it does not give you, based on the README, is the administrative depth of a server-first platform: there is no mention of roles beyond group admin, no audit log, no retention policy, no federation, no SSO. The feature table covers social chat thoroughly and enterprise governance not at all.

A second comparison is with building on Matrix or XMPP and adding an AI bot. Those routes give you an open protocol, multiple interoperable clients and a decade of operational experience. JiwuChat gives you a single integrated client with its own backend and no stated protocol. If interoperability matters, the protocol route wins. If you want one application that already does chat, calls and AI in a small binary, JiwuChat is the shorter path, at the cost of depending on one project's backend.

## Maintenance, releases and upgrade cost

The repository is not archived. The most recent push was on 2026-07-30, which is within two months of the current date, and the release list shows v2.0.3 on 2026-07-30, v2.0.2 on 2026-07-29 and v2.0.1 on 2026-05-20. The cadence in that window is active, with two releases one day apart followed by a gap of roughly two months. Note the version mismatch: package.json reports version 1.8.3 while the latest GitHub release is v2.0.3, so the npm version field is not the release version you should track.

Upgrade cost depends on how you consume the project. If you use the hosted web build, upgrades are the maintainer's problem. If you build from source, every upgrade means re-running pnpm install and pnpm build, and because the frontend and backend are separate repositories, a client release may require a matching jiwu-chat-core version. The README does not state a compatibility policy between the two, so pin a known-good pair in your own deployment notes rather than tracking main.

The licence is AGPL-3.0. For internal use inside an organisation, the obligations are mostly about distributing modified source to users who interact with it over a network. If you plan to embed the client in a commercial product, read the licence text and the backend repository's licence before writing code against either. This is not legal advice, and the README does not cover the backend's terms at all.

## Conclusion

Adopt JiwuChat if you want a small desktop and Android chat client that already wires AI providers into private and group conversations, and you are comfortable running the AGPL-3.0 frontend against the separately licensed jiwu-chat-core backend. Do not adopt it if you need a documented, versioned deployment procedure today: the README points at the core repository for self-hosting but does not describe the frontend build or the environment variables the .env files expect. Before committing, verify that jiwu-chat-core is still the supported backend, check the licence terms on both repositories, and confirm that Node 20 and pnpm 10 are available in your build environment, since package.json enforces both.

## FAQ

### What is JiwuChat and what platforms does it run on?

JiwuChat is a cross-platform instant messaging client built with Tauri2 and Nuxt3, described in the README as lightweight at around 10MB. The feature table lists Windows, macOS, Linux, Android and web support, and the README says one codebase covers all of them.

### How do I self-host the JiwuChat backend?

The README directs self-hosters to the separate jiwu-chat-core repository, which it says supports one-click Docker deployment. It does not describe the frontend build or the environment variables the client expects, so the client and backend should be treated as one system with two repositories to configure.

### Which AI providers does JiwuChat support?

The README's AI module lists Gmini, Kimi AI, DeepSeek and SiliconFlow among supported model providers, along with a model list and token counting. It also describes private AI chat, group AI chat and multiple AIs chatting at once, but does not document where provider API keys are stored.

### What licence is JiwuChat released under?

The repository is licensed under AGPL-3.0. The README does not state the licence of the jiwu-chat-core backend, so both should be checked before a hosted or commercial deployment.

### Can I try JiwuChat without building it?

Yes. The README lists a hosted web demo at jiwuchat.top with the account ikun233 and password 123456. It describes that account as a test account without permission to upload files, change profile information or change the password.

## Sources

- [KiWi233333/JiwuChat on GitHub](https://github.com/KiWi233333/JiwuChat)
- [License: AGPL-3.0](https://github.com/KiWi233333/JiwuChat/blob/main/LICENSE)
- [Project website](https://blog.jiwuchat.top)
- [README](https://github.com/KiWi233333/JiwuChat/blob/main/README.md)
- [Releases](https://github.com/KiWi233333/JiwuChat/releases)

---

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