[opensourcedex]

Twake Chat is a free, open source collaboration & communication project written in Dart and released under AGPL-3.0. It has 165 GitHub stars, 46 forks and 317 open issues, and was last pushed 10 hours ago. On this registry it ranks #41 of 41 tracked projects in Collaboration & Communication, with 5 head-to-head comparisons available.

What is Twake Chat?

Twake Chat is an open source, decentralized messaging client for the Matrix protocol, built by Linagora in Flutter, and it is intended for individuals and organizations that want secure, decentralized chat as well as for developers who want to build their own Matrix-based chat applications.

What it is

Twake Chat is a multi-platform Flutter application that connects to Matrix, described as an open network for secure, decentralized communication, and it is developed by Linagora as an open source project released under the AGPL-3.0 licence. The codebase is written in Dart, and the README documents build targets for Android, iOS, web and Linux, which means the same client is intended to run across phones, desktops and browsers against a single Matrix account.

The concrete problem it solves is the friction of Matrix itself. Matrix identities are long and awkward for ordinary users, and Twake Chat hides the complexity of Matrix IDs behind simple QR codes, so adding and verifying contacts does not require reading or typing raw identifiers. Because it is compatible with Element, Nheko, NeoChat and all other Matrix apps, it also replaces the assumption that a chat client is bound to one vendor: the same account and rooms remain reachable from any other Matrix client, so no conversation is trapped inside this application.

Key capabilities

  • Sends all kinds of messages, images and files, including voice messages and location sharing.
  • End-to-end encryption with emoji verification and cross signing.
  • Unlimited private and public group chats, plus public channels with thousands of participants.
  • Feature rich group moderation covering all Matrix features.
  • Spaces support, with the ability to discover and join public groups.
  • Hides the complexity of Matrix IDs behind simple QR codes.
  • Dark mode, custom themes, custom emotes and stickers, and push notifications.

Who uses it and how

  • Individuals and organizations that want an open source, decentralized chat application rather than a closed messaging silo.
  • Developers who want to build their own Matrix-based chat apps and use this Flutter codebase as a starting point.
  • Operators of public channels with thousands of participants who need group moderation built on Matrix features.
  • Teams that require end-to-end encryption with emoji verification and cross signing across the Android, iOS, web and Linux builds.

Getting started

End users install the published Android application from Google Play or the iOS application from the App Store, both linked from the README. Building from source requires Flutter 3.38.9, and the documented setup paths include bash scripts/config-pre-commit.sh for pre-commit verification, devenv shell through the provided devenv.nix, a web-ready build of libolm placed in assets/js/package, and for Linux the packages libjsoncpp1, libsecret-1-dev, libsecret-1-0, librhash0, libwebkit2gtk-4.0-dev and libolm3 plus a Rust toolchain.

How it compares

The facts name Element, Nheko and NeoChat as sibling Matrix clients, and Twake Chat is explicitly compatible with all of them, so the comparison is about client experience rather than protocol lock-in: the same Matrix account works across all of them. Twake Chat distinguishes itself within that group by being a Flutter multi-platform client from Linagora under the AGPL-3.0 licence, with QR-code onboarding that hides raw Matrix identifiers.

When to use it — and when not

Choose it if a Matrix account is already available, since this repository is a client only and the README documents no server-side component to deploy. Building it yourself is a real commitment: Flutter 3.38.9, JDK 17, an Android SDK with build tools 34.0.0 and NDK 26.1.10909125 for Android, a Rust toolchain plus several system libraries for Linux, and a self-built libolm for the web target. It is a poor fit for anyone who wants a managed hosted service, and the registry listing is thin, with no topics recorded and 317 open issues against 165 stars.

project readme (upstream, from github) — read inline

Twake Chat Client

Contributors Issues Documentation Android application Ios application


Website • View Demo • Report Bug • Roadmap • Translate Twake

Twake Chat is an open source, decentralized chat app based on the Matrix protocol. It was developed by Linagora. Twake Chat is a good option for individuals and organizations who are looking for a secure and decentralized chat app. It is also a good choice for developers who want to build their own Matrix-based chat apps.

Features

  • Send all kinds of messages, images and files
  • Voice messages
  • Location sharing
  • Push notifications
  • Unlimited private and public group chats
  • Public channels with thousands of participants
  • Feature rich group moderation including all matrix features
  • Discover and join public groups
  • Dark mode
  • Custom themes
  • Hides complexity of Matrix IDs behind simple QR codes
  • Custom emotes and stickers
  • Spaces
  • Compatible with Element, Nheko, NeoChat and all other Matrix apps
  • End to end encryption
  • Emoji verification & cross signing
  • And much more...

Development

Please make sure to run the following command at first, to verify your code before each commit:

bash scripts/config-pre-commit.sh

Requirements

  • Flutter 3.38.9

You can at any moment verify your flutter installation using:

flutter doctor -v
Web

If you only plan to work on the web target we recommend installing Google Chrome as it is the default supported target (Flutter being developped by Google).

It is also required to have a web ready version of libolm available in the assets/js/package folder. You can build a version using:

docker run -v ./assets/js/package:/package nixos/nix:2.22.1

