Cache ThirdParty together with Libraries on macOS

They're actually unused

.cursor/rules/api_usage.mdc

@@ -0,0 +1,105 @@
+---
+description: For tasks requiring sending Telegram server API requests or working with generated API types.
+globs:
+alwaysApply: false
+---
+# Telegram Desktop API Usage
+
+## API Schema
+
+The API definitions are described using [TL Language]\(https:/core.telegram.org/mtproto/TL) in two main schema files:
+
+1.  **`Telegram/SourceFiles/mtproto/scheme/mtproto.tl`**
+    *   Defines the core MTProto protocol types and methods used for basic communication, encryption, authorization, service messages, etc.
+    *   Some fundamental types and methods from this schema (like basic types, RPC calls, containers) are often implemented directly in the C++ MTProto core (`SourceFiles/mtproto/`) and may be skipped during the C++ code generation phase.
+    *   Other parts of `mtproto.tl` might still be processed by the code generator.
+
+2.  **`Telegram/SourceFiles/mtproto/scheme/api.tl`**
+    *   Defines the higher-level Telegram API layer, including all the methods and types related to chat functionality, user profiles, messages, channels, stickers, etc.
+    *   This is the primary schema used when making functional API requests within the application.
+
+Both files use the same TL syntax to describe API methods (functions) and types (constructors).
+
+## Code Generation
+
+A custom code generation tool processes `api.tl` (and parts of `mtproto.tl`) to create corresponding C++ classes and types. These generated headers are typically included via the Precompiled Header (PCH) for the main `Telegram` project.
+
+Generated types often follow the pattern `MTP[Type]` (e.g., `MTPUser`, `MTPMessage`) and methods correspond to functions within the `MTP` namespace or related classes (e.g., `MTPmessages_SendMessage`).
+
+## Making API Requests
+
+API requests are made using a standard pattern involving the `api()` object (providing access to the `MTP::Instance`), the generated `MTP...` request object, callback handlers for success (`.done()`) and failure (`.fail()`), and the `.send()` method.
+
+Here's the general structure:
+
+```cpp
+// Include necessary headers if not already in PCH
+
+// Obtain the API instance (usually via api() or MTP::Instance::Get())
+api().request(MTPnamespace_MethodName(
+    // Constructor arguments based on the api.tl definition for the method
+    MTP_flags(flags_value),      // Use MTP_flags if the method has flags
+    MTP_inputPeer(peer),         // Use MTP_... types for parameters
+    MTP_string(messageText),
+    MTP_long(randomId),
+    // ... other arguments matching the TL definition
+    MTP_vector<MTPMessageEntity>() // Example for a vector argument
+)).done([=]\(const MTPResponseType &result) {
+    // Handle the successful response (result).
+    // 'result' will be of the C++ type corresponding to the TL type
+    // specified after the '=' in the api.tl method definition.
+    // How to access data depends on whether the TL type has one or multiple constructors:
+
+    // 1. Multiple Constructors (e.g., User = User | UserEmpty):
+    //    Use .match() with lambdas for each constructor:
+    result.match([&]\(const MTPDuser &data) {
+        /* use data.vfirst_name().v, etc. */
+    }, [&]\(const MTPDuserEmpty &data) {
+        /* handle empty user */
+    });
+
+    //    Alternatively, check the type explicitly and use the constructor getter:
+    if (result.type() == mtpc_user) {
+        const auto &data = result.c_user(); // Asserts if type is not mtpc_user!
+        // use data.vfirst_name().v
+    } else if (result.type() == mtpc_userEmpty) {
+        const auto &data = result.c_userEmpty();
+        // handle empty user
+    }
+
+    // 2. Single Constructor (e.g., Messages = messages { msgs: vector<Message> }):
+    //    Use .match() with a single lambda:
+    result.match([&]\(const MTPDmessages &data) { /* use data.vmessages().v */ });
+
+    //    Or check the type explicitly and use the constructor getter:
+    if (result.type() == mtpc_messages) {
+        const auto &data = result.c_messages(); // Asserts if type is not mtpc_messages!
+        // use data.vmessages().v
+    }
+
+    //    Or use the shortcut .data() for single-constructor types:
+    const auto &data = result.data(); // Only works for single-constructor types!
+    // use data.vmessages().v
+
+}).fail([=]\(const MTP::Error &error) {
+    // Handle the API error (error).
+    // 'error' is an MTP::Error object containing the error code (error.type())
+    // and description (error.description()). Check for specific error strings.
+    if (error.type() == u"FLOOD_WAIT_X"_q) {
+        // Handle flood wait
+    } else {
+        Ui::show(Box<InformBox>(Lang::Hard::ServerError())); // Example generic error handling
+    }
+}).handleFloodErrors().send(); // handleFloodErrors() is common, then send()
+```
+
+**Key Points:**
+
+*   Always refer to `Telegram/SourceFiles/mtproto/scheme/api.tl` for the correct method names, parameters (names and types), and response types.
+*   Use the generated `MTP...` types/classes for request parameters (e.g., `MTP_int`, `MTP_string`, `MTP_bool`, `MTP_vector`, `MTPInputUser`, etc.) and response handling.
+*   The `.done()` lambda receives the specific C++ `MTP...` type corresponding to the TL return type.
+    *   For types with **multiple constructors** (e.g., `User = User | UserEmpty`), use `result.match([&]\(const MTPDuser &d){ ... }, [&]\(const MTPDuserEmpty &d){ ... })` to handle each case, or check `result.type() == mtpc_user` / `mtpc_userEmpty` and call the specific `result.c_user()` / `result.c_userEmpty()` getter (which asserts on type mismatch).
+    *   For types with a **single constructor** (e.g., `Messages = messages{...}`), you can use `result.match([&]\(const MTPDmessages &d){ ... })` with one lambda, or check `type()` and call `c_messages()`, or use the shortcut `result.data()` to access the fields directly.
+*   The `.fail()` lambda receives an `MTP::Error` object. Check `error.type()` against known error strings (often defined as constants or using `u"..."_q` literals).
+*   Directly construct the `MTPnamespace_MethodName(...)` object inside `request()`.
+*   Include `.handleFloodErrors()` before `.send()` for standard flood wait handling.

.cursor/rules/localization.mdc

