Disconnected gemlogs and a proposal for a Gemlog Sphere

Posted Tue 9 Mar, 2021.

Last night I spent 20 minutes putting together a hacky Python script to generate an Atom feed automatically when my gemlog index changes, just before rsync pushes the content to the server. I tend to use RSS instead of Atom, but I decided to go with whatever is more used around here.

The idea to make the gemlog index easy to parse so it can be used as a feed is brilliant, but I've found that the search engines using GUS software can list the feeds they know, and that requires a real feed.

list of known Gemini feeds on geminispace.info

Because I found that list very useful to discover new gemlogs to read, I wanted to have an Atom feed as well.

I like the "low-tech" aspect of Gemini, how a simply defined index page for a Gemini log can be used as a replacement for a more complex format, but it comes with some limitations. Probably the most apparent for me right now is that the Gemini space is made of mostly disconnected gemlogs.

For example: if I write an entry referring to content from another gemlog, that author doesn't know about my mention. Which is a problem that blogs from the WWW have, and tried to solve in different ways.

You could contact authors to inform them about your post, but in practice is difficult because not all the gemlogs provide contact details, or the contact details may not be useful (e.g. you may not have a Mastodon account).

One of the easy solutions in Gemini is using the "search backlink" feature of GUS based search engines, but it has a few problems:

It depends on the search engine knowing about all the gemlogs.

Gemini crawlers aren't efficient because the protocol doesn't support "conditional requests" (for example: give me this resource if it was modified after this date/time).

It is centralized and controlled by the search engine.

So I've been thinking about potential solutions, easy to integrate in our "low-tech" gemlogs, and using as reference some ideas that were tried in blogs (e.g. trackbacks).

Enter the Gemlog Sphere

This should be a simple CGI that enables the following:

Each gemlog has its own sphere.

A member of that sphere can send a link to a page that in the gemlog.

The gemlog can show a list of links coming from its sphere.

This means that if my gemlog is in the sphere of a gemlog I cited in a post, I can automatically send a notification with a link to my post.

This requires:

Each gemlog has an unique base URL.

These unique base URLs are shared between authors so they can be added to each gemlog sphere.

For example, we have a gemlog and we add a FOO gemlog to our sphere. In sphere.gmi:

That Gemini file could be public as well, so it could have header and other text. The important bits for the CGI are the gemlog URLs.

Then we would have a CGI that allows the following operations:

When a linking request is made, this list of requirements must be satisfied:

The given URL links to a page in our gemlog.

EXT-URL checks with a base URL of our sphere (e.g. gemini://FOO/gemlog/external-post.gmi).

If EXT-URL is not member of our sphere, we can respond with a page showing contact details (email preferred).

EXT-URL is online and has a link to our URL in its body.

Some basic anti-spam measures are applied.

Finally there must be a way to discover the "sphere" URL associated to a gemlog post. For that I suggest a query parameter "ref=sphere" is included in the sphere URLs, so it can be found automatically. This requires that at least one sphere URL exists in the gemlog post (could be a link to the external links pointing to the post).

We should have a local tool to manage our sphere:

Send links: we provide an URL in our gemlog and a target, the target is checked to see if it has a "ref=sphere" URL so we can find the sphere CGI. This could be automated when a new post is published.

List and remove links filtering by gemlog, URL, etc.

Check for broken links, with options to remove them.

This looks pretty much as trackbacks. The list of gemlogs in the sphere could be removed and we would accept links from anybody -which led to spam in the WWW-.

It is still reasonably "low-tech", only needs links to a CGI in an otherwise static gemlog, and works completely distributed.

When I implement some sort of CGI support on my server, this sounds like a nice little CGI to write.

Back to the index

Back home