I am pleased to announce **GraphiC.jl**, bringing the **GraphiC 2026** scientific graphics engine natively to the Julia language.

GraphiC was originally developed for research computing and fusion energy visualization at Oak Ridge National Laboratory (ORNL). In 2026, it has been modernized with a 64-bit C99 vector core, interactive SVG/HTML driver, and zero-overhead `ccall` bindings for Julia.

### Key Highlights

* **Zero Compilation Latency**: Instantaneous execution with sub-millisecond time-to-first-plot.

* **Pure Vector SVG**: Tightly cropped vector graphics with infinite resolution scaling and interactive web zooming.

* **Dual API Paradigm**:

1. *High-level 1-line plotting*: `GraphiC.plot()`, `GraphiC.scatter()`, `GraphiC.surface_plot()`, `GraphiC.contour_plot()`

2. *Procedural state-machine API*: 1:1 parity with classic C and Fortran GraphiC scientific routines.

* **Specialized Visualizations**: True 3D hidden-line surface meshes, contour topography, polar antenna diagrams, vector fields, and RF/microwave Smith charts.

* **Seamless Notebook Integration**: First-class MIME support renders vector graphics inline in Jupyter, Pluto.jl, and VS Code.

### Quick Example

```julia

using GraphiC

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

y = exp.(-0.2 * x) .* sin.(x)

GraphiC.plot(x, y;

title="Damped Harmonic Oscillator",

xlabel="Time (s)",

ylabel="Amplitude",

color=:blue,

grid=true,

filename="oscillator.svg"

)

Manual, documentation, and Community Edition downloads are available at: https://jamesrome.com/GraphiC2026

Feedback, suggestions, and benchmarks from the Julia scientific community are warmly welcome!

Hi everyone,

Following up on our earlier discussion about modernizing GraphiC (the lightweight scientific plotting engine originally developed at Oak Ridge National Laboratory and Scientific Endeavors Corp), we wanted to share a major progress update, architectural changes based on community feedback, and the release of GraphiC v7.3.0.

The core design philosophy remains unchanged: zero external dependencies (pure standard libc/libm—no Qt, OpenGL, X11, Cairo, or FreeType), sub-2ms cold-start latency, and an ultralight footprint (~655 KB static library) capable of rendering thousands of publication-grade figures per minute directly in-process from simulation codes.

Here is what's new in the latest release:

1. Simplified Standalone Distribution (No Git / Token Friction)

Based on feedback regarding external git dependencies and token management in commercial/academic environments, we have eliminated external Git dependency requirements:

• Standalone ZIP Archives: Both the free GraphiC 2D Community Edition and GraphiC Professional are distributed as self-contained downloadable ZIP archives.
• Local Repo Freedom: Unpack it into your workspace or project tree. Users can initialize their own internal Git repositories if desired without worrying about remote access tokens, submodules, or network firewalls on compute clusters.

2. Native Fortran Package Manager (fpm) Integration

For the computational Fortran community, integrating GraphiC into modern fpm projects is now a 2-line configuration:

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

• Automated Mixed-Language Builds: fpm automatically compiles both the core C engine and the Modern Fortran 2003 ISO_C_BINDING module together—Fortran users do not need to run a C compiler manually or write build glue.
• Broad Compiler Support: Out-of-the-box compatibility tested across GNU gfortran (4.8+), Intel oneAPI (ifx and ifort), LLVM flang, NVIDIA HPC SDK (nvfortran), and NAG (nagfor).
• Instant Execution: Run included scientific examples immediately with:bashexport GPC_NONINTERACTIVE=1 fpm run --example sample fpm run --example bess3d

3. Continuous TrueColor Scientific Colormaps

Vector plots can have perceptually continuous shading due to our adoption of the SVG format. We have added 7 mathematically calibrated, continuous 256-node colormaps designed for perceptual uniformity across displays, print, and grayscale reproduction:

• Perceptually Uniform: VIRIDIS (0), PLASMA (1), INFERNO (2), MAGMA (3).
• Diverging & Spectral: COOLWARM (4), RAINBOW (5), and Google TURBO (6).
• O(1)O(1)O(1) Fast Evaluation: High-throughput scalar-to-color mapping (gpc_get_color, gpc_colormap_eval) and continuous high-density scatter plotting (gpc_scatter).
• Linear Vector Gradient Color Bars (ColorKeyGradient): Emits hardware-accelerated SVG <linearGradient> definitions with calibrated numerical tick labels and bounding frames.
• Turbulence Showcase: Added shaded graduated color test plot rendering 7,850 experimental points shaded by density.

4. True 4-Way Language Parity (C, Fortran 2003, Python 3, Java 22 FFM)

Every routine in the library now features 100% signature and parameter parity across all 4 supported languages:

• C / C++: Clean ANSI C API with unified headers (graphic.h).
• Modern Fortran: Strict ISO_C_BINDING modules (graphic.f90, graphic_iso.f90) with type-safe interfaces and array descriptors.
• Python 3: Both procedural and object-oriented Figure APIs with Jupyter Notebook inline display and automatic context manager cleanup (with Figure(...) as fig:).
• Java 22+: Modern Foreign Function & Memory (FFM / Project Panama) API—direct zero-overhead off-heap calls without JNI boilerplate.

5. Smart Vector Output, Auto-Cropping & Telemetry

• SVG Auto-Cropping (svgcrop): Automatically calculates tight vector bounding boxes with a default 0.25" publication margin, eliminating oversized 8.5"×11" white space when embedding figures into LaTeX or papers.
• Desktop Auto-Preview (svgopen): Native OS dispatch (open on macOS, start on Windows, xdg-open on Linux) to view rendered SVG or interactive pan/zoom HTML5 plots.
• Headless Telemetry Streaming (svgpush): Directly streams rendered SVG payloads to remote dashboards or cloud compute endpoints over HTTP/HTTPS POST—ideal for headless clusters and IoT monitoring.

6. 263-Page Reconstructed Technical Manual

We completed a major overhaul of the reference manual (available as a clean vector PDF):

• 91-Section Table of Contents: 100% clickable internal hyperlinking in all PDF viewers.
• 203-Function Master Index: Every routine cross-referenced with operational level, source mapping, and multi-language parity status.
• 26 Visual Computational Recipes: Step-by-step recipes covering aerospace queuing models, orbital trajectories, 3D Bessel surfaces, contour projections, and spectral waterfall plots.
• Publication Architecture Diagrams: High-resolution vector diagrams detailing the dual typography pipeline (Hershey stroke fonts + TrueType quadratic Bézier engine).

Quick Comparison: Community vs. Professional

Feature	2D Community Edition (Free / Open Core)	Professional Edition (Commercial)
License	Standalone Free Archive	Commercial Single-Seat / OEM
Core 2D Plotting	Full (Linear, Log, Polar, Bar, Pie, Histograms)	Full (Linear, Log, Polar, Bar, Pie, Histograms)
Typography	23 Hershey Vector Fonts + TrueType Bézier Engine	23 Hershey Vector Fonts + TrueType Bézier Engine
Continuous Colormaps	Viridis, Plasma, Inferno, Magma, Turbo, etc.	Viridis, Plasma, Inferno, Magma, Turbo, etc.
Language Bindings	C, Modern Fortran, Python 3, Java 22 FFM	C, Modern Fortran, Python 3, Java 22 FFM
Build Systems	fpm, CMake, GNU Make, MSVC Makefile	fpm, CMake, GNU Make, MSVC Makefile
Advanced 3D & Contours	—	3D Hidden-Surface Meshes, Contours, Cross-Sections
Specialized Engineering	—	RF Smith Charts, Ternary Phase Diagrams, Waterfall Plots

Quick Modern Fortran Example (fpm)

fortranprogram quickstart
  use graphic
  implicit none
  real, dimension(100) :: x, y
  integer :: i
  do i = 1, 100
    x(i) = (i - 1) * 0.1
    y(i) = sin(x(i)) * exp(-x(i) * 0.1)
  end do
  call gpc_bgnplot()
  call gpc_svgcrop(0.25)
  call gpc_title("Damped Harmonic Motion", "Time (s)", "Amplitude (V)")
  call gpc_graf("0 2 10", 0.0, 2.0, 10.0, "-1 0.5 1", -1.0, 0.5, 1.0)
  call gpc_color(1)      ! Blue
  call gpc_curv(x, y, 100)
  call gpc_endplot()
  call gpc_svgopen("")   ! Launches default browser to view vector SVG
end program quickstart

Getting the Release

• Official Website & Docs: https://jamesrome.com/GraphiC2026
• Full Technical Manual: Download the 263-page GraphiC_Modern_Manual.pdf
• Community Edition Download: Free standalone ZIP available on the site.
• Professional Edition: Available via Lemon Squeezy with full 3D, specialized engineering modules, and more customization options.

We'd love to hear your feedback on the fpm workflow, language bindings, or any visualization bottlenecks in your current simulation pipelines!

Thank you to everyone for the thoughtful discussion on headless plotting, HPC bandwidth, and licensing. Based on community feedback, I have rolled out two major updates to GraphiC 2026:
### 1. Native `fpm` (Fortran Package Manager) Support
Modern Fortran users no longer need to deal with custom Makefiles or linker configurations. GraphiC now includes a root `fpm.toml`. You can build and test immediately:
```bash
fpm build
fpm run --example sample   # 2D Cartesian plotting
fpm run --example d3test   # 3D surface mesh demo

