Chatterino 2: a native Twitch chat client for Windows, macOS and Linux

What Chatterino 2 replaces, and for whom

Twitch's own chat lives in a browser tab. That is fine for one channel. It becomes awkward when you are watching three streams, moderating a fourth, and switching between a personal account and a moderator account, because each context is a separate tab with its own login state. Chatterino 2 is a desktop application that puts those contexts in one window. The README states plainly that it is "a chat client for Twitch.tv", so the scope is Twitch only, and the topics list confirms the targets: linux, macos, windows. The people who get value from it are viewers who follow several channels simultaneously, moderators who need a second account signed in without logging out of the first, and anyone who wants chat to survive a browser restart or a page reload. It is a client, not a broadcaster's tool: nothing in the repository description or README suggests it captures video, encodes a stream, or talks to OBS. The related searches include "Chatterino OBS plugin", but that phrase describes something the README does not document.

How the client is put together

The repository is a CMake C++ project with Qt as the UI layer, and the layout makes the split visible. src/ holds the application, lib/ holds vendored dependencies pulled in through .gitmodules, and tests/, benchmarks/ and mocks/ sit alongside them, which tells you the project is built with testability in mind rather than as a single translation unit. Build files exist per platform: BUILDING_ON_WINDOWS.md, BUILDING_ON_WINDOWS_WITH_VCPKG.md, BUILDING_ON_LINUX.md, BUILDING_ON_MAC.md and BUILDING_ON_FREEBSD.md, plus vcpkg.json and conanfile.py for dependency resolution. Continuous integration is defined under .CI/ and .github/, and the README carries build badges for Windows, Ubuntu, macOS and FreeBSD, so those platforms are exercised on every push. The data flow is the ordinary one for a chat client: the process connects to Twitch, receives messages, and renders them into panes. What the README does not describe is the internal message pipeline, the IRC or WebSocket details, or how panes are persisted between sessions. The Doxygen output at doxygen.chatterino.com is the project's own answer to that gap, and it is regenerated daily according to the README.

Installing Chatterino 2 on Windows, Linux or macOS

The README points at chatterino.com for current releases, and it names two package channels. Windows users can install from Chocolatey, and there is a Flathub package listed in the badge row as com.chatterino.chatterino. On Windows, the README warns that you may need the VC++ Redistributables first, and if the application still reports MSVCR120.dll missing, it points at the VC++ 2013 Redistributable. The Chocolatey route is the shortest path on Windows:

choco install chatterino

That installs the packaged build and lets choco upgrade handle later versions. If you would rather track the newest code, the README links a nightly-build release, and it is explicit that this is a separate download from the tagged releases. First run gives you an empty window; you add a channel by entering its name, and you can add further panes for other channels or for a second account. That multi-pane behaviour is the reason to use the client at all, and it is the first thing to try rather than the last. Builders who want to compile it themselves clone with submodules in one step:

git clone --recurse-submodules https://github.com/Chatterino/chatterino2.git

If you cloned without that flag, the README gives the recovery sequence: change into chatterino2 and run git submodule update --init --recursive. From there the platform BUILDING_ON_*.md file is the authority, and the README does not summarise their contents.

Where the documentation stops short

The README is a doorway, not a manual. It hands you the wiki at wiki.chatterino.com, the Doxygen site, and the per-platform build files, and then stops. There is no description of configuration file locations, no list of settings, no explanation of how accounts are stored or whether credentials are kept in the system keychain. For a client that asks you to log in with a Twitch account, that silence matters, and the search question "Is Chatterino safe to use?" is a reasonable thing to ask. What can be checked from the repository is the licence (MIT, with a LICENSES/ directory and REUSE.toml indicating REUSE-compliant licensing metadata), the source itself, and the fact that builds are produced by the project's own GitHub Actions workflows rather than by an opaque third party. What cannot be checked from the README is the credential handling. If that is your deciding factor, the source under src/ is where to look, not the README. The same gap applies to updates: the README does not document an in-application updater or a rollback path, so how you move between versions depends on the channel you installed from.

