Posts in category "Coding"

Now for some Rust

2 min read; 10 GFI

I'm sure I've mentioned it plenty of times on this blog over the years, but I like to dabble with programming languages. For some people, writing code is purely a job; they concentrate on one language, do it well, and that's enough for them. I can respect that. For me, though, writing code started as a hobby, long before I ever did it as a living, and it continues to be a hobby.

A consequence of this is that I like to try to wrap my head around a new language every so often. Over the years, I've written code with:

  • Assembler
  • BASIC
  • C
  • C++
  • Clipper
  • COBOL
  • Common Lisp
  • Emacs Lisp
  • JavaScript
  • Julia
  • OCaml
  • Pascal
  • Perl
  • PHP
  • Python
  • Ruby
  • Scheme
  • TypeScript

and probably some others I've forgotten to add to this list. One or two I like to think I've (mostly) mastered (at least at one point in my cycle of use); others I've dabbled with to the point of having some fun and nothing more.

This last week, I've started to add another language to the list: Rust. I don't know where on the usage scale it will end up yet (either quick dabble or the walk to attempting to master), but I'm finally getting to grips with it and the urge to do so is sticking.

I've had a couple of goes before now, both times making an effort to work through the book. For some reason, both those times in the past, I lost interest. I think it's because -- as I've often said -- I'm the sort of person who needs a purpose when it comes to learning a language. So, to this end, I'm working on the problem I've used for this so many times before: I'm writing a Norton Guide reading library.

As always, for me, this is a great project to work on: it's a problem I know well, it's an outcome I know well, and it's a requirement that touches on all sorts of issues that you want to be thinking about when learning a language. Already, while working on this, I've had to learn something about how to build a library package, how to lay the code out, what Rust does for the obvious bits of syntax you tend to go looking for, how to do memory management, how to do file IO, and so on.

I won't claim that what I've got written so far is good Rust. I suspect that much of it isn't even idiomatic Rust (yet). What I do know is, so far, the code is working, and in getting it to work, I've started to understand some core concepts of writing Rust.

I now want to see it through to the finish. Heck, who knows, perhaps I'll eventually take it further and build a Rust-based sibling application for AgiNG so I can see how working with Ratatui compares with all my experience with Textual.

Zensical (Redux)

2 min read; 8 GFI

Back in March this year I dipped my toe into trying out Zensical as a replacement for MkDocs/mkdocs-material. At the time I had success with using it as a drop-in replacement for a project, and following that used it for a couple more. All was good.

In that post, towards the end, I also said:

The next test will be to try the docs for something like Hike. They're a little bit more involved, with SVG-based screenshots being generated at build time, etc. If that just works out of the box too, without incident, I think I'm all sorted.

I did try this, but ran into a problem: the screenshots took ages to build. At that point I decided to put the PR on the back-burner and only use Zensical for more static-like sites.

A couple of days ago I noticed that v0.1.0 had been released, and with it this claim:

This release closes the major remaining compatibility gaps with MkDocs, including support for many of its most widely used plugins. You can bring your existing MkDocs project to Zensical and continue using the workflows you're familiar with.

With this I was reminded that I'd not gone back and tried to use it again. So I took the Hike PR, upgraded Zensical, rebuilt the docs and... pretty much as fast as MkDocs! The result, style changes aside, looked the same too.

Given that it seemed to be working fine, I decided to start again from scratch with my current pet project of choice: Rogallo. I removed MkDocs/mkdocs-material, added Zensical, tweaked the Makefile, ran make rtfm and... crash! The error being along the lines of:

RuntimeError: Python error: FileNotFoundError: [Errno 2] No such file or directory: '[...]/site-packages/zensical/templates/.icons/simple/cplusplus.svg'

I tweaked a couple of things to eliminate anything particular about my environment (in the case of Rogallo, SmolServe is used to run Zensical, to ensure there's a test server available for making the screenshots, so I wanted to ensure that it wasn't some fallout from that setup), but the problem remained.

I then hit the issues and did a quick search; it turned out it was a known issue and, in my case, was easily fixed with a quick make update (resolving the issue that markdown-exec had a small bug that had subsequently been addressed).

So, as of today, I've swapped Rogallo over to using Zensical for its documentation and, so far, it looks to be working out well. From my perspective the claim of it being a drop-in replacement is 100% true.

My only quibble: I wish they supported a zensical.yml configuration file. From what I can tell it's zensical.toml or mkdocs.yml, so no satisfying mv mkdocs.yml zensical.yml to be had here.

I think I can cope with that, though.

Peplum v1.1.0

1 min read; 5 GFI

I've just updated Peplum to v1.1.0. For anyone who might not have run into it before, Peplum is a simple terminal-based browser and reader for Python PEPs. I first released it in January last year and it's been pretty stable since. Earlier today, though, I noticed it falling over due to an unexpected value in one of the properties of a PEP.

