Piccolo is now being maintained and distributed by a very active volunteer group at www.piccolo2d.org. We'll leave this site here for history, but it is no longer being maintained.

Piccolo

Learn
  About Piccolo
  Piccolo Patterns
  Getting Started
  API Documentation
  Piccolo in Comparison
  Publications
  Developer FAQ
  Mailing Lists
  Graphics Primer
Play
Team
Press
Contribute
Applications
Contact Us

Download
About Piccolo

Welcome to Piccolo! 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.

Piccolo 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 Piccolo maintains a hierarchal structure of objects and cameras, allowing the application developer to orient, group and manipulate objects in meaningful ways.

Why use Piccolo? 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? Piccolo is a layer built on top of a lower level graphics API. There are currently three versions of the toolkit: Piccolo.Java, Piccolo.NET and PocketPiccolo.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, Piccolo is free and open source!

How many versions of Piccolo are there?

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

  • Piccolo.Java

    Piccolo.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.

  • Piccolo.NET

    Piccolo.NET is written in 100% C#.  It runs on platforms that support the .NET Framework.  This means mainly Windows machines. Piccolo.NET provides the same functionality as Piccolo.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.  Piccolo.NET is based on the GDI+ API.

  • PocketPiccolo.NET

    PocketPiccolo.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"?

Piccolo provides support for developers of 2D (+ zooming) object-oriented graphics programs in Java and C#. It uses a "scenegraph" model that is common to 3D environments. Basically, this means that Piccolo 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 is enables a very decoupled object oriented approach to graphical applications. Piccolo defines several visual components, and applications can readily extend them or define their own. Piccolo 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 Piccolo.  But, internally, most of our new research projects are being implemented in Piccolo.NET.

How do I get a Piccolo License?

It's free! Piccolo is completely open source. You can download and use Piccolo however you like. The only restriction is that you must follow the guidelines set forth in the BSD public license.  To read more about using the public license, visit the license page.

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 Piccolo team and Piccolo users?

There are several ways.  You can subscribe to the mailing lists if you would like to ask technical questions or receive announcements about Piccolo.  You can also contact us directly if you would prefer to do so.  Or, if you find a problem with Piccolo, you can send us a bug report.

Where did Piccolo 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 current incarnation, is a direct successor to Jazz. Piccolo takes all that we have learned over the years, and rolls 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.

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, Piccolo.  Piccolo 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 we will keep it on this website but we are not actively maintaining it, and are instead focusing all of our current efforts on Piccolo.