Quill: a fast Telegram client for macOS, Windows and Linux

Quill is a free, open-source Telegram desktop client written from scratch in Rust. You sign in with your normal Telegram account and get your real chats, groups, channels and calls. It talks to Telegram through TDLib, Telegram's own client library, and draws its whole interface on the GPU with GPUI, the UI framework from the Zed editor. There's no browser engine or web view inside.

On the same Mac, Quill used about a third of Telegram Desktop's memory and put its window on screen about four times faster on a warm launch (numbers below).

Website and install: shinycake.github.io/quill

If you like Quill, starring the repository helps more people find it. At 50 stars it can be listed in awesome-rust, and at 75 in Homebrew's main cask list, so brew install works without the tap.

Captured from a real Quill window signed in to a demo account.

On a Mac (macOS 14 or later, Apple Silicon), paste this into Terminal:

curl -fsSL https://raw.githubusercontent.com/shinycake/quill/main/scripts/macos-install.sh | bash

On Windows (10 or later, x64), paste this into PowerShell:

irm https://raw.githubusercontent.com/shinycake/quill/main/scripts/windows-install.ps1 | iex

On Linux (x86_64 or arm64, glibc), paste this into a terminal:

curl -fsSL https://raw.githubusercontent.com/shinycake/quill/main/scripts/linux-web-install.sh | bash

Each script downloads the latest release from GitHub Releases and checks it against the release's SHA-256 checksums. If the file doesn't match, the script stops and installs nothing. None of them needs administrator rights. Run the same command again to update.

Quill for Mac is signed with a Developer ID and notarized by Apple, so it opens without a warning however you download it. A Mac copy installed before 3 November 2026 can't update to the notarized version by itself: install it once with the command above, and updates work as usual after that. The Windows build isn't signed with a paid certificate yet, so a zip downloaded in a browser asks once on first launch: click More info, then Run anyway. Files the script downloads aren't marked for that check, so they open without a warning. The website walks through it step by step.

Prefer a package manager? On a Mac, brew install --cask shinycake/tap/quill-app. On Linux, flatpak install --user https://shinycake.github.io/quill/flatpak/quill.flatpakref installs from Quill's own Flatpak repository.

• Messages: bold, italic, code, spoilers, quotes and links. Replies and quote-replies, forwarding, scheduled and silent messages, cloud drafts, search inside a chat, reactions and polls.
• Media: photos, videos, albums, GIFs and stickers. Voice and video messages recorded in the app, with transcription. A fullscreen media viewer, an audio player bar, link previews and a downloads list.
• HDR photos: a photo sent as a file is shown in high dynamic range, with an HDR tag in the chat and the viewer. On a Mac with an XDR or HDR screen this covers iPhone HEIC with a gain map, and AVIF or HEIC in PQ or HLG. On Windows with HDR turned on, it covers Ultra HDR and gain-map JPEG from Android phones, and HDR JPEG XL.
• Calls: one-to-one audio and video calls with screen sharing, and group voice chats.
• Groups and channels: admin tools, invite links, join requests, forum topics, comments, and statistics with growth charts. Bots with keyboards, inline results and games.
• Privacy and accounts: secret chats, a local passcode lock, active-session management and two-step verification. Sign in with a phone code, a QR code or a password, and switch between several accounts.
• Your setup: light and dark themes with automatic night mode, accent colors, chat wallpapers, text size, and bubble or plain message layouts. tg:// and t.me links, a tray menu and unread badges.

STATUS.md lists every feature one by one, and the progress dashboard charts it over time.

Both apps ran on the same Mac, signed in to the same Telegram account, each with its own local cache.

The machine was an Apple M1 Pro with 16 GB running macOS 27.0.1.

• Memory: physical footprint from macOS footprint, which includes GPU memory. Each comparison uses the median of three runs per app. Measured on 8 October 2026 against Telegram Desktop 7.2.9.
• Launch: the time until the window is on screen. A cold launch empties the file cache first. Measured on 18 October 2026 against Telegram Desktop 7.3.1.

Windows and Linux haven't been measured yet.

Quill runs on your computer and keeps its data there. The local database is encrypted with a key held in the macOS keychain, Windows DPAPI, or a private file on Linux. Quill has no server of its own and no analytics. Besides Telegram, it only contacts GitHub to check for updates, and you can turn that off in Settings.

Agent access lets an AI agent on your computer, such as Claude Code, Codex, Claude Desktop or Cursor, use your Telegram account through the Quill that is already running. It's off by default, and while it's off the only trace is one switch in Settings > Advanced. Turn it on in Settings > Advanced > Agent access. That page shows setup commands with the path of your installed Quill, and a setup prompt you can paste into any agent. The lines below assume Quill is where the one-line installer puts it. On a Mac where /Applications isn't writable, the installer uses ~/Applications instead.

macOS (Terminal):

claude mcp add --scope user quill -- /Applications/Quill.app/Contents/MacOS/quill mcp   # Claude Code
codex mcp add quill -- /Applications/Quill.app/Contents/MacOS/quill mcp                 # Codex
/Applications/Quill.app/Contents/MacOS/quill agent connect claude-desktop --yes         # or cursor
/Applications/Quill.app/Contents/MacOS/quill agent install-skill                        # Quill skill for Claude Code

