Matheus de Camargo Marques

Posted on Sep 6

The End of WhatsApp, Telegram, Discord, and Slack: Why They're Already Dead (And You Don't Know It)

#erlang #elixir #whatsapp #telegram

The End of WhatsApp, Telegram, Discord, and Slack: Why They're Already Dead (And You Don't Know It)

"Centralization is a gilded prison. The key is in your hand — you just need to use it."

🤔 Before You Read On, Answer This:

Why does Discord store all your messages in plain text on their servers, even in DMs?
Why does Slack charge $12.80 per user/month for something you could run for free?
Why can WhatsApp — which has "end-to-end encryption" — ban your account and make you lose all your contacts and history?
Why doesn't Telegram encrypt group chats by default, and why is that a secret they're hiding?
Why do none of these apps work if the internet goes down — even if you're right next to the person?
Why are all your usage metadata (who you talk to, when, for how long) sold or used to train AI?
Why can't you run your own server like you can with email?

The answer is simple: they are digital prisons. And you're paying — with money, privacy, and freedom — to live in them.

📉 The 4 Communication Giants: A Destructive Analysis

1. WhatsApp (Meta) — The Encryption Farce

Encryption? Yes, but... Meta is deploying LLMs that need to read your messages to function. "End-to-end encryption" becomes "encryption until Meta's AI gets it."
Metadata is gold: who, when, where, for how long — everything goes to Meta's servers. Even with E2EE, metadata is not encrypted.
Easy censorship: if the government orders it, WhatsApp blocks your number. You lose all contacts and groups.
Zero-click vulnerabilities: in 2025, researchers found flaws that allow hacking iPhones and Macs without you clicking anything.
100,000 accounts breached per day: WhatsApp's former CSO publicly admitted the app cannot handle the scale of attacks.

Bottom line: WhatsApp is a backdoor for Meta into your pocket.

2. Telegram — The "Secure" One That Isn't

Cloud chats are plain text: only "secret chats" have E2EE. Your family, work, friends groups — all accessible to Telegram's servers.
Closed servers: nobody knows what really happens inside.
Vulnerable MTProto protocol: researchers found flaws allowing MitM (Man-in-the-Middle) attacks during the key handshake.
Documented censorship: Russia blocked voice calls on Telegram in 2025. Telegram couldn't stop it.

Bottom line: Telegram is a centralized server with a security veneer.

3. Discord — The Giant That Stores Everything in Plain Text

No E2EE encryption — not even in DMs. All messages sit in plain text on Discord's servers.
Moderators have access: they can read your DMs at any time.
Data sold for AI training: Discord has already admitted to using user data to improve their models.
Ban = total loss: if your server or account gets banned, you lose all history.
Political censorship: Discord has banned servers for "hate speech" with no appeal.

Bottom line: Discord is a centralized chat service that treats your data as trash.

4. Slack — The Most Expensive and Least Secure

Costs $12.80 per user/month — and you still don't get E2EE.
Messages in plain text on Salesforce's servers.
Admins can read everything: even messages in private channels.
Closed source: nobody can audit what happens to your data.
Total dependency: if Slack goes down (and it has, multiple times), your company stops.

Bottom line: Slack is a safe without a lock that you pay to use.

🚫 The Common Problem: Centralized Servers

All these apps share one characteristic: they depend on centralized servers.

If the server goes down, you can't talk to anyone.
If the government wants to censor, they block the server.
If the company wants to read your messages, they're there, in plain text.
If you get banned, you lose everything.

This isn't communication. It's conversation rental.

🔓 The Only Solution: Pure P2P Communication

The only way to avoid censorship, mass surveillance, and corporate dependency is to eliminate central servers.

Messages need to go directly from one device to another, without passing through any intermediary. That's a P2P (peer-to-peer) network.

