I think the main reason that Discord is as popular and prevalent as it is is that it’s so incredibly easy to just set up a new server with all the bells and whistles. That is the main reason why a self-hosted discord will never take off: nobody wants to go through the time and effort to set up and maintain their own server, when you could just click a few buttons to set it up and have to never worry about maintenance.

The protocol is secondary in this regard, i think. I’m not saying it’s trivial to build something like what discord has, but it is doable. What’s significantly more challenging is funding a seemingly unlimited service that allows for not just chat, but file uploads, voice/video chat, et cetera for free. And as much as it sucks, I don’t know if an open source model is going to realistically allow for something like that in the word that we live in.

Do you have a source for that claim?

Mainly from firsthand discussions, but there is also this:

https://cadence.moe/blog/2020-06-06-why-you-shouldnt-trust-discord#untrustworthy-staff

Discord does not go out of their way to detect client mods, so you can usually get away with them unless you’re doing something like mass joining servers faster than a human could. However, you will most likely be banned or reprimanded if a staff member happens to see you publicly post a screenshot from an obviously modified client.

I saw an exchange where a staff member saw a modified screenshot, and banned the person’s entire account, then unbanning it after 2 minutes, as a joke. I don’t think this is a very funny joke, and it shouldn’t be taken lightly. This shows that staff have the power to do whatever they want, and there don’t seem to be any review processes about reasonable use of power.

I have been threatened with a Discord account ban for bringing up the existence of a modified official client in the Discord official support server.

Modified, here, means that I used Electron’s devtools to fix a bug in my local copy of Discord so it didn’t eat my battery.

We keep an eye on chathistory but there are some snags. It requires that we hold a lot more data, and how we do that in a way that is sensible and private isn’t straightforward, but we have been thinking about how it might be solved. We’re open to it, and just thinking about the different ways it could work.

For example, a general position held by IRC users is that if you say something when someone’s not around, they won’t ever see it. This is one of the issues that we had with the matrix bridge - it was possible for users to retroactively see discussions they weren’t part of.

The same would be true of chathistory, and it changes the character of IRC enormously. Now, it’s no longer the case that what you said to a particular audience will stay in that audience. What you said about that less-than-perfect friend you know from another channel might suddenly be sent to them if they joined your channel some time later, entirely innocently.

I don’t mind a learning curve, but it should have some kind of payoff.

Ah, I must not have read that thoroughly! Thanks.

But yeah. Discord is generally deeply uncomfortable structureally. Also, maybe I misremember this one, but I seem to remember that your admins can read the private messages you have between users on “their server”, and that the UI doesn’t make this clear is a “decision”

Hell, here’s your first cut, hastily adapted from here and hacked up with bit of Claude and some elbow grease because Claude doesn’t Elixir super well yet:

Application.put_env(:example, Example.Endpoint,
  http: [ip: {127, 0, 0, 1}, port: 5001],
  server: true,
  live_view: [signing_salt: "aaaaaaaa"],
  secret_key_base: String.duplicate("a", 64),
  pubsub_server: Example.PubSub
)

Mix.install([
  {:plug_cowboy, "~> 2.5"},
  {:jason, "~> 1.0"},
  {:phoenix, "~> 1.7.2", override: true},
  {:phoenix_live_view, "~> 0.18.18"},
  {:phoenix_pubsub, "~> 2.1"}
])

defmodule Example.ErrorView do
  def render(template, _), do: Phoenix.Controller.status_message_from_template(template)
end

defmodule Example.ExampleLive do
  use Phoenix.LiveView, layout: {__MODULE__, :live}
  @topic "chat"
  def mount(_params, _session, socket) do
    if connected?(socket), do: Phoenix.PubSub.subscribe(Example.PubSub, @topic)
    # we could pull the username from params, then check that it's signed, and redirect otherwise
    {:ok, socket
          |> assign(username: "VvV", message: "")
          |> stream(:messages, [])}
  end

  def render("live.html", assigns) do
    ~H"""
    <script src="https://cdn.jsdelivr.net/npm/phoenix@1.7.2/priv/static/phoenix.min.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/phoenix_live_view@0.18.18/priv/static/phoenix_live_view.min.js"></script>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha1/dist/css/bootstrap.min.css" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha1/dist/js/bootstrap.bundle.min.js"></script>
    <script>
      let liveSocket = new window.LiveView.LiveSocket("/live", window.Phoenix.Socket)
      liveSocket.connect()
    </script>
    <h1>Lobsters chat</h1>
    <%= @inner_content %>
    """
  end

  def render(assigns) do
    ~H"""
    <div class="container">
      <div class="row">
        <div class="col-md-8 offset-md-2">
          <h2 class="text-center mb-4">Chat Room</h2>
          <div id="chat-messages" class="border p-3 mb-3" style="height: 400px; overflow-y: auto;">
            <div id="messages" phx-update="stream">
              <%= for {id, message} <- @streams.messages do %>
                <div id={id} class="mb-2">
                  <small class="text-muted">
                  <b> <%= message.username %> </b>
                  <%= message.timestamp %>
                  </small>
                  <p class="mb-1"><%= message.content %></p>
                </div>
              <% end %>
            </div>
          </div>
          <form phx-submit="send" class="d-flex">
            <input type="text" name="message" value={@message} placeholder="Type your message..." class="form-control me-2" phx-change="change" />
            <button type="submit" class="btn btn-primary">Send</button>
          </form>
        </div>
      </div>
    </div>
    """
  end

  def handle_event("send", %{"message" => message}, socket) when message != "" do
    message = %{id: System.unique_integer([:positive]), username: socket.assigns.username, content: message, timestamp: NaiveDateTime.local_now()}
    Phoenix.PubSub.broadcast(Example.PubSub, @topic, {:new_message, message})
    {:noreply, assign(socket, :message, "")}
  end

  def handle_event("send", _params, socket), do: {:noreply, socket}
  def handle_event("change", %{"message" => message}, socket), do:
    {:noreply, assign(socket, :message, message)}

  def handle_info({:new_message, message}, socket), do:
    {:noreply, stream_insert(socket, :messages, message)}
end

defmodule Example.Router do
  use Phoenix.Router
  import Phoenix.LiveView.Router

  pipeline :browser, do: plug(:accepts, ["html"])
  scope "/", Example do
    pipe_through(:browser)
    live("/", ExampleLive, :index)
  end
end

defmodule Example.Endpoint do
  use Phoenix.Endpoint, otp_app: :example
  socket("/live", Phoenix.LiveView.Socket)
  plug(Example.Router)
end

{:ok, _} = Supervisor.start_link([Example.Endpoint,{Phoenix.PubSub, name: Example.PubSub},], strategy: :one_for_one)
Process.sleep(:infinity)

libera 100% needs to incorporate CHATHISTORY. I run https://pico.sh and ask users to navigate to our IRC channel. There are so many people that join/leave because they show up to a channel with 0 chats and think it’s dead.

Discord/slack/etc are stickier because when you join a server it keeps you logged in and you can see previous chats.

Asking users to setup a bouncer is a huge wall to overcome for newbies, especially when these other chat apps are so seamless.

Further, getting push notifications is also a major problem, something that is automatic with other chat apps.

Private channels is also a massive pain to manage on libera. There are so many flags and things to “get right” that makes it prohibitive to use in any meaningful way especially compared to how stupid simple it is in slack/discord.