SED navigation bar go to SED home page go to Dataplot home page go to NIST home page SED Home Page SED Staff SED Projects SED Products and Publications Search Dataplot Pages

Downloading Dataplot Source Code for Linux/Unix Systems

Introduction Since there are many variants of Linux/Unix operating systems and different versions of each of these variants, you will need to download and compile the Dataplot source code.
What You Need Dataplot is written primarily in Fortran. Code for certain device drivers is written in C. This means that you need the following on your local system.
  • A Fortran 90 compiler. We currently use gfortran for Unix/Linux platforms. The gfortran compiler should be freely available if it is not already installed on your platform.

    Other commercial Fortran compilers are available on some Linux platforms (e.g., Intel and ABSOFT compilers are supported under Linux). Although you should be able to use these commercial compilers to build Dataplot, we do not have access to them so cannot provide guidance on the appropriate changes to the build script. However, if you are experienced with the compiler, the needed changes should be straightforward.

    A few graphics device drivers are written in C, so the gcc compiler also needs to be installed. The gcc compiler is likely to be installed on most Linux platforms. The gfortran compiler is less likely to be installed.

  • You need the xlib library (and the xlib.h include file). This should be available on most Unix systems by default. Check with your local system adminstrator if you are not sure.

  • Dataplot can make use of the several auxillary libraries if they are available on your system:

    • The GD library can be used to generate plots in PNG, JPEG, and GIF format and to read images in these formats.

    • The readline/history libraries can be used to edit/recall previously entereed commands (Dataplot requires version 6 of the readline library).

    • The libplot library provides several additional plot formats not otherwise supported by Dataplot. This library is part of the plotutils package.

    • The Cairo library is a popular library for generating 2-D graphics.

    On a first pass at the build, you may want to turn these off. Then if these libraries are available, you can build Dataplot with these libraries enabled. All of these libraries are freely downloadable if they are not currently available on your local system.

    These libraries provide useful capabilities, but none are essential to running Dataplot.

Pre-built Executables
Pre-built Executables Available for a Few of the Many Linux Distributions For convenince, pre-built executables are provided for a few specific Linux distributions (there are a large number of Linux/Unix distributions). Note that many Linux distributions are derived from other Linux distributions (the derived distributions typically feature easier installation or different desktop environments). If you have a Linux distribution that is derived from (or alternatively, our listed platform is derived from your Linux distribution), the pre-built executable may be compatible with your system. We have listed a few of the more common derivatives. The choice of platforms for pre-built executables is based on what we currently have available (this is subject to change) and is not intended to be an endorsement of any particular Linux/Unix implementation.
GD, readline, Cairo Libraries Assumed to be Available These executables are built assuming that the GD, readline, and Cairo libraries are available on your system. They are built without the libplot library. This choice was made since most Linux platforms are likely to have GD, readline, and Cairo already installed. The libplot library is less likely to be installed. These pre-built executables may not work on all system (e.g., libraries may not be where they are expected, incompatible versions of gcc/gfortran are installed on your system, an expected library is not installed). If you have a different version of the OS (e.g., Cent OS 7.5 rather than 7.4), the executable may or may not be compatible (having a newer version of the OS is more likely to work than having an older version). In any event, it may be worth a try using one of the pre-built executable before building from source.
Download the Pre-built Executable The following pre-built executables are available:
  • version 6.9 of Cent OS. This executable is built with version 4.4.7 of gcc/gfortran. Cent OS 6 is based on Red Hat Enterprise (RHEL 6), so this executable should be compatible with RHEL 6 installations.

  • version 7.4 of Cent OS. This executable is built with version 4.8.5 of gcc/gfortran. Cent OS 7 is based on RHEL 7, so this executable should be compatible with RHEL 7 installations.

  • version 27 of Fedora. This executable is built with version 4.8.5 of gcc/gfortran.

  • version 2.9 of 64-bit Cygwin. This executable is built with version 6.4.0 of gcc/gfortran.

  • version 16.04 of Ubuntu. This executable is built with version 5.4.0 of gcc/gfortran.

    Note that Ubuntu is derived from Debian and Mint is derived from Ubuntu, so this executable may be compatible with some Debian and Mint installations as well. There are a number of other Linux distributions that are derived from Debian or Ubuntu, but we have no direct experience with them.

