Skip to main content



The NatTable project is a proposed open source project under the Nebula Project.

This proposal is in the Project Proposal Phase (as defined in the Eclipse Development Process) and is written to declare its intent and scope. We solicit additional participation and input from the Eclipse community. Please send all feedback to the Eclipse Proposals Forum.


NatTable is a SWT data grid widget designed to handle sophisticated, performance sensitive data visualization requirements. There are numerous SWT table/grid widgets available, but many of these face performance or resource utilization issues when attempting to display very large result sets, or they lack features or flexibility required to build complex and customizable grid-centric user interfaces. This is a limiting factor for creating complex applications such as spreadsheets or trading systems on SWT and RCP. NatTable was designed to address these gaps and provide an enabling solution for SWT/RCP applications that require sophisticated data grid functionality.

NatTable was started as an open source project by Andy Tsoi in 2007 and is currently led by Edwin Park, with more than a dozen committers from various companies contributing to the codebase over the years. It was originally targeted towards implementing financial trading systems, and some of its initial design goals were to support operation over data sets with hundreds of thousands of rows and hundreds of columns, with data being updated in realtime and dynamically styled according to custom rules, with no perceived slowdown in performance. NatTable has been used in production for years in financial systems, but has also been leveraged in many other application domains.


NatTable aims to provide a powerful and flexible data grid implementation for applications with complex data grid requirements. The goal is to provide a rich set of useful grid functionality, and also to provide a framework that allows these features to be created and composed to meet users’ specific needs. Another key goal for NatTable is to provide a performant grid implementation even when displaying very large data sets and rapidly changing data.

NatTable will integrate with established Eclipse technologies where appropriate. It is designed to work well within an RCP application context but it has no dependencies on RCP and will also work well in a standalone SWT environment.


NatTable is a custom drawn SWT widget. It is distributed as a core OSGi bundle with a minimal set of dependencies, and one or more optional OSGi bundles for various extensions. Currently there are extension bundles that provide integration with GlazedLists and export functionality via Apache Poi.

NatTable is designed around the concept of layers and layer transformations. A layer is a two dimensional array of cells, and a grid is composed by assembling layers together in various ways.

A layer may be stacked on top of another layer and provide a transformed view of the cells in the underlying layer to the outside world. For example, column reordering, hiding, and viewport scrolling are implemented in this way.

Layers may also be arranged next to each other. The column header, row header, corner and body regions of a standard data grid are implemented this way.

NatTable provides a mechanism for commands to be propagated down the layer stack, with each layer in the layer stack having the option of intercepting and processing the command. There is also a complementary mechanism for events to be fired up the layer stack and handled by layers along the way.

Virtually everything in NatTable is designed to be configurable: key/mouse bindings, cell painters, cell editors, validators, display converters, etc. Configurable elements can be applied globally or bound to particular grid regions, rows, columns, or individual cells. These bindings can also be dynamically specified. This allows you to do things like highlight rows with errors, flash data values that have changed, apply custom validation to particular data types, etc.

NatTable can easily be configured to acquire its backing data from any data source that implements its data provider API:

	public interface IDataProvider {
	   public Object getDataValue(int columnIndex, int rowIndex);
	   public void setDataValue(int columnIndex, int rowIndex, Object newValue);  // optional
	   public int getColumnCount();
	   public int getRowCount();

In addition to being extremely simple to implement, this API allows NatTable to ask for only the data that it needs. This is key to allowing NatTable to perform well for extremely large data sets.

The following screenshot shows a NatTable instance with many features enabled, including:

  • Collapsible column groups
  • Sorting, filtering
  • Frozen columns/rows
  • Custom date, numeric formatting, alignment, color
  • Selected region and highlighting of rows/columns with selected cells

Why Eclipse?

NatTable will benefit the Eclipse community by providing a solution for SWT applications with sophisticated data grid visualization requirements. Eclipse is an ideal community for NatTable because it is the hub of SWT activity. Being part of Nebula will make it much easier for clients to discover NatTable and help to establish better alignment and integration with the other widgets in the SWT/Nebula catalog.

Initial Contribution

The initial contribution will consist of EPL-licensed code from the NatTable project.

The NatTable Core depends on the following open source modules:

  • SWT (EPL)
  • JFace (EPL)
  • Eclipse Core Commands (EPL)
  • Eclipse Core Runtime (EPL)
  • Apache Commons-Lang (Apache License V2.0)
  • Apache Commons-Logging (Apache License V2.0)

The optional NatTable GlazedLists extension has an additional dependency on:

  • GlazedLists (LGPL and MPL, see Homepage)

The optional NatTable Poi extension has an additional dependency on:

  • Apache Poi (Apache License V2.0)


The following individuals are proposed as initial committers to the project:

Edwin Park, Mecha1 Industries - Project lead
Matt Biggs, Gresham Computing
Stefan Bolton, Gresham Computing
Justin Dolezy, Digital Software Technology Ltd
Dirk Fauth, BeOne
James Hunt, Gresham Computing
Stephan Wahlbrink, Independent Developer

We welcome additional committers and contributions.


The following Architecture Council members will mentor this project:

  • Andrew Overholt
  • Kim Moir

Project Scheduling

Q1 - 2012: Code contribution and migration to Eclipse

Changes to this Document

Date Change
13-Jan-2012 Architecture Council mentors added.
14-Dec-2011 Document created

Back to the top