Stop Paying for AI Subscriptions! Newelle Runs LLMs Locally on Linux

What if I told you that every chat you send to ChatGPT, Claude, or Gemini is being logged, analyzed, and potentially used to train future models? That proprietary cloud AI knows your coding patterns, your personal projects, even your embarrassing debugging questions at 3 AM. Now imagine a world where you own your AI completely—where a powerful virtual assistant lives on your Linux machine, runs entirely offline, and never phones home to a corporate server.

This isn't science fiction. This is Newelle, the open-source virtual assistant that's making Linux developers abandon cloud AI subscriptions in droves.

Built by developer qwersyk and rapidly gaining traction across the Linux community, Newelle isn't just another chat wrapper. It's a fully-featured, extensible AI powerhouse that brings local large language models to your desktop with native Linux integration, terminal command execution, voice control, and an extension ecosystem that would make VS Code jealous. Whether you're a privacy-obsessed security researcher, a broke student tired of API bills, or a productivity hacker who wants AI that actually understands your system, Newelle delivers something the cloud giants never can: true ownership.

Ready to see why developers are calling this the secret weapon they've been waiting for? Let's dive deep.

What is Newelle? The Linux AI Revolution Explained

Newelle is an open-source virtual assistant specifically designed for Linux desktop environments, with a particular focus on GNOME integration. Created by the developer qwersyk and hosted on GitHub, this project represents a fundamental shift in how developers interact with AI tools—moving from rented, cloud-dependent services to sovereign, locally-run intelligence.

At its core, Newelle is a GTK4/Libadwaita application that serves as a unified interface for multiple AI providers and local models. But calling it just a "chat client" would be like calling Emacs just a text editor. Newelle is an operating system companion that can execute terminal commands, manage your files, search the web, read documents, schedule tasks, and even hold voice conversations with you—all while keeping your data on your machine.

The project has exploded in popularity because it solves three critical pain points simultaneously:

1. Privacy paralysis: Developers who want AI assistance but can't risk leaking proprietary code or personal data to third-party APIs
2. Subscription fatigue: The endless $20/month charges for AI tools that should be infrastructure, not a service
3. Fragmentation chaos: Juggling between terminal tools, browser tabs, and desktop apps just to get AI help with system tasks

Newelle's architecture is deliberately modular. It supports Llama.cpp and Ollama for local model execution, integrates with multiple cloud providers when needed, and exposes an extension API that lets developers add custom functionality. The project is distributed primarily through Flathub, making installation trivial on most modern Linux distributions, though it also supports Nix and manual builds for the hardcore crowd.

What makes Newelle genuinely exciting is how it embeds AI into your workflow rather than interrupting it. The Mini Window Mode triggers via global hotkey. Terminal commands suggested by the AI can be executed with a single click. File operations happen through a built-in manager that understands natural language. This isn't AI as a separate app—it's AI as an ambient layer across your entire Linux experience.

Key Features That Make Newelle Insanely Powerful

Newelle's feature set reads like a wishlist from developers who were fed up with half-baked AI tools. Here's what separates it from the pack:

🎨 Advanced Customization & Theming

Newelle doesn't just support dark mode—it adapts to your entire GNOME theme automatically. Profile management lets you create entirely separate configurations for different contexts: one profile for coding with aggressive terminal integration, another for writing with document-focused tools, a third for casual browsing with web search enabled.

🚀 Flexible Model Support (The Real Killer Feature)

This is where Newelle exposes the competition. You can simultaneously configure:

• Local models via Llama.cpp (direct download and management within the app)
• Local models via Ollama (seamless integration with existing model libraries)
• Cloud providers as fallback or for specific tasks requiring larger models
• Custom endpoints for self-hosted or corporate API gateways

The model selector lets you switch contexts mid-conversation. Stuck on a complex algorithm? Switch to your heaviest local model. Need a quick shell command? Use a lightweight 3B parameter model that responds instantly.

💻 Terminal Command Execution (Workflow Magic)

Newelle parses AI responses for shell commands and presents them as executable buttons. No copy-paste errors. No context switching. The AI suggests find . -name "*.log" -mtime +7 -delete, you click execute, it runs with appropriate permissions. This alone saves hours per week for DevOps engineers and systems administrators.

🧩 Extensions & MCP Support

