davep

Rogallo v0.10.0

Sat, 18 Jul 2026 16:44:46 +0100

Rogallo v0.10.0 is now available. This release has a number of changes, including some new features, some changes to the user interface, and a couple of quality-of-life improvements.

Maximum document width

Amongst some feedback someone left on a slightly unrelated post over on station there was mention of how a document "should" wrap at around 72 characters. While no rationale was given for the "should" part, I was happy enough to accept that this could be a preference for some people. With this in mind, I've added a configuration option to set a maximum width for documents.

While, personally, I prefer Rogallo's default behaviour (I work in an environment where I can resize a window, and I'm capable of doing it), I can appreciate that someone might want to cap it. So for folk who prefer this, they can now make Rogallo look like this (with maximum_document_width set to 80):

For the moment this can only be set via the configuration file. At some point I might make this more of a dynamic thing. I can imagine this being something handy, or at least fun, to change up as you're viewing different content.

Link jump timeout

The same feedback "suggested" that the link jumping facility that Rogallo has should have a timeout that clears the buildup of the number being looked for. This seemed like a reasonable thing to ask for. So, before, if you typed 1, a link with a label of 1 would be selected. If you did nothing for a while, and then typed 2, a link with the label of 12 would be highlighted. With the new timeout (set to 1 second by default, configurable in the configuration file), if you type 1 and then 2 more than a second later, first link 1 will be selected, then link 2 will be selected. On the other hand, if you type 1 then 2 within a second, 12 will be selected.

Setting the timeout to 0 disables this and Rogallo's link jumping facility will work as it did before.

Failed input recovery

With this new feature, if you send input text to a capsule and it rejects it for some reason, the input will be held on to. If you then visit the same URI again, the input dialog will be pre-populated with what you attempted to send a moment ago. This gives you the opportunity to edit anything wrong with the submission and try again.

Added all application commands to the command line

If you prefer to use Rogallo's command line more than the command palette, I've now ensured that all bindable application commands can be accessed via the command line. There's a difference in their form, to stay in keeping with the command line. So whereas in the command palette you'd run GoHome by typing go home, in the command line it becomes a !-prefixed snake-case command: !go_home.

All possible commands are listed in the help screen if it's brought up while the command line has focus.

Rogallo now has two new commands for quickly navigating within the current capsule path. GoToParent will navigate up a level in the path of the current URI, and GoToRoot will go to the root of the capsule.

Visited vs non-visited links

The icon for links is now used to show if a link is already in the location history (and so has been visited before), or not:

Here you can see that Account settings isn't in the visit history, but the other two links are. I was going to do the whole link, but I've never been a fan of how web browsers do this, so I've gone with just the icon. I've also made it subtle but still noticeable. So far, I'm much preferring this; I don't need it blasting out the difference, I just need it to be enough for me to notice¹.

Swapped around history and bookmark tools

Until now the "history" and "bookmarks" shortcut keys advertised in the footer brought up the sidebar-based management widgets. This made sense when that's all I had in Rogallo. For a while now though I've had palette-based search tools for both history and bookmarks. Normally I want to search for and select a bookmark or history item way more than I want to manage those lists. So I've relegated the sidebar-based tools to a secondary position and placed the palette-based search tools up front.

This also means that the default bindings have changed a bit. As always, you can discover the bindings with rogallo bindings.

Conclusion

I know I've nodded towards this before, but I think I'm getting close to making a v1.0.0 release. I want to daily-drive for a few more days, and I'd also like to expand the website. I'd also like to build a Gemini/Gemtext-based site for Rogallo -- it'd be pretty weird if I only documented it in http(s)space. I won't let those wishes become blockers for moving to calling Rogallo "stable", but it would be nice to have.

I do recognise that there's an a11y issue here with the subtle difference; there's some work to be done at some point to allow for a high-contrast theme that will resolve this sort of issue. ↩

Wasat v0.8.0

Sat, 18 Jul 2026 10:23:11 +0100

Wasat v0.8.0 is now available. This provides a small update to the GeminiURI class, adding three utility properties for extra URI manipulation.

without_query - gives the URI minus any attached query
parent - gives the parent path of the current URI (also minus the query)
root - gives the root path for the current URI (also minus the query)

In each case, the result is a fresh GeminiURI instance.

These are added because I'm aiming to add "go to parent" and "go to root" commands to Rogallo.

Terminal bean soup

Fri, 17 Jul 2026 20:54:32 +0100

I'm sure most people reading this will be familiar with the concept of "bean soup theory". In case anyone isn't, here's how Wikipedia describes it:

A specific phenomenon described as a 'What about me' effect. An individual watches a video that doesn't pertain to them, but finds a way to make it about them anyway. Stems from a 2023 TikTok recipe for bean soup, with commenters saying "What if I don't like beans?"

I feel there's a very specific set of folk who love to "bean soup" anything relating to terminals, and it's common to have them turn up in your mentions if you happen to do anything in the terminal, or for the terminal, that isn't about their purist opinions and how everything must be a Vim clone, or worse.

I first encountered this when I started working at Textualize. Unsurprisingly, given the point, purpose and focus of Textual, some folk would turn up in the Discord server, in the issues, in the discussions, in the mentions of posts in various places, and post their very important opinions about how TUI software must work. Not... discuss their preferences, or offer suggestions (there were plenty of people who were pleasant like that, they were lovely to converse with), no: their engagement was written as if every word that was mashed into their keyboard was a well-crafted, handed-from-on-high RFC-like holy document that MUST and SHOULD be followed¹.

If I was being very charitable I could cut them some slack. If you're building a framework for building applications for the terminal, there's a good reason to make it at least possible for the application authors to follow recognised best practice and to stick with hard-won conventions. Indeed, Textual has some design choices that I think are deeply questionable and misguided and I objected to them on more than one occasion. So, yeah, if I was being charitable, I could cut them some slack.

I could... if they weren't such arseholes about it.

This gets worse though if you're building an application for the terminal, especially if it's built as Free Software and the motivation is to build something for yourself and be kind enough to share. It irks the hell out of me when I build some application for myself, as a TUI, and then someone turns up and starts complaining about my choice of default key bindings, that work in my choice of terminal emulator and my configuration for that emulator.

It's even worse when they do it in a way where they have to show their very deep knowledge of terminals, and how they're very proud of just how lacking in features and progress their own choice of terminal emulator is.

Dude...² I know. I've used physical terminals. I've written COBOL on a minicomputer using a line editor on some honking great dumb all-green all-in-one box. I've even written code on a terminal using fan-fold paper. I've used all sorts of terminal emulators. I spent well over a decade doing shit inside rxvt which was running on my GNU/Linux server while displaying on my Windows desktop machine.

I've installed and tested plenty of terminal emulators.

I'm well aware of the conventions and expectations. If Ctrl+C doesn't quit... that is my choice. It's not ignorance, it's not a lack of history with this stuff, it's a choice. For my software.

So when you turn up and feel the need to tell me that some function keys might not work in some terminal on some GNU/Linux box... I get it, you don't like beans. If that's the case, how about you either don't make my hobby all about your tastes and how I should build my application to suit you, or how about you RTFM and configure my application so it works in your choice of terminal?

I mean... we know you won't. We know you don't even care about the application I'm having tons of fun building, that I'm spending time in a joyous flow-state creating and tinkering with. You just care about making the post all about you and your purity. We know you just care about showing how smart you are.

We know you just can't resist the urge to reply-guy³.

We get it: you don't like bean soup. Nobody cares. Nobody asked.

That reminds me: one day I should write a rant about the folk who obsess about the "Zen of Python". ↩
Let's be honest: it's always a dude. ↩
Let's be honest: it's always a guy. ↩

Solar halo

Fri, 17 Jul 2026 18:07:52 +0100

I forgot to post this yesterday. I was out on a lunch walk and noticed the clouds in the sky were looking like the right kind for some atmospheric optical fun. Sure enough, I looked up, and...

A nice partial 22° halo. It's been a wee while since I last saw one.

Rogallo v0.9.0

Thu, 16 Jul 2026 20:10:35 +0100

I've released v0.9.0 of Rogallo. The first big change in this release is the addition of syntax highlighting to pre-formatted text.

Much like in Markdown, Gemtext also supports pre-formatted text bounded by code fences. Gemtext supports the concept of "alt-text" for such text, like this:

```python
def hello(name: str = "World") -> str:
    return f"Hello, {name}!"
```

Until now Rogallo would simply show the text as-is (with some styling to make it stand out from normal paragraphs). From this release, if there is alt-text for the pre-formatted block, and if it's the name of a supported language, the content will have syntax highlighting applied.

If you're curious which languages are supported, it should be anything that Pygments supports.

Another significant change is to the user input dialog. As mentioned in an earlier post, the Gemini protocol imposes limits on how much text can be submitted to a capsule. As documented, the limit is for a resulting URI of 1024 bytes¹. To save someone typing out a long entry, only to have it lost², I've added a count of how much input is left available (calculated from the size of the URI that would result):

