JiwuChat: a ~10MB Tauri2 and Nuxt3 chat client with AI bots wired into the message stream
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 🍒
At a glance
- What is it?
- JiwuChat is an AGPL-3.0 instant messaging client built with Vue3, Nuxt3 and Tauri2 that ships desktop, Android and web builds from one codebase, with DeepSeek, Kimi, Gemini and SiliconFlow models callable from inside private and group chats. The interesting part is the AI integration; the part to check before adopting is who operates the server.
- Who is it for?
- Adopt JiwuChat if you need a small desktop and Android chat client where AI models answer inside the conversation rather than in a separate tab, and you accept the AGPL-3.0 obligations that come with shipping a modified client. Do not adopt it as a drop-in replacement for an existing messenger on your own infrastructure unless you first stand up jiwu-chat-core yourself, because the default build points at the maintainer's backend.
- Can I use it commercially?
- Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
- Is it still maintained?
- Yes. The repository last received commits 48 days ago.
- What is it written in?
- Mainly Vue, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The problem JiwuChat targets: AI assistants that live outside the conversation
Most desktop chat clients treat AI as a separate window. You copy a message out, paste it into a browser tab, copy the answer back. JiwuChat puts the model behind a chat participant instead. The README describes an AI module with private AI chat, group AI chat, and multiple AI models talking at once, plus a bot plaza and per-model token accounting. Models listed in the feature table include Gemini, Kimi AI, DeepSeek and SiliconFlow, and the repository description names DeepSeek, Gemini and Kimi. The audience is therefore narrow and specific: developers and technically comfortable users who already hold API keys for one or more of those providers and want them reachable from the same window where they talk to people. The second audience is anyone who wants a small native client rather than an Electron bundle; the README puts the size at roughly 10MB and attributes that to Tauri2. The third is self-hosters, because the README points at a separate repository, jiwu-chat-core, for a backend that supports Docker deployment. If none of those three describes you, the AI angle is the only reason to look at this over an existing messenger.
Tauri2 shell, Nuxt3 front end, and a backend you supply
The architecture visible in the repository metadata and README is a three-part split. The client is a Vue3 and Nuxt3 application; the topics list also includes Vite and Nuxt3, which is consistent with a Nuxt app built through Vite. Tauri2 wraps that front end into native desktop binaries for Windows, macOS and Linux, and the same codebase is adapted for Android and the web, which the README presents under a single heading about one codebase serving multiple platforms. Tauri's model is to use the operating system's own webview rather than bundling a browser engine, which is where the stated ~10MB figure comes from. Real-time messaging, multi-device message sync and read-state sync are handled by the server, not the client. Audio and video calls and screen sharing run over WebRTC, with a call-record module tracking call state and hang-ups. The AI side is a client-side integration: the feature table lists model management, a model list and token counting, and one screenshot is labelled API development, which suggests keys are configured in the app rather than proxied through the backend. The README does not spell out the transport between client and server, so treat any assumption about the protocol as unverified.
Getting a build running: Tauri prerequisites and the self-hosted core
The README does not include an install command for the client, so the only concrete setup path it gives is the backend. For a self-hosted deployment it directs readers to the jiwu-chat-core repository, which it says supports one-click Docker deployment. That is the piece you need before a client build is useful to you, because otherwise the app talks to the maintainer's server. For the client itself, the stack implies the usual Tauri workflow: Node and a package manager for the Nuxt front end, the Rust toolchain and the platform webview dependencies for Tauri, then the Tauri CLI to produce a desktop bundle. The README does not name the exact scripts, so check package.json in the repository before assuming a command. If you want to look at the app without building anything, the README publishes a web address and a shared test account with the username ikun233 and the password 123456. It also carries a warning that this account cannot upload files, change profile information or change the password, and the warning is struck through in the source, so the current permission set on that account is not something you can rely on from the README alone. Do not put real data into the demo account.
Where JiwuChat is the wrong tool
The licence is the first constraint. JiwuChat is AGPL-3.0. If you modify the client and let users interact with it over a network, the AGPL's network clause is generally read as requiring you to offer the corresponding source to those users. That is a real consideration for a company that wants to rebrand a chat client internally, and it is not a consideration you can wave away by keeping the binary private. The second constraint is server dependency. The README's self-hosting section points at a separate repository, which means the client and the service are versioned independently; the release notes show v2.0.3 and v2.0.2 landing one day apart, which is a fast patch cadence but also a sign that client and server compatibility needs checking per upgrade. The third is scope. This is a chat client with a feature table covering friends, groups, notifications, themes, a store integration, a blog integration and an AI shopping feature. Breadth like that usually means each individual area is less deep than a dedicated tool. If you need end-to-end encrypted group messaging with an audited protocol, the README does not make that claim, and you should not assume it. If you need federation or interoperability with an existing network, nothing in the material suggests it exists.
How it differs from Matrix clients and from building on an existing SDK
The obvious comparison is a Matrix client such as Element, which solves a similar surface problem (multi-platform chat with calls and file sharing) but takes the opposite approach on two axes. Matrix clients speak an open, federated protocol, so your account can talk to users on other servers; JiwuChat talks to jiwu-chat-core, a single backend you deploy yourself. And Matrix clients keep AI out of the core product, leaving bots to the wider ecosystem; JiwuChat builds model management, a bot plaza and token counting into the client. The trade is control for reach. With a Matrix client you inherit an ecosystem and a protocol specification; with JiwuChat you get a smaller, self-contained stack where the AI path is first-class but the network is whatever your server is. The other comparison is starting from a chat SDK or a Tauri template and writing the AI layer yourself. That gives you a licence you choose and a feature set you scope, at the cost of reimplementing friends, groups, sync, notifications and WebRTC signalling. JiwuChat's value is that those parts already exist in one repository under a single build.
Maintenance, releases and what an upgrade actually costs
The release history shows v2.0.1 in May, then v2.0.2 and v2.0.3 in late July on consecutive days. That pattern suggests active maintenance with occasional bursts, and it also suggests you should pin a version rather than track the default branch. Because the client and jiwu-chat-core are separate repositories, an upgrade is a two-sided operation: check whether the new client release expects a newer server API before rolling it out. The README lists nine translated README files under .doc, which indicates the project is maintained with some care for reach, but translation coverage is not a proxy for API stability. On licence cost, AGPL-3.0 means no per-seat fee and no vendor negotiation, which is attractive for a small team, but it also means your modifications are not something you can keep to yourself if users reach them over a network. That is a business decision, not a technical one, and it is worth a conversation with counsel before you fork rather than after. I am not a lawyer and this is not legal advice.
The AI integration is the reason to pick this, and also the thing to inspect first
Everything else in JiwuChat has a close equivalent elsewhere: multi-device sync, group management, WebRTC calls, desktop notifications, light and dark themes. The AI module is the differentiator, and it is also the least documented part. The feature table claims private AI chat, group AI chat, simultaneous multi-model chat, a model list and token counting, and the screenshots include an API development screen and a dark-theme AI conversation. What the README does not state is where API keys are stored, whether requests go directly from the client to the provider or through jiwu-chat-core, and what happens to conversation history when a bot participates in a group. Those three questions determine whether the AI feature is usable in a workplace. If keys live in the client and requests go straight to the provider, that is simple to reason about and simple to audit. If the server proxies them, your prompts pass through infrastructure you operate, which may be fine or may not, depending on your data rules. Read the source for the AI module before enabling it on anything other than a test account.
Editorial conclusion
Adopt JiwuChat if you need a small desktop and Android chat client where AI models answer inside the conversation rather than in a separate tab, and you accept the AGPL-3.0 obligations that come with shipping a modified client. Do not adopt it as a drop-in replacement for an existing messenger on your own infrastructure unless you first stand up jiwu-chat-core yourself, because the default build points at the maintainer's backend. Verify three things before you commit: that your Tauri toolchain builds the target platform, that the client can be repointed at your own server without patching, and that your legal team is comfortable with AGPL-3.0 for a network-served application.
Community notes