@@ -0,0 +1,164 @@
+---
+description: For tasks requiring changing or adding user facing phrases and text parts.
+globs:
+alwaysApply: false
+---
+# Telegram Desktop Localization
+
+## Coding Style Note
+
+**Use `auto`:** In the actual codebase, variable types are almost always deduced using `auto` (or `const auto`, `const auto &`) rather than being written out explicitly. Examples in this guide may use explicit types for clarity, but prefer `auto` in practice.
+
+```cpp
+// Prefer this:
+auto currentTitle = tr::lng_settings_title(tr::now);
+auto nameProducer = GetNameProducer(); // Returns rpl::producer<...>
+
+// Instead of this:
+QString currentTitle = tr::lng_settings_title(tr::now);
+rpl::producer<QString> nameProducer = GetNameProducer();
+```
+
+## String Resource File
+
+Base user-facing English strings are defined in the `lang.strings` file:
+
+`Telegram/Resources/langs/lang.strings`
+
+This file uses a key-value format with named placeholders:
+
+```
+"lng_settings_title" = "Settings";
+"lng_confirm_delete_item" = "Are you sure you want to delete {item_name}?";
+"lng_files_selected" = "{count} files selected"; // Simple count example (see Pluralization)
+```
+
+Placeholders are enclosed in curly braces, e.g., `{name}`, `{user}`. A special placeholder `{count}` is used for pluralization rules.
+
+### Pluralization
+
+For keys that depend on a number (using the `{count}` placeholder), English typically requires two forms: singular and plural. These are defined in `lang.strings` using `#one` and `#other` suffixes:
+
+```
+"lng_files_selected#one" = "{count} file selected";
+"lng_files_selected#other" = "{count} files selected";
+```
+
+While only `#one` and `#other` are defined in the base `lang.strings`, the code generation process creates C++ accessors for all six CLDR plural categories (`#zero`, `#one`, `#two`, `#few`, `#many`, `#other`) to support languages with more complex pluralization rules.
+
+## Translation Process
+
+While `lang.strings` provides the base English text and the keys, the actual translations are managed via Telegram's translations platform (translations.telegram.org) and loaded dynamically at runtime from the API. The keys from `lang.strings` (including the `#one`/`#other` variants) are used on the platform.
+
+## Code Generation
+
+A code generation tool processes `lang.strings` to create C++ structures and accessors within the `tr` namespace. These allow type-safe access to strings and handling of placeholders and pluralization. Generated keys typically follow the pattern `tr::lng_key_name`.
+
+## String Usage in Code
+
+Strings are accessed in C++ code using the generated objects within the `tr::` namespace. There are two main ways to use them: reactively (returning an `rpl::producer`) or immediately (returning the current value).
+
+### 1. Reactive Usage (rpl::producer)
+
+Calling a generated string function directly returns a reactive producer, typically `rpl::producer<QString>`. This producer automatically updates its value whenever the application language changes.
+
+```cpp
+// Key: "settings_title" = "Settings";
+auto titleProducer = tr::lng_settings_title(); // Type: rpl::producer<QString>
+
+// Key: "confirm_delete_item" = "Are you sure you want to delete {item_name}?";
+auto itemNameProducer = /* ... */; // Type: rpl::producer<QString>
+auto confirmationProducer = tr::lng_confirm_delete_item( // Type: rpl::producer<QString>
+    tr::now, // NOTE: tr::now is NOT passed here for reactive result
+    lt_item_name,
+    std::move(itemNameProducer)); // Placeholder producers should be moved
+```
+
+### 2. Immediate Usage (Current Value)
+
+Passing `tr::now` as the first argument retrieves the string's current value in the active language (typically as a `QString`).
+
+```cpp
+// Key: "settings_title" = "Settings";
+auto currentTitle = tr::lng_settings_title(tr::now); // Type: QString
+
+// Key: "confirm_delete_item" = "Are you sure you want to delete {item_name}?";
+const auto currentItemName = QString("My Document"); // Type: QString
+auto currentConfirmation = tr::lng_confirm_delete_item( // Type: QString
+    tr::now, // Pass tr::now for immediate value
+    lt_item_name, currentItemName); // Placeholder value is a direct QString (or convertible)
+```
+
+### 3. Placeholders (`{tag}`)
+
+Placeholders like `{item_name}` are replaced by providing arguments after `tr::now` (for immediate) or as the initial arguments (for reactive). A corresponding `lt_tag_name` constant is passed before the value.
+
+*   **Immediate:** Pass the direct value (e.g., `QString`, `int`).
+*   **Reactive:** Pass an `rpl::producer` of the corresponding type (e.g., `rpl::producer<QString>`). Remember to `std::move` the producer or use `rpl::duplicate` if you need to reuse the original producer afterwards.
+
+### 4. Pluralization (`{count}`)
+
+Keys using `{count}` require a numeric value for the `lt_count` placeholder. The correct plural form (`#zero`, `#one`, ..., `#other`) is automatically selected based on this value and the current language rules.
+
+*   **Immediate (`tr::now`):** Pass a `float64` or `int` (which is auto-converted to `float64`).
+    ```cpp
+    int count = 1;
+    auto filesText = tr::lng_files_selected(tr::now, lt_count, count); // Type: QString
+    count = 5;
+    filesText = tr::lng_files_selected(tr::now, lt_count, count); // Uses "files_selected#other"
+    ```
+
+*   **Reactive:** Pass an `rpl::producer<float64>`. Use the `tr::to_count()` helper to convert an `rpl::producer<int>` or wrap a single value.
+    ```cpp
+    // From an existing int producer:
+    auto countProducer = /* ... */; // Type: rpl::producer<int>
+    auto filesTextProducer = tr::lng_files_selected( // Type: rpl::producer<QString>
+        lt_count,
+        countProducer | tr::to_count()); // Use tr::to_count() for conversion
+
+    // From a single int value wrapped reactively:
+    int currentCount = 5;
+    auto filesTextProducerSingle = tr::lng_files_selected( // Type: rpl::producer<QString>
+        lt_count,
+        rpl::single(currentCount) | tr::to_count());
+        // Alternative for single values (less common): rpl::single(currentCount * 1.)
+    ```
+
+### 5. Custom Projectors
+
+An optional final argument can be a projector function (like `Ui::Text::Upper` or `Ui::Text::WithEntities`) to transform the output.
+
+*   If the projector returns `OutputType`, the string function returns `OutputType` (immediate) or `rpl::producer<OutputType>` (reactive).
+*   Placeholder values must match the projector's *input* requirements. For `Ui::Text::WithEntities`, placeholders expect `TextWithEntities` (immediate) or `rpl::producer<TextWithEntities>` (reactive).
+
+```cpp
+// Immediate with Ui::Text::WithEntities projector
+// Key: "user_posted_photo" = "{user} posted a photo";
+const auto userName = TextWithEntities{ /* ... */ }; // Type: TextWithEntities
+auto message = tr::lng_user_posted_photo( // Type: TextWithEntities
+    tr::now,
+    lt_user,
+    userName, // Must be TextWithEntities
+    Ui::Text::WithEntities); // Projector
+
+// Reactive with Ui::Text::WithEntities projector
+auto userNameProducer = /* ... */; // Type: rpl::producer<TextWithEntities>
+auto messageProducer = tr::lng_user_posted_photo( // Type: rpl::producer<TextWithEntities>
+    lt_user,
+    std::move(userNameProducer), // Move placeholder producers
+    Ui::Text::WithEntities); // Projector
+```
+
+## Key Summary
+
+*   Keys are defined in `Resources/langs/lang.strings` using `{tag}` placeholders.
+*   Plural keys use `{count}` and have `#one`/`#other` variants in `lang.strings`.
+*   Access keys via `tr::lng_key_name(...)` in C++.
+*   Call with `tr::now` as the first argument for the immediate `QString` (or projected type).
+*   Call without `tr::now` for the reactive `rpl::producer<QString>` (or projected type).
+*   Provide placeholder values (`lt_tag_name, value`) matching the usage (direct value for immediate, `rpl::producer` for reactive). Producers should typically be moved via `std::move`.
+*   For `{count}`:
+    *   Immediate: Pass `int` or `float64`.
+    *   Reactive: Pass `rpl::producer<float64>`, typically by converting an `int` producer using `| tr::to_count()`.
+*   Optional projector function as the last argument modifies the output type and required placeholder types.
+*   Actual translations are loaded at runtime from the API.

.cursor/rules/rpl_guide.mdc