To help ensure that the user doesn't submit too much, I've also added an error display if you go over the limit, which also refuses to submit the input.

With these in place it should be a lot harder to run into an unexpected loss of input.

One final tweak is a small change to the optional link stripe system I recently added. While playing around with some other themes, I noticed that the styling didn't show up well, or at all, in many of them. So I've changed it a little so it now shows in all available themes. I'm still not convinced it's quite right -- I'll play some more. But at least now it's visible in all cases.

Although I've already encountered one capsule that limits to 1022, from what I can tell. ↩
Right away I'm now thinking it might be a good idea to re-populate the input dialog in such a situation. I'll have to remember to make that a TODO issue. ↩

Wasat v0.7.0

Thu, 16 Jul 2026 17:07:52 +0100

The Gemini Protocol makes it clear that the maximum length of a URI, when making a request, is 1024 bytes. This has implications for how large a user's input can be when responding to a 1x response. Because of this, I'd like to update Rogallo so that it lets the user know how much space they have left as they type in their input.

With this in mind I've released v0.7.0 of Wasat. This adds the following to GeminiURI:

GeminiURI.MAXIMUM_LENGTH -- a constant for the maximum length of a Gemini URI (as mentioned above: 1024).
len() support -- if you ask for the len of an instance of GeminiURI it will return the length of the full URI.
GeminiURI.bytes_left is a property that tells you how many bytes are left until the limit, given the current URI.
GeminiURI.too_long is a boolean property that flags if the current URI is too long to send to a Gemini capsule.

This should give me all I need to add some guardrails to the user input dialog in Rogallo.

Gemtext v1.0.0

Thu, 16 Jul 2026 08:58:50 +0100

I've bumped Gemtext to v1.0.0. I've gone from "this is test code" to "this is stable code" mostly because the library is so simple and I'm unlikely to add any radically new features to it¹.

This bump also has one small addition: I've added an alt_text property to the PreFormatted class. This exists to capture and make available any text that comes after the pre-formatted text marker. For example, this text:

```python
print("Hello, World!")
```

will now result in:

PreFormatted(content='print("Hello, World!")', alt_text='python')

If/when I add syntax highlighting of pre-formatted text blocks to Rogallo, this new property will make that possible.

I was thinking about adding a Gemtext builder class at some point, but I can't see a use for it any time soon. Perhaps v2.0.0. ↩

Rogallo v0.8.0

Wed, 15 Jul 2026 19:56:57 +0100

Rogallo v0.8.0 is now available. This release includes a small bug fix, a big change to how external links and unhandled MIME types are dealt with, and a further improvement to link navigation.

First the big change: hand-off of unhandled content and trust. Until now, if Rogallo was met with a URI it didn't know how to handle, or met with a MIME type it isn't designed to deal with, it would simply hand it off to the browser in your environment. This is generally handy as it means that, when you're browsing gemtext content, if you meet a link that takes you to a conventional website, the link will (normally) be opened in your browser.

There are, of course, any number of schemes that form part of a URI. While Rogallo might commonly be handing off http and https URIs, there's no reason why it can't be handing off a finger or a mailto or whatever. Or, potentially, something a wee bit more dodgy like a javascript URI. While some web browsers don't allow that sort of thing by default (Safari, for example, blocks it unless configured otherwise), others might, and this could result in a nasty surprise.

So now Rogallo has a confirmation step that lets you allow a scheme this once, this and every subsequent time, or just cancel out.

By default the trusted schemes (the ones you say "always" on) are saved in a trusted_schemes file in the data directory.

Similar to the above: if, via a URI that Rogallo can handle, it meets a MIME type it can't handle, it will also pass it off to your operating system. I've added similar protection there too.

In this case any MIME types marked as trusted are dropped into a trusted_mime_types file in the data directory.

ℹ️ Note

If such a MIME type is allowed, it is passed off to your operating system to handle. If you'd like to tell Rogallo to try and internally handle a MIME type, you can set that by configuring the displayable content types.

I feel these changes help remove any possible footguns previously caused by unquestionably handing off URIs to the wider environment.

Another change I've made is to add even more link navigation. This sort of follows on from yesterday's release where I added labelled jumps to links. Again, the usual method of moving between links is to use Tab and Shift+Tab. The problem with those keys is they navigate you through all widgets in the UI that can receive focus. So, if you keep tapping Tab, you'll navigate out of the viewer and into the next available widget, once you reach the last link.

With this release I've added some extra keys which can be used to constantly cycle around the links while you're inside the viewer. These are:

Left, Shift+Up, L to go backwards through the links.
Right, Shift+Down, l to go forwards through the links.

While these might not be to everyone's taste (I'm already getting very used to using Left and Right), they do add another set of options for link navigation.

The final change is a simple bug fix, where the command line history simply wasn't being saved and loaded correctly. From now on it should save correctly and allow navigation of the history using the cursor keys.

With these changes in place, I feel I'm actually getting close to bumping up to a v1.0.0 release. While there are still things I want to add (there are currently a handful of TODO items in the issues), I see these as nice-to-have items that I want to do later on, rather than as must-have items that preclude considering Rogallo a viable daily-driver.

I'll see how the next day or so goes.

Rogallo v0.7.0

Tue, 14 Jul 2026 18:45:28 +0100

Rogallo v0.7.0 is now available. The main changes in this release revolve around the display and navigation of links.

The aim of Rogallo, as a "TUI" application, is that it is usable purely with the keyboard, and also very usable with the mouse too. So far I think I've managed to hit that mark, but I felt that things weren't quite as smooth as they could be when it came to navigating links.

Links, like any other UI element in the application that can receive "focus", can be navigated to using Tab and Shift+Tab. This is fine if there's just a handful of links in a page, but more than that and having to repeatedly press tab gets a bit boring. Meanwhile, if you have a mouse or other pointing device to hand, it's easy to scroll and click. I wanted to try and have a similar keyboard-based speedup available.

So now, by default, all links on a page get a numeric label:

To jump to a link, while the viewer has focus, simply type the number. When you do so, the corresponding link will be focused, then you just need to hit Enter to follow the link.

The input system is written to "wrap around", as it were. So if you type 1 the link with a label of 1 will be focused. If you then type 2, and if there's a link with a label of 12, it will be focused. If there are fewer than 12 links, the input chain resets, and 2 will be focused. The idea being: as you keep typing numbers, they concatenate until there's no matching link and then it starts fresh.

I was quite keen on having the labels over to the right, so they didn't disturb the layout of the main body of text, but there's a small downside with this: if you have a lot of links next to each other it's not always obvious which link and which label go together. While getting close to your desired link should be good enough (you can then still hit Tab to get to your chosen link), I felt something else could be done to give some help. So I added an option to turn on alternating background stripes for links.

If all of this seems a bit too cluttered, especially if you're the sort of person who is mouse-first or mouse-heavy with the terminal, there's still the option to turn off both the labels and the stripes and have Rogallo look like it did before.

I think this covers pretty much all the possible link navigation needs I can imagine anyone having.

As well as the above, other small changes in v0.7.0 include:

Fixed a cosmetic issue with the truncation of the current location shown in the viewer panel, if the location is longer than the available space is wide.
The suggestions provided in the command line now include hosts found in the "known hosts" trust store. So if you are trying to remember a location you visited long ago, and you never bookmarked it and it's fallen out of the location history, it's still there as a reminder/hint/completion.
Also added the same to the history search palette.

I've also done more work on the website. The configuration section now covers pretty much everything you can modify that changes how Rogallo works. I still want to add more to the site -- mostly concentrating on explaining some key features -- but I felt that anyone using Rogallo right now would be most interested in how they can tailor it to their own taste.

Wasat v0.6.0

Tue, 14 Jul 2026 12:14:35 +0100

Wasat v0.6.0 is now available. This is another quick update that fixes a small typing issue and also adds a handy new method I've been meaning to add to GeminiURI.

The typing issue is a simple enough one. The __init__ method for GeminiURI can take either a string or another GeminiURI as its argument. However, the type was actually specified as str | Self. In Rogallo, I want to have a sub-class of GeminiURI for one particular purpose, which will be passed an instance of GeminiURI. Something like this:

class KnownHost(GeminiURI):
    """A known host."""

From this, I want to be able to do:

[KnownHost(host) for host in self.known_hosts]

where known_hosts is typed as list[GeminiURI]. At this point, the type checker complains:

Argument 1 to "KnownHost" has incompatible type "GeminiURI"; expected "str | KnownHost"  [arg-type]

The error is correct, because the use of Self is saying "this needs to be an instance of my class". There's no reason why it needs to work this way, so I've relaxed the type to str | GeminiURI. In my example above, KnownHost is a subclass of GeminiURI, so the type checker will be happy again.

The new method I've added is GeminiURI.with_default_scheme. This is a class method that acts as a more relaxed "constructor" for a GeminiURI. Again, in Rogallo, there are a few places where I'm taking some input, assuming it's going to be a gemini:// URI, checking if it's missing the scheme prefix, and then prefixing the string with gemini:// before creating a GeminiURI¹. This means that Rogallo contains a few instances of this sort of code:

if ...: # ...we should treat some text as a URI but it isn't prefixed with "gemini://"
    uri = GeminiURI(f"{GEMINI_PREFIX}{text}")

It's a small difference, but from now on I'll be able to:

uri = GeminiURI.with_default_scheme(text)

This removes the need to check if there's a scheme already and it saves me having to import GEMINI_PREFIX, etc.

GeminiURI will deliberately raise an exception if the scheme isn't gemini. ↩

Wasat v0.5.0

Mon, 13 Jul 2026 19:31:36 +0100

Another quick update to Wasat, my Gemini Protocol client library for Python.

With v0.5.0 I've added a method for getting the list of currently-trusted hosts, and also added a public property to the client class for getting access to the trust store object.

Generally these shouldn't be required, shouldn't be something you'd normally want to work with; I've added them because I thought it might be another useful way of populating the suggested completions facility in the command line inside Rogallo. The idea being: if you're trying to remember the name of a capsule you've visited before, and it might have fallen out of the location history, its trust status might still be recorded so it can complete from there.

Let down by Openreach (again)

Mon, 13 Jul 2026 15:40:59 +0100

I knew it was too good to be true. While a little bit of me hoped it was going to happen this time, mostly I was expecting it to not happen.

It didn't happen.

Today was the day when Openreach were supposed to turn up again and deliver me a full fibre connection. The engineer was booked to turn up some time between 08:00 and 13:00 (as before). I was ready at 08:00. I was ready before 08:00 if I'm honest.

By 12:00 there was no sign of them. Despite there being an hour left to go, I'd written them off as a no-show again. I was wrong this time though. There was a knock on the door about 10 minutes later.

The engineer introduced himself, said he needed to go for a walk around first to get a feel for how and where the work needed to happen, and to figure out where the fibre was to come from (I kind of feel like this would be the sort of thing they'd know up front, but it's not my job and I trust them to know it).

Another 5 minutes and he's back... to tell me they can't do the job because the pole the fibre needs to come from is too far away. O_o

Now, I'm not going to get annoyed at this chap; presumably someone should have done some sort of site survey beforehand. Presumably this was the sort of thing that should have happened before the previous attempt to deliver the product?

So now I'm still without fibre, but with part of the job done. He installed the wee box that goes inside the house, and also the wee box that goes on the outside of the house. Of course, he drilled a hole and hooked them both up. So now I'm down an electrical socket, but have gained a box with a little red light that tells me I don't have full fibre.

He left assuring me that, having done this, it ensures that the actual delivery of the cable is turned into a priority. I can't say I'm that convinced, having sort of been here before. Some time later I got this text message:

We're sorry we couldn't get you connected today. The job is a bit more complex than usual.

We are going to get it sorted though and promise Full Fibre's worth the wait. We'll be back in touch in the next few days.

Again, I'm not convinced, having sort of been here before.

If I was a little more cynical and a little more prone to seeing a conspiracy where there was just a cock-up, I'd almost be tempted to entertain the idea that they turned up and fitted the box knowing full well that there was no fibre to be hooked up. Doing half a job is starting the job, after all. Presumably on some sheet somewhere that looks better than failing to do the job a second time.

I'm going to give them a couple of days to get back to me, as per the message, and then I think it's time to chase up EE and ask why, once again, they've failed to deliver me a product they promised me was available.

Rogallo v0.6.0

Sun, 12 Jul 2026 12:01:17 +0100

I've just released Rogallo v0.6.0, which contains the last big feature that was missing to make it a viable daily-driver Gemini Protocol client. That feature? Client certificates.

From now on, if you visit a capsule that requests a client certificate, rather than an error being shown, a dialog will pop up:

When you select the Create button, the certificate will be created and then, from then on, when you visit the capsule, that client certificate will be used.

As you might have noticed, there are "advanced options" available too. Most are just optional values that go into the certificate itself:

The two advanced options that mostly affect how all of this works are the scope and the transient option. The transient option means that the certificate is only good for the lifetime of this run of Rogallo. If you close Rogallo, the certificate will be discarded. In almost all cases, you'll want to leave this turned off.

The scope toggle affects the scoping of the certificate. As I've been able to understand, the strict reading of the Gemini Protocol says that a certificate should be scoped to the host, port, and path where it was first requested and generated for. However, out in the real world, it seems there are applications built for the protocol that don't work well with that approach. With this in mind, I've built Rogallo to always scope to just the domain and port, by default. If you want a particular certificate to follow the strict letter of the specification, turn the "Scope to domain/port" option off.

With all that in place, it should now be possible to use Rogallo with any Gemini application that needs client-side authentication. For the last couple of days, I've been using it to successfully play AstroBotany, for example.

As I said: with this in place, I believe Rogallo has all of the basic requirements of a Gemini protocol client covered. I'm not quite ready to call it v1.0.0 just yet -- there's a fair bit of testing and tweaking I still want to do, and I can see that, when it comes to certificates for example, there's some extra error handling I need to throw in. Additionally, the "advanced" version of the certificate create dialog is kind of tall for many terminals; I think I might need to play with the layout a bit.

Also, as I've mentioned a few times: I want to get proper documentation written and hosted on a dedicated site.

Back to this release: there's also a handful of other QoL changes and fixes. These include:

Any page that is opened from an in-page link is now always retrieved from the remote location, bypassing any cached copy. The idea being that, if someone is actively navigating documents, they will want the freshest version of the new page.
Fixed the layout of list items. Before now, the text wasn't wrapping, while, at the same time, space was being made for the text as if it was being wrapped.
The bookmark search palette is no longer available if there are no bookmarks to search (the idea being that not being available is less confusing than being available but empty).
The connection timeout, read timeout, and maximum number of redirects can now be set in the configuration file.
The title area of the viewer now has a key icon that appears if a page is using a client certificate.
Pages that require a client-side certificate are never added to the cache (the idea being that such pages are more likely to have dynamic content, and so the freshest version should always be loaded).
Reworked what is recorded in navigation and location history to ensure that what is saved is the landing URI, not the URI that was first visited. This solves the problem of what happens during redirections, and so also solves the issue of what happens with 10/11 response inputs (having the resulting query appear in history could result in duplicated "submissions" to whatever app was in use).

With these enhancements and fixes in place, I'm going to keep tending my plant, and posting away on Station, as a way of continuing to shake down the application. With that in mind, if anyone knows of any other sites and apps I should be testing against out in Geminispace, do let me know!

Wasat v0.4.0

Sun, 12 Jul 2026 10:12:59 +0100

By this point today I was hoping to have released a new version of Rogallo, complete with client certificate support. It is more or less all there and ready to go, but I ran into a small problem, something which confused me.

You see, according to the documentation for the Gemini Protocol, when there's a request by a capsule for a client certificate, that certificate should be scoped to the host, port and path and all paths below it. So that means that if example.com/foo causes a certificate to be requested, it's good for example.com/foo and example.com/foo/bar, but it isn't valid for example.com/other.

Makes sense.

The problem I ran into pretty quickly, with my implementation of this in Wasat and Rogallo, was this: I hit a site (a microblogging site of sorts) that had a joining page at example.com/join. Once you joined up and set your user name, you'd normally land at example.com/me. They're sibling paths and so should not use the same certificate. However, this was done via redirection, so I did some work to "clone" a certificate when there's a redirection.

But then it got more complicated. The site also lets you follow other people. This means that if you visit example.com/other-user you should also still have the client certificate in place so the capsule knows who you are (because client certificates are also, in effect, session cookies, as I understand it), so you can perform the follow. Again, this is a sibling path, and there's no redirection, so the certificate is no good because, at this point, it's scoped to example.com/join and example.com/me.

Meanwhile: testing this with Lagrange, it had no such problem whatsoever. How was it getting around this issue? Was I doing something wrong? Was I misreading the specification for the protocol? Was Lagrange being a bit more relaxed about its certificate scope?

After doing some digging, it would seem that it's the latter. It looks like it, and perhaps other clients, take a pragmatic approach to certificate scopes and generally scope them to the host and port alone, ignoring the path (in the case of Lagrange it seems to sort of actually divorce the certificates from the URIs anyway, treating certificates more as identities you can associate with any capsule, etc).

Given this, at least for now, I'm going to take that approach. Any time a certificate needs to be generated in Rogallo, I'm going to give the user the option (on by default) to scope the certificate to the whole host/port combination. Later on I might add the ability to fully manage certificates (right now that can be done by editing the certificates file in the data directory, but a proper UI for it would be nice).

Which brings me to this release of Wasat. v0.4.0 adds some extra functionality to GeminiURI that allows changing and removing individual parts of the URI. There's a new replace method that can be used to create a clone of a URI with various parts changed. Also, if you just want to change one specific part or simply prefer method chaining approaches, I've also added more with_ methods similar to the pre-existing with_query method, so now there's also with_host, with_port and with_path.

With these in place I can go back to Rogallo and carry on with the last bits of work I want to do on client certificate support, with Wasat making it easy for me to clone up and chop and change URIs to suit the scoping requirements.

Wasat v0.3.0

Sat, 11 Jul 2026 14:40:00 +0100

Wasat v0.3.0 is now available. This is a pretty small update, but one that's going to be useful in the next release of Rogallo. I've now got client certificate support up and going in the application, and I thought it might be useful to show the user if a given page is using a client certificate or not (and, perhaps, at some point, make the details of the certificate available as part of some page information dialog).

With this in mind, I've added client_cert_path and client_cert_used properties to the Response class. The former is the path to the certificate used (if one was used), the latter is a simple boolean flag to say if a certificate was used at all.

Of course, client_cert_path could be used for both purposes as it'll be None if one isn't used, but client_cert_used will read better in code if that's all that's needed.

Wasat v0.2.0

Fri, 10 Jul 2026 11:37:37 +0100

I've made a quick update to Wasat, my async Gemini Protocol client library for Python. Now that I'm at a point where I want to add client certificates to Rogallo, I'm essentially shaking down the support for this in Wasat.

One thing I wanted right away was a certificate that, in effect, never expires. So with this release of Wasat I've added an option where the days to expire can be set to None, which results in the expiration date being set to 9999-12-31.

Rogallo v0.5.0

Fri, 10 Jul 2026 10:16:36 +0100

As mentioned in the last release, I've been afk for a week and a bit, enjoying some downtime over in the Netherlands. Although... it wasn't exactly all afk. I did take a keyboard with me and, while time permitted, I did tinker on Rogallo. That's resulted in quite a few TODO items being ticked off, and quite a few changes and improvements being made.

Visible MIME type

It's a small tweak, but I found it useful. The status bar of the main viewer panel now shows the MIME type of the document currently being viewed. Normally it will be showing text/gemini:

but Rogallo can show some other text/ types too, so this will also make it obvious what you're looking at:

You might also notice that, depending on the theme being used, the "correct" MIME type gets a "this is fine" colour whereas anything else is in a more "neutral" colour.

Better handling of `text/plain` and friends

Now, if a document comes in that isn't text/gemini, there is no attempt to parse and render it as Gemtext; it's just shown as a simple block of plain text.

MIME type handling of local files

Given the above changes, Rogallo now makes an effort to guess the MIME type of any local file you view. This should help ensure that only Gemtext files get parsed and rendered as such.

OS hand-off for other MIME types

Where possible, when confronted with a MIME type that Rogallo can't handle, it will attempt to hand it off to your environment's main web browser. While not ideal, I have no wish to turn Rogallo into a terminal-based general content browser/viewer; this is all about Gemini and Gemtext.

History enhancements

The history list has been updated to allow the removal of individual items, and also clearing down the whole history.

Added home page support

It's now possible to set a home page with either a SetHome (which prompts for a URI) or a SetHomeToCurrentLocation (it does what it says) command. There is also a GoHome command that takes you to the home page you've set. The default bindings for all of these can be found by either running rogallo bindings, or by viewing the help screen; pulling up the command palette is also an option.

Added support for bookmarks

Bookmarks are now supported. The ToggleBookmarks will show/hide the bookmarks list. AddLocationToBookmarks will add the current location to the bookmarks. SearchBookmarks lets you search the bookmarks.

More command line suggestions

The completion suggestion facility in the application's command line (where you enter URIs or commands) has been enhanced to include suggestions from the navigation history, the location visit history and the bookmarks. This should make it a little easier to enter a URI you're trying to remember.

Added a history search

Having added the SearchBookmarks command, it made sense to also add a SearchHistory command too. So with that you can quickly search all the locations you've visited (within the limits of the history) and head back to one.

Optimised Gemtext rendering

While not something that should generally be obvious to the user, the Gemtext rendering engine has been optimised a little to reduce the number of Textual widgets used to display a document by consolidating all adjacent plain paragraphs.

Cleaned up quoted paragraphs

I've cleaned up an issue with adjacent quoted paragraphs. Until now there was an empty line between each quote; this spoiled the layout.

View source and ANSI escape sequences

Some Gemini sites use ANSI escape sequences to add colour to pages. While this isn't, as far as I can tell, part of the standard for Gemtext, it's a simple thing to support and so Rogallo has supported rendering this for a while; if a page has colours, they'll be used.