Peplum

So this release fixes that issue. It also drops support for Python 3.10 (which is now end of life) and CI now also tests with Python 3.14 and 3.15.

Peplum can easily be installed with uv:

uv tool install peplum

Once installed, simply run peplum.

Rogallo v3.3.0

1 min read; 10 GFI

Rogallo v3.3.0 has been released. This update adds the ability to ignore some types of errors you may encounter when navigating Geminispace.

The update was prompted by the fact that, yesterday, the certificate for AstroBotany expired. Rogallo, quite rightly, alerted me to this and didn't carry on with loading the content. But it got me realising that it's easy enough to inspect the situation, realise that it's just a blip that will be fixed pretty quickly, and meanwhile you just want to get on with watering your plant, etc. At that point, Rogallo didn't allow you to do this.

So v3.3.0 adds the ability to ignore some errors that might crop up when visiting a capsule.

The ignore button

When an error is ignored, it is only valid for that host, that port, and that particular error for the duration of your Rogallo session. If you close Rogallo and start it again, you'll be shown the same dialog when visiting that host/port.

As a reminder, if an error is being ignored for the document you're viewing, the verification icon in the document title will indicate an error with its background colour:

Showing a capsule error

If you click on the icon (if using a mouse), or use the AboutThisPage command (bound to F7 by default), any ignored errors will be shown along with the other document information.

Errors in the about dialog

With all this in place, all being well, if AstroBotany has a wee certificate update lag again in the future, I should still be able to visit the Koi pond without a problem.

Well, okay, with an ignored problem.

Rogallo v3.2.0

1 min read; 7 GFI

I've just bumped Rogallo to v3.2.0. This release has one small new feature and one wee bug fix.

The new feature is something I found myself wanting a short while ago. I was copying some URIs and then turning them back into Gemtext links in another document; after doing that a few times, I realised that it might be handy to extend the "copy URI" facility in the viewer so that there's a "copy URI as Gemtext" version. To this end, I've added gemtext_link.copy_link_as_gemtext as a viewer widget binding, bound to Shift+c by default.

The fix is a small one to how MIME type checks are done. In one particular case, Rogallo wasn't stripping off any parameters where it should have. This is now fixed.

Rogallo v3.1.0

2 min read; 10 GFI

Rogallo v3.1.0 is now available. This release is in response to a recent user request.

Right from the start of the development of Rogallo, I ensured that any MIME types that the application couldn't handle were correctly handed off to the operating system, to allow it to work out what to do. While it is possible for me to do some work to allow images inline -- something I might explore at some point in the future -- Rogallo doesn't currently support this and, accordingly, when faced with image/jpeg or image/png, etc, it delegates to the wider environment.

The problem, of course, is that the user might not have a tool in their environment that's capable of taking over the duties of downloading an image from a gemini URI and displaying it. So the next best thing is that Rogallo itself offers to download the file for you. With v3.1.0 this is now an option.

If you encounter a MIME type that hasn't already been marked for always opening in an external tool, there's a new Download button.

Download as an option

If selected, you'll be asked for a location to save the file.

The download dialog

