pyKurucz: A Pure Python Reimplementation of Kurucz SYNTHE for Stellar Spectrum Synthesis

The paper introduces pyKurucz, a pure Python reimplementation of the legacy Fortran SYNTHE code for stellar spectrum synthesis that achieves sub-0.01% agreement with the original while enabling modern integration with machine learning workflows and ensuring long-term maintainability.

The Gist

Imagine you are trying to predict exactly what a star looks like through a telescope. You know the star's temperature, how heavy its gravity is, and what chemicals it's made of. But to turn those numbers into a picture of light, you need a massive, complex machine that simulates how light travels through the star's atmosphere, bouncing off atoms and getting absorbed by gases.

For decades, the "gold standard" machine for doing this has been a piece of software called SYNTHE, written by the legendary astronomer Robert Kurucz. However, there's a catch: SYNTHE was written in a very old, obscure computer language (Fortran) from the 1970s. It's like finding a brilliant, working engine from a 1950s car, but the instructions are written in a dead language, the parts are rusted, and no modern mechanic knows how to fix it. When Robert Kurucz passed away in 2025, the fear was that this vital tool might be lost to history.

Enter pyKurucz.

This new paper introduces pyKurucz, a project that has taken that ancient, rusty engine and rebuilt it from scratch using modern, easy-to-read tools (Python). It's not just a wrapper that hides the old code; it's a faithful, line-by-line translation that does the exact same math, just in a language modern scientists can actually use.

Here is how it works, broken down with some everyday analogies:

1. The Recipe Book (The Physics)

Think of a star's atmosphere as a giant, multi-layered soup. To know what light escapes from the top, you need to know how "cloudy" (opaque) every layer of the soup is.

• The Ingredients: The code checks for everything that blocks light: hydrogen, helium, metals, and even tiny dust-like particles.
• The Line List: Imagine a library with 1.3 million books (atomic transitions). For every single color of light the code is calculating, it checks this library to see if any "books" (atoms) are absorbing that specific color.
• The Math: It calculates how much the light gets blurred by heat (like a hot air shimmer) and pressure (like a crowded room).

2. The Light Traveler (Radiative Transfer)

Once the code knows how cloudy the soup is, it has to simulate a photon (a particle of light) trying to escape the star.