All 19 Fortran examples are fully wired to fpm run --example <name>.

2. Free 2D Community Edition

For those who asked about an evaluation or open-access tier to experiment with sub-millisecond in-situ plotting:

• Download ZIP (Free): https://jamesrome.com/download/release/GraphiC_2D_Community.zip
• Includes the complete 2D engine (linear/log/polar axes, error bars, curve fitting, SVG/HTML export, C/Fortran/Python/Java bindings, and TrueType fonts).

3. Updated 233-Page Reference Manual (PDF)

A newly compiled edition of the manual is live, featuring Section 3: Platform Overview & Deployment Guide (covering Linux clusters, headless simulation loops, Windows, macOS, and the new fpm workflow):
https://jamesrome.com/download/release/GraphiC_Manual.pdf

Main project page and interactive gallery:
https://jamesrome.com/GraphiC2026

— James Rome, Sc.D., Oak Ridge, TN
Co-founder, Scientific Endeavors Corp. (defunct)

In the early 1980s, when personal computers first appeared, my colleague George Kelley and I were plasma physicists studying nuclear fusion. Mainframes had packages like DISSPLA™, but desktop PCs had primitive graphics and zero tools for publication-grade scientific plots. To solve this, we founded Scientific Endeavors Corporation and created GraphiC, an independent procedural graphics library designed for research workstations.

