Project vision

Stuff is a content centric iconoclast successor of today’s desktop environments. It abandons files and directories in hierarchies, the desktop metaphor and applications.

Stuff treats documents, paragraphs of text, images, tags, titles and other meta data as well as the components a document all as the same type of content — strings. Their relations provide structure to information.

Any item can be used as a tag and tags provide navigation and management of data. Tags are both user- and system generated.

The current set of content is filtered and visualised by the active view. The view is the editor, creation and editing of data is a natural, seamless part of viewing data.

Data manipulation and visualisation views are interchangeable components. Modularity allow stuff to evolve into being truely general purpose, adapting like a chameleon to different user groups, interaction models and form-factors.


Stuff currently alpha quality, the author keeps both his calendar as well as stuffs todo and bug lists inside his own stuff instance at the moment. The user interaction currently is a scaffolding that has allowed the rest of the functionality to form. 2008-09: Stuff has been frozen and shelved, pending future resurrection


To stuff everything is a string. The string could be a path to an image or other file in local storage or on the web like a URI. The string could also be the title of a film, first paragraph of a document, title of a document a tag or meta data about another string. Meta data is represented as key/value pairs that can be retrieved and set on any string. Stuff uses TT for it’s internal storage of strings and their relations. The user interface is a modular browser that supports modules for different view modes like list, one-level hierachy, grid, calendarand 2d spatial layout. The items contained in the different view modes are other modules for different media types or widgets. Adding new commands that can be bound to keybindings are also easily added to the framework.

Right now all of stuff is written in C using Clutter and statically compiled, adding support for dynamically loading components written in an embedded high-level language would complete the bootstrap of a flexible extendable environment.

TT is direct access, and simple query API for a triplet store. Stuff’s usage of TT doesn’t mirror RDF but takes some shortcuts. Like making the predicates of RDF statements (with empty or non-empty object) act as tags, tt also prevents multiple predicate arcs of the same type from a subject. String in TT are internally quarked, allowing the application to pass integer handles around instead of strings.


OGG Screencast, low-fps(buggy driver) screencast of stuff.

Screenshot from hypermedia GEGL presentation at GUADEC 2008. Showing the layout view. Like in all of the views shown here, all the child items of the view are tagged with the category, which is also used as the title in the upper left for each screenshot.

An example of the list view, containing the stuff todo list in august 2008.

The grid view, showing a directory on a hard drive, all the tags shown are automatically generated tags that also are applied to the individual files in the directory.

The calendar view is used automatically for categories on the form YYYY-MM, adding all the needed children on the fly. The children are normal categories, in the view their children are also shown. Images, other categories etc can be tagged with a date on the form YYYY-MM-DD to be part of the automatic calendaring system.

The year view directly uses the month views as it’s children, but blocks interaction with the view.

An item visualization mode showing a real time analog clock.

Attribute view used to edit keybindings.

Attribute view used to edit settings.

GEGL presentation made with using a file system backed early stuff prototype.

GEGL Image editing part of GEGL presentation at FSCONS.

OGG Screencast, chipmunk based physics engine integration with stuff and clutter.


  • Allow queries for documents/images/categories/items.

  • Make use of an embedded extension language for additional items, actions and views.

  • toolbar / context menu with available actions (and their keybindings)

  • Content filter plug-ins for all views for filtering and reordering the result set.

  • Setting a background/theme per view.

  • Edit settings in-situ (attribute view).

  • Items

    • embed video

    • text (file) editor

    • terminal

    • web browser

  • Wiki links directly from paragraphs of text.

  • export database to hyperlinked htmls + svgs + images.

  • mindmap visualization mode.

  • GEGL graph editing mode.

  • Add ability to split text items (like in hnb).

  • Map view (for coordinates?, geohas?)

  • Zpim renderer

  • Wikipedia data source?

  • Refactor to use RDF instead of custom (ab)use of triplets?


Stuff can be downloaded from, which contains a tarball with snapshots updated at moments of stability in stuffs development.

To keep up to date, you can also use git see


Stuff currently builds and works on debian like system, it probably works fine on many others.

  • clutter is the core gui engine for stuff,

  • libgnomeui2.0 (uses it’s thumbnail factory)

  • Documentation (this document)

    • asciidoc

In debian the dependencies are: build-essentials libclutter-0.8.0-dev libgnomeui-dev and libgdkpixbuf-dev


To build stuff type the following in the toplevel source directory:

$ make
$ ./stuff


See the tutorial that stuff launches into for descriptions of how to use it.


Individual files contain their own copyright and licensing information, most of stuff is GPLv3+ though some portions are LGPLv2+.