What Already Exists? (And Why It Doesn't Work)

Matrix: decentralized, but depends on servers you host. Not pure P2P.
Signal: excellent encryption, but completely centralized at the Signal Foundation.
Bitchat (Jack Dorsey): P2P via Bluetooth, but only works within a few meters.
Xeres: P2P, but based on GNU Net — archaic interface and low adoption.

None of these offer global scalability, low latency, and internet-based traffic simultaneously.

⚡ The Silent Revolution: Erlang + BitTorrent = Unbreakable Messenger

What if you could build a messaging app that:

Has no servers — every user is a node.
Doesn't require phone number or email — your identity is an Ed25519 public key.
Cannot be censored — no central point to block.
Works anywhere — UDP with hole-punching (like BitTorrent).
Scales to billions — running on the BEAM (the same VM as WhatsApp).
Is encrypted by default — Noise X25519 with forward secrecy.
Is free — no monthly fees, no paid plans.

This isn't science fiction. This is what I built with JusrisOs.Peer.DistCarrier.

Technical Architecture (Simplified)

+-----------------------------------------------------------------------+
|                        Your Messaging App (Elixir)                    |
+-----------------------------------------------------------------------+
|
[:gen_server / :gen_statem]
|
+-----------------------------------------------------------------------+
|                    JusrisOs.Peer.DistCarrier                          |
|                   (P2P Transport Layer)                              |
|                                                                       |
|   +-------------------+                     +---------------------+   |
|   |  Loopback TCP    | <--- Proxy Pump ---> |  Yamux Stream       |   |
|   +-------------------+                     +---------------------+   |
+-----------------------------------------------------------------------+
|
[Noise X25519 Handshake]
|
[Synchronous UDP Hole Punch]
|
+-----------------------------------------------------------------------+
|                   Mainline DHT (BitTorrent)                          |
|              Peer Discovery + Routing                                |
+-----------------------------------------------------------------------+

How it works in practice:

Discovery: via DHT (Mainline DHT from BitTorrent) — no servers.
Connection: UDP hole-punching to traverse NATs and firewalls — no open ports.
Security: Noise X25519 handshake with forward secrecy — military-grade encryption.
Transport: multiplexes multiple conversations over a single UDP connection via Yamux — efficient.
Delivery: messages go directly from peer to peer — no intermediaries.

Result:

No censorship: no central server to take down.
No surveillance: your metadata doesn't exist anywhere.
No accounts: your identity is your public key — no email or phone needed.
No fees: you pay nothing to anyone.
Scalability: the BEAM has already proven it can scale to 900 million users.

📊 Destructive Comparison

Feature	WhatsApp	Telegram	Discord	Slack	P2P (Elixir+DHT)
Default E2EE	✅	❌	❌	❌	✅
Centralized servers	✅ (Meta)	✅	✅	✅	❌
Metadata exposed	✅	✅	✅	✅	❌
Censorable by governments	✅	✅	✅	✅	❌
Requires phone/email	✅ (tel)	✅ (tel)	✅ (email)	✅ (email)	❌ (public key)
Open server code	❌	❌	❌	❌	✅ (each node)
Scales to billions	✅	✅	❌	❌	✅ (BEAM)
Operational cost	High	High	High	Very high	Zero
Works without internet?	❌	❌	❌	❌	❌ (BLE fallback possible)
Data ownership	Meta	Telegram	Discord	Salesforce	You

🛠️ How Is This Possible? (Code)

The heart of the system is an Elixir module that implements a custom distribution carrier for the BEAM:

defmodule JusrisOs.Peer.DistCarrier do
  @moduledoc """
  Carrier that replaces TCP with Noise + Yamux over UDP.
  """

  def setup(node, _type, _my_node, _long, _creation) do
    # Discover peer via DHT
    {:ok, %{host: host, port: port}} = try_dht_discover(node_to_id(node))

    # Synchronous hole-punch
    sync_hole_punch({host, port})

    # Noise handshake
    me = Identity.load_or_create()
    peer_pub = pubkey_for_node(node)
    {:ok, sess} = Transport.connect_with_fallback(me, {host, port}, peer_pub)

    # Create tunnel
    setup_tunnel(sess, node)
  end

  defp proxy_loop(tcp_sock, sess, sid, node) do
    receive do
      {:tcp, ^tcp_sock, data} ->
        SecureSession.send_data(sess, sid, data)
        proxy_loop(tcp_sock, sess, sid, node)
      {:yamux_data, ^sid, data} ->
        :gen_tcp.send(tcp_sock, data)
        proxy_loop(tcp_sock, sess, sid, node)
      {:tcp_closed, ^tcp_sock} ->
        :ets.delete(@ets, node)  # automatic cleanup
        :gen_tcp.close(tcp_sock)
    end
  end
end

With < 300 lines of Elixir, you have a distributed P2P cluster that can be the foundation of a global messenger.

🧠 Why This Is a Revolution

WhatsApp proved the BEAM scales to 900 million users with 50 engineers.
BitTorrent proved DHT + hole-punching connects billions of devices without servers.
Noise + Yamux proved that efficient encryption and multiplexing are possible.

Combining these three technologies is the next logical step.

We no longer need central servers. We no longer need corporations controlling our conversations. We no longer need to accept that a government can cut off our communication with a stroke of a pen.

We can build a global, free, private, and unbreakable messenger.

📌 What You Can Do Right Now

Stop accepting the status quo. Question why you use WhatsApp, Telegram, Discord, and Slack.
Support decentralized alternatives. Matrix, Signal (despite being centralized), and P2P projects like the one described here.
Learn Elixir/Erlang. It's the language that already scales to billions.
Contribute. The DistCarrier code is open. Help build the messenger of the future.

🧠 Food for Thought

"The internet was designed to be decentralized. We centralized it for convenience. It's time to decentralize it back."

WhatsApp, Telegram, Discord, and Slack are giants, but giants can fall. Tech history is full of examples: MySpace, Orkut, ICQ, MSN Messenger, Skype.

The next giant could be decentralized. And it can be built with Elixir, Erlang, and BitTorrent.

The question isn't whether this will happen. It's when.

And if you want to be part of that change, the code already exists. The technology already exists. What's missing is will.

Author: Matheus de Camargo Marques – Brazil

📧 matheuscamarques@gmail.com

🔗 LinkedIn

Enjoyed the article? Share it. Question it. Build on it. The future of communication depends on us.

Top comments (1)

Mathieu Kerjouan • Sep 7

Interesting. In fact, I was thinking on something similar few years ago, and I found SimpleXChat. The protocol they created is stable and already used by thousand (if not more) people around the world. The only drawback is the performance. Anyway, it could be nice to have this protocol running on the BEAM. ;)