XDBlog

Matrix

Wed, 04 Feb 2026 00:00:00 GMT

In an era of centralized silos, the Matrix protocol offers a refreshing alternative: an open, decentralized standard for real-time communication. Unlike traditional messengers, Matrix is not just an app—it is an ecosystem.

What is Matrix?

Matrix is an open source project that publishes an open standard for secure, decentralized, real-time communication. It allows users from different providers to talk to each other, much like how you can send an email from Gmail to Outlook.

Why Matrix is Better Than Other Messengers

1. Decentralization (No Single Point of Control)

With WhatsApp or Telegram, you are tied to their servers. If their servers go down, the service dies. In Matrix, anyone can host their own Homeserver. If one server goes offline, the rest of the network continues to function. You truly own your data.

2. Bridges (The "One App to Rule Them All")

Matrix can "bridge" other networks. This means you can use a Matrix client (like Element) to chat with people on:

Telegram
Discord
WhatsApp
Signal
Slack By using bridges, you don't have to switch between five different apps to stay in touch.

3. End-to-End Encryption (E2EE)

Matrix uses the Olm and Megolm cryptographic ratchets (based on the Signal protocol). This ensures that only the participants in a room can decrypt the messages. Even the server administrators cannot read your conversations.

4. Total Privacy

Most messengers require a phone number (Telegram, Signal, WhatsApp). Matrix allows you to register an account with just a username and password (depending on the homeserver policy), giving you a much higher level of anonymity.

Matrix vs. The Competition

Feature	Matrix	Telegram	WhatsApp
Federated	Yes (Open)	No (Closed)	No (Closed)
Open Source	Yes	Partial	No
Phone Required	No	Yes	Yes
Self-Hosting	Yes	No	No

How to Get Started

Pick a Client: Element is the most popular, but there are others like Cinny or FluffyChat.
Choose a Homeserver: You can start with the default matrix.org, but for better performance and privacy, many users choose smaller community servers or host their own.
Start Chatting: Your ID will look like @username:homeserver.tld.

Conclusion

Matrix is for those who value sovereignty and interoperability. It’s not just about messaging; it’s about taking back control of your digital identity. While the learning curve is slightly steeper than a simple phone app, the freedom it provides is worth the effort.

Tip: If you are a developer, Matrix is a dream. The entire API is based on simple HTTP/JSON, making it incredibly easy to write bots and integrations.

Telegram Userbot

Tue, 03 Feb 2026 00:00:00 GMT

In the Telegram ecosystem, most people are familiar with "Bot API" bots (like @BotFather). However, there is another powerful tool called a Userbot.

What is a Userbot?

A userbot refers to a third-party program that interacts with the Telegram API to perform automated tasks on behalf of a user. These userbots can be used to automate various tasks such as sending messages, joining channels, downloading media, and much more.

Userbots are different from regular Telegram bots as they run on the user's account rather than a bot account. This means that userbots can access more features and have greater flexibility in terms of the actions they can perform.

Key Use Cases

Personal Automation Automate repetitive tasks like clearing old messages, auto-replying when you are busy, or translating incoming messages in real-time.
Advanced Management Userbots can perform massive administrative tasks across multiple groups that standard bots might struggle with due to API limitations.
Data Archiving They are ideal for backing up chat histories or saving media from channels into a structured database.
Self-Bots (UX Enhancements) Many developers use userbots to add "slash commands" to their own chat experience, like .google [query] to instantly post a search link or .status to show system uptime.

Userbot vs. Regular Bot

Feature	Regular Bot (Bot API)	Userbot (MTProto)
Account Type	Dedicated `@bot` account	Your personal account
Initiating Chat	User must start the bot	Can message anyone
Privacy	Cannot see all messages	Can read everything you see
Risk	Safe, official	Risk of ban if used for spam

The "Rules of the Road"

Using a userbot is a "gray area" in Telegram's Terms of Service. To avoid getting your account banned:

Avoid Spam: Never use userbots for mass unsolicited messaging.
Rate Limiting: Don't flood the API with thousands of requests per second.
Security: Never share your api_id or api_hash (the credentials needed to run the script).

Popular Frameworks

If you want to build one, these are the top libraries:

Python: Telethon or Pyrogram.
JavaScript: GramJS.

Conclusion: Userbots are incredibly powerful for power users and developers, but they come with the responsibility of keeping your account secure and following Telegram's unwritten rules of etiquette.

Telegram API_ID & API_HASH

