This page lists proposed ideas for projects to improve Inkscape. The original list is from Krzysztof Kosiński. Consider it a permanent work-in-progress "brainstorm" list and feel free to add your own comments and project proposals. None of these are "official" and have not been thoroughly reviewed/debated and so may or may not fit with actual development plans.
- 1 General Codebase
- 2 Object Tree
- 3 Interface
- 4 SVG Support
- 5 Paths
- 6 Print
- 7 Technical Writing
- 8 Packaging and Release Management
- 9 Bug Triage
- 9.1 (100% Complete) Update Status for Critical Bugs from New
- 9.2 (100% Complete) Update Status for Critical Bugs from Fix Committed
- 9.3 (100% Complete) Update Status for High Priority Bugs from Fix Committed
- 9.4 Update Status for High Priority Bugs from New
- 9.5 Tag OSX bugs
- 9.6 Tag Windows bugs
- 9.7 Link Cairo bugs
- 9.8 Set Importance on Confirmed / Fixed Bugs
- 9.9 Ping Old Low Priority Bugs
- 9.10 Confirm all appropriate bugs marked Incomplete with responses
- 9.11 Convert high priority wishlist bugs into blueprints
- 9.12 Close old incomplete bugs with no response
- 10 Other
- 11 Finished Projects
Migrate argument parsing to GOption and remove the dependency on popt
Write test cases for this bug, so that the patches can be accepted into GLib: https://bugzilla.gnome.org/show_bug.cgi?id=522131 If this proves hard, simply apply the patch to the devlibs. Once this is done, port argument parsing to GOption.
Improve Icon Cache
Convert the icon cache (icon.cpp) to create the PNGs with a directory structure and index file matching the icon theme specification. Use this to get rid of customized classes InkAction, SPIcon, and so on. Partially Done
Replace the print functions in the SPxxx classes with a generic "Visitor" pattern and port the different export types (e.g. EMF, PDF, PS) to the new routines.
Clean up all unnecessary castings in C++ classes. Remove unnecessary use of "this". Etc.
In depth code reviews of submitted patches. This is done by some other projects with great success. It speeds up getting patches committed which encourages contributions. It can also be a good learning experience.
Robust ID handling refactoring
Currently ID clash resolution is implemented as a giant switch over object types, listing every possible dependency. Replace this with virtual methods on objects, which provide information on what each object refers to. Improve behavior when a dependency of an object is deleted, and when IDs are changed / deleted from the XML editor.
See id-class.cpp for specifics.
It should be possible to change ID and have Inkscape update all references. It should also not be automatically created for all objects. Tav
Convert the current document parser from DOM to SAX, so that it creates our XML tree right away, instead of creating the libxml2 DOM tree, creating our tree to match it, then freeing the libxml2 tree. This should improve performance and allow more robust fixes for some problems.
Typed XML tree
Improve XML tree so that it can store some attributes in parsed, binary form. The main target of this are the data URIs used to embed images, which could be stored as binary data only. This work should be done after completing task 3 (SAX parser), as this will make it easier.
Layer visibility performance improvement
Right now, toggling layer visibility causes massive changes in the display tree, because the entire toggled layer is invalidated at the XML level. This results in very bad performance for an action which should be nearly instantaneous. Improve the control flow so that only the visibility of the object representing the layer is turned off, but the remainder of the display and object tree is left alone.
GTK 3 on Windows
Rebuild the Windows devlibs so that they contain GTK3 Make the Windows port work with them, possibly sending the appropriate patches to the GTK maintainers.
this is already being worked on by Jazzy Nico: https://code.launchpad.net/~inkscape.dev/inkscape-devlibs/devlibs-gtk3
Provide actions which are actually relevant in the context menu, depending on the context of the selection. Examples of such actions include: release mask, release clipping path, put text on path, embed / extract image, unflow text, and so on.
Page size editing on the canvas
Provide a way to edit the page size directly on the canvas, using a manipulator similar to the rectangle, instead of keying in numbers in the Document Properties dialog.
On-canvas tool controls
More tool controls could be available on-canvas right by the object being edited. An example of this would be having some of the text tool controls available right by where text editing is happening akin to what GIMP provides.
Numeric input on the canvas
Right-clicking on nodes should bring up a numeric entry box which would allow you to specify its position numericaly. This could allow us to phase out some of the controls on the top bar. For dynamic offsets, the numeric entry would simply be the width of the offset
Unify document and desktop coordinates
Change the desktop coordinates to match document coordinates. Make it so that document coordinates are specified in the coordinate system of the toplevel SVG element, so that it is possible to emulate other coordinate systems using a suitable transform attribute or viewBox.
The idea here is to rewrite shape tools in the same paradigm as the node tool. Instead of storing all information about the shape in knots which differ only by their callbacks, allow to store information in a higher-level manipulator object. This would enable things like dragging the side of a rectangle and consistent outlining / update preferences for all shapes.
Improve the performance of layer visibility
Right now, toggling layer visibility causes massive changes in the display tree, because the entire toggled layer is invalidated at the XML level. This results in very bad performance for an action which should nearly instantaneous. Improve the control flow so that only the visibility of the object representing the layer is turned off, but the remainder of the display and object tree is leaved alone.
We have a solid plan on how to do this without special svg 2.0 spec and it's technically pretty simple, involving layers and the way we currently specify layer type. It's a project which would attract a lot of attention, even if at first the support didn't include saving the pages to pdf or other such documents.
Move the existing flowed text XML representation into an svg:switch and provide an alternative fallback representation with SVG 1.1 text objects only.
This should be done via SVG 2 CSS text wrapping which provides a simple SVG 1.1 fallback mechanism.
Refactor live path effects so that their XML representation matches that of SVG 2.0 vector effects. Put them in switches, so that the output is not limited to a single path. Integrate them better with core Inkscape. For instance, instead of four actions: inset, outset, dynamic offset, linked offset, there should be only one: offset. Using it on a normal path would create a dynamic offset, while using it on a clone would create a linked offset. The same principle would apply to vector effects: creating them on a normal path would move the path to defs and replace it with the vector effect, while creating them on clones would delete the clone and create a reference to the original path.
Create the document and rendering tree for linked SVG images. Use Inkscape's renderer instead of relying on the librsvg loader to avoid inconsistencies. Allow importing the linked image as a group via the context menu.
Mesh gradients, hatches, etc. See SVG2 page. Tav
Rewrite of Geom::PathVector and Geom::Path
Change PathVector to be a real object instead of a std::vector of Path, so that it can have useful methods, similar to curves.
Move the copy-on-write idiom to the PathVector object, rather than using it in the Path.
Investigate whether it is possible to store subpath data in a more compact way and make the Curve objects only convenience facades. Right now, if the path has only linear segments, every point is stored twice.
Apply the following renames to match SVG terminology:
- Path -> Subpath
- PathVector -> Path
Boolean operations and stroking
Add methods to PathVector objects:
a) Set operators (& | - ^), which perform the relevant boolean operation on the paths. Use the algorithm from CGAL or devise a new robust algorithm.
b) stroke(double line_width, LineJoin join, LineCap cap, double miter_limit), which performs the stroke-to-path operation.
c) stroke(double line_width, LineJoin join, LineCap cap, double miter_limit, std::vector<double> const &dasharray), which performs stroke-to-path with dashing.
SPCurve is a thin wrapper around Geom::PathVector which exists for historical reasons. Its functionality should be added to PathVector, and SPCurve should be purged.
Fill out arcs functionality
For accurate path Boolean operations with elliptical arcs, allow arcs in PathVectors and support Boolean operations between arcs and between elliptical arcs and S-Basis curves. Tav
Analyze what users require for CMYK and other aspects of color management, including a review of what other software does, and what can currently be done with Inkscape. Examine off the shelf code that could be used (e.g. libcms). Define what needs implemented in Inkscape's dependencies (e.g. libcairo) vs. what can or must be done in Inkscape itself. Outline project(s) to implement the needed changes. See Color_management.
Improve this Project List
Review all the projects in this list. Cleanup grammar or phrasing to make the descriptions clearer. Expand on points that are vague. Add links to relevant bug reports, feature requests, blueprints, etc. Add "[Please fill in]" to items that need more information; identify particular questions needing addressed where possible.
Release Notes Improvement
Review the release notes for the next major Inkscape release. Update wording and phrasing to be more comprehensible for end users. Fill in missing items where possible. Create and add explanatory graphics (c.f as done in past release notes). Add Known Issues from the previous release that are still relevant.
Inkscape Widgets Doxygen
Over the years Inkscape has collected a number of custom UI objects, which have been consolidated to src/widgets/. Many of these are un- or under-documented. For each widget, write doxygen comments in the header file explaining what the widget is and does, and document the widget's public API. In some cases there may be doxygen in the .cpp file for public API functions - this should move to the header.
Bring inkscape/doc up to date
The doc directory in the Inkscape codebase is used for high level technical documentation including architecture, codebase introduction, and new developer orientation, however it has not been very well maintained and much is obsolete or incorrect. It also needs to be reformatted into Markdown, and appropriate scripts created to generate it into HTML/PDF/SVG. There may be additional developer documentation in Wiki that would be worth inclusion here.
Code Doxygen Documentation
Ensure all functions declared in header files have doxygen-compatible documentation. See items in Janitorial tasks for the style we're going for. All doxygen of the core Inkscape code (i.e. excluding 3rd party libraries included in src/*/) should have consistently written and formatted doxygen, which should include descriptions of input, output, and return parameters, identification of potential errors, a one-line brief statement and a more detailed explanation of the routine's purpose.
Packaging and Release Management
Library Package De-integration
Several 3rd party codebases are included in Inkscape's codebase (i.e., src/lib*/, src/2geom, possibly livarot?). This has convenience for local patching of our own improvements and simplifies the number of components platform packagers need to deal with, however this increases the weight of our codebase and makes our package larger on platforms such as Linux that have good dependency sharing. Arguably, it may also hinder collaboration with the upstreams or other users of the libraries. Certainly it makes it difficult to roll out fixes to one of those libraries to our users. So, we want these libraries to be packaged and released separately from Inkscape.
For each of these libraries, create a separate git repository in Inkscape's gitlab project for hosting our branch of that project's code. Make sure any of Inkscape's changes to it are clearly registered as distinct git commits. If there is an active upstream project maintaining that library, make sure each of our changes are registered in their patch or bug tracking systems.
In theory, Inkscape should only be using the libraries' public APIs; doublecheck that this is indeed the case, and identify any instances where Inkscape code is bypassing it and accessing library internals directly. These should be filed as high priority bugs in Inkscape's bug tracker.
Lastly, make sure that `make dist` passes successfully for each of our branched libraries, and generates a source tarball. Inform the Release Team of the need to start separately packaging and releasing these libraries in conjunction with Inkscape's release processes.
With as many bugs as we've accumulated, working on them can seem daunting. Where to start!? Below are some encapsulated projects to try to achieve. Together, the more of these projects that are completed the less daunting the remaining work will be, and the better Inkscape will become!
The Bug management page in this wiki includes advice on how to judge bug status and importance levels.
Tip: Some of these tasks could be scripted and automated via the Launchpad email interface. See https://help.launchpad.net/BugTrackerEmailInterface
(100% Complete) Update Status for Critical Bugs from New
(DONE) Review each Critical bug with Status New, and change status to Incomplete if the last comment on the bug is a question, or Confirmed otherwise. -- Bryce
(100% Complete) Update Status for Critical Bugs from Fix Committed
Review each Critical bug with Status Fix Committed; most likely these are incorrect. If comments towards the end of the thread indicate a fix was committed to SVN, then it is okay to be in state Fix Committed. Otherwise, move it to a more accurate Status.
(100% Complete) Update Status for High Priority Bugs from Fix Committed
Review each High priority bug with Status Fix Committed; most likely these are incorrect. If comments towards the end of the thread indicate a fix was committed to SVN, then it is okay to be in state Fix Committed. Otherwise, move it to a more accurate Status.
Update Status for High Priority Bugs from New
Review each High priority bug with Status New, and change status to Incomplete if the last comment on the bug is a question, or Confirmed otherwise.
Tag OSX bugs
Using the Advanced search, identify bugs that are reported against OSX and update them to include the tag 'osx'.
Tag Windows bugs
Using the Advanced search, identify bugs that are reported against Windows and update them to include the tag 'windows'. Some bugs are already tagged with 'win32'
- Searched all entries with 'win' in it. Tagged all appropriate bug reports with 'win32'. Now only 'win32' tags exist, but no 'windows' tags. Renaming the tags via the database should be easier than doing it manually (if at all possible). Is this what you guys had in mind? --Cerno 15:40, 30 June 2008 (UTC)
Link Cairo bugs
Do a search for 'cairo'. Review the bugs (there's only about a dozen), and for each, identify if the issue is a Cairo bug. If so, look in the cairo bug tracker at freedesktop.org for a matching bug (or enter a new one if there isn't one already) and link it in via the 'Also affects: +Project'.
Set Importance on Confirmed / Fixed Bugs
Do a search on Importance=Undecided and Status=Fix Committed,Confirmed,In Progress. (There's 18 of these presently). Review each and assign it an Importance (probably Medium or High in most cases, but use best judgement).
Ping Old Low Priority Bugs
Search on bugs with Importance=Low, sorted by Oldest First. Go through the bugs that are more than a year old and review them. If they don't seem to have gotten much activity (e.g. few comments), and don't seem to be worth keeping, mark them Incomplete, with the following text:
"Thank you for taking the time to report this bug and helping to make Inkscape better. You reported this bug a long while ago and there hasn't been any activity in it recently. We were wondering is this still an issue for you? Can you try with latest Inkscape release? Thanks in advance."
or if it is a feature request: "Thank you for taking the time to report this feature request and helping to make Inkscape better. You requested this feature a long while ago and there hasn't been any activity in it recently. We were wondering; is this still on your wishlist? Can you try with latest Inkscape release and see if recent improvements have obsoleted your request? Thanks in advance."
Wait about a month, then follow up with a search against these bugs that have not received a response; they can then be closed as Invalid.
Confirm all appropriate bugs marked Incomplete with responses
Search on 'Incomplete with response', and review the feedback that's been given. If it appears the initial triager's information requests were met, and the bug seems legitimate, move it to Confirmed. If there seems to be further questions needing answered, ask them and leave it as incomplete.
As well, specify a priority for these bugs. Generally, issues that cause crashes or data loss are high priority unless they only occur in very narrow situations. Issues which are purely cosmetic or involve very obscure or limited conditions are low priority, and everything else is Medium. Only use Critical priority for extremely serious bugs that will be affecting most everyone using Inkscape.
Convert high priority wishlist bugs into blueprints
Browse the collection of bugs marked wishlist. Look for sets of related bugs that are all requesting essentially the same feature. Create a corresponding blueprint at https://blueprints.launchpad.net/inkscape, and use Specify a URL to attach it to a wiki page. Then consolidate the wishlist bug reports together onto the blueprint page. Specify if you're willing to act as the Drafter for the spec, and carry it through to acceptance, or if you prefer someone else take that role.
Once you've created the specification, use Link to bug to link each of the related bugs.
Close old incomplete bugs with no response
Do a query on bugs marked Incomplete with no response, and sort by age. All bugs older than 1 month with no reply can be closed as out of date.
Extension system improvements
Refactor the extension API. Clean up the kludgy class hierarchy, possibly using multiple inheritance. Use GInputStream and GOutputStream as parameters instead of file paths, so that things like the clipboard can have
This is a big task which has several sub-tasks:
a) Unify the interactive and non-interactive renderers. (It would be desirable to have one codebase, but we need to investigate a little more whether this is practical.)
b) Pluggable renderers - allow writing rendering backends which use something other than Cairo, e.g, OpenGL, Skia, Mozilla Azure or GEGL.
c) OpenGL renderer - implement an OpenGL 3.x+ canvas which would render Beziers using this method: http://http.developer.nvidia.com/GPUGems3/gpugems3_ch25.html
Investigate whether this generalizes to S-basis and circular arcs. Since the described method does not handle stroking, this work depends on 5.
Also check how OpenGL path rendering is implemented in Qt, since apparently the performance there is very good. http://zrusin.blogspot.com/2011/09/nv-path-rendering.html
Currently we always use a very accurate method to compute the Gaussian blur filter. Add an alternate method which approximates Gaussian blur using three stacked box blurs (simple averages). This is detailed in the SVG 1.1 SE specification.
Improve Inkscape's connectors, following the proposed SVG connectors spec. Tav
Support animation in Inkscape. Should implement the model from the Web Animations specification so that both SMIL and CSS animations are supported. Inkscape Community/Tav
Development Project Management System
Enhance Inkscape's web tools for managing development projects.
- Estimation of difficulty: Moderately hard
- Potential mentors: Bryce Harrington
- Programming skills needed: Python
- Prerequisites: Working knowledge of Django web application development
Design and implement tools to allow submitting and editing ideas for development projects. Create various project listing views that display projects that need further editing, lists of projects meeting various criteria (e.g. janitorial, new features, programming language, etc.), assigned projects, completed projects, and so forth.
This work would be part of a larger, ongoing effort to unify Inkscape's various collections of task ideas into a single system, to make them easier for potential contributors to review and select from. Some of this project has already been implemented, so you would be focusing on enhancing its user interfaces to make it more powerful and more broadly usable.
- "Janitorial" tasks suitable for new developers looking for easy ways to get involved in Inkscape development
- Google Summer of Code Project Ideas (this page!!)
- Funded development work, with funds supplied by various fundraisers
- User-supplied requests for feature enhancements
- Current collections of tasks that we want to eventually migrate into this system:
- High level specification for the system
- FundedProjectSystemDevelopment related tasks
Restore Ancient Change History
Inkscape's earliest development history is missing, with the first commit being "bzr r1" when we migrated to bzr. Prior history was in CVS and is missing. While not a huge priority, it would be nice to have this pre-bzr history resurrected and prepended to our git history.
These GLib data structures are poorly designed (they are simple lists without sentinels, leading to blunders such as O(N) performance when appending to a doubly-linked list) and not type-safe. Replace all uses with standard C++ containers or suitable Boost containers. </style>
Common build system for all platforms
Migrate and port all necessary features to the CMake build system and remove Autotools.
Use a different data structure for Inkscape::Selection
Inkscape::Selection currently uses GSList as its data structure. This is suboptimal, since a very common operation is checking whether some object is selected. Change Inkscape::Selection so that its underlying structure is a boost::multi_index container which implements the same semantics as Java's LinkedHashSet.
Remove dom/ directory
This directory contains strange code which is barely used. The only class which is actually used is the URI class.