ZapZap review: WhatsApp Web in a PyQt6 desktop shell

What ZapZap changes around WhatsApp Web

ZapZap solves a desktop integration and packaging problem for users who regularly communicate through WhatsApp Web. The README describes it as an unofficial client that loads `https://web.whatsapp.com/` in an application built with Python, PyQt6, and QtWebEngine. Rather than implementing a separate messaging system, ZapZap places the web client in its own window and adds desktop services around it.

The clearest audience is a desktop user who finds a normal browser tab inconvenient. ZapZap supports multiple account profiles with isolated web sessions, so users can keep separate signed-in accounts without placing them in one browser context. It also adds a system tray icon, native desktop notifications, application-level theming, configurable downloads, and custom CSS and JavaScript injection.

Linux receives the widest documented distribution. The README lists Flatpak as the recommended option, alongside AppImage builds for x86_64 and aarch64, a DEB package, a Snap package, and a Fedora COPR repository. Windows users can download x86_64 or ARM64 executables, while Python users can install a wheel. This makes ZapZap relevant to users who want WhatsApp packaged through operating-system and desktop-ecosystem tooling.

The unofficial status is an architectural qualification, not a minor disclaimer. ZapZap depends on WhatsApp Web continuing to function inside QtWebEngine. A change to the website can therefore affect the application even when ZapZap itself has not changed. Users who want an independently maintained native client or a direct WhatsApp API should not interpret the PyQt6 interface as proof that ZapZap implements a separate client protocol.

PyQt6 modules, WebEngine rendering, and account isolation

The repository layout divides the project into focused Python packages. `zapzap.features.browser` contains separate `shell` and `web` packages, while the accounts feature includes a `domain` package. Other packages cover configuration, themes, internationalization, diagnostics, reporting, environment handling, and platform-specific behavior. The settings interface is itself split into pages for accounts, appearance, notifications, language downloads, networking and privacy, advanced customization, and debugging.

At runtime, PyQt6 supplies the application window and desktop controls. PyQt6-WebEngine renders the WhatsApp Web page inside that window. The README states that account profiles use isolated web sessions. That design permits multiple accounts while keeping each profile's web session separate. It does not explain the storage location, encryption, export, backup, or recovery mechanism for those sessions, so users with existing installations should not assume that changing package formats will automatically migrate profiles.

ZapZap can inject CSS and JavaScript globally or for an individual account. This gives users a way to alter the web interface beyond the built-in light, dark, and system theme controls. The trade-off is dependence on WhatsApp Web's current page structure. Scripts written against one version of that interface can stop working after an upstream interface change. The README does not publish a compatibility policy or versioning rule for injected customizations.

QtWebEngine dictionaries provide spell checking, according to the README. Download handling is configurable, but the README does not enumerate available download actions, default directories, naming rules, or conflict behavior. Those details matter when ZapZap replaces a browser workflow for users who regularly receive files through chat.

Installing ZapZap and completing a first sign-in

Python users can install the published package with the command documented in the README:

pip install zapzap

The package metadata declares Python 3.8 or later and depends on `PyQt6` and `PyQt6-WebEngine`. After installation, use the console entry point declared as `zapzap = "zapzap.__main__:main"`:

zapzap

The application should open the WhatsApp Web interface in its desktop window. Complete the normal WhatsApp Web authentication flow shown there. Before configuring a second account, confirm that the first window opens, notifications appear, downloads open as expected, and the selected theme matches the system or your preference.

The repository also includes `run.py`, so source users have a separate entry file. The README does not document the exact source-development setup command, and the available installation instructions do not state whether dependencies from `requirements.txt` must be installed separately before running `run.py`. A developer following the published package route can use `pip install zapzap`, while source-build users should consult `docs/README.md` for the complete procedure.

For non-Python installation, the README directs Linux users to the Flathub page for `com.rtosta.zapzap`, AppImage, DEB, and Windows users to the GitHub releases, Snap users to Snapcraft, and Fedora users to the listed COPR repository. It explicitly documents automatic AppImage updates through `.zsync`, but it does not say that Flatpak, Snap, DEB, COPR, Windows executables, or Python installations use the same updater.

Where ZapZap differs from browser-based WhatsApp Web

The main difference is not a new conversation protocol. It is the application environment around WhatsApp Web. ZapZap provides a standalone window, multiple isolated account profiles, native system tray behavior, desktop notifications, theme handling, spell checking, download configuration, and custom styling or scripting. The README's comparison table presents browser WhatsApp Web as tied to the default browser, while ZapZap is packaged for multiple desktop and Linux distribution systems.

