QuasiX: High-Performance GW/BSE for Python

QuasiX is a high-performance implementation of the GW approximation and Bethe-Salpeter Equation (BSE) for calculating quasiparticle energies and optical excitations in molecules and materials.

Note

QuasiX v0.6.0 is the current release (M1 milestone). The project is under active development with a manuscript in preparation for Journal of Chemical Theory and Computation.

Key Features

• G0W0 and evGW: One-shot and eigenvalue self-consistent GW calculations

• BSE Optical Spectra: Singlet and triplet excitations with oscillator strengths

• High Performance: Rust core with SIMD optimizations (8-40x faster than PySCF)

• Python Interface: Seamless integration with PySCF for molecular calculations

• GW100 Validated: Benchmarked against the GW100 test set (MAD = 1.55 meV vs PySCF)

Quick Example

from quasix import G0W0Driver
from pyscf import gto, scf

# Build molecule
mol = gto.M(
    atom='O 0 0 0; H 0 0.757 0.587; H 0 -0.757 0.587',
    basis='def2-svp'
)
mf = scf.RHF(mol).run()

# Run G0W0
gw = G0W0Driver(mf)
result = gw.kernel()
print(f"HOMO QP energy: {result.homo_qp:.3f} eV")

Performance Highlights

QuasiX achieves significant speedups through:

• Rust implementation with zero-cost abstractions

• SIMD-vectorized tensor operations (AVX-512 support)

• Parallel frequency integration

• Efficient density-fitting (RI) approximation

Performance Comparison (G₀W₀@PBE/def2-TZVP, 64 threads)

Molecule	QuasiX	PySCF	Speedup
H₂O (43 AO)	1.0 s	8.0 s	8.3×
CH₄ (55 AO)	1.3 s	29.8 s	23.3×
N₂ (62 AO)	1.7 s	67.6 s	40.1×

Validation

QuasiX has been rigorously validated against the GW100 benchmark set:

• G₀W₀ vs PySCF: MAD = 1.55 meV (sub-meV agreement, 11 molecules)

• evGW@PBE0/def2-TZVP: MAD = 0.29 eV, MSE = +0.14 eV vs NIST experimental IPs (50 molecules)

• evGW vs TURBOMOLE: MAD = 27.7 meV (Newton vs graphical QP solver)

• See Benchmarks for detailed validation results with actual data.

Documentation Contents

Getting Started

• Installation
  • System Requirements
  • Installation Methods
  • Verifying Installation
  • Optional Dependencies
  • Troubleshooting
  • Platform-Specific Notes
  • Building Documentation
  • Next Steps
• Quick Start Guide
  • Prerequisites
  • Example 1: G0W0 Calculation for Water
  • Example 2: evGW for Better Accuracy
  • Example 3: BSE Optical Spectrum
  • Example 4: Custom Calculation Parameters
  • Example 5: Parallel Execution
  • Output Analysis
  • Comparing Starting Points
  • Common Workflow: GW + BSE
  • Next Steps

User Guide

• Tutorials
  • Getting Started
  • Available Tutorials
  • Planned Tutorials
  • Example Gallery
  • See Also
• Benchmarks
  • G₀W₀ Validation: QuasiX vs PySCF
  • evGW Validation: QuasiX vs Experiment
  • evGW: QuasiX Newton vs TURBOMOLE Graphical
  • Performance Benchmarks
  • evGW Convergence
  • Data Sources
  • References

Theory Background

• GW Theory
  • Introduction
  • Many-Body Perturbation Theory
  • Quasiparticle Equation
  • G0W0: One-Shot GW
  • evGW: Eigenvalue Self-Consistent GW
  • Density Fitting (RI Approximation)
  • Frequency Integration
  • Implementation Details
  • References
• BSE Theory
  • Introduction
  • Theoretical Framework
  • Spin Channels
  • Tamm-Dancoff Approximation (TDA)
  • Optical Properties
  • Exciton Analysis
  • Implementation Details
  • References

API Reference

• API Reference
  • Overview
  • Module Documentation
  • Quick Reference
  • Result Attributes
  • Error Handling
  • See Also

Development

• Contributing
• Changelog

Indices and Tables

• Index

• Module Index

• Search Page

Citation

If you use QuasiX in your research, please cite:

@article{quasix2025,
  title={QuasiX: A High-Performance Rust Implementation of GW and
         Bethe-Salpeter Equation Methods with Seamless Python Integration},
  author={Vchirawongkwin, Viwat},
  journal={J. Chem. Theory Comput.},
  year={2025},
  note={In preparation}
}

License

QuasiX is dual-licensed under MIT and Apache 2.0 licenses.

Acknowledgments

QuasiX builds upon:

• PySCF for molecular integrals and SCF

• ndarray for efficient array operations

• PyO3 for Python-Rust bindings