The extension ecosystem transforms Newelle from a chat app into a platform. Using the Model Context Protocol (MCP), developers can expose tools to the AI: database connectors, API clients, custom search engines, internal documentation systems. The newelle-extension topic on GitHub already hosts community contributions, and the barrier to creating your own is surprisingly low.

🗣 Voice Interface with Wake Word

Full hands-free operation with Speech-to-Text and Text-to-Speech, including wake word detection. This isn't a gimmick—it's genuinely useful for accessibility, for coding while referencing documentation, or for managing your system while your hands are occupied.

🧠 Long-Term Memory & Chat Branching

Newelle remembers previous conversations and lets you branch chats at any message. Explored a solution that didn't work? Branch back to the hypothesis, try a different approach. The conversation tree becomes a genuine thinking tool, not just a linear log.

📁 Built-in File Manager with AI Understanding

Navigate, read, and manipulate files through natural language. "Show me all Python files modified this week" or "Create a backup of the config directory before editing"—the AI translates intent to file operations.

Real-World Use Cases: Where Newelle Dominates

Scenario 1: The Privacy-First Developer

The pain: You're working on proprietary software. Every time you ask ChatGPT to debug a function, you're potentially leaking trade secrets to OpenAI's training pipeline.

Newelle's solution: Download CodeLlama or DeepSeek-Coder directly through Newelle's interface. Run entirely offline. Your source code never leaves your machine. The AI still suggests fixes, explains algorithms, and generates tests—but with zero data exfiltration risk.

Scenario 2: The DevOps Engineer Living in Terminal

The pain: You're constantly switching between terminal, browser documentation, and AI chat to construct complex shell pipelines.

Newelle's solution: Keep Newelle in Mini Window Mode with a global hotkey. Describe what you need: "Find all Docker containers using more than 500MB RAM, sorted by memory usage, and output as a table with container names." Newelle suggests the command, you execute inline, tweak if needed, and move on. Context switching eliminated.

Scenario 3: The Researcher Drowning in Papers

The pain: You have hundreds of PDFs, need to synthesize information across them, but can't upload sensitive research to cloud AI.

Newelle's solution: Use the Chat with Documents feature. Load papers into Newelle's context. Ask cross-document questions: "What methodologies do Smith 2023 and Jones 2024 share? Where do they contradict?" The AI reasons across your local document collection with no data leaving your system.

Scenario 4: The Accessibility-Focused User

The pain: Repetitive strain injury makes typing painful. Voice assistants like Siri or Alexa can't interact with your development environment.

Newelle's solution: Enable wake word detection. "Hey Newelle, create a new branch called feature-auth-refactor." "Newelle, run the test suite and read me the failures." Full system control through voice, with the AI understanding your specific Linux environment.

Step-by-Step Installation & Setup Guide

Newelle offers multiple installation paths depending on your Linux distribution and comfort level with package management. Here's how to get running in minutes.

Method 1: Flathub (Recommended for Most Users)

Flatpak provides the most straightforward installation with automatic updates:

# Ensure Flathub is configured on your system
flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

# Install Newelle directly from Flathub
flatpak install flathub io.github.qwersyk.Newelle

# Launch the application
flatpak run io.github.qwersyk.Newelle

Critical permission setup: The Flathub build runs sandboxed by default, which limits file system access. To make Newelle actually useful for system tasks, extend permissions:

# Temporary full access (use with caution)
flatpak run --talk-name=org.freedesktop.Flatpak --filesystem=home io.github.qwersyk.Newelle

For permanent permission adjustment, install Flatseal (flatpak install flathub com.github.tchx84.Flatseal) and enable:

• "All user files" under Filesystem
• "Session Bus" with org.freedesktop.Flatpak added

⚠️ Security Warning: These permissions reduce sandbox security. Only enable on trusted systems, and never with proprietary models you don't fully understand.

Method 2: Nix (For the Declarative Crowd)

Nix users get the cleanest experience—no installation required:

# Run directly from the GitHub repository
nix run github:qwersyk/Newelle

# Or clone for development/latest commits
git clone https://github.com/qwersyk/Newelle.git
cd Newelle
nix run .        # Run the application
nix develop .    # Enter development shell

Method 3: Manual Build with GNOME Builder

For developers wanting the bleeding edge or to contribute:

# Install GNOME Builder and the latest GNOME SDK
# (Distribution-specific; on Fedora: sudo dnf install gnome-builder)

# Clone the repository
git clone https://github.com/qwersyk/Newelle.git
cd Newelle

