# LingChat: a Tauri desktop companion that watches your screen and reacts

> LingChat wraps a large language model in a Rust and Vue desktop app with per-save memory, a self-trained emotion model, and vision that can read your desktop. The voice layer is where the hardware budget runs out.

**SlimeBoyOwO/LingChat** — Immersive AI-driven Galgame chat with emotional expressions, desktop pet, scheduling, and interactive story modules.

- Repository: https://github.com/SlimeBoyOwO/LingChat
- Website: https://lingchat.wiki/
- Stars: 2,387 · Forks: 141
- Language: Rust
- License: AGPL-3.0
- Published: 2026-10-07 · Updated: 2026-10-07 · Language: en
- Canonical page: https://hysenlabs.com/projects/slimeboyowo-lingchat

## A Tauri shell with a Rust core and a Vue front end

LingChat is reported as a Rust project, and the repository layout explains why. There is a `src-tauri/` directory holding the Rust side and a `src/` directory for the front end, with `index.html`, `vite.config.ts`, `tsconfig.json` and a `pnpm-lock.yaml` at the top level. The build is Tauri 2, not Electron, with plugins for dialog, fs, notification, opener, process and updater.

The package metadata is unusually candid about what kind of codebase this is. It carries a `packageManager` pinned to pnpm, marks itself an ES module, and mixes formatting responsibilities between `prettier --write .` for the front end and `cargo fmt` for the Rust side, with a `rustfmt.toml` at the root and husky wiring the two together as a pre-commit hook:

```json
  "packageManager": "pnpm@11.21.0",
  "format:rs": "cargo fmt --manifest-path src-tauri/Cargo.toml",
  "format:check": "prettier --check . && cargo fmt --manifest-path src-tauri/Cargo.toml -- --check",
```

The build scripts are conventional, running a type check before the Vite build:

```json
    "dev": "vite",
    "build": "vue-tsc --noEmit --skipLibCheck && vite build",
```

So this is a native desktop application with a web front end, not a packaged web page. That distinction is the reason a feature like desktop perception or a system tray pet is possible at all, and it is also why the release notes talk about AppImage packaging and `tauri-plugin-notification` version bumps rather than only about features.

There are mobile ambitions in the tree as well: `android:prepare`, `android:build`, `ios:init` and `ios:build` scripts are present, and the 0.5.2 notes mention hiding a desktop pet button on iOS. Treat those as work in progress rather than shipped platforms.

## Per-save memory and an emotion model trained by the author

The feature list has nine items and two of them are unusual enough to be the project's real identity. The first is permanent memory with independent saves, where each save has its own persistent memory so you can experience different conversation styles without them bleeding into each other. That is a design choice worth respecting: most companion apps have one global memory, and one bad conversation poisons it.

The second is a self-developed emotion recognition model, which decides the emotional state of each AI reply so the character is not answering in a flat register. The README credits a separate repository, Emotion-Model-Trainer, as the training tool for recognising emotion across 18 short-phrase categories, and the `scripts/` directory contains a download step for the emotion model in the init script. So the model is a first-class asset rather than a prompt instruction.

Everything downstream of that classification is presentation. The interface exposes expressions, actions and speech bubbles that change with the detected emotion, and supports different backgrounds and music. Character clothing can be switched, and there are interaction verbs beyond plain chat.

What the README does not do is tell you how well the classifier performs, or what happens when a reply is genuinely ambiguous. There is no accuracy figure and no fallback description. If emotion detection matters to you, that is the gap to probe yourself, and the hover-level detail you can check is whether the same reply gets a different expression when rephrased.

## Desktop vision needs a second model you have to assign yourself

The perception feature works by sending a screenshot to a vision-capable model and letting the character comment on what you are doing. Two details in the setup are worth knowing before you expect it to work.

First, it needs its own model. The README points to Alibaba Cloud Bailian for obtaining a vision model API key and notes that the default free credit is described as ample for this project's use. Second, you must explicitly assign a model to the vision role in the advanced settings under large model management, and the default behaviour is to follow the chat model, reusing whatever you are chatting with.

That default is the trap. If your chat model has no image input, following it silently produces a feature that does not work. The 0.5.2 release notes address exactly this by adding native multimodal image understanding, so the recognition model can send images directly instead of describing them in text, with configurable compression and automatic compression for oversized images. The same release added image understanding support for DeepSeek models.

The trigger is explicit rather than ambient. You send a message asking it to look at your desktop, and with proactive conversation enabled it can also observe on its own. Proactive observation is opt-in configuration, which is the right default for something that reads your screen.

One inconsistency is worth naming. The quick start tells you to download the newest `v0.5` build, while the 0.5.2 release notes add native multimodal image understanding and refer to a resource archive used for manual updates. Read the release notes for the version you actually download rather than assuming the two are in sync.

## Voice synthesis is the feature that needs a GPU

LingChat can speak. You download the voice engine from the text menu inside the running app, unpack the archive, and launch the bundled batch file that starts the API service, after which a VITS service handles speech.

The performance guidance is the most concrete number in the entire README, and it is a warning. On integrated graphics or an older machine, generating a single line of speech may take about a minute. On a machine with a GPU it can finish inside a second. The README goes further and says that users on integrated graphics may hit so many errors that the feature is unusable.

That is the honest shape of this feature: a large quality difference between machine classes, with the worse case being a minute of silence per reply. There is no caching story, no queueing description, and no fallback to text. If you plan to use voice continuously, the hardware assumption is not optional.

