Home
Welcome to the changelog (and blog) for Shule.
3 November 2026 (Tuesday)
I released Shule 0.11.0, today (sha256sum on the file should yield f072a7ff2ea0b3329c15568b5b1c423e36dc4af81d36557ed6de38bb8e46ba28). I would have waited longer and added more features and fixes, but the bug fixes with the search and replace with whole words only were pretty urgent.
This release adds more compose key codes. It begins to explain the convert menu (not finished). I removed an item from the convert menu as I already mentioned. Many prompts were added to features that didn't prompt you if you wanted to do them. Many showinfo boxes were added to let you know that something did happen that was supposed to happen. The reading mode feature is present as afore described.
This release doesn't add the new Wikiweb functionality I had mentioned (that may take a while), but it does add menu items for the already-existing Wikiweb functionality. I did add the ability to set the project; that was already in the source code, but it wasn't accessible at run-time except when the other methods needed it. I also added some are you sure type prompts to make it so you don't use these features on accident. I still need to make a way to actually view what's in the database without exporting to HTML every time, though (entering data and exporting your projects to HTML is mostly what you can do with your data inside of Shule at present, but you could take it outside of Shule and do other stuff with it, programmatically). I need to make a way to navigate the database, too.
The new functionality I want to add is basically input prompts for entering data for small units of data, reports, and such, and ways to access the text files associated with the nodes. For entering large amounts of data, you would want to do the text-only data entry method.
With regard to the text-only data entry, you probably don't want to mess around too much with pin inheritance, since although it should work (not quite like I had hoped, though), it's programmed in a way where it's easy to make mistakes and mess up your database. Sticking to the more fundamental and seemless commands is probably a better idea. Just do regular pinning, unless you're prepared to accept the additional risk, or unless you're just learning.
One problem with the text-only data entry is that there's the temptation to never start over, but just keep the old entered data along with the new so you can see what you've already done (and while you can do that, that was never the intention). This is one of the reasons we need a standard way to view the database and access reports in Shule. It's possible I already made commands that do something similar in the text only data entry; it's been a while since I've worked with it much (I'm pretty happy with the custom/file/directory indexes, and they've been taking my focus).
Wikiweb itself does have methods for reports and things; they're just not implemented in Shule, yet (as far as I know, as aforementioned). Anyway, part of the reason I called it Wikiweb was because I wanted a faster and more flexible/functional way to enter data for a website that displays things wiki-style (that is, the article category model--except I wanted a lot more than categories; therefore, we have context pairs and relations instead). I was tired of doing things so tediously with MediaWiki (it takes a lot of time and Internet to interlink 500 articles lots of ways, whereas with with Wikiweb, that is trivial; I'm sure they made it tedious on purpose, though, so people couldn't totally vandalize the site into something unrecognizeable in short order). I did plan to add users to Wikiweb so it could actually be used for wikis, but as-is, it's for regular websites that don't particularly have a content management system. The main benefit isn't multi-user editing (you can't do that); it's quick data entry and quick structure creation.
2 November 2026 (Monday)
Oh wow. I found some pretty major new bugs with the whole words only option in the search and replace that didn't exist until recently (don't the whole words only option with replace all, replace or count in Shule 0.10.0; use regular expressions to get the same effect instead; wait for the next release, which shouldn't be long before it comes out). In looking at the code, I'm not sure why the same bugs didn't exist until recently (it's plainly coded to produce the bugs), but they didn't. It's really weird. It's like the code changed in my sleep or something (I need to examine earlier code where it did work; fortunately, I have lots of versions of it, including versions from before I released it online). Anyway, I know the bugs didn't manifest, because I used the feature extensively for about 15 years and it worked fine, as expected (and I did periodically test it to make sure, just because I do that sort of thing--call it paranoia if you want). I'm not sure when the bug started, but it wasn't that long ago.
Anyway, it's mostly fixed now in my version of it (count and replace all work fine again), but I still need to get replace and find and replace to stop replacing selected text that it shouldn't (nevermind that it's not naturally selected for it to delete in this context; so you have to try to produce the rest of the bug).
Okay, it's fixed, now. That's a relief. I need to go and tidy up the code. There's lots of old code I haven't used in many years there, and there are if statements that purposefully can't arrive at some conditions (with lots of code in those conditions); I did that in case I needed the old code (and for documentation of what I wasn't doing), but if I need it, I can just find an old version of Shule.
I tidied up the code.
It looks like I needed an edit separator in Editor.replace_handler(), too. Yikes. I added the separator. It did work like there was one in the recent past, though. Maybe I accidentally deleted it or deleted something that used to indirectly trigger it.
I found a spot where this is no edit separator that still acts like it has one. I added one just in case (redundant edit separators don't seem to be a problem). It might be required with a future operating system, Python, or Tkinter update.
Okay. That was embarrassing. Now onto other things! Like maybe Wikiweb-style indexes (which I intend to name something else).
I'm having second thoughts about implementing archive indexes, but I probably will add them anyway. The reason I'm having second thoughts is because a single file can be corrupted a lot more easily than zillions of files (and longevity in data-persistence is something I try to prioritize; I'm not talking about I'm talking about user-created content). So, if I add it, I think I will do a redundant backup attached to it (or let you decide on a number of redundant backups and warn you if you choose zero). No, I'm not planning to do this with squashfs's native redundancy, as I don't think that would work (unless maybe I use `-no-duplicates` and `-no-fragments` and make a redundant superblock). I'll probably just concatenate them together with a funky delimeter that no one is likely to use for anything (to be safe). I might as well add useful information in the delimeter, too, like a hash of each file.
31 October 2026 (Saturday)
I fixed the ten-key pad keys, which apparenty, in Kubuntu, don't work the same as they used to in some period of history on Xubuntu. Now I hope they stil work in Xubuntu, too. So, the up and down keys work again. Delete works. The ten-key pad insert key currently purposefully does nothing (it's not a compose key like the other insert). I plan to use it for something eventually, but I'm not sure what. I might make a compose key, I guess. Or I could use it as an actual insert key is supposed to work (I think I'll make a compose key for that instead, though).
Anyway, I'm working on a reading mode option, but I haven't decided how it should manifest in the next release, yet. Currently, you have three options when you press Menu+rmo, which allows you to configure what the ten-key pad insert and delete buttons do.
I still need to make a menu item and compose key for it, but I made it so you can start Shule without a menu, if you want. Surprisingly, I don't notice a performance difference (it's pretty fast either way). Back in the day, I noticed increased startup lag the more menu items I added.
I plan to make it so you can start Shule without a tab bar, too, and just have logical buffers instead.
Yesterday, I added a bunch of new compose key codes for menu items without them, and I worked on the help documentation for the Tools->Convert menu. In the process, I removed the numbers to password text menu item.
I added more ellipses to menu items, and updated the functionality of a number of methods safer (for instance, now Shift+Esc prompts you before restarting).
I'm not quite done with the deleting of indexes feature. When you delete the current index, it currently doesn't give you a new current index (I'm deciding if that's a good or a bad thing).
30 October 2026 (Friday)
I added more compose key codes (for indexes).
I continued working on the option to delete a particular index. Currently, it doesn't actually delete any base directories nor their keys (that wasn't actually my initial intent), but it does delete the references to them in Shule.
I fixed Menu->Tools->System->Update compose so it no longer tells lies (an update I did a long time ago had a bug). I just took out the buggy option instead of fixing it, for now, since the choice was kind of confusing anyway, and I needed to go to bed.
29 October 2026 (Thursday)
I released Shule 0.10.0, today (doing `sha256sum shule_0.10.0.tar.bz2` on the command-line should yield d92a53e2a3cf86b2e6b7966f8d6d6d025080d1c7eeb10e3cf90b582899a7cd26). This release mostly adds configuration options for the mousewheel-click and the right-click on the mouse, within Shule. I added this information (and a little more) to the help documentation.
I think it was this release where I fixed it so launching LilyPond PDF files no longer opens a terminal emulator with it. I didn't know it was doing that until soon before I fixed it (I think that bug was introduced with recent changes (when I was trying to implement better subprocess parameters).
Lest you're curious, I check the hashes both before uploading Shule and after downloading Shule (well, now I do; I didn't do that the first time I included a hash several versions ago).
I noticed an issue where if you scroll the mousewheel while browsing the menus, it selects whatever the mouse is over. Hopefully that's an easy fix, but for now it's a feature.
Okay, I'm back. I made many attempts, but nothing removed the mousewheel scroll selecting menu items (so you just have to live with it for now).
29 October 2026 (Thursday)
I fixed the mousewheel paste so it doesn't trigger inappropriately upon release after the shift+mousewheel-click dialog opens (while it is open), so it doesn't lose focus. Shift+right-click didn't have this problem, since it pastes on press rather than with <> (which I had to bind to prevent erroneous pastes from the system), although I guess I didn't have to make it do something.
I plan to make it so you can delete individual indexes from Shule's persistent data. This isn't crucial, since you can just overwrite it if necessary, and ignore it if not.
28 October 2026 (Wednesday)—11:17:12 PM
I added the option to configure the right-click and/or the mousewheel-click to copy by selecting things. It doesn't use the primary selection, though (just the regular clipboard). I was going to add the ability to have any number of in-app clipboards (including an in-app emulation of the primary selection), but I didn't feel good about that for reasons I don't know. So, that's not the direction we're going. However, I do want to add the option to encrypt the clipboard:
I'm thinking about adding an option to encrypt the clipboard data prior to copying (which would allow for seemless copying/pasting in Shule, but if you pasted outside of Shule, or outside of other supported apps, then it would paste encrypted data).
27 October 2026 (Tuesday)
I made it so you can configure lots of different options for the mousewheel-click behavior (shift+mousewheel-click) and the right-click behavior (shift+right-click). The defaults are still the same, though (custom index for right-click and offline dictionary for mousewheel-click). I also put these configuration options in the Tools->Misc menu.
I set the options for configuring the buttons to be these (for the next release; you type in the option you want):
• `copy and paste` (`copy`)
• `cut and paste` (`cut`)
• `offline dictionary` (`dict`/`dictionary`)
• `custom index` (`custom`)
• `directory index` (`dir`/`directory`)
• `file index` (`file`)
• `directory file` (`dfile`, `dirfile`)
• `web directory file` (`web`)
• `backspace`
• `delete previous word`
While I liked the simple toggle from Shule 0.9.0, I appreciate typing it in because it's hard to accidentally change it this way, typing it in helps you remember which option you chose, and you get more options (plus you can see the current setting with the initial value of the input box).
In my previous entry, I neglected to mention how copying works with mouse-only copying. Just select text and click (you don't particularly have to click on the selected text, as long as it's selected and you click). If nothing is selected, it will paste. With today's changes, you also have the option to cut and paste instead of copy and paste, and there's also an option to mimic backspace and control-backspace with the mouse.
Yes, I still need to spruce up the `web directory file` feature.
Yes, there's still no context menu. I might make that an option some day now that you wouldn't actually have to have it (probably just a frame with a stack of buttons on it instead of a traditional Tkinter context menu).
24 October 2026 (Saturday)
I released Shule 0.9.0, today (the sha256sum is ca14ca16fe9231da83243c2db4776ebe3d04d1dde0bfc0910ab412a5c1101ce3). This one introduces the shift+mousewheel-click shortcut that toggles the mousewheel click copy/paste on and off. It also adds some additional backup/restore options for the compose keys. It also adds some more informative showinfo boxes and stuff like that (for backup/restore dialogs and adding/updating/deleting compose key codes). I made the difference between some of the index menu items more clear. I updated the documentation somewhat. I made it so the backup/restore methods use json instead of pickle, except for the one that does all the settings (that just compresses them and decompresses them into the right spot). I made the default folder different for backups and restores, except for color themes (I need to improve that, but there are more complex implications in changing it).
23 October 2026 (Friday)—10:41:28 PM
Fixed. Here's Shule 0.8.2 (The sha256sum is a994181f719f975b22779a98b38534679ed50646727000369628eb6239cafc2a).
23 October 2026 (Friday)—7:07:45 PM
Woops. I introduced a mousewheel-click bug with that release (I guess I only ever tested it with one tab open; so, it did the showinfo boxes way too many times if you had more open). I need to fix that.
23 October 2026 (Friday)
I released Shule 0.8.1, today (the sha256sum hash should be bc6d6f3b787bfdb74d14888fab320878e93859ce700691a6aed66ec01cf6cb70).
The following improvements except where otherwise noted are included in this release:
Evidently, I hadn't completely fixed the middle-click paste issue (after many times of having thought I fixed it), but now I'm confident that it really is fixed. Hopefully it is! That is, now it does the dictionary lookup reliably instead of pasting sometimes. However, if you actually want it to paste, now it should reliably paste instead of doing a dictionary lookup if you toggle it with Menu+mbc. It's just the regular paste, though. It doesn't automatically copy the selection without your say-so (but I don't have anything against adding that as an option).
I fixed the find dialog so the replace dialog keyboard shortcuts no longer work in it.
The installation files now tell you that you should use the command-line if you try to execute them from a file manager.
I fixed a few other minor things, including in the help documentation and the menus.
I tried the add the ability to specify the download folder for Menu+dow, but it turns out I have it programmed to make that a complicated task. I may have to reprogram the whole thing. Other than having to use the `~/Downloads` folder all the time, it should work great, though.
Special thanks go to msw and user4934382 of stackoverflow.com for pointing out the correct keybinding (`<>`) to handle the mousewheel-click paste events in Tkinter (even though the question wasn't really the same as mine). Hours querying AI chatbots didn't tell me that (nevertheless, I should point out that a standard keybinding doesn't affect what the license of the new code has to be, so you can still use any new code I've written since Shule 0.1.0 under the MIT license, even if the license of the old code still probably means you have to dissect it out of Shule and compare it with the first release to find out if it's new).
22 October 2026 (Thursday)
I released Shule 0.8.0, today (the sha256sum hash should be 87e976ec7b7fee8d196a403e2931e21c5b40b89c101bb2eb20907d8a5a0b45c4). There are a lot of pretty major changes, described in previous entries since Shule 0.7.0. Additionally, I made these changes:
I disabled the re-open with root feature, for now, as 1. it doesn't work, and 2. it doesn't conform to modern security standards. I plan to reimplement it, though.
I disabled the clipboard history. Just use KDE's clipboard history (which you pretty much have to use if you use KDE). It's pretty nice.
I fixed lots of random bugs.
I updated the installation files. They should no longer run in file managers if you execute them (just from the command-line). It now prompts you whether or not you want to install the default Firefox from apt. The UPDATE file is more informative, and prompts you about stuff.
I removed the keyboard shortcut for randomizing Shule's colors and added a fairly long compose key code for it. I liked it, but maybe not everyone would. A major thing I used it for was to discover new color combinations that I liked (I would just press Ctrl+9 over and over until I saw one I liked).
I added a disclaimer showinfo box about random e-texts.
I updated the pre-built themes to have a color setting for the file dialog folder color (fortunately, they're plaintext; so, all I had to do was edit them instead of loading them and changing the color and saving them again).
Some major improvements already mentioned include these:
• Password entry is more secure (the passwords you enter for symmetric encryption are no longer ever on disk, even for a fraction of a millisecond--they are still in RAM and such, though).
• Custom indexes, file indexes, and directory indexes each exist, work as intended, and work very much like each other. You can set a unique file extension or file extension style for each index (not just each index type). This isn't baked into the index itself, but is related to the filepath of the index, and isn't crucial for the data in the index.
• I updated the help documentation somewhat.
• You can use websites kind of like indexes, too (Shule is now technically in the early stages of being a plaintext web browser), but this is still only slightly complete. The way that works is first of all you select a website URL and ctrl+left-click on it. Then it downloads the index.html file (visibly, in xterm [that was a simple way and informative to provide a progress dialog that you can easily cancel]) and loads it into Shule (as plaintext). If you ctrl+left-click on a word or selection after that, it goes to an HTML file on the same website that corresponds to that word (so if you ctrl+click on `horses`, then it will load `horses.html` from the same website). Unfortunately, I probably still need to program it so it doesn't keep doing this when you leave the website's files if you ctrl+left-click on stuff (and I have lots of other improvements to make).
• I updated messageboxes in search/replace dialogs to go over the dialog instead of sometimes behind it.
• I fixed some unhandled exceptions in the search/replace dialogs.
• The statusbar is more efficient.
One bug I forgot to fix is when you're in the find dialog, if you press Alt+a, it will activate replace all from the replace dialog. I imagine the other replace dialog shortcuts might work, too. For now, consider it a feature, I guess, and remember you can do ctrl+z in the editor to undo it. However, after using Shule for many years, I never accidentally used it until one time recently (hence the bug still existing).
I also forgot to add ellipses to the random e-book features. (I already fixed that for the next release.)
The installation files now notify you if you execute them from a file manager to use the command-line (this is also for the next release; not 0.8.0).
21 October 2026 (Wednesday)
I updated the security of the password entry for opening and saving passphrase-protected (specifically, symmetrically encrypted) files in Shule. Now, the passphrase should never actually be on disk. Before, there was a brief (very brief) window where an attacker on the same system could in theory have stolen a file containing the password (although I didn't make it super easy for them, especially if they used old software); it was only in a file so the password wouldn't show up with the pipe in the task manager. Now neither of those things are even an issue, but it would be nice to make it even more secure so attackers couldn't scour the RAM or swap areas for the passphase (as they presumably could for any regular Python string in any Python program).
Anyway, I've been wanting to fix this issue (the one that was fixed) for years, and it turns out, mostly all I needed was an extra argument. No messing around with file permissions and groups.
Text files are pretty small (usually). I'm considering for the archive indexes having a redundant copy of the archive appended to the archive and having Shule check both to see if they match a hash--to ensure one wasn't corrupted and that if one was, you can still access the other and repair the corrupted one. Either way, I want to have built-in hash verification as proof of the file's non-corruption or corruption.
This makes me wonder why all files don't have their hash after the last successful modification as metadata (well, other than performance). I'm not saying I don't actually know the answer to that, but one can dream.
17 October 2026 (Saturday)
I changed the code so most of the imports no longer do such as `from tkinter import *` and `from tkinter.font import families`; instead I just do `import tkinter` and `import tkinter.font` and then do such as `tkinter.font.families()` when I need to use it. So, now you can actually tell which modules what came from (there are a few others I need to fix, but the bulk of it should be done). I'm told that in Python this doesn't have a performance disadvantage (so, I don't see a lot of reason not to do it, other than brevity and to show you at the top what you're using from it without searching). I made a point to stop doing the former kinds of imports a long time ago, except in Shule, since I was already doing them and it was a big project. My one lament here is that I use `tkinter.messagebox.showinfo()` a lot, but I should get over it. This should incentivize me to build my own message dialogs (not just my own input box).
Fixed some old exceptions that I hadn't realized were there. There were some hiding in the find and search and replace dialogs, if you had an empty search box and pressed buttons. I fixed it so when you press Ctrl+g on the first run before opening the find dialog that it lets you know what's going on instead of doing the following: doing nothing, even if you have search data that should be there from a previous session (for now it just launches the find dialog in that case, after telling you that it needs to do so to build the dialog). I fixed some exceptions in pretext.py with pageup and pagedown when you there's only one line in the document.
Anyway, I spent most of Friday before that figuring out what I wanted to know about squashfs, and planning design decisions (without actually programming, except on other projects).
16 October 2026 (Friday)—4:38:11 PM
I changed my mind about squashfs again. It's awesome like I first thought, but the default settings are not what I need for zillions of plaintext keys in an archive index! :) Instead, I want to do stuff like this: `mksquashfs /path/to/source_dir archive.squashfs -b 4K -noappend -no-compression` (or use `-comp zstd` or `-comp lz4` compression algorithms instead of -no-compression, depending on what I want).
16 October 2026 (Friday)
I've changed my mind about squashfs; it has a lot of potential, but for some things it doesn't work as I expected. I'll probably just do traditional archives. Well, maybe I just need to try the right block size.
16 October 2026 (Friday)
Okay, I'm done with the file, directory, and custom indexes for now, except some debugging of new features that I'm too tired and stretched for time to do right now.
It turns out that the renaming and deleting methods didn't actually need that tab data after all. So, I just deleted it and re-enabled the code that I disabled with it for some reason. It works great.
I added the ability to clear settings and to set defaults for what the settings are for new indexes. I still need to make compose key codes for them all.
I'm hoping to release Shule 0.8.0 soon.
I'm planning to add offline public domain scripture look-up methods (for at least The Book of Mormon and The King James version of the Bible).
I'm planning to add archive indexes (using squashfs); essentially, these are planned to just be one of the other kinds of indexes with some archival functionality wrapping it.
I need to finish the online indexes (but I want to integrate archive indexes with that; so, perhaps I should do archive indexes first).
I'm still planning to add functionality for Wikiweb-style indexes (or something similar to indexes).
15 October 2026 (Thursday)—2:18:45 PM
Okay, the custom, file, and directory indexes should all work as intended now. I found the bugs I was talking about and found what caused all of them (except the one bug with the tab data I fixed by removing the tab data and the code that used it; indexes no longer use tab data to figure things out). My set_index_value method was overwriting some values with the defaults when it shouldn't have (including some I hadn't experienced errors for, yet). There were a couple hidden TypeErrors that didn't print anything. I didn't have it check to see if keys were directories. I updated the code so I understand it more. I had the wrong variables in one input prompt and possibly on a showinfo or two.
Now I need to fix the file renaming and deleting so it takes indexes into account again (another way, hopefully).
I still need to make it so you can set the default values for new indexes (right now, you can only set the values for existing ones).
I also still need to make it so you can delete custom indexes, reset index data and all that. You'd think you might use this currently-absent feature more than you actually do, though. I've only rarely and fleetingly felt the need. I mean, you can always overwrite current persistent data and ignore unused persistent data.
14 October 2026 (Wednesday)
Okay, so the code for the indexes is a lot closer to being done, now, and I spruced up most of the old code and removed the link to the tab variables. I found a number of issues and fixed most of them. The remaining bug I've found is this: File indexes and directory indexes are getting their initial value for setting the file extension from the most recent custom index for some reason, it seems. I haven't looked into it more than a little, yet, but they're setting the file extension style just fine, so it shouldn't be too big of an issue, I hope!
It might make your head spin a little if you're changing settings for lots of indexes instead of just a few, because they're all different and the program will remember the settings even if you don't. But, that's how it's supposed to work. Hopefully I can reduce the headspinning, somehow, though.
Some of the fixed bugs were in my smaller supporting methods instead of the giant one, which surprised me. I mean, I neglected to make some of them aware of the fact that determining the base directory isn't as simple as they assumed. Whether you're in what kind of base directory already determines what the base directory is for what kind of base directory. So, now we have more supporting methods that simplify that, and a lot of it is thanks to a method I made the other day that I didn't even intend to use for this (but it seems to work perfectly and makes the giant method more straightforward, too).
Oh, I just noticed when closing my debugging instance of Shule that I've got an IsADirectoryError to resolve, too. It will have to wait a number of hours (maybe about ten).
13 October 2026 (Tuesday)
No wonder I was having persistent data issues. I didn't even use the method for getting the base directories of file and directory indexes, although I did program it! Now the bigger question is, why is it still working? It must be the tab data (some of that is still important for renaming files with indexes, though). :) Of course, I could just reprogram my key-fetching method to make everything transparent, but I want to try to figure this out before resorting to that (not just because I'm almost done and it would be a huge method to reprogram, but because it's great mental exercise, and it's intriguing; I mean, figuring out how my old code works and interacts with new code is something I like to be able to do).
I want to make word-wrap tab-specific. That would be so useful. Why am I not doing that? Well, I would need a default word wrap for when you open new tabs and restart the program, but the old tabs need to be able to override that (and both settings need to be able to be set). I probably didn't do it because it's complicated, I maybe didn't think about a valid way to do it back then, and I probably thought it might weird people out--but I think I can manage it better these days. The overriding setting doesn't have to be prominently featured; it can be a compose key code (and it wouldn't affect the persistent data); so, no one would get weirded out.
Well, I'm thinking every tab will automatically have it's own word wrap settings, but the global settings are only for the initial tab and new tabs, but we still need to determine what sets the global/persistent settings. Do we do the last tab set, or have a dedicated setting for that? To me, the dedicated setting makes more sense. It does add more options, but I'm not someone who likes to oversimplify options (if they're actually useful and don't get in the way, nor slow things down, I say, keep them). But yes, Shule does have a simple interface, and I don't plan to change that. Most of its features are not on the surface.
So, I'm thinking about implementing some squashfs features. Squashfs is nice since it's way faster than tar (including when mounted) and accomplishes similar things (plus you can compress it in the same file format, without another on top of it, and it's still fast). I'm planning to do Wikiweb-style indexes. It might be cool to use RocksDB with them for the persistent data (instead of pickle) and put it all in a single squashfs file (to make it one file). I'm toying with the idea of making my own e-book format that uses RocksDB, MessagePack, and squashfs, for super fast e-books (this is kind of like the word processor idea I already mentioned, except it wouldn't actually have to be designed for such massive scale--although it could--and it could be a lot easier to program). Maybe I'll make it use Markdown instead of HTML (there's something to be said for readability). I really don't like CSS in e-books (or even websites--or even anything), either. It obfuscates everything, and it's hard for third-parties to parse. If you take a look at the source code of this website, you will find precious little CSS and JavaScript. There's a reason for that. I actually write this in source code form inside of Shule (so the file largely resembles a plaintext file with a little HTML at the beginning and end, and infrequent usage of italics, bold, underline, and links).
12 October 2026 (Monday)
I programmed the indexes to a functional state, but the persistent data on file indexes and directory indexes needs to be fixed (it gets the base directory right; so, it's mostly just the autofilled stuff that isn't always autofilled and/or autofilled correctly); I think the data for the tabs might be overwriting the persistent data with less dimensions. Those indexes do work, but I didn't write it all from scratch after all. My tests seem to convey that the most important stuff seems to be done, though, and I love it, so far. :)
I thought of a way to vastly improve the indexes several days to weeks ago, but unfortunately, I didn't write it down, and I forgot. Hopefully I'll remember it. It was a feature change (not a performance improvement); specifically, it was a way to make switching between indexes more convenient for those who aren't used to it yet (however, the current way has been growing on me since the indexing features have been maturing and becoming more fun: yes, the indexes are a fun feature, if you ask me; very mentally stimulating; very liberating; very useful).
I'm thinking about adding scrolled listboxes so you can select your custom index base directories that way instead of having to remember their names (I'd probably keep the current way, too). I made it mandatory to name them (this helps make it easier to actually remember that you can switch them by their names and it gives you practice; it's easier to program that way, too; once you have practice, it's so much more fun than only using one custom index base directory except on rare occasions).
10 October 2026 (Saturday)
I reprogrammed custom indexes (and much of the directory and file index functionality), but it's not 100% done, yet, and I'm still debugging it. I need to add and/or integrate supporting methods.
10 October 2026 (Saturday)
Well, I encountered some mysterious bugs (after attempting to give unique settings to every custom index). So, after a lot of analysis and the bugs still being mysterious, and because the code needs further changes anyway, I'm re-writing the index code. When I'm done, even the file indexes and the directory indexes should have unique persistent settings per index that aren't files in your actual base directory (not just the custom ones).
Fortunately, it can be easier to write code a second time when you have a better idea of what you want, and aren't working on code that has been patched up about five times already to support better functionality. But yes, I did make a backup of the code from before it had mysterious bugs.
Custom index settings are each identified by a user-entered name (the user selects them by these names, and the names are keys in a dictionary in the settings that identifies their settings). File index settings and directory index settings are to be identified by their base directories (instead of names) in the same way, since the program already has access to that. A a filepath and/or the hash of the archive could be used to identify a particular archive index's settings.
9 October 2026 (Friday)
I switched what the mouse wheel button and Alt+left-click do.
I began working on making it so each custom index has its own persistent last key, last key directory, default file extension, file extension style, and such (without requiring any settings files in the base directory). They all shared the same ones before, and that was kind of confusing. I'm not done, yet, but I need to sleep and stuff like that.
I gave data_dir (it's one of the modules Shule imports) the ability to do jsons (although I should probably do it better), although nothing actually uses that feature, yet (and I need to re-write the feature, maybe). In doing so, I've realized that I could stand to rewrite (or at least edit) a lot of my old code from 2014 and before! Data_dir didn't originate with Shule. I forgot what I used it with initially, but it seemed like an intense project (before Shule existed).
8 October 2026 (Thursday)
Now when you're in a custom directory and attempt to access a directory index, it will access the directory index corresponding to the directory that contains the custom index's base directory (as previously planned). I also updated the help documentation (adding Menu+hpa).
I fixed a bug where I had an elif where an if should be, where it didn't let new base directories be created in some circumstances (this required another condition to fix).
7 October 2026 (Wednesday)
I decided to rename the file index base directory extension to `.目录`, for a few reasons. One, it's short. Two, the meaning should be appropriate. Three, it's very unlikely that a user will make that a file extension manually. Four, it's easy to identify visually (while .file_index looks more cluttered and obfuscated); this is helpful both for people using the index (such as when choosing a subdirectory for a key within an index when creating a key) and for me as a programmer, so I can see where it is in the code without strain.
I updated the rename function (F2 within Shule) to make sure it is aware of file indexes (so, if you rename the file, it renames the file index's base directory, too; it updates it in the favorites; it updates it in the open tabs). I did not update the delete function. I think it's okay if they're just not deleted (you can delete file indexes manually; better than deleting lots-of-work-you-really-should-save on a whim).
I made it so the `open/create directory file` functionality uses Editor.split_ext just like the indexes do. Also, the shortcut to play LilyPond MIDIs was updated to use it. (Yes, Shule has had some support for LilyPond since soon after I made it).
I'm planning to make another kind of index: archive indexes. These are very important (including for online use, since you could download the whole thing at once and browse it). The basic idea is that you treat the root of the archive as the base directory and it otherwise functions the same as the other indexes.
Just so you know, Shule does not autosave files. This is intentionally a missing feature of Shule. You're supposed to save your files consciously and often in Shule (ideally with ctrl+s; ctrl+8 will save all tabs), and avoid saving them when you don't want to save them. Saving is fast, so you don't need to worry about it taking a long time (unless you're doing it over a slow network). The basic idea is, you are responsible for your content (not Shule; Shule provides tools; it doesn't act as an overseer of your work; you are free). Similarly, spellchecking only works on a word-by-word basis (currently; I might implement something more advanced in time, but I really want to avoid putting squiggly lines under suspected misspelled words).
Oh, I realized compose keys are nice for language learning, including Chinese, because you can make compose key codes for whole words, like 目录, for instance (I made a custom code of 'fi' on my right windows key for that). So, I don't have to copy it paste it all the time. Yes, compose key codes aren't limited to outputting a single character. You could put a whole document in one, for that matter. They can work kind of like templates, too. You can make a custom index for learning Chinese, or whatever other languages you want, and make two entries for each word you learn.
I could be wrong, but I think the current index features are almost done.
I eventually plan to make an index-like system (to accompany--not replace--the others) that does Wikiweb justice (this wouldn't just be plaintext files, though).
6 October 2026 (Tuesday)
Having indexes in indexes proved to be an issue (it was confusing [error prone for the user and hard to track] and it conflicted with the goal of having every index key be unique, since there would be two or more indexes and all and they would need to be aware of each other's keys). So, I got rid of that ability (mostly; you can still put custom indexes anywhere; I need to fix that). I'm happy with the decision to discontinue the index-in-index feature.
While these changes in large part address the issue of accidentally using one kind of index when you mean another, I'm investigating further changes there. For instance, I'm considering the ability to toggle off other index shortcuts while you work in a specific one, and use Ctrl+k for the one you're using.
I plan to have it so if you try to use a directory index inside a custom index, that it will instead access the directory index of the directory that contains the custom index's base directory. This is intentionally how file indexes already work when you try to access a directory index in one, as it's a natural thing to want to do. So you should be able to do this with custom indexes even if you set a file index to be a custom index and access the directory index of its base directory's parent directory.
There are lots more things I've considered (not particularly related to indexes).
If I make a cross-platform version of Shule, I'm considering using Qt for it instead of Tkinter, for things like syntax highlighting (you can program syntax highlighting in Tkinter, though, but it sounds easier to do without significant speed-sacrifices or licensing issues in Qt). I may make it so it can render markdown into rich text (but that would be a mode; not a replacement of text editing powers).
Oh, just so you know, I haven't used Stackoverflow for a source since long before I released Shule 0.1.0 online. So, any changes I've made since then are usable under the MIT license; I just mean the changes/updates (not the remaining older code, some of which still would need to use the CC-by-SA license).
5 October 2026 (Monday)
I'm still working out some issues with the indexes. I wrote a new Editor.split_ext() method since os.path.splitext() didn't distinguish between periods in a sentence and the period for the file extension. So, now you can have index keys like `This is a sentence. And another.` that still have a file extension separate from the key text (keys should be able to be complete sentences, ideally); so, the example filename would be `This is a sentence. And another..txt` and it would work (and the new code doesn't treat `. And another.` as the file extension). Editor.split_ext() doesn't take paths (only filenames; so relative paths aren't considered). Leading and trailing periods are allowed as part of the filename and at the end of the file extension. Space isn't allowed before or after the file extension period. Like os.path.splitext(), It only treats the last file extension as the file extension (so, `myfile.one.two` would just treat `.two` as the file extension instead of `.one.two` [I need to make it so my set file extension method knows that!]). File names can't contain os.sep; they can't be comprised of only periods and spaces (nor of only one or the other). Leading and trailing whitespace is stripped.
3 October 2026 (Saturday)
Okay, custom indexes, file indexes, and directory indexes are now a thing, and since they build off the same functionality, they're on an equal playing field. Press Ctrl+y for open/create file index key, and Ctrl+shift+y for open/create directory index key. Yes, you can still use Ctrl+Shift+z for redo (and if you really don't like Ctrl+y being usurped by the indexes, you can edit the keyboard shortcuts yourself in the source code).
Custom indexes have a custom base directory in an arbitrary location (you can have more than one, as before). File indexes have an auto-generated base directory that corresponds to a file. Directory indexes have an auto-generated base directory that corresponds to the directory that contains it (not just one file in it).
Shule should be a whole lot more useful, now!
I edited the `Index reference` documentation.
I have more to do before the next release of Shule, though, but I'm highly tempted to release it early to let you have that slightly more efficient statusbar, lest you commonly edit enormous files.
2 October 2026 (Friday)
I removed Ki from Shule altogether, and implemented the re-written code (as `Custom index` instead of `Ki index`, meaning you can customize the base directory for it; you can still name extra ones and change them by name). I'm glad it works. I also added the ability to choose whether the file extension style uses a default extension, requires manual extension entry, or has a changing default based on the last manual extension you entered. Ki already had that functionality, but I hadn't chosen to implement it fully in Shule until now. So, other than the new file extension features, it should do pretty much the same thing, except more efficiently than before, with less code—except one thing: wildcards don't work anymore. I'm using os.walk now instead of pathlib.Path(somePath).rglob specifically for increased efficiency and to oust the wildcards. I plan to add regular expression search features instead (opening lists of results in temporary tabs instead of directly opening files).
While I've programmed/implemented the code for file indexes and directory indexes, I haven't tested to see how it works, yet. I still need to set up keyboard shortcuts for these, too.
I've also been removing the old code for file indexes and directory indexes (the ones that had the alias feature).
I need to update the index reference. Essentially, custom indexes, file indexes, and directory indexes work the same way, except for their base directories. You could make a file (or directory) index into a custom index (just by specifying its URL as the custom index base directory), for that matter (they're just collections of plaintext files, which means they're highly portable, and they don't require special software to understand, even if Shule makes it a lot more convenient).
Under the hood, I've also added the ability to open all matching keys, but the implementation doesn't use that, currently.
I spoke too soon. It looks like there's a bug in Shule where after a few uses I get a mysterious Nonetype where I should get a base directory. I'll have to fix that later today. Tkinter's natural Ctrl+k must delete from the insert to the end of the line or something, because that fires when opening/creating the index fails; so, I should bind Editor.Test() to it first to get rid of that.
1 October 2026 (Thursday)
I worked on the new custom/file/directory index system. It should be replacing Ki entirely (instead of using it). I'm hopefully almost done, but I have a few more things to do, in addition to checking for bugs. While the Ki method is fast enough, this new method should be faster; it should take a whole lot less code; it should be a lot more efficient. Ki is a huge program with sourcecode that is hard to read on account of it being an experiment in imperative programming from someone used to object-oriented programming (Ki is definitely overkill for this task).
I'm planning to program a search and a regular expression search feature for indexes, and maybe directories in general: one for searching filenames and one for searching file contents. The plan is to just open a temporary tab with the resulting filepaths. I should make it so you can do document statistics on whole indexes (for wordcounts and such).
29 September 2026 (Tuesday)
I improved the efficiency of the statusbar, somewhat (it no longer updates the window name every time `shule.py->Editor.update_status()` is called (but only when you rename a file, or open a file). I tried debouncing update_status() for even more efficiency, but although it worked, it looked way too choppy; so, I'm not planning to go that route.
I haven't worked more on the web browsing functionality, yet.
However, I'm bringing back file indexes and directory indexes in a new form. All of the indexes are now Ki-style indexes. I plan to rename Ki-style index in the menu to something like `custom index` or maybe `default index`. So, yes, the directories for the file indexes and directory indexes need not be flat directories with no sub-directories anymore. They can be as deep as you want. I'm still programming it, but I can re-use the Ki-style index method(s) for the file and directory indexes. Yes, there are no more aliases for index keys (that feature is being retired, at present).
25 September 2026 (Friday)
I started on the plaintext web browser functionality. It took a lot longer than expected to start, but it's finally coming along! I underestimated the time it would take to figure out just downloading the files and staying in the same directory (along with deciding on an algorithm to do so). Anyway, you can now control-click on a word, like say `index` to go to something like https://www.mywebsite.com/index.html (provided that website is the most recent one you've loaded a file from).
I settled on opening wget in xterm with the download progress, intentionally blocking as it does so (you can do control+c on it to stop the download), and I actually like that a fair amount! That's a lot less work a lot more informative than making a graphical solution (which I did investigate for hours first), and you can just press Ctrl+c to stop it.
The functionality isn't ready for release, yet. No shortcuts. I still have some unhandled exceptions (I may rework the code there). Other stuff needs to be done. Debugging. Menu items. One cool thing is you can do this with password-protected files, too.
Anyway, now I have a plaintext web browser that doesn't render any markup, but can still follow regular words as links. That's pretty cool, if you ask me, even if it's pretty simple! :)
One of my goals is to provide tools to make for more efficient more enjoyable computer time (particularly for writers, programmers, readers, and such, but now we're adding web surfers to the list).
24 September 2026 (Thursday)—9:46:54 PM
I updated the document statistics methods. There was a bug where the character count only factored in after stripping leading and trailing whitespace from the document.
Also, I added a publication character count (which approximately is intended to include those that would be counted in a publication context; however, note that it only counts one new line character per paragraph, no matter how many new lines there are in a row). Note that spaces used to indent a paragraph or blockquote are not counted here as publication characters.
And, I added a page count. So, now I can finally tell people roughly how many pages whatever I'm writing has instead of the word count when they ask for pages (the actual page count could be slightly higher than what it renders, if the document contains poetry or pages where lots of space is taken up by the chapter introduction or whatever).
I moved the document statistics from `Tools->Misc` to `File->Util`.
I fixed the names in Edit->Go (and the RAM efficiency with `Edit->Go->Random line`), and fixed another issue I didn't know about. (In `Edit->Go->Position before jump`, the previous jump now factors in with random lines, too).
24 September 2026 (Thursday)—7:39:27 PM
I added more information to Shule's statusbar. Now, it tells you the percentage of the way through the document you (rather the text insert) is. It does this by characters (not by lines); so, it should be very accurate (but note that it floors it when it isn't a whole number). It uses tkinter.Text.count (so it doesn't pull another copy of the text into memory). Also, it tells you the total number of lines in the document and the total number of characters in the current line.
Note that before I made Shule, I made a GTK file pager (plaintext e-reader) in Vala that had the percentage feature, at the very least (although it must have measured by lines rather than characters; there wasn't really a text insert to worry about there). It had a favorites or bookmarks menu a lot like Notetab Light's, but Shule has a different style of favorites feature that doesn't rely on a menu (Shule's is more advanced in function and speed; you don't need a mouse nor a menu at all to use Shule's favorites).
Anyway, these new features should be very helpful, for both reading, text editing and writing. You no longer have to guage the scrollbar to know your progress through a book.
I changed the strings in the shule.py->Editor.get_status() to f-strings in the process.
I probably need to update the RAM efficiency of `Edit->Go->random line/row …`, and I definitely need to get rid of that ellipsis in the menu item (because it does what it does right away). Why does it even say `row`? Yikes. :) I do use that feature a lot (with Ctrl+Shift+j), but apparently, I don't browse the menu a lot (I'm more of a keyboard shortcut kind of person).
24 September 2026 (Thursday)
I fixed an unhandled exception where if you try to save a favorite when the current tab hasn't been saved, it tried to use a Nonetype inappropriately). I guess that's been there since 2014.
I'm planning to add a new kind of web browsing capability to Shule. That is, the ability to open online plaintext files, and navigate them with the mouse just like you can do with offline files. I plan to add the option to do it with archive files (so it just downloads the archive of multiple text files and then you can navigate it on your computer as if you were doing it online). I could, in theory, add a scripting language to allow for things like variables and random elements. I could add scripting for offline files, too, actually (technically, they would all be offline; all you do on the server is download the file). Might as well.
Anyway, this would allow people to make plaintext websites designed for Shule to run. It would be pretty easy to make them, since it's plaintext (no markup); you focus on the content rather than the design.
So, basically, the idea is, you write a story, or a collection of articles or something. Then when users right-click on any word in that file (no need to select it first), it opens a file named that word (if it exists) from the same server, wherein the file has an automatic file extension that you don't have to worry about (no markup for the links, just like the current offline methods). Of course, you may want to point out somehow which words actually mean something (like in a list).
I'm thinking about changing which mouse buttons do what. I feel like the dictionary look-up needs to be easier.
Oh, just so you know, you can install more dict dictionaries if you want to do foreign language translation when you trigger the offline dictionary.
22 September 2026 (Tuesday)
I released Shule 0.7.0, today (sha256sum on it should yield 37272edc5978fe3dd1fdb498224bd9aa779cd067e9e4eb32a3ad1e225c36d260). It improves the statusbar update with up and down arrow keys, as adds statusbar updates with the reading mode navigation (by paragraph, with and without hard returns). It adds the back and forward (and alt plus those) mouse button shortcuts for reading navigation.
Note that the feature intended for skipping up and down paragraphs where there are hard returns in the paragraph can also be used to skip up and down chapters where there aren't blank lines between the paragraphs within a chapter, whether or not there are hard returns with the paragraphs (to skip paragraphs only, there need to be blank lines between the paragraphs).
21 September 2026 (Monday)
> I wanted to do Alt plus those keys for the hard returns mode, but that turned out to be pretty complicated.
I found a fairly simple way how to bind Alt+back and Alt+forward on the mouse, after all. So, the hard returns methods are bound to that, now. All you do stuff like this (in the appropriate places):
self.holding_alt=False;
self.editor.tk.bind("<FocusIn>", self.on_focus_in);
self.editor.tk.bind("<FocusOut>", self.on_focus_out);
self.bind("<KeyPress-Alt_L>", self.on_alt_pressed);
self.bind("<KeyPress-Alt_R>", self.on_alt_pressed);
self.bind("<KeyRelease>", self.on_key_released); #For releasing Alt (so it doesn't get stuck if you press Alt-tab or whatever)
def on_button_press(self, event):
if event.num==8:
if self.holding_alt==False:
return self.paragraph_down_reading(event=event);
else:
return self.paragraph_down_reading_hr(event=event);
elif event.num==9:
if self.holding_alt==False:
return self.paragraph_up_reading(event=event);
else:
return self.paragraph_up_reading_hr(event=event);
def on_alt_pressed(self, event=None):
self.holding_alt=True;
def on_key_released(self, event=None):
self.holding_alt=False;
def on_focus_in(self, event=None):
self.holding_alt=False;
def on_focus_out(self, event=None):
self.holding_alt=False;
19 September 2026 (Saturday)
I found out that I forgot to call `self.editor.update_status()` at the end of those new paragraph up/down methods (so, the statusbar wouldn't update). Fixed for the next version.
I also made it so the back and forth buttons on the mouse can be used to skip up and down paragraphs reading mode style (without hard returns). I wanted to do Alt plus those keys for the hard returns mode, but that turned out to be pretty complicated. So, I might just do compose key codes that can set which methods are called when you press them.
19 September 2026 (Saturday)
I just released Shule 0.6.0. Using sha256sum on it should yield 749efb4a86fc591e5426166cd28cf7747f40d1d1aa57e33b003b7cf460cc4b8c (as it did for me before the upload and after I tried downloading it). This version has lots of major improvements, which I've already described in prior entries. I consider it a big milestone, and I very much like it (but it's still not to 1.0.0). Shule should be a lot more convenient to use, now (especially reading features [primarily navigation], and the file dialogs; lots of bug-fixes, notably in the file dialogs—but it also integrates dict as an offline dictionary with Alt+left-click [no selecting required], Alt+PageUp, and Menu+def; see the first item in the Tools->Misc menu; don't confuse it with the online dictionary). The documentation has been updated to reflect the changes (but there are still previous undocumented things).
Be sure to read the help documentation on the reading features if you haven't been paying close attention here.
I've only tested Shule 0.6.0 on Kubuntu 26.04.1 (of course, on KDE), with Python 3.14.7 (compiled myself), but I don't know a reason why it wouldn't work on Gnome or XFCE on Ubuntu, too, including with the stock version of Python.
In this version, you do have to set the mimetypes yourself after installation, if you want them set.
Be careful not to hit Scroll Lock or Pause on accident. They're reading navigation buttons for when you're reading a book with hard returns. You can change or disable those shortcuts in pretext.py (and you can use Alt+, and Alt+, instead if you want). F8 and F9 (as well as Alt+left and Alt+right) are also reading navigation buttons, but for content without hard returns in the middle of a paragraph.
FYI, on KDE, you can make the mouse pointer hide automatically so it doesn't distract you while reading. Go to System Settings->Window Management->Desktop Effects->Hide Cursor (there's a configure button to the right of it).
19 September 2026 (Saturday)
I fixed the functionality for skipping up paragraphs (with hard returns in the paragraphs). It wasn't broken, but now it uses much less RAM as it never dumps a full copy of the Text widget's contents into a string and additionally it doesn't split that into a list. That's a relief. I'm pleased.
Shule 0.6.0 should be almost ready for release.
For a future release (not Shule 0.6.0), I'm thinking I want to bring back file indexes and folder indexes, with some modifications:
• Make sure the shortcuts to access them aren't easily confused with the other index shortcuts (like don't use just Ctrl and an alphabet key). Use compose key codes, and maybe a more creative shortcut. I'm thinking maybe make a compose key code that switches the Ki-style index shortcuts for each of these (including the left mouse click), so you don't actually have to use a different shortcut (you just use the method you like to use and switch when you need to).
• Don't involve any saved data that causes issues when you edit the data without Shule.
• Nix aliases: Unless you find a method wherein renaming files outside of Shule wouldn't cause issues. Portability and sustainability ideally wouldn't require special software that could potentially receive updates that could outmode the data set, nor would they require reliance on the software to avoid breaking the data set when editing the data set without the special software.
• Make simpler, user-readable directory structures.
File and directory indexes were kind of cool and useful (but the aliases [although they were functional and I liked them when I made them] and consequent saved data were issues). While it's true that they're not super necessary with the index-type functionality we already have, they do still fill unfilled niches, and would make a lot of things a lot easier.
I need to program the functionality in the file dialog for the `Recent` and `Starred` tabs. I never actually wrote it (I just made the tabs; they've been there for years).
I changed it so the default dictionary web browser is Firefox instead of Dillo, simply because it doesn't render properly in Dillo and we're already installing Firefox.
I edited the menus a bit, and made Alt+PageUp a keyboard shortcut for the offline dictionary (if you don't want to use the mouse).
18 September 2026 (Friday)
I decided I like using F8 and F9, and Alt+left and Alt+right for skipping up and down paragraphs (without hard returns), for reading, and using Scroll Lock and Pause, and Alt+, and Alt+. for the same with hard returns.
I programmed part of the new skip up paragraph method for content with hard returns (the situation where you start on a blank line is already handled). Now I need to do handle the situation where you don't. It shouldn't take long now that I have a method that counts the number of empty or filled lines at the end (I just didn't have a lot of time left in the day to work on it). I should likely make it more RAM-efficient for large files, though, since it gets everything from the insert to the beginning of the file and splits it into a list (whereas, I only need the last two hard-returned paragraphs or so); I can probably do that by using the already-in-use Text widget instead of a new variable.
17 September 2026 (Thursday)
On Wednesday, I changed it so when you enter a path in the folder bar for the file dialogs that it will put the focus on the File name bar instead of not moving it.
Today, I changed it so the new skip up and down paragraph methods for content with hard returns uses Scroll Lock and Pause respectively (instead of Alt+Up and Alt+Down, because they were too easy to press on accident). On the bright side, you don't have to press modifier keys, and KDE doesn't seem to use Scroll Lock or Pause for stuff! I still need to finish the paragraph up functionality for hard returns.
I added F8 and F9 (with no modifiers) for shortcuts for the reading-mode move up/down a paragraph (without hard returns), experimentally to see what I think (KDE doesn't seem to use those keys for anything and they don't require a modifier, which is nice).
I disabled the email and webserver menu items and shortcuts for at least the present. The email stuff might actually still work, if you want to uncomment it and try it, but I haven't tested it in a really long time.
15 September 2026 (Tuesday)
I'm adding reading navigation options to skip up and down paragraphs with hard returns, so you don't have to remove those to have convenient reading options. Down is done (the most important part). Still working on up. I'm using Alt+Up and Alt+Down for the keyboard shortcuts [Edit on 17 September 2026: I changed it to Scroll Lock and Pause].
14 September 2026 (Monday)—9:10:07 PM
Well, it looks like Tkinter doesn't make it easy to modify their askcolor dialog (except when/where it comes to the text it returns). I might have to build a new one from scratch, or use another GUI library's tool (I don't really want to do that, though).
I still need to fix the mime type stuff during installation for KDE. (15 September 2026: I decided just to nix the mime type associations for now. You can do that manually if you want.)
14 September 2026 (Monday)—7:25:02 PM
Okay, I abandoned the notion of making the folders bold in the file dialogs, but the folders are now a different color. So, you can tell them apart (and you can customize that color just like all the others). Note that if you change all the foreground colors in one go, you'll probably want to change the folder color manually afterward so it isn't the same as the file color.
Now, I need to make it so the hexadecimal colors in the color dialogs are uppercase, and automatically focused/highlighted.
I need to make sure no showinfo dialogs and such ever start behind the find/replace dialogs in KDE.
I just made it so the folder color matches in the All and Folders tabs of the file dialog.
14 September 2026 (Monday)—4:40:11 PM
Okay, I fixed a bunch more errors (including ones I hadn't mentioned) in my open/save file dialogs. As far as I know (this isn't a guarantee), they're bug-free, now, with the All tab, anyway; the other tabs likely need work. I can't believe I've been using it like that for so long. Shule should be several times more relaxing to use now.
An issue I fixed that I didn't mention was when you try to open a file that doesn't exist, it said you didn't have permission to open it instead of saying that it didn't exist. [14 September 2026: I found out what it was and fixed it. It was for a currently unreleased feature.]
Now, I want to make directories bold, so you know they're not regular files.
14 September 2026 (Monday)—3:26:27 PM
> One of the most annoying longstanding bugs in Shule right now is when you go to open a file, sometimes it complains at you saying you don't have permission to write/open that file when you really do.
This is fixed, as of today. Apparently, the problem was that I got the current working directory twice, at different times, instead of just once (so, it wasn't current in some contexts). It was a pretty simple fix for such a longstanding bug (I just have it refer to the dialog's path the second time, now). I'm grateful open and save dialogs should work as intended there, now.
I plan to improve more stuff about them (when you create a new folder, I want to have it focus the insert in the place to name the file instead of keeping it where the folder-naming input box is).
This looks a lot easier to edit now than the last time I tried to edit it many years ago.
I also need to change it so when you do something or other and cancel, it doesn't interrupt you by notifying you of the fact that you canceled. I need to remember what 'something or other' was, though.
I also need to make it so showinfo message boxes don't appear behind your app (instead of on top) in KDE.
10 September 2026 (Thursday)—7:01:09 PM
I fixed an unhandled PermissionError in `Open/create path` (Ctrl+Shift+i). I also made it so it prompts you to create them if there are missing directories in a file path (instead of silently creating both them and the file).
Note that while you can't currently open files from the command-line before you save them like you can with Nano, you can use `Open`create path` to do essentially the same thing (and create missing directories in the process) inside of Shule.
I changed some of the dependencies. Apparently, you need more stuff for dict to work offline; so, I added more dict-related dependencies. I also added noto-mono and firefox back just in case your default fonts are problematic and for reasons to do with mimetypes (but if you don't like that, you can comment those out). I didn't include the other fonts, though (because there's not a big reason to include those by default).
I fully got rid of keccak hash support (even were pysha3 to work in your version of Python). You won't see it mentioned in Shule, now, nor will you see pysha3 mentioned.
I'm realizing I don't have any command-line options whatsoever for Shule (remember, I did start this app in 2014, and I didn't routinely add command-line options then). One of these days I'll probably add --help, --version, --open-named (for opening a file with a name and a filepath before it is saved like nano does), and maybe other stuff.
If you want any particular features in Shule, let me know and I'll consider them when I check the Discord server again. This isn't a promise that I'll add them, though! (Especially if it's syntax highlighting, line numbers, or parentheses matching that you want.)
One of the most annoying longstanding bugs in Shule right now is when you go to open a file, sometimes it complains at you saying you don't have permission to write/open that file when you really do [fixed on 14 September 2026]. The workaround is to select the path in the dialog and press enter. Then try again. I'm not sure what's causing the issue, yet, because I wrote the code probably about twelve years ago, and I need to refamiliarize myself with it. This bug is one of the reasons I made other cool ways to open files, like Ctrl+Shift+i and Ctrl+m. So, you can thank the bug for its contribution to those. This reminds me of how pearls are made.
Speaking of bugs, there's a bug in Ctrl+Shift+o that makes it so when you select multiple URLs and launch them, sometimes (not all the time) it opens all of them but one (and it's not consistent which one it doesn't open). I re-did that code recently, but I'm still unaware of the cause of the problem.
I've decided against adding uget/kget support to Shule. However, I am working on making it so you can highlight text and launch it in a terminal emulator as a temporary Bash script (so you could launch uget or kget that way—or even nano for that matter). I do plan to make it require you to enter a starting directory, though (and to remember the last one entered), to avoid issues.
I need to add more Ki-like powers to Shule. For instance, I want to make it so you can put a file in a directory that shule can automatically recognize so it will treat it as a base directory. Then we can treat the current method as a default directory, and use base-directories, too, to make it easier to have multiple Ki-style projects (instead of requiring you to remember your project names and requiring you to switch between them to do multiple).
10 September 2026 (Thursday)
I wasn't expecting this, but I integrated an offline dictionary (using dict) into Shule. Now all you have to do is hold Alt and left-click on a word and it will define it in a new temporary tab for you (if it has a definition for you), which is very handy for reading (and it's super easy to look up words within definitions that you don't know, too, since you can just Alt-click on them, and keep doing that)! If the word contains spaces, you need to select the word, but otherwise, no. You can also do Menu+def to manually type in a word to define. The heavy-lifting for this functionality was already completed with previous features (for right-clicking and the mousewheel click). I also added dict as a dependency. This feature should be released with Shule 0.6.0.
Before I did that, I made it so it should automatically detect your default file manager on the first run, so you aren't stuck with having to redefine it from Thunar, if you don't have/use Thunar. Same for the LilyPond PDF viewer.
9 September 2026 (Wednesday)—6:50:55 PM
Hrmm. If you're installing on KDE, be sure to edit thunar out of Shule/installation_files/DEPEND before you install, or it might make it so your computer doesn't shutdown properly (probably because of conflicts with Thunar and Dolphin related to unmounting at shutdown). If you've already installed Thunar, then purging it (`sudo apt purge thunar thunar*`) will probably help (it did for me) If you installed the recommended packages for Thunar, you may have to purge those, too (I did that, too). Be sure to manually set your file manager path inside of Shule, too, if you purge Thunar (Tools->Paths->File Manager Path Then type `dolphin` or whatever). [Edit on 14 September 2026: While what I said in this entry is good advice, it didn't really help all that much for my use-case, actually; I think my USB hubs were related to the problem; I'm guessing it does unmount, but it just shuts down without powering down, somehow, since I haven't been triggering disk repairs at startup].
For the uninitiated, Thunar is the file manager that XFCE uses by default. Dolphin is the file manager that KDE uses by default. I like the latest Ubuntu's version of Thunar because it lets you queue, pause, and unpause files that you're copying, and the integrated archive extraction is nice. So, I might test to see if I can use it instead of Dolphin, and purge Dolphin instead, but I'm not sure if that works. I'm on a fresh install of Kubuntu 26.04.1, now (not Xubuntu); I reinstalled my system in an attempt to try to fix the shutdown issue (which didn't work) and to stop getting a bunch of crash reports (which seems to have worked), which crash reports were probably caused by installing too many desktop environments. On the fresh install of KDE (the full installation), I didn't install XFCE; I just installed Thunar and the recommended packages to go with it, and that still caused the shutdown issue even with just that.
I also found out that mime types don't register properly for Shule on KDE in Kubuntu 26.04.1 (but Shule otherwise installs fine). I need to update that. Manually fixing mimetypes isn't the end of the world, though, especially if you don't even want Shule to run them by default (I personally like Shule to open most plaintext file extensions, but maybe you don't).
The reason I didn't catch these things in KDE before was because I installed it in XFCE and just used it in KDE before (but you only see it when installing), and XFCE didn't trigger the issues when installing there. But then I installed it fresh in Kubuntu 26.04.1 after I reinstalled my operating system—and I found the issues.
This isn't KDE-related, but I also found out that some of those font dependencies take a long time to download. They aren't 100% necessary, as long as you set a good font manually in Shule, or if your default font is good. So, you can remove those, too, if you want.
I hope to have these issues fixed by the next release.
Oh, and I'm adding something like this to the help file documentation (but it can help you now if you use KDE 26.04.1):
In KDE (in Kubuntu 26.04.1), here are instructions on how to free up your compose keys to be properly usable in Shule:
To change the Windows/meta key shortcuts, do this, go to settings->Keyboard->Shortcuts->Plasma Workspace and configure `Activate Application Launcher` (be sure to uncheck `Meta` as one of its keyboard shortcuts). Then click Apply, or it won't work.
To make it so you can properly do Ctrl+Meta in Shule (to add/edit/delete compose key codes), do this:
Go to System Settings->Keyboard->Shortcuts->Window Management and reconfigure these settings so Ctrl+Meta+arrow keys doesn't activate them (I advise changing them to Ctrl+Alt+left/right/up/down instead):
• Switch One Desktop Down
• Switch One Desktop to the Left
• Switch One Desktop to the Right
• Switch One Desktop Up
Then click Apply.
Tangent (not about Shule): Note that in Kubuntu 26.04.1, to give yourself more desktops in the workspace switcher (AKA pager) so you can actually use those shortcuts for something useful, and if you want to know my preferred settings for them, do this: go to System Settings->Window Management->Virtual Desktops and then in the upper right corner give yourself six desktops and two rows. Then click Apply. Then right-click on the pager widget in the lower left corner to the right of the start menu type thing (you might not have realized it was there until now). Select Configure Pager. Check `Show application icons on window outlines`, and `Navigation wraps around`; select `No text`. Click apply. Now try holding Ctrl+Alt and moving the arrow keys. You'll have a unique taskbar on each workspace (unless you configure it differently, because there are other options).
Also (still tangential), if you want to set up KDE's native compose key instead of or in addition to using Shule's (I like to set my Caps Lock to be it, which is still useful in Shule because it means I can't accidentally trigger the Caps Lock), then do this: System Settings->Keyboard->Keyboard->Keybindings->Position of Compose key (then check Caps Lock or whatever). And click Apply!
The reason for those tangents above is because it took me a really long time to figure out how to do those things in KDE, even in this age of AI chatbots (which evidently aren't trained on the latest Ubuntu versions fully or else they didn't understand the way I talk). So, I thought I would pass along how to do them, especially since they coincide with keys you need to configure for Shule.
Also, in KDE, if you want to add gnome-terminal as your default terminal, go to System Settings->Default Applications->Terminal emulator. Then click on Other. Then click the button to the right of the input box with the `Open file dialog` tooltip (don't type anything in that input box first). Then navigate to `/usr/bin/gnome-terminal` (or type `which gnome-terminal` to find out where it is first and use that path). And away you go.
While I'm handing out tangential lifehacks for your computer, if you want to get rid of the new panel to the left of your sidebar in Firefox 155.0.1, go to about:config and type sidebar.revamp and set it to false. That also took a very long time to figure out. The AI didn't know the true answer until I used words like 'panel to the left of the sidebar' specifically (instead of some other description). That panel is kind of useful for the password access, but it takes up real estate, and I primarily use a 19-inch computer monitor, currently.
I'm thinking about porting shule to latest version of Qt on Python to see what it has to offer (and about revamping Shule in the process). Don't hold your breath, but I might do it. If I do, though, that means I'll probably add syntax highlighting (but I very much plan not to let it dominate the color schemes when it comes to non-programming usage). Also, if I do that, I still plan to keep and maintain the Tkinter version either way.
Anyway, I tried out the Kate text editor recently, and it's pretty cool. It's KDE's text editor. Shule is not planned to emulate Kate in the future; they have very different goals and design paradigms, even if they do have some similar uses, as most text editors do. But, Kate is still cool (I like how it's fast, highly configurable, and so on).
I'm thinking about switching Shule's built-in download manager with uget (uget-gtk) and/or kget integration.
7 September 2026 (Monday)—12:26:12 PM
If you want the hash for shule_0.5.0.tar.bz2, here's the sha256 checksum:
b242d185960aa633ef9a832ac7629d31dfb890628cc232571370ec124c11549a
To use it, go to the command-line in whatever directory you have shule_0.5.0.tar.bz2 and type `sha256sum shule_0.5.0.tar.bz2`. The hash that appears should be the same as the checksum above. If you downloaded it before I wrote this entry, the hash won't match; it looks like the initial upload had issues (but this time I checked it before the upload and after a download and it matched).
5 September 2026 (Saturday)—10:42:02 PM
I released Shule 0.5.0, today! I'm excited about this release. Please try the reading features and using mouse buttons on plaintext as if you were clicking on hyperlinks. So far, I've only tested it on Xubuntu 26.04 on KDE, Gnome, and XFCE, with Python 3.14.7 (compiled myself), but it should work with everything the previous released worked with (in theory). This is the first release to have been tested on KDE and found to work well on KDE (I don't remember if I ever tried it on KDE before, but if I did, it was a really long time ago when KDE was very blue in color).
Did I mention already that you can now close tabs by clicking the mousewheel on them?
So, the major changes here are bugfixes (notably with the various mouse button clicks), the ability to open/create files/directories via a filepath with Ctrl+Shift+i, redoing keyboard shortcuts for the reading-mode paragraph scrolling (You can use either `Alt+`, and `Alt+.`, or `Alt+left` and `Alt+right`), bringing back the regular Ctrl+up and Ctrl+down, remapping some other keyboard shortcuts, and some documentation updates. Also, when you Alt+backspace/delete it deletes the previous word, but it treats hyphens, quotes, parentheses, brackets, and number signs as word characters (you can modify what characters it counts in the regular expression in pretext.py on line 889, which line is where the definition for the alt_backspace method is [I'm considering removing number signs from that, since it would delete Python comment markers, too, but it's nice for deleting the number signs in hexadecimal color codes and hashtags]), while Ctrl+Shift+backspace/delete treats all non-whitespace characters as word characters when deleting the previous/next word.
Oh, also, the pickled persistent data uses the same pickling protocol (5) every time instead of the latest one, now, for the sake of compatibility.
I'm probably going to rename Ki indexes just plain indexes, so people don't get too confused.
5 September 2026 (Saturday)—8:35:26 PM
Okay, I polished up the left mouseclick and the wheel mouseclick and removed some bugs. Now you don't have to worry about ending punctuation causing issues, nor about ASCII versions of em dashes causing issues. Shule 0.5.0 is almost ready for release.
5 September 2026 (Saturday)—1:03:46 AM
Okay, I did a little more programming and fixed the right-click and mousewheel click so they handle multiple periods, multiple hyphens, and multiple plusses correctly; I also made it so it catches exclamation marks and question marks [I got later made it so it didn't]. You can change what it catches in shule.py in Editor.get_filename_with_mouse() in the regular expression there.
I fixed it so the right-click and the mousewheel click both get the selected text if something is already selected.
4 September 2026 (Friday)—10:33:38 PM
I changed the keyboard shortcuts I made yesterday from Shift+Backspace and Shift+Delete to Control+Shift+Backspace and Control+Shift+Delete (because it's too easy to accidentally trigger it when doing something unrelated without the Control. We'll see if this helps.
Also, where I wrote this, ‘While writing this entry, I just returned the old Control+Up and Control+Down functionality, and put the new reading-mode paragraph skipping functionality under Alt+Left and Alt+Right (as well as Control+Return and Shift+Return, with Control+Shift+Return being the same as Control+Return to make it more likely that you can do it with one hand on more keyboards.’ I changed the shortcuts that involved Return/Enter to Alt+, (up a paragraph) and Alt+. (down a paragraph); I changed the old shortcuts associated with Alt+, and Alt+. to other things (Ctrl+Shift+F9 and Shift+Alt+> respectively).
I added the ability to close tabs by middle-clicking on them. It will necessarily focus on the tab, though (it was a lot easier to program that way, and that way you don't accidentally close a random tab without knowing you did something).
3-4 September 2026 (Thursday and Friday)
I've been making improvements to Shule (not released, yet), adding new features and stuff. I fixed some issues with Control+Delete and Control+Backspace. I added new functionality with Alt+Backspace, Shift+Backspace, Alt+Delete and Shift+Delete for those who get frustrated when Control+Backspace and Control+Delete are too conservative in what they consider a word.
A while back, I added the ability to open and create files and directories with Ctrl+Shift+i from an input box instead of open/save dialogs. You press the aforementioned keys then you enter a path (a file path or a directory path). If it exists, it opens it. If it doesn't exist, it offers to create it. It will create multiple levels of new directories if you let it. By opening a directory, I just mean it opens an open-file dialog there (but it could easily be configured to open a file manager instead). The default path for the input box is that of the current tab if it is saved; otherwise, it remembers the previous one entered, I think.
I've changed the documentation some, but it's far from finished!
I removed file indexes and directory indexes (now we just have key indexes, and the ability to open files in the same directory in an index-like fashion). The reason for removing them is because they detracted from similar features that were preferred for most use-cases. The result of using a Ki-style index is you get directories with plaintext files in them that can be edited in any editor. The removed features required Shule on account of aliases and stuff like that needing to be pickled.
While writing this entry, I just returned the old Control+Up and Control+Down functionality, and put the new reading-mode paragraph skipping functionality under Alt+Left and Alt+Right (as well as Control+Return and Shift+Return, with Control+Shift+Return being the same as Control+Return to make it more likely that you can do it with one hand on more keyboards.
I fixed some issues with fullscreen.
You can now hide and show the menu whenever you want with `Menu+men`, whether or not you're in fullscreen mode.
I've been testing Shule in Gnome (not just XFCE) on Xubuntu 26.04. This isn't part of Shule, but I've found that you can invert the colors nicely in Gnome with the extension-manager app if you install the extension called `Invert Screen Colors` (version 4), by ilijaculap; but Shule's `Menu+inv` feature to invert them in Shule is still helpful if you want to get the inverted color codes for your theme (or if you're not using Gnome). The aforementioned Gnome extension (not part of Shule) currently lets you invert either everything or individual windows (so, it's actually a step up from `xcalib -i -a`), and you can review the source code yourself. One mistake I made with Gnome was binding Gnome's fullscreen to F11 (because that overrides Shule's fullscreen and it won't hide the menu); it's not a bug; it's just a desktop environment configuration. You also have to unbind the windows keys in Gnome (in the keyboard shortcuts), if you want to use them as compose keys.
I may have mentioned this before, but I've updated the mouse buttons, mapping the right click to Ki-style indexes and the mouse wheel press to open/create files in the same directory as your open/active tab's. I need to fix a bug there where it has issues if you put multiple periods or hyphens in the same word that you click on (it treats periods and hyphens as word characters in this context, to make it easy to do filenames). You can simulate hypertext fiction in plaintext with this feature, by the way (as long as the reader is reading in Shule or something with the same functionality)! It's cool. Now we just need people to write some hypertext fiction in this format! (Which would be super easy to do, by the way; no markup required.)
22 August 2026 (Saturday)—7:47:37 PM
I released Shule 0.4.1 and then Shule 0.4.2, today. I added a font dependency and updated the `About` file to show that I had tested it on more systems. If you're wondering why the download link was broken for Shule 0.4.1, that's because it was a tar.gz file instead of a tar.bz2 file (but the download link is fixed).
Note that I'm not using pysha3 (and I'm not projected to use it in Shule in the future, unless they update it); so, `keccak_512` and other hashes with keccak in the name aren't available (but there are still plenty of good hashes, like sha3).
If you find any bugs, or even if you use Shule at all, feel free to put a message on the Discord server. Don't wait for me to respond, though; I check it anywhere from a few times a week to once every two months). I haven't advertised Shule a lot, yet.
Oh, I just remembered an oversight. I disabled the Ctrl+b keyboard shortcut and forgot to re-enable it (I did this to retrain my brain into using Ctrl+k for accessing/creating index keys with Ki-style indexes, since it used to be Ctrl+b). However, if you use Ki-style indexes and don't use file-indexes, you might be happy with this oversight, since they were easy to mix up. You can re-enable it in the source code.
22 August 2026 (Saturday)—5:43:14 PM
I released Shule 0.4.0, today. I fixed a major bug with Ki-style indexes that would delete some text under certain circumstances (I think if you tried to make a key and canceled, it would delete like a line of text). I recently got a new computer and put Xubuntu 26.04 LTS on it. I compiled Python 3.14.7 on it. I tested Shule and found some problems, but I fixed the major issues (the buttons in Tkinter no longer worked, but they work again). My new computer with Xubuntu 26.04 LTS doesn't render inverted colors (via xcalib -ia) terribly well. So, I made the default theme of Shule (and this website, too) so it had fonts that rendered well when inverted. Of necessity, I added color the color theme to the find and replace dialogs (since they were hard to read with the xcalib issues). I removed the requirement to install pycurl (e.g. pip3 install pycurl) and replaced it with the requests module (because curl gave me a deprecation warning and the requests module was the simpler solution).
I added the ability to invert colors within Shule itself (so you don't have to use xcalib): use Menu+inv for that (press the menu compose key and type `inv`).
If generating a random e-book didn't work for you before, it should work now, and pull from a larger book of e-books than before. Disclaimer: The ebooks generated are not mine, and they are not saved to disk (unless you personally save them).
I fixed an issue with Shule's version of Ki, which Shule utilizes for ki-style indexes (the independent release of Ki still has the issue). The problem was, I was using multi-line strings as comments, and they had what at least one new version of Python considered to be invalid escape sequences. So, I made them raw f-strings, and now they're good.
I updated the documentation some.
I made it so when you change all the background and foreground colors that it dreams the scrollbars and their troughs as backgrounds. This change was because of light-sensitivity.
I might have fixed some other issues.
There is one new issue on some systems. That is, when you open the find and find and replace dialogs, it prints some message to the terminal—but everything still seems to work. An AI seemed to think the cause of the message was the input method (using XIM instead of ibus or fcitx); XIM uses less RAM, so I'm inclined to leave it as-is until a future release breaks it (if it ever does), but you never know. [EDIT on 22 August 2026 (Saturday)—8:42:20 PM: I discovered that the XFCE compose key doesn't do em dashes properly in Shule in Xubuntu 26.04, for some reason (this might relate to the input method)—but you can type them just fine with the right-windows compose key built-into shule. Edit (25 August 2026): I discovered that ibus, which was apparently installed, was responsible for the Xfce's compose key not outputting em dashes properly. It worked fine after I uninstalled it.]
[Edit: 24 August 2026: I forgot to mention that I changed the way Ctrl+up and Ctrl+down work to make them nicer for reading e-books, so it cleanly skips to the next or previous paragraph, keeping the current paragraph at the very top of the screen, and skipping any extra blank lines between paragraphs. The screen positioning factor is nice in e-books, but it might be weird while programming or something until you get used to it (I was going to add a toggle between the old and new method, or use different keybindings or something, but I forgot about that at the time I released it). If you prefer the old method, the code for it still exists in `pretext.py` if you want to comment out the new and uncomment the old.]
19 June 2026 (Friday)—7:29:45 PM
If you have old download links for Shule that you can't seem to get working, replace the space in each link with an underscore.
19 June 2026 (Friday)—9:23:05 AM
Shule 0.3.1 has been released. I changed the `+` and `-` in the age calculator to `plus` and `minus` for additional clarity, so people don't accidentally think the ages are a year older than they are.
19 June 2026 (Friday)—6:50:49 AM
Shule 0.3.0 has been released. Enjoy. Many longstanding issues have been fixed (detailed in the previous two entries). Most importantly, though, the run (F5) feature works. Also, I changed this:
• The accuracy of the age calculator should be fixed. It no longer attempts to show the format in years, months, weeks, days. Instead, it says a number of years plus or minus a number of days. The accuracy of this was easier to verify, and it's more practical anyway, since that's really what you probably want to know subconsciously.
I tested this release on Python 3.10.12, as well as manually compiled installations of Python 3.13.3 and Python 3.14.6, all on Xubuntu 22.04.5 LTS 64-bit on a desktop computer. It works on all of them, other than that pysha3 is incompatible with Python 3.14.6 (pysha3 is needed to use the keccak hash algorithms, such as `keccak_512`, if you want to use those [if you don't know what they are, you probably don't need them]; hashlib in Python already has the primary sha3 hashes, as of several Python releases ago, fortunately; Shule runs fine without pysha3 installed).
18 June 2026 (Thursday)
I haven't uploaded the changes yet, but I did this, today (for the upcoming Shule 0.3.0--I only increment the version when i upload it, and not as I program it):
• I switched the open/create Ki index shortcut to Ctrl+k, and the open/create file index to Ctrl+b (since the Ki indexes are a much higher priority, and it makes more sense with the k shortcut).
• I switched Alt+n and Ctrl+n (so if you accidentally press Ctrl+n instead of Ctrl+b, you will know that you made a mistake since it will print ♮ to the screen instead of bringing up an input box).
• I made it so the default file extension doesn't change just because you open a ki index with a non-default extension. I had previous made it so it would change hoping for a productivity benefit, but I don't think there was one, since I switch back to the default extension almost immediately after I use any other extension, usually (and there is already a shortcut to change the default extension, if needed [Shift+Alt+k]).
• I made it so when you open a file in the same directory with Ctrl+m or such that it won't tag on the default extension if you specify your own extension.
• I reprogrammed Ctrl+Shift+o; so, those bugs should be gone, now. So, right now the expected behavior for using it when text is selected is, if there is one, and only one valid directory path, in the selection, it will open an open file dialog to that location (and ignore all other URIs); if there are multiple valid directory paths, it ignores them all (but may open other things). If there there are valid filepaths (delimited by new lines) and no web addresses, then, whether or not there is whitespace around the filepaths, then it opens them all, unless there are also web address, in which case it refuses to open anything. If there are web addresses and no filepaths then it opens all the web addresses. Furthermore, it can open web addresses even if there is other text in the selection that isn't URI-related (but this is not true for files and directories, other than surrounding whitespace). If no text is selected, then it only evaluates one URI (whatever you enter, whether it be a file, a directory, or a web address).
[Earlier] 18 June 2026 (Thursday)
No changes uploaded yet, but the following changes are forthcoming in Shule 0.3.0:
• An `F5/run` feature that actually works instead of crashing your program. [Similar functionality such as compiling, compiling all and running the interpreter, also should work, now, for all the programming languages listed, as well as for GNU LilyPond.]
• `menu+pas` pastes with queries removed.
• Some annoying keyboard shortcuts that are easy to accidentally press have been changed or removed. I plan to maybe change a few more shortcuts, though. [I did, later in the day.]
• This feature may or may not have been in 0.2.0, but you can now press Shift+Alt+j to jump to a random line of the current tab. This is a lot more useful than it might at first sound (at least it is for me; when you're dealing with a super long document and want to peruse random parts of it, it's kind of hard to be random if you have to scroll forever to do it).
• Ctrl+shift+o now opens links even if you select non-link text, too. You can also open multiple links in selected text, too, but I need to work out at least one bug there.
• Ctrl+m (Menu+dfo) now lets you open or create a file in the same directory as the current one, without a file dialog (the idea is to make it just as easy as with creating and opening index keys). It uses a default file extension, currently (which might be a little unexpected). I need to fix it so if you specify an extension it will use it instead of always putting the default on the end. Menu+dfe lets you choose the file extension.
• Menu+glp lets you specify a directory and then it outputs all the paths recursively from that directory into the editor.
• Shule also no longer opens emails addresses to compose emails for them—from the command-line—anyway, although I might re-implement that with a flag/option instead of just having it try to figure out if it's an email address.
• The age calculator has at least one bug that needs to be fixed, leading to semi-inaccurate ages in some contexts. I plan to reprogram it instead of fixing it.
23 October 2024 (Wednesday)
Version 0.2.0 released. I added Ki-style indexes, which can make indexes a lot more handy. Related shortcuts include Ctrl+b (open or create a key), middle-clicking selected text (open or create a key naming it after the selected text), Alt+k (set the base directory), Shift+Alt+k (set the file extension), Shift+Alt+colon (name a base directory), and Alt+semicolon (set the base directory by name). These allow you to make independent indexes that won't be messed up if you rename or delete a file manually (as opposed to via Shule). Furthermore, you can make complex sub-directory structures for your base directory and the index is still capable of accessing them just as easily. The version of Ki included in Shule's source code is not separable from Shule. It has been modified for Shule to use it (you should get a new copy of Ki if you want to use Ki separately).
Anyway, if you learn how to use these new features, you might be impressed at what you can do with them. It's basically a lot of the stuff you can do with Ki for the command-line, except it's not for the command-line. Ki does still have additional features that Shule lacks, however, and Shule doesn't work exactly the same. Ki-style directories from Shule are compatible with Ki, if you want to use Ki in them. Shule's version of Ki has settings that are currently at ~/.ki_kumoshk_shule (they shouldn't conflict with your regular Ki installation). I may change this in the future (since I'd like to keep the settings in Shule's settings).
The alterations in this version are all covered by the MIT license.
The index help file has an error in that it says changing file extensions is only a feature of Ki-style directories. They both allow this, and have separate menu items for the purpose. I need to fix that. I also need to differentiate them more.
16 October 2024 (Wednesday)
Version 0.1.2 released. Removed a keyboard shortcut (shift+delete), which was too easy to trigger by accident. Replaced it with Menu-compose+rud.
16 October 2024 (Wednesday)
Version 0.1.1 released. Fixed a bug where F5 caused the program to crash sometimes. Now it uses Gnome-terminal instead of xterm. [EDIT: Actually, not really. The bug was still there. The release of Shule 0.3.0 should have that problem completely fixed--it's already fixed and works so much better (as of some time before June 2026), but I haven't uploaded it, yet, as of 18 June 2026 (Thursday)—1:10:56 AM.]
16 October 2024 (Wednesday)
Version 0.1.0 released online.
28 April 2014 (Monday)
[7 September 2026: I wrote the following in my handwritten journal on 28 April 2014:]
'…
I programmed. I decided I better make my own text editor, because SciTE isn't working properly on Xubuntu 14.04 and I didn't find any other Python editors with the aspects I wanted. I'm using Tkinter for my GUI, since I want something that will work with just about any Python installation, even future versions of Python (since Tkinter is likely to remain supported). I got the ScrolledText widget to resize with the screen. I got a menu up. I'm working on getting a tabbed interface. All of these things, I owe credit to helpful people online [7 September 2026: mostly people on , especially Bryan Oakley, who explained how to use Tkinter] for sharing their knowledge. [7 September 2026: I wrote that I owe them credit for the following sentence, too:] Also, I got the screen to start maximized (properly maximized—not just sized to fill the screen). I'm programming the editor with and for Python 3.4, as well as plain text (UTF-8 only), LilyPond and such. Since CTRL+Shift+u doesn't [7 September 2026: rather, didn't at the time] work in Tkinter to allow Unicode character sequences, I'm planning to have a menu shortcut that allows for it. So, if you press CTRL+Shift+u a prompt will come up asking for a character code sequence. Hit enter after you type it, and it appears. It will remember the last one entered for faster input. Maybe I'll allow for remapping keys, too.' [7 September 2026: I haven't actually made those last two features, yet! I totally should!]