Over the past year, I have completely modernized the engine for modern 64-bit platforms (GraphiC 2026), targeting Modern Fortran (2003/2008 with iso_c_binding), C99/C11, Python 3, and Java 22.

During the rewrite, several design decisions from the 1980s proved to be surprisingly relevant to modern HPC and headless simulation bottlenecks:

1. The Headless Simulation Bottleneck

Many scientific codes run on cluster compute nodes without X11, Wayland, or GPU access. Typical modern workflows often shell out to Python/Matplotlib via pipes or CLI calls. While Matplotlib is expressive, it carries a ~350 ms cold-start penalty and a 300+ MB dependency stack (NumPy, FreeType, Pillow, GUI backends). If you are running an iterative solver and want to dump an in-situ diagnostic plot every few time steps, this latency becomes a noticeable bottleneck.

GraphiC was built with zero external runtime dependencies—it compiles purely with standard C headers and links against only -lm. Cold start is under 2 milliseconds, allowing it to be called directly inside MPI loops without disturbing compute throughput.

2. Algorithmic 3D Hidden-Line Removal vs. Z-Buffers

Most modern 3D plotting relies on OpenGL/Vulkan z-buffering or painter’s algorithm sorting. For publication vector output (SVG/EPS), polygon sorting often creates sorting artifacts, intersecting edge cracks, and bloated vector file sizes.

