# Nagram: a third-party Telegram Android client built on NekoX

> Nagram is a GPLv3 fork of NekoX that adds combined messages, editable text styles, proxy subscription parsing and a long list of NekoX options. It is a source build, not an app store download, and the README is aimed at developers who can assemble the toolchain.

**NextAlone/Nagram** — The third-party Telegram android app.

- Repository: https://github.com/NextAlone/Nagram
- Stars: 3,348 · Forks: 223
- Language: Java
- License: GPL-3.0
- Published: 2026-09-24 · Updated: 2026-09-24 · Language: en
- Canonical page: https://hysenlabs.com/projects/nextalone-nagram

## What Nagram is and who it is for

Nagram is a third-party Telegram client for Android, forked from NekoX. The README states plainly that it is "based on NekoX with some modifications." The primary language is Java, the licence is GPL-3.0, and the repository keeps several Android application modules alongside the main TMessagesProj directory.

The audience is narrow and specific. This is not a client for someone who wants to install Telegram from Google Play and forget about it. It is for Android users who want behaviour the official client does not expose: proxy subscription parsing across SIP008, ssr, v2rayN, vmess1 and clash formats; custom emoji packs; OpenCC Chinese conversion; a no-Google-Services notification build; and the Nagram-specific additions listed in the README, such as combined message, editable text style, forced copy, invert reply, quick reply in the long-click menu, undo and redo, and a scrollable chat preview.

Because it is a fork of a fork (NekoX itself descends from Nekogram), the feature set is cumulative. The README devotes most of its length to the NekoX changes rather than to Nagram's own additions, which tells you where the weight of the codebase sits.

## How the client is put together

The repository layout is a standard Telegram Android fork. TMessagesProj holds the main application and its JNI native code; TMessagesProj_App, TMessagesProj_AppHockeyApp, TMessagesProj_AppHuawei, TMessagesProj_AppStandalone and TMessagesProj_AppTests are per-distribution variants, which is why the README treats FCM and keystores as separate configuration steps. openpgp-api is vendored in, matching the OpenKeychain integration mentioned in the feature list.

The native side is built from C and C++ through the NDK, with a helper script named run that wraps the build. The README's compilation guide splits native work into two stages: ./run init libs prepares dependencies, then ./run libs native builds external libraries and native code. Gradle handles the Java and resource packaging afterwards.

One detail worth pausing on: the README instructs builders to delete the signature verification block in TMessagesProj/jni/jni.c before compiling. That is a deliberate modification to a security check, and it means a self-built Nagram is not signature-verified at the native layer in the same way the upstream build is. The README presents it as a build step, not as a warning.

## Installing Nagram: releases or a source build

The README does not describe an app store listing. It points to the GitHub releases page, and the recent releases are tagged 1248 (12.10.1.1248), 1244 (12.9.2.1244) and 1242 (12.9.0.1242). For most users the release APK is the only realistic path, because the source build requires a full Android native toolchain.

If you do build it, the README gives a Debian or Arch Linux or macOS environment and these native tools. On Debian-based distributions the command is:

```bash
sudo apt install gcc golang make cmake ninja-build yasm
```

On Arch Linux the equivalent is:

```bash
sudo pacman -S base-devel go ninja cmake yasm
```

The Android SDK components are pinned: build-tools;33.0.0, platforms;android-33, ndk;27.2.12479018, cmake;3.18.1 and cmake;3.22.1. The README recommends Android Studio, but also gives the sdkmanager route:

```bash
sudo apt install sdkmanager
sdkmanager --sdk_root $HOME/Android/SDK --install "build-tools;33.0.0" "platforms;android-33" "ndk;27.2.12479018" "cmake;3.18.1" "cmake;3.22.1"
```

After checking out submodules with git submodule update --init --recursive and removing the signature check in TMessagesProj/jni/jni.c, you run the native stages:

```bash
./run init libs
./run libs native
```

Then fill TELEGRAM_APP_ID and TELEGRAM_APP_HASH in local.properties, sourced from the Telegram developer portal. Replace TMessagesProj/google-services.json only if you want FCM. Replace release.keystore with your own and set ALIAS_NAME, KEYSTORE_PASS and ALIAS_PASS in local.properties. The final step is:

```bash
./gradlew assemble<Release/Debug>
```

