Just a quick announcement to let you know that on 3 and 4 April, we will have a stand for Joplin at the Journées du Logiciel Libre in Lyon, France. The JdLL has been taking place in Lyon for 22 years and is a popular open source conference in France. Last year we had a stand too, but of course that was cancelled due to Covid. So this year is a first for Joplin so if you're around, come and say hi!

Also I am looking for anyone who could help look after the stand, even for an hour or two, over these two days. There won't be a lot to do - pretty much just hand over fliers and answer the occasional question, which as Joplin users I'm sure you'll know the answer to. Coffee and/or beers are on me :-) So if you aren't far and would be interested, please let me know!

We are going to apply again this year for GSoC. If we are selected by Google, this year's theme will be centered around:

• Joplin plugin system - eg. development of various features that can be done as plugins, and improvement of the plugin system itself.

• Joplin external applications - anything that can be developed as an external application and that makes use of Joplin's API and other extension points.

At times we had a rough GSoC last year, mostly because we weren't familiar with the process and how to best handle various situations, but overall it was a success and we got great improvements to the search engine and keyboard shortcut systems thanks to our two students. We plan to make some adjustments to the way we welcome students to make the process go smoothly this year.

We will submit the GSoC application on 19 Feb and will let you know if we are selected. Like last year, we would appreciate any help with managing the event - if you are interested in being a tutor, or if you can help with welcoming new students and answering their questions, please let us know!

So far, we have @CalebJohn, @PackElend, @tessus and myself as potential tutors.

The first release of Joplin Server is now available as a pre-release:

https://github.com/laurent22/joplin/blob/dev/packages/server/README.md

What does it sync with?​

You will need Joplin v1.6+ clients, which are available as pre-releases for desktop and Android.

What does it do?​

At this point, this server allows you to sync any Joplin client with it, as you would do with Dropbox, OneDrive, etc. So in that way, it's not essential. Long term, the goal is to add collaboration features:

• Sharing a note with anyone, using a URL. When the note is changed, the content at the URL is changed too.
• Sharing a notebook with a user on the same Joplin Server instance. For example, if you share a notebook with another user, that user will see this notebook in their desktop or mobile app, and will be able to edit the notes, etc.

Any improvement over Nextcloud?​

For now, one benefit of using Joplin Server, compared to Nextcloud or WebDAV in general, is that it is much faster and resource efficient. I've done a basic test with Nextcloud and Joplin Server running on the same server. Both have mostly default settings (except Nextcloud which uses Redis for file locks):

Why is it so much faster? I assume it's in part because the WebDAV protocol is terribly inefficient. It sends unnecessarily large XML blobs for every request, which are time consuming to download and parse. It also doesn't support delta sync (unlike Joplin Server), which means the complete file list needs to be downloaded before syncing in order to compare the local and remote items.

Finally it's possible that Nextcloud file locking system means an overhead on each request. It shouldn't be much since it's handled by Redis but who knows. Joplin Server doesn't need locking as data consistency is handled by the clients.

So just by following common sense and transferring only the required data in a sane format (JSON), we can have something more performant. In my case, I appreciate that the mobile app no longer freezes when it starts synchronising - before it would do that due to the large XML WebDAV file that needs to be parsed.

Stability​

I've been using it with the desktop and mobile app for a few weeks now and haven't had any issue so far. The server also passes all the existing sync-related test units (sync, e2ee and lock handling) so I'm reasonably confident it can already be used. As always though, keep making backups in case there's any issue.

Suggestions are welcome​

This is still a pre-release and if you notice anything off please let me know. In particular, I believe it doesn't gzip responses, so that will need to be added. The process also doesn't restart when it crashes, which could be solved with pm2.

Also if you have any idea on how to make installation easier, your feedback is welcome.

The latest version features of Joplin features a few improvements to make it easier to preview various media files. For now it is possible to view PDF files, as well as listen and view audio and video files.

The feature is optional and you can enable/disable it in the settings, each viewer has its own settings:

For now the feature works on desktop (Markdown editor only) and on mobile (except for the PDF viewer).

From version 1.5, the macOS application will now be notarised. It means that when you install it you will no longer see a warning telling you that the app hasn't been checked for malware. You also won't need to go in the OS security settings to launch the app.

Notarisation has been around since macOS Catalina, however it took a while to implement it for Joplin as the process is complex and error prone.

First the app has to be built and uploaded to Apple's servers. They then automatically check the app for any malware, a process that can take 5 to 15 minutes (and presumably more if the app is incorrectly flagged as malware). Once it's done, Apple creates a notarisation ticket for the app.

Then whenever the app is started, Apple check on their server if the app has a notarisation ticket (a process that recently caused "apps taking minutes to launch, stuttering and non-responsiveness throughout macOS"). It's also possible to staple this notarisation ticket to the app, so that it's possible to check the ticket even when the computer is offline.

All that has now been automated in the Joplin build pipeline, and will apply to all macOS app future versions.

One feature that may have gone a bit unnoticed in recent versions is the ability to change the application layout. It is mainly aimed at plugins, so that they can create a panel anywhere, and you can then move it wherever you want, but it can also be used to re-arranged existing application components.

For example, you can put the note list below the sidebar, to have more space for the text editor, move the sidebar to the right of the application, etc.

To begin changing the application layout, click on "Change application layout" from the View menu:

This will put the app into a special mode, from which you can move the side bar, note list and text editor around. You do so by pressing on the arrow keys:

For example, pressing the left arrow on the note list would move it to the left, just below the sidebar:

Once you're done modifying the layout, press the "Escape" key to exit.

The plugin system has been part of Joplin since the previous version, however it was still a bit unstable. In the latest version we're getting a bit closer to production-ready state. The plugin API in particular has been significantly expanded, based on the developer feedback, so that more types of plugin are possible now, and indeed a few plugin concepts have started appearing on the forums. In particular all this could be done now:

• Access notes, folders, etc. via the data API
• Add a view to display custom data using HTML/CSS/JS
• Create a dialog to display information and get input from the user
• Create a new command and associate a toolbar button or menu item with it
• Get access to the note currently being edited and modify it
• Listen to various events and run code when they happen
• Hook into the application to set additional options and customise Joplin's behaviour
• Create a module to export or import data into Joplin
• Define new settings and setting sections, and get/set them from the plugin
• Create a new Markdown plugin to render custom markup.
• Create an editor plugin to modify low-level the behaviour of the Markdown editor (CodeMirror)

Plugin JPL format and configuration screen

The plugin configuration screen has also been updated so that it's possible to import the new JPL (Joplin PLugin) format and to enable/disable as well as uninstall plugins.

What's next?

It is now possible to create new plugins, package them into the JPL format, and to install them into the app.

The last piece missing is a way to discover and share plugins, and a way to update them easily, basically what we need is an online package manager. It is not clear yet how this is going to be done, but one idea would be to have a GitHub repository where anyone could submit or update a plugin, then the app would connect to that repository to make it easy to install new plugins. This is just an idea at this point though, and if you have any suggestion on other ways it could be done, feel free to let me know. A discussion about it has been started in the forum.

With 340 votes on GitHub, spell checker support was the most requested feature and is now finally available in Joplin! This was always tricky to add due to the custom editors (Rich Text and Markdown) we use, but thanks to the recent improvements in the Electron framework and to Caleb John's work on the Markdown editor it is now possible.

It should be working fine in both editors however it is currently considered Beta for the Markdown Editor because to enable the feature we had to use a special mode which in the past caused various issues. Now it seems to work well, at least we haven't noticed any bug so far, but please keep that in mind. If you notice any issue let us know in the forum.

Enabling the spell checker

To enable or disable the spell checker, simply click on the top right hand globe icon (or select Spell Checker in the Tools menu), then select the language you would like to use. Since the list of languages can be huge on certain operating system, the latest selected languages also appear just below the "Use spell checker" checkbox.

Activating the Markdown Editor Beta spell checker

By default, the spell checker is not activated in the Markdown editor even if "Use spell checker" is ticked because it is currently in Beta state. To enable it, go to the General settings, open the Advanced Settings, and select "Enable spell checking in Markdown editor". As mentioned above, we think the feature is stable and haven't found any bug with it, however if you notice anything please let us know.

I'm still trying to get a sense of what sharing and collaboration features would be useful in Joplin. By this mean any way to share a note with someone else or have multiple users collaborate on the same set of notes or notebooks.

If a feature like this might interest you, I'd be helpful if you could describe: how would you use it? How would you expect it to work?

All this might not be implemented right away, but it will inform how the development should happen for example by making sure that even if a feature can't be done now the software is done in such a way that it's possible to add it later on.

Any idea or suggestion is welcome!

In this series of posts about version 1.1, we'll introduce another feature by one of our GSoC candidates, Anjula. Anjula developed over the past few months a system to allow configuring the keymap shortcuts, and created a nice editor for it.  Here is what he has to say:

Joplin desktop application supports keyboard shortcuts to a certain  degree. However, there wasn't an option for users to configure keyboard  shortcuts according to their preferences. My project was to implement a  keyboard shortcut editor along with the necessary integration.

Custom keyboard shortcuts would be a great addition for all Joplin  users including power users and those who are migrating to Joplin from  other note-taking applications. People also do not have the same  keyboard layout; not everyone has F6 necessarily. It would solve  conflicts between different preferences of workflows, and increase  discoverability for all keyboard shortcuts.

Back-end service for handling keymapping-related functionality​

KeymapService builds an in-memory keymap based on the default keymap  configuration. The default keymap configuration may vary from platform  to platform. Essentially, the in-memory keymap binds a keyboard shortcut  for some command of Joplin. Clients of KeymapService may obtain the  keyboard shortcuts for some commands, and/or alter the keymap via the  provided methods.

KeymapService also allows altering the keymap via a keymap file,  which is located in the profile directory. Contents of this keymap file  will take higher priority than the default keymap configuration, and  will replace the default keyboard shortcuts.

It is guaranteed that the keymap always stays pristine with proper validation.

Keyboard shortcut editor with the necessary functionality to alter the keymap​

Depending on the interfaces of KeymapService, the Keyboard shortcut editor allows the user to,

• View all the available commands and their respective keyboard shortcuts
• Change, or disable a keyboard shortcut for some command
• Restore a keyboard shortcut to its default value
• Export all changes to a keymap file (in JSON format)
• Import changes from an exported keymap file
• Perform a simple search to locate some shortcut

Changes performed to the keymap will be reflected immediately in the  application user-interface as well as in the keymap file located in the  profile directory. The editor will also perform continuous validation to  ensure that the keymap will not enter a dirty-state. For example, it  won't allow the user to use the same shortcut for two or more commands.

The complete report with details of code contributions can be found here.