Mon, 02 Feb 2026 00:00:00 GMT

To work with Telegram's MTProto API (for userbots or custom clients), you need two unique identifiers: api_id and api_hash.

Step-by-Step Instructions

Login: Go to my.telegram.org.
Authentication: Enter your phone number in international format. You will receive a confirmation code via the Telegram app (not SMS).
API Development: Click on the "API development tools" link.
Create App: Fill out the form:
- App title: Any name you prefer.
- Short name: A simple alphanumeric string.
- Platform: Select any (e.g., Web or Android).
Save: Click "Create application." You will now see your App api_id and App api_hash.

Why do you need them?

Unlike the Bot API (used for @BotFather bots), these credentials allow you to:

Build custom Telegram clients.
Automate your personal account (Userbots).
Analyze large amounts of public channel data.
Manage account-level settings programmatically.

Security Warning

Keep your api_hash secret. If someone obtains your hash and phone number, they can gain full access to your account. Do not hardcode these values in public GitHub repositories.

Basic Example (Python/Telethon)

from telethon import TelegramClient

api_id = 12345
api_hash = 'your_api_hash_here'

with TelegramClient('session_name', api_id, api_hash) as client:
    client.loop.run_until_complete(client.send_message('me', 'Hello from my blog!'))

Heroku Userbot

Thu, 05 Feb 2026 00:00:00 GMT

Heroku Userbot: A New Take on the Legendary Hikka

If you've ever dabbled in Telegram automation, the name Hikka is surely familiar to you. It’s the foundation, the classic. However, 2024 has brought us something new.

September 9, 2024, marked the official release of Heroku userbot — an ambitious fork of the original Hikka.

Why Should You Pay Attention?

Forks aren't created without reason. The Heroku developer (@coddrago) set out to take the best parts of the original and adapt them to modern demands while preserving that signature "comfy" flexibility. The project is designed for stable performance across a wide variety of platforms.

What’s Under the Hood?

Full Compatibility: Works seamlessly with existing Hikka modules.
Refined Internals: Reworked core components for improved speed.
Exclusive Features: Built-in "out of the box" tweaks that make life easier.

Whether you're looking for a reason to upgrade your current toolkit or you're just starting your journey into the world of userbots, Heroku is an excellent entry point.

Documentation

About the Project

Heroku Userbot is a functional branch (fork) of the Hikka Userbot project. Launched in September 2024, the project serves as an initiative to enhance user experience and optimize the codebase.

Initial Release Date: September 9, 2024
Base Architecture: Hikka Userbot
Language: Python

Installation and Setup

Installation

Clone the repository: git clone https://github.com/coddrago/Heroku
Navigate to the folder: cd Heroku/
Install dependencies: pip install -r requirements.txt
Launch the bot: python3 -m heroku

Command Line Flags and Arguments

When launching the bot via python3 -m heroku, you can pass several arguments to customize its behavior. This is especially useful for advanced deployments (VPS, Docker, or automated environments).

Flag	Destination	Description
`--port`	`port`	Specifies the port for the web interface. (Default: auto-generated via `gen_port()`).
`--phone`, `-p`	`phone`	Pass phone number(s) directly to the bot. Can be used multiple times.
`--no-web`	`disable_web`	Disables the web interface entirely.
`--qr-login`	`qr_login`	Enables login via QR code instead of a phone number (requires another device to scan).
`--data-root`	`data_root`	Sets a custom root directory path for storing session files.
`--no-auth`	`no_auth`	Disables authentication and API token input. The bot will exit if auth is required.
`--proxy-host`	`proxy_host`	MTProto proxy host (address) without the port.
`--proxy-port`	`proxy_port`	MTProto proxy port (integer).
`--proxy-secret`	`proxy_secret`	MTProto proxy secret key.
`--root`	`disable_root_check`	Disables the "force insecure" warning when running the bot as root.
`--sandbox`	`sandbox`	If enabled, the bot will shut down instead of attempting a restart.
`--proxy-pass`	`proxy_pass`	Opens a proxy pass tunnel on startup (not required during initial setup).
`--no-tty`	`tty`	Disables ANSI escape sequences (colorful output) in the console.

Usage Examples

Running with a specific port and no web interface:

python3 -m heroku --port 8080 --no-web

Running via MTProto Proxy:

python3 -m heroku --proxy-host 1.2.3.4 --proxy-port 8888 --proxy-secret YOUR_SECRET