# within the docker
nix build -v --extra-experimental-features flakes --extra-experimental-features nix-command gitlab:matrix-org/olm/3.2.16?host=gitlab.matrix.org\#javascript
cp /result/javascript/* /package/. -v
exit

# back on your host
sudo chown $(id -u):$(id -g) ./assets/js/package -Rv
Android
  • An implementation of JDK 17 (tested with openjdk-17.0.13+11)
  • (Optional) Android Studio
  • An Android SDK with:
    • Android build tools: 34.0.0
    • Android platform: 31, 32, 33, 34, 35
    • CMake: 3.22.1
    • Android NDK: 26.1.10909125
    • Google APIs: enabled

Note: Gradle will try to install the JDK 8. If for any reasons the operation failed, try to install your own and use this method to tell Gradle where to find it.

Linux
  • Lib JsonCPP
  • Lib Secret
  • Lib RHash
  • Lib WebKit 2 GTK
  • Lib OLM

If needed, a complete list is available in the flake.nix.

On Ubuntu, the following command should install all the required elements:

sudo apt install libjsoncpp1 libsecret-1-dev libsecret-1-0 librhash0 libwebkit2gtk-4.0-dev libolm3

In addition, the Linux build requires Rust. For macOS or Linux, execute the following command in a terminal emulator:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

For Windows, you can use the Rust Installer.

In case you have Rust already installed, make sure to update it to latest version:

rustup update
devenv.nix

A devenv.nix is provided in order to ease the process of setting up your dev environment. Check out the install instructions: https://devenv.sh/getting-started/

Then you can use devenv shell to fire up your environment. This can be automated thanks to: [nix-direnv](https://github.com/nix-community/nix-direnv/)

Supported platforms:

  • Linux x86_64
  • MacOS aarch_64
  • MacOS x86_64
  • Windows WSL

Configure the app

In order to run the web target you must provide a default configuration file. This can be done by copying the config.sample.json to config.json. Here is an example working with matrix.org:

{
  "application_name": "Twake Chat",
  "application_welcome_message": "Welcome to Twake Chat!",
  "default_homeserver": "matrix.org",
  "privacy_url": "https://twake.app/en/privacy/",
  "render_html": true,
  "hide_unknown_events": true,
  "issue_id": "",
  "app_grid_dashboard_available": false,
  "homeserver": "https://matrix.org/",
  "platform": "localDebug",
  "default_max_upload_avatar_size_in_bytes": 1000000,
  "dev_mode": true,
  "qr_code_download_url": "https://sign-up.twake.app/download/chat",
  "enable_logs": true,
  "support_url": "https://twake.app/support",
  "cozy_external_bridge_version": "0.16.1"
}

Running the code

Before running the app, please update the dependencies:

flutter pub get && flutter pub run build_runner build --delete-conflicting-outputs

Now you can run the project:

flutter devices   # To list available run targets

# flutter run -d <device>, e.g:
flutter run -d chrome

Build

Please use the helper script corresponding to your target in order to build:

Web

./scripts/build-web.sh

Linux

# ./scripts/build-linux.sh          ## For release purposes
./scripts/build-linux-debug.sh

Android

# ./scripts/build-android-apk.sh    ## For release purposes
./scripts/build-android-debug.sh

Performance Profiling

Why Chrome DevTools instead of Flutter DevTools?

Flutter DevTools is designed for native (iOS/Android/Desktop) profiling and provides frame-level insights via the Dart VM. On Flutter Web however, the Dart code is compiled to JavaScript and runs inside a browser engine. Flutter DevTools cannot profile the JavaScript execution, browser rendering pipeline, or web worker scheduling.

Chrome DevTools Performance panel is the right tool for Flutter Web because it captures the actual browser behavior: main thread long tasks, animation frame durations, garbage collection pauses, network timing, and GPU compositing — which is where the real bottlenecks are on web.

The problem with manual analysis

A Chrome DevTools performance trace recorded over a typical user session (navigating conversations, scrolling, viewing members) produces a JSON file exceeding 350,000 lines. The flame chart is virtually unreadable by eye for identifying patterns across hundreds of animation frames and long tasks.

Automated profiling with Chrome DevTools MCP

We use the Chrome DevTools MCP server connected to an AI coding assistant (OpenCode + Claude Code) to automate the entire profiling workflow:

  1. Install the MCP server — add to your OpenCode MCP configuration (~/.config/opencode/opencode.json):

    {
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "chrome-devtools": {
      "type": "local",
      "command": ["npx", "-y", "chrome-devtools-mcp@latest"]
    }
  }
}

  2. Switch to the original branch you want to compare with your changes

  3. Ask Claude Opus 4.6 to perform the profiling — example prompt:

    Run the app on Chrome, in profile mode, connect via the Chrome DevTools MCP, set CPU throttling to 4x (recommended threshold to simulate a low-end device), start a performance trace, navigate through the app (open DM conversations, group rooms, scroll through messages, view member lists), stop the trace, and analyze the results. Compare before/after if applicable (Sync XHR (main thread), Animation frame avg, Jank, Long tasks, JS Heap).

Every now and then, manually scroll through the app using your mouse to make sure that the programmatic scrolling isn't skewing the data.

  1. **Switch to the branch where you

readme truncated — read the full docs on github

Frequently asked questions

Is Twake Chat free to use?

Twake Chat is open source under the AGPL-3.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Twake Chat do?

Secure open source messaging for professional teams

What is Twake Chat written in?

Twake Chat is primarily written in Dart. Its source is publicly available at https://github.com/linagora/twake-on-matrix, and it has 165 GitHub stars.