@@ -0,0 +1,216 @@
+---
+description:
+globs:
+alwaysApply: true
+---
+# RPL (Reactive Programming Library) Guide
+
+## Coding Style Note
+
+**Use `auto`:** In the actual codebase, variable types are almost always deduced using `auto` (or `const auto`, `const auto &`) rather than being written out explicitly. Examples in this guide may use explicit types for clarity, but prefer `auto` in practice.
+
+```cpp
+// Prefer this:
+auto intProducer = rpl::single(123);
+const auto &lifetime = existingLifetime;
+
+// Instead of this:
+rpl::producer<int> intProducer = rpl::single(123);
+const rpl::lifetime &lifetime = existingLifetime;
+
+// Sometimes needed if deduction is ambiguous or needs help:
+auto user = std::make_shared<UserData>();
+auto data = QByteArray::fromHex("...");
+```
+
+## Introduction
+
+RPL is the reactive programming library used in this project, residing in the `rpl::` namespace. It allows handling asynchronous streams of data over time.
+
+The core concept is the `rpl::producer`, which represents a stream of values that can be generated over a certain lifetime.
+
+## Producers: `rpl::producer<Type, Error = no_error>`
+
+The fundamental building block is `rpl::producer<Type, Error>`. It produces values of `Type` and can optionally signal an error of type `Error`. By default, `Error` is `rpl::no_error`, indicating that the producer does not explicitly handle error signaling through this mechanism.
+
+```cpp
+// A producer that emits integers.
+auto intProducer = /* ... */; // Type: rpl::producer<int>
+
+// A producer that emits strings and can potentially emit a CustomError.
+auto stringProducerWithError = /* ... */; // Type: rpl::producer<QString, CustomError>
+```
+
+Producers are typically lazy; they don't start emitting values until someone subscribes to them.
+
+## Lifetime Management: `rpl::lifetime`
+
+Reactive pipelines have a limited duration, managed by `rpl::lifetime`. An `rpl::lifetime` object essentially holds a collection of cleanup callbacks. When the lifetime ends (either explicitly destroyed or goes out of scope), these callbacks are executed, tearing down the associated pipeline and freeing resources.
+
+```cpp
+rpl::lifetime myLifetime;
+// ... later ...
+// myLifetime is destroyed, cleanup happens.
+
+// Or, pass a lifetime instance to manage a pipeline's duration.
+rpl::lifetime &parentLifetime = /* ... get lifetime from context ... */;
+```
+
+## Starting a Pipeline: `rpl::start_...`
+
+To consume values from a producer, you start a pipeline using one of the `rpl::start_...` methods. These methods subscribe to the producer and execute callbacks for the events they handle.
+
+The most common method is `rpl::on_next`:
+
+```cpp
+auto counter = /* ... */; // Type: rpl::producer<int>
+rpl::lifetime lifetime;
+
+// Counter is consumed here, use std::move if it's an l-value.
+std::move(
+    counter
+) | rpl::on_next([=]\(int nextValue) {
+    // Process the next integer value emitted by the producer.
+    qDebug() << "Received: " << nextValue;
+}, lifetime); // Pass the lifetime to manage the subscription.
+// Note: `counter` is now in a moved-from state and likely invalid.
+
+// If you need to start the same producer multiple times, duplicate it:
+// rpl::duplicate(counter) | rpl::on_next(...);
+
+// If you DON'T pass a lifetime to a start_... method:
+auto counter2 = /* ... */; // Type: rpl::producer<int>
+rpl::lifetime subscriptionLifetime = std::move(
+    counter2
+) | rpl::on_next([=]\(int nextValue) { /* ... */ });
+// The returned lifetime MUST be stored. If it's discarded immediately,
+// the subscription stops instantly.
+// `counter2` is also moved-from here.
+```
+
+Other variants allow handling errors (`_error`) and completion (`_done`):
+
+```cpp
+auto dataStream = /* ... */; // Type: rpl::producer<QString, Error>
+rpl::lifetime lifetime;
+
+// Assuming dataStream might be used again, we duplicate it for the first start.
+// If it's the only use, std::move(dataStream) would be preferred.
+rpl::duplicate(
+    dataStream
+) | rpl::on_error([=]\(Error &&error) {
+    // Handle the error signaled by the producer.
+    qDebug() << "Error: " << error.text();
+}, lifetime);
+
+// Using dataStream again, perhaps duplicated again or moved if last use.
+rpl::duplicate(
+    dataStream
+) | rpl::on_done([=] {
+    // Execute when the producer signals it's finished emitting values.
+    qDebug() << "Stream finished.";
+}, lifetime);
+
+// Last use of dataStream, so we move it.
+std::move(
+    dataStream
+) | rpl::on_next_error_done(
+    [=]\(QString &&value) { /* handle next value */ },
+    [=]\(Error &&error) { /* handle error */ },
+    [=] { /* handle done */ },
+    lifetime);
+```
+
+## Transforming Producers
+
+RPL provides functions to create new producers by transforming existing ones:
+
+*   `rpl::map`: Transforms each value emitted by a producer.
+    ```cpp
+    auto ints = /* ... */; // Type: rpl::producer<int>
+    // The pipe operator often handles the move implicitly for chained transformations.
+    auto strings = std::move(
+        ints // Explicit move is safer
+    ) | rpl::map([](int value) {
+        return QString::number(value * 2);
+    }); // Emits strings like "0", "2", "4", ...
+    ```
+
+*   `rpl::filter`: Emits only the values from a producer that satisfy a condition.
+    ```cpp
+    auto ints = /* ... */; // Type: rpl::producer<int>
+    auto evenInts = std::move(
+        ints // Explicit move is safer
+    ) | rpl::filter([](int value) {
+        return (value % 2 == 0);
+    }); // Emits only even numbers.
+    ```
+
+## Combining Producers
+
+You can combine multiple producers into one:
+
+*   `rpl::combine`: Combines the latest values from multiple producers whenever *any* of them emits a new value. Requires all producers to have emitted at least one value initially.
+    While it produces a `std::tuple`, subsequent operators like `map`, `filter`, and `start_with_next` can automatically unpack this tuple into separate lambda arguments.
+    ```cpp
+    auto countProducer = rpl::single(1); // Type: rpl::producer<int>
+    auto textProducer = rpl::single(u"hello"_q); // Type: rpl::producer<QString>
+    rpl::lifetime lifetime;
+
+    // rpl::combine takes producers by const-ref internally and duplicates,
+    // so move/duplicate is usually not strictly needed here unless you
+    // want to signal intent or manage the lifetime of p1/p2 explicitly.
+    auto combined = rpl::combine(
+        countProducer, // or rpl::duplicate(countProducer)
+        textProducer   // or rpl::duplicate(textProducer)
+    );
+
+    // Starting the combined producer consumes it.
+    // The lambda receives unpacked arguments, not the tuple itself.
+    std::move(
+        combined
+    ) | rpl::on_next([=]\(int count, const QString &text) {
+        // No need for std::get<0>(latest), etc.
+        qDebug() << "Combined: Count=" << count << ", Text=" << text;
+    }, lifetime);
+
+    // This also works with map, filter, etc.
+    std::move(
+        combined
+    ) | rpl::filter([=]\(int count, const QString &text) {
+        return count > 0 && !text.isEmpty();
+    }) | rpl::map([=]\(int count, const QString &text) {
+        return text.repeated(count);
+    }) | rpl::on_next([=]\(const QString &result) {
+        qDebug() << "Mapped & Filtered: " << result;
+    }, lifetime);
+    ```
+
+*   `rpl::merge`: Merges the output of multiple producers of the *same type* into a single producer. It emits a value whenever *any* of the source producers emits a value.
+    ```cpp
+    auto sourceA = /* ... */; // Type: rpl::producer<QString>
+    auto sourceB = /* ... */; // Type: rpl::producer<QString>
+
+    // rpl::merge also duplicates internally.
+    auto merged = rpl::merge(sourceA, sourceB);
+
+    // Starting the merged producer consumes it.
+    std::move(
+        merged
+    ) | rpl::on_next([=]\(QString &&value) {
+        // Receives values from either sourceA or sourceB as they arrive.
+        qDebug() << "Merged value: " << value;
+    }, lifetime);
+    ```
+
+## Key Concepts Summary
+
+*   Use `rpl::producer<Type, Error>` to represent streams of values.
+*   Manage subscription duration using `rpl::lifetime`.
+*   Pass `rpl::lifetime` to `rpl::start_...` methods.
+*   If `rpl::lifetime` is not passed, **store the returned lifetime** to keep the subscription active.
+*   Use operators like `| rpl::map`, `| rpl::filter` to transform streams.
+*   Use `rpl::combine` or `rpl::merge` to combine streams.
+*   When starting a chain (`std::move(producer) | rpl::map(...)`), explicitly move the initial producer.
+*   These functions typically duplicate their input producers internally.
+*   Starting a pipeline consumes the producer; use `

.cursor/rules/styling.mdc

@@ -0,0 +1,154 @@
+---
+description: For tasks requiring working with user facing UI components.
+globs:
+alwaysApply: false
+---
+# Telegram Desktop UI Styling
+
+## Style Definition Files
+
+UI element styles (colors, fonts, paddings, margins, icons, etc.) are defined in `.style` files using a custom syntax. These files are located alongside the C++ source files they correspond to within specific UI component directories (e.g., `Telegram/SourceFiles/ui/chat/chat.style`).
+
+Definitions from other `.style` files can be included using the `using` directive at the top of the file:
+```style
+using "ui/basic.style";
+using "ui/widgets/widgets.style";
+```
+
+The central definition of named colors happens in `Telegram/SourceFiles/ui/colors.palette`. This file allows for theme generation and loading colors from various sources.
+
+### Syntax Overview
+
+1.  **Built-in Types:** The syntax recognizes several base types inferred from the value assigned:
+    *   `int`: Integer numbers (e.g., `lineHeight: 20;`)
+    *   `bool`: Boolean values (e.g., `useShadow: true;`)
+    *   `pixels`: Pixel values, ending with `px` (e.g., `borderWidth: 1px;`). Generated as `int` in C++.
+    *   `color`: Named colors defined in `colors.palette` (e.g., `background: windowBg;`)
+    *   `icon`: Defined inline using a specific syntax (see below). Generates `style::icon`.
+    *   `margins`: Four pixel values for margins or padding. Requires `margins(top, right, bottom, left)` syntax (e.g., `margin: margins(10px, 5px, 10px, 5px);` or `padding: margins(8px, 8px, 8px, 8px);`). Generates `style::margins` (an alias for `QMargins`).
+    *   `size`: Two pixel values for width and height (e.g., `iconSize: size(16px, 16px);`). Generates `style::size`.
+    *   `point`: Two pixel values for x and y coordinates (e.g., `textPos: point(5px, 2px);`). Generates `style::point`.
+    *   `align`: Alignment keywords (e.g., `textAlign: align(center);` or `iconAlign: align(left);`). Generates `style::align`.
+    *   `font`: Font definitions (e.g., `font: font(14px semibold);`). Generates `style::font`.
+    *   `double`: Floating point numbers (e.g., `disabledOpacity: 0.5;`)
+
+    *Note on Borders:* Borders are typically defined using multiple fields like `border: pixels;` (for width) and `borderFg: color;` (for color), rather than a single CSS-like property.
+
+2.  **Structure Definition:** You can define complex data structures directly within the `.style` file:
+    ```style
+    MyButtonStyle { // Defines a structure named 'MyButtonStyle'
+      textPadding: margins; // Field 'textPadding' expects margins type
+      icon: icon;         // Field 'icon' of type icon
+      height: pixels;     // Field 'height' of type pixels
+    }
+    ```
+    This generates a `struct MyButtonStyle { ... };` inside the `namespace style`. Fields will have corresponding C++ types (`style::margins`, `style::icon`, `int`).
+
+3.  **Variable Definition & Inheritance:** Variables are defined using `name: value;` or `groupName { ... }`. They can be of built-in types or custom structures. Structures can be initialized inline or inherit from existing variables.
+
+    **Icon Definition Syntax:** Icons are defined inline using the `icon{...}` syntax. The generator probes for `.svg` files or `.png` files (including `@2x`, `@3x` variants) based on the provided path stem.
+    ```style
+    // Single-part icon definition:
+    myIconSearch: icon{{ "gui/icons/search", iconColor }};
+    // Multi-part icon definition (layers drawn bottom-up):
+    myComplexIcon: icon{
+      { "gui/icons/background", iconBgColor },
+      { "gui/icons/foreground", iconFgColor }
+    };
+    // Icon with path modifiers (PNG only for flips, SVG only for size):
+    myFlippedIcon: icon{{ "gui/icons/arrow-flip_horizontal", arrowColor }};
+    myResizedIcon: icon{{ "gui/icons/logo-128x128", logoColor }}; // Forces 128x128 for SVG
+    ```
+
+    **Other Variable Examples:**
+    ```style
+    // Simple variables
+    buttonHeight: 30px;
+    activeButtonColor: buttonBgActive; // Named color from colors.palette
+
+    // Variable of a custom structure type, initialized inline
+    defaultButton: MyButtonStyle {
+      textPadding: margins(10px, 15px, 10px, 15px); // Use margins(...) syntax
+      icon: myIconSearch; // Assign the previously defined icon variable
+      height: buttonHeight; // Reference another variable
+    }
+
+    // Another variable inheriting from 'defaultButton' and overriding/adding fields
+    primaryButton: MyButtonStyle(defaultButton) {
+      icon: myComplexIcon; // Override icon with the multi-part one
+      backgroundColor: activeButtonColor; // Add a field not in MyButtonStyle definition
+    }
+
+    // Style group (often used for specific UI elements)
+    chatInput { // Example using separate border properties and explicit padding
+      border: 1px;                          // Border width
+      borderFg: defaultInputFieldBorder;    // Border color (named color)
+      padding: margins(5px, 10px, 5px, 10px); // Use margins(...) syntax for padding field
+      backgroundColor: defaultChatBg;       // Background color
+    }
+    ```
+
+## Code Generation
+
+A code generation tool processes these `.style` files and `colors.palette` to create C++ objects.
+- The `using` directives resolve dependencies between `.style` files.
+- Custom structure definitions (like `MyButtonStyle`) generate corresponding `struct MyButtonStyle { ... };` within the `namespace style`.
+- Style variables/groups (like `defaultButton`, `primaryButton`, `chatInput`) are generated as objects/structs within the `st` namespace (e.g., `st::defaultButton`, `st::primaryButton`, `st::chatInput`). These generated structs contain members corresponding to the fields defined in the `.style` file.
+- Color objects are generated into the `st` namespace as well, based on their names in `colors.palette` (e.g., `st::windowBg`, `st::buttonBgActive`).
+- The generated header files for styles are placed in the `Telegram/SourceFiles/styles/` directory with a `style_` prefix (e.g., `styles/style_widgets.h` for `ui/widgets/widgets.style`). You include them like `#include "styles/style_widgets.h"`.
+
+Generated C++ types correspond to the `.style` types: `style::color`, `style::font`, `style::margins` (used for both `margin:` and `padding:` fields), `style::icon`, `style::size`, `style::point`, `style::align`, and `int` or `bool` for simple types.
+
+## Style Usage in Code
+
+Styles are applied in C++ code by referencing the generated `st::...` objects and their members.
+
+```cpp
+// Example: Including the generated style header
+#include "styles/style_widgets.h" // For styles defined in ui/widgets/widgets.style
+
+// ... inside some UI class code ...
+
+// Accessing members of a generated style struct
+int height = st::primaryButton.height; // Accessing the 'height' field (pixels -> int)
+const style::icon &icon = st::primaryButton.icon; // Accessing the 'icon' field (st::myComplexIcon)
+style::margins padding = st::primaryButton.textPadding; // Accessing 'textPadding'
+style::color bgColor = st::primaryButton.backgroundColor; // Accessing the color (st::activeButtonColor)
+
+// Applying styles (conceptual examples)
+myButton->setIcon(st::primaryButton.icon);
+myButton->setHeight(st::primaryButton.height);
+myButton->setPadding(st::primaryButton.textPadding);
+myButton->setBackgroundColor(st::primaryButton.backgroundColor);
+
+// Using styles directly in painting
+void MyWidget::paintEvent(QPaintEvent *e) {
+    Painter p(this);
+    p.fillRect(rect(), st::chatInput.backgroundColor); // Use color from chatInput style
+
+    // Border painting requires width and color
+    int borderWidth = st::chatInput.border; // Access border width (pixels -> int)
+    style::color borderColor = st::chatInput.borderFg; // Access border color
+    if (borderWidth > 0) {
+        p.setPen(QPen(borderColor, borderWidth));
+        // Adjust rect for pen width if needed before drawing
+        p.drawRect(rect().adjusted(borderWidth / 2, borderWidth / 2, -borderWidth / 2, -borderWidth / 2));
+    }
+
+    // Access padding (style::margins)
+    style::margins inputPadding = st::chatInput.padding;
+    // ... use inputPadding.top(), inputPadding.left() etc. for content layout ...
+}
+```
+
+**Key Points:**
+
+*   Styles are defined in `.style` files next to their corresponding C++ source files.
+*   `using "path/to/other.style";` includes definitions from other style files.
+*   Named colors are defined centrally in `ui/colors.palette`.
+*   `.style` syntax supports built-in types (like `pixels`, `color`, `margins`, `point`, `size`, `align`, `font`, `double`), custom structure definitions (`Name { field: type; ... }`), variable definitions (`name: value;`), and inheritance (`child: Name(parent) { ... }`).
+*   Values must match the expected type (e.g., fields declared as `margins` type, like `margin:` or `padding:`, require `margins(...)` syntax). Borders are typically set via separate `border: pixels;` and `borderFg: color;` fields.
+*   Icons are defined inline using `name: icon{{ "path_stem", color }};` or `name: icon{ { "path1", c1 }, ... };` syntax, with optional path modifiers.
+*   Code generation creates `struct` definitions in the `style` namespace for custom types and objects/structs in the `st` namespace for defined variables/groups.
+*   Generated headers are in `styles/` with a `style_` prefix and must be included.
+*   Access style properties via the generated `st::` objects (e.g., `st::primaryButton.height`, `st::chatInput.backgroundColor`).