Wiring a custom character to a specific voice model is a small file edit rather than a UI flow. The setting lives in a `settings.yml` under `game_data/characters/` for that character, and the parameter to change is `model_name`, set to the name of the imported model. Worth noting that this path sits in the install directory rather than a user profile, so changing a character's voice means editing files next to the executable.

The voice stack also borrows from two upstream projects the README credits, Simple-Vits-API for the synthesis service and Style-Bert-VITS2 for the model family, which is where the quality ceiling and the training data requirements actually come from.

## Screenshots, conversation histories and what actually leaves your machine

Before enabling desktop perception on a machine that holds real work, it is worth being clear about the trust boundary. Turning it on means the app can send screenshots of your screen to a third-party model API. The README states plainly that the default free credit from the chosen provider is enough for the project, which is friendly, but it is also a statement about cost, not about what leaves the device.

The same applies to conversation content generally. LingChat is a front end for hosted models, and the provider you configure receives your messages, your images, and whatever context the memory system decides to include. The repository offers no local model path and no documented offline mode.

Data storage is local and per-save. The 0.5.2 release notes show real work on this: automatic saves now trigger only on genuine conversation change, so the main menu and app startup no longer overwrite an old save, an issue tracked as #803, and save line synchronisation was made atomic in a separate pull request. Two other fixes in the same release touched the memory module and the scene graph, which tells you the state management is the part of the code base that is still moving.

For anyone running this near sensitive material, the practical controls are the provider you choose and whether proactive observation is enabled. Both are configuration decisions you make in the advanced settings, and both are worth deciding before the first conversation rather than after.

## Licensing, assets and the gap between the README and the docs

LingChat is released under the AGPL-3.0 license, which is the copyleft license with the strongest network clause of the common ones. For personal use that means nothing changes. If you distribute a modified build, or run a modified build as a service for others, the AGPL requires you to offer those users the corresponding source. That is a legal matter rather than engineering advice, but the practical upshot for an evaluator is simple: read the LICENSE file before you fork it, and assume any commercial or hosted deployment needs its own review.

The asset disclaimer is the constraint people miss. Some interface and sound assets come from Blue Archive, and the conversation blip sounds come from Undertale, with an explicit instruction not to use them commercially. The default character illustrations were drawn by the developer, who asks that they not be reused commercially or repurposed. So the code is AGPL and the art and audio carry their own terms. Any product built on this has to treat those as separate obligations, which is a real limit on commercial use even where the licence would allow it.

Documentation is where this project is thinnest. The README covers the quick start and the two optional integrations, then points to a separate documentation site at lingchat.wiki and two QQ groups, one for installation support and one for developers. Installation itself is split across platforms inconsistently: the quick start is Windows-first and tells you to download the newest `v0.5` archive from Releases, unpack it and double-click `LingChat.exe`, while the 0.5.1 and 0.5.0fix1 release notes are the place that lists macOS `.dmg` and Linux `.AppImage` and `.deb` artifacts, plus the `data_files.zip` archive that must be unpacked into a `data/` folder inside the program directory if you update resources manually.

One rough edge is worth flagging before you install: the README warns that `LingChat.exe` can go missing after extraction because Windows Defender flagged it, and the fix is to allow the file in Windows Security Center. An antivirus false positive on the primary binary is normal for unsigned desktop apps, but it is also a poor first impression, and it is a reminder to download from the Releases page rather than from a mirror. The last push was on 2026-09-19, with 0.5.2 released on 2026-09-13, so the current line is moving.

## Conclusion

LingChat is worth installing if you want a desktop companion rather than a browser tab, because the parts it does differently are the parts a browser cannot do: reading your screen, reacting with an expression and a voice, and keeping memory tied to a specific save. The two costs are honest ones. Voice synthesis on integrated graphics takes about a minute per line and may simply fail, and the vision feature needs a second vision-capable model on top of your chat model. Start with the text and memory features from a plain .exe, .dmg or .AppImage, add VITS only once you have confirmed your machine has a usable GPU, and read the LICENSE file and the asset disclaimer together before you consider anything commercial.

## FAQ

### What is LingChat and what platform does it run on?

LingChat is an AI companion application built with Tauri, combining a Rust core in src-tauri with a Vue front end, packaged as a desktop program. It supports Windows, macOS and Linux through .exe, .dmg and .AppImage or .deb artifacts respectively, with Android and iOS build scripts present but not shipped.

### Does LingChat need a GPU to generate voice?

For usable performance, yes. The README states that on integrated graphics or an older machine a single line of voice may take about a minute to generate, and that such users may encounter enough errors that the feature is unusable, while a machine with a GPU can generate within about a second. Text conversation does not have that requirement.

### How does LingChat perceive what is on your desktop?

You configure a separate vision-capable model in the advanced settings under large model management and assign it to the vision role, since the default follows the chat model, which may not accept images. You then trigger it by sending a message asking it to look at your desktop, and with proactive conversation enabled it can also observe on its own.

### Can I use LingChat commercially?

The code is licensed AGPL-3.0, which carries a strong source-sharing requirement for distributed or hosted modifications. Separately, the README states that some interface and sound assets come from Blue Archive and Undertale and must not be used commercially, and asks the same of the default character illustrations. Both need review before any commercial use.

## Sources

- [License: AGPL-3.0](https://github.com/SlimeBoyOwO/LingChat/blob/main/LICENSE)
- [Project website](https://lingchat.wiki/)
- [README](https://github.com/SlimeBoyOwO/LingChat/blob/main/README.md)
- [Releases](https://github.com/SlimeBoyOwO/LingChat/releases)
- [SlimeBoyOwO/LingChat on GitHub](https://github.com/SlimeBoyOwO/LingChat)

---

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