How big is the Slack desktop app?
The official Slack desktop client is built on Electron, so every copy ships with its own Chromium browser engine and Node.js runtime. Its download is ~125 MB on macOS (~220 MB for the Universal build), ~167 MB on Windows, and ~95 MB on Linux, and it takes up more once installed: the Linux .deb alone unpacks to ~148 MB. That is before it has fetched a single message.
msga is a native Slack desktop client, and it is a different size class entirely:
| Platform | msga download | What you get | Official Slack |
|---|---|---|---|
| macOS (Apple Silicon, 14+) | ~2 MB | One app in a DMG | ~125 MB (Universal: ~220 MB) |
| Windows | ~4 MB | One .exe | ~167 MB |
| Linux (x86_64, any distro) | ~4 MB | One fully static binary, Wayland or X11 | ~95 MB (.deb) |
| Installed on disk | The same single file | Nothing unpacked or extracted | ~148 MB unpacked (Linux .deb) |
Official Slack sizes are for the Slack 4.52.171 downloads from slack.com, and the slk sizes further down are for its v0.23.0 release on GitHub, both October 2026.
Each msga download is the whole app. You don't need an installer framework, a separate runtime, or a package of shared libraries next to it. On Linux you mark the file executable and run it. On Windows you run the .exe. On macOS you drag the app out of the DMG.
Why Electron apps are so big
An Electron app is a website packaged with a private copy of a web browser. The application code may only be a few megabytes of JavaScript, but it can't run without the rest: Chromium's layout engine, its JavaScript engine, its GPU compositor, its media stack, its network stack, its font handling, and Node.js on top. All of that has to be in the download, because the app can't count on any of it being on your machine.
So every Electron app you install carries its own copy of a browser, and you end up with as many browsers on disk as you have Electron apps. The same architecture explains why Slack uses so much RAM: a browser engine is heavy to download, and it is just as heavy to keep running.
What msga does instead
msga is written in C++ that calls the operating system directly through its own thin cross-platform layer. It has no GUI toolkit, no Electron, no web view, and no bundled Chromium or Node.js. The operating system already provides most of what a desktop app needs, so msga uses it:
- Windows, input, and desktop services are native on each platform: Wayland or X11 on Linux, AppKit on macOS, Win32 on Windows.
- Networking uses what the platform provides: WinHTTP on Windows, NSURLSession on macOS, and msga's own HTTP client over Mbed TLS on Linux.
- Text is drawn by msga's own CPU renderer, using FreeType and HarfBuzz for fonts and shaping.
There is no layout engine for HTML or CSS, because there is no HTML or CSS. The interface is drawn directly, so the binary contains only the code that renders a Slack window, plus the code that talks to Slack's APIs.
Why macOS is smaller than Windows and Linux
The order of the three sizes follows from what each operating system already has installed.
On macOS, msga links only against system frameworks. AppKit, networking, and TLS are all part of the OS, so the app bundle holds little besides msga's own code. That is why the build is ~2 MB.
On Windows, Win32 and WinHTTP ship with the OS, and the .exe imports only Windows' own DLLs. To stay a single file with nothing to install, though, it carries FreeType, HarfBuzz, and the C++ runtime inside it, which puts it at ~4 MB.
On Linux, msga ships as one fully static binary, so it can run on any x86_64 distribution, old or new, under Wayland or X11, without depending on whichever library versions your distro happens to have. The trade-off is that the binary has to carry its own TLS (Mbed TLS), FreeType, and HarfBuzz. Those libraries account for most of the extra couple of megabytes over macOS, and the result is still ~4 MB. (For the Linux side in more depth, see the lightest Slack client for Linux.)
How does msga compare with slk?
slk is a third-party Slack client written in Go and released under the MIT license, and it is small too. It is a terminal (TUI) app: you run it inside a terminal emulator and drive it from the keyboard with vim-style keys, instead of getting a desktop window of its own. Inline images appear only in terminals that support the kitty graphics protocol or sixel. Its README describes it as "under 20MB", and that holds up: slk is a fraction of the size of the official app, and a genuinely nice project if you like living in the terminal.
| Platform | msga (download = on disk) | slk download (archive) | slk unpacked |
|---|---|---|---|
| macOS (Apple Silicon) | ~2 MB | ~7.4 MB (.tar.gz) | ~18.7 MB |
| Windows (x64) | ~4 MB | ~9.2 MB (.zip) | ~24.2 MB |
| Linux (x86_64) | ~4 MB | ~7.9 MB (.tar.gz or .deb) | ~20.0 MB, statically linked |
One detail matters when reading these numbers: slk's downloads are compressed archives of ~7–9 MB that unpack to a ~19–24 MB program, while msga's ~2–4 MB download is the uncompressed program itself and takes the same space on disk.
On Linux, the two are built the same way: both are fully static, single-file binaries. msga's is ~4 MB, including its own TLS, font rendering, and text shaping, with a full graphical UI. slk's is ~20 MB, with a terminal UI. That makes msga ~5x smaller, so static linking is not what sets them apart. The difference is what goes inside. A Go program carries the Go runtime and garbage collector, the networking, TLS, and crypto code from Go's standard library, and, in slk's case, its TUI and SQLite dependencies. msga is hand-written C++ that includes only the pieces it needs.
On disk, msga is roughly 5–9 times smaller than slk, and it is a full graphical desktop client that draws its own window, images, and emoji. So this is a comparison of size, not of like-for-like interfaces. If you prefer a keyboard-driven client in your terminal, slk is a good choice and still far lighter than the official app. If you want a desktop window, msga gives you one in less space than a terminal client takes.
Why app size still matters
Disks are big and connections are fast, so a ~100–200 MB app can look harmless. App size does still matter, though, in a few places:
- Slow or metered connections. On hotel Wi-Fi, a phone hotspot, or a capped data plan, ~4 MB arrives in seconds while ~95–220 MB might not arrive at all.
- Updates. msga updates itself. On Linux and Windows it swaps in the new version for the next start, and on macOS it downloads the new DMG. When the whole app is a few megabytes, every update is nearly instant, and you're never asked to fetch another copy of a browser to get a bug fix.
- Disk space. On a laptop with a small SSD, or a machine full of VMs and containers, a hundred-plus megabytes per chat app adds up.
- Cold start. Less code to load from disk means less to wait for. msga starts in under a second and uses ~40 MB of memory at startup and ~60 MB after an hour, with CPU near 0% at idle.
- Page cache. A small binary stays resident in the OS file cache cheaply, so reopening the app after it has been closed is effectively free.
- CI machines, VMs, and remote desktops. A single static file is easy to copy onto a test box, a thin client, or a throwaway VM, with nothing to install and nothing left behind.
- Auditability. A small binary comes from a small codebase. msga is GPL-3.0 and on GitHub, written in plain C++ with no framework underneath, so you can read the code that handles your Slack session in an afternoon. Nobody can read Chromium in an afternoon.
Honest limitations
msga's small size comes partly from not shipping a browser, and partly from not trying to be every part of Slack. It covers the core of daily Slack use: channels, DMs, threads, search, file sharing, reactions, canvases, notifications, and multiple workspaces. As a bonus, it can show your Claude Code sessions as DMs. Some things are only partly supported. Huddles are detected and shown, but you join them in the browser. Interactive app buttons are limited, because Slack delivers those callbacks only to its own clients.
If your day depends on Huddles or heavily interactive integrations, keep the official app for those moments. If Slack is mostly reading and writing for you, a ~2–4 MB native client does the job. The overview of msga on macOS, Windows, and Linux covers what it does on each desktop.