.cursorignore

@@ -0,0 +1,2 @@
+# Add directories or file patterns to ignore during indexing (e.g. foo/ or *.csv)
+Telegram/ThirdParty/

.devcontainer.json

@@ -0,0 +1,30 @@
+{
+    "name": "CentOS",
+    "image": "tdesktop:centos_env",
+    "customizations": {
+        "vscode": {
+            "settings": {
+                "C_Cpp.intelliSenseEngine": "disabled",
+                "cmake.generator": "Ninja Multi-Config",
+                "cmake.buildDirectory": "${workspaceFolder}/out",
+                "cmake.copyCompileCommands": "${workspaceFolder}/compile_commands.json"
+            },
+            "extensions": [
+                "ms-vscode.cpptools-extension-pack",
+                "llvm-vs-code-extensions.vscode-clangd",
+                "TheQtCompany.qt",
+                "ms-python.python",
+                "ms-azuretools.vscode-docker",
+                "eamodio.gitlens"
+            ]
+        }
+    },
+    "capAdd": [
+        "SYS_PTRACE"
+    ],
+    "securityOpt": [
+        "seccomp=unconfined"
+    ],
+    "workspaceMount": "source=${localWorkspaceFolder},target=/usr/src/tdesktop,type=bind,consistency=cached",
+    "workspaceFolder": "/usr/src/tdesktop"
+}

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/cant-reproduce.yml

@@ -0,0 +1,25 @@
+name: Can't reproduce.
+
+on:
+  schedule:
+    - cron: '0 3 * * *'
+
+jobs:
+  cant-reproduce:
+    runs-on: ubuntu-slim
+    steps:
+      - uses: lee-dohm/no-response@v0.5.0
+        with:
+          token: ${{ github.token }}
+          responseRequiredLabel: cant reproduce
+          closeComment: >
+            This issue has been automatically closed because no developer succeeded to
+            reproduce the issue with the given reproduction steps. With only the
+            information that is currently in the issue, we don't have enough
+            information to take action. Please reach out if you find what's missing to
+            reproduce the issue so that we can investigate further.
+
+
+            Note that GitHub is a developer communication platform. If you're an ordinary
+            user seeking for help, get to support crew via `Settings -> Ask question` in
+            the application.

.github/workflows/copyright_year_updater.yml

@@ -9,7 +9,7 @@ on:
 
 jobs:
   Copyright-year:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-slim
     steps:
       - uses: desktop-app/action_code_updater@master
         with:

.github/workflows/docker.yml

@@ -5,22 +5,19 @@ on:
     paths:
       - '.github/workflows/docker.yml'
       - 'Telegram/build/docker/centos_env/**'
-  pull_request:
-    paths:
-      - '.github/workflows/docker.yml'
-      - 'Telegram/build/docker/centos_env/**'
 
 jobs:
   docker:
     name: Ubuntu
     runs-on: ubuntu-latest
+    if: github.ref_name == github.event.repository.default_branch
 
     env:
       IMAGE_TAG: ghcr.io/${{ github.repository }}/centos_env:latest
 
     steps:
       - name: Clone.
-        uses: actions/checkout@v3.1.0
+        uses: actions/checkout@v6
         with:
           submodules: recursive
 
@@ -28,9 +25,12 @@ jobs:
         run: |
           sudo apt update
           curl -sSL https://install.python-poetry.org | python3 -
+          echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u $ --password-stdin
 
       - name: Free up some disk space.
-        uses: jlumbroso/free-disk-space@f68fdb76e2ea636224182cfb7377ff9a1708f9b8
+        uses: jlumbroso/free-disk-space@54081f138730dfa15788a46383842cd2f914a1be
+        with:
+          tool-cache: true
 
       - name: Docker image build.
         run: |
@@ -39,7 +39,4 @@ jobs:
           DEBUG= LTO= poetry run gen_dockerfile | DOCKER_BUILDKIT=1 docker build -t $IMAGE_TAG -
 
       - name: Push the Docker image.
-        if: ${{ github.ref_name == github.event.repository.default_branch }}
-        run: |
-          echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u $ --password-stdin
-          docker push $IMAGE_TAG
+        run: docker push $IMAGE_TAG

.github/workflows/issue_closer.yml

@@ -6,7 +6,7 @@ on:
 
 jobs:
   comment:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-slim
     steps:
       - name: Process an issue.
         uses: desktop-app/action_issue_closer@master

.github/workflows/linux.yml

@@ -12,6 +12,7 @@ on:
       - '!.github/workflows/linux.yml'
       - 'snap/**'
       - 'Telegram/build/**'
+      - '!Telegram/build/docker/centos_env/**'
       - 'Telegram/Resources/uwp/**'
       - 'Telegram/Resources/winrc/**'
       - 'Telegram/SourceFiles/platform/win/**'
@@ -30,6 +31,7 @@ on:
       - '!.github/workflows/linux.yml'
       - 'snap/**'
       - 'Telegram/build/**'
+      - '!Telegram/build/docker/centos_env/**'
       - 'Telegram/Resources/uwp/**'
       - 'Telegram/Resources/winrc/**'
       - 'Telegram/SourceFiles/platform/win/**'
@@ -43,69 +45,94 @@ jobs:
   linux:
     name: Rocky Linux 8
     runs-on: ubuntu-latest
-    container:
-      image: ghcr.io/${{ github.repository }}/centos_env
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.GITHUB_TOKEN }}
-
-    defaults:
-      run:
-        shell: scl enable gcc-toolset-12 -- bash --noprofile --norc -eo pipefail {0}
 
     strategy:
       matrix:
         defines:
           - ""
           - "DESKTOP_APP_DISABLE_X11_INTEGRATION"
-          - "DESKTOP_APP_DISABLE_WAYLAND_INTEGRATION"
 
     env:
-      UPLOAD_ARTIFACT: "false"
+      UPLOAD_ARTIFACT: "true"
+      ONLY_CACHE: "false"
+      IMAGE_TAG: tdesktop:centos_env
 
     steps:
-      - name: Get repository name.
-        run: echo "REPO_NAME=${GITHUB_REPOSITORY##*/}" >> $GITHUB_ENV
-
       - name: Clone.
-        uses: actions/checkout@v3.1.0
+        uses: actions/checkout@v6
         with:
           submodules: recursive
-          path: ${{ env.REPO_NAME }}
 
       - name: First set up.
         run: |
-          gcc --version
-          ln -s /usr/src/Libraries
+          sudo apt update
+          curl -sSL https://install.python-poetry.org | python3 -
+          cd Telegram/build/docker/centos_env
+          poetry install
+          DOCKERFILE=$(DEBUG= LTO= poetry run gen_dockerfile)
+          echo "$DOCKERFILE" > Dockerfile
+          rm -rf __pycache__
+
+      - name: Free up some disk space.
+        uses: jlumbroso/free-disk-space@54081f138730dfa15788a46383842cd2f914a1be
+        with:
+          tool-cache: true
+
+      - name: Set up Docker Buildx.
+        uses: docker/setup-buildx-action@v3
+
+      - name: Libraries cache.
+        uses: actions/cache@v5
+        with:
+          path: ${{ runner.temp }}/.buildx-cache
+          key: ${{ runner.OS }}-libs-${{ hashFiles('Telegram/build/docker/centos_env/**') }}
+          restore-keys: ${{ runner.OS }}-libs-
+
+      - name: Libraries.
+        uses: docker/build-push-action@v6
+        with:
+          context: Telegram/build/docker/centos_env
+          load: ${{ env.ONLY_CACHE == 'false' }}
+          tags: ${{ env.IMAGE_TAG }}
+          cache-from: type=local,src=${{ runner.temp }}/.buildx-cache
+          cache-to: type=local,dest=${{ runner.temp }}/.buildx-cache-new,mode=max
+
+      - name: Move cache.
+        run: |
+          rm -rf ${{ runner.temp }}/.buildx-cache
+          mv ${{ runner.temp }}/.buildx-cache{-new,}
 
       - name: Telegram Desktop build.
+        if: env.ONLY_CACHE == 'false'
         run: |
-          cd $REPO_NAME/Telegram
-
           DEFINE=""
           if [ -n "${{ matrix.defines }}" ]; then
             DEFINE="-D ${{ matrix.defines }}=ON"
             echo Define from matrix: $DEFINE
-            echo "ARTIFACT_NAME=Telegram_${{ matrix.defines }}" >> $GITHUB_ENV
+            echo "ARTIFACT_NAME=Telegram ${{ matrix.defines }}" >> $GITHUB_ENV
           else
             echo "ARTIFACT_NAME=Telegram" >> $GITHUB_ENV
           fi
 
-          ./configure.sh \
-          -D CMAKE_C_FLAGS_DEBUG="" \
-          -D CMAKE_CXX_FLAGS_DEBUG="" \
-          -D CMAKE_C_FLAGS="-Werror" \
-          -D CMAKE_CXX_FLAGS="-Werror" \
-          -D CMAKE_EXE_LINKER_FLAGS="-s" \
+          docker run --rm \
+          -u $(id -u) \
+          -v $PWD:/usr/src/tdesktop \
+          -e CONFIG=Debug \
+          $IMAGE_TAG \
+          /usr/src/tdesktop/Telegram/build/docker/centos_env/build.sh \
+          -D CMAKE_CONFIGURATION_TYPES=Debug \
+          -D CMAKE_C_FLAGS_DEBUG="-O0" \
+          -D CMAKE_CXX_FLAGS_DEBUG="-O0" \
+          -D CMAKE_COMPILE_WARNING_AS_ERROR=ON \
           -D TDESKTOP_API_TEST=ON \
+          -D DESKTOP_APP_DISABLE_AUTOUPDATE=OFF \
           -D DESKTOP_APP_DISABLE_CRASH_REPORTS=OFF \
           $DEFINE
 
-          cmake --build ../out --config Debug --parallel
-
       - name: Check.
+        if: env.ONLY_CACHE == 'false'
         run: |
-          filePath="$REPO_NAME/out/Debug/Telegram"
+          filePath="out/Debug/Telegram"
           if test -f "$filePath"; then
             echo "Build successfully done! :)"
 
@@ -119,12 +146,12 @@ jobs:
       - name: Move artifact.
         if: env.UPLOAD_ARTIFACT == 'true'
         run: |
-          cd $REPO_NAME/out/Debug
+          cd out/Debug
           mkdir artifact
-          mv Telegram artifact/
-      - uses: actions/upload-artifact@master
+          mv {Telegram,Updater} artifact/
+      - uses: actions/upload-artifact@v6
         if: env.UPLOAD_ARTIFACT == 'true'
         name: Upload artifact.
         with:
           name: ${{ env.ARTIFACT_NAME }}
-          path: ${{ env.REPO_NAME }}/out/Debug/artifact/
+          path: out/Debug/artifact/

.github/workflows/lock.yml

@@ -6,9 +6,9 @@ on:
 
 jobs:
   lock:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-slim
     steps:
-      - uses: dessant/lock-threads@v3
+      - uses: dessant/lock-threads@v6
         with:
           github-token: ${{ github.token }}
           issue-inactive-days: 45

.github/workflows/mac.yml

@@ -40,14 +40,14 @@ jobs:
 
   macos:
     name: MacOS
-    runs-on: macos-12
+    runs-on: macos-latest
 
     strategy:
       matrix:
         defines:
           - ""
     env:
-      UPLOAD_ARTIFACT: "false"
+      UPLOAD_ARTIFACT: "true"
       ONLY_CACHE: "false"
       PREPARE_PATH: "Telegram/build/prepare/prepare.py"
 
@@ -56,7 +56,7 @@ jobs:
         run: echo "REPO_NAME=${GITHUB_REPOSITORY##*/}" >> $GITHUB_ENV
 
       - name: Clone.
-        uses: actions/checkout@v3.1.0
+        uses: actions/checkout@v6
         with:
           submodules: recursive
           path: ${{ env.REPO_NAME }}
@@ -64,26 +64,25 @@ jobs:
       - name: First set up.
         run: |
           sudo chown -R `whoami`:admin /usr/local/share
-          brew install automake ninja pkg-config
+
+          brew update
+          brew upgrade || true
+          brew install automake meson nasm ninja pkg-config
 
           # Disable spotlight.
           sudo mdutil -a -i off
 
           sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
 
-      - name: ThirdParty cache.
-        id: cache-third-party
-        uses: actions/cache@v3.0.11
-        with:
-          path: ThirdParty
-          key: ${{ runner.OS }}-third-party-${{ hashFiles(format('{0}/{1}', env.REPO_NAME, env.PREPARE_PATH)) }}
-          restore-keys: ${{ runner.OS }}-third-party-
+          sudo sed -i '' '/CMAKE_${lang}_FLAGS_DEBUG_INIT/s/ -g//' /opt/homebrew/share/cmake/Modules/Compiler/GNU.cmake
 
       - name: Libraries cache.
         id: cache-libs
-        uses: actions/cache@v3.0.11
+        uses: actions/cache@v5
         with:
-          path: Libraries
+          path: |
+            Libraries
+            ThirdParty
           key: ${{ runner.OS }}-libs-${{ hashFiles(format('{0}/{1}', env.REPO_NAME, env.PREPARE_PATH)) }}
           restore-keys: ${{ runner.OS }}-libs-
 
@@ -92,9 +91,7 @@ jobs:
           ./$REPO_NAME/Telegram/build/prepare/mac.sh skip-release silent
 
       - name: Free up some disk space.
-        run: |
-          cd Libraries
-          find . -iname "*.dir" -exec rm -rf {} || true \;
+        run: find Libraries '(' '(' ! '(' -name '*.a' -o -name '*.h' -o -name '*.hpp' -o -name '*.inc' -o -name '*.cmake' -o -path '*/include/*' -o -path '*/objects-*' -o -path '*/cache_keys/*' -o -path '*/patches/*' -o -perm +111 ')' -type f ')' -o -empty ')' -delete
 
       - name: Telegram Desktop build.
         if: env.ONLY_CACHE == 'false'
@@ -105,23 +102,21 @@ jobs:
           if [ -n "${{ matrix.defines }}" ]; then
             DEFINE="-D ${{ matrix.defines }}=ON"
             echo Define from matrix: $DEFINE
-            echo "ARTIFACT_NAME=Telegram_${{ matrix.defines }}" >> $GITHUB_ENV
+            echo "ARTIFACT_NAME=Telegram ${{ matrix.defines }}" >> $GITHUB_ENV
           else
             echo "ARTIFACT_NAME=Telegram" >> $GITHUB_ENV
           fi
 
           ./configure.sh \
-          -D CMAKE_C_FLAGS="-Werror" \
-          -D CMAKE_CXX_FLAGS="-Werror" \
+          -D CMAKE_CONFIGURATION_TYPES=Debug \
+          -D CMAKE_COMPILE_WARNING_AS_ERROR=ON \
           -D CMAKE_XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED=NO \
           -D TDESKTOP_API_TEST=ON \
+          -D DESKTOP_APP_DISABLE_AUTOUPDATE=OFF \
           -D DESKTOP_APP_DISABLE_CRASH_REPORTS=OFF \
           $DEFINE
 
-          cd ../out
-
-          xcoderun='xcodebuild build -project Telegram.xcodeproj -scheme Telegram -destination "platform=macOS,arch=x86_64" -configuration Debug'
-          bash -c "$xcoderun" || bash -c "$xcoderun" || bash -c "$xcoderun"
+          cmake --build ../out --config Debug --parallel
 
       - name: Move artifact.
         if: env.UPLOAD_ARTIFACT == 'true'
@@ -130,7 +125,7 @@ jobs:
           mkdir artifact
           mv Telegram.app artifact/
           mv Updater artifact/
-      - uses: actions/upload-artifact@master
+      - uses: actions/upload-artifact@v6
         if: env.UPLOAD_ARTIFACT == 'true'
         name: Upload artifact.
         with:

.github/workflows/mac_packaged.yml

@@ -40,7 +40,7 @@ jobs:
 
   macos:
     name: MacOS
-    runs-on: macos-13
+    runs-on: macos-latest
 
     strategy:
       matrix:
@@ -49,8 +49,8 @@ jobs:
 
     env:
       GIT: "https://github.com"
-      OPENALDIR: "/usr/local/opt/openal-soft"
-      UPLOAD_ARTIFACT: "false"
+      CMAKE_PREFIX_PATH: "/opt/homebrew/opt/ffmpeg@6:/opt/homebrew/opt/openal-soft"
+      UPLOAD_ARTIFACT: "true"
       ONLY_CACHE: "false"
       MANUAL_CACHING: "1"
       AUTO_CACHING: "1"
@@ -60,7 +60,7 @@ jobs:
         run: echo "REPO_NAME=${GITHUB_REPOSITORY##*/}" >> $GITHUB_ENV
 
       - name: Clone.
-        uses: actions/checkout@v3.1.0
+        uses: actions/checkout@v6
         with:
           submodules: recursive
           path: ${{ env.REPO_NAME }}
@@ -69,10 +69,11 @@ jobs:
         run: |
           brew update
           brew upgrade || true
-          brew install autoconf automake boost cmake ffmpeg openal-soft openssl opus ninja pkg-config python qt yasm xz
+          brew install ada-url autoconf automake boost cmake ffmpeg@6 jpeg-xl libavif libheif libtool openal-soft openh264 openssl opus ninja pkg-config python qtbase qtimageformats qtsvg xz
           sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
 
           xcodebuild -version > CACHE_KEY.txt
+          brew list --versions >> CACHE_KEY.txt
           echo $MANUAL_CACHING >> CACHE_KEY.txt
           echo "$GITHUB_WORKSPACE" >> CACHE_KEY.txt
           if [ "$AUTO_CACHING" = "1" ]; then
@@ -81,9 +82,10 @@ jobs:
           fi
           echo "CACHE_KEY=`md5 -q CACHE_KEY.txt`" >> $GITHUB_ENV
 
+          echo "MACOSX_DEPLOYMENT_TARGET=$(grep 'set(QT_SUPPORTED_MIN_MACOS_VERSION' /opt/homebrew/Cellar/qtbase/*/lib/cmake/Qt6/Qt6ConfigExtras.cmake | sed -E 's/^.*"(.*)"\)$/\1/')" >> $GITHUB_ENV
           echo "LibrariesPath=`pwd`" >> $GITHUB_ENV
 
-          curl -o tg_owt-version.json https://api.github.com/repos/desktop-app/tg_owt/git/refs/heads/master
+          echo "WEBRTC=`curl -sSL --header 'Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}' https://api.github.com/repos/desktop-app/tg_owt/git/refs/heads/master | jq -r .object.sha`" >> $GITHUB_ENV
 
       - name: RNNoise.
         run: |
@@ -94,29 +96,62 @@ jobs:
           ./autogen.sh
           ./configure --disable-examples --disable-doc
           make -j$(sysctl -n hw.logicalcpu)
-          make install
+          sudo make install
 
       - name: WebRTC cache.
         id: cache-webrtc
-        uses: actions/cache@v3.0.11
+        uses: actions/cache@v5
         with:
           path: ${{ env.LibrariesPath }}/tg_owt
-          key: ${{ runner.OS }}-webrtc-${{ env.CACHE_KEY }}-${{ hashFiles('**/tg_owt-version.json') }}
+          key: ${{ runner.OS }}-webrtc-${{ env.WEBRTC }}-${{ env.CACHE_KEY }}
       - name: WebRTC.
         if: steps.cache-webrtc.outputs.cache-hit != 'true'
         run: |
           cd $LibrariesPath
 
-          git clone --recursive --depth=1 $GIT/desktop-app/tg_owt.git
+          git clone --depth=1 --recursive --shallow-submodules $GIT/desktop-app/tg_owt.git
           cd tg_owt
 
-          cmake -B build . -GNinja -DCMAKE_BUILD_TYPE=Debug
+          cmake -Bbuild -GNinja . \
+          -DCMAKE_BUILD_TYPE=Debug \
+          -DCMAKE_C_FLAGS_DEBUG="" \
+          -DCMAKE_CXX_FLAGS_DEBUG="" \
+          -DCMAKE_DISABLE_FIND_PACKAGE_absl=ON
+
           cmake --build build --parallel
 
+      - name: TDE2E cache.
+        id: cache-tde2e
+        uses: actions/cache@v5
+        with:
+          path: ${{ env.LibrariesPath }}/tde2e
+          key: ${{ runner.OS }}-tde2e-${{ env.CACHE_KEY }}
+      - name: TDE2E.
+        if: steps.cache-tde2e.outputs.cache-hit != 'true'
+        run: |
+          cd $LibrariesPath
+
+          git init tde2e
+          cd tde2e
+          git remote add origin $GIT/tdlib/td.git
+          git fetch --depth=1 origin 51743dfd01dff6179e2d8f7095729caa4e2222e9
+          git reset --hard FETCH_HEAD
+
+          cmake -Bbuild -GNinja . \
+          -DCMAKE_BUILD_TYPE=Debug \
+          -DCMAKE_INSTALL_PREFIX=$PWD/build/prefix \
+          -DCMAKE_C_FLAGS_DEBUG="" \
+          -DCMAKE_CXX_FLAGS_DEBUG="" \
+          -DTD_E2E_ONLY=ON
+
+          cmake --build build --parallel
+          cmake --install build
+
       - name: Telegram Desktop build.
         if: env.ONLY_CACHE == 'false'
         env:
           tg_owt_DIR: ${{ env.LibrariesPath }}/tg_owt/build
+          tde2e_DIR: ${{ env.LibrariesPath }}/tde2e/build/prefix
         run: |
           cd $REPO_NAME
 
@@ -124,16 +159,16 @@ jobs:
           if [ -n "${{ matrix.defines }}" ]; then
             DEFINE="-D ${{ matrix.defines }}=ON"
             echo Define from matrix: $DEFINE
-            echo "ARTIFACT_NAME=Telegram_${{ matrix.defines }}" >> $GITHUB_ENV
+            echo "ARTIFACT_NAME=Telegram ${{ matrix.defines }}" >> $GITHUB_ENV
           else
             echo "ARTIFACT_NAME=Telegram" >> $GITHUB_ENV
           fi
 
           cmake -Bbuild -GNinja . \
           -DCMAKE_BUILD_TYPE=Debug \
-          -DCMAKE_FIND_FRAMEWORK=LAST \
+          -DCMAKE_C_FLAGS_DEBUG="" \
+          -DCMAKE_CXX_FLAGS_DEBUG="" \
           -DTDESKTOP_API_TEST=ON \
-          -DDESKTOP_APP_USE_PACKAGED_LAZY=ON \
           $DEFINE
 
           cmake --build build --parallel
@@ -152,7 +187,7 @@ jobs:
           cd $REPO_NAME/build
           mkdir artifact
           mv Telegram.dmg artifact/
-      - uses: actions/upload-artifact@master
+      - uses: actions/upload-artifact@v6
         if: env.UPLOAD_ARTIFACT == 'true'
         name: Upload artifact.
         with:

.github/workflows/master_updater.yml

@@ -5,33 +5,9 @@ on:
     types: released
 
 jobs:
-  updater:
-    runs-on: ubuntu-latest
-    env:
-      SKIP: "0"
-      to_branch: "master"
+  User-agent:
+    runs-on: ubuntu-slim
     steps:
-      - uses: actions/checkout@v4.1.0
+      - uses: desktop-app/action_code_updater@master
         with:
-          fetch-depth: 0
-        if: env.SKIP == '0'
-      - name: Push the code to the master branch.
-        if: env.SKIP == '0'
-        run: |
-          token=${{ secrets.TOKEN_FOR_MASTER_UPDATER }}
-          if [ -z "${token}" ]; then
-              echo "Token is unset. Nothing to do."
-              exit 0
-          fi
-
-          url=https://x-access-token:$token@github.com/$GITHUB_REPOSITORY
-          latest_tag=$(git describe --tags --abbrev=0)
-          echo "Latest tag: $latest_tag"
-
-          git remote set-url origin $url
-          git remote -v
-          git checkout master
-          git merge $latest_tag
-
-          git push origin HEAD:refs/heads/$to_branch
-          echo "Done!"
+          type: "dev-to-master"

.github/workflows/needs-user-action.yml

@@ -0,0 +1,16 @@
+name: Needs user action.
+
+on:
+  issue_comment:
+    types: [created]
+  schedule:
+    - cron: '0 2 * * *'
+
+jobs:
+  needs-user-action:
+    runs-on: ubuntu-slim
+    steps:
+      - uses: lee-dohm/no-response@v0.5.0
+        with:
+          token: ${{ github.token }}
+          responseRequiredLabel: needs user action

.github/workflows/no-response.yml

@@ -1,19 +0,0 @@
-name: No Response
-
-# Both `issue_comment` and `scheduled` event types are required for this Action
-# to work properly.
-on:
-  issue_comment:
-    types: [created]
-  schedule:
-    - cron: '0 0 * * *'
-
-jobs:
-  noResponse:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: lee-dohm/no-response@v0.5.0
-        with:
-          token: ${{ github.token }}
-          # Label requiring a response
-          responseRequiredLabel: waiting for answer

.github/workflows/snap.yml

@@ -40,14 +40,14 @@ jobs:
 
   snap:
     name: Ubuntu
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
 
     env:
-      UPLOAD_ARTIFACT: "false"
+      UPLOAD_ARTIFACT: "true"
 
     steps:
       - name: Clone.
-        uses: actions/checkout@v3.1.0
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
           submodules: recursive
@@ -57,14 +57,18 @@ jobs:
           sudo iptables -P FORWARD ACCEPT
           sudo snap install --classic snapcraft
           sudo usermod -aG lxd $USER
-          sudo snap run lxd init --auto
-          sudo snap run lxd waitready
+          sudo lxd init --auto
+          sudo lxd waitready
 
       - name: Free up some disk space.
-        uses: jlumbroso/free-disk-space@f68fdb76e2ea636224182cfb7377ff9a1708f9b8
+        uses: samueldr/more-space-action@97048bd0df83fb05b5257887bdbaffc848887673
+        with:
+          enable-remove-default-apt-patterns: false
+          enable-lvm-span: true
+          lvm-span-mountpoint: /var/snap/lxd/common/lxd/storage-pools/default/containers
 
       - name: Telegram Desktop snap build.
-        run: sg lxd -c 'snap run snapcraft -v'
+        run: sudo -u $USER snap run snapcraft --verbosity=debug
 
       - name: Move artifact.
         if: env.UPLOAD_ARTIFACT == 'true'
@@ -75,7 +79,7 @@ jobs:
           mkdir artifact
           mv $artifact_name artifact
 
-      - uses: actions/upload-artifact@master
+      - uses: actions/upload-artifact@v6
         if: env.UPLOAD_ARTIFACT == 'true'
         name: Upload artifact.
         with:

.github/workflows/stale.yml

@@ -5,9 +5,9 @@ on:
 
 jobs:
   stale:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-slim
     steps:
-      - uses: actions/stale@v5
+      - uses: actions/stale@v10
         with:
           stale-issue-message: |
             Hey there!

.github/workflows/user_agent_updater.yml

@@ -6,12 +6,10 @@ on:
   schedule:
     # At 00:00 on day-of-month 1.
     - cron: "0 0 1 * *"
-  pull_request_target:
-    types: [closed]
 
 jobs:
   User-agent:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-slim
     steps:
       - uses: desktop-app/action_code_updater@master
         with:

.github/workflows/waiting-for-answer.yml

@@ -0,0 +1,16 @@
+name: Waiting for answer.
+
+on:
+  issue_comment:
+    types: [created]
+  schedule:
+    - cron: '30 0 * * *'
+
+jobs:
+  waiting-for-answer:
+    runs-on: ubuntu-slim
+    steps:
+      - uses: lee-dohm/no-response@v0.5.0
+        with:
+          token: ${{ github.token }}
+          responseRequiredLabel: waiting for answer

.github/workflows/win.yml

@@ -5,6 +5,7 @@ on:
     paths-ignore:
       - 'docs/**'
       - '**.md'
+      - '!docs/building-win*.md'
       - 'changelog.txt'
       - 'LEGAL'
       - 'LICENSE'
@@ -23,6 +24,7 @@ on:
     paths-ignore:
       - 'docs/**'
       - '**.md'
+      - '!docs/building-win*.md'
       - 'changelog.txt'
       - 'LEGAL'
       - 'LICENSE'
@@ -42,7 +44,7 @@ jobs:
 
   windows:
     name: Windows
-    runs-on: windows-2022
+    runs-on: windows-latest
 
     strategy:
       matrix:
@@ -50,7 +52,7 @@ jobs:
         generator: ["", "Ninja Multi-Config"]
 
     env:
-      UPLOAD_ARTIFACT: "false"
+      UPLOAD_ARTIFACT: "true"
       ONLY_CACHE: "false"
       PREPARE_PATH: "Telegram/build/prepare/prepare.py"
 
@@ -69,34 +71,52 @@ jobs:
         shell: bash
         run: echo "REPO_NAME=${GITHUB_REPOSITORY##*/}" >> $GITHUB_ENV
 
-      - uses: ilammy/msvc-dev-cmd@v1.12.0
-        name: Native Tools Command Prompt.
-        with:
-          arch: ${{ matrix.arch }}
-
       - name: Clone.
-        uses: actions/checkout@v3.1.0
+        uses: actions/checkout@v6
         with:
           submodules: recursive
           path: ${{ env.TBUILD }}\${{ env.REPO_NAME }}
 
-      - name: Set up environment paths.
+      - name: First set up.
         shell: bash
         run: |
-          echo "CACHE_KEY=$(sha256sum $TBUILD/$REPO_NAME/$PREPARE_PATH | awk '{ print $1 }')" >> $GITHUB_ENV
+          DOCPATH=$TBUILD/$REPO_NAME/docs/building-win.md
+          [ "${{ matrix.arch }}" != Win32 ] && DOCPATH=$TBUILD/$REPO_NAME/docs/building-win-${{ matrix.arch }}.md
+          SDK="$(grep "SDK version" $DOCPATH | sed -r 's/.*\*\*(.*)\*\* SDK version.*/\1/')"
+          echo "SDK=$SDK" >> $GITHUB_ENV
+
+          sed -i '/CMAKE_${lang}_FLAGS_DEBUG_INIT/s/${_Zi}//' "$PROGRAMFILES"/CMake/share/cmake*/Modules/Platform/Windows-MSVC.cmake
+
+          echo "$(sha256sum $TBUILD/$REPO_NAME/$PREPARE_PATH | awk '{ print $1 }')" >> CACHE_KEY.txt
+          echo "$SDK" >> CACHE_KEY.txt
+          echo "CACHE_KEY=$(sha256sum CACHE_KEY.txt | awk '{ print $1 }')" >> $GITHUB_ENV
 
           echo "Configurate git for cherry-picks."
           git config --global user.email "you@example.com"
           git config --global user.name "Sample"
 
+      - uses: ilammy/msvc-dev-cmd@v1.13.0
+        name: Native Tools Command Prompt.
+        with:
+          arch: ${{ matrix.arch }}
+          sdk: ${{ env.SDK }}
+
       - name: NuGet sources.
         run: |
           nuget sources Disable -Name "Microsoft Visual Studio Offline Packages"
           nuget sources Add -Source https://api.nuget.org/v3/index.json & exit 0
 
+      - name: ThirdParty cache.
+        id: cache-third-party
+        uses: actions/cache@v5
+        with:
+          path: ${{ env.TBUILD }}\ThirdParty
+          key: ${{ runner.OS }}-${{ matrix.arch }}-third-party-${{ env.CACHE_KEY }}
+          restore-keys: ${{ runner.OS }}-${{ matrix.arch }}-third-party-
+
       - name: Libraries cache.
         id: cache-libs
-        uses: actions/cache@v3.0.11
+        uses: actions/cache@v5
         with:
           path: ${{ env.TBUILD }}\Libraries
           key: ${{ runner.OS }}-${{ matrix.arch }}-libs-${{ env.CACHE_KEY }}
@@ -122,14 +142,14 @@ jobs:
               *) ARCH="${{ matrix.arch }}";;
             esac
             echo "Architecture from matrix: $ARCH"
-            ARTIFACT_NAME="${ARTIFACT_NAME}_${{ matrix.arch }}"
+            ARTIFACT_NAME="${ARTIFACT_NAME} ${{ matrix.arch }}"
           fi
 
           GENERATOR=""
           if [ -n "${{ matrix.generator }}" ]; then
             GENERATOR="-G \"${{ matrix.generator }}\""
             echo "Generator from matrix: $GENERATOR"
-            ARTIFACT_NAME="${ARTIFACT_NAME}_${{ matrix.generator }}"
+            ARTIFACT_NAME="${ARTIFACT_NAME} ${{ matrix.generator }}"
           fi
           echo "TDESKTOP_BUILD_GENERATOR=$GENERATOR" >> $GITHUB_ENV
 
@@ -140,7 +160,7 @@ jobs:
           if [ -n "${{ matrix.defines }}" ]; then
             DEFINE="-D ${{ matrix.defines }}=ON"
             echo "Define from matrix: $DEFINE"
-            ARTIFACT_NAME="${ARTIFACT_NAME}_${{ matrix.defines }}"
+            ARTIFACT_NAME="${ARTIFACT_NAME} ${{ matrix.defines }}"
           fi
           echo "TDESKTOP_BUILD_DEFINE=$DEFINE" >> $GITHUB_ENV
 
@@ -154,11 +174,8 @@ jobs:
           echo "TDESKTOP_BUILD_API=$API" >> $GITHUB_ENV
 
       - name: Free up some disk space.
-        run: |
-          cd %TBUILD%
-          del /S Libraries\*.pdb
-          del /S Libraries\*.pch
-          del /S Libraries\*.obj
+        shell: bash
+        run: find TBuild/Libraries '(' '(' ! '(' -name '*.lib' -o -name '*.a' -o -name '*.exe' -o -name '*.h' -o -name '*.hpp' -o -name '*.inc' -o -name '*.cmake' -o -path '*/include/*'  -o -path '*/objects-*' -o -path '*/cache_keys/*' -o -path '*/patches/*' ')' -type f ')' -o -empty ')' -delete
 
       - name: Telegram Desktop build.
         if: env.ONLY_CACHE == 'false'