Silent mode without colorful output (useful for logging):

python3 -m heroku --no-tty

Basic Commands

Heroku uses a standard prefix (default is .), which can be modified using .setprefix command.

Command	Action
`.help [module_name]`	Open the help menu
`.dlm`	Install a module from the official module repo
`.e [code]`	Evaluates python code
`.ping`	Test your userbot ping
`.terminal [cmd]`	Execute console commands directly from the chat

Key Features and Differences from Hikka

Compared to the original base, Heroku Userbot introduces several significant technical upgrades:

Aiogram v3 Core: Completely migrated to the latest version of the Aiogram library.
- Support for modern Telegram features like nested entities and blockquotes in inline messages.
- Access to a wider range of the latest Telegram Bot API methods.
Smart Loader: An enhanced module loader that automatically checks for and applies updates to your modules every time the userbot restarts.
Refined UI/UX: Completely overhauled visual templates for inline menus and system messages, providing a cleaner and more modern look.
Stability: A massive "bug-squashing" campaign was conducted, fixing numerous legacy issues for a smoother experience.

Warning: This software is intended for automating routine tasks. The developers are not responsible for account bans resulting from violations of Telegram's Terms of Service (Spam/Flood).

Module Channels & Repositories

Heroku is fully compatible with the Hikka ecosystem, giving you access to thousands of custom scripts. You can find modules in these popular Telegram channels:

How to Install

To add a new module, simply reply to a .py file or send a link to the code with the following command:

.dlm [link/file]

Useful Links

Markdown Tutorial

Sun, 01 Feb 2026 00:00:00 GMT

Markdown Tutorial

A markdown example shows how to write a markdown file. This document integrates core syntax and extensions (GMF).

Block Elements
Span Elements
- Links
- Emphasis
- Code
- Images
- Strikethrough
Miscellaneous
- Automatic Links
- Backslash Escapes
Inline HTML

Block Elements

Paragraphs and Line Breaks

Paragraphs

HTML Tag: <p>

One or more blank lines. (A blank line is a line containing nothing but spaces or tabs is considered blank.)

Code:

This will be
inline.

This is second paragraph.

Preview:

This will be inline.

This is second paragraph.

Line Breaks

HTML Tag: <br />

End a line with two or more spaces.

Code:

This will be not
inline.

Preview:

This will be not
inline.

Headers

Markdown supports two styles of headers, Setext and atx.

Setext

HTML Tags: <h1>, <h2>

“Underlined” using equal signs (=) as <h1> and dashes (-) as <h2> in any number.

Code:

This is an H1
=============
This is an H2
-------------

Preview:

This is an H1

This is an H2

atx

HTML Tags: <h1>, <h2>, <h3>, <h4>, <h5>, <h6>

