# Newelle puts local models, cloud models and shell commands in one GNOME window

> Newelle is a Python and GTK4 desktop assistant for Linux that talks to remote or local models, executes commands the model puts forward and keeps chat history in folders. Its two drawbacks are a native dependency stack built for GNOME only, and command execution with no documented audit trail.

**qwersyk/Newelle** — Newelle - Your Ultimate Virtual Assistant

- Repository: https://github.com/qwersyk/Newelle
- Website: https://newelle.qsk.me
- Stars: 1,499 · Forks: 149
- Language: Python
- License: GPL-3.0
- Published: 2026-10-14 · Updated: 2026-10-14 · Language: en
- Canonical page: https://hysenlabs.com/projects/qwersyk-newelle

## One Python shell over many model providers

Newelle is a GTK4 and Adwaita desktop assistant for Linux, written in Python, and it is distributed on Flathub as io.github.qwersyk.Newelle. Model choice lives in the settings rather than in code: you pick a provider and a model, or you switch to a model downloaded locally and run through Llama.cpp or Ollama. Interfaces let the same conversation surface be driven from Telegram or through an API, which is the part that separates Newelle from a plain chat window. On top of that sit multichat for running several conversations at once, chat branching to fork an alternative from any message, chat editing to rewrite or remove a message after the fact, and chat folders to organise the result. Call Mode handles real time conversation with a model, and rich formatting covers Markdown and LaTeX.

## Web pages arrive as a prompt prefix, not a crawler

Reading a website needs no configuration in Newelle. Append the prefix #https://.. to a prompt and the application scrapes that page and folds it into the conversation. Web Search is a separate switch, so a lookup is a deliberate choice rather than something every prompt pays for. Two features work against the context window that a scraper will overflow. Dynamic Context Management summarises and drops messages it judges irrelevant so the conversation keeps fitting, while Long Term Memory pulls material back from earlier chats. Chat with your own documents covers local files. Neither feature is documented with the summarisation ratio, the token budget or the retention period, so you cannot tell from the README how much of a long transcript survives a session.

## Shell execution and file permissions share one trust decision

One feature list entry is titled Terminal Command Exection, misspelled in the README itself, and promises to execute commands the model puts forward on the fly. A separate entry, File Permissions, covers setting permissions to which files to edit or read. Read those two entries together and the trust boundary becomes clear: commands run, and files are gated. Two more entries widen that boundary. Scheduled Tasks runs tasks in the background, and the built-in file manager lets the assistant manage your files with its help, which together mean a queued task can act on your disk while you are away from the machine. No confirmation dialog, allow list for commands, or command history is described anywhere in the README, so the permission settings are the only control the documentation puts in your hands.

## Local inference rides on a Cargo manifest inside a Python tree

Downloading a model from inside Newelle and running it with Llama.cpp or Ollama is the feature that separates this client from a thin web wrapper, and the repository layout shows how that is wired. The top level carries cargo-sources.json next to meson.build, meson_options.txt, install.sh and io.github.qwersyk.Newelle.json, the flatpak manifest, plus build_locale.sh and a modules directory. A Cargo manifest in a repository whose primary language is Python is the signature of a native engine reached through bindings rather than a pure Python runner. The meson build is what stitches that together for the desktop shell, and the flatpak manifest is what makes the same bundle installable without a system wide toolchain.

## Mini window mode begins with a launch flag, not a setting

Mini Window Mode is a lightweight version of Newelle meant to be summoned by keyboard, and getting it bound takes two steps in the documented order. Run the app once with the flag, then enable the hotkey in settings. If you installed through Flathub:

```bash
flatpak run io.github.qwersyk.Newelle --mini
```

Outside flatpak the same thing is `newelle --mini`. Once Newelle is already open, CTRL+G toggles mini window mode, so the hotkey you enabled only matters after the first launch. On GNOME the window will not necessarily land where you expect, and the README asks you to flip a Mutter key yourself:

```bash
gsettings set org.gnome.mutter center-new-windows true
```

That is a change to your desktop shell, taken to make one app behave, and it affects every new window GNOME opens. Installation itself is thinner than the feature list: the section opens with a build badge and the line "There are two ways of doing this" without naming them, while Flathub remains the route the badges point at.

## Extensions, MCP tools and Claude skills enter through one door

Three entries in the feature list all add capability from outside the codebase: Extensions to add your own functionalities and models, Tools & MCP support to add tools via MCP servers, and Skills to support skills from Claude and Codex. The Extensions section sends you to the GitHub topic newelle-extension for existing extensions, and the second badge at the top of the README links to that same topic, so one topic carries both the companion listing and the add-on library. Extensions also add tools to the same pool as MCP servers, which means tool search covers both. What you get from that pool is not described: the README does not document the extension manifest, the MCP configuration format, or the permission an extension inherits. Treat the wiki link as the place where that has to come from, since it is the only documentation the README points to beyond itself.

## Three tagged builds in 2026, and a master ahead of them

Three builds are tagged in 2026: 1.4.0 on 2026-05-19, 1.4.5 on 2026-06-19 and 1.5.0 on 2026-08-19. The last push was on 2026-09-16, four weeks after 1.5.0, so the master branch that a builder badge would package already carries work past that tag. That gap matters for anyone who wants a reproducible install, because the Flathub build and a self built one are not the same tree. The upgrade cost is not in the code but in the state you have accumulated: profiles created in the profile manager, per directory file permissions, installed extensions, MCP server entries and scheduled tasks all sit outside the repository and are not described as exportable anywhere. Backing up your settings directory before a version jump is your own decision to make, since the README documents no migration step between versions.

## Conclusion

Newelle suits a GNOME user who wants one window holding many models, local inference and long chat history, and who is willing to grant a Python app permission to run shell commands on their behalf. It is the wrong tool for macOS or Windows, where the GTK4 stack and its Mutter dependency have no home, and for anyone who needs an auditable command history. Before installing, open the file permission settings and decide which directories the assistant may touch, then bind the mini window hotkey only after one manual launch.

## FAQ

### Does Newelle run on macOS or Windows?

No package or build for those systems is described. Newelle is a GTK4 and Adwaita application for Linux with gnome, gtk and gtk4 among its repository topics, shipped through Flathub as io.github.qwersyk.Newelle.

### How do I run AI models locally in Newelle?

The feature list says local models can be downloaded directly from inside Newelle and run with Llama.cpp or Ollama. Remote providers and models are a separate choice in settings, so the two run modes sit in the same interface.

### Can Newelle execute shell commands on my machine?

Yes, the feature list has an entry for executing commands the AI puts forward on the fly, and another entry, File Permissions, for setting which files may be edited or read. The README does not describe a confirmation step or a log of executed commands.

### How do I trigger Newelle's mini window?

Run the application once with the mini flag, `flatpak run io.github.qwersyk.Newelle --mini`, or `newelle --mini` outside flatpak, then enable the hotkey in settings. CTRL+G toggles mini window mode while the app is already open.

## Sources

- [License: GPL-3.0](https://github.com/qwersyk/Newelle/blob/master/LICENSE)
- [Project website](https://newelle.qsk.me)
- [qwersyk/Newelle on GitHub](https://github.com/qwersyk/Newelle)
- [README](https://github.com/qwersyk/Newelle/blob/master/README.md)
- [Releases](https://github.com/qwersyk/Newelle/releases)

---

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