Section 2. Architectural Overview

GraphiC modernizes the classic UNIX philosophy: a lean, fast, rock-solid native C core paired with clean, zero-overhead bindings for modern dynamic and managed languages.

2.1 Native C99 / POSIX Core Engine (Source/, Include/)

• Implemented in clean, portable C99 with standard POSIX headers.
• Completely free of external third-party dependencies; links strictly with the standard C runtime (libc) and mathematics library (libm).
• Builds simultaneously as a shared library (lib/libgraphic.dylib on macOS, libgraphic.so on Linux, graphic.dll on Windows) and static archive (lib/libgraphic.a).
• Manages 2D/3D transformations, viewport clipping, polygon filling, contour elevation calculation, and drawing pipelines.

2.2 Modern Vector SVG Driver & Interactive Web Viewer

• Native Scalable Vector Graphics (SVG): Replaces legacy Tektronix 4014 / 4105 rasterization with clean, standalone W3C Scalable Vector Graphics (SVG). Features resolution-independent vector lines, crisp circle/arc primitives, inline <defs> vector hatch patterns, and automatic viewBox scaling. Generates fully responsive output that renders natively in modern web browsers, Microsoft Word, LaTeX/PDF documents, and publication vector editors (Inkscape, Adobe Illustrator).

• Automated Companion Web Viewer (<plotname>.html): Whenever any C, Fortran, Python, Java, or Julia program creates an SVG plot (via bgnplot(0, SVG, "plot.svg") or language bindings), GraphiC’s SVG driver automatically generates a companion HTML viewer file (plot.html) in the same directory. Opening this file in any web browser (open plot.html) provides immediate interactive capabilities:

  • Mouse-Wheel Zooming: Smoothly zoom in and out centered on the canvas.
  • Click-and-Drag Panning: Freely navigate high-density multi-curve or 3D surface plots.
  • Toolbar Controls: Instant buttons for Reset View (1:1), Zoom In (+), Zoom Out (-), and Download SVG.

• Master Interactive Gallery Viewer (docs/viewer.html / viewer.html): For exploring the entire GraphiC visual library in one place, GraphiC includes a standalone master gallery application:

  • Location: Located at docs/viewer.html (and mirrored at viewer.html in the repository root). Open directly in Safari, Chrome, Edge, or Firefox via open docs/viewer.html.
  • Portfolio Catalog: Browse all 26 figures categorized into Industrial Airport Queuing & Delay Cascades, 3D Horizon Surfaces, Contour Maps, Smith & Polar Charts, 2D Scientific Curves, Categorical Bar & Pie Charts, and Typography & Vector Fonts.
  • Multi-Language Code Inspector: Includes real-time code tabs displaying the exact code required to generate each plot across C, Fortran 2023, Python 3, Java 22 FFM, and Julia.
  • Canvas Customization: Toggle between Light, Dark, and Blueprint Grid canvas backgrounds, inspect raw SVG vector markup, and export publication assets.

2.3 Python 3 Language Package (python/graphic/)

• Zero-Copy C-Types Binding: Interfaces directly with the native libgraphic dynamic library using standard library ctypes. Transparently accepts Python lists, tuples, or NumPy 1D and 2D arrays with zero memory duplication.

• Authentic GraphiC Procedural State Machine: Directly mirrors the classic procedural pipeline using authentic GraphiC routine names:

  import graphic as gp
  
  # 1. Initialize session & page dimensions
  gp.bgnplot(0, 'S', "oscillator.svg")
  gp.page(8.0, 6.0)
  gp.startplot(gp.BRT_WHITE)
  
  # 2. Define plot window & origin
  gp.area2d(6.5, 4.5)
  gp.physor(0.75, 0.75)
  
  # 3. Calibrate axes, labels & borders
  gp.box()
  gp.heading("Damped Oscillator")
  gp.xname("Time (seconds)")
  gp.yname("Amplitude (volts)")
  gp.graf("%3.1f", 0.0, 1.0, 10.0, "%3.1f", -1.0, 0.5, 1.0)
  
  # 4. Plot vector curves & conclude
  gp.color(gp.BLUE)
  gp.curve(x, y, len(x), 0)
  gp.endplot()   # or gp.stopplot()

• Optional Context-Manager Ergonomics: For developers preferring Pythonic with blocks, Figure preserves the exact same authentic GraphiC routine names:

  from graphic import Figure, BLUE
  
  with Figure(8.0, 6.0, background="white", output_path="oscillator.svg") as fig:
      fig.heading("Damped Oscillator")
      fig.xname("Time (seconds)")
      fig.yname("Amplitude (volts)")
      fig.graf("%3.1f", 0.0, 1.0, 10.0, "%3.1f", -1.0, 0.5, 1.0)
      fig.box()
      fig.color(BLUE)
      fig.curve(x, y)

2.4 Java 22 Foreign Function & Memory (FFM) Package (com.sciend.graphic)

• Zero-Overhead Panama FFM Architecture: Built upon the modern JDK 22 Foreign Function & Memory API (java.lang.foreign). Directly downcalls native C symbols via Linker.nativeLinker() and off-heap Arena memory segments, eliminating legacy JNI boilerplate, C glue code, and runtime compilation wrappers.

• Authentic GraphiC Procedural State Machine: Provides direct static access via com.sciend.graphic.Graphic using authentic GraphiC routine names:

  import com.sciend.graphic.Graphic;
  import static com.sciend.graphic.Graphic.*;
  
  // 1. Initialize session & page canvas
  bgnplot(0, 'S', "oscillator.svg");
  page(8.0f, 6.0f);
  startplot(BRT_WHITE);
  
  // 2. Define plot window & origin
  area2d(6.5f, 4.5f);
  physor(0.75f, 0.75f);
  
  // 3. Calibrate axes, labels & borders
  box();
  heading("Damped Oscillator");
  xname("Time (seconds)");
  yname("Amplitude (volts)");
  graf("%3.1f", 0.0f, 1.0f, 10.0f, "%3.1f", -1.0f, 0.5f, 1.0f);
  
  // 4. Plot vector curves & conclude
  color(BLUE);
  curve(x, y, x.length, 0);
  endplot();   // or stopplot()

• Deterministic Resource Management (AutoCloseable): For modern Java workflows, Figure implements AutoCloseable with automatic cleanup while maintaining authentic GraphiC routine names:

  import com.sciend.graphic.Figure;
  import static com.sciend.graphic.Color.*;
  
  try (Figure fig = new Figure(8.0f, 6.0f, WHITE, "oscillator.svg")) {
      fig.heading("Damped Oscillator");
      fig.xname("Time (seconds)");
      fig.yname("Amplitude (volts)");
      fig.graf("%3.1f", 0.0f, 1.0f, 10.0f, "%3.1f", -1.0f, 0.5f, 1.0f);
      fig.box();
      fig.color(BLUE);
      fig.curve(x, y);
  }

2.5 Modern & Legacy Fortran Packages (fortran/src/ and Source/gpcfor_compat.c)

