Modernizing a 40-Year-Old Scientific Plotting Library Using AI
Modernizing a 40-Year-Old Scientific Plotting Library Using AI
George Kelley and I bought Corona PCs at the time the first IBM PC was released. We got Coronas because they had high-resolution screens (640 x 480 at the time!) so that we could make the kind of scientific plots we were used to making using DISSPLA on mainframe computers.
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 (learned by looking at compiled C code) 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 ScientificEndeavors Corporation to market GraphiC worldwide to universities, national laboratories, and aerospace firms.
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 30 years…
Enter AI, in particular the Google Antigravity agent (AG). Unlike a chatbot, an agent can (with permission) actually change things on your computer (or even other computers using ssh). I asked AG whether GraphiC was still competitive, and it said yes:
⇄ Scroll horizontally to view all engines (first column stays fixed)
| Feature / Dimension | GraphiC (Modern 2026) | Matplotlib | Gnuplot | MATLAB | OriginPro | DISLIN | PLplot | Plotly |
|---|---|---|---|---|---|---|---|---|
| Binary Footprint | ~655 KB static (407 KB dynamic) |
150–350 MB (Python + wheels) |
15–30 MB (standalone bin) |
15–25 GB (MCR runtime: 4GB) |
3–5 GB (Windows suite) |
10–25 MB (compiled libs) |
15–40 MB (shared libs + drivers) |
30–80 MB (Python wheel + 3.5MB JS) |
| External Dependencies | ZERO (Pure standard libc/libm) |
Python, NumPy, FreeType, libpng, pyparsing, dateutil | cairo, pango, libpng, readline, Qt/X11 | Java VM, Intel MKL, OpenGL drivers, Qt | Windows COM, MSVC CRT, DirectX/OpenGL | FreeType, Motif/X11, GL, zlib | CMake, FreeType 2, libpango, libcairo, libltdl, Qt/X11 | Node.js/V8, Chromium/Kaleido (for headless export), d3.js |
| Cold-Start Execution Latency | < 0.002s (Sub-millisecond) |
0.50 – 1.50s (module import overhead) |
0.05 – 0.15s (process fork/pipe) |
3.0 – 10.0s (desktop engine boot) |
4.0 – 8.0s (GUI suite launch) |
0.01 – 0.03s (compiled binary) |
0.02 – 0.08s (driver plugin loading) |
1.0 – 3.0s (headless browser launch) |
| Language Integration | True 4-Way Parity: C/C++, Fortran 2003 (fpm), Python 3, Julia, Java 22 FFM |
Python only (C/Fortran bridges brittle) |
Piped scripts only (no direct C/Fortran API) |
MATLAB syntax (MEX/Engine IPC required) |
LabTalk & Origin C (proprietary desktop) |
C, Fortran, Python (legacy Java JNI wrappers) |
C, C++, Fortran 2003, Python, Java (SWIG wrappers; CMake build) |
JavaScript, Python, R (No compiled C or Fortran) |
| Vector & Web Output | Native SVG + Auto Interactive HTML5 Viewer, PostScript, WMF | SVG, PDF, PNG (HTML requires mpld3/bokeh) |
SVG, PostScript, Canvas (HTML5 JS driver) | FIG, EPS, PDF, SVG (complex 3D often rasterized) |
EPS, PDF, SVG, EMF, TIFF | PostScript, PDF, SVG, WMF, PNG | PostScript, PDF, SVG, PNG (requires Cairo/SVG drivers) |
Interactive HTML/SVG (Static PDF/SVG requires Kaleido) |
| Serverless & Cloud Containers (AWS Lambda, GCP Cloud Run) |
Native & Trivial (<2 MB container layer, instant cold boot) |
Possible but bulky (250+ MB layer, high cold start) |
Requires apt dependencies in container | Impractical / Costly (Production Server license: $10k+) |
Unsupported (Windows desktop only) |
Supported via dynamic shared object | Bulky container setup (multiple shared lib packages) |
Very heavy / impractical (~300 MB Chromium/Kaleido layer) |
| Typography & Fonts | Dual-Engine: 23 Built-in Hershey Vector Fonts + TrueType Engine (Zero FreeType dep) |
External FreeType library + system TTF/OTF | Relies on host fontconfig & pango | System fonts + internal TeX engine | Windows GDI TrueType & OpenType | Hershey fonts + external FreeType | FreeType 2 & system fontconfig (or legacy Hershey) | Web browser CSS fonts & SVG text elements |
| 3D Hidden-Surface Engine | Pure Software Algorithmic: No GPU, No OpenGL, No X11 required |
Painter's Algorithm (notorious depth sorting artifacts) |
Software hidden3d algorithm | Hardware OpenGL / Software Mesa fallback | OpenGL hardware acceleration | Software hidden-line removal | Basic wireframe & mesh (plmesh / plot3d; basic occlusion) |
WebGL / GPU Canvas (No software headless renderer) |
| Specialized Built-In Plots (Smith charts, Ternary, Quiver) |
Built-In: RF Smith Charts, Ternary Phase, 3D Columns, Vector Quiver |
Requires 3rd-party add-ons (scikit-rf, python-ternary) |
Complex manual math transform scripts | Requires RF Toolbox or File Exchange scripts | Built-in (Ternary & Smith templates) | Polar/contour built-in; lacks native Smith | Polar & contour built-in; lacks native Smith | Rich web/financial & Ternary; lacks native Smith |
| Simultaneous Active Plots | simuplot(n)Up to 10 live concurrent coordinate systems |
Subplots & Axes objects (OOP state) | multiplot (sequential write) |
subplot / tiled layout |
Multi-layer graph windows | Multiple page zones | Subpage layouts & multiple stream windows | Subplot grids (declarative JSON spec) |
| Cost & Distribution Model | $295 / Single User (Perpetual license; OEM redistribution negotiated) |
Open Source (PSF / BSD) | Open Source (Gnuplot License) | $$$$ Proprietary ($2,000+ / seat; cloud expensive) |
$$$ Proprietary ($1,000–$3,000 / seat) |
Freeware / Commercial license | Open Source (LGPL v2.1+) | Open Source core (MIT) / Commercial tier |
I gave AG the go-ahead. 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.
-
Replaced our Tektronix plot storage format with a modern, universal (SVG) driver with an interactive browser-based viewer and live monitor streaming.
-
Complete multi-language parity was established—delivering first-class bindings for Modern Fortran(2003/2018/legacy F77), Python 3, Java 22 (Foreign Function & Memory API), and Julia (nativeLibdl FFI).
-
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 precision coordinate transforms developed four decades ago are now preserved and running at native 64-bit speed for the next generation of scientific research.
Although AG is really wonderful at writing code, there are some drawbacks:
-
It lacks (my) taste. It literally took weeks to update the user manual to my satisfaction.
-
It is forgetful. It sometimes reverted things to previous incorrect iterations, and things available in one of the five supported languages were missing in others, and in the manual too. It took eagle eyes on my part to assure full parity. AG and I agreed on a list of things that any changes must satisfy.
I urge you to try the updated GraphiC 2026. There is a free Community Edition to try for 2-D plots, and the long manual to provide instruction using many examples, and to see what extra features the Professional version offers. I really believe that $295 is a reasonable price for this package. Consider
Historical & Inflation Cost Comparison ($495 in 1984 vs. $295 Today)
-
Nominal Price:
- 1984 (Original GraphiC): $495.00
- 2026 (GraphiC Professional): $295.00
- Difference: –$200.00 (a 40% nominal price drop)
-
Real Purchasing Power (Inflation-Adjusted):
- 1984 Price in 2026 Dollars: ~$1,572.00
- 2026 Price: $295.00
- Difference: –81.2% reduction in real cost (selling for less than one-fifth of its original 1984 purchasing power)
-
2D Community Edition:
- 1984: None (paid commercial only)
- 2026: $0.00 (100% free standalone edition covering 2D plots, error bars, bar charts, Hershey fonts, TrueType text, and vector SVG output)
-
Licensing Model:
- One-time perpetual license (for personal use)
- Zero subscriptions, zero phone-home DRM, zero runtime server fees
-
Language Support:
- 1984: C only
- 2026: C, Modern Fortran (fpm), Python 3, Julia, and Java 22
Add new comment