PhiFlow is a Python library for differentiable physics simulation, primarily targeting fluid dynamics, particle systems, and PDE-based optimization. It provides a unified field abstraction (CenteredGrid, StaggeredGrid, PointCloud, Mesh) with automatic resampling and boundary handling, enabling seamless integration with machine learning workflows. The library supports multiple backends (NumPy, PyTorch, TensorFlow, JAX) and features a rich geometry module, physics solvers (advection, diffusion, incompressible flow, SPH, waves), and visualization tools. While its core abstractions are clean and well-tested, the codebase exhibits some technical drift due to deprecated API surface, large monolithic Dash-based web UI, and heavy reliance on the external phiml tensor library. Nonetheless, it is actively maintained with extensive test coverage and a growing research community.
This repository provides **NEC2++**, a from-scratch C++ implementation of the Numerical Electromagnetics Code (NEC-2), a well-known Method of Moments (MoM) solver for wire and patch antenna simulation. The code is distributed as a standalone command-line tool (`nec2++`), a shared library (`libnecpp`) with a stable C API, and Python bindings (separate repository `python-necpp`). It reads standard NEC-2 input files (`.nec`) and produces output files with radiation patterns, impedances, near fields, and structure currents. The library is designed for embedding into optimization systems and GUI applications, supporting large models with tens of thousands of segments. Architecturally, the simulation is driven by a `nec_context` class that orchestrates geometry construction (via `c_geometry`), matrix assembly using Eigen's dense linear algebra, network solving, and result extraction. Input parsing uses an ANTLR 4 grammar to handle the free-format NEC card syntax, with a table-driven handler dispatch replacing a large switch statement. The ground model includes Sommerfeld/Norton integrals, implemented in both C (direct Fortran translation) and C++ wrappers. The codebase is well-tested, with a comprehensive test harness comparing outputs against the original Fortran NEC-2 and a C port (`nec2c`), plus unit tests using Catch2. The repository is actively maintained (last commit in 2026, recent PRs fixing bugs and adding features), uses C++17, and bundles a known version of Eigen (v3.4) for linear algebra, avoiding external BLAS/LAPACK dependencies. While the code has some legacy C sections and occasional commented-out dead code, the overall architecture is clean and extensible. Notable reusable components include the ANTLR grammar for parsing structured free-form input, the wire intersection algorithm in `nec_wire.h`, and the ground parameter abstraction in `nec_ground.h`.
FTorch is a production-stable Fortran library that enables direct coupling of PyTorch machine learning models to Fortran scientific codes without requiring a Python runtime. It provides a comprehensive Fortran interface to LibTorch (PyTorch's C++ backend) for tensor operations, model inference, automatic differentiation, optimizers (SGD, Adam, AdamW), and loss functions (MSE, cross-entropy). The architecture uses a three-layer design: Fortran modules with derived types (torch_tensor, torch_model, torch_optim) that call a thin C API (ctorch.h/ctorch.cpp), which in turn wraps LibTorch. This layered approach isolates Fortran code from C++ ABI changes and allows the library to be built as a shared or static library with CMake, supporting CPU, CUDA, HIP, XPU, and MPS backends. The library includes extensive examples covering tensor manipulation, simple neural networks, ResNet-18 inference, batching, multi-I/O, looping, multi-GPU, MPI parallelism, autograd, and full training loops. Unit tests use pFUnit and integration tests are built from examples, with CI testing across multiple compilers (gfortran, ifx, flang) and platforms. A Python utility package (ftorch_utils) provides model conversion (PyTorch to TorchScript) and validation. FTorch is published in the Journal of Open Source Software (JOSS) and is used in several HPC climate and fusion simulation codes (E3SM, CAM, ICON, UKAEA). The codebase demonstrates strong engineering practices: fypp code generation reduces boilerplate for multiple tensor ranks and data types, C interoperability is handled cleanly via iso_c_binding, and finalizers ensure automatic resource cleanup. However, there are some maintenance risks including reliance on fypp preprocessing, a large CI matrix, and the need to track LibTorch releases. A legacy API (torch_tensor_from_array_legacy) is still present but deprecated. Overall, FTorch is a well-crafted, domain-specific library that fills a critical gap for Fortran-HPC users needing ML integration.
This repository is a curated collection of 177+ domain-specific scientific 'skills' for AI agents, following the Agent Skills standard. Each skill is a self-contained module providing a CLI tool, documentation, and tests for a specific scientific or technical task—ranging from single-cell RNA-seq analysis (scanpy) and molecular docking (diffdock) to clinical report validation and ISO standards readiness. The architecture is a monorepo of independent skills, each with its own scripts/, references/, assets/, and tests/. Skills are designed to be safe, bounded, and reproducible: they validate inputs before execution, enforce resource limits, avoid network access unless explicitly required, and produce structured JSON reports. The repository also includes a shared test infrastructure (skill_contract) and a meta-skill (autoskill) that can automatically propose new skills from screen activity. While primarily an application library for AI agents, it has strong data/research characteristics due to its heavy use of scientific data formats and validation of research artifacts.
OpenHPC is a community-driven software distribution and infrastructure framework for High Performance Computing (HPC) clusters. It provides a collection of RPM packages, installation recipes, and testing infrastructure to deploy and manage HPC environments on Linux distributions such as RHEL, SUSE, and openEuler. The repository serves as the build system and validation suite for the distribution, ensuring compatibility across multiple MPI implementations, compilers, and scientific libraries. It does not function as a single application but rather as a meta-package and deployment framework for HPC systems.
pyGIMLi is a mature open-source geophysical modelling and inversion library, implemented as a C++ core with Python bindings. It provides mesh generation, finite-element solvers, data containers, and high-level manager classes for methods such as electrical resistivity tomography (ERT), vertical electrical sounding (VES), frequency-domain electromagnetics (FDEM), magnetics, gravity, traveltime, and spectral induced polarization. The library is not a GUI application; it is a programmatic toolkit with Python entry points, example scripts, and a console-app pattern in some managers.
Sphinx Book Theme is a Python package implementing a book-style HTML theme for Sphinx documentation builds. It extends pydata-sphinx-theme (pinned to 0.22.0) and adds custom docutils directives (Margin), a build-time transform that rewrites footnotes into Tufte-style side/margin notes, and header-button generators that emit launch links for Binder/Colab/JupyterHub/Deepnote/JupyterLite plus source links for GitHub/GitLab/Bitbucket. It is distributed on PyPI and serves as the default theme for Jupyter Book, making it a foundational component of the scientific Python documentation ecosystem. Despite this research-communication role, it is a software library, not a data tool — it renders and styles documentation rather than analyzing data. This hybrid character is worth noting: the repo does not contain data pipelines, notebooks for analysis, or research outputs; it contains a Sphinx plugin and frontend asset pipeline. The Python layer is thin but carefully engineered. Theme setup in __init__.py registers Sphinx events, directives, nodes, and transforms; header_buttons/ uses a clean per-provider functional abstraction for generating URLs; _compat.py guards against docutils API drift; and _compile_translations.py coordinates a JSON-to-PO/MO translation workflow. The frontend is compiled with Webpack from a 7-1-architecture SCSS codebase with sections for layout, content, and third-party extension overrides. Tests build real sample sites and use pytest-regressions to verify rendered HTML across Python 3.11-3.14 and Sphinx 8-9, which demonstrates solid engineering discipline for a theme project. The README explicitly declares maintenance mode: bug fixes only, no new features. The last commit is recent and CI runs continuously, but the tightly pinned pydata-sphinx-theme dependency, Sphinx 11 deprecation warnings in the test config, and hand-maintained translation files indicate slow technical drift. For engineers looking for reusable pieces, the standout items are the footnote-to-sidenote transform, the header-button provider pattern, and the HTML asset-hashing utility; the Jinja templates and SCSS are heavily theme-specific and not worth extracting.
PyEMD is a pure Python library for computing the Earth Mover's Distance (also known as Wasserstein distance) between histograms. As of version 2.0, it serves as a thin wrapper around the POT (Python Optimal Transport) library, providing three main functions: `emd()` for computing the EMD value, `emd_with_flow()` for getting both the EMD value and the flow matrix, and `emd_samples()` for computing EMD directly from sample arrays. The library implements optimizations from the original C++ implementation, including pre-flow cancellation of mass within same bins for zero-cost transport. It follows modern Python packaging practices with pyproject.toml, uses setuptools_scm for version management, and maintains comprehensive test coverage.
PyMFEM provides Python bindings for the MFEM finite element library, enabling finite element simulations (PDE solvers) from Python. The architecture consists of SWIG-generated wrapper modules for serial (`mfem.ser`) and parallel MPI (`mfem.par`) execution, built on top of the C++ MFEM library. Key entry points include the core modules (`mfem.ser`, `mfem.par`), a suite of 30+ example scripts covering Laplace, elasticity, Maxwell, Navier-Stokes, and more, and miniapps for specialized applications (DPG, multidomain, field interpolation). The system supports JIT-compiled coefficients via Numba, complex-valued solvers via CHypre, and GPU backends (CUDA, libCEED). While primarily a software library, it has a strong research character due to its advanced numerical methods (DPG, fractional PDEs, topology optimization) and extensive example set that serves as both documentation and validation.
PySB is a Python framework for building and simulating rule-based mathematical models of biochemical systems. It provides a domain-specific language (DSL) embedded in Python for defining monomers, rules, parameters, and observables, with operator overloading to express reactions concisely. The library supports multiple simulation backends (SciPy ODE, BioNetGen, StochKit, Kappa, CUDA/OpenCL SSA, cupSODA) and can export models to SBML, MATLAB, Mathematica, BNGL, JSON, and other formats. It includes tools for sensitivity analysis, pattern matching, model testing, and parameter estimation. While primarily a software library, it also contains research examples, paper figure reproduction scripts, and experimental data, making it a hybrid project with a strong application core. The codebase is well-structured with clean abstractions (simulator base class, exporter registry, composable filter predicates) and extensive test coverage, though it carries some technical debt from deprecated modules and external tool dependencies.
Fityk is a cross-platform scientific data fitting program focused on nonlinear curve fitting, particularly peak fitting in spectroscopy and crystallography. It provides a core library (libfityk) with multiple fitting algorithms (Levenberg-Marquardt, MPFIT, Nelder-Mead, Genetic Algorithm, NLopt), a rich set of built-in peak functions (Gaussian, Lorentzian, Voigt, Pearson VII, etc.), symbolic derivatives via AST, and a bytecode VM for expression evaluation. The architecture is modular: a core library, a CLI with readline and gnuplot integration, a wxWidgets GUI, and scripting support via Lua and SWIG bindings for Python, Perl, Ruby, and Java. Key entry points include the Fityk class API, the command parser (cparser.cpp), the runner (runner.cpp), and the GUI main frame (frame.cpp). Data flows involve loading data from files (via xylib), defining models as sums of functions, fitting using least-squares optimization, and outputting parameters and statistics. External dependencies include wxWidgets, Boost, Lua, NLopt, xylib, readline, gnuplot, zlib, and SWIG. The codebase is well-structured with extensive documentation and tests, though it shows some age with pre-C++11 idioms and platform-specific workarounds.
Fiji (Fiji Is Just ImageJ) is a comprehensive scientific image processing platform built on ImageJ. This is a portable application distribution rather than a library, designed for life sciences research with cross-platform support (Windows, Linux, macOS). The codebase implements a monolithic application architecture with a plugin system based on SciJava, supporting multiple scripting languages (Java, JavaScript, Python, Ruby, Clojure, BeanShell, ImageJ Macro). It manages plugin dependencies via Maven-based update sites and provides a launcher system that handles platform-specific native library paths and JVM configuration. The repository demonstrates significant engineering craftsmanship in its cross-platform build automation, legacy compatibility layer for ImageJ 1.x, and service abstraction patterns. However, it carries technical debt through deprecated components (fiji.Main, bin/ImageJ.sh), version drift between pom.xml (2.18.1-SNAPSHOT) and Info.plist (2.0.2), and heavy reliance on shell scripts for platform-specific logic. The codebase is actively maintained with recent commits but has 138 open issues indicating ongoing development challenges.
I‑Simpa is a mature, open‑source desktop application for 3D numerical sound propagation modelling, designed for scientific acoustic simulations. The system provides a full GUI (built with wxWidgets and OpenGL) for defining acoustic scenes (sources, receivers, materials, meshes), running multiple calculation cores (particle tracing SPPS, classical theory TCR, and experimental TLM), and post‑processing results via point/surface receivers, impulse responses, and sound maps. It features a tree‑based data model with XML persistence, a Python scripting layer for automation and custom tools, and supports industry‑standard file formats (STL, PLY, GABE binary arrays). The codebase is predominantly C++ with a Boost.Python bridge, and is actively maintained by the Environmental Acoustic Research unit at Université Gustave‑Eiffel. The architecture follows a classic monolith pattern with clear separation: a core calculation library (`src/spps/`, `src/ctr/`), a 3D rendering engine (`src/isimpa/3dengine/`), a GUI layer (`src/isimpa/IHM/`), and a data manager with element/property tree. Python scripts in `SystemScript/` extend the UI through a plugin mechanism. While the project is functionally complete and validated against benchmarks, it exhibits moderate technical drift: bundled MathJax 2.7.5 (2018) for documentation, some French comments and variable names, and a few Python 2 remnants. Despite this, the component design—especially the octree spatial index, GABE binary I/O, and XML element tree—are cleanly abstracted and potentially reusable in other scientific or simulation contexts. The repository also includes extensive documentation and tutorials, though the experimental directivity feature is flagged as undocumented.
PyMetis is a Python wrapper for the METIS graph partitioning library, providing a high-level API for partitioning graphs and meshes, and for computing sparse matrix orderings (nested dissection). The Python package exposes functions such as `part_graph`, `part_mesh`, and `nested_dissection` via pybind11 bindings to the bundled METIS 5.2.1 C source. The build system (meson-python) compiles the METIS library and GKlib utilities from source, producing a self-contained wheel. The repository also includes a comprehensive test suite that validates partitioning of 2D/3D tetrahedral meshes and graph-based partitions with weighted vertices and edges. While the Python API is clean and straightforward, the project's primary value lies in its reliable integration of a well-established, high-performance C library rather than in novel algorithmic contributions. The codebase is actively maintained, with regular releases, CI/CD pipelines for multiple platforms, and support for both PyPI and conda-forge distributions.
This repository is a Python framework for constrained nonlinear optimization, with a strong emphasis on uncertainty quantification (UQ) and scientific machine learning. It provides a suite of derivative-free global and local optimizers (differential evolution, Nelder-Mead, Powell, etc.) through a common abstract interface, alongside powerful constraint and penalty handling via symbolic equations (using sympy) and decorator-based composition. The library supports ensemble solvers, parallel execution (via pathos/pyina), and includes extensive UQ tools: discrete measures, product measures, expectation bounds, probability of failure, and McDiarmid bounds. It is structured as a reusable Python package with well-documented modules and a large collection of example scripts demonstrating applications from benchmark optimization to XRD surrogate design and geophysical inversion. While the core library is solid and showcases high craftsmanship in its symbolic constraint generation and abstract solver pattern, many example scripts are exploratory and contain hardcoded parameters or incomplete code, reflecting its research origins. The framework is actively maintained but shows some technical drift (e.g., a forked legacy SciPy optimizer, use of eval/exec in logging and plotting, and heavy reliance on optional dependencies like sympy, klepto, and pathos).
This repository is a comprehensive catalog of containerized AI agents for scientific computing, primarily in chemistry, biology, materials science, and engineering domains. It includes over 40 agents (e.g., AutoDock Vina, AlphaFold, OpenFOAM, GWP predictor) each packaged as a Docker container with a utility module, example inputs, and tests. The platform also provides a Python CLI tool (`discovery`) for submitting jobs to an Azure-based HPC service, managing storage, and monitoring job status. The repository is hybrid in nature, containing both production-ready application components (CLI, agent deployment infrastructure) and research artifacts (training pipelines for the GWP predictor, model weights, and data ingestion scripts). The agent architecture follows a consistent pattern: each agent has a `quick_setup`/`save_final_results` lifecycle and is designed to run in a containerized environment with mounted `/input` and `/output` directories. The CLI is well-structured with Typer and Rich, and includes extensive tests. However, the codebase exhibits significant duplication (e.g., `molecular_utils.py` and `io_utils.py` appear identically in multiple agents) and some hardcoded paths, which reduces maintainability. The GWP predictor training pipeline is a notable research component with a multi-step ETL process and active learning, but it is tightly coupled to specific external data sources. Overall, the repository serves as a strong foundation for deploying scientific AI agents on Azure, with moderate reusability of individual components.