Uses 1-6 hash characters (#) at the start of the line, corresponding to <h1> - <h6>.

Code:

# This is an H1
## This is an H2
###### This is an H6

Preview:

This is an H1

This is an H2

This is an H6

Optionally, you may “close” atx-style headers. The closing hashes don’t need to match the number of hashes used to open the header.

Code:

# This is an H1 #
## This is an H2 ##
### This is an H3 ######

Preview:

This is an H1

This is an H2

This is an H3

Blockquotes

HTML Tag: <blockquote>

Markdown uses email-style > characters for blockquoting. It looks best if you hard wrap the text and put a > before every line.

Code:

> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
> consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
> Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
>
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
> id sem consectetuer libero luctus adipiscing.

Preview:

This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.

Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing.

Markdown allows you to be lazy and only put the > before the first line of a hard-wrapped paragraph.

Code:

> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.

> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
id sem consectetuer libero luctus adipiscing.

Preview:

This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.

Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse id sem consectetuer libero luctus adipiscing.

Blockquotes can be nested (i.e. a blockquote-in-a-blockquote) by adding additional levels of >.

Code:

> This is the first level of quoting.
>
> > This is nested blockquote.
>
> Back to the first level.

Preview:

This is the first level of quoting.

This is nested blockquote.

Back to the first level.

Blockquotes can contain other Markdown elements, including headers, lists, and code blocks.

Code:

> ## This is a header.
>
> 1.   This is the first list item.
> 2.   This is the second list item.
>
> Here's some example code:
>
>     return shell_exec("echo $input | $markdown_script");

Preview:

This is a header.

This is the first list item.

This is the second list item.

Here's some example code:
return shell_exec("echo $input | $markdown_script");

Lists

Markdown supports ordered (numbered) and unordered (bulleted) lists.

Unordered

HTML Tag: <ul>

Unordered lists use asterisks (*), pluses (+), and hyphens (-).

Code:

*   Red
*   Green
*   Blue

Preview:

Red
Green
Blue

is equivalent to:

Code:

+   Red
+   Green
+   Blue

and:

Code:

-   Red
-   Green
-   Blue

Ordered

HTML Tag: <ol>

Ordered lists use numbers followed by periods:

Code:

1.  Bird
2.  McHale
3.  Parish

Preview:

Bird
McHale
Parish

It’s possible to trigger an ordered list by accident, by writing something like this:

Code:

1986. What a great season.

Preview:

What a great season.

You can backslash-escape (\) the period:

Code:

1986\. What a great season.

Preview:

1986. What a great season.

Indented

Blockquote

To put a blockquote within a list item, the blockquote’s > delimiters need to be indented:

Code:

*   A list item with a blockquote:

    > This is a blockquote
    > inside a list item.

Preview:

A list item with a blockquote:

This is a blockquote inside a list item.

Code Block

To put a code block within a list item, the code block needs to be indented twice — 8 spaces or two tabs:

Code:

*   A list item with a code block:

        <code goes here>

Preview:

A list item with a code block:
```
<code goes here>
```

Nested List

Code:

* A
  * A1
  * A2
* B
* C

Preview:

A
- A1
- A2
B
C

Code Blocks

HTML Tag: <pre>

Indent every line of the block by at least 4 spaces or 1 tab.

Code:

This is a normal paragraph:

    This is a code block.

Preview:

This is a normal paragraph:

This is a code block.

A code block continues until it reaches a line that is not indented (or the end of the article).

Within a code block, ampersands (&) and angle brackets (< and >) are automatically converted into HTML entities.

Code:

    <div class="footer">
        &copy; 2004 Foo Corporation
    </div>

Preview:

<div class="footer">
    &copy; 2004 Foo Corporation
</div>

Following sections Fenced Code Blocks and Syntax Highlighting are extensions, you can use the other way to write the code block.

Fenced Code Blocks

Just wrap your code in ``` (as shown below) and you won't need to indent it by four spaces.

Code:

Here's an example:

```
function test() {
  console.log("notice the blank line before this function?");
}
```

Preview:

Here's an example:

function test() {
  console.log("notice the blank line before this function?");
}

Syntax Highlighting

In your fenced block, add an optional language identifier and we'll run it through syntax highlighting (Support Languages).

Code:

```ruby
require 'redcarpet'
markdown = Redcarpet.new("Hello World!")
puts markdown.to_html
```

Preview:

require 'redcarpet'
markdown = Redcarpet.new("Hello World!")
puts markdown.to_html

Horizontal Rules

HTML Tag: <hr /> Places three or more hyphens (-), asterisks (*), or underscores (_) on a line by themselves. You may use spaces between the hyphens or asterisks.

Code:

* * *
***
*****
- - -
---------------------------------------
___

Preview:

Table

HTML Tag: <table>

It's an extension.

Separates column by pipe (|) and header by dashes (-), and uses colon (:) for alignment.

The outer pipes (|) and alignment are optional. There are 3 delimiters each cell at least for separating header.

Code:

| Left | Center | Right |
|:-----|:------:|------:|
|aaa   |bbb     |ccc    |
|ddd   |eee     |fff    |

 A | B
---|---
123|456


A |B
--|--
12|45

Preview:

Left	Center	Right
aaa	bbb	ccc
ddd	eee	fff

A	B
123	456

A	B
12	45

Span Elements

Links

HTML Tag: <a>

Markdown supports two style of links: inline and reference.

Inline

Inline link format like this: [Link Text](URL "Title")

Title is optional.

Code:

This is [an example](http://example.com/ "Title") inline link.

[This link](http://example.net/) has no title attribute.

Preview:

This is an example inline link.

This link has no title attribute.

If you’re referring to a local resource on the same server, you can use relative paths:

Code:

See my [About](/about/) page for details.

Preview:

See my About page for details.

Reference

You could predefine link references. Format like this: [id]: URL "Title"

Title is also optional. And the you refer the link, format like this: [Link Text][id]

Code:

[id]: http://example.com/  "Optional Title Here"
This is [an example][id] reference-style link.

Preview:

This is an example reference-style link.

That is:

Square brackets containing the link identifier (not case sensitive, optionally indented from the left margin using up to three spaces);
followed by a colon;
followed by one or more spaces (or tabs);
followed by the URL for the link;
The link URL may, optionally, be surrounded by angle brackets.
optionally followed by a title attribute for the link, enclosed in double or single quotes, or enclosed in parentheses.

The following three link definitions are equivalent:

Code:

[foo]: http://example.com/  "Optional Title Here"
[foo]: http://example.com/  'Optional Title Here'
[foo]: http://example.com/  (Optional Title Here)
[foo]: <http://example.com/>  "Optional Title Here"

Uses an empty set of square brackets, the link text itself is used as the name.

Code:

[Google]: http://google.com/
[Google][]

Preview:

Google

Emphasis

HTML Tags: <em>, <strong>

Markdown treats asterisks (*) and underscores (_) as indicators of emphasis. One delimiter will be <em>; *double delimiters will be <strong>.

Code:

*single asterisks*

_single underscores_

**double asterisks**

__double underscores__

Preview:

single asterisks

single underscores

double asterisks

double underscores

But if you surround an * or _ with spaces, it’ll be treated as a literal asterisk or underscore.

You can backslash escape it:

Code:

\*this text is surrounded by literal asterisks\*

Preview:

*this text is surrounded by literal asterisks*

Code

HTML Tag: <code>

Wraps it with backtick quotes (`).

