Armin Burgmeier edited this page Aug 25, 2014 · 7 revisions

Gobby Development

There are two core projects involved in Gobby development. The libinfinity shared library contains the implementation of the protocol that is used to synchronize document changes between users, and the actual Gobby application implements the graphical user interface on top of libinfinity.


Libinfinity is a shared library that provides the implementation of the concurrency control algorithm and the implementation of the infinote protocol. It is licensed under the LGPLv2.1+. The library itself consists of the following projects.

  • libinfinity: This is the core part of the libinfinity API,, implementing the directory tree structure and the concurrency control algorithm.
  • libinftext: This part of the library specifically handles synchronization of plain text documents, on top of libinfinity's concurrency control mechanisms (the adOPTed algorithm).
  • libinfgtk: This part of the library provides integration of libinfinity with the GTK+ toolkit. It provides widgets for certificate handling and showing permissions for nodes in the tree.
  • libinftextgtk: This part of the library provides integration of libinftext with the GTK+ toolkit. It allows to use GtkTextBuffer for the text storage, such that it can be displayed at the same time in a GtkTextView widget, and it has functionality to draw cursors and selection areas of remote users.
  • infinoted: Infinoted is a dedicated Gobby server that ships with libinfinity. There is more information available about it here on the Wiki.
  • libinfinoted-plugin-manager: This is a small library that is shared by infinoted and infinoted plugins. It provides a way for plugins to access the state of the server.

Libinfinity at the moment is declared as unstable in the sense that its API is allowed to change. However, when an API break occurs, the API version of the library is increased, which results in parallel-installable libraries. Typically, this is done when the minor version number changes. For example, libinfinity 0.5.0 and 0.6.0 are parallel-installable and have a different API. However, every release in the libinfinity 0.5.x series are API stable.

See API Documentation for an extensive reference-style documentation of the available API in libinfinity, and Infinoted Plugin Development for instructions how to create custom plugins for infinoted. Special instructions are available for how to interface infinoted to external user databases.


Gobby is a GTK+-based application which on top of libinfinity implements a text editor application with support for collaborative editing. Since version 0.5.0, it is licensed under the ISC license.

Web Client

While at the moment there is no web interface that is compatible to the infinote protocol, there is a JavaScript library, jinfinote, which implements the concurrency control algorithm (adOPTed) in a compatible way. This is the part which is doing the actual "hard work".

Ideas for Future Development

This is an ideas list of features that can be implemented in the future.

  • Typing Sounds: Whenever someone else is typing, (optionally) play a sound of keys on a keyboard being pressed, and maybe indicate it also with a different icon in the userlist.
  • Multi-Threading: At the moment, libinfinity is completely single-threaded, except for some otherwise blocking operations such as generating a private key. Instead, each communication group (i.e., each session) could run in its own thread, to better exploit multi-core systems. Only the InfTextGtkBuffer implementation would then need to dispatch its operations in the GtkTextBuffer to the main thread, and wait for it to finish. Much activity in the same session would still be single-threaded, however there things would be harder to parallelize. The concurrency control algorithm could be run in a separate thread, such that extensive operations are not blocking, and incoming requests could then be queued. Also, the concurrency control algorithm itself could be partly parallelized when transforming two requests A, B at a certain vector state V against each other. At this point, one could translate A and B in parallel to the state V.
  • More Server Slimdown: The password and PAM authentication options of infinoted could be converted into plugins, such that the core of the server application is as small as possible.
  • Timeline widget: A GTK+ widget would be nice that is showing the current text documents, and provides a slider to go back and forth in history.
  • Infinote Record Viewer: In a similar way, a widget would be nice to show session records, so that recorded sessions can be replayed and seeked in. On top of such a widget, a standalone application to play a record could be useful.
  • OCSP: The OCSP protocol for certificate revocation should be supported, and also OCSP Stapling.
  • Gobby Client Certificate Storage: At the moment, Gobby stores one private key and one certificate, and uses it both when another client connects (as a server certificate) and when Gobby itself connects to another server (as a client certificate). Gobby should instead have separate properties for these, and also allow more than one client certificate to be installed at the same time.
  • Multicast Discovery: At the moment, Gobby can discover other instances and servers via avahi on Linux, however that option is not available on Windows and Mac OS X. It would be good to use mDNS implementations on these platforms to provide the same service, or alternatively, an own simple discovery protocol using UDP multicast.
  • "default" account: When looking up permissions that are not set, the permission for the "default" account and the root node (which must be set) is taken. Instead of the "default" account, there should be two default accounts, one for authentication and one for unauthenticated users. This would allow to enable authenticated users with some operations (as opposed to unauthenticated ones), without having to enable that permission for each user individually.
  • Account groups: It would be good to support groups of accounts that can also given permissions to. It might be helpful to implement an "account hierarchy", where an account can have a parent account, and when a permission is not set for an account, then it is looked up for the parent account. The hierarchy would then by user -> group -> "authenticated".
  • Password authentication: At the moment, only a global server password can be used to protect the server, but the password cannot be used to authenticate users, since there is no per-user password available. On the server side, there is limited support already available to set and store user passwords, but there is no mechanism to use the password provided by the user to also authenticate the user and apply the corresponding permissions.
  • Git Integration: Some sort of integration of Gobby with Git could prove to be very useful. However, it is not intuitively clear how the best way for this to work would be, and some more thinking is required there.