Skip to main content

The ECM Rich Client Platform (Apogee) Project

An Eclipse Technology Project Proposal
March 2006


The Apogee Project is a proposed open source project under the Eclipse Technology Project.

This proposal is in the Project Proposal Phase (as defined in the Eclipse Development Process document) and is written to declare its intent and scope. This proposal is written to solicit additional participation and input from the Eclipse community. You are invited to comment on and/or join the project. Please send all feedback to the newsgroup.


This project comes from our thought about next steps in the Enterprise Content Management (ECM) market. More and more customers need specific application related to ECM to properly handle their data and integrate in a seamless way all their digital assets and involved processes. These applications share a lot of features and need many common services. ECM applications developers definitely need a framework that would ease the creation of this kind of desktop applications, when the browser is not enough...

Eclipse RCP is expected to play a major role for next generation desktop applications. In the ECM business, web interfaces are great, but some customers / applications need more (highly responsive interface, rich UI, desktop integration, offline mode support, etc.).

At Nuxeo, we already have delivered some projects in this area and have begun to create such a framework for ECM applications, called Apogee. It's time to take it to the next level.

This project aims at building a framework to create ECM-oriented desktop applications, independent from vendor or technologies. This framework could be used to create applications that will be integrated with Documentum , Interwoven , Nuxeo CPS or any ECM platform.


This project's goals are to :

  • Define generic concepts and models required to create ECM desktop applications (documents, content types, storage, communication, standards, workflow, search, synchronisation, online/offline, etc.).
  • Build the core infrastructure needed by desktop ECM applications, implementing the concepts and models defined above.
  • Build a set of highly-customizable application-level components that would ease the creation of ECM desktop applications (mail client, IM, forms, calendar client, document editor, etc.).


This project is divided into 2 area: 

  • Core Platform: offers the low level document management infrastructure
  • Application Platform: a set of highly extensible applicative components

