Today, I Learned about Project Gemini

created May 13, 2020

This is the most interesting idea that I have encountered thus far in 2020. No, it's not about NASA rebooting one of its manned space flight programs.

While browsing Hacker News late last night, actually, very early this morning, I learned about Project Gemini and Castor. I stopped reading sooner than I wanted because I knew that if I kept going, then I would be up all night.

About Gemini:

Gemini is a new, collaboratively designed internet protocol, which explores the space inbetween gopher and the web, striving to address (perceived) limitations of one while avoiding the (undeniable) pitfalls of the other.

About Castor:

A graphical client for plain-text protocols written in Rust with GTK. It currently supports the Gemini, Gopher and Finger protocols.

The Project Gemini website hosts the following three document pages, and each appears to be written in plain, raw, Markdown text.

From the FAQ page:

Gemini is a new application-level internet protocol for the distribution of arbitrary files, with some special consideration for serving a lightweight hypertext format which facilitates linking between files.

Gemini is intended to be simple, but not necessarily as simple as possible. Instead, the design strives to maximise its "power to weight ratio", while keeping its weight within "acceptable" limits. Gemini is also intended to be very privacy conscious.

You may think of Gemini as "the web, stripped right back to its essence" or as "Gopher, souped up and modernised a little", depending upon your perspective.

Gemini is not intended to replace either Gopher or the web, but to co-exist peacefully alongside them as one more option which people can freely choose to use if it suits them. In the same way that many people currently serve the same content via gopher and the web, people will be able to "bihost" or "trihost" content on whichever combination of protocols they think offer the best match to their technical, philosophical and aesthetic requirements and those of their intended audience.

Gemini strives for simplicity of client implementation. Modern web browsers are so complicated that they can only be developed by very large and expensive projects. This naturally leads to a very small number of near-monopoly browsers, which stiffles innovation and diversity and allows the developers of these browsers to dictate the direction in which the web evolves.

Gemini aims to be simple, but not too simple.

A [Gemini] client comfortable for daily use which implements every single protocol feature should be a feasible weekend programming project for a single developer.

It's debatable to what extent these goals have been met. Experiments suggest that a very basic interactive client takes more like a minimum of 100 lines of code, and a comfortable fit and moderate feature completeness need more like 200 lines. But Gemini still seems to be in the ballpark of these goals.

Gemini is designed with an acute awareness that the modern web is a privacy disaster, and that the internet is not a safe place for plaintext. Things like browser fingerprinting and Etag-based "supercookies" are an important cautionary tale: user tracking can and will be snuck in via the backdoor using protocol features which were not designed to facilitate it. Thus, protocol designers must not only avoid designing in tracking features (which is easy), but also assume active malicious intent and avoid designing anything which could be subverted to provide effective tracking. This concern manifests as a deliberate non-extensibility in many parts of the Gemini protocol.

I emphasized my favorite part of this next paragraph.

The "first class" application of Gemini is human consumption of predominantly written material - to facilitate something like gopherspace, or like "reasonable webspace" (e.g. something which is comfortably usable in Lynx or Dillo). But, just like HTTP can be, and is, used for much, much more than serving HTML, Gemini should be able to be used for as many other purposes as possible without compromising the simplicity and privacy criteria above. This means taking into account possible applications built around non-text files and non-human clients.

I wish that Gemini supported image embedding as the only heavy bit of content.

The "native content type" of Gemini (analogous to HTML for HTTP(S) or plain text for Gopher) never requires additional network transactions (there are no in-line images, external stylesheets, fonts or scripts, no iframes, etc.). This allows for quick browsing even on slow connections and for full awareness of and control over which hosts connections are made to.

The Links2 web browser does not support stylesheets, fonts, scripts, iframes, etc. But Links2 does support image embedding, and Links2 supports color and formatting display if the HTML page uses old techniques, such as tables and applying colors to the HTML body tag.

I created this page to make it display similarly in Links2 and in one of the modern web browsers. Normally, my default pages at display much differently in Links2, compared to NetSurf and more so-called modern web browsers, since Links2 does not support CSS.

This is a great article that I read in the summer of 2016, and it inspired me to start up my test Gopher site at gopher:// .


In 1993, Gopher was still far more popular than the World Wide Web, and Gopher traffic grew by 997 percent. But the Web was starting to catch up — that year, it grew by 341,634 percent.

When the web added the HTML image tag, that probably changed things.

Soon enough, the Web did have pictures and was available on more platforms. In 1993, the first popular Web browser, Mosaic, was introduced for sale, breaking the commercial taboo of the internet and suggesting — to McCahill at least — that tech investors had taken sides. “The fix was in,” he says.

In 1994, modem speeds doubled, and the interminable rendering of images on the Web — once dubbed the World Wide Wait — greatly accelerated. PCs began to be sold with these faster modems built in. To anyone looking for a simple, even crude explanation for the Web’s rise, this is it: the ability to view a reasonable facsimile of a naked woman in the privacy of your own home. “That’s what came to drive a lot of the internet,” Alberti says. “Porn.”

Maybe it's good that Gemini mimics Gopher by not supporting only text.

The Internet Gopher, with his text-only menu and gloss-less, institutional mien, couldn’t keep up. He had fallen off the wave, and almost overnight was revealed as a buck-toothed square, ignored by the girls on the beach, his surfboard held together by duct tape. “Obsolesced,” as one observer put it in 1994. A has-been.

For McCahill, the realization happened on the street. “I saw a URL on the side of a bus,” he says. “That’s when I knew the Web was all about advertising. Gopher was not good for advertising. I knew it would start winding down.”

When the Common Gateway Interface tech was added to the web server spec, that enabled the development of more dynamic websites. I created my first CGI program in November 1996.

The tech created in the early 1990s that may have ultimately ruined the original spirit of the web includes: the HTML image tag, CGI on the server, and JavaScript on the client side.

I have to admit though that I have always enjoyed creating server-side programs in CGI or something similar to create web apps (via the server and not the client) that produce dynamically-generated web pages.

Back to the Gemini spec. This part discusses why Gemini requires TLS.

Old machines are awesome, and keeping them running, online and useful for as long as possible is an awesome thing to do. But it also makes no sense for the vast majority of internet users to sacrifice any and all privacy protection to facilitate this. Remember, though, that Gemini does not aim to replace Gopher, so the retro-compatible internet is not directly endangered by it. In fact, people serving content via Gopher right now are strongly encouraged to start also serving that same content via Gemini simultaneously. Retrocomputing fans can continue to access the content via Gopher, while modern computer users who wish to can switch to Gemini and reap some beneits.

The admin tax exists with maintaining TLS certificates.

Related May 13, 2020 post:

"The modern HTTPS world has no place for old web servers"

I thought of my January 2019 post.

"Markdown-only Web Browser"

Instead of creating HTML pages, websites would create plain text files that use simple Markdown formatting. A web browser would fetch the Markdown pages, and render them for display.

At the moment, I do not have a standalone, native, desktop browser app that does the above. I'm relying on web browser extensions.

Both extensions permit me to upload custom CSS, which allows me to display the Markdown files however I desire. If other websites published Markdown files, then those websites would be displayed according to my custom CSS.

Every web page for every website would look the same TO ME. It would be similar to using "reader mode" functionality that exists with some web browsers, which makes every web page look the same.

My proof of concept website exists at:

I even kicked around the ideas for a feed format, based upon Markdown.

During my reading of Project Gemini, I learned that the inventor of the project also created an XML Atom-based feed format and an aggregator.

Since my simplified website idea relied on plain, raw, Markdown text, I did not want a feed format to use XML nor JSON. I wanted the feed format to use Markdown too.

I like Aaron Swartz's sarcastic RSS 3.0 spec that I created in 2002.

A year or two ago, I created my own simple, web-based feed reading app. It processes XML RSS and Atom feeds. I'd like to add support for JSONFeed and the's h-feed formats. But I did add support for RSS 3.0. Rather than a joke, I find RSS 3.0 to be useful. It's easy for humans to read and for computer programs to parse.