@@ -169,8 +186,11 @@ jobs:
           %TDESKTOP_BUILD_GENERATOR% ^
           %TDESKTOP_BUILD_ARCH% ^
           %TDESKTOP_BUILD_API% ^
+          -D CMAKE_CONFIGURATION_TYPES=Debug ^
+          -D CMAKE_COMPILE_WARNING_AS_ERROR=ON ^
+          -D CMAKE_MSVC_DEBUG_INFORMATION_FORMAT= ^
+          -D DESKTOP_APP_DISABLE_AUTOUPDATE=OFF ^
           -D DESKTOP_APP_DISABLE_CRASH_REPORTS=OFF ^
-          -D DESKTOP_APP_NO_PDB=ON ^
           %TDESKTOP_BUILD_DEFINE%
 
           cmake --build ..\out --config Debug --parallel
@@ -178,9 +198,11 @@ jobs:
       - name: Move artifact.
         if: (env.UPLOAD_ARTIFACT == 'true') || (github.ref == 'refs/heads/nightly')
         run: |
+          set OUT=%TBUILD%\%REPO_NAME%\out\Debug
           mkdir artifact
-          move %TBUILD%\%REPO_NAME%\out\Debug\Telegram.exe artifact/
-      - uses: actions/upload-artifact@master
+          move %OUT%\Telegram.exe artifact/
+          move %OUT%\Updater.exe artifact/
+      - uses: actions/upload-artifact@v6
         name: Upload artifact.
         if: (env.UPLOAD_ARTIFACT == 'true') || (github.ref == 'refs/heads/nightly')
         with:

.gitignore

@@ -18,6 +18,9 @@ Release/
 *.xcodeproj
 ipch/
 .vs/
+.vscode/
+.cache/
+compile_commands.json
 
 /Telegram/log.txt
 /Telegram/data
@@ -50,3 +53,14 @@ stage
 *.*~
 .idea/
 cmake-build-debug/
+
+# Local configuration files
+settings.local.json
+*.local.json
+.env
+.env.local
+.env.*.local
+
+# Cursor IDE local settings (but keep .cursor/rules/)
+.cursor/*
+!.cursor/rules/

.gitmodules

@@ -1,9 +1,6 @@
-[submodule "Telegram/ThirdParty/libtgvoip"]
-	path = Telegram/ThirdParty/libtgvoip
-	url = https://github.com/telegramdesktop/libtgvoip
 [submodule "Telegram/ThirdParty/GSL"]
 	path = Telegram/ThirdParty/GSL
-	url = https://github.com/desktop-app/GSL.git
+	url = https://github.com/Microsoft/GSL.git
 [submodule "Telegram/ThirdParty/xxHash"]
 	path = Telegram/ThirdParty/xxHash
 	url = https://github.com/Cyan4973/xxHash.git
@@ -79,12 +76,6 @@
 [submodule "Telegram/ThirdParty/dispatch"]
 	path = Telegram/ThirdParty/dispatch
 	url = https://github.com/apple/swift-corelibs-libdispatch
-[submodule "Telegram/ThirdParty/plasma-wayland-protocols"]
-	path = Telegram/ThirdParty/plasma-wayland-protocols
-	url = https://github.com/KDE/plasma-wayland-protocols.git
-[submodule "Telegram/ThirdParty/wayland-protocols"]
-	path = Telegram/ThirdParty/wayland-protocols
-	url = https://github.com/gitlab-freedesktop-mirrors/wayland-protocols.git
 [submodule "Telegram/ThirdParty/kimageformats"]
 	path = Telegram/ThirdParty/kimageformats
 	url = https://github.com/KDE/kimageformats.git
@@ -94,9 +85,9 @@
 [submodule "Telegram/ThirdParty/cld3"]
 	path = Telegram/ThirdParty/cld3
 	url = https://github.com/google/cld3.git
-[submodule "Telegram/ThirdParty/wayland"]
-	path = Telegram/ThirdParty/wayland
-	url = https://github.com/gitlab-freedesktop-mirrors/wayland.git
 [submodule "Telegram/ThirdParty/libprisma"]
 	path = Telegram/ThirdParty/libprisma
 	url = https://github.com/desktop-app/libprisma.git
+[submodule "Telegram/ThirdParty/xdg-desktop-portal"]
+	path = Telegram/ThirdParty/xdg-desktop-portal
+	url = https://github.com/flatpak/xdg-desktop-portal.git

CMakeLists.txt

@@ -4,15 +4,7 @@
 # For license and copyright information please follow this link:
 # https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
 
-if (APPLE)
-    # target_precompile_headers with COMPILE_LANGUAGE restriction.
-    cmake_minimum_required(VERSION 3.23)
-else()
-    cmake_minimum_required(VERSION 3.16)
-endif()
-if (POLICY CMP0149)
-    cmake_policy(SET CMP0149 NEW)
-endif()
+cmake_minimum_required(VERSION 3.25...3.31)
 
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
@@ -20,19 +12,17 @@ include(cmake/validate_special_target.cmake)
 include(cmake/version.cmake)
 desktop_app_parse_version(Telegram/build/version)
 
-set(project_langs C CXX)
-if (APPLE)
-    list(APPEND project_langs OBJC OBJCXX)
-elseif (LINUX)
-    list(APPEND project_langs ASM)
-endif()
-
 project(Telegram
-    LANGUAGES ${project_langs}
+    LANGUAGES C CXX
     VERSION ${desktop_app_version_cmake}
     DESCRIPTION "Official Telegram Desktop messenger"
     HOMEPAGE_URL "https://desktop.telegram.org"
 )
+
+if (APPLE)
+    enable_language(OBJC OBJCXX)
+endif()
+
 set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT Telegram)
 
 get_filename_component(third_party_loc "Telegram/ThirdParty" REALPATH)
@@ -47,9 +37,7 @@ include(cmake/variables.cmake)
 include(cmake/nice_target_sources.cmake)
 include(cmake/target_compile_options_if_exists.cmake)
 include(cmake/target_link_frameworks.cmake)
-include(cmake/target_link_optional_libraries.cmake)
 include(cmake/target_link_options_if_exists.cmake)
-include(cmake/target_link_static_libraries.cmake)
 include(cmake/init_target.cmake)
 include(cmake/generate_target.cmake)
 include(cmake/nuget.cmake)
@@ -57,17 +45,10 @@ include(cmake/validate_d3d_compiler.cmake)
 include(cmake/target_prepare_qrc.cmake)
 
 include(cmake/options.cmake)
-
-if (NOT DESKTOP_APP_USE_PACKAGED)
-    if (WIN32)
-        set(qt_version 5.15.11)
-    elseif (APPLE)
-        set(qt_version 6.2.6)
-    endif()
-endif()
 include(cmake/external/qt/package.cmake)
 
 set(desktop_app_skip_libs
+    glibmm
     variant
 )
 

LEGAL

@@ -1,7 +1,7 @@
 This file is part of Telegram Desktop,
 the official desktop application for the Telegram messaging service.
 
-Copyright (c) 2014-2023 The Telegram Desktop Authors.
+Copyright (c) 2014-2025 The Telegram Desktop Authors.
 
 Telegram Desktop is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by

README.md

@@ -43,9 +43,9 @@ Version **1.8.15** was the last that supports older systems
 ## Third-party
 
 * Qt 6 ([LGPL](http://doc.qt.io/qt-6/lgpl.html)) and Qt 5.15 ([LGPL](http://doc.qt.io/qt-5/lgpl.html)) slightly patched
-* OpenSSL 1.1.1 and 1.0.1 ([OpenSSL License](https://www.openssl.org/source/license.html))
+* OpenSSL 3.2.1 ([Apache License 2.0](https://www.openssl.org/source/apache-license-2.0.txt))
 * WebRTC ([New BSD License](https://github.com/desktop-app/tg_owt/blob/master/LICENSE))
-* zlib 1.2.11 ([zlib License](http://www.zlib.net/zlib_license.html))
+* zlib ([zlib License](http://www.zlib.net/zlib_license.html))
 * LZMA SDK 9.20 ([public domain](http://www.7-zip.org/sdk.html))
 * liblzma ([public domain](http://tukaani.org/xz/))
 * Google Breakpad ([License](https://chromium.googlesource.com/breakpad/breakpad/+/master/LICENSE))
@@ -58,13 +58,13 @@ Version **1.8.15** was the last that supports older systems
 * Guideline Support Library ([MIT License](https://github.com/Microsoft/GSL/blob/master/LICENSE))
 * Range-v3 ([Boost License](https://github.com/ericniebler/range-v3/blob/master/LICENSE.txt))
 * Open Sans font ([Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0.html))
-* Vazir font ([SIL Open Font License 1.1](https://github.com/rastikerdar/vazir-font/blob/master/OFL.txt))
+* Vazirmatn font ([SIL Open Font License 1.1](https://github.com/rastikerdar/vazirmatn/blob/master/OFL.txt))
 * Emoji alpha codes ([MIT License](https://github.com/emojione/emojione/blob/master/extras/alpha-codes/LICENSE.md))
-* Catch test framework ([Boost License](https://github.com/philsquared/Catch/blob/master/LICENSE.txt))
 * xxHash ([BSD License](https://github.com/Cyan4973/xxHash/blob/dev/LICENSE))
 * QR Code generator ([MIT License](https://github.com/nayuki/QR-Code-generator#license))
 * CMake ([New BSD License](https://github.com/Kitware/CMake/blob/master/Copyright.txt))
 * Hunspell ([LGPL](https://github.com/hunspell/hunspell/blob/master/COPYING.LESSER))
+* Ada ([Apache License 2.0](https://github.com/ada-url/ada/blob/main/LICENSE-APACHE))
 
 ## Build instructions