Fortran has been an essential scientific computing language throughout GraphiC’s history (originally supported on 32-bit Windows via gpcfor.dll). The modernized library provides two distinct Fortran interop layers: 1. Modern Fortran 2003/2008/2018/2023 (iso_c_binding): - fortran/src/graphic_iso.f90: Type-safe standard C interoperability interface declarations mapping C entry points directly into Fortran with zero runtime glue overhead. - fortran/src/graphic.f90: High-level idiomatic Fortran module providing constants (COLOR_BLUE, STYLE_DASHED), subroutines (gpc_begin, gpc_graf, gpc_curve, gpc_surface, gpc_contour), and automatic Fortran string null-termination (trim(str) // c_null_char). 2. Legacy Fortran 77 ABI Compatibility Shim (Source/gpcfor_compat.c): - Re-implements the classic gpcfor.dll pass-by-reference symbols in both uppercase (CALL BGNPLOT(...), CALL GRAF(...), CALL CURVE(...)) and lowercase trailing underscore (bgnplot_, graf_, curve_). - Automatically handles fixed-length Fortran character array padding and hidden string lengths, allowing legacy scientific simulation and analysis codes to link without modification. 3. Official Fortran Package Manager (fpm) Integration (fpm.toml): - Full native support for the official modern Fortran build tool and package manager across macOS, Linux, and Windows. - Automated mixed-language compilation: typing fpm build compiles both the C99 engine core and Fortran 2003 modules into libgraphic.a with zero configuration or manual Makefile maintenance. - Built-in example runner: fpm run --example sample, fpm run --example d2test, fpm run --example d3test. - Seamless dependency management: external computational physics and simulation programs can declare GraphiC as a local dependency directly in their own fpm.toml via graphic = { path = "../GraphiC" }.

2.6 Julia Language Package (julia/src/GraphiC.jl)

Julia has become a cornerstone of modern scientific computing, computational physics, and numerical simulation. GraphiC provides native, zero-overhead Julia bindings via the standard Libdl library without requiring external C wrapper packages or intermediate translation layers: - Dual Programming Paradigms: - High-Level Idiomatic API: Single-line plotting functions (GraphiC.plot, GraphiC.scatter, GraphiC.surface_plot, GraphiC.contour_plot) with automatic bounds calculation, nice tick steps, Cartesian grid toggles, and tight SVG canvas auto-cropping. - Procedural State-Machine API: 1:1 parity with the classic C and Fortran GraphiC procedural pipelines (bgnplot
$\to$

page
$\to$

startplot
$\to$

area2d
$\to$

box
$\to$

graf
$\to$

curve
$\to$

endplot
$\to$

stopplot). - Multi-Series Plotting & Legends: Incremental multi-curve workflows via plot! and scatter!, automatic legend calculation and placement (label="Series", legend=:best), and explicit vector SVG export with savefig(fig, "file.svg"). - Plots.jl Ecosystem Integration: Full compatibility with Julia’s premier Plots.jl plotting frontend via Julia 1.9+ package extensions (GraphiCPlotsExt.jl), activated seamlessly via graphic(). - Makie.jl Ecosystem Integration: Dedicated vector backend for Julia’s next-generation Makie.jl data visualization ecosystem via Julia 1.9+ package extensions (GraphiCMakieExt.jl), activated seamlessly via graphic_makie(). Enables standard Makie commands (lines, scatter, contour, and surface) to generate compact, publication-ready vector SVGs with true analytic 3D hidden-surface removal. - Rich Interactive Display in Notebooks & IDEs: The Figure (and PlotOutput) type implements Base.show(io, MIME"image/svg+xml", ...) for inline vector SVG display inside Jupyter Notebooks, Pluto.jl, and the VS Code Julia interactive window. - Smart Resolvers: Colors and line styles accept Symbols (:red, :blue, :dashed, :circle), strings ("red", "#ff0000"), hex values (0xRRGGBB), Colorant/RGB objects, or raw integer constants. - Full Scientific Visualization Coverage: - 2D Cartesian curves, marker symbols, symmetric error bars, fine grid subdivisions. - Grouped bar charts (GraphiC.bar) and exploded pie charts (GraphiC.pie). - Polar coordinate grids (polgrid) and spiral curves (polcurv). - 3D perspective wireframe meshes with hidden-line removal (surmat, surface, volm3d, vuabs, graf3d, d3base, plane3d). - 2D contour maps with numeric elevation annotations (conmat, contour). - RF and microwave Smith charts (smdraw, plotrx).

Example multi-series high-level Julia usage with automatic legends:

using GraphiC

x = range(0.0, 4π, length=120)

# Create base figure with first curve
fig = GraphiC.plot(x, sin.(x);
    title="Harmonic Oscillator Modes",
    xlabel="Time t (s)",
    ylabel="Amplitude A(t)",
    label="sin(x)",
    color=:blue,
    thick=1.5,
    ltype=:solid,
    grid=true
)

# Overlay second series
GraphiC.plot!(fig, x, cos.(x);
    label="cos(x)",
    color=:red,
    ltype=:dashed
)

# Overlay scatter measurement points
GraphiC.scatter!(fig, [1.0, 3.0, 5.0, 7.0, 9.0], [0.8, -0.9, -0.3, 0.7, 0.4];
    label="Sensor Data",
    color=:magenta,
    symbol=:circle
)

# Save crisp vector SVG directly
GraphiC.savefig(fig, "oscillator_multiseries.svg")

Example procedural state-machine Julia usage:

using GraphiC

GraphiC.bgnplot(1, 'S', "cosine.svg")
GraphiC.page(8.0, 6.0)
GraphiC.startplot(GraphiC.WHITE)
GraphiC.svgcrop(0.25)
GraphiC.area2d(5.0, 3.5)
GraphiC.physor(1.5, 1.2)
GraphiC.box()

GraphiC.title("Cosine Curve Demonstration", "Angle (Degrees)", "Amplitude")
GraphiC.graf("%3.0f", 0.0, 60.0, 360.0, "%3.1f", -1.0, 0.5, 1.0)

x = range(0.0, 360.0, length=73)
y = cos.(deg2rad.(x))

GraphiC.color(GraphiC.BLUE)
GraphiC.thick(1.2)
GraphiC.curve(x, y, length(x), GraphiC.SOLID)

GraphiC.endplot()
GraphiC.stopplot()

2.7 How You See GraphiC Plots

When you run a GraphiC program, two files are created on disk in the same directory: - myplot.svg: The pure vector graphics file (resolution-independent, publication-ready). - myplot.html: A lightweight companion web page that displays the SVG inside an interactive canvas.

What Happens When You Call svgopen()

When you call svgopen(NULL) (or when GPC_AUTOPREVIEW=1 is set at plot startup), GraphiC dispatches your operating system’s native desktop application launcher: - macOS: open myplot.html (opens in Safari or default system browser) - Windows: start myplot.html (opens in Microsoft Edge or default browser) - Linux: xdg-open myplot.html (opens in default desktop browser)

Your browser window pops up showing myplot.html. The JavaScript inside myplot.html displays the vector plot with interactive controls (zoom, pan, download SVG) and automatically refreshes when endplot() finalizes the graphic.

You can also pass a specific file if you ever want to open the raw SVG directly: - svgopen(NULL)
$\rightarrow$

Opens myplot.html in your default browser with pan/zoom controls. - svgopen("myplot.svg")
$\rightarrow$

Opens the raw .svg file directly in whatever viewer your OS associates with .svg.

---

Section 3. Platform Overview & Deployment Guide

GraphiC 2026 is engineered as a universal, 64-bit C99/POSIX scientific graphics engine with native bindings for Modern Fortran (Fortran 2003/2018), Python 3, and Java 22. Unlike modern web-based charting widgets or bloated GUI frameworks that demand heavy background runtimes, display servers (X11/Wayland), or dynamic interpreters, GraphiC operates entirely in-process with zero external library dependencies beyond the standard host C library (libc) and math library (libm).

This chapter provides an exhaustive deployment reference for running, compiling, and distributing GraphiC across macOS, Linux, Microsoft Windows, and modern package managers.

3.1 Core Architectural Principles & Linking Strategy

Static vs. Dynamic Linking in Scientific Computing

In computational physics, aerospace simulations, and laboratory instrumentation, static linking (libgraphic.a or graphic.lib) is the strongly recommended default:

---

3.2 macOS (Apple Silicon & Intel)

GraphiC is a first-class citizen on macOS, natively supporting both Apple Silicon (ARM64 M1/M2/M3/M4) and Intel (x86_64) architectures.

1. Prerequisites & Toolchains

• C/C++: Apple Clang installed via standard Xcode Command Line Tools:

  xcode-select --install

• Modern Fortran: GNU Fortran (gfortran) installed via Homebrew:

  brew install gcc

2. Building and Linking

• Static Linking (Recommended):

  # C / C++ Application
  clang -O2 -IInclude my_app.c lib/libgraphic.a -lm -o my_app
  
  # Modern Fortran Application (Fortran 2003/2018)
  gfortran -O2 -I fortran/bin my_app.f90 lib/libgraphic.a -lm -o my_app

• Dynamic Linking (libgraphic.dylib): If building against libgraphic.dylib, macOS locates libraries via runtime search paths (@rpath) or the DYLD_LIBRARY_PATH environment variable:

  clang -O2 -IInclude my_app.c -Llib -lgraphic -lm -o my_app
  export DYLD_LIBRARY_PATH="$(pwd)/lib:$DYLD_LIBRARY_PATH"
  ./my_app

3. Python 3 Deployment on macOS

• Supported Environments: Native Apple Silicon (arm64 M1/M2/M3/M4) and Intel (x86_64) via Homebrew Python (brew install python), Apple Xcode system Python, or Conda.

• Dynamic Binding: Loads lib/libgraphic.dylib via standard library ctypes.

• Quick Setup & Execution:

  # Editable install (or set PYTHONPATH):
  pip install -e python
  # Or:
  export PYTHONPATH="$(pwd)/python:$PYTHONPATH"
  
  # Run Python examples:
  python3 python/examples/sample.py
  python3 python/examples/d3test.py

• Interactive Desktop Preview: Calling gp.svgopen() launches Safari or your default browser instantly via macOS open <plot>.html.

4. Julia Package Deployment on macOS

• Supported Versions: Native Julia 1.6 through 1.11+ for macOS (ARM64 and x86_64), available via brew install --cask julia or juliaup.

• Zero-Overhead FFI: Loads lib/libgraphic.dylib using standard Libdl.dlopen with zero external glue libraries or compiler prerequisites.

• Running Julia on macOS:

  # Run 1-line modern high-level plotting:
  julia --project=julia julia/examples/highlevel.jl
  
  # Run Julia examples or full unit test suite (40 assertions):
  julia --project=julia julia/examples/sample.jl
  julia --project=julia julia/test/runtests.jl

• Notebooks & Pluto.jl: Fully implements Base.show(io, MIME"image/svg+xml", p) for rich inline vector rendering in Pluto.jl, JupyterLab, and VS Code.

---

3.3 Linux (HPC Clusters, Workstations & Servers)

On Linux (x86_64 and AArch64), GraphiC is designed for headless servers, high-performance computing (HPC) clusters, cloud containers (Docker/Podman), and engineering workstations.

1. Supported Compilers

• GNU Compiler Collection (GCC): gcc, g++, gfortran (version 9 through 14+).
• LLVM / Clang: clang, flang.
• Intel oneAPI: icx, ifx (formerly icc / ifort).
• NAG Fortran Compiler: nagfor.

2. HPC Cluster Compilation & SLURM Deployment

Because GraphiC has zero graphical windowing dependencies (all vector drawing streams to W3C SVG), simulation jobs can be submitted directly across headless compute nodes without virtual framebuffers (Xvfb) or display forwarding:

# Compile with static archive:
gfortran -O3 -march=native -I fortran/bin simulation.f90 lib/libgraphic.a -lm -o simulation

# SLURM batch job submission:
srun -n 64 ./simulation

3. Shared Library Usage on Linux (libgraphic.so)

If using shared objects, either bake the library path into the binary with -Wl,-rpath:

gcc -O2 -IInclude my_app.c -Llib -Wl,-rpath,'$ORIGIN/lib' -lgraphic -lm -o my_app

or export the dynamic linker path:

export LD_LIBRARY_PATH=/path/to/graphic/lib:$LD_LIBRARY_PATH

4. Python 3 Deployment on Linux (Headless, Containers & HPC)

• Supported Environments: RHEL, Rocky, AlmaLinux, Ubuntu, Debian, Fedora, Arch, and Docker/Podman container images.

• Zero-X11 Headless Execution: GraphiC outputs pure W3C SVG directly to disk. Python scripts run seamlessly on headless Linux servers, SLURM batch nodes, and CI/CD pipelines without DISPLAY environment variables or Xvfb virtual display framebuffers.

• Execution:

  export PYTHONPATH="/path/to/graphic/python:$PYTHONPATH"
  export LD_LIBRARY_PATH="/path/to/graphic/lib:$LD_LIBRARY_PATH"
  
  python3 python/examples/sample.py
  python3 python/examples/d3test.py

5. Julia Package Deployment on Linux

• Supported Environments: Official Linux glibc binaries (x86_64, AArch64) via juliaup or HPC environment modules (module load julia).

• HPC Batch Visualization: Julia simulation codes can compute massive matrix operations and emit publication vector SVGs in single batch runs with zero windowing or OpenGL dependencies.

• Execution:

  export LD_LIBRARY_PATH="/path/to/graphic/lib:$LD_LIBRARY_PATH"
  julia --project=julia julia/examples/highlevel.jl
  julia --project=julia julia/examples/sample.jl
  julia --project=julia julia/test/runtests.jl

---

3.4 Microsoft Windows (64-Bit Windows 10, 11 & Windows Server)

On 64-bit Windows, GraphiC supports all major compilers and development environments:

Option A: MinGW-w64 / MSYS2 / GCC (Open Source & fpm)

The standard open-source toolchain on Windows compiles GraphiC identically to Unix: * Static Linking (libgraphic.a):

```powershell
# Compile directly to a standalone Windows executable:
gfortran -O2 -I fortran/bin my_sim.f90 libgraphic.a -o my_sim.exe
```

• Deployment Benefit: The resulting my_sim.exe is completely self-contained. It can be distributed as a single executable file and run on any modern 64-bit Windows system without installing runtime redistributables or external DLLs.

Option B: Microsoft Visual Studio (MSVC) & Intel oneAPI Fortran (ifx / ifort)

The industry standard in aerospace, automotive, defense, and CAD engineering: * Static Library (graphic.lib):

```cmd
:: Compile and link into standalone executable:
ifx -O2 -I fortran\bin my_sim.f90 graphic.lib -Fe:my_sim.exe
```

Option C: Dynamic Link Libraries (graphic.dll)

When deploying with graphic.dll: * Windows DLL Search Order: 1. The application’s own directory (the folder where my_sim.exe resides). 2. The current working directory. 3. The Windows system directory (C:\Windows\System32). 4. Directories enumerated in the user and system PATH environment variable. * No LD_LIBRARY_PATH Needed: Unlike Linux or macOS, Windows does not have a separate library path variable. Placing graphic.dll in the same directory as my_sim.exe ensures instant, foolproof loading.

Option D: Python 3 Deployment on 64-Bit Windows

GraphiC provides native, zero-copy Python bindings on 64-bit Windows without requiring a C compiler: * Runtime Compatibility: Compatible with official Python 64-bit (Python 3.8 through 3.13+ from python.org, Windows Store, Anaconda, Miniconda, or WinPython). * DLL Resolution: The graphic Python module utilizes Python’s standard ctypes library to bind directly to graphic.dll. On Windows, Python automatically discovers graphic.dll when placed in: 1. The python/graphic/ package directory (pre-shipped). 2. The current working directory where your script is executed. 3. Any directory registered via os.add_dll_directory("C:/path/to/graphic/lib") (Python 3.8+). 4. The system user/system PATH. * Quick Installation & Execution:

```powershell
# Editable install (or pip install from local repository):
pip install -e python

# Alternatively, run directly via PYTHONPATH without installing:
$env:PYTHONPATH = "python;$env:PYTHONPATH"

# Execute scientific Python examples:
python python/examples/sample.py
python python/examples/d3test.py
```

• Jupyter & VS Code: Full interactive vector SVG rendering and live browser preview (graphic.svgopen()) work natively in VS Code, JupyterLab, and Windows Terminal.

Option E: Julia Package Deployment on 64-Bit Windows

GraphiC offers native Julia bindings with zero compilation overhead on 64-bit Windows: * Supported Versions: Official Julia 64-bit (Julia 1.6 through 1.11+), installed via winget install JuliaLang.Julia, juliaup, or the official installer from julialang.org. * Zero-Compiler Architecture: Julia uses the standard library Libdl to link directly into graphic.dll. Windows users do not need Microsoft Visual Studio, MinGW, or any C compiler installed to generate plots in Julia. * Quickstart & Example Execution:

```powershell
# Launch Julia with the GraphiC project environment:
julia --project=julia

# Or run any example script directly:
julia --project=julia julia/examples/highlevel.jl
julia --project=julia julia/examples/sample.jl
julia --project=julia julia/examples/d3test.jl

# Run the full automated Julia test suite (40 unit assertions):
julia --project=julia julia/test/runtests.jl
```

• Interactive Notebooks & Windows GUI: Integrates with Pluto.jl, Jupyter, and VS Code. In Pluto and Jupyter, vector SVGs render inline via native MIME"image/svg+xml". In command-line scripts, calling GraphiC.svgopen() launches the companion HTML viewer directly in Microsoft Edge or your default browser via the native Windows start shell service.

---

3.5 Fortran Package Manager (fpm) Across Platforms

GraphiC natively supports the official Fortran Package Manager (fpm), providing unified, zero-configuration compilation across macOS, Linux, and Windows.

Supported Compilers

GraphiC is implemented in portable ANSI C99 and modern standard Fortran 2003+ via ISO_C_BINDING. It is tested, benchmarked, and fully supported across all industry-standard compiler toolchains:

• Fortran Compilers:
  • GNU Fortran (gfortran 4.8+): Default compiler on Linux, macOS (via Homebrew), and Windows (via MinGW-w64).
  • Intel oneAPI Fortran Compiler (ifx & ifort): High-performance compiler for x86-64 workstations and supercomputing clusters.
  • LLVM Flang (flang): Modern LLVM-based Fortran compiler across Unix architectures.
  • NVIDIA HPC SDK (nvfortran): Optimized for accelerated and GPU-adjacent scientific simulation codes.
  • NAG Fortran Compiler (nagfor): Strict standards-conforming compiler for numerical algorithms. (Any standard Fortran 2003/2008/2018/2023 compiler implementing ISO_C_BINDING is fully compatible).
• C / C++ Compilers:
  • GCC (gcc 4.9+): Default on Linux and MinGW-w64.
  • Clang / Apple LLVM (clang): Default on macOS Xcode and FreeBSD.
  • Microsoft Visual C++ (MSVC / cl.exe): Visual Studio 2017, 2019, and 2022 (x64 native).
  • Intel oneAPI DPC++/C++ (icx).

Mixed-Language Architecture: Do Fortran Users Need a C Compiler?

Because GraphiC’s core plotting engine, coordinate transforms, 3D hidden-surface algorithms, and SVG vector drivers are implemented in portable C99 (Source/*.c), while the Fortran API is delivered in standard Fortran 2003+ (Source/*.f90):

• When building from source via fpm (or local path dependency): Yes, a C compiler is required on the build machine. However, fpm coordinates mixed C/Fortran builds 100% automatically—it detects your companion C compiler (gcc, clang, cl.exe, or icx), compiles all C core files alongside the Fortran modules, and archives both into libgraphic.a with zero manual Makefile maintenance.
• Companion C Compilers Already Present: In virtually all scientific workstation and HPC environments, a companion C compiler is already bundled with or is a prerequisite for the Fortran compiler:
  • macOS: gfortran (via Homebrew) requires Xcode Command Line Tools, which installs Apple clang.
  • Linux / HPC Supercomputers: gcc is installed alongside gfortran as part of the core GNU compiler collection (build-essential).
  • Intel oneAPI: Intel oneAPI HPC Toolkit installs icx alongside ifx.
  • Windows (MSYS2 / MinGW-w64): Installing mingw-w64-x86_64-gcc installs gcc and gfortran together in the exact same package.
  • Windows (Visual Studio + Intel): Visual Studio C++ workload provides MSVC cl.exe alongside Intel Fortran ifx.
• When linking against pre-compiled libraries: No C compiler is needed. If libgraphic.a (or graphic.lib) has already been built for your platform, Fortran developers only need their Fortran compiler (gfortran my_sim.f90 libgraphic.a -lm -o my_sim).

Obtaining and Installing fpm

fpm is available on all major operating systems via standard package managers: * macOS (Homebrew):

```bash
brew install fpm
```

• Windows, macOS & Linux (Conda / Mamba):

  conda install -c conda-forge fpm

• Windows (Standalone Binary or MSYS2): Download the standalone fpm.exe executable from GitHub Releases and place it in your system PATH, or install via MSYS2:

  pacman -S mingw-w64-x86_64-fpm

• Linux (Package Managers):

  • Fedora / RHEL: sudo dnf install fpm
  • Arch Linux: sudo pacman -S fortran-package-manager
  • Ubuntu / Debian: Download the standalone Linux binary from GitHub Releases.

• Compiler Selection with fpm: By default, fpm automatically detects and uses gfortran. To compile with an alternative compiler (such as Intel ifx or LLVM flang), use the --compiler flag or export FC:

  fpm build --compiler ifx
  # or: export FC=ifx && fpm build

1. Building the Library and Running Examples

Users who clone or download the GraphiC package can build and run tests with single commands:

# Build the library and Fortran modules
fpm build

# Run any example program
fpm run --example sample
fpm run --example d2test
fpm run --example d3test

2. Consuming GraphiC in External Projects

To embed GraphiC inside an independent scientific simulation, DAQ system, or aerospace analysis package, declare it as a local path dependency in your application’s fpm.toml.

Both GraphiC 2D Community Edition and GraphiC Professional are distributed as self-contained, standalone source packages (Community as a free download, and Professional as the complete licensed suite via Lemon Squeezy).

Extract your downloaded distribution archive onto your workstation or HPC cluster, and reference the directory in your project’s fpm.toml:

[dependencies]
graphic = { path = "../GraphiC" }  # Path to extracted Community or Pro folder

(Users and organizations wishing to maintain GraphiC in version control can simply initialize their own internal Git repository within the extracted directory).

Example: Building an External Fortran Project with GraphiC

Consider an external scientific project directory structure:

my_simulation/
├── fpm.toml
└── app/
    └── run_sim.f90

Where my_simulation/fpm.toml specifies the local dependency:

[package]
name = "my_simulation"
version = "1.0.0"

[dependencies]
graphic = { path = "../GraphiC" }

And app/run_sim.f90 utilizes GraphiC plotting routines:

program run_sim
  use graphic
  implicit none
  real, dimension(100) :: x, y
  integer :: i

  ! Generate sample dataset
  do i = 1, 100
    x(i) = real(i) * 0.1
    y(i) = sin(x(i))
  end do

  call bgnplot(1, 4, "simulation_output.svg")  ! Native SVG vector output
  call linplt(x, y, 100)                      ! Cartesian polyline plot
  call endplot()
end program run_sim

When you execute fpm build or fpm run, fpm automatically compiles GraphiC’s C99 core and Fortran 2003 modules from the local folder, links libgraphic.a, and produces your finished executable with zero external network dependencies.

---

3.6 Runtime Configuration, Automation & Fonts

1. Headless Automation (GPC_NONINTERACTIVE=1)

By default, interactive GraphiC plots wait for a user keypress upon plot termination (endplot). When running automated batch simulations, SLURM scripts, cron jobs, background web daemons, or headless CI/CD pipelines, set the non-interactive environment variable: * macOS / Linux / Bash:

```bash
export GPC_NONINTERACTIVE=1
```

• Windows PowerShell:

  $env:GPC_NONINTERACTIVE="1"

• Windows Command Prompt:

  set GPC_NONINTERACTIVE=1

  When set, endplot immediately flushes all SVG and HTML files to disk and returns control to the calling application without blocking.

2. Font File Resolution (GPC_FONTS)

GraphiC searches for font files (*.fnt and Unicode.ttf) in the following order: 1. Directory path specified by the GPC_FONTS environment variable (e.g. export GPC_FONTS=/usr/local/share/graphic/fonts). 2. The current working directory.

---

Section 4. Memory Management: Legacy DOS vs Modern 64-Bit Systems

Historical 16-Bit Memory Architecture

In the original 1980s DOS implementation, IBM PC software operated under the infamous 640 KB conventional memory barrier with 16-bit segmented real-mode pointers (segment:offset). Generating high-resolution 3D surface meshes (e.g.,
$100 \times 100$

floating-point arrays) or multi-thousand point curves easily exceeded available physical RAM.

To survive, GraphiC incorporated a custom virtual memory subsystem: - getbuf() and freebuf(): Custom dynamic allocators that partitioned small memory heaps. - Disk Paging & Temporary Spill Files: Array buffers were swapped to temporary scratch files on floppy disks or slow early hard drives. - Expanded / Extended Memory (EMS / XMS): Routines to bank-switch 16 KB pages into DOS memory windows. - Byte-Offset Seek Files (.OFF): Auxilliary index files written alongside .TKF plot files so that multi-page plots could be randomly accessed by seeking to byte offsets without parsing the entire file.

Modern 64-Bit Architecture

In modern 64-bit computing environments: 1. Flat 64-bit Virtual Address Space: Operating systems provide
$2^{48}$

to
$2^{64}$

bytes of addressable memory per process. Datasets of millions of points fit effortlessly in active memory without paging overhead. 2. Virtual Memory & Hardware MMU: The kernel and hardware Memory Management Unit (MMU) automatically handle page faults, demand paging, and translation lookaside buffer (TLB) caching orders of magnitude faster than any userland disk-swapping algorithm. 3. Elimination of Obsolete .OFF Files: Modern SVG files are self-contained XML documents. The legacy .OFF files served only DOS-era PLAY.EXE tools and have been permanently disabled, eliminating disk I/O overhead and directory clutter. 4. Standard Heap Allocation: The modern library uses standard C malloc(), calloc(), and free() for dynamic temporary buffers, ensuring thread safety, memory sanitizer (ASan) validation, and zero leaks.

---

Section 5. Typography, Fonts, and Text Systems

GraphiC incorporates a comprehensive, multi-engine typographic subsystem engineered specifically for scientific plotting and technical publication. Rather than forcing all text through a single font model, GraphiC natively integrates three distinct font architectures—Hershey vector stroke fonts, standard TrueType (.ttf) outline fonts, and Adobe PostScript Type 1 (.pfb / .pfa) fonts. All three engines can be freely intermixed within the same plot, or switched dynamically in mid-string using in-line escape characters.

Figure 5.1 — GraphiC Multi-Engine Typography Architecture

---

4.1 The Three Native Typography Engines

1. The Hershey Vector Stroke Font Engine (.fnt)

Originally compiled by Dr. Allen V. Hershey at the U.S. Naval Weapons Laboratory, Hershey fonts represent characters as connected vector line strokes: - Zero Dependencies: Because characters are drawn directly with line segments, they require no operating system font managers, rasterizers, or display servers. - Arbitrary Scaling & Rotation: Can be scaled to any cap height or rotated to arbitrary angles without raster blur, anti-aliasing artifacts, or loss of clarity. - Scientific Symbol Suites: Complete coverage of uppercase and lowercase Greek alphabets, mathematical operators (
$\int, \partial, \sum, \sqrt{}$

,
$\infty$

,
$\approx$

), astronomical symbols, and accented characters. - Included Typefaces: simplex.fnt (clean technical sans-serif), complex.fnt (double-stroke Roman serif), duplex.fnt (bold sans-serif), triplex.fnt (heavy Roman), script.fnt (flowing cursive), italics.fnt (slanted serif), and simgrma.fnt (Greek mathematical).

2. The Native TrueType Engine (.ttf)

Developed for GraphiC Version 7.0 by David Dillow (Source/Truetype.c, Source/Ttfntld.c, Source/Ttfntplt.c) and modernized for 64-bit platforms: - Direct TrueType File Parsing: Reads standard Microsoft/Apple .ttf font files directly from disk via gfopen(). - 64-Bit Clean Binary SFNT Directory Ingestion: Portable big-endian binary parsing of TrueType tables, removing legacy 64KB table size limits. Tables parsed include cmap (Format 0 and Format 4 Microsoft Unicode BMP character mapping), glyf (glyph quadratic Bézier geometry), head, hhea, hmtx (horizontal metrics and advance widths), kern (pairwise kerning tables), loca (16-bit short and 32-bit long glyph location offsets), and maxp. - Transparent UTF-8 Sequence Decoding: Multi-byte UTF-8 sequences in strings (Greek letters, math symbols, degree signs) are automatically decoded on the fly into Unicode code points and resolved through the cmap Format 4 table. - Quadratic B-Splines (qspline): Evaluates second-order Bézier curves into smooth polygonal contours with configurable tessellation tolerance (SetTTMaxError). - Solid Filling & Outlines with Even-Odd Rule: Supports hollow vector outlines (fillfont(0)) and solid filled glyph interiors (fillfont(1)). In vector output (SVG, PDF), filled glyphs apply fill-rule="evenodd" so internal counters (‘O’, ‘0’, ‘B’, ‘8’, ‘R’, ‘e’, ‘a’) remain hollow. - Pairwise Kerning: TrueType kern tables are automatically parsed to produce proportional, publication-quality letter spacing (SetTTKerning(1, 0)).

3. The PostScript Type 1 Engine (.pfb / .pfa) & GrafText

Also engineered by David Dillow (Source/Psfont.c): - Direct Adobe Type 1 Ingestion: Reads binary (.pfb) and ASCII (.pfa) PostScript font files. - In-Memory eexec Decryption: Automatically decrypts the encrypted private dictionary and character outlines using the standard Adobe Type 1 deciphering key (55665). - Cubic Bézier Curve Parsing: Interprets PostScript CharStrings bytecodes and subroutines (Subrs), converting third-order Bézier splines into polygon outlines or solid filled glyphs. - Adobe Font Metrics (.afm) Integration: Parses corresponding .afm metric files for character advance widths and pairwise kerning adjustments. - GrafText 30 Standard Typefaces: For PostScript (.ps) and Encapsulated PostScript (.eps) printing, GTfont(number) selects from 30 standard printer-resident Adobe PostScript fonts.

---

4.2 Font Selection and Registration: font()

The public font() routine loads and registers up to FNTNUM (default 10) fonts in memory simultaneously:

void font(int nfont, ...);

Calling Syntax

The first parameter nfont specifies the total number of fonts to be loaded. It is followed by variable argument pairs: font(nfont, font_path_1, escape_char_1, font_path_2, escape_char_2, ...): - font_path (char *): Path to the font file. The file extension automatically routes the font to the correct engine: - .TTF or .ttf
$\rightarrow$

TrueType outline engine (TRUETYPE). - .PFB or .pfb
$\rightarrow$

PostScript Type 1 filled engine (PSFILLED). - .FNT or .fnt
$\rightarrow$

Hershey stroke vector engine (REGULARFONT). - escape_char (char or int): The character used as an in-string trigger to activate this font.

Practical Examples

Loading Mixed TrueType, PostScript, and Hershey Fonts:

/* Load 3 fonts: TrueType Times, PostScript Helvetica, and Hershey Greek */
font(3,
     "times.ttf",    '\\',    /* '\' triggers Times TrueType */
     "helv.pfb",     '|',     /* '|' triggers Helvetica PostScript */
     "simgrma.fnt",  '/'      /* '/' triggers Greek mathematical font */
);
fillfont(1);                  /* Enable solid fill for TrueType and PostScript */

Reloading and Freeing Fonts: - Calling font(-1) reloads the previously registered font set without needing to repeat the arguments. - Calling freememq() unloads all loaded fonts and frees their heap buffers.

---

4.3 In-Line Multi-Font Switching & Mathematical Notation

Once fonts are registered with font(), they can be switched dynamically anywhere inside titles, axis labels, or annotations simply by including the designated escape character:

heading("Magnetic Field \\B(r) |[Tesla] /m/b");

• The text starts in the primary active font (times.ttf).
• \\ switches to Font 0 (times.ttf).
• | switches to Font 1 (helv.pfb).
• / switches to Font 2 (simgrma.fnt), printing
  $\mu_B$

  in Greek notation.

• Doubling the escape character (e.g., // or \\\\) prints the literal character without triggering a font change.

Subscripts and Superscripts

GraphiC features automatic baseline displacement and scaling for scientific scripts: - ^ enters superscript mode (configurable with supsym(char)). - _ enters subscript mode (configurable with subsym(char)). - scrht(factor): Adjusts the character height scale factor (default
$0.7 \times$

cap height). - scrshft(factor): Adjusts the baseline shift percentage.

Example:

xname("Density n_e (10^1^9 m^-^3)");
yname("Electron Temperature T_e (keV)");

---

4.4 Typography Controls, Styling, and Effects

---

4.5 Standard Adobe PostScript Printer Fonts (GrafText)

When exporting plots to Encapsulated PostScript (.eps) or routing to PostScript printer drivers, GTfont(number) provides direct access to the 30 standard PostScript printer fonts:

---

4.6 Modern SVG Vector Typography (2026 Modernization)

In the modern 64-bit SVG driver, text is rendered with dual-mode precision: 1. Geometric Vector Outlines & Filled Polygons: When maximum archival fidelity and 100% device independence are required, TrueType, PostScript, and Hershey characters are decomposed into exact SVG <path> and <polygon> elements. The output is mathematically guaranteed to render identically on every device, operating system, and vector graphics suite (Inkscape, Illustrator, Word) without requiring local font files. 2. Semantic SVG <text> Elements: When searchability, screen reader accessibility, and text selection in web browsers or PDF viewers are preferred, GraphiC emits semantic <text> nodes with standard CSS font family cascades (font-family: "Times New Roman", Times, serif;).

---

4.7 Native Unicode (UTF-8) and TrueType Typography

Modern 64-bit GraphiC introduces transparent Unicode (UTF-8) decoding alongside the fully modernized TrueType outline engine. Scientific users can now use standard UTF-8 string literals directly in C, C++, Python, Java, and Fortran code without relying on legacy character codes or awkward multi-font escape switches.

1. Transparent UTF-8 Multi-Byte Decoding

When a TrueType font (.ttf) is active, GraphiC’s string measurement and rendering pipelines (strsizq() and TrueTypeOut() in Source/Ttfntplt.c) automatically decode UTF-8 multi-byte sequences on the fly into 16-bit and 32-bit Unicode scalar values: - 2-Byte Sequences (0xC0–0xDF): Standard Greek characters (
$\alpha, \beta, \gamma, \delta, \lambda, \mu, \pi, \sigma, \omega$

), degree symbols (
$^\circ\text{C}$

), plus-minus (
$\pm$

), and Latin accents. - 3-Byte Sequences (0xE0–0xEF): Mathematical operators (
$\le, \ge, \ne, \approx, \equiv, \subset, \in, \infty, \nabla, \partial, \sqrt{}$

), arrows (
$\rightarrow, \leftarrow$

), and geometric shapes. - 4-Byte Sequences (0xF0–0xF7): Extended mathematical alphanumeric symbols and specialized notations.

The decoded Unicode value is queried directly against the font’s OpenType/TrueType cmap table (Format 4 Unicode BMP), retrieving the exact vector glyph contour definitions without intermediate transliteration.

2. Character Counter Geometry & Even-Odd Hole Punching

TrueType glyphs represent character shapes using quadratic Bézier contour loops. Glyphs with enclosed “counters” or holes—such as O, 0, B, 8, R, e, a, %, and Greek letters like
$\Delta$

and
$\theta$

—contain an outer contour followed by one or more interior cutout contours.

In the modernized SVG vector driver, all filled TrueType glyphs are rendered with:

<path d="..." fill="#000000" fill-rule="evenodd" stroke="#000000" stroke-width="1"/>

The standard evenodd fill rule ensures that the interior counters remain completely transparent and hollow, preventing glyph holes from being erroneously filled in by vector renderers, web browsers, or PDF converters.

3. TrueType Outline vs. Hershey Vector Fonts

GraphiC provides both font technologies so developers and researchers can choose the optimal approach for each technical application:

4. Scientific Example: Native UTF-8 Spectroscopy Plot

#include <graphic.h>

int main(void) {
    float x[] = {0.0f, 1.0f, 2.0f, 3.0f};
    float y[] = {25.0f, 30.0f, 45.0f, 60.0f};

    bgnplot(1, 'g', "spectroscopy.svg");
    startplot(WHITE);

    /* Load system Arial font as TrueType Font 0 with trigger '\310' */
    font(1, "/System/Library/Fonts/Supplemental/Arial.ttf", '\310');
    fillfont(1); /* Enable solid glyph fill with even-odd counter hollowing */

    page(8.0f, 6.0f);
    area2d(6.5f, 4.5f);
    color(BLUE);

    /* Direct UTF-8 string literals: Greek symbols, math relations, degree signs */
    heading("\310Laser Spectroscopy: λ = 532 nm, T = 25 °C, ΔV ≤ 5.0 V");
    xname("\310Wavelength Offset Δλ (nm) [α = 0.05, β = 1.2, π ≈ 3.14]");
    yname("\310Temperature T (°C) [±0.5 °C]");

    graf("%-4.1f", 0.0f, 1.0f, 3.0f, "%-4.1f", 20.0f, 10.0f, 70.0f);
    color(RED);
    curve(x, y, 4, 0);

    endplot();
    stopplot();
    return 0;
}

---

Section 6. Directory Layout and Clean Workspace Policy

The repository is structured to maintain strict separation of concerns and a 100% clean root directory:

Clean Workspace Policy: - No stray .svg, .tkf, .html, or .off files are ever permitted in the root repository directory. - All example executables and scripts must write their vector output files strictly inside their respective language directory (c/examples/, python/examples/, or java/examples/). - The obsolete .OFF file generation has been permanently disabled in the C driver.

---

Section 7. Compilation, Quickstart & Live Monitor Display

Building C/C++ Libraries and Examples

cd <GraphiC_Dir>

# 1. Clean build artifacts
make clean

# 2. Build libgraphic.a, libgraphic.dylib, and play utility
make all

# 3. Compile all 33 portable C example executables into bin/
make examples

# 4. Run all C examples to generate SVGs in c/examples/
make run_c_examples

Running Python 3 Examples

export PYTHONPATH=<GraphiC_Dir>/python:$PYTHONPATH

# Run individual examples
python3 python/examples/d2test.py
python3 python/examples/d3test.py
python3 python/examples/cnttest.py
python3 python/examples/smtest.py

Compiling and Running Java 22 Examples

cd <GraphiC_Dir>/java

# Compile library and examples with Java 22 FFM preview enabled
javac --enable-preview --source 22 -d bin src/main/java/com/sciend/graphic/*.java examples/*.java

# Run individual examples
java --enable-preview -cp bin examples.D2Test
java --enable-preview -cp bin examples.D3Test
java --enable-preview -cp bin examples.CntTest
java --enable-preview -cp bin examples.SmTest

Compiling and Running Fortran Examples

GraphiC provides 100% standards-compliant Fortran 2003+ modules via ISO_C_BINDING. It is fully compatible out-of-the-box with all major industry Fortran compilers including Intel oneAPI (ifx/ifort), LLVM (flang), GNU (gfortran), NAG (nagfor), and NVIDIA (nvfortran):

# Compile library, Fortran modules, and example executables
make fortran_examples

# Run all Fortran examples (generates SVGs in fortran/examples/)
make run_fortran_examples

Example modern Fortran usage:

program harmonic
  use graphic
  implicit none

  call gpc_begin(DRIVER_SVG, "fortran/examples/d2test.svg")
  call gpc_page(8.0, 6.0)
  call gpc_start(COLOR_WHITE)
  call gpc_area2d(5.5, 4.0)
  call gpc_physor(1.5, 1.2)
  call gpc_box()
  call gpc_title("Harmonic Oscillations", "Time (s)", "Amplitude (V)")
  call gpc_graf("%3.1f", 0.0, 1.0, 10.0, "%3.1f", -1.0, 0.5, 1.0)
  call gpc_color(COLOR_BLUE)
  call gpc_curve(x, y, 100, 0)
  call gpc_end()
  call gpc_stop()
end program harmonic

Running Julia Examples & Test Suite

GraphiC provides zero-overhead native Julia bindings (GraphiC.jl) using Libdl with support for both 1-line high-level plotting and classic procedural pipelines:

# Run individual examples
julia --project=julia julia/examples/highlevel.jl
julia --project=julia julia/examples/sample.jl
julia --project=julia julia/examples/d2test.jl
julia --project=julia julia/examples/d3test.jl
julia --project=julia julia/examples/bess3d.jl
julia --project=julia julia/examples/cnttest.jl
julia --project=julia julia/examples/smtest.jl
julia --project=julia julia/examples/polar.jl
julia --project=julia julia/examples/bartest.jl
julia --project=julia julia/examples/piechart.jl

# Or execute all 10 examples via Makefile:
make run_julia_examples

# Run the automated Julia unit test suite (40 assertions):
make test_julia

Example 1-line idiomatic modern Julia usage:

using GraphiC

x = range(0.0, 4π, length=120)
y = exp.(-0.25 .* x) .* sin.(x)

# 1-Line publication-quality vector plot with automatic layout and crop
p = GraphiC.plot(x, y;
    title="Damped Harmonic Oscillator",
    xlabel="Time t (s)",
    ylabel="Amplitude A(t)",
    color=:blue,
    thick=1.5,
    ltype=:solid,
    symbol=:circle,
    grid=true,
    filename="oscillator.svg"
)

---

Cross-Platform Deployment & Linking Guide: macOS, Linux, Windows, and fpm

GraphiC 2026 is designed as a portable, flat 64-bit C99 engine with native ISO C bindings for Modern Fortran, Python 3 CFFI/ctypes bindings, and Java 22 Foreign Function & Memory (FFM) bindings. Because it relies solely on standard POSIX/C99 system calls and the standard math library (-lm), it builds and runs natively across modern operating systems without external rendering engines, display servers, or GUI dependencies.

1. Core Principles: Static vs. Dynamic Linking

In computational physics and high-performance engineering, static linking (libgraphic.a or graphic.lib) is strongly recommended: * Zero Runtime Dependencies: The entire GraphiC vector rendering engine is compiled directly into your simulation binary. * Portable Deployment: You can copy your compiled executable across compute clusters, cloud nodes, or student laptops without configuring library search paths or encountering shared library version mismatches (“DLL Hell”). * Sub-Millisecond Execution: In-process execution eliminates inter-process communication (IPC) and file serialization overhead.

---

2. macOS (Apple Silicon M1/M2/M3/M4 & Intel x86_64)

• Toolchains: Apple Clang (via Xcode Command Line Tools xcode-select --install) and GNU Fortran (gfortran via Homebrew).

• Static Linking (Recommended):

  # C / C++
  clang -O2 -IInclude my_sim.c lib/libgraphic.a -lm -o my_sim
  
  # Modern Fortran (Fortran 2003/2018)
  gfortran -O2 -I fortran/bin my_sim.f90 lib/libgraphic.a -lm -o my_sim

• Dynamic Linking (libgraphic.dylib): If linking against libgraphic.dylib, macOS locates libraries via runtime search paths (@rpath) or the DYLD_LIBRARY_PATH environment variable:

  clang -O2 -IInclude my_sim.c -Llib -lgraphic -lm -o my_sim
  export DYLD_LIBRARY_PATH="$(pwd)/lib:$DYLD_LIBRARY_PATH"
  ./my_sim

---

3. Linux (x86_64 & AArch64 / ARM64)

• Toolchains: GCC (gcc, gfortran), LLVM/Clang, or Intel oneAPI (icx, ifx).

• Static Linking (HPC Standard):

  # GCC / gfortran
  gfortran -O2 -I fortran/bin my_sim.f90 lib/libgraphic.a -lm -o my_sim
  
  # Intel oneAPI (ifx)
  ifx -O2 -I fortran/bin my_sim.f90 lib/libgraphic.a -lm -o my_sim

  The resulting binary is completely self-contained and ready to execute across SLURM cluster nodes, compute clouds, or containerized Docker environments.

• Shared Library (libgraphic.so): When using shared objects, either embed the run-time library path using -Wl,-rpath:

  gcc -O2 -IInclude my_sim.c -Llib -Wl,-rpath,'$ORIGIN/lib' -lgraphic -lm -o my_sim

  or export the environment variable:

  export LD_LIBRARY_PATH=/path/to/graphic/lib:$LD_LIBRARY_PATH

---

4. Microsoft Windows (64-bit Windows 10, 11, and Windows Server)

GraphiC supports all standard 64-bit Windows compilation toolchains:

Option A: MinGW-w64 / MSYS2 / GCC / gfortran

The standard open-source toolchain on Windows compiles GraphiC identically to Unix: * Static Linking (libgraphic.a):

```powershell
# Compile directly to a standalone Windows executable:
gfortran -O2 -I fortran/bin my_sim.f90 libgraphic.a -o my_sim.exe
```

• Advantage: Produces a single, self-contained my_sim.exe that runs on any modern Windows PC. No installers, no external DLLs, and no runtime environments required.

Option B: Microsoft Visual Studio (MSVC) & Intel oneAPI Fortran (ifx / ifort)

The industry standard in corporate aerospace, defense, and CAD engineering: * Static Library (graphic.lib):

```cmd
ifx -O2 -I fortran\bin my_sim.f90 graphic.lib -Fe:my_sim.exe
```

The plotting routines are linked directly into my_sim.exe.

Option C: Windows Dynamic Link Library (graphic.dll)

If you choose to distribute graphic.dll: * Windows locates DLLs in a strict order: 1. The application’s own directory (the folder where my_sim.exe resides). 2. The current working directory. 3. The system directories (C:\Windows\System32). 4. Directories listed in the user and system PATH environment variable. * Deployment Tip: Unlike Linux (LD_LIBRARY_PATH) or macOS (DYLD_LIBRARY_PATH), Windows does not use a library path variable. Simply place graphic.dll in the same directory as your .exe (or add its directory to PATH), and Windows loads it automatically.

---

5. Fortran Package Manager (fpm)

GraphiC natively supports the official Fortran Package Manager (fpm) across macOS, Linux, and Windows: * Building the Library & Modules:

```bash
fpm build
```

• Running Example Demos:

  fpm run --example sample
  fpm run --example d2test
  fpm run --example d3test

• Consuming GraphiC in Your Own Project: Both Community and Professional editions are distributed as standalone source archives. Extract the archive onto your system and add the local directory path to your project’s fpm.toml:

  [dependencies]
  graphic = { path = "../GraphiC" }  # Path to extracted Community or Pro folder

  When you run fpm build, fpm automatically compiles GraphiC’s C99 core and Fortran modules, links libgraphic.a, and embeds the plotting engine directly into your program with zero external network dependencies.

---

6. Runtime Configuration & Environment Variables

• GPC_NONINTERACTIVE=1:
  By default, interactive GraphiC plots wait for a user keypress upon plot termination (endplot). When running automated batch simulations, SLURM scripts, cron jobs, background web daemons, or headless CI/CD pipelines, set export GPC_NONINTERACTIVE=1 (or $env:GPC_NONINTERACTIVE="1" on Windows PowerShell) to disable the interactive pause and immediately flush vector outputs to disk.
• GPC_FONTS=/path/to/fonts:
  Specifies the search directory for GraphiC outline fonts (Swiss.fnt, News.fnt), stroke fonts (Simplex.fnt, Complex.fnt), and TrueType fonts (Unicode.ttf). If omitted, GraphiC searches the current working directory.

---

Real-Time Live Monitor Display & Early Run Abort

A major architectural advantage of GraphiC is its ability to draw graphics directly to the screen monitor as data is generated (bgnplot(mode, ...) with mode = 0 for monitor only or mode = 2 for dual monitor and file output).

Why Live Monitor Display Is Mission-Critical

In scientific computing, aerospace trajectory modeling, finite-element analysis, and laboratory data acquisition (DAQ), calculations often run for many minutes, hours, or days: 1. Interactive Data Streaming: Rather than running “blind” in batch mode and inspecting a static plot file hours later, the engineer can observe the physical state, orbital path, or voltage trace evolving point-by-point in real time. 2. Early Error Detection & Run Cancellation: If an integration step diverges, numerical instability emerges, boundary conditions are violated, or a physical sensor drops data, the anomaly is immediately visible on the monitor. The user can press Ctrl+C or click Stop to abort the run immediately, refine parameters, and restart—saving valuable time and computational resources. 3. Dual-Channel Logging: Mode 2 directs graphics to the interactive display while simultaneously logging the complete, publication-grade vector graphics file (.svg or .tkf) to disk for documentation and archival reporting.

---

Section 8. Complete GraphiC Procedural API Technical Reference (§8.1–§8.19)

This reference documents the complete public API of the GraphiC library reconstructed from the original C source code implementation, parameter tables, and algorithmic commentary (Source/*.c and Include/Proto.h). Each routine is specified in the clean, high-contrast format of the original printed reference manual detailing its operational level, source mapping, coordinate systems, multi-language signatures, parameter constraints, and algorithmic behavior.

Routine Level Classifications

As in the original printed GraphiC reference manual (Page L-01), routines are classified into functional operational levels: - Level 0 (Pre-Initialization): Global configuration routines invoked before bgnplot() (e.g. rotate()). - Level 1 (Basic / Primary): Foundational routines invoked immediately following session initialization (bgnplot, startplot, page, area2d, graf, curve, surmat, conmat, smdraw, polgrid, etc.). - Level 2 (Intermediate / Customization): Specialized styling, font attributes, custom tick spacing, grid controls, 3D viewing angles, legends, and statistical fitting. - Level 3 (Advanced / Low-Level & Interactive): Complex mathematical transformations, interactive crosshair digitizers, simultaneous subplot context switching, raw clipping windows, and coordinate conversion pipelines.

8.1 Initialization Routines

Covers global plotting subsystem initialization, screen monitor bindings, driver allocation, and mode configuration.

Initializes a graphics plotting session, allocates internal device state tables, and binds the output vector stream, display driver, and live screen monitor.

bgnplot() must be called prior to any other GraphiC routine (with the exception of static configuration routines like rotate()).

Multi-Language Signatures:

Begins a new plotting canvas page and initializes background fill.

Clears the active frame, resets clipping boundaries to full canvas dimensions, resets pen state to UP at origin, and sets background color. In multi-page sessions, each startplot() constitutes an independent page frame.

Multi-Language Signatures:

Closes the current output file stream and redirects subsequent pages to NewName.

Allows generating a sequential series of separate vector graphics files from a single continuous calculation or simulation loop.

Multi-Language Signatures:

8.2 Plot Termination Routines

Handles canvas page closure, vector buffer flushing, plot additions, and complete session termination.

Enables or disables automatic date and time stamping on the current plot page.

The timestamp is printed along the top edge of the active picture using the stroke font specified by the font selector character. Passing '0' disables timestamping (default).

or '0' to disable date and time output. Enclose in single quotes.

Multi-Language Signatures:

Returns GraphiC to Level 1 while keeping the current page and screen active.

Used when multiple overlapping coordinate systems or independent curve overlays must be composited onto the same physical drawing region without re-erasing the screen or writing an end-of-page trailer.

See Also: startplot, endplot

Multi-Language Signatures:

Completes drawing for the current page, flushes pending polygon and polyline buffers to the output driver, and closes active vector container elements.

In interactive environments, endplot() pauses for user inspection or keypress. When GPC_NONINTERACTIVE=1 or batch driver is active, it completes immediately.

@return [int] Status code (0 for success, non-zero for abort or error).

See Also: startplot, stopplot

Multi-Language Signatures:

Terminates the GraphiC session.

Flushes and closes the active file stream (e.g. final </svg> closing tag), frees dynamically allocated workspace memory (horizons, spline buffers, font tables), and resets terminal or display hardware to initial state.

See Also: bgnplot, endplot

Multi-Language Signatures:

8.3 Page and Axis Options

Defines physical sheet dimensions, active plotting viewports, curve cropping, axis offsets, borders, tick geometries, text heights, and legend positioning.

The GraphiC default is to crop lines and curves at the edges of the plot region (i.e. the rectangular viewport defined by the call to area2d()). To turn off this feature, call acrop(1); this automatically moves the clipping boundary to the physical edge of the drawing page, allowing vectors and curves to span across the entire sheet. Line cropping is automatically reset to the default value (acrop(0)) after each call to curve drawing routines.

Multi-Language Signatures:

In GraphiC, all SVG output files automatically crop to the tight bounding box of the area filled by the plot (including axes, labels, numbers, ticks, curves, titles, and legends) plus a user-configurable margin. This eliminates excess white space surrounding the graphic, allowing plots to be cleanly embedded into LaTeX documents, Microsoft Word, web pages, or publication figures without requiring a separate post-processing clipping step.

When to Call: Autocrop is enabled by default with a 1/4" (0.25 inch) margin, so applications requiring standard cropping do not need to make any explicit call. When a custom margin is desired (e.g. svgcrop(0.1f) for 0.1" margin, or svgcrop(0.0f) for flush cropping), svgcrop() can be called at any point before the plot is closed with endplot() or stopplot(). Calling svgcrop() prior to bgnplot() or immediately following bgnplot() establishes the cropping margin for the current plot and all subsequent plots in the session. To completely disable cropping and preserve the traditional uncropped 8.5" x 11" landscape canvas, call svgcrop(-1.0f).

Multi-Language Signatures:

Native vector viewer launcher and real-time network streaming telemetry interface. svgopen(filepath): Launches system default web browser (macOS open, Windows start, Linux xdg-open) to view interactive plot. svgpush(url, filepath): Transmits vector SVG file payload across local network or cloud dashboard via HTTP POST.

Multi-Language Signatures:

svgpush() transmits an SVG plot over the network to a remote web server, dashboard, or live monitoring service using an HTTP/HTTPS POST request with Content-Type: image/svg+xml. This routine directly modernizes and supersedes the historical 2007 tkfpush socket streaming mechanism, providing high-efficiency telemetry integration for IoT monitors (such as live water temperature tracking), automated web publishing, and compute-cluster simulations streaming progress plots directly to a researcher's web browser without manual file copying or external shell scripts. Returns 0 upon successful HTTP transmission, or a negative error code if the destination cannot be reached.

Multi-Language Signatures:

Establishes the physical bounding dimensions of the active 2D plotting box.

The area2d dimensions define the length of the horizontal (X) and vertical (Y) axes. Data points outside this boundary are clipped unless clipping is overridden. Must be called prior to graf(), scales(), or box().

Multi-Language Signatures:

Establishes the physical offset of the lower-left corner of the plot area from the bottom-left corner of the canvas page in physical inches.

Allows leaving margins for axes numerical labels, axis titles, and page headings, or positioning multiple separate subplots across a single page.

Multi-Language Signatures:

Translates the current physical origin by relative increments dx, dy.

Useful for stepping through regular grid arrangements of subplots in multi-panel figures without recalculating absolute page coordinates.

Multi-Language Signatures:

Draws a rectangular border enclosing the active 2D plotting area defined by area2d().

Uses current line style, thickness, and color. Must be called after area2d() and physor().

See Also: area2d, pbox

Multi-Language Signatures:

Configures orientation of the physical drawing coordinate system.

0 = Upright / Landscape orientation. 1 = Rotated 90 degrees / Portrait orientation.

Must be called before bgnplot() or startplot().

Multi-Language Signatures:

Selectively disables the rendering of axis lines and/or numeric labels.

Either scales() or graf() must still be called so that GraphiC can calculate data-to-pixel transformation matrices.

Bit 0 (0x01, AXESOFF): Turn all axes and labels off. Bit 1 (0x02, XAXIS): Suppress X-axis line. Bit 2 (0x04, YAXIS): Suppress Y-axis line. Bit 3 (0x08, XLAB): Suppress X-axis numerical labels. Bit 4 (0x10, YLAB): Suppress Y-axis numerical labels. Value 0 (AXESON): All axes and labels visible (default).

Multi-Language Signatures:

Enables an enclosing rectangular frame around the 2D plot area.

Must be called before any axis-generating routines (graf or scales).

Multi-Language Signatures:

Selects between boxed perimeter axes and center-crossed axes.

Multi-Language Signatures:

Sets the intersection coordinates (x, y in data units) where axes intersect.

Rather than binding axes to the left and bottom perimeter of the plot box, CrossAt allows axes to cross at arbitrary values such as (0, 0) for Cartesian graphs. Must be called before graf().

Multi-Language Signatures:

Shifts the position of the entire plot by xshift and yshift inches.

If rotate(1) was invoked, shifts are interpreted relative to the rotated screen coordinate frame.

Multi-Language Signatures:

Global dimensioning routines for axis typography and tick marks:

axnamht(inch): Sets height of axis title labels (xname, yname). Default 0.15 in. tickht(height): Sets physical height of tick marks. Default 0.08 in. titlht(inch): Sets height of plot title string (heading). Default 0.20 in. numht(inch): Sets height of numeric values along axes. Default 0.10 in.

Multi-Language Signatures:

Controls orientation of Y-axis numeric labels.

0 = rotate labels 90 degrees parallel to the Y-axis (default).

Multi-Language Signatures:

Publication legend box builder.

legpos(entries, xleg, yleg, border): Establishes legend box position (xleg, yleg) in physical inches, allocates vertical spacing for entries items, and specifies border outline. legend(marker, string, style, strhgt, scolor): Adds an annotated entry containing a sample line segment of style and color, centered marker symbol, and descriptive text label.

Multi-Language Signatures:

Configures major and fine background grid lines across the 2D plotting box.

grid(gridon): If gridon=1, draws dotted grid lines aligned with major tick marks. fgrid(fon, ndiv): Subdivides each major interval into ndiv sub-grid lines using line style fon. Must be called before graf() or scales().

Multi-Language Signatures:

Controls axis tick mark appearance.

tickout(1): Reverses default inward-pointing ticks to point outward from the plot box. tickht(height): Sets physical length of tick marks in inches (default ~ 0.08 in). Must be called before graf().

Multi-Language Signatures:

Configures fine grid subdivisions intersecting the X or Y axis.

xfgrid(): Subdivides intervals between main X grid lines. yfgrid(): Subdivides intervals between main Y grid lines.

Multi-Language Signatures:

Supplies custom text labels (e.g. month names "Jan", "Feb", categories) for axis tick marks.

When enabled, GraphiC spaces the supplied string labels uniformly along the axis.

Multi-Language Signatures:

Sets descriptive title strings for axes and the overall plot heading.

Labels are centered along their respective axes. In modern GraphiC, strings support full formatting escape codes for superscripts, subscripts, Greek characters, and font switching. Must be called before graf() or scales().

Multi-Language Signatures:

8.4 Simultaneous Plots

Manages independent simultaneous subplots on a single page, context switching, and multi-threaded independent viewports.

Enables simultaneous plotting on multiple independent axes systems.

Allows concurrent rendering of multiple physical perspectives or simulation states within the same overall calculation loop. Subplots are referenced by zero-based index via context(). Calling simuplot(0) terminates simultaneous plotting mode and consolidates all sub-streams into the final output.

Multi-Language Signatures:

Switches the active plotting context to subplot plot_number.

Directs subsequent GraphiC calls (axes, curves, labels, titles) to the coordinate frame, viewport bounds, and scaling factors of the specified subplot. Numbers run consecutively from 0 to (numplots - 1).

Multi-Language Signatures:

Sets coordinate origin mode for compound multi-plot layouts.

When enabled (set_flag = 1), origin shifts performed by physor() or orel() are referenced to the absolute physical page boundary rather than the current subplot boundary.

Multi-Language Signatures:

8.5 2-D Axes Routines

Calibrates linear and logarithmic axes, computes optimum round tick intervals, renders data curves, error bars, and bar charts.

Establishes mathematical user coordinate mapping and draws calibrated 2D axes.

Calculates coordinate transformation matrix converting data values into physical inches and pixel coordinates. Draws tick marks and formatted numerical labels along the X and Y axes according to the provided C printf format specifications.

Multi-Language Signatures:

Automatically inspects data arrays x and y, calculates aesthetically rounded minimum, maximum, and tick step bounds, and invokes graf() automatically.

Multi-Language Signatures:

Calibrates logarithmic coordinate axes.

xlog(): Logarithmic X-axis, linear Y-axis (semi-log). ylog(): Linear X-axis, logarithmic Y-axis (semi-log). loglog(): Logarithmic X-axis and Logarithmic Y-axis (log-log).

Decades are labeled with scientific powers of 10 ($10^{-2}, 10^{-1}, 10^0, 10^1$). Intermediate tick marks (2, 3, 4, 5, 6, 7, 8, 9) are placed automatically.

Multi-Language Signatures:

Scans arrays x and y, calculates min and max values, and rounds outwards to integer powers of 10 to calibrate a log-log coordinate grid.

Multi-Language Signatures:

Plots a 2D data series connecting data coordinates (x[i], y[i]).

Transforms data coordinates through the active calibration matrix into physical drawing commands. Automatically clips polyline segments at the area2d boundary.

sym = 0 : Draw connected line only. sym > 0 : Draw line and place marker symbol every sym points. sym < 0 : Draw marker symbol ONLY (scatter plot) every |sym| points.

Multi-Language Signatures:

Fills the area between curve (x, y) and curve (x1, y1).

If the two curves do not share identical endpoints, GraphiC connects the extremities to form a closed polygon boundary before applying the fill pattern.

Multi-Language Signatures:

Draws error bars centered at (x, y) with horizontal range [xmin, xmax] and vertical range [ymin, ymax]. End tick bars are drawn automatically.

Multi-Language Signatures:

Renders statistical column or bar charts with pattern hatching and color fills.

Renders grouped or segmented bars. Supports custom widths, side-by-side comparisons, and distinct hatch fills per category.

Multi-Language Signatures:

Renders categorized bar charts with custom bar widths and individual colors.

0 = Standard individual bars. 1 = Stacked bars for repeated X positions. 2 = Grouped side-by-side bars for repeated X positions.

Multi-Language Signatures:

Plots a statistical histogram given bin boundaries and frequency counts.

Multi-Language Signatures:

Configures scatter plot marker mode for curve().

When dot=1, passing sym=0 to curve() draws an individual pixel dot at each data point without interconnecting line segments. Passing sym=-1 draws selected glyph symbols at every point without connecting lines.

Multi-Language Signatures:

Renders 2D scatter points with continuous point-by-point colormap shading based on scalar coordinate z without polyline connection artifacts.

Multi-Language Signatures:

Renders continuous linear vector gradient color bar with numerical calibration ticks, border framing, and publication typography.

Multi-Language Signatures:

8.6 Smith Charts

Generates transmission line impedance Smith charts, constant-VSWR circles, normalized resistance/reactance arcs, and electrical wavelength translations.

Draws the complete Smith impedance/admittance chart coordinate system.

Renders constant-resistance circles ($R/Z_0 = 0, 0.2, 0.5, 1.0, 2.0, 5.0$), constant-reactance arcs ($\pm j X/Z_0$), outer unit circumference ($|\Gamma| = 1.0$), and reflection coefficient angle scales in physical vector lines.

Multi-Language Signatures:

Renders impedance or reflection coefficient data onto the active Smith chart.

plotrx(r, x): Plots a normalized impedance point Z = r + j x.

plotrho(rho, theta): Plots a complex reflection coefficient point Γ = |ρ| e^(jθ) (where |ρ| ≤ 1.0).

smove(dell): Draws an arc of constant reflection coefficient |Γ| through an electrical distance dell (in wavelengths).

Multi-Language Signatures:

Steps a distance dell along a uniform transmission line toward the generator or load.

Multi-Language Signatures:

Draws a circle centered at (u, v) with specified radius on the active Smith chart.

Multi-Language Signatures:

8.7 Polar Plots

Draws circular polar grids, radial decibel/linear scales, polar data curves, and angular sectors.

Generates polar coordinate systems and angular plots.

polgrid(...): Draws concentric radial range circles (from rmin to rmax) and radial rays dividing 360 degrees into ntheta angular spokes. polcurve(r, theta, dim, sym): Connects polar points (r[i], theta[i]) where theta is in degrees. wedge(...): Fills a circular wedge bounded by [rmin, rmax] and [thmin, thmax] with pattern.

Multi-Language Signatures:

Plots data points given radial vector r and angular vector theta (in radians).

Multi-Language Signatures:

Fills an annular sector bounded by [rmin, rmax] and angles [thmin, thmax] (in degrees).

Multi-Language Signatures:

8.8 Contour Plots

Calculates 2D isoclines across regularly or irregularly spaced data grids, elevation color coding, contour stacking, and ternary phase diagrams.

Generates and draws contour elevation curves across a regular 2D rectangular grid.

Scans elevation matrix cells, locates isocline crossings via linear interpolation, threads smooth continuous contour lines across adjacent cells, and formats elevation value numbers inline along contour paths according to labint.

0 = no numeric labels, 1 = label every line, 2 = label every 2nd line, etc.

Multi-Language Signatures:

Traces contour isoclines at custom arbitrary elevation thresholds.

Unlike conmat() which steps at uniform intervals, lconmat() accepts an explicit array of arbitrary elevation values, allowing clustered lines near steep gradients.

Multi-Language Signatures:

Configures color-mapped contour rendering and companion legend key.

contcolor(colors, border): Assigns an array of color indices to successive contour levels. ColorKeyL(...): Draws a graduated color scale key rectangle annotated with numeric tick bounds.

Multi-Language Signatures:

Evaluates function fun across a regular grid of nx by ny points and generates smooth interpolated contour lines at the specified elevation levels.

Grid dimensions nx and ny MUST be odd integers for the interpolation algorithm.

The first 2 digits define line style (1-9); the 3rd digit defines color index (1-15). For example, 104 = line style 1 in color 4.

Multi-Language Signatures:

Enables or disables 3D elevation stacking for 2D contour maps.

When stacked=1, subsequent contour maps or workboxes are offset in 3D space according to plane3d calibration, creating multi-tier topographical slices.

Multi-Language Signatures:

8.9 Triangle Plots

Triangle plots provide for the graphic display of an attribute of a three-component mixture. Each component is associated with a vertex. The fraction of that component is plotted on a line parallel to the opposite side. The position of the line is proportionally closer to the vertex depending on the relative amount of the component.

Evaluates mathematical function fun across a triangular coordinate simplex and renders ternary contour lines.

Multi-Language Signatures:

Renders ternary phase diagrams where components satisfy A + B + C = 100%.

trimat(): Generates contour isoclines over a triangular phase space. aname(), bname(), cname(): Sets vertex labels for the three constituent components.

Multi-Language Signatures:

8.10 Three-Dimensional Plots

Renders 3D perspective surface meshes with hidden-line horizon removal, 3D coordinate boxes, space trajectories, and cross-sectional planes.

Sets the physical size of the 3D workbox enclosing the 3D surface plot in inches.

Must be called before graf3d() or vuabs().

Multi-Language Signatures:

Establishes the 3D camera eye viewpoint.

vuabs(xvu, yvu, zvu): Positions observer in scaled 3D coordinate space. vuangl(phi, theta, radius): Positions observer via spherical angles: phi = azimuth angle in X-Y plane (degrees), theta = elevation angle above Z plane (degrees), radius = eye distance factor. view(a, b, c): Positions viewpoint in user data space coordinates.

Multi-Language Signatures:

Draws the 3D coordinate box and sets linear data bounds for X, Y, and Z.

Renders back and front perspective pillars, baseline frames, and tick subdivisions.

Multi-Language Signatures:

Evaluates and draws a 3D perspective surface mesh.

Implements GraphiC's analytical floating horizon algorithm: Traces grid lines from front to back, updating upper and lower horizon profile arrays. Vector segments occluded by foreground peaks are clipped in analytical coordinate space, producing clean vector output without depth-buffering artifacts.

surmat(): 1D row-major array zmat[xdim * ydim]. surmat2(): 2D pointer-to-pointer array zmat[ydim][xdim]. surfun(): Evaluates an analytical C function f(x, y) dynamically.

Multi-Language Signatures:

Evaluates function zfun across an interpolated grid and renders a 3D surface mesh with analytical hidden-line horizon removal.

Multi-Language Signatures:

Configures surface facet visibility and contrasting mesh colors.

survis(str): Selects visible sides: "TOP", "BOTTOM", or "BOTH". nohide(1): Disables hidden-line removal to render a transparent see-through wireframe. tcolor(col): Sets color index for top of surface (e.g. BLUE). bcolor(col): Sets color index for bottom of surface (e.g. RED).

Multi-Language Signatures:

Draws the 3D workbox framework established by graf3d() and view()/vuabs().

See Also: graf3d, vuabs, sclfix

Multi-Language Signatures:

Renders a 3D space curve given coordinate vectors x, y, z.

Multi-Language Signatures:

Configures elevation color coding for 3D surfaces.

Multi-Language Signatures:

Draws a 3D line from (xf, yf, zf) to (xt, yt, zt) in perspective projection.

Multi-Language Signatures:

Typography in 3D coordinate space:

d3head(title, place): Places a caption string relative to the 3D workbox. d3pltfnt(x, y, z, string, height, angle): Plots text at user coordinate (x, y, z).

Multi-Language Signatures:

Controls auto-scaling of the 3D workbox.

When isfixed=1, GraphiC maintains a fixed physical workbox scale across multiple frames even as viewing distance or viewing angles change.

Multi-Language Signatures:

Labels the X, Y, and Z axes of the 3D workbox.

The first character may be a stroke font selector code. Must be called before graf3d().

Multi-Language Signatures:

d3bars(bwid): Configures surface rendering to draw perspective 3D column bars/histograms of normalized width bwid centered on each grid node, rather than a continuous connected wireframe mesh.

Multi-Language Signatures:

plane3d(wplane, pos, hide): Draws an intersecting orthogonal planar cross-section inside the 3D bounding box at position pos along the wplane axis, optionally clipping hidden surface polygons.

Multi-Language Signatures:

d3bars(bwid): Configures surface rendering to draw perspective 3D column bars/histograms of normalized width bwid centered on each grid node, rather than a continuous connected wireframe mesh.

Multi-Language Signatures:

plane3d(wplane, pos, hide): Draws an intersecting orthogonal planar cross-section inside the 3D bounding box at position pos along the wplane axis, optionally clipping hidden surface polygons.

Multi-Language Signatures:

WaterfallCurve(x, y, z, npts): Renders a single discrete spectral curve at baseline position y with amplitude z and hidden-line removal against preceding traces. WaterfallPlot(x, y, z, nx, ny): Renders a complete 2D matrix of ny successive spectral curves staggered along the Y axis, automatically performing hidden-line removal.

Multi-Language Signatures:

8.11 Pie Charts & Statistical Plots

Generates proportional circular pie charts, normal probability error functions, and statistical distribution metrics.

Renders a circular pie chart with optional sector explosion, hatching, and callouts.

Automatically computes percentage wedges from raw input values seg[i], draws radial dividers, applies distinct colors and vector fill patterns, applies radial displacement offsets (offset[i]) to explode highlighted slices, and centers text labels.

Multi-Language Signatures:

Statistical analysis and exploratory data visualization routines. mean(x, xdim): Computes arithmetic mean of data array. median(x, xdim): Computes 50th percentile median value of data array. StdDev(x, xdim): Computes sample standard deviation of data array. BoxPlot(x, y, ydim, outlier, symnum, width): Generates standard Tukey box-and-whisker plot displaying median, quartiles, and outliers.

Multi-Language Signatures:

Normal probability distribution and Gaussian error function calibration subsystem. erfscales(nydiv, y, npts): Calibrates non-linear Gaussian probability vertical scales. erfcurve(x, y, npts, sym): Plots data points along calibrated Gaussian probability curve. erfgrid(ymin, ystep, ymax, yformat): Draws non-linear probability grid tick lines and labels.

Multi-Language Signatures:

8.12 Line-Drawing Routines

Low-level vector graphics primitives for arbitrary lines, circles, ellipses, radial vectors, and customizable arrowheads.

Fundamental two-point straight line drawing primitives. uline() connects coordinates specified in user mathematical data units. linch() connects coordinates in physical inches on the page canvas. line() connects coordinates in device raster pixels. All line segments respect active dash patterns (dashf), stroke width (tline), and color.

Multi-Language Signatures:

Precision scientific vector arrow drawing routines with customizable arrowheads. uvector(xfrom, yfrom, xto, yto, ltow, size, type): Draws vector arrow in user data coordinates. vector(xfrom, yfrom, xto, yto, ltow, size, type): Draws vector arrow in physical page inches.

Multi-Language Signatures:

Draws an ellipse or elliptical arc.

Allows arbitrary center location (xc, yc), semi-major and semi-minor radii (xr, yr), overall orientation tilt angle (rotation), and angular arc span [th1, th2]. fillellipse() sets fill pattern and border color for subsequent ellipse calls.

Multi-Language Signatures:

8.13 Line and Symbol Styles

Renders line styles, dot-dash patterns, line thickening, marker symbols, and custom symbol scales.

Sets stroke pattern for polylines and curves.

type: 0 = Solid line 1 = Short dash 2 = Long dash 3 = Dotted line 4 = Dash-dot 5 = Dash-dot-dot

Multi-Language Signatures:

Selects and renders centered vector marker symbols.

sympick(symbol): Selects active marker glyph: 1 = Circle, 2 = Triangle, 3 = Square, 4 = Diamond, 5 = Star, 6 = Cross (+), 7 = Saltire (X), etc. symbol(x, y, symnum): Draws symbol symnum centered directly at data coordinate (x, y).

Multi-Language Signatures:

Configures line stroke width.

tcurve(width): Sets curve line width in device units (1 = standard, 2 = bold, 3 = heavy). tline(width): Sets general line width for borders, boxes, and axes.

Multi-Language Signatures:

8.14 Color & Palettes

High-precision conversions between RGB, HLS, CMYK, and indexed palette systems.

GraphiC 2026 provides 7 mathematically calibrated, continuous 256-node scientific colormaps: VIRIDIS (0), PLASMA (1), INFERNO (2), MAGMA (3), COOLWARM (4), RAINBOW (5), and TURBO (6). These palettes guarantee perceptual linearity and high aesthetic fidelity across color displays, print publication, and grayscale reproduction.

Figure 7.14: Standard Continuous Scientific Colormaps (VIRIDIS, PLASMA, INFERNO, MAGMA, COOLWARM, RAINBOW, and TURBO).

Active drawing color and TrueColor RGB integer synthesis. color(col): Sets active vector drawing and text stroke color. RGBcolor(r, g, b): Packs red, green, and blue components into 24-bit TrueColor RGB integer (0x01RRGGBB).

Multi-Language Signatures:

Color model transformation and colorimetric conversion routines. RGBtoHLS(r, g, b, &h, &l, &s): Converts RGB color triplet to Hue-Lightness-Saturation color space. HLStoRGB(h, l, s, &r, &g, &b): Converts Hue-Lightness-Saturation values back to Red-Green-Blue intensities. RGBtoCMYK(r, g, b, &c, &m, &y, &k): Converts 24-bit RGB values to 4-color process CMYK printing separations. RGBtoIBM(rgb): Maps 24-bit RGB color to nearest standard 16-color IBM PC palette index.

Multi-Language Signatures:

Evaluates normalized parameter t across the designated scientific colormap, returning packed 24-bit TrueColor RGB integer (0x01RRGGBB).

Multi-Language Signatures:

Queries continuous colormap shading for scalar value in [minv, maxv] in 𝒪(1) time, returning packed 24-bit TrueColor RGB integer (0x01RRGGBB).

Multi-Language Signatures:

Queries continuous colormap shading for scalar value, returning discrete R, G, B color channels (0...255).

Multi-Language Signatures:

Packs individual 8-bit R, G, B channels into GraphiC 24-bit TrueColor integer (0x01RRGGBB).

Multi-Language Signatures:

8.15 Text Routines

TrueType (.ttf), PostScript Type 1 (.pfb), and Hershey vector stroke (.fnt) typography, multi-font inline switching, solid glyph filling, pairwise kerning, and mathematical script shifts.

Multi-engine typography and vector text rendering subsystem. font(nfont, file1, esc1, ...): Registers and loads up to 10 fonts into memory simultaneously. Automatically selects the rendering engine from file extension (.TTF, .PFB, .FNT). pltfnt(x, y, string, height, angle): Renders string at user data coordinates (x, y). prtfnt(xinch, yinch, string, height, angle): Renders string at physical page coordinates (xinch, yinch). fillfont(fill): 0 = hollow vector outline; 1 = solid polygon glyph fill (default for TrueType/PostScript). fontfill(fill, pat, bdr): Fills characters with hatch pattern pat and draws outline in color bdr. tifont(wid) / tfont(wid): Configures stroke pen thickness in physical inches (float) or raster pixels (int). SetTTKerning(onoff, str): Enables/disables TrueType pairwise kerning tables (kern SFNT table). SetTTFull(onoff, str): 1 = full 256-character set (Windows ANSI/Latin-1); 0 = standard 128 ASCII. SetTTMaxError(err, str): Configures Bézier curve subdivision tolerance for smoothness vs speed.

Multi-Language Signatures:

Formatted title and margin text line positioning subsystem. ctline(string, height): Centers text horizontally within the current plot area at the active line position. ltline(string, height): Left-aligns text against the current plot boundary at the active line position. rtline(string, height): Right-aligns text against the right plot boundary at the active line position. strwidth(string, height): Computes exact horizontal advance width of string in physical inches.

Multi-Language Signatures:

Fine typographical styling controls for vector stroke and TrueType fonts. skew(slant): Applies forward italic slant angle transformation to stroked vector characters and TrueType glyphs. widen(fact): Dynamically scales character horizontal advance width and aspect ratio along the baseline without altering vertical font height. supsym(ch): Defines the escape delimiter character triggering superscript mode (default '^' or '['). subsym(ch): Defines the escape delimiter character triggering subscript mode (default '_' or ']').

Multi-Language Signatures:

8.16 Interactive Crosshairs & Digitization

Interactive fullscreen cursor crosshairs with live digital coordinate readout and point digitization.

Enables interactive full-screen crosshair cursor and live digital position readout.

Displays a digital readout on the screen at text row srow, column scol in an 8x10 font. Crosshairs are manipulated via arrow keys or mouse pointer. The readout defaults to user data coordinates. Pressing <Alt-i> switches to physical inches; <Alt-u> returns to user data coordinates.

Marked points (<Enter>) are dynamically recorded into arrays fx and fy.

Interactive Key Controls: <Enter> : Mark point at current crosshair location. <Ins> : Draw line segment from previous point to cursor location. <Del> : Erase last drawn segment. <Alt-1>..<9> : Select line pattern for drawing. <q> or <Esc> : Exit crosshairs and return to program execution.

Axis routines (graf, scales) must be called prior to curson().

Multi-Language Signatures:

Constrains crosshairs to follow an existing discrete data curve (x[i], y[i]).

Arrow keys step forward and backward along the curve index. Digital readout displays exact sampled point values.

Multi-Language Signatures:

8.17 Spline Interpolation & Numerical Methods

Cubic spline interpolation, curvature-constrained smoothing, non-linear regression fitting, and matrix solvers.

Fits a continuous cubic spline curve through input points (x[i], y[i]).

Generates an interpolated smooth curve of n1 densely sampled points (xn, yn). Boundary conditions are controlled by end slope constraints s1 and s2.

Multi-Language Signatures:

Performs iterative robust curve fitting with outlier attenuation.

Uses iteratively reweighted least squares to minimize the influence of experimental outliers and noisy measurement spikes.

Multi-Language Signatures:

High-performance linear equation solver and matrix inversion using Gaussian elimination with partial pivoting.

matsolve(a, n, b): Solves A * x = b. Matrix a is factored in-place and solution vector is returned in b. matinverse(a, y, n): Inverts square matrix a into matrix y.

Multi-Language Signatures:

8.18 Polygons & Panel Filling

Draws filled, hatched, and stippled polygonal regions and panels with 16 vector fill patterns.

Fills arbitrary planar convex or concave polygonal regions with solid colors or vector cross-hatch patterns. panel(x, y, nlines, pcolor, border): Fills polygon specified in floating-point user data coordinates. panelinch(x, y, nlines, pcolor, border): Fills polygon specified in physical page inches.

Multi-Language Signatures:

8.19 Memory, File I/O & Utility Routines

Coordinate conversions (user units to pixels/inches), memory auditing, file management, and terminal control.

High-performance coordinate transformation and spatial mapping pipeline between user data space, physical page inches, and device raster pixel grids. usertopix(x, y, z, &px, &py): Transforms 2D or 3D user data coordinates into discrete device raster pixels. pixtouser(px, py, &x, &y): Maps screen or vector pixel coordinates back to floating-point user data space. usertoinch(x, y, &xi, &yi): Maps floating-point user data coordinates directly to physical page inches. pixtoin(pixels): Converts device raster pixels to physical page inches. intopix(inches): Converts physical inches (or cm) into device pixel quantity.

Multi-Language Signatures:

Computes minimum and maximum extrema across a data array.

Used internally by calibration routines such as graf(), loggraf(), and r3d_contour() to determine optimal axis limits, tick intervals, and contour elevation slices. Non-real IEEE-754 floats (NaN and Inf) are automatically detected and bypassed via IsNotRealFloat(). If an array contains zero valid real numbers, minq is assigned 0.0, maxq is assigned 1.0, and Warning 47 is dispatched.

Multi-Language Signatures:

Configures the interpolation tolerance factor for random point plotting.

When plotting contours or surfaces from scattered, ungridded (x, y, z) observations via r3d_surface() or r3d_contour(), clustering or collinear points can trigger the error: "Too few data points. Try a coarser grid." Increasing tolerance expands the neighborhood acceptance threshold for triangular facet formation, eliminating the error. As tolerance increases, interpolating precision is smoothed across sparse regions.

Multi-Language Signatures:

Clears the text terminal screen and resets console attributes.

In legacy DOS environments, blank(attr) wrote attribute bytes directly to video RAM (0xB800 / 0xB000). In modern POSIX / 64-bit environments, blank() emits standard ANSI escape sequences (\033[2J\033[H) to reset modern terminal emulators cleanly.

Multi-Language Signatures:

Intelligent file open routine with directory search fallback and buffer allocation.

gfopen() locates and opens GraphiC support files (Hershey vector fonts, TrueType fonts, color maps, message tables, and TKF files) using an automated multi-tier search hierarchy: 1. Current working directory of the calling process. 2. Path specified by the GPC or GPC_DIR environment variable. 3. Dynamic binary location discovery: Uses POSIX dladdr() or macOS _NSGetExecutablePath() to resolve the directory containing libgraphic.dylib / libgraphic.so, searching the adjacent ../share/graphic/ and ../fonts/ directories. 4. Standard system installations: /usr/local/share/graphic/, /opt/homebrew/share/graphic/.

If bigbuff is non-zero, gfopen() attaches a high-throughput 12 KB memory buffer (TKBUFFSIZE = 12288 bytes) via setvbuf() to minimize operating system kernel context switches during rapid sequential streaming.

@return [FILE*] Opened standard C file pointer, or NULL on failure.

Multi-Language Signatures:

Section 9. High-Level Modern APIs & Object-Oriented Interfaces Technical Reference (§9.1–§9.5)

9.1 Architectural Overview & Automated Capabilities

While GraphiC’s classic procedural state-machine API gives computational physicists and systems engineers granular micro-control over every coordinate transform, viewport dimension, and tick increment, modern data science and exploratory research in Julia, Python, and Java often require rapid, automated plotting of vectors and matrices in a single line of code. GraphiC provides native high-level interfaces that eliminate repetitive setup boilerplate while preserving full vector SVG fidelity, sub-millisecond execution speeds, and zero runtime dependencies.

Whenever a high-level routine (such as Julia’s GraphiC.plot() or Python’s fig.autoscale()) is invoked, GraphiC executes a deterministic 7-stage pipeline behind the scenes: 1. Automatic Data Bounds & Nice Tick Calibration: Scans input vectors or matrices to extract extrema (min/max) and applies an analytical nice-step algorithm (
$1, 2, 2.5, 5 \times 10^k$

). This guarantees clean, human-readable axis tick marks without requiring manual graf() math. 2. Viewport Geometry & Canvas Centering: Calculates centered physical dimensions (area2d) and offsets (physor) relative to page dimensions, guaranteeing that title headings, numeric labels, and axis names never clip or collide with canvas boundaries. 3. Tight SVG Bounding-Box Cropping: Automatically issues svgcrop(0.25) so emitted SVG vector files hug the drawn figure with an exact 0.25-inch padding margin. Generated plots drop directly into Microsoft Word, LaTeX documents, or web pages without requiring inkscape or external PDF crop utilities. 4. Smart Resolvers for Colors, Styles & Markers: Translates intuitive language Symbols or strings (:blue, :dashed, :circle, "#003366", 0xRRGGBB) directly into native palette indices and stroke tables. 5. Deterministic Session Lifecycle Management: Automatically sequences bgnplot
$\to$

page
$\to$

startplot
$\to$

box
$\to$

graf
$\to$

curve
$\to$

endplot
$\to$

stopplot inside a single protected call or context manager. 6. Rich Inline Display in Notebooks & IDEs: Implements native MIME"image/svg+xml" display hooks for instantaneous vector rendering inside Jupyter Notebooks, Pluto.jl, and VS Code interactive windows. 7. Dual Desktop Display Strategy: Emits resolution-independent vector SVG for publication alongside a companion interactive HTML viewer supporting mouse-wheel zoom, drag-to-pan, and instant live auto-refresh.

---

High-Level API Edition Availability Matrix (§9.1)

The following matrix outlines the functional scope and availability of GraphiC’s high-level modern APIs across the free GraphiC 2D Community Edition and GraphiC Professional. Every plot type and visualization routine is backed by GraphiC’s universal C engine and is available across All supported languages (C, Modern Fortran, Python 3, Java 22, and Julia). Language-specific syntax entries (such as context managers and 1-line auto-finalization) are explicitly noted where language idioms apply:

9.2 Julia High-Level & Multi-Series API Reference (GraphiC.jl)

The Julia package (GraphiC.jl) exports both single-line convenience routines and an incremental multi-series figure API designed for scientific researchers. Each plotting routine returns a Figure object (aliased to PlotOutput for full backwards compatibility) that holds the series list, layout attributes, renders inline in notebooks, and writes vector SVG.

GraphiC.plot(x, y; kwargs...) — 2D Cartesian Vector Plot & Base Figure

Generates a complete 2D Cartesian vector plot from coordinate vectors x and y. When called without an existing figure, it initializes a new Figure.

GraphiC.plot!(fig, x, y; kwargs...) & GraphiC.plot!(x, y; kwargs...) — Multi-Series Curves

Adds an additional curve series to an existing Figure. If fig is omitted, it adds the series to GraphiC.current_figure(). Axis ranges and bounds automatically expand to accommodate the union of all series extrema, and the legend is updated automatically.

GraphiC.scatter(x, y; symbol=:circle, color=:blue, kwargs...)

Specialized 1-line scatter plot. Equivalent to plot(x, y; ltype=-1, symbol=symbol, color=color, kwargs...) with no connecting lines between data points.

GraphiC.scatter!(fig, x, y; kwargs...) & GraphiC.scatter!(x, y; kwargs...)

Overlays discrete scatter marker points on an existing figure without connecting lines.

GraphiC.savefig(fig, filename) & GraphiC.savefig(filename)

Exports the figure to a crisp, standalone vector SVG file. Automatically tight-crops with bounding margins.

GraphiC.surface_plot(z; kwargs...) — 3D Perspective Wireframe Surface

Renders a 3D perspective wireframe mesh with hidden-line removal directly from a 2D Julia matrix z.

GraphiC.contour_plot(z; kwargs...) — 2D Topographic Contour Map

Generates a 2D topographic elevation contour map directly from a 2D Julia matrix z.

Julia Companion Interactive Utilities

• GraphiC.svgopen(filepath=nothing): Dispatches your operating system’s native application launcher (open on macOS, start on Windows, xdg-open on Linux) to open the interactive companion HTML viewer with pan/zoom controls.
• GraphiC.svgpush(url=nothing, filepath=nothing): Transmits a hot-reloading push notification to an active browser canvas, refreshing the plot without requiring manual page reloads.

using GraphiC

# Multi-Series Plot with Automatic Legends and Explicit Limits
x = range(0.0, 10.0, length=100)
fig = GraphiC.plot(x, sin.(x);
    title="Harmonic Oscillator Waveforms",
    xlabel="Time (s)",
    ylabel="Amplitude",
    label="sin(x)",
    color=:blue,
    thick=1.5,
    xlims=(0.0, 10.0),
    ylims=(-1.2, 1.2),
    grid=true
)

# Overlay second curve
GraphiC.plot!(fig, x, cos.(x);
    label="cos(x)",
    color=:red,
    ltype=:dashed
)

# Overlay discrete experimental scatter points
GraphiC.scatter!(fig, [1.5, 3.0, 4.5, 6.0, 7.5], [0.99, -0.98, -0.21, 0.96, 0.35];
    label="Measured Data",
    color=:magenta,
    symbol=:circle
)

# Export publication-quality vector SVG
GraphiC.savefig(fig, "harmonic_comparison.svg")

---

9.2.1 Plots.jl Ecosystem Integration (Plots.jl Backend)

For researchers whose workflows leverage Julia’s premier metapackage Plots.jl, GraphiC.jl includes a zero-overhead package extension (GraphiCPlotsExt.jl, active on Julia 1.9+). This extension registers GraphiCBackend into Plots.jl, allowing standard Plots commands to delegate all 2D vector path drawing, line styles, marker symbols, and subplots to GraphiC’s high-speed C engine.

Activating the GraphiC Backend in Plots.jl

using Plots
import GraphiC: graphic   # or using GraphiC

# Activate the GraphiC zero-latency vector C engine backend
graphic()

# Standard idiomatic Plots.jl pipeline
x = range(0, 2π, length=100)
p = plot(x, sin.(x), label="sin(x)", color=:blue, lw=2, title="Plots.jl via GraphiC")
plot!(p, x, cos.(x), label="cos(x)", color=:red, linestyle=:dash)
scatter!(p, [1.0, 2.0, 3.0, 4.0], [0.84, 0.91, 0.14, -0.75], label="Data", color=:green)

# Generates native, zero-latency vector SVG
savefig(p, "plots_graphic_output.svg")

Key Capabilities in Plots.jl Mode:

1. Zero Runtime Latency: Direct FFI rendering to standalone SVG without external Node.js, Electron, or Python processes.
2. TrueColor 24-Bit Color Mapping: Seamless conversion of Plots RGBA and Colorant values to GraphiC’s native TrueColor format (0x01RRGGBB).
3. Full Line & Symbol Parity: Transparent translation of Plots :solid, :dash, :dot, and marker shapes (:circle, :rect, :diamond, :cross) to native GraphiC vector routines.
4. Subplot Layouts: Automatic grid and multi-panel coordinate scaling across subplots.
5. Upstream Contribution Files: Full upstream PR files for direct inclusion in JuliaPlots/Plots.jl/src/backends/graphic.jl are maintained in contrib/Plots_jl_backend/.

---

9.2.2 Makie.jl Ecosystem Integration (Makie.jl Vector Backend)

For researchers and data scientists leveraging Makie.jl—Julia’s premier, high-performance data visualization ecosystem—GraphiC.jl includes a dedicated, zero-overhead package extension (GraphiCMakieExt.jl, active on Julia 1.9+).

While Makie includes CairoMakie (2D vector/raster) and GLMakie/WGLMakie (OpenGL/WebGL 3D rasterizers), it has lacked a dedicated vector backend that produces true analytic hidden-line removal for 3D surfaces and mathematical wireframes. The GraphiCMakieExt extension registers GraphiC’s vector engine directly into Makie’s MakieScreen pipeline, enabling standard Makie recipes (lines, scatter, contour, and surface) to output compact, infinite-resolution vector SVGs with analytic horizon suppression.

Activating the GraphiC Vector Screen in Makie.jl

using Makie
import GraphiC: graphic_makie   # or GraphiC.activate_makie()

# Set GraphiC as the active Makie vector backend
graphic_makie()

# Standard idiomatic Makie 2D workflow
x = range(0, 10, length=100)
fig, ax, plt = lines(x, sin.(x); color=:blue, linewidth=2)
scatter!(ax, [2.0, 4.0, 6.0, 8.0], [0.91, -0.76, -0.28, 0.99]; color=:red, markersize=8)

# Save crisp vector SVG via GraphiC C engine
save("makie_vector.svg", fig)

3D Perspective Surfaces with Analytic Hidden-Line Removal

using Makie
import GraphiC: graphic_makie

graphic_makie()

# 3D Bessel / Sinc Surface Mesh
x = range(-3, 3, length=30)
y = range(-3, 3, length=30)
z = [sin(sqrt(xi^2 + yi^2)) for xi in x, yi in y]

fig = Figure()
ax = Axis3(fig[1, 1], title="3D Perspective Surface")
surface!(ax, x, y, z; colormap=:viridis)

# Outputs publication-grade SVG with analytic hidden-surface suppression
save("makie_surface.svg", fig)

Key Capabilities in Makie Mode:

1. True Analytic Hidden-Line Removal for 3D Surfaces: Unlike OpenGL z-buffers or painter’s algorithm triangles that explode SVG file sizes with tens of thousands of fragmented facets, GraphiC computes exact analytical horizon curves, yielding compact, razor-sharp vector SVGs suitable for publication.
2. Zero Overhead & Zero Mandatory Dependencies: Makie is declared as a weak dependency ([weakdeps]) under Julia 1.9+ package extensions. If Makie is not imported, GraphiC.jl incurs zero load-time overhead and zero additional memory footprint.
3. Pluto, Jupyter & IDE Integration: Automatically hooks into Makie.backend_show and Makie.colorbuffer, displaying vector SVGs directly inline in Pluto.jl notebooks, Jupyter, and VS Code.
4. Transparent Attribute Translation: Automatically unwraps Makie.Observables and maps Makie colors (Colorant, RGBA, hex), line widths, line styles (:dash, :dot), marker symbols, and colormaps (:viridis, :plasma, :inferno, :coolwarm, :turbo) to native GraphiC C primitives.

---

9.3 Python 3 Object-Oriented & Context-Manager Reference (graphic.Figure)

The Python package (python/graphic/figure.py) exposes the Figure class. Figure wraps GraphiC’s C engine inside a Python context manager, guaranteeing automatic resource finalization (endplot
$\to$

stopplot) and rich vector display in Jupyter notebooks.

Figure Constructor & Context Manager

Figure(width=8.0, height=6.0, bgcolor='white', tkf_name='graphic_plot.tkf', background=None, output_path=None)

Figure Core Methods Reference

import numpy as np
from graphic import Figure, BLUE, SOLID

x = np.linspace(0.0, 10.0, 150)
y = np.exp(-0.2 * x) * np.cos(2.0 * x)

# Automatic session lifecycle with context manager
with Figure(8.0, 6.0, bgcolor='white', output_path='py_oscillator.svg') as fig:
    fig.heading('Damped Harmonic Oscillator')
    fig.xlabel('Time (seconds)')
    fig.ylabel('Amplitude (volts)')
    fig.autoscale(x, y)
    fig.box()
    fig.color(BLUE)
    fig.curve(x, y, line_type=SOLID)

---

9.4 Java 22 Foreign Function & Memory High-Level API (com.sciend.graphic.Figure)

The Java 22 package (java/src/main/java/com/sciend/graphic/Figure.java) leverages Project Panama Foreign Function & Memory (FFM) APIs to provide zero-overhead native C interop. Figure implements AutoCloseable, enabling deterministic cleanup via standard try-with-resources blocks.

import com.sciend.graphic.Figure;
import com.sciend.graphic.Color;
import com.sciend.graphic.LineStyle;

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]) * Math.exp(-0.1f * x[i]));
}

try (Figure fig = new Figure(8.0f, 6.0f, Color.WHITE, "java_plot.svg")) {
    fig.heading("Damped Waveform");
    fig.autoscale(x, y);
    fig.box();
    fig.plot(x, y, Color.BLUE, LineStyle.SOLID);
}

---

9.5 Modern Fortran 2003/2018 Module Reference (graphic.f90)

The Modern Fortran module (fortran/src/graphic.f90) exposes type-safe subroutines with automatic null-termination of Fortran strings (trim(str) // c_null_char) and standard array shape binding:

program test_modern_graphic
  use graphic
  implicit none
  real, dimension(100) :: x, y
  integer :: i

  do i = 1, 100
    x(i) = real(i - 1) * 0.1
    y(i) = sin(x(i)) * exp(-0.1 * x(i))
  end do

  call gpc_begin(1, 'S', 'fortran_plot.svg')
  call gpc_page(8.0, 6.0)
  call gpc_startplot(COLOR_WHITE)
  call gpc_svgcrop(0.25)
  call gpc_area2d(6.0, 4.2)
  call gpc_physor(1.2, 1.1)
  call gpc_box()
  call gpc_title('Fortran Damped Wave', 'Time (s)', 'Amplitude (V)')
  call gpc_graf('%3.1f', 0.0, 2.0, 10.0, '%3.1f', -1.0, 0.5, 1.0)
  call gpc_color(COLOR_BLUE)
  call gpc_curve(x, y, 100, STYLE_SOLID)
  call gpc_endplot()
  call gpc_stopplot()
end program test_modern_graphic