I was born into a version of the internet that already felt fully formed.
By the time I started using it seriously, the dominant platforms were already established: algorithmic feeds, centralized social networks, and applications designed around constant updates and notifications. That was simply the baseline.
Because of that, I never lived the earlier internet. I didn’t experience RSS when it was mainstream, I didn’t use mailing lists as my primary communication layer, and I didn’t grow up with tools like Emacs as part of a standard workflow. I encountered them later, as historical artifacts that were still quietly functional.
And that timing changes everything.
Discovering systems that were never “new” to me
When I first encountered RSS, it didn’t feel nostalgic. It felt unfamiliar. Almost counterintuitive.
I started using a self-hosted instance of FreshRSS, not because it reminded me of a past version of the web, but because it solved a present problem: information overload without structure.
What surprised me was not that it was simple, but that it felt complete. There was no sense that something was missing. No recommendation engine, no ranking system trying to optimize my attention. Just a direct relationship between sources and reader.
That simplicity didn’t feel like minimalism. It felt like removal of unnecessary assumptions.
Learning tools without the cultural context
The same happened with Emacs.
I didn’t grow up with it. I didn’t see it evolve. I encountered it in its modern form, already shaped by decades of development, plugins, and community conventions.
And yet, what stood out immediately was not its age, but its consistency.
Emacs doesn’t behave like a typical application. It behaves like an environment that you gradually shape. With distributions like Doom Emacs, that environment becomes more structured, but the core idea remains: the tool does not define your workflow—you do.
That is a very different assumption from most modern software.
Reading as an intentional act again
Using Elfeed reinforced that shift.
Reading RSS inside Emacs is not about consumption efficiency. It is about removing everything that competes with attention.
There is no feed designed to keep me scrolling. No interface trying to predict what I want next. Just a list of entries that I explicitly chose to follow.
Because I did not grow up with RSS, I don’t associate it with “going back” to anything. Instead, it feels like discovering a different set of design choices that were never part of my default experience.
Communication systems that don’t try to be platforms
The same pattern appears again with email and mailing lists.
I didn’t experience mailing lists as a primary communication medium. My default expectation was always platform-based messaging: centralized systems, profiles, and interfaces designed around immediacy.
But mailing lists operate differently. There is no feed optimized for engagement. No hidden ordering of messages. Everything is delivered as plain, structured conversation.
This is also where systems like SourceHut become interesting. They don’t try to abstract communication into a platform layer. Instead, they lean directly on existing primitives like email and patches, treating them as first-class workflows.
The result is slower communication, but also more transparent communication. Nothing is hidden behind an interface designed to shape behavior.
Reclaiming ownership with static sites
This entire blog is another example. It is built with Hugo, a static site generator.
For a long time, the easiest way to publish something online was to put it on a platform owned by someone else. You got an audience and an editor, but you gave up control over the presentation, the longevity, and the underlying data.
A static site is the exact opposite. It is just HTML, CSS, and Markdown. It doesn’t rely on a database that might become corrupted, or a platform that might change its business model tomorrow.
There is a quiet but growing movement around “Digital Gardens” and personal websites—spaces that are curated and owned by the author, rather than optimized for algorithmic discovery. Writing in plain text and compiling to static files feels less like creating content and more like building an archive.
The self-hosting mindset
Underlying many of these tools is the philosophy of self-hosting.
Using FreshRSS wasn’t just about the RSS protocol; it was about the realization that I could run the software myself. Instead of paying with my data or attention for a “free” Software as a Service (SaaS), I could rent a small server and deploy the tools I needed.
This changes the relationship you have with your software. When you host it, you are responsible for it, but you also have absolute sovereignty over it. It doesn’t try to upsell you, it doesn’t pivot to a new feature set you didn’t ask for, and it doesn’t shut down when a startup runs out of funding.
It is a heavier burden, but it is also a declaration of independence from the constant churn of the modern internet.
A different relationship with “old” technology
What makes all of this interesting is that I don’t experience it as nostalgia.
I don’t remember a time when these tools were the norm. I only encounter them as systems that still function, still evolve, and still serve specific purposes better than many modern alternatives.
That distance changes how I see them. They are not “old tools I used to use.” They are simply tools that exist, with different design assumptions.
And because I didn’t grow up with them, I am not comparing them emotionally to what came before. I am comparing them structurally to what I use now.
What these systems have in common
Over time, a pattern becomes visible across all of them.
They tend to assume:
- that communication does not need to be instantaneous
- that information should remain readable without mediation
- that users can control their own information flow
- that systems should be inspectable rather than opaque
- that simplicity is a long-term advantage, not a limitation
None of these ideas are inherently “old.” But they were implemented more consistently in earlier internet systems than in many modern ones.
Closing thoughts
The interesting part is not that these tools are old.
It is that they still work without needing to adapt to the assumptions of modern platform design.
Discovering them later in time creates a different perspective. There is no nostalgia involved, no sense of returning to something. Instead, there is a kind of structural clarity: realizing that the internet was not always built around attention, and does not have to be.
RSS, Emacs, mailing lists, SourceHut and static sites are not alternatives to modern tools because they are outdated. They are alternatives because they follow different principles.
And those principles are still valid
Comments
This blog uses a public mailing list for comments. Any message sent to the list will be publicly visible. You can join the discussion by viewing the archive or replying via email.