About Piccolo2D

Welcome to Piccolo2D! A revolutionary way to create robust, full-featured graphical applications in Java and C#, with striking visual effects such as zooming, animation and multiple representations.

Piccolo2D is a toolkit that supports the development of 2D structured graphics programs, in general, and Zoomable User Interfaces (ZUIs), in particular. A ZUI is a new kind of interface that presents a huge canvas of information on a traditional computer display by letting the user smoothly zoom in, to get more detailed information, and zoom out for an overview. We use a "scene graph" model that is common to 3D environments. Basically, this means that Piccolo2D maintains a hierarchal structure of objects and cameras, allowing the application developer to orient, group and manipulate objects in meaningful ways.

Why use Piccolo2D? It will allow you to build structured graphical applications without worrying so much about the low level details. The infrastructure provides efficient repainting of the screen, bounds management, event handling and dispatch, picking (determining which visual object the mouse is over), animation, layout, and more. Normally, you would have to write all of this code from scratch. Additionally, if you want to build an application with zooming, that's built right into the framework too.

What exactly is it? Piccolo2D is a layer built on top of a lower level graphics API. There are currently three versions of the toolkit: Piccolo2D.Java, Piccolo2D.NET and PocketPiccolo2D.NET (for the .NET Compact Framework). The java version is built on Java 2 and relies on the Java2D API to do its graphics rendering. The .NET version is built on the .NET Framework and relies on the GDI+ API to do its graphics rendering. This makes it easy for Java and C# programmers, even those targeting PDAs, to build their own animated graphical applications. And best of all, Piccolo2D is free and open source!

How many versions of Piccolo2D are there?

There three versions of Piccolo2D: Piccolo2D.Java, Piccolo2D.NET, and PocketPiccolo2D.NET. They contain the same core functionality with a few differences. We will examine each separately here. For a detailed comparison, see Piccolo2D in Comparison.

Piccolo2D.Java: Piccolo2D.Java is written in 100% java, and the great thing about Java is that it runs on lots of machines including Windows, Mac OS X, Linux and Solaris. It is based on the Java2D API.
Piccolo2D.NET: Piccolo2D.NET is written in 100% C#. It runs on platforms that support the .NET Framework. This means mainly Windows machines. Piccolo2D.NET provides the same functionality as Piccolo2D.Java, enabling .NET users to easily integrate advanced 2D graphics and zooming with standard Windows application code. It is a deep port of the Java version. The API is very similar, but there are a few differences to better support .NET style guidelines and constructs. Piccolo2D.NET is based on the GDI+ API.
PocketPiccolo2D.NET: PocketPiccolo2D.NET is also written in C#. It runs on platforms that support the Compact .NET Framework. This means mainly PDAs. Current platforms include Pocket PCs, Pocket PC Phones, Smart Phones, and Windows CE.NET devices.

What do you mean by "Structured Graphics"?

Piccolo2D provides support for developers of 2D (+ zooming) object-oriented graphics programs in Java and C#. It uses a "scene graph" model that is common to 3D environments. Basically, this means that Piccolo2D keeps a hierarchal structure of objects and cameras. Each node in the hierarchy has a general 2D affine transform which allows every object to be arbitrarily translated, scaled, rotated, and sheared. In addition, the cameras have affine transforms that specify their view into the scene.

This simple approach is very powerful because it enables a very decoupled object oriented approach to graphical applications. Piccolo2D defines several visual components, and applications can readily extend them or define their own. Piccolo2D supports dynamic and constrained objects that respond to various kinds of context (such as the current camera view). And, the camera model supports multiple views, overviews, and even embedded views (where a camera looks at another camera within the scene).

What development directions are you following?

We are continuing to expand and maintain all three versions of Piccolo2D. But, internally, most of our new research projects are being implemented in Piccolo2D.NET.

How do I get a Piccolo2D License?

It's free! Piccolo2D is completely open source. You can download and use Piccolo2D however you like. The only restriction is that you must follow the guidelines set forth in the BSD public license.

Note that you are not obligated to make your applications open source. You are free to protect your applications in any way you see fit.

How do I contact the Piccolo2D team and Piccolo2D users?

There are several ways. You can subscribe to the mailing lists if you would like to ask technical questions or receive announcements about Piccolo2D. Or, if you find a problem with Piccolo2D, you can file a bug report.

Where did Piccolo2D come from?

Ken Perlin at New York University came up with the initial zoomable surface concept. He and David Fox implemented the first versions of Pad (described in the 1993 SIGGRAPH paper available here). Perlin and Fox's original work was supported in part originally by NYNEX, and then NSF.

The next major step was Pad++, designed by Ben Bederson and Jim Hollan while at Bellcore. They both moved to the University of New Mexico where they developed the bulk of Pad++ in collaboration with Jon Meyer and Ken Perlin at NYU. This was supported largely by a DARPA initiative in HCI.

Then there was Jazz, a rewrite in Java by Ben Bederson and his team at the University of Maryland. It was a rich toolkit and supported all kinds of features including embedded Swing widgets and SVG. However, it grew too big, and more importantly it had a very general design that actually made it somewhat hard to use because there were so many objects.

Piccolo, the ancestor of Piccolo2D, is a direct successor to Jazz. Piccolo took all that Ben and his team had learned over the years, and rolled it into a lean and mean tiny engine that is very easy to understand, use and extend. It was built by Jesse Grosjean and then ported to .NET by Aaron Clamage under the direction of Ben Bederson at the University of Maryland.

Piccolo2D is the reincarnation of Piccolo as an open source community project after the UMD staff stopped active maintenance in 2008 and freed the code for transfer to a public hoster - Google Code namely.

What happened to Jazz?

Jazz has lived a healthy and prosperous life. It has enabled us to perform our research on Zoomable User Interfaces, and it has spawned a new toolkit, Piccolo2D. Piccolo2D is now replacing Jazz and now supports everything Jazz does (except embedded Swing widgets which we never found to be crucial anyway). Jazz remains open source, and will stay on the UMD website but we are not actively maintaining it, and are instead focusing all of our current efforts on Piccolo2D.