Release channels and what they cost you

The release list shows two very different things living under one roof. v2.5.5 is tagged 2026-03-22, with a v2.5.5-beta.1 on 2026-03-01 before it. The nightly-build tag, by contrast, is dated 2022-11-08, which is years behind the tagged releases even though the repository's last push was 2026-09-28. That mismatch is worth reading carefully: a nightly tag that old does not mean development stopped, since the master branch is clearly still receiving commits, but it does mean the nightly release page is not a reliable mirror of current master. If you want the newest code, the honest options are to build it yourself from the platform instructions or to wait for a tagged release. The upgrade cost is low if you installed through Chocolatey or Flathub, because those tools own the version. It is higher if you downloaded an installer by hand, since nothing in the README describes an automatic update mechanism. On the licence side, MIT is permissive: it allows commercial use, modification and redistribution provided the copyright notice and permission notice are retained. That is a summary of the licence text, not legal advice, and the LICENSE file plus LICENSES/ are the authoritative sources. Note that the MIT licence covers this project's own code; the vendored code under lib/ and the Qt dependency carry their own terms.

What it does not do, and what to use instead

Chatterino 2 is Twitch-only. The search question "Does Chatterino work with YouTube?" has a short answer from the README: it describes a chat client for Twitch.tv and mentions no other platform, so YouTube chat is out of scope. If you need one window covering Twitch and YouTube at once, you want a different class of tool, a multi-platform chat aggregator rather than a single-platform client. The difference in approach is not cosmetic. An aggregator normalises several platforms' message formats into one model and pays for it with per-platform lag and a lowest-common-denominator feature set; Chatterino 2 targets one platform and can therefore expose Twitch-specific behaviour directly. The same logic applies to the related search "Chatterino7": a separate project with its own repository and its own feature set sits outside this one, and the README here says nothing about it, so treat any comparison you read elsewhere as unverified against this source. The other boundary is extensibility. The related searches for "Chatterino plugins" and "chatterino2 plugins" suggest demand, but the README documents no plugin API, no scripting layer and no extension directory. If plugins are a requirement, this is the wrong tool, and the searches themselves point at third-party projects rather than at anything in this repository.

Working on the codebase

For contributors, the repository is unusually explicit about hygiene. Formatting is clang-format driven from .clang-format in the root, with .clang-tidy and .prettierrc alongside it, and the README tells contributors to consult the wiki's developer page for the rest. There is one piece of setup that is easy to miss and that the README calls out directly: the history contains large stylistic commits that touch most files, so git blame produces noisy output unless you opt in to the ignore list.

git config blame.ignoreRevsFile .git-blame-ignore-revs

After that, blame skips the revisions listed in .git-blame-ignore-revs, which the README notes GitHub already does by default. CONTRIBUTING.md and REUSE.toml round out the process requirements, and the presence of tests/, benchmarks/ and mocks/ means changes are expected to be exercisable rather than only visually checked. The practical cost of contributing is the C++ and Qt toolchain plus whichever dependency manager your platform file prescribes, which is a real barrier compared with a scripting-based client. In exchange, the build is reproducible across five documented platforms and the project runs its own CI on each push.

Editorial conclusion

Adopt Chatterino 2 if you watch or moderate several Twitch channels at once and want them in one native window with per-pane account switching; skip it if your chat lives on YouTube, or if you want a plugin API, since the README documents no extension mechanism and the related searches for plugins point at third-party projects rather than anything in this repository. Before committing, check the release page for the version you intend to run, because the newest tagged build is v2.5.5 from 2026-03-22 while the nightly-build tag dates from 2022-11-08, and those two channels are not the same thing.

Frequently asked questions

Official sources

1. Chatterino/chatterino2 on GitHub
2. License: MIT
3. Project website
4. README
5. Releases