This meant that if you asked to view the source of a page, you'd also see that rendered in colour. I felt that wasn't in the spirit of viewing the source.

So now, if viewing a page like this:

When you go to view the source, instead of all of the colours still being rendered, you now get to see which ANSI escape codes were used where:

Viewer auto-focus

One small change is that, any time a document is loaded (from bookmarks, history, the command line, etc), the viewer now gains focus. Something I kept forgetting to do and finally I got fed up with having to tab over to the viewer each time.

Content cache

Rogallo now has a content cache for pages loaded from capsules (the aim is to never bother caching content loaded from the filesystem). Any page that is loaded with a success status code (20) gets cached, and when you go back to it, if it's within the TTL of the cache entry (by default set to one hour), the content of the page will be loaded from the cache rather than making a fresh request.

Using the Reload command always bypasses the cache.

There is also a ClearCache command which will delete all cached data.

The TTL of the cache can be changed in the configuration file by updating the value for cache_ttl. Also, if you don't wish to ever use a cache, you can set with_cache to false to disable it.

What's next

With all of the above, I feel this gets Rogallo close to being v1.0.0-ready. Not quite, but very close. The main addition that still needs to be tackled is client-side certificates. I don't anticipate this being too tricky, it's just more a case of needing to play around with the code I've got so far, and needing to think about how to implement it in a TUI-friendly way (if, indeed, there are any considerations there at all).

For now though, as long as you don't need a client-side certificate, there's plenty to play with and try out.

A view of Whitby

Thu, 09 Jul 2026 09:34:23 +0100

I'm back home, back in Scotland, after a touch over a week in the Netherlands. It's been a great week. Much like on the flight out, from the aircraft, I managed to get a view of a part of the UK I like. This time it was Whitby.

While likely not immediately obvious, it is there. It was a lot more obvious with the naked eye. Zooming in a bit...

The track confirms that we were in a good position for such a view:

While I didn't grab a photo (I wasn't in a window seat this time so it wasn't so easy to keep track of where we were), I also managed to see Scarborough -- a place where I spent many summer holidays as a child in the 1970s.

Sadly I did miss a view of Newcastle, as when we got close to there, we took a left-hand turn and all I could see out of our windows was sky.

Perhaps next time...

textual-enhanced v1.6.0

Mon, 06 Jul 2026 10:31:10 +0200

I've just made a small update to textual-enhanced, my core library used for most of my Textual-based applications. In v1.6.0 I've extended the "constructor" for ModalInput to allow passing in optional values for password, suggester, title and sub_title.

Most of the time I just want to quickly call on ModalInput to get input from the user. If I need anything more fancy, I roll my own dialog. But in some work I'm doing on Rogallo, it would be helpful for me to at least set the suggester. So, without adding every optional parameter for the Textual Input widget, I've extended what can be passed in to what I think will be a useful subset for my applications.

BagOfStuff v1.2.0

Fri, 03 Jul 2026 11:27:07 +0200

Quick bump to BagOfStuff. v1.2.0 adds something I totally forgot yesterday.

While adding the del method to the history classes, to make it easier for me to manipulate them as if they had the interface of a Python list, I totally forgot to add a clear method. Rogallo will need to be able to 100% clear history, as well as remove individual entries in the history, so that's kind of needed too.

It's there now.

davep

Rogallo v0.10.0

Maximum document width

Link jump timeout

Failed input recovery

Added all application commands to the command line

Capsule navigation commands

Visited vs non-visited links

Swapped around history and bookmark tools

Conclusion

Wasat v0.8.0

Terminal bean soup

Solar halo

Rogallo v0.9.0

Wasat v0.7.0

Gemtext v1.0.0

Rogallo v0.8.0

Rogallo v0.7.0

Wasat v0.6.0

Wasat v0.5.0

Let down by Openreach (again)

Rogallo v0.6.0

Wasat v0.4.0

Wasat v0.3.0

Wasat v0.2.0

Rogallo v0.5.0

Visible MIME type

Better handling of text/plain and friends

MIME type handling of local files

OS hand-off for other MIME types

History enhancements

Added home page support

Added support for bookmarks

More command line suggestions

Added a history search

Optimised Gemtext rendering

Cleaned up quoted paragraphs

View source and ANSI escape sequences

Viewer auto-focus

Content cache

What's next

A view of Whitby

textual-enhanced v1.6.0

BagOfStuff v1.2.0

Better handling of `text/plain` and friends