The README also notes that Windows users should use a Linux VM such as WSL2 or dual boot, which is a fair signal of how much the build depends on a Unix-like host.

## Where Nagram is the wrong tool

The README's own feature list contains a maintenance admission: the built-in VMess, Shadowsocks, SSR and Trojan-GFW proxy support is marked "No longer maintained." If your reason for choosing Nagram is one of those protocols, the project is telling you that part is not being kept up, and you should look at the proxy subscription and public proxy paths instead.

The second limitation is the build itself. There is no documented Windows native path. There is no Docker build. The README asks for a specific NDK version and two CMake versions, and it asks you to disable a signature check. If you only want a Telegram client on a phone, none of that is worth doing, and the release APK is the answer.

Third, the README does not document rollback, downgrade or migration between Nagram versions. It also does not document how to move an existing Telegram session into Nagram or back. Those are real questions for anyone switching clients, and the README is silent on them.

## Nagram against NekoX and the official Telegram client

The honest comparison is with NekoX, not with Telegram. Nagram is a fork of NekoX, and the README's own structure shows it: most of the feature list is labelled "NekoX Changes," covering unlimited login accounts, proxy handling, sticker backup and restore, OpenCC, translation support, custom cache directories and the option to use a build without Google Services. Nagram's own additions sit above that in a shorter list.

Against the official Telegram Android client, the difference is control. Nagram exposes proxy configuration, custom servers including test DCs, a custom cache directory that can live on external storage, an option to block secret chat initiation, an option to disable trending, and a set of bulk actions such as deleting all messages in a group or unblocking all users. The official client does not surface those.

The cost is trust and upkeep. A third-party client handles your Telegram session, and the README does not make a security argument for doing so. It simply states the licence and the branding rules. That is a gap you have to close yourself by reading the source.

## Licence, branding and what a fork must do

Nagram's source code is GPL-3.0. The README separates the code licence from the brand: the Nagram name and project identity belong to @NextAlone, and the application icon artwork is copyright MaitungTM. BRANDING.md holds the full policy, and the README states that modified, forked and third-party distributions must use distinct branding and replace the Nagram brand assets.

That distinction matters if you plan to redistribute. The GPL gives you the right to modify and share the code, but it does not give you the right to ship the Nagram name or the icon. A fork that keeps the Nagram branding is out of bounds under the stated policy, regardless of what the GPL permits for the source.

This is not legal advice. If you intend to publish a fork, read BRANDING.md and LICENSE in the repository before you do.

## Conclusion

Nagram fits Android users who want NekoX's proxy and sticker features plus combined messages and editable text styles, and who are comfortable installing a signed APK or building from source. It is the wrong choice if you need iOS, a desktop client, or an app store listing: the README documents only an Android Gradle build and points at GitHub releases. Before adopting it, check the release page for the version matching your device, confirm the GPLv3 branding rules in BRANDING.md if you plan to redistribute, and verify that you have your own TELEGRAM_APP_ID and TELEGRAM_APP_HASH because the build requires them.

## FAQ

### What is Nagram?

Nagram is a third-party Telegram client for Android, based on NekoX with some modifications. The README lists its own additions, including combined message, editable text style, forced copy, invert reply, quick reply in the long-click menu, undo and redo, and a scrollable chat preview.

### How do I install Nagram?

The README points to the GitHub releases page for builds, so the practical route is downloading a release APK. Building from source requires a Debian, Arch or macOS host with the pinned Android SDK, NDK and CMake versions, plus your own Telegram app ID and hash.

### What are some third-party Telegram apps for Android?

Nagram is one, and it is a fork of NekoX, which itself carries most of Nekogram's features. The README frames Nagram as sitting downstream of that lineage rather than as an independent client.

### Is Nagram a Telegram copy app?

It is a third-party Telegram client, not a copy of the official app. The README describes it as based on NekoX with modifications, and it uses the Telegram API and MTProto protocol, with links to the official API and protocol manuals.

## Sources

- [Issues](https://github.com/NextAlone/Nagram/issues)
- [License: GPL-3.0](https://github.com/NextAlone/Nagram/blob/main/LICENSE)
- [NextAlone/Nagram on GitHub](https://github.com/NextAlone/Nagram)
- [README](https://github.com/NextAlone/Nagram/blob/main/README.md)
- [Releases](https://github.com/NextAlone/Nagram/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/nextalone-nagram