This is an archive of the old MediaWiki-based ImageJ wiki. The current website can be found at


Source code
Project management
Coding style
Writing plugins
ImageJ Ops
Contributing to a plugin
Distributing your plugins
Development lifecycle
Building a POM
Developing with Eclipse
Hands-on debugging
Adding new ops
Adding new formats
Using native libraries
Tips for developers
Tips for C++ developers
ImageJ 1.x plugins

ImageJ, and the SciJava component collection in general, is developed according to certain biases, which we describe here. This philosophy has evolved over a very long development history, reflecting many lessons learned over a course of decades.

Open source

The SciJava ecosystem is strongly committed to open source software development. But this software is not an open source software product—it is an open source software project following an open source development process.

ImageJ is funded by taxpayer money, so the project strives to be as transparent as possible. There are public source code repositories, public communication channels, public project management resources, and of course, this community editable website. As you can see, we love doing it in public!

Independent learning

Tell me and I forget. Teach me and I remember. Involve me and I learn. —Xunzi

The ImageJ and SciJava communities intend to foster not only scientific independent thinking, but just as importantly, independent learning. We want to not only teach people how to fish, but teach them how to learn.

As such, responses to questions on ImageJ public channels will often begin with "What have you tried?" or "Can you make a minimal, complete, verifiable example?"—see the Bug reporting best practices for details. A good rule of thumb for questioners is to "put as much effort into your question as you expect to be put into its reply"—and for responders, to cordially encourage this behavior in questioners. Responses may give detailed macro or script solutions to image analysis questions, but they will also often include details of how such solutions were produced, as well as how they might be improved or tailored to other similar scenarios.

We are always looking for more ways to improve the software to meet this goal of encouraging independent learning. Write to the ImageJ forum with your ideas!


Extensibility is ImageJ's greatest strength. ImageJ is not just a software application—it is an extensible platform for the development of image visualization, segmentation, registration, and analysis routines.

Isaac Newton attributed his success to standing on the shoulders of giants. The SciJava component collection's powerful plugin mechanism and open source software process codify that metaphor into the software itself. Not only are there many different types of plugins, but it is also possible to extend the system with your own new types of plugins. See the Extensibility page for details.


One of the central goals of the SciJava component collection is to extend Java's mantra of "write once, run anywhere" in new directions: ImageJ Ops for image processing algorithms, and SCIFIO for scientific image I/O.

ImageJ2 commands work not only in the ImageJ user interface, but also from many other applications in the SciJava ecosystem, including CellProfiler, OMERO, KNIME and Alida.


Backward compatibility is one of ImageJ's most important goals. It must remain possible to use existing plugins and macros with new versions of ImageJ. See the Compatibility page for details.

Release early, release often

What's the alternative?

Some projects opt to release their entire software stack with a single monolithic version number. This has one extremely nice ramification: it clearly communicates which versions of which software components are intended to be compatible with one another.

For example, the OME project (which includes OMERO and Bio-Formats) employs this approach to versioning and release management. Before each release, the entire OME team performs careful and thorough integration testing of all components.

Versioning strategies
Versioning BOM Monoversioned
Releases RERO "Big bang"
Version compatibility Compatible components are declared in a Bill of Materials (BOM) Compatible components have the same version number
Frequency of releases Faster Slower
Stability Less More

ImageJ subscribes to the release early, release often (RERO) mantra often cited in software engineering circles. In particular—and especially because there is a small core development team—the project is driven by Boyd's Law of Iteration: speed of iteration beats quality of iteration. That is not to say that we do not strive for quality—we do. But we have found through experience that more releases, together with guiding user feedback, push a project forward more efficiently than a slower release cycle does.

To ensure releases can happen quickly, each SciJava component is independently released and versioned, using reproducible builds with a "release ready" master branch. This allows individual SciJava components to be released with the push of a button, in a timespan less than five minutes. This puts bug-fixes into the hands of users as quickly as possible.

Convention over configuration

With increased modularity often comes increased complexity. One key way of addressing this issue is to provide sensible defaults (e.g., the big green Xerox button) as a way of dealing with complex software programs. We embrace the philosophy of convention over configuration utilized by many large software projects in recent years. For this reason, SciJava projects use the Maven build tool for project management.

Why Java?

While it was once true that Java is always slower than the equivalent in C++, this is no longer the case. There have been quite a few benchmarks comparing Java vs C++ performance, this one probably being the grandfather of all.

Pragmatically, one should note that there is not really a big difference in performance when comparing Java to C++.

Java programs run without trouble and without recompiling on the major platforms: Windows, Mac OS X and Linux. And plugins compiled on one platform also execute on all other platforms without recompiling. And profiling and debugging is easier with Java than with C++. And all programs/plugins double as libraries.

So the true reason why we use Java is probably: it makes ImageJ accessible.

See also Isn't Java too slow? and Why is your software written in Java? from the LOCI FAQ.