optixde 0.2.2__tar.gz

optixde-0.2.2/CHANGELOG.md

@@ -0,0 +1,83 @@
+# Changelog
+
+All notable changes to OptiXDE are documented in this file.
+
+The format follows the spirit of [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and OptiXDE uses semantic versioning for public releases.
+
+## [Unreleased]
+
+## [0.2.2] - 2026-07-27
+
+### Added
+
+- File-level SPDX copyright and MIT license identifiers across Python sources.
+- Explicit author, contact, license, project URL, and benchmark reference
+  metadata for open-source and research citation workflows.
+
+### Changed
+
+- Modernized Python package license metadata and prepared automated
+  TestPyPI/PyPI publishing.
+- Removed repository-tracked personal editor settings.
+
+## [0.2.1] - 2026-06-30
+
+### Added
+
+- Citation metadata through `CITATION.cff` so GitHub can expose a repository
+  citation entry.
+- Project changelog and README links for release notes and citation guidance.
+
+## [0.2.0] - 2026-06-30
+
+### Added
+
+- Public release artifacts for OptiXDE v0.2.0, including wheel and source
+  distribution on GitHub Releases.
+- Matrix-free solver coverage for Poisson, Helmholtz, diffusion, and wave
+  equations on rectangular uniform grids.
+- Wave-equation examples, including periodic single-mode phase validation,
+  Gaussian packet propagation, and a paper-style Section 6.3 reproduction
+  script.
+- Operator-splitting examples for nonlinear PDE workflows, including
+  Allen--Cahn and 1D periodic viscous Burgers.
+- Burgers reproduction tooling with high-resolution reference comparison,
+  space-time visualization, parameter scans, and Torch backend support.
+- Periodic vorticity-streamfunction Navier--Stokes examples, including a
+  Taylor--Green vortex and a cylinder-flow Brinkman prototype with force,
+  wake, spectrum, history, and scan diagnostics.
+- Schrödinger/paraxial Gaussian propagation example with periodic FFT backend
+  support.
+- PyTorch backend workflows for periodic FFT solvers on CPU and CUDA-capable
+  devices, plus Colab-oriented GPU smoke scripts.
+- Backend diagnostics via `return_info=True`, capability flags, backend name,
+  device, boundary condition, transform path, and shape/dtype metadata.
+- Unified solver reference validation benchmark covering representative wave,
+  Burgers, Navier--Stokes, and Schrödinger paths.
+- Organized examples under `examples/base`, `examples/benchmarks`, and
+  `examples/solid`, with opt-in artifact generation.
+- Release checklist and CI validation for tests, compile checks, and compact
+  solver-reference smoke runs.
+
+### Changed
+
+- Standardized public solver entry points under `optixde.solvers`.
+- Modernized legacy benchmark and example CLIs with explicit output paths.
+- Moved generated figures and benchmark artifacts toward `examples/artifacts`
+  and kept repository outputs opt-in.
+- Improved README coverage for solver conventions, boundary conditions,
+  diagnostics, examples, GPU usage, and release validation.
+
+### Notes
+
+- The Torch backend currently targets periodic FFT paths. Dirichlet and Neumann
+  DCT/DST paths remain NumPy/SciPy-oriented.
+- Embedded-domain, segmented-boundary, cylinder-flow, and solid-mechanics
+  modules are still experimental and should be validated for each research use
+  case.
+
+[Unreleased]: https://github.com/yangyLab/OptiXDE/compare/v0.2.2...main
+[0.2.2]: https://github.com/yangyLab/OptiXDE/releases/tag/v0.2.2
+[0.2.1]: https://github.com/yangyLab/OptiXDE/releases/tag/v0.2.1
+[0.2.0]: https://github.com/yangyLab/OptiXDE/releases/tag/v0.2.0

optixde-0.2.2/CITATION.cff

@@ -0,0 +1,21 @@
+cff-version: 1.2.0
+message: "If you use OptiXDE in academic work, please cite this software and the related paper or preprint when available."
+title: "OptiXDE: optical-inspired PDE solvers"
+version: "0.2.2"
+date-released: "2026-07-27"
+type: software
+license: MIT
+authors:
+  - family-names: "Yang"
+    given-names: "Yang"
+    email: "yangyhhu@foxmail.com"
+repository-code: "https://github.com/yangyLab/OptiXDE"
+url: "https://github.com/yangyLab/OptiXDE/releases/tag/v0.2.2"
+abstract: "OptiXDE is a lightweight Python package for optical-inspired, matrix-free spectral solvers for differential equations on uniform grids, with examples for linear PDEs, nonlinear splitting, flow, wave propagation, and GPU-oriented periodic FFT workflows."
+keywords:
+  - PDE
+  - spectral methods
+  - FFT
+  - optical-inspired computing
+  - scientific computing
+  - GPU

optixde-0.2.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Yang Yang <yangyhhu@foxmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

optixde-0.2.2/MANIFEST.in

@@ -0,0 +1,4 @@
+include CHANGELOG.md
+include CITATION.cff
+include LICENSE
+include README.md

optixde-0.2.2/PKG-INFO

@@ -0,0 +1,451 @@
+Metadata-Version: 2.4
+Name: optixde
+Version: 0.2.2
+Summary: OptiXDE: optical-inspired PDE solver
+Author-email: Yang Yang <yangyhhu@foxmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yangyLab/OptiXDE
+Project-URL: Repository, https://github.com/yangyLab/OptiXDE
+Project-URL: Issues, https://github.com/yangyLab/OptiXDE/issues
+Keywords: PDE,spectral methods,FFT,scientific computing,GPU
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20
+Provides-Extra: plot
+Requires-Dist: matplotlib>=3.6; extra == "plot"
+Provides-Extra: sparse
+Requires-Dist: scipy>=1.9; extra == "sparse"
+Provides-Extra: torch
+Requires-Dist: torch; extra == "torch"
+Provides-Extra: gpu
+Requires-Dist: torch; extra == "gpu"
+Provides-Extra: cupy
+Requires-Dist: cupy; extra == "cupy"
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: coverage>=7.5; extra == "dev"
+Requires-Dist: matplotlib>=3.6; extra == "dev"
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+Requires-Dist: scipy>=1.9; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Dynamic: license-file
+
+<p align="center">
+  <img src="optixde_logo_horizontal.svg" alt="OptiXDE logo" width="620">
+</p>
+
+# OptiXDE
+
+[![Python](https://img.shields.io/badge/python-3.9%2B-blue.svg)](pyproject.toml)
+[![Release](https://img.shields.io/badge/release-v0.2.2-blueviolet.svg)](https://github.com/yangyLab/OptiXDE/releases/tag/v0.2.2)
+[![Tests](https://img.shields.io/badge/tests-unittest-green.svg)](#development)
+[![GPU](https://img.shields.io/badge/GPU-PyTorch%20periodic%20FFT-purple.svg)](docs/colab_torch_gpu.md)
+
+OptiXDE is a lightweight Python package for optical-inspired PDE solvers on
+uniform grids. It focuses on fast, matrix-free spectral methods for rectangular
+domains, with experimental embedded-domain and solid-mechanics modules growing
+alongside the core solver stack.
+
+The core convention is consistent across the package:
+
+- Poisson: `-Δu = f`
+- Helmholtz: `(-Δ + k0^2)u = f`
+- Diffusion: `u_t = D Δu`
+- Wave: `u_tt = c^2 Δu`
+
+## Highlights
+
+- **Matrix-free solvers** for Poisson, Helmholtz, diffusion, and wave equations.
+- **Operator splitting** utilities for nonlinear PDEs such as Allen--Cahn.
+- **Nonlinear examples** for Allen--Cahn and 1D periodic viscous Burgers.
+- **Periodic incompressible flow** via 2D vorticity-streamfunction Navier--Stokes.
+- **Schrödinger/paraxial propagation** for optical-style complex wave fields.
+- **FFT/DCT/DST transforms** for periodic, Dirichlet, and Neumann boundary
+  conditions.
+- **Robin boundary support** through specialized fallbacks and finite-difference
+  projection helpers.
+- **PyTorch backend** for periodic FFT solvers on CPU or CUDA GPUs.
+- **Backend diagnostics** with `return_info=True` and capability flags.
+- **Geometry helpers** for signed-distance primitives and Boolean operations.
+- **Experimental modules** for segmented domains and periodic solid mechanics.
+
+## Install
+
+Install the current release from PyPI:
+
+```bash
+pip install optixde
+```
+
+Install optional features from PyPI as needed:
+
+```bash
+pip install "optixde[plot]"    # Matplotlib plotting helpers
+pip install "optixde[sparse]"  # SciPy-based polygonal embedded solvers
+pip install "optixde[gpu]"     # PyTorch backend for periodic GPU FFT solvers
+```
+
+For local development:
+
+```bash
+git clone https://github.com/yangyLab/OptiXDE.git
+cd OptiXDE
+pip install -e .
+```
+
+For development, optional feature groups can be installed from the checkout:
+
+```bash
+pip install -e ".[plot]"    # Matplotlib plotting helpers and examples
+pip install -e ".[sparse]"  # SciPy-based polygonal embedded solvers
+pip install -e ".[torch]"   # PyTorch backend alias
+pip install -e ".[gpu]"     # PyTorch backend for periodic GPU FFT solvers
+pip install -e ".[cupy]"    # CuPy backend, if your CUDA/CuPy stack is ready
+pip install -e ".[dev]"     # tests, lint, plotting, sparse extras
+```
+
+## Quick Start
+
+```python
+import numpy as np
+from optixde.solvers import (
+    diffusion2d_solve,
+    helmholtz2d_solve,
+    poisson2d_solve,
+    wave2d_solve,
+)
+
+Lx = Ly = 2.0 * np.pi
+N = 64
+x = np.linspace(0.0, Lx, N, endpoint=False)
+y = np.linspace(0.0, Ly, N, endpoint=False)
+X, Y = np.meshgrid(x, y, indexing="xy")
+
+u_exact = np.sin(2 * X) * np.cos(3 * Y)
+f = 13.0 * u_exact
+
+u = poisson2d_solve(f, Lx, Ly, bc="periodic")
+w = helmholtz2d_solve(f, Lx, Ly, k0=1.0, bc="periodic")
+next_u = diffusion2d_solve(
+    u_exact,
+    D=0.1,
+    Lx=Lx,
+    Ly=Ly,
+    dt=0.01,
+    bc="periodic",
+)
+next_wave_u, next_wave_v = wave2d_solve(
+    u_exact,
+    np.zeros_like(u_exact),
+    c=1.0,
+    Lx=Lx,
+    Ly=Ly,
+    dt=0.01,
+    bc="periodic",
+)
+```
+
+## Solver Map
+
+### Poisson
+
+```python
+u = poisson2d_solve(f, Lx, Ly, bc="periodic")
+u = poisson2d_solve(f, Lx, Ly, bc="dirichlet")
+u = poisson2d_solve(f, Lx, Ly, bc="neumann")
+u = poisson2d_solve(f, Lx, Ly, bc="robin", robin=(alpha, beta, g))
+```
+
+Periodic and Neumann Poisson problems require `mean(f) = 0`; OptiXDE enforces
+this by default and fixes the additive constant with a zero-mean gauge.
+
+### Helmholtz
+
+```python
+u = helmholtz2d_solve(f, Lx, Ly, k0=1.0, bc="periodic")
+u = helmholtz2d_solve(f, Lx, Ly, k0=1.0, bc="dirichlet")
+u = helmholtz2d_solve(f, Lx, Ly, k0=1.0, bc="neumann")
+```
+
+`k0 > 0` makes the operator strictly elliptic, so no zero-mean constraint is
+needed.
+
+### Diffusion
+
+```python
+u = diffusion2d_solve(u0, D, Lx, Ly, dt, bc="periodic")
+u = diffusion2d_solve(u0, D, Lx, Ly, dt, bc="dirichlet")
+u = diffusion2d_solve(u0, D, Lx, Ly, dt, bc="neumann")
+u = diffusion2d_solve(u0, D, Lx, Ly, dt, bc="robin", robin=(alpha, beta, g))
+```
+
+Periodic diffusion also supports an ETD1 source term through `source=`.
+
+### Wave
+
+```python
+u, v = wave2d_solve(u0, v0, c, Lx, Ly, dt, bc="periodic")
+u, v = wave2d_solve(u0, v0, c, Lx, Ly, dt, bc="dirichlet")
+u, v = wave2d_solve(u0, v0, c, Lx, Ly, dt, bc="neumann")
+```
+
+The wave solver advances the first-order state `(u, v)` for `u_tt = c^2 Δu`
+with an exact spectral update for each mode. With `return_info=True`, it returns
+`u_next, v_next, info`.
+
+## Boundary Conditions
+
+| Boundary condition | Poisson | Helmholtz | Diffusion | Wave | Notes |
+| --- | --- | --- | --- | --- | --- |
+| `periodic` | Yes | Yes | Yes | Yes | FFT-based; supports NumPy, Torch, and CuPy backends. |
+| `dirichlet` | Yes | Yes | Yes | Yes | DST-based rectangular-domain solver. |
+| `neumann` | Yes | Yes | Yes | Yes | DCT-based rectangular-domain solver; Poisson uses a zero-mean gauge. |
+| `robin` | Yes | No | Yes | No | Uses exact Dirichlet/Neumann fallbacks where possible and penalty/projection helpers otherwise. |
+
+The older `mode=` keyword remains accepted as a compatibility alias for `bc=`.
+
+## Backends And GPU
+
+The default backend is NumPy:
+
+```python
+u = poisson2d_solve(f, Lx, Ly, bc="periodic", backend_name="numpy")
+```
+
+For GPU work, PyTorch is the recommended path:
+
+```python
+u = poisson2d_solve(
+    f,
+    Lx,
+    Ly,
+    bc="periodic",
+    backend_name="torch",
+    device="cuda",
+)
+```
+
+Current PyTorch scope:
+
+- Supported: periodic Poisson, Helmholtz, diffusion, wave, Burgers,
+  vorticity-streamfunction Navier--Stokes, and Schrödinger FFT paths.
+- Supported: CPU tensors and CUDA tensors, depending on your PyTorch install.
+- Not yet supported: Torch DCT/DST paths for Dirichlet and Neumann solvers.
+
+For Colab GPU validation, see `docs/colab_torch_gpu.md`.
+
+## Diagnostics
+
+Backends expose lightweight capability flags:
+
+```python
+from optixde.fft_backend import get_backend
+
+backend = get_backend("torch", device="cuda")
+print(backend.capabilities)
+```
+
+Solver entry points can return metadata with `return_info=True`:
+
+```python
+u, info = poisson2d_solve(
+    f,
+    Lx,
+    Ly,
+    bc="periodic",
+    backend_name="torch",
+    device="cuda",
+    return_info=True,
+)
+
+print(info["backend"], info["device"], info["bc"], info["transform"])
+```
+
+Common `info` fields are stable across solvers:
+
+- `solver`, `equation`, `bc`, `transform`: which equation and numerical path ran.
+- `backend`, `device`, `capabilities`: NumPy/Torch/CuPy backend and feature flags.
+- `input_shape`, `output_shape`, `input_dtype`, `output_dtype`: array metadata.
+- PDE extras such as `dt`, `viscosity`, `epsilon`, `wave_speed`, or `coefficient`.
+
+This is useful for tests, benchmarks, Colab runs, and checking whether a solve
+used FFT, DCT, DST, operator splitting, or a fallback path.
+
+## Examples
+
+Example scripts live under `examples/`:
+
+- `examples/base/`: core PDE demos and rectangular-domain experiments.
+- `examples/benchmarks/`: CPU/GPU backend timing scripts and benchmark cases.
+- `examples/solid/`: periodic solid-mechanics demos.
+- `examples/demo_post.py`: plotting helper demo.
+
+See `examples/README.md` for a command index.
+
+Run a small backend benchmark:
+
+```bash
+python examples/benchmarks/torch_fft_backend_benchmark.py --device cpu --sizes 64 128
+```
+
+On a CUDA machine or Colab runtime:
+
+```bash
+python examples/benchmarks/colab_torch_gpu_smoke.py --device cuda --n 256
+python examples/benchmarks/torch_fft_backend_benchmark.py --device cuda --sizes 512 1024
+```
+
+Run the paper-style wave examples:
+
+```bash
+python examples/base/wave_single_mode_phase.py --sizes 128 256 512
+python examples/base/wave_gaussian_packet.py --n 256
+python examples/base/wave_gaussian_packet.py --n 192 --sigma 0.28 --center-x 3.141592653589793 --center-y 3.141592653589793 --T 6 --animation-output output/animations/wave/gaussian_packet.gif
+python examples/base/wave_section_6_3_reproduction.py --output-dir examples/artifacts/section_6_3_wave
+```
+
+Run the nonlinear Allen--Cahn splitting example:
+
+```bash
+python examples/base/allen_cahn_splitting.py --n 128 --T 0.1
+python examples/base/burgers_1d_periodic.py --n 256 --T 1.0
+python examples/base/burgers_1d_periodic.py --backend torch --device cuda --n 1024 --T 1.0
+python examples/base/burgers_section_reproduction.py --n 256 --ref-n 2048 --output-dir examples/artifacts/burgers_section --scan
+python examples/base/navier_stokes_taylor_green.py --n 128 --T 1.0
+python examples/base/navier_stokes_cylinder_brinkman.py --nx 128 --ny 64 --steps 1000 --plot --output examples/artifacts/navier_stokes_cylinder_brinkman.png --history-output examples/artifacts/navier_stokes_cylinder_brinkman_history.csv --history-figure examples/artifacts/navier_stokes_cylinder_brinkman_history.png --summary-output examples/artifacts/navier_stokes_cylinder_summary.csv --wake-figure examples/artifacts/navier_stokes_cylinder_wake.png --spectrum-figure examples/artifacts/navier_stokes_cylinder_spectrum.png
+python examples/base/navier_stokes_cylinder_brinkman.py --nx 160 --ny 80 --steps 16000 --dt 0.001 --viscosity 0.005 --forcing 0.05 --perturbation 0.08 --penalty-eta 0.002 --animation-output output/animations/navier_stokes/cylinder_wake_vorticity.gif --animation-stride 200 --animation-vmax 8 --quiet
+python examples/base/navier_stokes_cylinder_brinkman.py --nx 128 --ny 64 --steps 5000 --report-every 10 --quiet
+python examples/base/navier_stokes_cylinder_brinkman.py --nx 96 --ny 48 --steps 400 --scan --scan-viscosity 0.002 0.0036 --scan-forcing 0.1 0.15 --scan-output examples/artifacts/navier_stokes_cylinder_scan.csv --quiet
+python examples/base/schrodinger_gaussian_packet.py --n 128 --T 1.0
+```
+
+Run the unified reference-validation table:
+
+```bash
+python examples/benchmarks/solver_reference_validation.py --sizes 64 128 --output examples/artifacts/solver_reference_validation.csv
+```
+
+## Package Layout
+
+```text
+optixde/
+  bc/             Robin, rasterization, and segmented-boundary helpers
+  fft_backend/    NumPy, PyTorch, CuPy, and propagator-cache utilities
+  geometry/       Signed-distance primitives and Boolean geometry
+  operators/      Spectral operators and transform helpers
+  post/           Optional Matplotlib plotting utilities
+  solvers/        Core, segmented-domain, and solid-mechanics solvers
+```
+
+Primary public imports:
+
+- `from optixde.solvers import poisson2d_solve, diffusion2d_solve, wave2d_solve`
+- `from optixde.solvers import burgers1d_solve, navier_stokes2d_vorticity_solve`
+- `from optixde.solvers import schrodinger2d_solve, allen_cahn2d_solve`
+
+PDE-specific modules are also kept as stable compatibility namespaces:
+
+- `optixde.solvers.poisson`
+- `optixde.solvers.helmholtz`
+- `optixde.solvers.diffusion`
+- `optixde.solvers.wave`
+- `optixde.solvers.splitting`
+- `optixde.solvers.allen_cahn`
+- `optixde.solvers.burgers`
+- `optixde.solvers.navier_stokes`
+- `optixde.solvers.schrodinger`
+- `optixde.fft_backend`
+- `optixde.geometry`
+- `optixde.bc`
+
+## Development
+
+Install development extras:
+
+```bash
+pip install -e ".[dev]"
+```
+
+Run tests:
+
+```bash
+python -m unittest discover -s tests -p "test*.py"
+```
+
+Optional checks:
+
+```bash
+python -m compileall -q optixde tests examples/benchmarks
+python examples/benchmarks/solver_reference_validation.py --sizes 16 32 --burgers-ref-n 64 --burgers-dt 0.005 --burgers-ref-dt 0.0025 --burgers-T 0.02 --ns-dt 0.01 --ns-T 0.02 --wave-T 0.02
+ruff check optixde tests
+```
+
+The test suite includes public import checks, transform checks, solver
+diagnostics, Robin smoke tests, analytic convergence tests for the core
+solvers, and a lightweight reference-validation benchmark used by CI. Torch GPU
+tests are skipped automatically when PyTorch or CUDA is not available.
+
+## Citation
+
+If you use OptiXDE in academic work, please cite the software release and the
+related paper or preprint when available. GitHub can read the citation metadata
+from `CITATION.cff`.
+
+```bibtex
+@software{optixde2026,
+  title   = {OptiXDE: optical-inspired PDE solvers},
+  author  = {Yang, Yang},
+  year    = {2026},
+  url     = {https://github.com/yangyLab/OptiXDE},
+  version = {0.2.2},
+}
+```
+
+Release notes are tracked in `CHANGELOG.md`.
+
+### Benchmark References
+
+Several examples reuse published benchmark problem definitions for independent
+OptiXDE implementations and comparisons:
+
+- M. Raissi, P. Perdikaris, and G. E. Karniadakis, “Physics-informed neural
+  networks: A deep learning framework for solving forward and inverse problems
+  involving nonlinear partial differential equations,” *Journal of
+  Computational Physics*, 378, 686–707 (2019),
+  [doi:10.1016/j.jcp.2018.10.045](https://doi.org/10.1016/j.jcp.2018.10.045).
+- L. Lu, X. Meng, Z. Mao, and G. E. Karniadakis, “DeepXDE: A deep learning
+  library for solving differential equations,” *SIAM Review*, 63(1), 208–228
+  (2021),
+  [doi:10.1137/19M1274067](https://doi.org/10.1137/19M1274067).
+
+## Copyright, License, and Disclaimer
+
+Copyright (c) 2025-2026 Yang Yang
+<yangyhhu@foxmail.com>.
+
+OptiXDE is open-source software distributed under the
+[MIT License](LICENSE). You may use, copy, modify, and redistribute the
+software subject to the terms of that license. Third-party libraries,
+datasets, papers, and other referenced materials remain subject to their
+respective licenses and copyrights.
+
+OptiXDE is research software provided "as is", without warranty of any kind.
+Numerical results should be independently verified before the software is used
+for engineering, safety-critical, clinical, financial, or other consequential
+decisions. The authors and contributors are not liable for losses or damages
+arising from use of the software, to the extent permitted by applicable law.
+
+Project information, source code, issue reporting, and release history are
+available at [github.com/yangyLab/OptiXDE](https://github.com/yangyLab/OptiXDE).
+
+## Project Status
+
+OptiXDE is currently an early-stage research/development package. The stable
+center is the rectangular-domain spectral solver stack; segmented-domain,
+Robin, CuPy, and solid-mechanics pieces are still evolving.
+
+When adding new solvers, keep the `-Δ` operator convention consistent across
+the package and prefer backend-aware, matrix-free implementations where
+possible.