Core Platform

  • A generic resource model / content repository that can be integrated with Eclipse's resource model. JSR-170 (Java Content Repository) is considered as the native local resource model for Apogée (JSR-170 begins to be widely adopted in the Java community). Adapters between JSR-170 and Eclipse resource model will have to be written. The open source implementation of the JCR at Apache is JackRabbit and seems to be a good candidate for Apogée. For JackRabbit's backend and non content-related data storage, we plan to study db4o (it could also be used as PersistenceManager for JackRabbit). Vendors should be allowed to write their own Apogée connector, allowing them to connect Apogée to ECM platforms using proprietary interfaces.
    As the JCR does not define a data model, Apogée will still need to provide a convenient way to handle content / data model (this is more detailed in the content repository and storage specification of the apogée project).
  • A form services (based on XForms) to define content creation/edition forms, user interface forms (like workflow action forms), etc. that would be directly delivered by the ECM platform using XForms forms, according to the content model used.
    This service can generate Eclipse Forms / SWT from the XForms description using the Eclipse XForms engine.
  • A generic model to define actions / views available on a document, integrated with the ECM platform (edit, check-in, check-out, properties, etc.) actions model. Actions have to be integrated with Eclipse's menuitems / views model.
  • A pluggable unified security model based on roles/permissions that can be easily integrated with the ECM platform (on the server). We are currently investigating ETF/Higgins and Acegi for this part.
  • An Indexing and search service will be provided by JackRabbit built-in index and search features. Apogée may allow developers to plug other search engines, that could be needed for specialized needs.
  • A relation service to handle relation between resources (RDF based). This component may be based on Sesame. This service should be independant from the content repository.
  • A communication service that can be used by components to communicate with the ECM platform and other component of the information system. This component will use the Eclipse Communication Framework (ECF) (and protocols like XMPP / SOAP / XML-RPC or JMS).
  • A subscription-based user notification mechanism (to allow the user to be notified by the ECM platform through various channels like UI glitches (ex: windows tray), email, instant messaging (or SMS) when events occur. This service may be based on ECF.
  • A service to handle online/offline mode and enabling/disabling actions/capabilities according to the connexion availability. This has to provide local and remote content repository synchronisation. SyncML (through Sync4J/Funambol) may be used here.
  • A digital signature service to sign documents and workflow actions.

Application Platform

  • Mail client component that can be used to create a specific, business-oriented, mail client (for example : custom mail-based application like workflow-based collaborative mail management or CRM application).
  • Calendar component (customizable to create calendar-style application like planning management).
  • Instant Messaging component (presence and synchronous communication between users, user notification channel). This would be based on ECF.
  • Rich document editor (based on XHTML) that can be used to create custom content editors (for example a custom NewsML document editor or a DocBook one).
  • Collaborative workspaces (that would offer access to collaborative workspaces on the ECM platform).
  • Synchronous document editing (plugged into the document editor).
  • Annotation service (that may be based on Annotea).
  • Tagging and categorization service.
  • Reporting service (BIRT based) to allow the creation of activity reports.

Existing standards and projects leveraged

This project will be based on a number of high-quality open source framework:

This project will be heavily based on open standard :

  • W3C XMLSchema for content/data schemas
  • W3C XForms for forms provided by the ECM platform (edit view, workflow actions forms, search form, etc.)
  • RDF as relation format
  • XMPP as communication protocol / XML bus / event channel
  • SOAP


This project will be organized into 2 top-level components :

  • Core Platform (CP) : build all core services like data storage, relation, form, content type, indexing / search, communication, synchronization, etc.
  • Applicative Platform (AP) : mail client, calendaring, rich text editor, workflow editor, collaborative workspaces, digital signature, IM, etc.

Proposed initial committers and project lead

The initial committers will focus on developing and creating core services. The agile development process adopted will follow's standards for openness and transparency. Our goal is to provide the infrastructure and APIs needed to build a strong developer community that would empower the plateform to make it quickly grow. The initial committers are:

  • Eric Barroca ( : project manager
  • Bogdan Stefanescu ( technical leader
  • Eugen Ionica (Nuxeo): relation and search services
  • Cédric Bosdonnat (Nuxeo): content editors and synchronization
  • Carl Rosenberger (db4objects): storage service

Interested potential commiters are kindy invited to express it on the newsgroup or via email.

Interested parties

Interest have been notified by follwoing organization so far:

To express support, concern, or constructive opinion regarding the formation of this proposed technology project, all are encouraged to utilize the newsgroup.

Initial contribution

The current source code and documentation repository for this project currently live here : (direct SVN access : A website is also available for documentation publishing:


Development model is time based. Major release cycle is yearly.


  • M1 - April 2006
    • [CP] Technical specifications of the core platform (60% done)
    • [CP] Resource model (done — currently being refactored on top of JackRabbit)
    • [CP] Relation service / RDF (done)
    • [CP] Indexing and Search service / Lucene (done)
    • [CP] Rich Content editors (MSWord, OpenOffice, XHTML) (done)
    • [CP] Eclipse Forms generation service (XForms based, alpha support, done)
    • [CP] On-the-fly validation of a SWT form with a XML Schema (XSD) (done)
  • M2 - June 2006
    • [CP] Communication service (XML-RPC based)
    • [CP] Integration of server-defined actions available on resources (documents)
    • [CP] Content type service (use content types defined by the server with XSD)
    • [AP] Collaborative workspaces
    • [CP] Rich Text Editor (done)
  • M3 - August 2006
    • [CP] Security model and service
    • [CP] Form service (XForm full support)
    • [CP] Client / Server synchronization -> online/offline mode
  • M4 - September 2006
    • [CP] Communication framework (SOAP support)
    • [AP] Instant Messaging (XMPP based)
    • [AP] Mail client (alpha)
    • [AP] Calendar client (alpha)
  • RC - October 2006
    • Feature freeze
  • Final - December 2006

2.0 - September 2007

  • [AP] Digital signature
  • [AP] Reporting service
  • [AP] Mail component (complete)
  • [AP] Calendar component (complete)
  • [AP] Relation management (relation graphs, visual relation management)
  • [AP] Synchronous collaborative rich document edition
  • [CP] Annotation service

Back to the top