GraphiC uses an exact 2D horizon-matching algorithm (Wright's mathematical horizon method) for 3D meshes:

• It computes silhouettes and mathematical horizons across lines rather than rasterizing triangles.
• The output is clean, resolution-independent vector lines with true occlusion, resulting in tiny SVG files (~50 KB) that scale infinitely for journal papers.

3. Native Vector Typography & Hershey Fonts

To completely eliminate dependencies on system font servers or FreeType, the library includes 23 vector Hershey stroke font plates (including Greek, Math symbols, Gothic, and Cyrillic) along with native TrueType parsing. Because vector glyphs are rendered directly as strokes, text scales perfectly across all vector backends without missing glyph warnings.

4. Specialized Engineering Coordinates

Beyond standard Cartesian, log, and semilog plots, scientific work often needs specialized coordinate transformations that are cumbersome to implement from scratch:

• RF Microwave Smith charts (reflection coefficients and impedance circles)
• Chemical ternary equilibrium phase diagrams
• Multi-axis independent Y scales
• 2D velocity vector fields and cylindrical Bessel functions

5. Real-Time In-Situ Plotting

Because the rendering pipeline has virtually zero latency, GraphiC can display live data streams across multiple plots concurrently as they are computed. Rather than waiting for a job to finish before inspecting output files, you can watch solver states in real time—enabling you to abort diverging runs early and debug boundary conditions on the fly.

I’ve put together an interactive showcase of the SVG outputs, compiler benchmarks, and made the complete 190-page technical User Manual freely downloadable for anyone interested in the algorithms, coordinate systems, and API design:

🔗 Technical Overview & Free Manual: https://jamesrome.com/GraphiC2026

I would be interested to hear from other computational scientists: How do you currently handle in-situ visualization or vector figure generation directly from headless compute nodes?

(Full disclosure: I am the original co-author and developed this modernized release.)

Like many homeowners, I wanted to document my household items for insurance coverage in case of a fire or disaster. But taking hundreds of photos, renaming files, creating spreadsheets, and estimating prices manually takes days, if not weeks.

I built AI Home Inventory to automate the tedious parts.

How it works:

1. You point the app to a folder of photos, or use your Android device to take photos.
2. It automatically clusters photos by timestamp (so multiple photos of the same chair or TV are grouped as one object).
3. It uses Gemini/Claude/ChatGPT to identify the items, write description details, estimate replacement values, and document how it arrived at the figure.
4. It exports everything into a clean, formatted Excel spreadsheet.

Privacy First: Because home data is highly sensitive, the app stores the database file (.json) locally inside your room folder, performs image conversions on-disk, and encrypts API credentials using Electron's native safeStorage Keychain APIs.

See https://jamesrome.com/ai-home-inventory for more details.

I need 20 testers to get this approved for the Play Store, so I made a Google Group:
https://groups.google.com/g/ai-home-inventory-by-jar

Please join and get the unlocked app for free.

You will need to get an API key. https://jamesrome.com/aiengines

You can get a free key from Google, but it is rate limited.

https://preview.redd.it/e1i6gwzx61fh1.png?width=2404&format=png&auto=webp&s=ded698ada44c98a73043303d1df29a52feeefcc6

https://preview.redd.it/yo1l7wb371fh1.png?width=2404&format=png&auto=webp&s=4a84f75b0e019b9ebd7f398a67b490574c476828