Code:

Use the `printf()` function.

Preview:

Use the printf() function.

To include a literal backtick character within a code span, you can use multiple backticks as the opening and closing delimiters:

Code:

``There is a literal backtick (`) here.``

Preview:

There is a literal backtick (`) here.

The backtick delimiters surrounding a code span may include spaces — one after the opening, one before the closing. This allows you to place literal backtick characters at the beginning or end of a code span:

Code:

A single backtick in a code span: `` ` ``

A backtick-delimited string in a code span: `` `foo` ``

Preview:

A single backtick in a code span: `

A backtick-delimited string in a code span: `foo`

Images

HTML Tag: <img />

Markdown uses an image syntax that is intended to resemble the syntax for links, allowing for two styles: inline and reference.

Inline

Inline image syntax looks like this: ![Alt text](URL "Title")

Title is optional.

Code:

![Alt text](/path/to/img.jpg)

![Alt text](/path/to/img.jpg "Optional title")

Preview:

That is:

An exclamation mark: !;
followed by a set of square brackets, containing the alt attribute text for the image;
followed by a set of parentheses, containing the URL or path to the image, and an optional title attribute enclosed in double or single quotes.

Reference

Reference-style image syntax looks like this: ![Alt text][id]

Code:

[img id]: url/to/image  "Optional title attribute"
![Alt text][img id]

Preview:

Strikethrough

HTML Tag: <del>

It's an extension.

GFM adds syntax to strikethrough text.

Code:

~~Mistaken text.~~

Preview:

~~Mistaken text.~~

Miscellaneous

Automatic Links

Markdown supports a shortcut style for creating “automatic” links for URLs and email addresses: simply surround the URL or email address with angle brackets.

Code:

<http://example.com/>

<address@example.com>

Preview:

http://example.com/

address@example.com

GFM will autolink standard URLs.

Code:

https://github.com/emn178/markdown

Preview:

https://github.com/emn178/markdown

Backslash Escapes

Markdown allows you to use backslash escapes to generate literal characters which would otherwise have special meaning in Markdown’s formatting syntax.

Code:

\*literal asterisks\*

Preview:

*literal asterisks*

Markdown provides backslash escapes for the following characters:

Code:

\   backslash
`   backtick
*   asterisk
_   underscore
{}  curly braces
[]  square brackets
()  parentheses
#   hash mark
+   plus sign
-   minus sign (hyphen)
.   dot
!   exclamation mark

Inline HTML

For any markup that is not covered by Markdown’s syntax, you simply use HTML itself. There’s no need to preface it or delimit it to indicate that you’re switching from Markdown to HTML; you just use the tags.

Code:

This is a regular paragraph.

<table>
    <tr>
        <td>Foo</td>
    </tr>
</table>

This is another regular paragraph.

Preview:

This is a regular paragraph.

This is another regular paragraph.

Note that Markdown formatting syntax is not processed within block-level HTML tags.

Unlike block-level HTML tags, Markdown syntax is processed within span-level tags.

Code:

<span>**Work**</span>

<div>
    **No Work**
</div>

Preview: