Ben's Logarion ☪

topics:
Software
id:
27182120-f540-48b2-a7e8-13580f73df61

Gemini Client Review

Note: This article has been updated on 2020-08-15 to add a link to each project for easier access.

Introduction

Alright! Here is a fun piece for those in Gemspace. Since discovering Gemini this year, I have taken a great interest in the ecosystem, both in terms of software as well as content. Gemini has a very nice community, so both the people are cool and the software is cool. This is great for people like me who enjoy computing as a hobby.

Approaching the system as a user proved to be somewhat daunting at first. Indeed, I was a passive subscriber on the Gemini mailing list for months before I even knew what Gemini was. Unable to very quickly and easily install a client on my system due to no Gemini related packages being present in my operating system's package repositories, I first got a hold of the gopher client on Unix (FreeBSD), and it blew my mind.

For Gemini specifically, the easiest thing was to install elpher in emacs, which is readily available in the MELPA respoistory. I don't really qualify as an emacs user, though I know how to edit text with it, so installing remote packages in it was a strange experience at first, but with just minor tinkering I had it installed. It turned out to be well worth the effort, as it is in my estimation one of the finest clients, with the rendering and UI being virtually perfect especially considering that it operates in emacs, which provides unique constraints and challenges. Of course, everyone has their own taste.

After that, the only option left for the majority of Gemini software was to compile from source. Curious to see what else was out there, I set about downloading and compiling any client softare I could on Linux. Because I'm no stranger to building packages from source, this turned into a fairly simple and straightfoward process. Since I already had Rust installed on my system, the Rust-based projects came first, followed by Qt/C++ once I figured out how to get qmake working on my system. Python projects I could simply run, and one client used Haskell, which I already had set up.

That just left Go, and I was unable to use it on my local system because of stupid Internet restrictions. Luckily, it was very simple to get working remotely on my server, and then I discovered all the Go-based clients I had downloaded were text-based anyway, so that allowed me to finally build them all and quickly test them over SSH. Of course, I was still able to try binary versions of those clients, but now that my build process is more or less complete, I decided it's finally time to review the browsers after trying "all" of them. (There must still be some I haven't tried yet. For example, I have not used any Windows browser.)

So, without further ado, the reviews:

Text-mode

I decided to divide projects into the categories of Graphical vs. Text-mode as a fundamental distinction. I'm doing text-mode first because I consider them first class citizens in Gemini, and there's also more of them!

amfora

=> https://github.com/makeworld-the-better-one/amfora/releases

Written in Go, amfora recently became one of my favorite text-mode clients. Even though it runs in the terminal, it is a bit on the "graphical" side, providing a visual interface and rendering. A lot of care has gone into the attractive layout of the pages as well as text effects like colors and typefaces (bold, italic) to enhance the experience. Even more amazing, it supports tabs, and the tabs are also visual. Amfora comes as precompiled binaries for a dizzying array of systems and architectures, so you don't even have to compile it.

At around 15 MB it is a little bit large, but that's not a lot of space nowadays. It seems like an ideal client for newcomers or casual users, and it has built-in help as most clients do. When I initially wrote this review, I complained about some quirks related to input and navigation that the author has since responded to. Now the numbers 1-0 are hotkeys to the first ten links like in bombadillo, and you can quickly tab through links on any page. (Sweet!)

asuka

=> https://git.sr.ht/~julienxx/asuka

This was first Gemini terminal client I ever compiled. It's a bit of an oddball, but that's what makes it interesting and desirable. It is also still one of my preferred text-mode clients, though I find it to be somewhat slow.

The first things that jumps out at you about it is the color scheme and the fact that it is black-on-white. This is unusual for a text-mode client, but the distinct visual style and presentation helps to create an experience. It lets you know that Gemini is something different. The great retro look and feel reminds me of using applications in MS-DOS, and a very surprising perk is that it supports mouse input. (What!) The visual line-based navigation is also really cool.

AV-98

=> https://tildegit.org/solderpunk/AV-98

Of course, AV-98 is one of the flagship clients of Gemini. Unlike the "visual" style provided by the previous two clients, it's more of a straight, no-nonsense terminal client. That means you have a prompt that awaits your input, and commands will print output onto the screen. This classic interface is both simple and effective.

Thanks to being interpreted in Python, this client is very compatible and works out of the box on nearly any system. I wouldn't be surprised if it ran on Windows with no additional setup. In spite of being interpreted, it's very fast. There isn't otherwise a whole lot to say about AV-98; the pages look good, and it's quick and easy. It's well and thoughtfully crafted, and I'm sure it has nifty features I have not even discovered yet.

bombadillo

=> https://bombadillo.colorfield.space/releases/

Another Go client, I have known about bombadillo a bit longer than the others, so as far as I know it is a long established project. It supports both Gopher and Gemini, which is very handy if you use both, and I'm sure many people do. The interface is visual, and it seems perfectly fast and usable. Unfortunately, something about it isn't working right on my system, and some Gemini pages on my site just don't display properly in bombadillo, for example the beginning part of the document being cut off or missing, and issues with line wrapping in paragraphs. This is certainly not the intended behavior, so it may be a bug in the client or unexpected incompatibility somewhere. Therefore, I need to do some troubleshooting, but setting this aside it seems like a solid client and worth trying.

bollux

=> https://sr.ht/~acdw/bollux/

The amazing thing about bollux is that it's written in bash. (Yes, it's a bash script.) Honestly, I've never seen anything like it before, but it's fast and a lot of fun to use. Like asuka it's very simple and basic, and like AV-98 it uses a command line style interface. For displying pages, it full-screens them which assists you in scrolling around, and that is quite useful if scrolling is not easy on your terminal; you don't have to scroll back to read the top of a long page. It does also use color and text effects like the other clients, so it is visually appealing as well.

With not even Python as a dependency, bollux takes the creativity and effective minimalism to a level that feels faithful to the Gemini Way.

diohsc

=> https://repo.or.cz/diohsc.git

Last but not least, this very cool client is written in Haskell, which is the thing I love most about it. It's no secret that I like Haskell, and the language lends diohsc both speed and reliability. The interface is classic command-input like bollux and AV-98, and like them it is fast. Page rendering is quite good, and honestly I never had a problem with this client. I personally use it more than the other command line clients, but for those unfamiliar with with Haskell and cabal, it might be a little effort to get it running. If you are already a Haskeller then you basically have no excuse not to use this.

Graphical

Alrisha

=> https://git.sr.ht/~fabrixxm/alrisha

Written in Qt, Alrisha is nice and straightforward. The interface is simple, it supports tabs, and seems to get the job done. I ran into some interface quirk on my system, namely scrolling with the touchpad not really having the desired effect. (The scrolling starts, but it doesn't stop!) The pages look pretty good, but they are plain without color. Also the layout is a bit spacey, but that's a really common thing in graphical clients, apparently. The way it titles tabs is very nice.

elpher

=> https://melpa.org/#/elpher

I already wrote quite a bit about elpher in my introduction. I ended up putting it in the "graphical" section of the article even though it's technically both in some strange way. You can run it in emacs from in your terminal, or you can use it with graphical emacs and enjoy the added perks like variable text sizing and clickable links. Because it runs in emacs, that helps it to be compatible with and run on a great number of systems, and I'm sure it works on Windows and Linux just the same thanks to how wonderful emacs is. I find elpher to be nearly a perfect client; it supports both Gopher and Gemini, provides the benefits of both text-mode and graphical clients, has great UI, renders pages seemingly perfectly, and it's fast and reliable. What could be better? The first time I loaded up elpher, I spent a good couple of hours browsing Gopher sites. It never gets in your way and just lets the content shine through. If you haven't tried it yet, it really is that good, and probably is the best client you're missing. (After all, I can understand not wanting to bother with emacs. I had low expectations before I tried it, and I was wrong.)

Castor

=> https://sr.ht/~julienxx/Castor/

Castor is a great graphical client written in Rust and GTK. It was the first fully graphical client for Gemini that I tried, and it has consistently provided a solid experience. It is simple and fast, and the page rendering is rather good and attractive. I like the color theme a lot, although block quotes look kind of weird. One thing I always appreciated about it is that it shows links as buttons. I don't know why I like that so much, but it contributes to the client's uniqueness and ease of use. I can imagine it being a breeze to use with a touch screen interface, for example on a tablet or mobile. It is still currently my default URI handler for gemini:// links on my desktop.

Kristall

=> https://github.com/MasterQ32/kristall/releases

If you don't know about Kristall, well let me tell you... you should know. Another Qt client, Kristall is currently the tour de force for Gemini on the desktop. When it comes to features and configurability, there's nothing like it. If it weren't for my great love of elpher, I would go ahead and call it the best client, at least on the desktop. Obviously, it's not going to replace the utility and convenience of text-mode clients, but when I'm on my laptop and want to browse Gemini, I find myself launching Kristall more than anything. What can I say? It looks good, and like Castor it pops up ready right away without the slight inconvenience of having to wait for emacs to load and then put it in elpher mode.

If I were forced to criticize something about it, the configurability could be regarded as a flaw. When I first start using it, I did not like the style settings and customized them myself so the pages would look better (to me). The fact that I had to do that might be seen as a drawback, but the fact that I could do it should be seen as an advantage. I do love the simplicity and minimalism of the Gemini ethos, but if you're going to go graphical then go graphical! Clearly, if you need a desktop client, this is the one.

Moonlander

=> https://sr.ht/~admicos/moonlander/

Moonlander shows promise, but I understand it to be a work in progress, so I would not recommend using it just yet. However, I do look forward to any future updates it receives, as what is there so far looks good. In its rendering style it feels a little similar to Alrisha, but Alrisha currently offers you more and is more complete. Where that client is written in Qt, this one is Rust/GTK.

Mobile

Deedum

=> https://github.com/snoe/deedum/releases

=> https://play.google.com/store/apps/details?id=ca.snoe.deedum

Technically a graphical client, I decided I'd create a "mobile" category as well, since this one runs on Android. Right now this is the only Android client I know or have used, and it's plenty good. The interface is straightforward, rendering is well and proper, you get tabs, and... well, what more do you need? I only wish it had dark mode just to save a bit of my poor old phone's battery, since it has an AMOLED display. :) Needless to say, if you have Android, you should have this installed if you are to be a true Gemonaut.