Hi All,

Recently there have been a number of proposals for significant changes in Geany, different languages, GObjectification and other various changes.

As good or bad as the individual suggestions may be, they have made it clear to me that there is no plan for the future of Geany that allows them to be evaluated effectively.

So I am starting this thread to try to get ideas on where Geany should be headed.

To start the ball rolling, here are some of the things I see Geany should aspire to:

1. An architecture that allows multi-threading to be used for non-GUI tasks.  The most obvious of course is parsing.  At the moment none of the parsers support symbols in anything other than the global scope, and adding them would significantly increase the parsing effort, but doing it in a background thread would make the performance hit less obvious.  But there needs to be a careful design of the passing of data from the edit buffer to the parser and back to the symbol tables to minimise overhead, latency and ensure its non blocking.  With such an architecture other complex functionality can then also happen in the background without impacting Geany's responsive feel.

2. Language specific assistance, such as indentation, or dynamic error marking and intelligent autocompletes.  I consider that these hang off the previous capability of better parsing/analysis of the program.  Matthew has demonstrated a prototype that provides some of these facilities using libclang (for the clang languages only C, C++, Obj-c).  But the current Geany architecture does not support plugging such things in easily, and with the number of languages that Geany supports, I would suggest that its small, light and fast tag would be severely threatened if assistance for all languages were plugged in at once.

3. Proper portability.  At the moment Geany is really a Linux application that has some limited (and buggy) support for Windows.  The main editing widget that Geany uses is available for many platforms and toolkits.  If Geany had an architecture that separated the target specific parts into a "backend" the way Scintilla does, then it would be possible to support multiple targets more easily, making Geany less at the mercy of one toolkit's direction (that means you deprecating GTK) and better able to support different platforms like OSX and Windows.  Work such as that Dimitar is doing for spawning on Windows naturally then falls into such a backend.

4. Multiple top level windows.  As monitors are cheaper, being able to spread views of files to optimally utilise the screen space available adds to the users effectiveness.  Most languages support multiple modules in different files and many use multiple files for related parts, such as C/C++ header and body.  Looking at and editing several places/files at once has many uses.  As useful as splitwindows one and two are (especially together) they still assume a single rectangular top level is available for subdivision.  But different desktop menu layouts or having other applications visible at the same time can limit the contiguous rectangular space available.  Multiple top levels can make better use of non-rectangular space.

These are all big changes that don't fall into the current Geany mode of "light maintenance and extra features as someone implements them".  For big changes like those above however, a clear design and a planned process is needed to ensure that the big changes don't clash with each other and that they are not derailed by interim smaller changes.

I would suggest the process to be:

1. gather other major ideas for capabilities that Geany should plan to support
2. develop a design that supports these (or at least the most useful ones)
3. look at how that design can be implemented, can the existing design be mutated to it, or is it a clean framework that large parts of the existing functionality can plug into, or is it a whole clean implementation.  This also includes issues like languages to use (C, C++, Vala, Haskell etc).
4. depending on the outcome from 3. use a new repository organisation or at least a new branch in the existing Geany repo to ensure that the existing Geany is not destabilised by major changes as they take place.

This is something very different to the way Geany is currently operating, and I don't know if the community wants to consider such a more structured approach.  If its felt that its worthwhile then I suggest that steps one and two are best achieved using the wiki and I will volunteer to set up and maintain page(s) for those phases at least.

So to summarise, what capabilities should Geany aspire to support, and what is the process to develop the best software architecture to support those capabilities.