Windows (PowerShell):

claude mcp add --scope user quill -- "$env:LOCALAPPDATA\Programs\Quill\quill.exe" mcp   # Claude Code
codex mcp add quill -- "$env:LOCALAPPDATA\Programs\Quill\quill.exe" mcp                 # Codex
& "$env:LOCALAPPDATA\Programs\Quill\quill-cli.exe" agent connect claude-desktop --yes   # or cursor
& "$env:LOCALAPPDATA\Programs\Quill\quill-cli.exe" agent install-skill                  # Quill skill for Claude Code

Linux:

claude mcp add --scope user quill -- ~/.local/bin/quill mcp   # Claude Code
codex mcp add quill -- ~/.local/bin/quill mcp                 # Codex
~/.local/bin/quill agent connect claude-desktop --yes         # or cursor; Claude Desktop has no official Linux build
~/.local/bin/quill agent install-skill                        # Quill skill for Claude Code

agent connect merges Quill into the app's MCP config after a backup. Any other MCP app can run Quill as a stdio server: the executable, with the argument mcp. Scripts and agents that don't speak MCP use the same tools from the command line: quill agent status, quill agent read --chat saved, quill agent send --chat @some_bot --text /start, or quill agent call <tool> --json '{…}' for any tool. quill agent --help lists every command and exit code. On Windows, run these with quill-cli.exe instead of quill.exe. quill.exe is a windowed program, so a terminal doesn't wait for it or get its exit code, and quill-cli.exe does both.

Agents can read the chats you grant (by default Saved Messages, bots and your own channels), search them, send and edit messages, react, and manage drafts and folders. They can also make raw TDLib calls under the same grants and, if you turn on a second switch, click and type in Quill's window. Quill asks you before an agent goes outside its grants. Every send shows in an activity log, can wait for your click, and is paced to stay inside Telegram's limits.

Some limits hold whatever the agent asks. Quill never sends your data to an AI service itself; the agent you run asks Quill for it. There's no network listener, only a local socket with a per-launch token. Read receipts, online status and typing are never hidden, there's no bulk export, and Telegram's terms don't allow training AI models on your chats. The agent guide has the tools, recipes and errors.

docs/build.md covers each platform and the packaging scripts. The short version:

cargo test --no-default-features
cargo run --features ui          # live connect with your Telegram credentials + tdjson
cargo run --no-default-features -- --connect-smoke   # headless WaitPhoneNumber gate

Without credentials, cargo run --features ui opens a synthetic demo chat. To sign in to a real account from your own build, get an API ID and hash from my.telegram.org and build TDLib with scripts/build-tdlib.sh. Then set TELEGRAM_API_ID and TELEGRAM_API_HASH in the environment or in a gitignored quill.local.env file, and point QUILL_TDJSON_PATH at the library. docs/credentials.md has the details. Don't reuse another app's API ID: Telegram's API terms require every app to have its own. Release packages already include Quill's own.

On Linux, building the UI also needs the GTK 3 and ALSA development packages (libgtk-3-dev and libasound2-dev on Debian and Ubuntu).

Toolchain: Rust 1.100.0, pinned in rust-toolchain.toml (also the minimum supported version). UI: gpui-kit 0.9.0. TDLib: 1.8.70.

Is Quill an official Telegram app? No. It's an independent open-source client that uses the public Telegram API under Telegram's API Terms of Service.

Can my account get banned for using it? Quill follows Telegram's rules for third-party apps as closely as it can, but Telegram decides what it allows and nobody can promise anything. Keep an official app installed.

Is it free? Yes. Quill is free software under the MIT license.

Which systems does it run on? macOS 14 or later on Apple Silicon, Windows 10 or later on x64, and Linux on x86_64 or arm64 with glibc, a Vulkan driver and GTK 3.

Quill is released under the MIT License. The packages also contain third-party components under their own licenses, among them TDLib (BSL-1.0), OpenSSL (Apache-2.0), FFmpeg (LGPL-2.1 or later, Linux and Windows only), Telegram's tgcalls call engine (LGPL-3.0) and the ThorVG sticker renderer (MIT). THIRD_PARTY.md lists every component. The license texts are in licenses/, and the licenses of the Rust crates are in THIRD_PARTY_LICENSES.md. In the app, Settings → Appearance → About Quill → Open-source licenses opens the same list.

Pull requests are welcome. Before you open one, run the checks from the Linux CI job:

cargo fmt --all -- --check
cargo clippy --no-default-features --all-targets -- -D warnings
cargo test --no-default-features

Feature PRs don't edit STATUS.md or DECISIONS.md. List the checklist items you finished in parity-fragments/<slice-id>.txt and write your notes in docs/decisions/<slice-id>.md; the merge pipeline updates STATUS.md after the merge. Older decisions, pins and blockers are archived in DECISIONS.md. Never commit API credentials.