# Open in GNOME Builder and click the build/run button
# Or use the provided install script after SDK setup:
sh install.sh

Post-Installation: Configure Mini Window Mode

The global hotkey transforms Newelle from an app you open to a tool you invoke:

# Set startup mode to mini and configure the launcher
/bin/bash -c 'flatpak run --command=gsettings io.github.qwersyk.Newelle set io.github.qwersyk.Newelle startup-mode "mini" && flatpak run io.github.qwersyk.Newelle'

# For GNOME users: enable automatic window centering
gsettings set org.gnome.mutter center-new-windows true

After running the first command, bind a hotkey in your system settings (e.g., Ctrl+Space) to launch Newelle in its lightweight overlay mode.

REAL Code Examples from Newelle

Let's examine actual implementation patterns from the Newelle repository, showing how this tool integrates into real workflows.

Example 1: Nix Zero-Installation Execution

The Nix flake enables ephemeral execution without system modification—perfect for testing or CI pipelines:

# Execute Newelle without installing anything permanently
nix run github:qwersyk/Newelle

# Pin to a specific revision for reproducibility
nix run github:qwersyk/Newelle?rev=abc123def456

# Enter a development shell with all dependencies
nix develop github:qwersyk/Newelle

What's happening here: Nix downloads all dependencies (GTK4, Libadwaita, Python bindings, AI runtime libraries) into a temporary environment, builds Newelle, and executes it. When you exit, nothing remains on your system except the Nix store cache. This is revolutionary for testing—try Newelle without commitment, or run it on ephemeral cloud instances without complex setup.

For developers maintaining the project, the local development workflow uses the same pattern:

git clone https://github.com/qwersyk/Newelle.git
cd Newelle
nix run .    # Builds and runs from local source

The . tells Nix to use the local flake.nix, picking up your modifications immediately. This tight feedback loop makes contributing extensions or core features genuinely pleasant.

Example 2: Flatpak Permission Escalation for System Integration

Newelle's sandboxed Flathub build intentionally restricts access. Here's the precise command to enable full functionality:

# Grant temporary broad permissions for a single session
flatpak run \
  --talk-name=org.freedesktop.Flatpak \
  --filesystem=home \
  io.github.qwersyk.Newelle

Breaking this down:

• --talk-name=org.freedesktop.Flatpak: Allows Newelle to request execution outside the sandbox via Flatpak's portal system. This is how terminal commands actually run on your host system rather than inside the container.
• --filesystem=home: Grants read/write access to your home directory, essential for the file manager and document chat features.
• io.github.qwersyk.Newelle: The Flatpak application ID, following reverse-DNS convention.

For permanent configuration, the README recommends Flatseal—a GUI permission manager. But power users can also modify permissions via command line:

# Alternative: direct override (persists across launches)
flatpak override io.github.qwersyk.Newelle \
  --filesystem=home \
  --talk-name=org.freedesktop.Flatpak

Understanding this permission model is crucial for security-conscious deployment. The default sandbox protects you; you explicitly choose when to relax constraints based on your threat model.

Example 3: Mini Window Mode Configuration

The global hotkey setup demonstrates Newelle's deep GNOME integration:

# Combined command: set gsettings and launch
/bin/bash -c 'flatpak run --command=gsettings io.github.qwersyk.Newelle set io.github.qwersyk.Newelle startup-mode "mini" && flatpak run io.github.qwersyk.Newelle'

Technical insight: This command uses flatpak run --command=gsettings to execute gsettings inside Newelle's sandbox, ensuring the setting is written to the correct DConf database that the sandboxed app can read. The && chains the configuration with the actual launch.

The startup-mode "mini" setting tells Newelle to open in its compact overlay form rather than the full chat window. Combined with GNOME's window centering:

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

...you get a centered, keyboard-invokable AI assistant that feels native to your desktop environment. This isn't electron-app hackery—it's proper Linux desktop integration.

Example 4: Extension Discovery and Installation

Newelle's extension ecosystem uses GitHub topics for discovery:

# Browse existing extensions
# Visit: https://github.com/topics/newelle-extension

# Extensions are installed through Newelle's GUI or by placing
# extension files in the appropriate configuration directory

While the README doesn't show explicit extension installation commands (it's GUI-driven), the architecture implies standard patterns. Extensions likely follow GNOME's extension model: JavaScript or Python files with metadata, dropped into ~/.var/app/io.github.qwersyk.Newelle/config/newelle/extensions/ or similar. The MCP (Model Context Protocol) support suggests extensions can expose arbitrary tools to the AI—imagine an extension that adds your company's internal API as callable functions.

