IceCube refers to a principled approach to reconciliation that is general-purpose yet parameterised by application semantics. Users interact with local replicas of shared data; their modifications are recorded as actions (executable objects that can be replayed at other sites) connected by contraints (semantic relations between actions). Reconciliation consistst of collecting actions and constraints, and computing an execution schedule that executes as many actions as possible, subject to the constraints.  For instance, if two actions conflict this is expressed by a "mutual-exclusion" constraint, and no more than one of them can be in any schedule.

Joyce

Joyce is a programming framework that offers an operation-based replication and collaboration system. Joyce connects participants that are all working on the same shared data and distributes the modifications made by one participant to all the others. It allows participants to disconnect and reconnect without loss of information or responsiveness; an application can continue to run while disconnected and modifications will be propagated to it on reconnection.

Using Joyce developers can create applications that exist in an ad-hoc, P2P, collaborative environment. The framework includes APIs for; creating, discovering, joining and leaving groups, data consistency and user interface. Joyce works by maintaining, in a distributed fashion a data-structure called the multilog which represents activity across an "occasionally connected" collaborative group. This multilog is semantically rich and applications can synamically choose which parts of it to project into the local user interface. By altering which parts of the log are projected, applications can offer features such as selective undo/redo and the filtering or blocking of individual collaborators.

Joyce delivers: an assembly containing the API framework. Assemblies containing default implementations of the logging and communication facilities (these can be swapped out for bespoke implementations if necessary.) An assembly containing a "passive storage node" that, when inserted into a collaborative group, will persist the multilog for that group.

Babble

Babble is a free-flow collaborative editor written using the Joyce framework. It allows ad-hoc, multi-synchronous, multi-coordination collaborative editing, selective history management, transparent storage and snapshot versioning.

Using Babble any number of authors can edit the document at any time and in any place. There is no locking either in the document itself (e.g. region locking) or via some centralized server (e.g. source control). Authors can either be online or offline. The transition is seemless and the user experience remains the same. Offline changes will be merged when the author reconnects to the group. When a conflict occurs the editor will visualise the conflicting regions and an author can resolve at his convenience.

Using Babble, contributions from different collaborators may also be tracked and filtered. Authors may block contributions from other collaborators and block their own contributions reaching other collaborators. For example a privileged user may want to control who sees sensitive information.

The editor uses Joyce to track and isolate individual actions and their dependencies. Using this information Babble provides a selective undo/redo that is not constrained to the common FIFO paradigm. Further, the editor also uses Joyce to explicitly record cognitively high-level operations such as search-and-replace to more accurately reflect the user's mental model during editing.