• The code uses a solver called JOSH (a nod to the original Fortran routine). Think of JOSH as a very patient hiker walking up a mountain (the star's atmosphere). At every step, the hiker checks the terrain, calculates how much light is lost or gained, and keeps moving until they reach the top and can finally see the star's light.

3. Why Do We Need This? (The "Statement of Need")

Why go through the trouble of rewriting it?

• The "Black Box" Problem: The original Fortran code is a "black box." It works, but it's hard to open, fix, or connect to modern tools. It's like having a calculator that only works if you press a specific sequence of buttons you found in a dusty manual.
• The Future: Modern science is moving toward Artificial Intelligence (AI) and machine learning. You can't easily teach an AI to drive a car if the steering wheel is made of wood and the engine requires a hammer to start. pyKurucz turns the engine into a digital, programmable electric motor. Now, scientists can plug it directly into AI systems to train them, or tweak the physics instantly without needing a compiler.

4. Did It Work? (The Validation)

The authors didn't just guess; they tested it rigorously.

• They took 100 different types of stars (from cool, red giants to hot, blue O-stars) and ran the new Python code alongside the old Fortran code.
• The Result: The two codes agreed almost perfectly. The difference was less than 0.01%. It's like two master chefs following the same recipe; one uses a 1970s oven and the other uses a modern smart oven, but the cake comes out tasting exactly the same.

5. The Role of AI in Making It

Here is the most interesting twist: AI helped build the AI-friendly code.
The original Fortran code was so messy and old that even human experts struggled to read it. The authors used a powerful AI (Anthropic's Claude) to help translate the code.

• Think of it like this: The original code was a tangled ball of yarn in a dark room. The human authors were the guides, and the AI was a pair of super-powered hands that could untangle the knots. It wasn't magic; the humans still had to check every knot, but the AI made the impossible task possible for a small team.

Summary

pyKurucz is a rescue mission. It saves the most important tool in stellar astronomy from becoming obsolete. By translating it into modern Python, it ensures that:

1. Preservation: The knowledge of how stars shine is saved forever in a readable format.
2. Innovation: Scientists can now mix this classic physics with modern AI to discover new things about the universe.
3. Accessibility: Anyone with a laptop can now run these complex simulations without needing a specialized, ancient computer setup.

It is a bridge between the golden age of 20th-century astronomy and the AI-driven future of the 21st century.

Technical Summary

Based on the provided paper, here is a detailed technical summary of pyKurucz:

1. Problem Statement

Stellar spectrum synthesis is a cornerstone of astrophysics, used to derive stellar parameters (temperature, gravity, chemical composition) from observed spectra. For decades, Kurucz's SYNTHE code has been the standard tool for this task. However, the original implementation faces critical challenges:

• Legacy Code Issues: Written in a pre-Fortran-77 dialect with fixed-format source, single-character variables, computed GOTOs, and EQUIVALENCE statements.
• Maintenance Crisis: The code is incompatible with modern compilers (e.g., gfortran) without extensive manual patching. Following the death of Robert L. Kurucz in 2025, the long-term maintenance of this critical infrastructure is uncertain.
• Workflow Incompatibility: The Fortran-based ecosystem lacks native integration with modern Python-based data science, machine learning (ML), and differentiable programming workflows.
• Installation Barriers: Cross-platform installation requires complex Fortran toolchains, hindering adoption in diverse research environments.

2. Methodology

pyKurucz is a pure Python reimplementation of the SYNTHE spectrum synthesis code. It is not a wrapper around the Fortran binary but a line-by-line translation validated against the original ground truth.

• Architecture: The synthe_py package is organized into three layers:
  • I/O Layer: Handles loading Kurucz-format .atm model atmospheres, parsing GFALL atomic line catalogs, and exporting spectra.
  • Physics Layer: Implements the core physics, including:
    • Continuous Opacity: Interpolated from pre-tabulated arrays (KAPP logic) covering H⁻ absorption, hydrogen bound-free (Karsas & Latter), helium, metals, Rayleigh, and Thomson scattering.
    • Line Opacity: Calculates Voigt profiles for ~1.3 million atomic transitions (thermal Doppler + pressure broadening). Specialized routines handle Hydrogen Balmer/Lyman lines (HPROF4 with Holtsmark ion microfield theory) and Helium lines (BCS/Griem/Dimitrijević).
    • Population Calculations: Solves Saha ionization and Boltzmann excitation equilibrium with detailed partition functions.
    • Molecular Equilibrium: Solves for ~300 diatomic species using Gibbs free energy minimization during preprocessing.
  • Engine Layer: Orchestrates wavelength-by-wavelength opacity accumulation and solves the radiative transfer equation using the JOSH solver (a port of the ATLAS routine). It integrates on a fixed log-$\tau$ grid using parabolic optical depth quadrature and Lambda iteration for scattering.
• Performance Optimization:
  • Uses NumPy and SciPy for data handling.
  • Leverages Numba for Just-In-Time (JIT) compilation of performance-critical inner loops (e.g., Voigt profile evaluation, opacity accumulation).
  • Requires no Fortran compiler.
• Data Consistency: The implementation uses the exact same input data as the original Fortran code (atomic line lists, partition functions, opacity tables) stored as pre-extracted .npz archives to ensure numerical fidelity.
• AI-Assisted Development: The reimplementation was achieved using Anthropic's Claude Opus 4.6 (via Cursor) to navigate the complex, legacy Fortran logic. This required extensive human guidance, debugging, and validation, representing a new paradigm in scientific software preservation.

3. Key Contributions

• First Pure Python SYNTHE: Provides the first tool capable of generating Kurucz-SYNTHE-quality synthetic spectra entirely within a Python environment.
• Numerical Fidelity: Validated to be a "drop-in replacement" with sub-0.01% median agreement with the original Fortran code across a wide range of stellar types.
• Modern Ecosystem Integration: Enables direct integration with ML frameworks (PyTorch, JAX) for differentiable spectral fitting and training of data-driven emulators (e.g., The Payne, The Cannon).
• Accessibility: Removes the barrier of Fortran compilers, allowing cross-platform installation and making the codebase readable for teaching and rapid prototyping.
• Archival Preservation: Serves as a long-term, maintainable reference implementation of the SYNTHE physics, ensuring reproducibility after the original author's passing.

4. Results

• Validation Scope: Tested against 100 randomly drawn atmosphere models spanning:
  • Effective Temperature ($T_{\text{eff}}$): 2,500 K (cool giants) to 44,000 K (O-type stars).
  • Surface Gravity ($\log g$): -1 to 5.
  • Metallicity ([Fe/H]): -2.5 to +0.5.
  • Wavelength Range: 300–1800 nm at resolving power $R = 300,000$.
• Accuracy Metrics:
  • Median Fractional Deviation: < 0.002% compared to Fortran reference.
  • 99th-Percentile Deviation: < 0.2%.
  • These deviations are well below systematic uncertainties introduced by model atmosphere choices or line list completeness.
• Performance: Currently 2–3× slower than the original Fortran code. However, the authors note that the readable, structured Python code with Numba-JIT loops makes it a tractable engineering task to optimize further using AI tools.

5. Significance

pyKurucz represents a critical milestone in computational astrophysics. By faithfully preserving the physics of the most widely cited stellar synthesis code in a modern, accessible language, it:

1. Future-Proofs Research: Ensures that decades of spectral analysis methods remain usable and reproducible regardless of the decline of legacy Fortran support.
2. Accelerates Survey Science: Lowers the barrier for generating massive training grids for next-generation surveys (SDSS-V, DESI, 4MOST, WEAVE) without requiring Fortran expertise.
3. Enables New Methodologies: Facilitates gradient-based optimization and differentiable physics, allowing for more sophisticated spectral fitting techniques that were previously impossible with rigid Fortran binaries.
4. Demonstrates AI in Science: Serves as a case study for using Large Language Models (LLMs) to preserve and modernize complex, legacy scientific software, bridging the gap between historical codebases and modern computational needs.

Limitations & Future Work:
Current limitations include the lack of parsed molecular line opacity (affecting cool stars/IR), no self-consistent atmosphere iteration (requires external .atm files), LTE-only physics, and 1D plane-parallel geometry. Future work aims to address these, starting with a Python ATLAS12 implementation.