RSS 3.0 inspired me to create a feed format in Markdown plain text.

On my new Linux laptop, the four main web browsers that I use include:

Pale Moon is my dominant web browser. I use Links2 occasionally and the other two infrequently.

Pale Moon does not support as many add-ons as Firefox. I have enjoyed using the uMatrix extension in Chrome and Firefox. A clone was made for Pale Moon, called eMatrix, which I rely on heavily.

The Markdown Viewer Webext for Firefox does not have a counterpart for Pale Moon. But for the Ungoogled Chromium web browser, I can install extensions, meant for Chrome. I installed Markdown Preview Plus in Ungoogled Chromium.

The Firefox Markdown converter only works on .md files. For the Chrome extension, the users can choose what extensions to convert, such as .md, .txt, .text, and a few more.

I used Ungoogled Chromium with the Markdown Preview Plus extension to read the Project Gemini web docs, and the browser extension converted the Markdown plain text to an HTML display. The Project Gemini docs appear the same as the pages on my test website, since I uploaded my own custom CSS to be used by the Markdown Preview Plus extension.

This is my post about Toledo area birdwatching locations, during the spring migration. It's stored in plain, raw, Markdown text and not HTML text. And this is how it looks when viewed in a Chrome-like web browser with the Markdown viewer extension.

my post about toledo area birdwatching locations

And the Project Gemini FAQ page displays the same way to me, since the doc pages use a smidgen of Markdown formatting.

gemini faq page

I thought maybe that Markdown was going to be the markup used by Project Gemini, and Gemini browser clients would convert the Markdown plain text into a formatted display for readers, but that's not the case, or it's not quite that way.

To install the Gemini, Gopher, and Finger client called Castor, I did the following:

curl --proto '=https' --tlsv1.2 -sSf | sh

git clone

cd castor

sudo apt install build-essential rustc cargo libgtk-3-dev libgdk-pixbuf2.0-dev libssl-dev

sudo make

sudo make install

I started Castor from the command prompt, and I entered the URL for my test Gopher site gopher:// and it worked !!!

Prior to Castor, the only Gopher clients that I had on my Linux laptop were the Lynx text-based web browser and the command-line utility cURL. Links2 does not support Gopher. I do not have the 1996 version of Mosaic installed, which I think still supported Gopher.

Before Firefox made changes to its add-on system or whatever, an add-on existed called Overbite that enabled Firefox to view Gopher sites. Overbite was not created for Firefox's new add-on system. Overbite nor anything similar does not exist for Pale Moon.

On my old iPhone, I use iGopher to view Gopher sites. In one of the above HN threads, I learned about another iOS Gopher client that requires at least iOS v9.0, but my old iPhone still runs iOS v8.x.

This is is a modern Gopher browser for iOS. Built from the ground up, it lets you access the wealth of data available via Gopher from your favorite devices.

Size 1.6 MB

Conversely, Firefox ...

Requires iOS 11.4 or later.

Size 84.2 MB

The wonderfully annoying modern web is complex and bloated because the modern web does too much. The great minds in tech should have created a new application layer protocol in the late 1990s or by 2000 called bloat://.

My website could have continued to exist on the real, original web. We could do our web reading with NetSurf.

Example websites:

Those sites can be read easily with Links2 and NetSurf. The browsers do not need to support JavaScript. We don't need to HTML5 nor CSS3 on the web.

Sophisticated web applications that permit users to perform tasks in private, such as banking, and horribly designed, reader-hostile websites, such as most media websites, would exist at bloat://.

Web Components, Progressive Web Apps, Web Assembly, and a thousand other interesting but ridiculously unnecessary technologies for WEB READING could exist in the Bloat browser.

Bloat sites:

The reason why we only have a few web rendering engines that support the modern web is because supporting the modern web is too complex.

If only a Web of Documents type of web existed, then we would probably have a large number of independent web rendering engines and web browsers that would differentiate from each other by offering additional features, such as user authoring tools, feed reading, and customization of the web reading experience.

