No description
  • Rust 68.5%
  • C++ 15.4%
  • QML 15.2%
  • CMake 0.6%
  • Shell 0.3%
Find a file
Repository files (latest commit first)
Filename Latest commit message Latest commit date
2026-10-31 19:21:11 +01:00
crates Name keyring entries and share one Google OAuth client across Gmail logins 2026-10-31 19:20:40 +01:00
packaging/arch PKGBUILD: bump pkgver to 0.1.5 2026-10-31 19:21:11 +01:00
ui Name keyring entries and share one Google OAuth client across Gmail logins 2026-10-31 19:20:40 +01:00
.gitignore PKGBUILD: switch from jiffy-git to release tarball package 2026-10-31 18:06:30 +01:00
Cargo.lock Bump version to 0.1.5 2026-10-31 19:20:57 +01:00
Cargo.toml Bump version to 0.1.5 2026-10-31 19:20:57 +01:00
PLAN.md Add Gmail support via a protocol-neutral mail backend 2026-10-31 18:41:37 +01:00
README.md Name keyring entries and share one Google OAuth client across Gmail logins 2026-10-31 19:20:40 +01:00

Jiffy ⚡

A modern, fast JMAP email client for Linux and KDE Plasma desktop environments, with Gmail support.

Features & Goals

  • JMAP Native: Built from the ground up for RFC 8620 (JMAP Core) and RFC 8621 (JMAP Mail).
  • Gmail: Gmail and Google Workspace accounts through the Gmail API (see Gmail).
  • Rust Core (jiffy-core): Safe, high-concurrency engine utilizing Tokio, Stalwart Labs' jmap-client, and local SQLite storage.
  • KDE Plasma & Kirigami (Qt6/QML): Responsive Breeze HIG-compliant user interface with fluid animations and unified inbox aggregation.
  • End-to-End Cryptography: OpenPGP/GPG signing and decryption.
  • Offline First: Local caching, state token tracking, and instantaneous search.

Repository Layout

jiffy/
├── Cargo.toml                 # Workspace manifest
├── PLAN.md                    # Multi-step development blueprint
├── packaging/arch/PKGBUILD    # Arch Linux package (jiffy)
├── README.md
├── crates/
│   ├── jiffy-core/            # Rust Core backend engine (JMAP, Gmail, Tokio, SQLite)
│   │   ├── Cargo.toml
│   │   ├── src/           # backend, client, gmail, sync, storage, accounts, oauth, onboarding, compose, gpg, pgp, security, sanitize
│   │   └── tests/
│   └── jiffy-bridge/          # CXX FFI Bridge exporting Rust engine to Qt6/C++
│       ├── Cargo.toml
│       ├── build.rs
│       └── src/           # lib.rs (FFI), compose.rs, logins.rs, security.rs, demo.rs
└── ui/                        # Qt6 / QML Frontend application & models
    ├── CMakeLists.txt
    ├── data/                  # .desktop entry and KNotification config
    ├── qml/                   # Kirigami UI (Main, Sidebar, MessageList, MessageView, ...)
    ├── src/
    │   ├── main.cpp
    │   ├── BridgeController.h/.cpp
    │   ├── DesktopIntegration.h/.cpp   # Tray icon & notifications
    │   └── models/
    │       ├── MailboxListModel.h/.cpp
    │       ├── MessageThreadModel.h/.cpp
    │       ├── MessageFilterProxyModel.h/.cpp
    │       └── MessageDetailModel.h/.cpp
    └── tests/
        └── test_bridge.cpp

Building & Running

Requires Rust, CMake, Qt ≥ 6.10 and Kirigami. KStatusNotifierItem and KNotifications are optional.

# The CMake build invokes `cargo build -p jiffy-bridge` itself
cmake -B ui/build -S ui && cmake --build ui/build

# Explore the UI with sample data (in-memory, no server needed)
./ui/build/jiffy-ui --demo

# Or add your JMAP or Gmail account with the sidebar's "+" button
./ui/build/jiffy-ui

Gmail

Gmail has no JMAP server, so Jiffy talks to the Gmail API instead. Google only lets verified apps use Gmail's mail scopes publicly, so you sign in with your own Google Cloud OAuth client, which stays in Google's "testing" mode:

  1. In the Google Cloud Console, create a project and enable the Gmail API (APIs & Services → Library).
  2. Under Google Auth Platform → Audience, keep the app in Testing and add your Google address as a test user.
  3. Under Clients, create an OAuth client of type Desktop app and copy its client ID and client secret.
  4. In Jiffy, add an account with your Gmail address (or pick Google (Gmail API) under Set Up Manually for a Workspace domain), paste the client ID and secret, and sign in with your browser. Jiffy saves the client, so further Gmail accounts only need their address (Use a Different Client… switches to another one; add each address as a test user in step 2).

Labels appear as folders (nested labels nest), starring flags a message, and new mail is checked every minute (Gmail push needs Cloud Pub/Sub). Google expires refresh tokens of apps in testing mode after seven days, so Jiffy asks you to sign in again weekly: use the notification's Sign In Again action, or the button next to the account under Settings → Manage Accounts…. Your cached mail and settings are kept.

Account credentials are stored in the system keyring (KWallet / Secret Service), in entries named "Jiffy:

()" plus "Jiffy: Google OAuth client" (entries from before 0.1.5 get these names the next time Jiffy updates them). OpenPGP uses your GnuPG installation (gpg must be installed): incoming mail is decrypted and outgoing mail signed with your GnuPG secret keys; signatures are verified and outgoing mail encrypted with keys from your GnuPG keyring, Jiffy's key cache, or WKD / keys.openpgp.org (online lookup can be turned off in settings). Encrypted mail is always also encrypted to you.

Each sending address signs with the newest usable GnuPG secret key whose user ID contains that address. Settings → Manage Accounts… → OpenPGP Keys shows which key that is and lets you pick a different one. Addresses without a key get a Create Key button (an ed25519 key valid for two years; GnuPG asks for the passphrase and stores a revocation certificate), and each key can be published to keys.openpgp.org (which mails a verification link), backed up, exported or extended by two years. Manage Keys… opens Kleopatra (or GPA / Seahorse) for importing keys and everything else.

Desktop notifications use jiffy.notifyrc, which is installed by cmake --install ui/build; without it, new-mail alerts fall back to tray balloons.

Packaging

An Arch Linux package recipe lives in packaging/arch/PKGBUILD (jiffy, built from the latest release tarball):

cd packaging/arch && makepkg -si

Release builds go through CMake as usual; non-Debug build types use cargo's release profile, and -DJIFFY_CARGO_ARGS=--frozen builds offline from the committed Cargo.lock.

Running Tests

# Run Rust workspace unit and integration tests
cargo test

# Build and run Qt6 / CXX Bridge verification suite
cmake --build ui/build && ./ui/build/test-bridge