With the QGIS Grant Programme 2023, we were able to support four proposals in the first round and an additional two proposals through the second round that are aimed to improve the QGIS project, including software, infrastructure, and documentation. The following reports summarize the work performed in the proposals. 

1. QGIS Bug Tracker cleanup #266 – Report
   While checking existing bugreports we have identified and closed ~291 tickets, among them:
   
   – 162 bugreports and feature requests which were already fixed or implemented
   – 29 bugreports and feature requests which are invalid (data issues, wrong use of functionality, etc)
   – 57 duplicate bugreports and feature requests
   – 5 won’t fix bugreports
   – 5 bugreports were converted to feature requests
   – 33 tickets were closed (does not contain steps to reproduce, test data and no feedback was provided within several month)
   
   Additionally we ensured that all tickets has correct tags assigned to to make them easier to find.
   
   
2. Porting to C++ and harmonization of Processing algorithms #271 – Report
   The work has been completed with several pull requests:
   – Port various geometry algorithms to C++ 
   – Port Align Rasters tool to Processing 
   – Port Raster Calculator algorithm to C++ 
   – Port XYZ Tiles algorithms to C++ 
   
   Existing Processing algorithms Voronoi Polygons and Delaunay Triangulation have been ported to C++ and now use GEOS instead of the unmaintained Python module. Both algorithms have been given additional parameters to disable post-processing step (adding attributes of input points for Voronoi polygons and adding feature IDs of the 3 points forming a triangle for Delaunay triangulation) and thus improve algorithm performance. The Concave Hull algorithm has been ported to C++ and uses GEOS for QGIS builds with GEOS >= 3.11, while a port of the existing implementation based on Delaunay triangulation is used for builds with older GEOS versions.
   
   Two algorithms for generating XYZ tiles (directory and MBTiles variants) have been ported to C++ using a safer and cleaner multi-threading approach.
   
   The Align Rasters tool (available from the Raster → Align Rasters menu), which was not exposed to Processing, has been removed and a new Processing algorithm with the same functionality has been added. To make this possible, we have added a new QgsProcessingParameterAlignRasterLayers parameter type to Processing, which provides an adapter to QList<QgsAlignRaster::Item>. The “Raster” menu item now opens the Processing algorithm. We have also added a separate, simplified modeler-only version of the algorithm that accepts a single raster to align and returns a single raster layer output.
   
   The existing Raster Calculator algorithm has been ported to C++. The algorithm now has two variants: a toolbox version that works the same way as before, and a modeler version that uses the same approach to input naming as the GDAL raster calculator (in the formula, you should use letters instead of layer names). The old algorithm implementation has been retained for compatibility with existing models and will be removed in QGIS 4. We have also added a separate raster calculator algorithm for creating virtual raster layers.
3. Improve test result handling on QGIS CI #268 – Report
   While the original proposal was explicitly stated to be a research project with no guarantees of success, the end result is predominantly a success (with some limitations!). You can see the new failure handling in action in this PR. 
   
   What we have now is that any tests which fail a rendering comparison will write a descriptive comment to the PR, as shown in the above link. The comment details which render tests failed, where they are in the code, and includes some helpful pointers to downloading the full test report and the QGIS developer documentation.
   
   Originally, I hoped to link directly to the full test report or include it as an attachment to the comment. Unfortunately this is NOT possible given the current Github API. There’s a bunch of notes I’ve added to the initial comment which link to the limitations / feature requests on Github’s side, so we can monitor the situation and further improve the reports if/when Github add this functionality.
   
   As well as the above described improvements on the CI side, I’ve also implemented lots of improvements in running the tests locally and how the render test reports are generated and presented to developers!
   
   
4. Unification of all geometric and topological verification methods #236 – Report
   Our efforts are primarily focused on two main aspects of the proposal:
   1. Unification of Algorithms:
   This component entails both refactoring existing algorithms and introducing new ones. While the refactoring phase did not reach the level of ambition initially envisioned, considerable cleanup has been achieved, particularly in eliminating code duplications, as evidenced by the PR submitted [1] [2] [3]. Other deduplications could be considered, but the main issue is not to break the small optimizations or adaptations to the logic of the existing code.
   
   2. Integration of Geometry Checker Algorithms:
   Following the discussions within the QEP framework, we have decided to transition algorithms to those already present in the geometry checker. These algorithms encompass topological considerations. Unfortunately, due to timing constraints with the year-end and the feature freeze period, this integration was not yet completed. [4] [5] 
    
   Processing Integration:
   Efforts have been made to incorporate the geometry checker’s algorithms into the processing framework [6] [7] [8]. Regrettably, these efforts have not yet been fully realized. We encountered challenges in aligning processing with the logic of the geometry checker. However, the ongoing PR by Jacky shows promising progress in overcoming these obstacles. We are optimistic about achieving the integration of geometry (and topology) checker algorithms into processing for the upcoming version. This integration aims to streamline ETL processes for verification and correction tasks, thereby enhancing codebase cleanliness.
   
   
5. The remaining project reports will be added as the projects wrap up.

Thank you to everyone who participated and made this round of grants a great success and thank you to all our sustaining members and donors who make this initiative possible!