These differences are most useful to Linux users. A Flatpak package can fit an existing Flatpak workflow, while DEB, Snap, and COPR serve particular package managers. The AppImage route provides a self-contained executable format and an explicit `.zsync` update mechanism. Windows executable builds serve x86_64 and ARM64 systems without requiring the Python package route. The README does not compare sandbox permissions or update controls between these formats, however, so package format should not be chosen solely on availability.

Opening `https://web.whatsapp.com/` in a conventional browser is the real alternative. A browser already provides familiar profile storage, cookie handling, extensions, bookmarks, tab management, and its own update process. ZapZap instead emphasizes account separation and desktop integration. Users who depend on browser extensions, existing browser cookies, or tightly coupled tab workflows may find the browser route less disruptive. Users who want separate accounts and a dedicated messaging application may find ZapZap more appropriate.

The README compares the privacy of a browser session with a dedicated desktop application, but it does not document network routing, request modification, telemetry, diagnostics uploads, or cookie protection. The application shell should therefore not be treated as independent evidence of stronger privacy.

ZapZap failure modes and unsupported expectations

The main failure mode is an upstream compatibility break. Because ZapZap loads WhatsApp Web, login changes, altered interface elements, or browser-dependent behavior can disrupt the application. The repository does not document a guaranteed fallback, native offline queue, or release process that independently verifies every WhatsApp Web change before publication.

Custom CSS and JavaScript create a second compatibility boundary. ZapZap can apply these customizations globally or per account, but injected code may depend on page selectors and interface behavior owned by WhatsApp. A customization that fails after a website update is not necessarily evidence of a Python failure. Users who rely on such modifications should retain a way to disable them.

The README does not document rollback for profiles, custom scripts, downloads, or package updates. It also does not explain whether an AppImage can return to an earlier release without affecting local account sessions. Existing users should inspect `CHANGELOG.md` before upgrading because that file is the repository's documented record of project changes. Source users can additionally consult `docs/README.md`, which the README identifies as the source for maintenance procedures and automated-test instructions.

ZapZap is also unsuitable when WhatsApp Web must be replaced by a native implementation. The package structure contains no documented native account protocol or separate messaging backend. Users who require direct API access, offline message storage outside the web session, or a vendor-managed official client should look elsewhere rather than expecting the PyQt6 shell to provide those capabilities.

Maintenance releases, upgrades, and GPL-3.0 obligations

The repository is not archived. Its last push was on 2026-10-15, and release 7.5 was published on 2026-10-09. Two documented prereleases preceded it: `7.5-rc.5` on 2026-10-02 and `7.5-rc.4` on 2026-10-01. This recent sequence shows ongoing release activity, but it does not by itself establish the compatibility of every packaging channel.

Upgrade cost depends on the installation method. Python users must consider changes to `zapzap`, `PyQt6`, and `PyQt6-WebEngine`. Packaged users must consider what the relevant repository replaces and how local account profiles, downloads, settings, CSS, and JavaScript are retained. The README does not describe a settings export format or migration procedure. It also does not document update behavior beyond AppImage `.zsync` support.

The changelog is therefore the first project-specific file to inspect before moving an existing installation forward. For developers, `docs/README.md` contains architecture, maintenance procedures, and automated-test instructions according to the root README. A reader should also check whether a new release includes packaging changes relevant to their architecture, particularly when using aarch64 AppImage or ARM64 Windows executables.

ZapZap is licensed under GPL-3.0-or-later, as stated in the README and `pyproject.toml`. Anyone redistributing or modifying the software should review the obligations in `LICENSE`, including applicable source-availability and notice requirements. This is not legal advice. The practical license fact relevant to an adopter is that ZapZap is distributed under GPL-3.0-or-later rather than under a permissive or proprietary license.

Editorial conclusion

Adopt ZapZap if you specifically want WhatsApp Web in a standalone PyQt6 application, especially on Linux with separate accounts or system-level tray integration. Do not choose it if you require a native client that does not depend on WhatsApp Web. Before installing, confirm that your platform is supported, review `CHANGELOG.md` for upgrade notes, then verify sign-in, notifications, downloads, profile separation, and update behavior on the first release.

Frequently asked questions

Official sources

1. License: GPL-3.0
2. Project website
3. rafatosta/zapzap on GitHub
4. README
5. Releases