History of GraphiC

The IBM PC was released in 1981. At the time, George Kelley and I (James Rome) were plasma physicists studying nuclear fusion. We realized that generating graphical plots would give us critical insight into plasma equilibria and physical behavior, but the original IBM PC had very low-resolution graphics (CGA 320×200). To overcome this, we each purchased a Corona PC, which offered an amazing 640×480 pixel display.

However, we soon discovered that there was no software available to produce publication-grade scientific plots on microcomputers. We had been using the DISSPLA™ Fortran package on mainframes and were heavily influenced by its methodology. In both DISSPLA and GraphiC, plotting is a structured, procedural state machine:

1. Initialize Session: bgnplot(device, mode, file)

2. Page Dimensions & Units: page(width, height)

3. Start Page Canvas: startplot(bgcolor)

4. Set Plot Area & Origin: area2d(xlen, ylen) and physor(x, y)

5. Calibrate Axes & Labels: box(), heading(title), xname(x), yname(y), graf(...)

6. Execute Plot Routines: Calling the authentic GraphiC routines across all languages (conmat, curve, surmat, smdraw, polgrid, xlog, etc.) without obscuring them behind generic OOP abstractions.

7. Close Frame & Subsystem: Always conclude with endplot() followed by stopplot().

We insisted on vector graphics—where everything is a discrete point, stroke, or filled polygon—so that we could zoom in to inspect fine details on our computer screens and reproduce plots cleanly across pen plotters and laser printers.

We decided that the C language was best suited to run efficiently on a personal computer, but we had to learn it from scratch! We also studied 8086 assembly language and hand-coded critical inner loops in assembly to maximize rendering speed, since numerical math co-processors (like the 8087) were not yet available. It took us several years to perfect our lean, mean, fast C graphics engine. We subsequently founded Scientific Endeavors Corporation to market GraphiC worldwide to scientists and other technical workers.

After George passed away, his son Steve Kelley took his place in the company. Steve cleaned up numerous bugs, expanded features, and managed dedicated customer support. When Steve suffered an untimely death, we terminated Scientific Endeavors. And there the codebase sat, untouched, for over 30 years…

The 2026 Renaissance: Enter AI and Google Antigravity

In 2026, working in close collaboration with me, Google’s Antigravity autonomous AI coding agent resurrected the original GraphiC C archives.

Over the course of this modernization: Archaic 16-bit DOS segmented pointers, expanded memory (EMS) page banking, and disk overlays were eliminated in favor of a clean, flat 64-bit POSIX/C99 architecture running natively across macOS (Apple Silicon ARM64 & Intel), Linux, and Windows.  Obsolete pen plotter support and the Tektronix storage file format were replaced by a modern W3C Scalable Vector Graphics (SVG) driver with an interactive browser-based viewer and live monitor streaming. And, Complete multi-language parity was established—delivering first-class bindings for Modern Fortran (2003/2018/legacy F77), Python 3, and Java 22 (Foreign Function & Memory API).

Most importantly, the core mathematical soul of GraphiC remains unaltered: the exact procedural state machine, analytical 3D hidden-surface horizon algorithms, Hershey stroke vector fonts (and now Postscript and TrueType), and precision coordinate transforms developed four decades ago are now preserved and running at native 64-bit speed for the next generation of scientific research.

Advantages of GraphiC

• GraphiC is made for users who want to display data in new ways that are not part of standard "give me the data and I will plot it for you" programs.
• GraphiC can plot multiple views of data as it is being generated. Thus, long experiments can be monitored and stopped if things go awry.
• Vector graphics allow zooming and panning in the included viewer. This allows an overview and study of details in one plot.
• GraphiC is fully self-contained and needs no other libraries or programs except for your compiler..
• The GraphiC C code was designed before numeric co-processors, and is extremely fast and compact.
• It was bug tested for many years and eventually, no changes were needed. (Bad for upgrade sales.)
• GraphiC has support for things such as Smith Charts and error function plots that are not included in most competitive packages.
• The Manual has numerous examples (ported to other languages on disk) that can be used as boiler plate for new plots. Several real-world examples that used GraphiC are also included.

#include <graphic.h>
#include <math.h>

int main(void) {
    float x[100], y[100];
    for (int i = 0; i < 100; i++) {
        x[i] = i * 0.1f;
        y[i] = sinf(x[i]);
    }
    bgnplot(1, 'g', "wave.tkf");
    startplot(WHITE);
    page(8.0f, 6.0f);
    area2d(6.5f, 4.5f);
    color(BLACK); box();
    heading("Harmonic Oscillation");
    graf("%g", 0.0f, 2.0f, 10.0f,
         "%g", -1.5f, 0.5f, 1.5f);
    color(BLUE);
    curve(x, y, 100, 0);
    endplot(); stopplot();
    return 0;
}

program wave_demo
    use graphic_iso
    implicit none
    real(c_float) :: x(100), y(100)
    integer :: i

    do i = 1, 100
        x(i) = real(i - 1) * 0.1
        y(i) = sin(x(i))
    end do
    call bgnplot(1, 103, "wave.tkf")
    call startplot(WHITE)
    call page(8.0, 6.0)
    call area2d(6.5, 4.5)
    call color(BLACK); call box()
    call heading("Harmonic Oscillation")
    call graf("%g", 0.0, 2.0, 10.0, &
              "%g", -1.5, 0.5, 1.5)
    call color(BLUE)
    call curve(x, y, 100, 0)
    call endplot(); call stopplot()
end program wave_demo

import math
from graphic import Figure, BLUE, SOLID

x = [i * 0.1 for i in range(100)]
y = [math.sin(v) for v in x]

with Figure(8.0, 6.0, tkf_name="wave.tkf") as fig:
    fig.setup_axes(0.0, 2.0, 10.0,
                   -1.5, 0.5, 1.5)
    fig.title("Harmonic Oscillation")
    fig.xlabel("Time (s)")
    fig.ylabel("Amplitude (V)")
    fig.plot(x, y, color="blue")
    fig.save("wave.svg")

import com.sciend.graphic.*;

public class WaveDemo {
    public static void main(String[] args) {
        float[] x = new float[100];
        float[] y = new float[100];
        for (int i = 0; i < 100; i++) {
            x[i] = i * 0.1f;
            y[i] = (float) Math.sin(x[i]);
        }
        try (Figure fig = new Figure(8.0f, 6.0f,
                 Color.WHITE, "wave.tkf")) {
            fig.setupAxes(0f, 2f, 10f,
                          -1.5f, 0.5f, 1.5f);
            fig.title("Harmonic Oscillation");
            fig.plot(x, y, Color.BLUE, LineStyle.SOLID);
            fig.save("wave.svg");
        }
    }
}