To augment this, I've also added downloading support for links in the viewer. It might be, for example, that you've already marked image/jpeg and image/png as MIME types that should always be handed off to the operating system (perhaps you have a GUI-based client such as Lagrange or Major Tom installed and it's configured to pick up the URI and handle it). In that case, you'd never be shown the dialog that would allow for downloading. So now, on the occasion that you do want to download within Rogallo, you can navigate to the link and press d. The download dialog will then appear, and you can save the content of the link that way.

ℹ️ Note

If you want to change the binding for the link-based download, you can use the recently added UI element binding facility to bind gemtext_link.download_link to something else.

For now, at least, the download process is pretty simple. It follows the same approach as acquiring the content of a URI for display purposes, but instead writes it to the file you picked. There's no "download manager" or similar and no sticky "download directory". These are things I might consider adding in the future.

Rogallo v3.0.0

3 min read; 10 GFI

It's been a while since I last published an update to Rogallo. In part this is because I've had other distractions, but also in part because I've not had a huge need to add any new features of late. For the most part I feel Rogallo is "done"1.

I haven't, however, been doing nothing with the code. On and off, over the last handful of weeks, I've been addressing something that I've wanted to tidy up since the early days of development: application configuration. The majority of my Textual-based applications use a simple JSON configuration file, and that's generally good enough. When I started Rogallo I used the same approach. Rogallo has since grown quite a lot and there's much that can be configured and so the "honking great pile-o-JSON" approach was starting to feel quite untidy.

So Rogallo v3.0.0 addresses this. The headline change is that the single JSON file has been replaced with a number of focused YAML files, and some items that were in the original configuration file have been moved out to either the data directory or the state directory, depending on their purpose.

Now for some details on the changes.

❗ Important

There are a lot of changes to how Rogallo is configured. As is mentioned at the end of this post, Rogallo will make a best effort to migrate your old configuration to the new format. However, as a precaution, you might want to think about making a backup copy of your configuration.json file before upgrading Rogallo.

Focused configuration files

As mentioned above, whereas before Rogallo kept all of its configuration in a single file, it now looks to a number of different YAML files that focus on a different aspect of configuration. These include:

General configuration

For the configuration items that remain, that aren't exactly focused on a particular Rogallo feature, the settings have moved to general.yaml.

Removal of some application commands

Rogallo's design is based around the idea of some "actions" being application-wide commands, and some actions being UI-control-specific. As I worked through the configuration changes I decided that it was time to "demote" some application-wide commands to either being UI-control-specific bindings or just simple configuration properties. With this in mind I've removed the following commands:

  • ChangeCommandLineLocation
  • StripeLinks
  • ToggleANSIEscapeSequenceHandling
  • ToggleCosyLinkNumbers
  • ToggleEmojiRemoval
  • ToggleLinkNumbers

All but ChangeCommandLineLocation are now keyboard shortcuts specific to the viewer widget itself (press F1 when the viewer has focus to get more details). ChangeCommandLineLocation is now a simple configuration property in general.yaml.

UI element action keyboard bindings

From the very start, Rogallo has supported some degree of control over keyboard bindings. As mentioned above, there's a split between "application-wide commands" and "UI-element-specific" actions. Until now it's always been possible to configure the bindings for the former, but never the latter.

In other words: you could always configure the binding for the HandOffToOperatingSystem application command (hands the URI of the currently-viewed document to your OS), but you couldn't change the in-viewer binding for the o key, which opens the URI of the focused link in the OS.

Rogallo v3.0.0 adds support for changing the bindings of the latter. So if you wanted to change o to b for opening a URI externally:

gemtext_link.open_link_externally: b

You can find the bindable IDs for each of the UI controls at the bottom of each page for each of the controls.

New Gophermap badges

Not directly a configuration setup change, but something I noticed while doing the work, was the fact that Rogallo (and the underlying Gophermap library) didn't handle PNG and RTF item types. They're now directly supported.

Conclusion

I believe all of the above changes make it easier to configure Rogallo, and more importantly easier to backup and share the configuration. Technically all of this is one huge breaking change -- everything that was in configuration.json now lives elsewhere. However, I've added some code to Rogallo that detects when you still have a pre-v3.0.0 configuration active, loads up the values, creates the new files, and then renames the old file to configuration.migrated.json. As mentioned near the start of this post, you might want to think about making a backup copy of configuration.json before upgrading.


  1. One last big thing I do want to add is support for tabs. Still to come. ↩

Rogallo v2.4.0

1 min read; 10 GFI

I've released Rogallo v2.4.0, which contains two new features.

The first is the addition of a feature related to the Gemini Protocol, and it's something I've been meaning to add for a wee while: a trusted host browser/manager. It's a simple enough idea: you might want to have a look at all the host/port pairs that exist in your trusted hosts list and, perhaps, revoke the trust for one or more.

The trusted host browser

From the dialog you can either visit the host/port combination (perhaps you got curious about what you've trusted in the past and want to see what was there), or you can forget the trust. This also somewhat follows on from work done in Rogallo v2.1.0, except rather than having to make the decision when you visit a capsule, you can review all the capsules you currently trust.

If this seems useful, it's called up with the new BrowseTrustedHosts command, bound to Ctrl+Shift+t by default.

The second new feature is something that's been on my TODO list for quite a while, and has mainly been sat there because I wanted the viewer widget in the application to settle down a bit before I tackled this. I'm talking here about in-viewer search. It's a simple enough requirement, but one that's not that straightforward when you're dealing with views of different kinds of text files, views of the source of such documents, and also having to handle things like embedded ANSI escape sequences.

The work is now done, so if the viewer itself is focused, you can press Ctrl+f, enter some text to search for, and then press Ctrl+n to keep moving through all the hits. Once you hit the last match, you'll be told there are no more matches, but then the search will start again from the top.

Performing a text search

You can also cancel an ongoing search with Ctrl+Shift+f.

I'm glad to finally get this added to Rogallo as it's a feature I've been finding myself needing on a good few occasions.

Rogallo v2.3.0

2 min read; 8 GFI

Rogallo v2.3.0 is now available. The main addition to this release is support for the Titan Protocol.

First up, there's a small fix. The other day I discovered Scriptonite. While looking at the examples I noticed none of them worked with Rogallo. This struck me as odd because the whole point of Scriptonite is that it all happens on the server-side; nothing on the client-side should affect how well it works.

It turns out that Wasat had a bug when it came to slicing and dicing Gemini URIs, where parts of a URI that followed a ; were being lost. Somewhat amusingly, I didn't even need to do any work on a fix because it had already been taken care of in the branch that existed to support Titan.

The point here being: as of v2.3.0, Rogallo now works fine with the Scriptonite examples.

As I mentioned, the main change in this release is support for the Titan protocol. It's been on the TODO list for a wee while, partly because I was struggling to follow the idea of it, and also partly because I'd not played with it and just didn't see the purpose. The other day I sat down and properly dived in and it finally all clicked.

With v2.3.0, if you now visit a titan:// URI, you will be presented with a rich input dialog. It is a tabbed view, with one tab being for text input/upload:

Titan text entry

and the other being a file attachment and upload:

Titan file upload

As per the Titan specification, there is support for setting the MIME type for the attached data. If using the text view, this will always be set to text/plain. If using a file attach/upload, you have full control over it, but it will default to the best guess based on the file selected.

There is also support for entering an upload token.

As well as supporting the core Titan specification, I've also added support for the proposed ;edit extension. This means that it is safe to enable Titan-based editing on bbs.geminispace.org, making it easier to modify text you've already written.

Editing a post with Titan

One final change in this release of Rogallo also relates to user input. I've given the Gemini-based input dialog an overhaul. Originally this was, by design, as simple and as bare-bones as possible. It was simply a free-text input box that would grow as you added lines, and the prompt from the server was shown as a title in the border of that box. While testing out editing on BBS, I realised that this doesn't always work so well; most of the time the prompt would get truncated.

The input prompt being truncated

Not a great user experience. The redesigned input box works more or less the same, but now ensures that the prompt is fully visible.

The new version of the input box

Between this change and the new Titan edit/upload dialog, I feel Rogallo is now in a good position to act as a near-zero-compromise daily driver when it comes to wandering around the small web.

I guess adding tabs will get it closer to zero. Perhaps in-terminal image viewing. Okay, perhaps a sprinkle of http(s) support too? Also...

Rogallo v2.2.0

3 min read; 10 GFI

Rogallo v2.2.0 is available. This release contains a handful of small new features and also a very minor cosmetic change.

First to the small cosmetic change: the overall design behind the UI of Rogallo is that it's split into a couple of key panels -- the side-panel and the main viewer. The styling of a panel when focus is within it, and when it is outwith it, is different; the idea being that your eye should be drawn to the active panel. This is an approach I take with all my Textual applications.

Part of this styling is to have a thin border to the left of the active panel, which also helps signify that the panel is the one you should be paying attention to. In applications where there's always two or more panels on the screen all the time, this makes sense -- you want the line between the panels anyway to help break up the content. In Rogallo, however, it's going to be normal to only ever have the one panel in view (the viewer).

The other day I realised that, when it's just the viewer available, I should remove that left-hand border. So that's how Rogallo works now. If the viewer is the only panel visible: no border. If the side-panel is also visible: borders. I think it makes the display look a little cleaner; for what it's worth it also saves one column of the display for something more useful.

I've also added a couple of useful features to the active link in the viewer. Now, when a link is selected, you can press c to copy the URI of that link to the clipboard. You can also press o to open the URI by passing it to the operating system. Both these changes should make it easier to take a link out of a document and go and do something else with it.

The last couple of changes are around visiting finger:// URIs. The first is a quick and simple change: any finger content now makes use of Rogallo's document cache, so if you find yourself navigating back and forth between finger responses, there should be fewer requests made in a short period of time.

I added caching partly in anticipation of another change to finger responses: making them interactive where possible. Having created finger2gemtext, I've updated Rogallo so that, where possible, the response is turned into Gemtext and anything that can be turned into a link is now interactive. This means that some finger services should be easier to navigate, no longer requiring that you copy/edit/paste text to get a fresh finger:// URI to follow.

This can be seen if you visit somewhere like finger://plan.cat or finger://redterminal.org/. Whereas before you would just be shown some plain text:

A plain text finger response

Now you get a version that lets you follow the implied links in the response:

A richer finger response

This is, of course, going to be reasonably brittle. If any of the services change their output format such that the "links" can't be detected any more, the output won't be turned into Gemtext. Likewise, it's not impossible that false positives might turn up. I'm going to run with this for a while and see how it works out. I also have a vague plan for how the detection and smarter rendering of finger responses could be made configurable by the user.

Anyway, that's it for this release of Rogallo. Now I can return to the main change I was making a start on this week: Titan support. I've not so much been putting it off as I have been allowing myself to get distracted by the above changes -- mostly because I don't quite get Titan support yet and I don't have a good location to play around with it. Time to solve that problem...