IDL (Interactive Data Language)

IDL (Interactive Data Language) is an array-oriented programming language and interactive computing environment designed for the analysis and visualization of scientific data. Optimized for working with large numerical arrays — spectra, images, and multidimensional grids — IDL has been a fixture of fields such as astronomy, space physics, remote sensing, and medical imaging for nearly five decades.

History & Origins

IDL traces its roots to the Laboratory for Atmospheric and Space Physics (LASP) at the University of Colorado Boulder in the early 1970s, where David Stern built a series of programs to help scientists interpret data from NASA missions. The lineage began with Rufus, a simple vector-oriented calculator on the PDP-12, followed by the Mars Mariner Spectrum Editor (MMED) used to study data from the Mariner 7 and Mariner 9 probes, and then SOL, the first of Stern’s tools to be a true programming language with a Fortran-like syntax.

Building on that experience, Stern founded Research Systems, Inc. (RSI) in Boulder in 1977 and released the first version of IDL that year as a higher-level, interactive language aimed squarely at data analysis. Early commercial customers included NASA’s Goddard Space Flight Center and Ball Aerospace.

From VAX to Unix

In 1981, RSI released a VAX/VMS version written in VAX MACRO and Fortran, exploiting the system’s virtual memory to handle datasets larger than physical RAM. As scientific computing moved toward workstations, RSI undertook a complete rewrite in C for Unix in 1987 (led by Stern with Ali Bahrami, initially targeting the Sun-3). This C rewrite — rather than a port of the VAX code — gave IDL the portability that carried it onto the many platforms scientists used through the 1990s, including the Windows version in 1992 and a Macintosh version in 1994.

Design Philosophy

IDL is built around a single guiding idea: the array is the natural unit of scientific data, and the language should make whole-array operations as effortless as scalar arithmetic. Rather than writing explicit loops to process every pixel or sample, an IDL programmer expresses computations over entire arrays at once — an approach that is both concise and, because the heavy lifting happens in compiled internals, fast.

Key characteristics include:

• Array (vector-oriented) programming — arithmetic and many functions operate element-wise across arrays of any dimensionality without explicit loops.
• Dynamic typing — variables take on types as values are assigned; no declarations are required.
• Interactive command line — IDL is used both as a REPL for exploratory work and as a language for writing reusable procedures and functions.
• Integrated graphics — plotting, image display, and (since IDL 8.0) a modern function-graphics system are first-class parts of the environment.
• Fortran and C heritage — the syntax borrows constructs from both, making it approachable for the scientists and engineers who were IDL’s original audience.

Key Features

IDL distinguishes between procedures (invoked with a command-style syntax) and functions (which return values), and supports structures, pointers, and — since 1997 — a limited form of object-oriented programming. Source code is compiled to an intermediate representation (p-code) that is executed by the IDL runtime. Ordinary variables are freed automatically when they go out of scope, but the heap variables underlying pointers and objects are not garbage-collected and must be released explicitly (for example with PTR_FREE or OBJ_DESTROY) — a well-known source of memory leaks in IDL code.

A short example shows the array-first style:

; Create an array and operate on it without explicit loops
x = FINDGEN(100) * 0.1        ; 0.0, 0.1, ... 9.9
y = SIN(x)                    ; element-wise sine over the whole array
PLOT, x, y                    ; immediate visualization

; Reductions and slicing
PRINT, MAX(y), MEAN(y)
PRINT, y[10:20]               ; a slice of the array

The combination of concise array syntax and built-in visualization is what made IDL attractive to researchers who wanted to move quickly from raw instrument data to a publishable figure.

Evolution

Over the decades IDL accumulated features that tracked the needs of its scientific users. The 1992 addition of widget-based graphical interfaces let developers build interactive analysis tools; ENVI, introduced in 1994 and written in IDL, grew into a leading remote-sensing application. Object-oriented support arrived in 1997, and IDL 8.0 (released around 2009) brought a substantially modernized “New Graphics” system alongside friendlier syntax — dot notation for object properties, simpler object creation, and bracket-based array indexing.

The product itself has changed hands several times. RSI was acquired by Eastman Kodak in 2000, then passed to ITT Industries (operating as ITT Visual Information Solutions from 2006), to Exelis in 2011, to Harris Geospatial Solutions in 2015, and — following the L3Harris merger and subsequent divestiture — to NV5 Geospatial in 2023, which continues commercial development today. The most recent release line is IDL 9, with IDL 9.2 released in 2025.

Open Implementations

Because IDL is proprietary, licensed software, the community produced compatible open-source alternatives:

• GNU Data Language (GDL) — a free, largely IDL-compatible implementation under the GPL.
• Fawlty Language (FL) — a free compiler aiming for compatibility with IDL 8.

A closely related commercial language, PV-WAVE, shares a common ancestry and much of IDL’s syntax, having branched from the same codebase.

Current Relevance

IDL remains entrenched in specific scientific communities — particularly solar physics, astronomy, and remote sensing — where decades of accumulated, battle-tested analysis libraries (such as the IDL Astronomy User’s Library and SolarSoft) represent an enormous body of domain expertise that is not trivially replaced. In these niches, mission data-reduction pipelines and instrument software written in IDL are still actively used and maintained.

At the same time, the broader scientific-computing world has shifted substantially toward Python (with NumPy, SciPy, Astropy, and Matplotlib) and toward MATLAB in engineering settings. Many groups now run IDL alongside Python or migrate legacy IDL code, and IDL itself provides bridges to Python. The free GDL implementation has also extended the reach of existing IDL codebases to users without a commercial license.

Why It Matters

IDL is a notable example of an array-programming language built for a specific community of practice rather than for general-purpose software development. Alongside APL, MATLAB, and later NumPy, it helped establish the idea that scientific computation is best expressed as operations on whole arrays — a paradigm that now underpins most modern data-science and numerical tooling. Its long history processing data from spacecraft, telescopes, and earth-observation instruments has woven it into the record of late-20th-century space science, and the libraries written in it continue to support working scientists today.