The look of web pages should be decided by the READERS. When content comes down to our computers, the typography should be controlled by us.

Project Gemini supports the documents idea of Gopher. Yeah, a simplified web can co-exist alongside the massively bloated web, but maybe it shouldn't.

I guess that today's http/https is now bloat:// and Gemini is a slightly enhanced Gopher that is similar to the Web of Documents idea.

According to the Project Gemini spec, some Markdown-like markup is used as the Gemini markup, which is encouraging. Heading lines

Lines beginning with "#" are heading lines. Heading lines consist of one, two or three consecutive "#" characters, followed by optional whitespace, followed by heading text. The number of # characters indicates the "level" of header; #, ## and ### can be thought of as analogous to <h1>, <h2> and <h3> in HTML.

Heading text should be presented to the user, and clients MAY use special formatting, e.g. a larger or bold font, to indicate its status as a header (simple clients may simply print the line, including its leading #s, without any styling at all). However, the main motivation for the definition of heading lines is not stylistic but to provide a machine-readable representation of the internal structure of the document. Advanced clients can use this information to, e.g. display an automatically generated and hierarchically formatted "table of contents" for a long document in a side-pane, allowing users to easily jump to specific sections without excessive scrolling. CMS-style tools automatically generating menus or Atom/RSS feeds for a directory of text/gemini files can use first heading in the file as a human-friendly title. Unordered list items

Lines beginning with a * are unordered list items. This line type exists purely for stylistic reasons. The * may be replaced in advanced clients by a bullet symbol. Any text after the * character should be presented to the user as if it were a text line, i.e. wrapped to fit the viewport and formatted "nicely". Advanced clients can take the space of the bullet symbol into account when wrapping long list items to ensure that all lines of text corresponding to the item are offset an equal distance from the left of the screen.

Links, however, are created similar to how links are done in Gopher.

Lines beginning with the two characters "=>" are link lines, which have the following syntax:

=>[<whitespace>]<URL>[<whitespace><USER-FRIENDLY LINK NAME>]<CR><LF>

All the following examples are valid link lines:

=> gemini://
=> gemini:// An example link
=> gemini:// Another example link at the same host
=>gemini:// Yet another example link at the same host
=> foo/bar/baz.txt A relative link
=> gopher:// A gopher link

Note that link URLs may have schemes other than gemini://. This means that Gemini documents can simply and elegantly link to documents hosted via other protocols, unlike gophermaps which can only link to non-gopher content via a non-standard adaptation of the h item-type.

Clients can present links to users in whatever fashion the client author wishes.

The default view of Castor displays links as buttons, which is odd. Castor, however, provides some typographical customizations, but I don't know if it applies to link text display.

From the Castor page:

You can change some settings like initial URL, colors and delimiters for Headers, Lists, Text and Background. Edit ~/.config/castor/settings.toml and add the values you need.

Overall, I like Castor a lot.

The creator and maintainer of Gemini maintains his Gemini site here:


Howdy, I'm Solderpunk - founder and de facto BDFL of the Gemini protocol and the universe, Gopher phlogger and general grumpy digitial malcontent. This is where I "eat my own dogfood", as they say, with respect to Gemini. Right now it's not my primary online presence, but who knows what the future might hold.

Other interesting finds:

CAPCOM Geminispace aggregator

The Bongusta aggregator for Gopherspace


This Gemini server was written in Lua.
"The First Gemini Protocol Server"

"Minimal but usable interactive Gemini client in < 100 LOC of Lua"

Good hack here.

As a little exercise over the last week or so, I implemented a #gemini client entirely in #Fortran:

It actually works pretty well. Because of the way it's designed, I do plan on implementing a Windows GUI client based on this code. Right now it assumes you're at a dumb terminal.

Wed, May 20, 2020

More client and sever software that supports Gemini has been created in recent days.

These three client apps interest me.

This is another graphical Gemini browser. It's written in C#.

This is a cURL-like command line utility to interact with Gemini sites.

This is similar to wget but for Gemini sites.