Advanced Usage & Best Practices

Optimize Local Model Performance

Local models trade capability for privacy. Maximize their effectiveness:

• Context window management: Enable "Dynamic Context Management" in settings. This automatically summarizes older messages to keep within your GPU's memory constraints.
• Model quantization: Use Q4_K_M or Q5_K_M quantized models from HuggingFace. They retain 95%+ of full precision quality at 25% of the memory footprint.
• GPU offloading: Configure Llama.cpp layers to offload to your GPU. Even integrated Intel graphics help significantly versus pure CPU inference.

Profile-Based Workflow Switching

Create dedicated profiles for different contexts:

• "Secure": No web access, local models only, restricted file permissions
• "DevOps": Terminal execution enabled, web search active, cloud model fallback
• "Writing": Document chat focused, voice input enabled, markdown formatting emphasized

Switch profiles based on current task rather than reconfiguring manually.

Scheduled Tasks for Automation

Newelle's background task scheduler can:

• Run daily system health checks and report via notification
• Monitor log files for anomalies
• Periodically summarize news from configured RSS feeds

Combine with the Call Mode for truly ambient assistance—Newelle proactively informs you of issues rather than waiting for queries.

Newelle vs. The Competition: Why It Wins

The verdict: Newelle uniquely combines the privacy of local tools with the polished UX of commercial products. It's not just an alternative—it's a category definer for how AI assistants should work on open systems.

Frequently Asked Questions

Q: Can Newelle run without any internet connection? A: Absolutely. Download models through Llama.cpp or Ollama integration, and Newelle functions entirely offline. Web search and cloud model fallbacks obviously require connectivity, but core functionality is fully air-gapped capable.

Q: What hardware do I need for local models? A: Minimum 8GB RAM for smaller models (3B-7B parameters). For comfortable use with 13B models, 16GB RAM plus a GPU with 8GB+ VRAM is ideal. Newelle automatically detects your hardware and suggests appropriate models.

Q: Is my data really private with local models? A: With locally-run models, your conversation data never leaves your machine. However, if you configure cloud provider APIs, those messages go to the respective services. Newelle's profile system lets you segregate sensitive vs. non-sensitive contexts.

Q: Can I use Newelle on non-GNOME desktops? A: Yes, though with reduced integration. The app runs on any Flatpak-capable system, but Mini Window Mode hotkeys and certain theme adaptations work best on GNOME. KDE, XFCE, and Sway users report successful usage.

Q: How do extensions compare to VS Code's ecosystem? A: Newelle's extension system is younger but architecturally powerful. MCP support means extensions can expose arbitrary tools to the AI, not just UI modifications. The barrier to entry is lower—Python and JavaScript are both supported.

Q: What's the catch? Why is this free? A: Newelle is genuinely open-source (check the GitHub repository). No freemium traps, no data harvesting business model. Community contributions sustain development, with a growing Discord and extension ecosystem.

Q: Can I migrate my ChatGPT conversation history? A: Not directly—export formats differ. However, Newelle's chat branching and folder organization often prove more useful than linear history imports. Start fresh; the improved organization pays dividends.

Conclusion: Your AI, Your Rules

Newelle represents something rare in today's AI landscape: genuine user empowerment. Not the marketing-speak kind, but the technical reality of running sophisticated language models on hardware you control, with data that never leaves your possession, integrated into a desktop environment designed for serious work.

The Linux community has waited too long for AI tools that respect our values—openness, privacy, hackability. Newelle delivers without compromise. It doesn't ask you to trust a corporation's privacy policy. It doesn't extract rent through subscriptions. It simply provides the infrastructure for intelligent computing, then gets out of your way.

Whether you're switching from cloud subscriptions for security reasons, seeking deeper system integration than Electron apps provide, or exploring local AI for the first time, Newelle deserves your attention. The installation takes minutes. The productivity transformation lasts indefinitely.

Ready to reclaim your AI? Star Newelle on GitHub, install from Flathub today, and join the community building the future of open, local intelligence. Your future self—working faster, spending less, and sleeping better knowing your data is truly yours—will thank you.

Have you tried Newelle? What's your local AI setup? Drop your configuration in the comments—let's build the definitive guide to sovereign computing together.