IGOR Pro
IGOR Pro is an interactive software environment designed for experimentation with scientific and engineering data, enabling users to perform analysis, simulations, and the creation of publication-quality graphs and layouts.[1] Developed by WaveMetrics, a division of Sutter Instrument since its acquisition in 2022, it was first released as Igor 1.0 in early 1989, with the "Pro" designation added around 1994, and has since become a tool for handling large datasets through features like curve fitting, signal processing, and image manipulation.[2] The software includes a fully programmable structured language with a symbolic debugger, supports external operations (XOPs) for custom extensions, and integrates with Python and HDF5 for enhanced data handling and automation.[1] Originally developed on Macintosh systems starting in 1987 by Larry Hutchinson, IGOR Pro initially shipped on a single 800K floppy disk and targeted time-series analysis before expanding to broader applications in physics, biology, and engineering research.[2] Over its more than 35-year history, it has been adopted by tens of thousands of professionals worldwide for tasks such as data import/export, hardware acquisition, and Unicode-compatible internationalization.[2] While early versions supported both Macintosh and Windows, the current version, IGOR Pro 10 (released with hundreds of improvements including built-in Python support), is a 64-bit application exclusive to Windows 10 (build 1809 or later) and Windows 11, with no native macOS support beyond virtualization options for older releases.[3] It excels in processing multidimensional data efficiently, offering tools for statistical analysis, visualization of large images, and export in formats like SVG, EPS, PDF, and PNG.[1]Introduction
Overview
IGOR Pro is an interactive scientific data analysis, numerical computing, and graphing software developed by WaveMetrics.[1] It serves as a comprehensive environment for experimentation with scientific and engineering data, enabling users to produce publication-quality graphs and perform custom analyses through a built-in programming language.[1] The software's core data unit, known as a wave, represents multidimensional arrays that underpin its analysis capabilities.[1] IGOR Pro 10 offers native compatibility with Windows 10 (build 1809 or later) and Windows 11 as a 64-bit application, with no native macOS support (available only through virtualization), and lacks direct support for Linux without emulation tools like Wine.[3] The current version, IGOR Pro 10, was released in October 2025, introducing enhancements such as improved compiler performance, refined user interface elements like code folding in procedure windows, and built-in Python integration for expanded scripting options.[4][5] As commercial software, IGOR Pro operates on a perpetual licensing model, available in single-user, multi-user, academic, and student editions, with free 30-day trials and upgrade paths for prior license holders.[6][7][8]Development and history
WaveMetrics, Inc. was founded in 1987 by Larry Hutchinson and Howard Rodstein in Lake Oswego, Oregon, to commercialize an early software tool named Igor, initially developed by Hutchinson as a graphing application for the Macintosh platform.[2] The first public release of Igor occurred in 1989, targeting scientific users for data visualization and basic analysis on Apple Macintosh systems.[1] In the early 1990s, the software evolved with expanded capabilities in data analysis and programming, leading to its rebranding as IGOR Pro around 1994 to reflect these professional enhancements.[2] A significant milestone came with the port to Microsoft Windows in the mid-1990s, broadening its accessibility beyond Macintosh users and establishing cross-platform support for scientific computing. Subsequent versions built on this foundation: IGOR Pro 5, released in 2004, introduced advanced curve fitting tools for more sophisticated nonlinear modeling.[9] IGOR Pro 6 followed in 2007, adding multi-threading support to leverage multi-processor systems for faster computations in programming and curve fitting routines.[10] IGOR Pro 7, launched in 2013, provided enhanced 64-bit architecture for handling larger datasets and improved image processing operations, including filtering and manipulation tools.[11] The 2018 release of IGOR Pro 8 incorporated native NetCDF file support via a dedicated XOP and the Igor Filter Design Laboratory for signal processing workflows.[12] IGOR Pro 9 arrived in 2021 with built-in HDF5 support and numerous new operations for data management.[13] Most recently, IGOR Pro 10, released in October 2025, emphasized Python integration for seamless code execution and data exchange, alongside UI refinements and performance optimizations for processing large datasets.[14] Headquartered in Lake Oswego, Oregon, WaveMetrics has maintained a niche focus on scientific and engineering software, with the company transitioning to new ownership in 2022 under Sutter Instrument to ensure continued development.[2] As of November 2025, IGOR Pro 10 receives regular patch updates for stability and compatibility with Windows 11, with older versions supporting macOS Sonoma (version 14), without an announced major version 11.[3][15]Core Concepts
Waves data structure
In IGOR Pro, waves serve as the fundamental data structure for storing and managing numeric, text, or reference data in the form of multidimensional arrays ranging from one-dimensional (1D) vectors to four-dimensional (4D) tensors.[16] This design emphasizes efficient handling of scientific datasets, such as time-series signals or image volumes, where waves act as named objects that encapsulate both the raw data and associated metadata.[17] Unlike generic arrays in other programming environments, waves are optimized for evenly spaced data, often referred to as waveforms, which facilitates seamless integration with analysis and visualization tools.[16] Each wave possesses several key attributes that define its structure and usability. The wave is assigned a unique name within its data folder, supporting up to 255 characters and case-insensitive matching, which allows for descriptive identifiers like "voltageTrace" or more complex quoted names.[16] Dimension sizes specify the array's shape—for instance, a 1D wave might have 100 points along a single axis, while a 2D wave could define rows and columns for matrix data, up to a maximum of approximately 2.1 billion elements in 32-bit mode or 214 billion in 64-bit mode, limited primarily by available memory.[16] Data types include numeric formats such as double-precision floating-point (64-bit), single-precision (32-bit), signed or unsigned integers (8- to 64-bit), and complex numbers, alongside text waves for string storage.[17] Optional headers provide essential metadata, including units (e.g., "s" for seconds or "V" for volts), dimension labels (up to 255 characters per label since IGOR Pro 8.00), and scaling parameters like starting values (x0) and increments (dx) for each dimension, enabling intuitive access via scaled indices such as wave(x) where x represents physical coordinates.[16] Waves are created and manipulated through built-in commands that prioritize ease of use and efficiency. The primary creation command isMake/O/N=(dimensions) waveName, where /O overwrites an existing wave if present, and N= specifies the size—for example, Make/O/N=100 wave0 generates a 1D numeric wave with 100 double-precision elements initialized to zero.[16] For multidimensional waves, the syntax extends to Make/O/N=(rows,columns,layers,chunks) matrixWave, supporting up to 4D structures like volumetric data.[16] Text waves are created similarly with the /T flag, as in Make/O/T/N=4 labels = {"Trial1", "Trial2", "Trial3", "Trial4"}, allowing storage of variable-length strings encoded in UTF-8, which can include binary data or special characters for annotations.[16] Manipulation operations include resizing with Redimension/N=(newSize) waveName for dynamic adjustment without data loss, insertion or deletion of points via InsertPoints or DeletePoints, and scaling setup using SetScale d 0, 1, "unit", waveName to associate physical units and intervals.[16] These commands handle memory allocation automatically, preventing common errors like buffer overflows.
Waves operate within scopes defined by data folders, which provide a hierarchical organization akin to namespaces. Global waves reside in the root experiment folder (e.g., accessible via root:MyData:signalWave) and persist across sessions unless explicitly saved or cleared, making them suitable for shared datasets.[16] Local waves, created within function contexts or subfolders, are temporary and automatically managed for cleanup, such as free waves flagged with /FREE that are deallocated upon function exit to optimize memory during computations.[16] This scoping mechanism ensures waves can be referenced efficiently in procedures without copying data, promoting modularity.
The waves structure offers distinct advantages over standard arrays in terms of memory management and workflow integration. Built-in automatic resizing and allocation eliminate manual pointer handling, reducing the risk of memory leaks while supporting large datasets limited only by system RAM.[17] Waves enable direct plotting without data duplication—for instance, a 1D wave can be displayed as a trace using the Display command, leveraging its scaling for accurate axis labeling.[16] In programming contexts, waves are passed by reference, allowing in-place modifications that enhance performance for iterative analyses.[16]
A representative example is a 1D wave for time-series data: Make/O/N=1000 timeData; SetScale x 0, 0.01, "s", timeData; timeData = sin(2*pi*x) + 0.1*enoise(1), which creates a 1000-point sine wave with added noise, scaled from 0 to 10 seconds, complete with time units and dimension labels for immediate use in graphing or further processing.[16]
Programming language
IGOR Pro's built-in programming language is a procedural scripting language designed for automating data analysis, visualization, and experiment control within the software environment. It supports structured programming constructs including functions, procedures, loops, conditionals, and macros, enabling users to create reusable code for tasks like data manipulation and graphing. The language operates primarily in an interpreted mode with just-in-time compilation for procedures, resembling C in its syntax for control flow and expressions while prioritizing ease of use for scientific applications.[16][18] Key syntax elements include variable declarations such asVariable x = 5 for numeric values or String s = "text" for strings, wave references like WAVE w = root:folder:waveName to access the primary data structures, and control structures including if...endif for conditionals, for...endfor and do...loop for iterations, and switch...endswitch for multi-way branching. Built-in functions cover mathematical operations (e.g., sin(x), sqrt(x)), statistical tools (e.g., mean(w)), and wave manipulations (e.g., Make/O/N=100 w to create a new wave). Statements are semicolon-separated, with support for escape sequences in strings (e.g., \B for subscripts) and case-insensitive keywords and names.[16][19]
Compilation and execution occur interactively via the command line for ad-hoc scripts or through procedure files (.ipf) saved within experiment files for more complex routines. Procedures are automatically compiled upon modification, saving, or invocation using commands like COMPILEPROCEDURES, ensuring efficient runtime performance without a separate build step. Execution supports immediate evaluation in the command window, deferred processing with Execute/P, and batch modes for automation, all scoped to data folders that organize variables, waves, and other objects.[16][19]
Advanced features include structures for grouping data (e.g., STRUCT Point { Variable x, y; }), enabling limited object-oriented patterns in user-defined functions, and comprehensive error handling via try...catch...endtry blocks, the /Z flag for non-fatal errors, and commands like Abort to halt execution with custom messages. The language also supports multithreading through MultiThread for parallel wave assignments and ThreadSafe functions, along with dependency formulas using := for automatic updates (e.g., wave1 := sin(wave0)).[16]
For example, the following procedure creates a sine wave and stores it in a new wave object:
This snippet demonstrates wave creation, assignment, and basic mathematical expression evaluation.[16]Function MakeSineWave() WAVE w // References an existing wave or declares a reference Make/O/N=100 w // Creates a 1D numeric wave with 100 points w = sin(2 * pi * x / 100) // Assigns sine values based on index x EndFunction MakeSineWave() WAVE w // References an existing wave or declares a reference Make/O/N=100 w // Creates a 1D numeric wave with 100 points w = sin(2 * pi * x / 100) // Assigns sine values based on index x End
Features
Data analysis and processing
IGOR Pro provides an extensive set of built-in operations and functions for numerical data analysis and manipulation, exceeding 550 in total, enabling users to perform complex computations on waves without external dependencies.[19] These include over 300 dedicated to mathematical transformations, such as the FFT operation for fast Fourier transforms and the Integrate operation for numerical integration of waves (e.g., Integrate waveName).[20] Statistical tools are available through functions like those in WaveStats, which compute measures including mean and standard deviation.[21] For curve fitting, the FuncFit operation supports linear, polynomial, and nonlinear regression using built-in or user-defined models, employing the Levenberg-Marquardt algorithm for iterative least-squares minimization.[22] Data import and export in IGOR Pro accommodate a wide range of formats to facilitate integration with other software, including delimited text files like CSV, HDF5 for hierarchical data, MATLAB .mat files, and native Igor binary formats.[23] The LoadWave operation serves as the primary command for ingesting data, allowing programmatic loading with options for headers, delimiters, and wave creation.[23] Export capabilities mirror these, supporting the same formats for seamless data exchange. Processing pipelines in IGOR Pro leverage macros—user-defined procedures—for batch operations on multiple datasets, automating repetitive analysis tasks.[18] For image data represented as 2D or 3D waves, dedicated tools include the Convolve operation for applying filters like Gaussian blurs and the Threshold operation for binarizing images based on intensity levels, enabling segmentation and feature extraction.[24] A typical workflow for data preparation might involve smoothing a noisy wave using the Smooth operation with boxcar averaging, as inSmooth/B=3 waveName to reduce short-term variations over a width of three points, followed by outlier removal via identification with WaveStats and subsequent point deletion.[25] Custom analysis can extend these using the programming language for tailored pipelines.[18]
IGOR Pro supports multi-threaded execution for many operations, including matrix computations via the MatrixOP operation and others that leverage automatic threading (introduced in version 7), allowing efficient handling of large datasets on multi-core systems. Operations like MultiThread enable manual multithreading. Enhancements in version 10 include better support for more logical processors on Windows 11.[26] This enhances performance for intensive analyses without manual intervention.
Graphing and visualization
IGOR Pro provides robust tools for creating graphs from wave data structures, enabling users to visualize scientific and engineering datasets through a variety of plot types. Graph creation is facilitated by operations such asAppendToGraph, which adds traces like waveforms or XY pairs to an existing graph window, supporting unlimited numbers of traces and axes per graph.[27] This command allows for seamless integration of 2D plots including line, scatter, area, bar, and category types, which can be combined within a single window for multi-trace displays.[27] Additionally, specialized 2D visualizations encompass contour plots derived from matrix waves or XYZ triplets with options for non-linear spacing and smooth interpolation via Delaunay triangulation, as well as image plots that handle true/false color representations, uneven spacing, and complex numerical data.[28][29] Waterfall plots, useful for spectral or time-series stacking, are generated using the NewWaterfall operation on 2D waves, creating 3D-like stacked traces with customizable offsets, though advanced variants may employ the Gizmo module for enhanced rendering.[30] For 3D plotting, the Gizmo tool leverages OpenGL to produce surface plots in wireframe or filled formats, including parametric and intersecting surfaces with adjustable lighting to highlight depth and contours.[31]
Customization options in IGOR Pro allow precise control over visual elements to suit analytical needs. Axes support linear, logarithmic, reciprocal, and date/time scaling, with multiple axes per graph enabling overlaid datasets at different scales.[27] Annotations include dynamic text boxes that update with wave values, legends, and drawing tools for lines, arrows, and Bezier curves across multiple layers.[27][29] Trace styles offer 62 marker symbols, 72 fill patterns, customizable line thicknesses (e.g., 1.35 points), dash patterns via an editor, and color selections for lines, fills, and contours.[27] For multi-trace graphs, automatic layout features resize elements proportionally to the window, optimizing fonts, markers, and line widths while preserving aspect ratios, with manual overrides available for fixed dimensions.[27]
Graphs in IGOR Pro are designed for publication-quality output, ensuring high-resolution rendering suitable for scientific journals. Export formats include EPS (using PostScript level 2 for precise fill patterns), PDF, and PNG, with TIFF supported for bitmap needs; these maintain vector scalability and high fidelity when imported into tools like Adobe Illustrator.[32] Built-in page layout windows serve as figure templates, allowing assembly of multiple graphs with precise positioning and export of cropped sections to match journal specifications.[32]
Interactive capabilities enhance data exploration within graphs. Users can zoom via marquee selection, mouse wheel, or menu commands, and pan smoothly across large datasets containing millions of points; right-click options within zoomed regions further refine views.[33][34] Data cursors provide live readouts of trace values at cursor positions, with info boxes displaying coordinates and statistics.[33] Linked graphs synchronize updates when underlying waves change, such as from analysis outputs, ensuring consistent views across multiple windows.[35]
Advanced visualization tools extend interactivity and complexity. Gadgets, implemented as controls like sliders and buttons on graph panels, enable dynamic parameter adjustments—such as real-time scaling or filtering—via user-defined procedures that trigger graph updates.[36] In 3D contexts, Gizmo supports volumetric rendering with isosurfaces, voxelgrams, and orthogonal slices, incorporating lighting models to simulate realistic shading on surfaces and scatter plots.[31] These features, combined with fast refresh rates, facilitate exploratory analysis directly within publication-ready visuals.[29]