Towards an Open Synchronization Protocol for Kirby?

The CMS Questions
,
1

Hello everyone,

After reading Maurice Renck article about synchronizing Obsidian with Kirby, I found myself thinking about a more fundamental question.

Most discussions focus on how to synchronize content between an editor and Kirby. However, during a brainstorming session with ChatGPT, another idea emerged:

What would an open synchronization protocol need to look like so that any editor could work with Kirby?

In that model, Obsidian would simply be one possible client. The same protocol could also be implemented by VS Code, an Android app, a web application, or future editors that communicate with Kirby through a common, open interface.

Before discussing technical details, though, I think there is a more fundamental question:

Who should define such a protocol?

  • The developers?
  • The users?
  • Or should it be a collaboration between both?

During our discussion, we came up with the term “council” as a metaphor—a collaborative process where different perspectives come together.

Users understand their daily workflows and the problems they are trying to solve.

Developers understand what is technically feasible, secure, maintainable, and sustainable in the long term.

And there are also people who primarily think conceptually, asking questions about architecture, extensibility, and guiding principles rather than implementation details.

One conclusion from our discussion especially stood out to me, and I’d like to offer it here as a starting point for conversation:

A good protocol should not be designed by developers or users alone. It should emerge through an ongoing dialogue between people with different perspectives—users, developers, and conceptual thinkers—where shared principles are established before individual features are designed.

I’d be very interested to hear your thoughts.

Does the idea of an editor-agnostic synchronization protocol for Kirby make sense? Or are there good reasons why such an approach would not work—or simply wouldn’t fit Kirby’s philosophy?

Note: This post was developed in collaboration with ChatGPT. The ideas were explored together during a brainstorming session, and ChatGPT helped organize and formulate them. The questions themselves and the overall direction of the discussion originated from that collaborative process.

2

Thanks for reading and moving this topic further. As I am currently nearly done with my two plugins, one for Kirby and one for Obsidian, I thought about that too.

I think with Micropub we have a good protocol, and there was a Kirby plugin that was working nicely. It’s unfortunately not maintained anymore, and it was very challenging to configure. As I learned, Micropub can be used in both directions, so this may be a solution; I didn’t know that when writing the post.

Writing those plugins, the main work was the translation of data. Of course an open protocol would help, but most of the work still will be on one side (in my case Kirby has the authority) as it has to translate/transform the data. So it may be nice to have a schema or protocol; still, most of the work has to be done on top or below it.

And regarding your question on who should be involved in defining something like this: it depends. Define “user”. When the user is the end user, let’s say a blogger, the chances are high that there is no interest in knowing anything about those things. As a user, I want to install the plugin, switch some settings, and have it up and running.

When the user is a plugin developer, this might look different.

In general, I think an open protocol should be defined publicly, I guess. This opens the possibility for everybody to participate or simply wait for things to be ready to be shipped.