These executable files are compressed with gzip and named to include the OS type and version and build date. So once you download the file, use gzip to uncompress the file. You can then move it to a convenient location. For example, you might do something like the following

    gunzip dataplot_fedora_27_2018_05_19.exe.gz

    sudo mv dataplot_fedora_27_2018_05_19.exe \
                /usr/local/bin/dataplot

Download the Source File The source files (including the build scripts) need to be downloaded
  1. The current version of the Dataplot source files (Fortran files, C files, and include files, build script) (updated 05/19/2018).

    The following previous versions of the source code are also available:

Building Dataplot After Downloading Files
Step 1: Unpack Source/Script Files The first step is to upack the source and script files. If you have superuser priveleges, you may want to create the directory "/usr/local/src/dataplot" and move the source files to that directory. If not, you should create a new directory of your choice. One suggestion is ~/dataplot/src, but this is really your choice. Once you have moved the files to this directory, do the following:
  • gunzip dpsrc.tar.gz | tar -xf
If you like, you can either remove or re-compress the tar file.
Step 2: Edit and Run the Build Script The next step is to edit and run the build script.
  1. The size data sets that Dataplot can handle is determined by several PARAMETER statements in the file "DPCOPA.INC". Although this file sets many parameters, the only one you should potentially change is

    • MAXOBV - maximum number of observations per variable (default = 1,500,000)

    In most cases, you can just use the default machine. If you have an older machine with limited memory, you may want to set this value smaller (say 100,000 or 500,000). If you have a machine with very large memory and you will be working with large data sets, you can set this value higher (we have gone as high 10,000,000, but we would generally not recommend this on an initial build).

  2. We provide several variants of the build script. There are separate scripts for 64-bit and 32-bit machines. Most current computers will be 64-bit machines. However, some older machines may still be 32-bit. The 64-bit script is provided for both the c-shell and the Bourne shell. Although the Bourne shell is almost always going to be present, some Linux installations may not install the c-shell by default. If both shells are available, the choice of script is a matter of which shell you are most comfortable using. The 32-bit version of the script is only provided for the Bourne shell.

    • build_linux_64.csh

      A build script for 64-bit Linux machines using the c-shell and the gfortran/gcc compilers.

    • build_linux_64.bash

      A build script for 64-bit Linux machines using the Bourne shell and the gfortran/gcc compilers.

    • build_linux_32.bash

      A build script for 32-bit Linux machines using the Bourne shell and the gfortran/gcc compilers.

    If you have a non-Linux/Unix system, these build scripts can be adapted to your system (contact Alan Heckert if you need assistance).

    The build script is well commented. Read the comments to see what changes you need to make to the script. Most users should be able to just set the location for the source files and then just set the flags that indicate whether the GD, LIBPLOT, or READLINE libraries are available on your system. The Open-GL library should not be used yet and the Aquaterm library is for Mac OS X only.

Dataplot Executable File The build script defines the variable DPNAME which specifies the name of the Dataplot executable that will be created. By default, this is "./dataplot". If Dataplot is successfully built, you will typically want to copy this file to the /usr/local/bin directory. If you do not have super user permission on your machine, a good alternative is the ~/bin directory (i.e., create a bin directory under your home directory). However, you can in fact copy the Dataplot executable to whatever directory is most convenient to you.

Privacy Policy/Security Notice
Disclaimer | FOIA

NIST is an agency of the U.S. Commerce Department.

Date created: 06/05/2001
Last updated: 05/24/2018

Please email comments on this WWW page to alan.heckert@nist.gov.