kernelforge 0.1.2__tar.gz → 0.1.13__tar.gz

kernelforge-0.1.13/.github/workflows/ci.yml

@@ -0,0 +1,60 @@
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+
+jobs:
+  test:
+    name: pytest (${{ matrix.os }} / py${{ matrix.python-version }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-24.04, macos-15]
+        python-version: ["3.14"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install OpenMP (macOS only)
+        if: runner.os == 'macOS'
+        run: brew install libomp llvm
+
+      - name: Install OpenBLAS (Linux only)
+        if: runner.os == 'Linux'
+        run: sudo apt-get install -y libopenblas-dev
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Build & install (macOS only)
+        if: runner.os == 'macOS'
+        env:
+          OMP_NUM_THREADS: "1"
+          OPENBLAS_NUM_THREADS: "1"
+          CMAKE_PREFIX_PATH: /opt/homebrew/opt/libomp
+        run: |
+          uv sync --dev --all-extras
+          uv pip install scikit-build-core pybind11
+          CMAKE_ARGS="-DCMAKE_C_COMPILER=/opt/homebrew/opt/llvm/bin/clang \
+                      -DCMAKE_CXX_COMPILER=/opt/homebrew/opt/llvm/bin/clang++" \
+            uv pip install -e .[test] --no-build-isolation
+
+      - name: Build & install (Linux only)
+        if: runner.os == 'linux'
+        env:
+          OMP_NUM_THREADS: "1"
+          OPENBLAS_NUM_THREADS: "1"
+        run: |
+          uv sync --dev --all-extras
+          uv pip install scikit-build-core pybind11
+          uv pip install -e .[test] --no-build-isolation
+
+
+      - name: Run pytest
+        env:
+          OMP_NUM_THREADS: "1"
+          OPENBLAS_NUM_THREADS: "1"
+        run: uv run pytest -q -ra -k "not slow" -x

kernelforge-0.1.13/.github/workflows/release.yaml

@@ -0,0 +1,108 @@
+# .github/workflows/release.yml
+name: "Build & Publish"
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  build-wheels:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-22.04, macos-latest]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"   # host Python, cibuildwheel makes all others
+
+      - name: Clean wheelhouse and build artifacts
+        run: |
+          rm -rf dist/ build/ *.egg-info wheelhouse/
+
+      - name: Install GCC and OpenMP (macOS)
+        if: runner.os == 'macOS'
+        run: brew install gcc libomp
+
+      - name: Install cibuildwheel
+        run: python -m pip install cibuildwheel==2.*
+
+      - name: Build wheels
+        env:
+          CIBW_BUILD: "cp310-* cp311-* cp312-* cp313-* cp314-*"
+          CIBW_SKIP: "pp* *-musllinux_* cp*-manylinux_i686"
+          CIBW_TEST_COMMAND: "pytest -q {project}/tests -k 'not slow' -x"
+          CIBW_TEST_EXTRAS: "test"
+          CIBW_ENVIRONMENT: >
+            OMP_NUM_THREADS=1
+            OPENBLAS_NUM_THREADS=1
+          CIBW_BEFORE_BUILD_LINUX: |
+            yum -y install openblas-devel
+            find /usr/include -name cblas.h -print
+          CIBW_ENVIRONMENT_LINUX: >
+            CPPFLAGS="-I/usr/include/openblas"
+            CFLAGS="-I/usr/include/openblas"
+            LD_LIBRARY_PATH="/usr/lib64:$LD_LIBRARY_PATH"
+            CMAKE_ARGS="-DBLAS_LIBRARIES=/usr/lib64/libopenblas.so -DBLAS_INCLUDE_DIR=/usr/include/openblas -DCMAKE_CXX_FLAGS=-I/usr/include/openblas -DCMAKE_C_FLAGS=-I/usr/include/openblas"
+            OPENBLAS_NUM_THREADS=1
+            OMP_NUM_THREADS=1
+          CIBW_ENVIRONMENT_PASS_LINUX: >
+            CPPFLAGS
+            CFLAGS
+            LD_LIBRARY_PATH
+            CMAKE_ARGS
+            OPENBLAS_NUM_THREADS
+            OMP_NUM_THREADS
+          CIBW_ENVIRONMENT_MACOS: >
+            MACOSX_DEPLOYMENT_TARGET=15.0
+            CMAKE_ARGS="-DBLAS_VENDOR=Apple
+              -DCMAKE_CXX_FLAGS=-I/opt/homebrew/opt/libomp/include
+              -DCMAKE_C_FLAGS=-I/opt/homebrew/opt/libomp/include
+              -DCMAKE_SHARED_LINKER_FLAGS=-L/opt/homebrew/opt/libomp/lib
+              -DCMAKE_EXE_LINKER_FLAGS=-L/opt/homebrew/opt/libomp/lib"
+          CIBW_ENVIRONMENT_PASS_MACOS: >
+            MACOSX_DEPLOYMENT_TARGET
+            CMAKE_ARGS
+          CIBW_ARCHS_MACOS: arm64
+        run: python -m cibuildwheel --output-dir wheelhouse
+
+      - name: Build sdist
+        run: python -m pip install build && python -m build --sdist -o wheelhouse
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ runner.os }}
+          path: wheelhouse/*
+  publish:
+    needs: build-wheels
+    runs-on: ubuntu-22.04
+    if: github.event_name == 'release' || github.event_name == 'workflow_dispatch'
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: wheels-Linux
+          path: dist
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: wheels-macOS
+          path: dist
+
+      - name: Flatten artifacts
+        run: |
+          mkdir -p dist/flat
+          find dist -name '*.whl' -exec cp {} dist/flat/ \;
+          find dist -name '*.tar.gz' -exec cp {} dist/flat/ \;
+
+      - uses: pypa/gh-action-pypi-publish@v1.11.0
+        with:
+          packages-dir: dist/flat
+

{kernelforge-0.1.2 → kernelforge-0.1.13}/.gitignore

@@ -208,3 +208,5 @@ cython_debug/
 marimo/_static/
 marimo/_lsp/
 __marimo__/
+
+uv.lock

kernelforge-0.1.13/CMakeLists.txt

@@ -0,0 +1,138 @@
+cmake_minimum_required(VERSION 3.18)
+project(kernelforge LANGUAGES C CXX)
+
+# Platform tweaks
+if(APPLE)
+
+  # Required for "new lapack" in Accelerate
+  set(CMAKE_OSX_DEPLOYMENT_TARGET "15.0" CACHE STRING "" FORCE)
+  add_compile_definitions(ACCELERATE_NEW_LAPACK)
+  set(CMAKE_OSX_ARCHITECTURES "arm64" CACHE STRING "" FORCE)
+
+  # Necessary to compile with -Accelerate, homebrew clang and openmp
+  # Took me way too long to figure out
+  add_compile_options(-stdlib=libc++)
+  add_link_options(
+    -stdlib=libc++
+    -L/opt/homebrew/opt/llvm/lib/c++
+    -Wl,-rpath,/opt/homebrew/opt/llvm/lib/c++
+  )
+
+endif()
+
+# Position-independent code for all targets (helps for Python extensions)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+# Dependencies
+find_package(Python COMPONENTS Interpreter Development.Module REQUIRED)
+execute_process(
+  COMMAND "${Python_EXECUTABLE}" -m pybind11 --cmakedir
+  OUTPUT_VARIABLE pybind11_DIR
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+find_package(pybind11 CONFIG REQUIRED)
+
+find_package(OpenMP REQUIRED)
+if (OpenMP_CXX_FOUND)
+  if (APPLE)
+    # Apple/Homebrew Clang requires explicit flags
+    add_compile_options(-Xclang -fopenmp -I/opt/homebrew/opt/libomp/include)
+    add_link_options(-L/opt/homebrew/opt/libomp/lib -lomp)
+  else()
+    add_compile_options(${OpenMP_CXX_FLAGS})
+    add_link_options(${OpenMP_CXX_FLAGS})
+  endif()
+endif()
+
+# Use Accelerate on Apple, otherwise BLAS (MKL, OpenBLAS, etc)
+if(APPLE)
+  find_library(ACCELERATE Accelerate REQUIRED)
+else()
+  find_package(BLAS REQUIRED)
+endif()
+
+# Common interface for headers from Python/pybind11
+add_library(kf_common INTERFACE)
+target_link_libraries(kf_common INTERFACE pybind11::headers Python::Module)
+
+# ---- Small helpers to avoid repetition --------------------------------------
+# Track created modules/objlibs so we can link things in one go later
+set(_KF_ALL_MODULES "")
+set(_KF_ALL_OBJLIBS "")
+
+# Create a C++ object library + pybind11 module pair:
+#   kf_add_cpp_module(<base> <obj_src> <binding_src>)
+#   -> object lib: kf_<base>
+#   -> module target: _<base>
+function(kf_add_cpp_module base obj_src bind_src)
+  set(obj kf_${base})
+  add_library(${obj} OBJECT ${obj_src})
+  target_link_libraries(${obj} PRIVATE kf_common)
+  target_link_libraries(${obj} PRIVATE OpenMP::OpenMP_CXX) # <-- compile flags propagate
+
+  pybind11_add_module(_${base} MODULE
+    ${bind_src}
+    $<TARGET_OBJECTS:${obj}>
+  )
+  set_target_properties(_${base} PROPERTIES OUTPUT_NAME "_${base}")
+  target_link_libraries(_${base} PRIVATE OpenMP::OpenMP_CXX) # <-- link flags
+
+  list(APPEND _KF_ALL_MODULES _${base})
+  list(APPEND _KF_ALL_OBJLIBS ${obj})
+  set(_KF_ALL_MODULES "${_KF_ALL_MODULES}" PARENT_SCOPE)
+  set(_KF_ALL_OBJLIBS "${_KF_ALL_OBJLIBS}" PARENT_SCOPE)
+endfunction()
+
+# Portable optimization; native tuning is opt-in
+option(KF_USE_NATIVE "Enable -march/-mcpu=native style flags" OFF)
+
+function(kf_apply_cxx_flags tgt)
+  if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+    target_compile_options(${tgt} PRIVATE
+      -O3 -ffast-math -ftree-vectorize -fopenmp
+      $<$<BOOL:${KF_USE_NATIVE}>:-mcpu=native -mtune=native>
+    )
+  elseif (CMAKE_CXX_COMPILER_ID MATCHES "Intel")
+    target_compile_options(${tgt} PRIVATE
+      -O3 -ffast-math
+      $<$<BOOL:${KF_USE_NATIVE}>:-xHost -mtune=native>
+    )
+  endif()
+endfunction()
+
+# ---- C++ modules -------------------------------------------------------------
+kf_add_cpp_module(kernels  src/kernels.cpp                src/bindings_kernels.cpp)
+kf_add_cpp_module(invdist  src/invdist.cpp                src/invdist_bindings.cpp)
+kf_add_cpp_module(fchl19   src/fchl19_representation.cpp  src/bindings_fchl19.cpp)
+kf_add_cpp_module(cholesky src/cholesky.cpp               src/bindings_cholesky.cpp)
+
+# Apply C++ flags to the object libs (not to the module targets)
+foreach(obj ${_KF_ALL_OBJLIBS})
+  kf_apply_cxx_flags(${obj})
+endforeach()
+
+# ---- OpenMP (C++) ------------------------------------------------------------
+if (OpenMP_CXX_FOUND)
+  target_link_libraries(_cholesky PRIVATE OpenMP::OpenMP_CXX)
+  target_link_libraries(_kernels PRIVATE OpenMP::OpenMP_CXX)
+  target_link_libraries(_fchl19 PRIVATE OpenMP::OpenMP_CXX)
+  target_link_libraries(_invdist PRIVATE OpenMP::OpenMP_CXX)
+endif()
+
+# ---- BLAS/LAPACK backend selection (link all modules) -----------------------
+foreach(m ${_KF_ALL_MODULES})
+  if(APPLE)
+    target_link_libraries(${m} PRIVATE ${ACCELERATE})
+  elseif(WIN32)
+    target_link_libraries(${m} PRIVATE MKL::MKL)
+  else()
+    target_link_libraries(${m} PRIVATE BLAS::BLAS)
+  endif()
+endforeach()
+
+# ---- Install ----------------------------------------------------------------
+install(TARGETS _kernels _invdist _fchl19 _cholesky
+  LIBRARY DESTINATION kernelforge   # Linux/macOS
+  RUNTIME DESTINATION kernelforge   # Windows (.pyd)
+)
+install(FILES python/kernelforge/__init__.py DESTINATION kernelforge)

kernelforge-0.1.13/Makefile

@@ -0,0 +1,12 @@
+install-linux:
+	CMAKE_ARGS="-DKF_USE_NATIVE=ON" uv pip install -e .[test] --verbose
+
+install-macos:
+	CMAKE_ARGS="-DCMAKE_C_COMPILER=/opt/homebrew/opt/llvm/bin/clang -DCMAKE_CXX_COMPILER=/opt/homebrew/opt/llvm/bin/clang++ -DKF_USE_NATIVE=ON " uv pip install -e .[test] --verbose
+
+test:
+	pytest
+
+environment:
+	uv venv --python 3.14
+	uv pip install scikit-build-core pybind11

kernelforge-0.1.13/PKG-INFO

@@ -0,0 +1,188 @@
+Metadata-Version: 2.2
+Name: kernelforge
+Version: 0.1.13
+Summary: Optimized Kernels for ML
+Author: Anders Christensen
+License: MIT
+Project-URL: Homepage, https://github.com/andersx/kernelforge
+Project-URL: Issues, https://github.com/andersx/kernelforge/issues
+Requires-Python: >=3.10
+Requires-Dist: numpy>=2.00
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: pytest-xdist; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-timeout; extra == "test"
+Description-Content-Type: text/markdown
+
+# KernelForge - Optimized Kernels for ML
+
+I really only care about writing optimized kernel code, so this project will be completed as I find additional time... XD
+
+I'm reviving this project to finish an old project using random Fourier features for kernel ML.
+
+
+# Installation
+
+```bash
+conda env create -f environments/environment-dev.yml
+pip install -e .
+pytest -v -s
+```
+## PyPI installation
+
+Install the requirements (e.g. the conda env above) and install from PyPI.
+This should work on both MacOS and Linux/PC:
+
+```bash
+conda activate kernelforge-dev
+pip install kernelforge
+```
+This will install pre-compiled wheels with gfortran and linked againts OpenBLAS on Linux and Accelerate on MacOS.
+If you want to use MKL or other BLAS/LAPACK libraries, you need to compile from source, see below.
+
+
+## Intel compilers and MKL
+
+It is 2025 so you can `sudo apt get install intel-basekit` on Linux/PC to get the compilers and MKL.
+Then set up the environment variables:
+```bash
+source /opt/intel/oneapi/setvars.sh
+```
+In this case, MKL will be autodetected by some CMake magic. If you additionally want to compile with Intel compilers, you can set the environment variables when running `pip install`:
+```bash
+CC=icx CXX=icpx FC=ifx make install
+```
+
+In my experience, GCC/G++/GFortran with OpenBLAS is very similar to Intel API alternatives in terms of performance, perhaps even better.
+On MacOS, GNU compilers with `-framework Accelerate` for BLAS/LAPACK is the default and is very fast on M-series macs.
+
+## Timings
+I've rewritten a few of the kernels from the original QML code completely in C++.
+There are performance gains in most cases.
+These are primarily due to better use of BLAS routines for calculating, for example, Gramian sub-matrices with chunked DGEMM/DSYRK calls, etc.
+In the gradient and Hessian matrices there are also some algorithmic improvement and pre-computed terms.
+Memory usage might be a bit higher, but this could be optimized with more fine-graind chunking if needed.
+More is coming as I find the time ...
+
+Some speedups vs the original QML code are shown below:
+
+| Benchmark | QML [s] | Kernelforge [s] |
+|:---------------|------------:|--------------------:|
+| Upper triangle Gaussian kernel (16K x 16K) | 1.82 | 0.64 |
+| 1K FCHL19 descriptors (1K) | ? | 0.43 |
+| 1K FCHL19 descriptors+jacobian (1K) | ? | 0.62 |
+| FCHL19 Local Gaussian scalar kernel (10K x 10K) | 76.81 | 18.15 |
+| FCHL19 Local Gaussian gradient kernel (1K x 2700K) | 32.54 | 1.52 |
+| FCHL19 Local Gaussian Hessian kernel (5400K x 5400K) | 29.68 | 2.05 |
+
+## TODO list
+
+The goal is to remove pain-points of existing QML libraries
+- Removal of Fortran dependencies
+  - No Fortran-ordered arrays
+  - No Fortran compilers needed
+- Simplified build system
+  - No cooked F2PY/Meson build system, just CMake and Pybind11
+- Improved use of BLAS routines, with built-in chunking to avoid memory explosions
+- Better use of pre-computed terms for single-point inference/MD kernels
+- Low overhead with Pybind11 shims and better aligned memory?
+- Simplified entrypoints that are compatible with RDKit, ASE, Scikit-learn, etc.
+  - A few high-level functions that do the most common tasks efficiently and correctly
+- Efficient FCHL19 out-of-the-box
+  - Fast training with random Fourier features
+  - With derivatives
+
+
+## Priority list for the next months:
+
+- [x] Finish the inverse-distance kernel and its Jacobian
+- [x] Make Pybind11 interface
+  - [ ] Finalize the C++ interface
+- [x] Finish the Gaussian kernel
+- [x] Notebook with rMD17 example
+- [x] Finish the Jacobian and Hessian kernels
+- [x] Notebook with rMD17 forces example
+- FCHL19 support:
+  - [x] Add FCHL19 descriptors
+  - [x] Add FCHL19 kernels (local/elemental)
+  - [x] Add FCHL19 descriptor with derivatives
+  - [x] Add FCHL19 kernel Jacobian
+  - [x] Add FCHL19 kernel Hessian (GDML-style)
+  - [ ] Improve FCHL19 kernel Jacobian performance (its poor)
+- Finish the random Fourier features kernel and its Jacobian
+  - [ ] Parallel random basis sampler
+  - [ ] RFF kernel for global descriptors
+  - [ ] SVD and QR solvers for rectangular matrices
+  - [ ] RFF kernel for local descriptors (FCHL19)
+  - [ ] RFF kernels with Cholesky solver and chunked DSYRK kernel updates
+  - [ ] RFF kernels with RFP format with chunked DSFRK kernel updates
+  - [ ] RFF kernel Jacobian for global descriptors
+  - [ ] RFF kernel Jacobian for local descriptors (FCHL19)
+- [ ] Notebook with rMD17 random Fourier features examples
+
+- Science:
+  - Benchmark full kernel vs RFF on rMD17 and QM7b and QM9
+  - Both FCHL19 and inverse-distance matrix
+
+#### Todos:
+- Houskeeping:
+  - [x] Pybind11 bindings and CMake build system
+  - [x] Setup CI with GitHub Actions
+  - [x] Rewrite existing kernels to C++ (no Fortran)
+  - [x] Setup GHA to build PyPI wheels
+  - [x] Test Linux build matrices
+  - [x] Test MacOS build matrices
+  - [ ] Test Windows build matrices
+  - [x] Add build for all Python version >=3.11
+  - [ ] Plan structure for saving models for inference as `.npz` files
+- Ensure correct linking with optimized BLAS/LAPACK libraries:
+  - [x] OpenBLAS (Linux) <- also used in wheels
+  - [x] MKL (Linux)
+  - [x] Accelerate (MacOS)
+- Add global kernels:
+  - [x] Gaussian kernel
+  - [x] Jacobian/gradient kernel
+  - [ ] Optimized Jacobian kernel for single inference
+  - [x] Hessian kernel
+  - [x] GDML-like kernel
+  - [ ] Full GPR kernel
+- Add local kernels:
+  - [x] Gaussian kernel
+  - [x] Jacobian/gradient kernel
+  - [x] Optimized Jacobian kernel for single inference
+  - [x] Hessian kernel (GDML-style)
+  - [ ] Full GPR kernel
+  - [ ] Optimized GPR kernel with pre-computed terms for single inference/MD
+- Add random Fourier features kernel code:
+  - [ ] Fourier-basis sampler
+  - [ ] RFF kernel
+  - [ ] RFF gradient kernel
+  - [ ] RFF chunked DSYRK kernel
+  - [ ] Optimized RFF gradient kernel for single inference/MD
+  - The same as above, just for Hadamard features when I find the time?
+- GDML and sGDML kernels:
+  - [x] Inverse-distance matrix descriptor
+  - [ ] Packed Jacobian for inverse-distance matrix
+  - [x] GDML kernel (brute-force implemented)
+  - [ ] sGDML kernel (brute-force implemented)
+  - [ ] Full GPR kernel
+  - [ ] Optimized GPR kernel with pre-computed terms for single inference/MD
+- FCHL18 support:
+  - [ ] Complete rewrite of FCHL18 analytical scalar kernel in C++
+  - [ ] Stretch goal 1: Add new analytical FCHL18 kernel Jacobian
+  - [ ] Stretch goal 2: Add new analytical FCHL18 kernel Hessian (+GPR/GDML-style)
+  - [ ] Stretch goal 3: Attempt to optimize hyperparameters and cut-off functions
+- Add standard solvers:
+  - [x] Cholesky in-place solver
+    - [x] L2-reg kwarg
+    - [x] Toggle destructive vs non-destructive
+  - [ ] QR and/or SVD for non-square matrices
+- Add moleular descriptors with derivatives:
+  - [ ] Coulomb matrix + misc variants without derivatives
+  - [x] FCHL19 + derivatives
+  - [x] GDML-like inverse-distance matrix + derivatives
+#### Stretch goals:
+- [ ] Plan RDKit interface
+- [ ] Plan Scikit-learn interface
+- [ ] Plan ASE interface

kernelforge-0.1.13/README.md

@@ -0,0 +1,171 @@
+# KernelForge - Optimized Kernels for ML
+
+I really only care about writing optimized kernel code, so this project will be completed as I find additional time... XD
+
+I'm reviving this project to finish an old project using random Fourier features for kernel ML.
+
+
+# Installation
+
+```bash
+conda env create -f environments/environment-dev.yml
+pip install -e .
+pytest -v -s
+```
+## PyPI installation
+
+Install the requirements (e.g. the conda env above) and install from PyPI.
+This should work on both MacOS and Linux/PC:
+
+```bash
+conda activate kernelforge-dev
+pip install kernelforge
+```
+This will install pre-compiled wheels with gfortran and linked againts OpenBLAS on Linux and Accelerate on MacOS.
+If you want to use MKL or other BLAS/LAPACK libraries, you need to compile from source, see below.
+
+
+## Intel compilers and MKL
+
+It is 2025 so you can `sudo apt get install intel-basekit` on Linux/PC to get the compilers and MKL.
+Then set up the environment variables:
+```bash
+source /opt/intel/oneapi/setvars.sh
+```
+In this case, MKL will be autodetected by some CMake magic. If you additionally want to compile with Intel compilers, you can set the environment variables when running `pip install`:
+```bash
+CC=icx CXX=icpx FC=ifx make install
+```
+
+In my experience, GCC/G++/GFortran with OpenBLAS is very similar to Intel API alternatives in terms of performance, perhaps even better.
+On MacOS, GNU compilers with `-framework Accelerate` for BLAS/LAPACK is the default and is very fast on M-series macs.
+
+## Timings
+I've rewritten a few of the kernels from the original QML code completely in C++.
+There are performance gains in most cases.
+These are primarily due to better use of BLAS routines for calculating, for example, Gramian sub-matrices with chunked DGEMM/DSYRK calls, etc.
+In the gradient and Hessian matrices there are also some algorithmic improvement and pre-computed terms.
+Memory usage might be a bit higher, but this could be optimized with more fine-graind chunking if needed.
+More is coming as I find the time ...
+
+Some speedups vs the original QML code are shown below:
+
+| Benchmark | QML [s] | Kernelforge [s] |
+|:---------------|------------:|--------------------:|
+| Upper triangle Gaussian kernel (16K x 16K) | 1.82 | 0.64 |
+| 1K FCHL19 descriptors (1K) | ? | 0.43 |
+| 1K FCHL19 descriptors+jacobian (1K) | ? | 0.62 |
+| FCHL19 Local Gaussian scalar kernel (10K x 10K) | 76.81 | 18.15 |
+| FCHL19 Local Gaussian gradient kernel (1K x 2700K) | 32.54 | 1.52 |
+| FCHL19 Local Gaussian Hessian kernel (5400K x 5400K) | 29.68 | 2.05 |
+
+## TODO list
+
+The goal is to remove pain-points of existing QML libraries
+- Removal of Fortran dependencies
+  - No Fortran-ordered arrays
+  - No Fortran compilers needed
+- Simplified build system
+  - No cooked F2PY/Meson build system, just CMake and Pybind11
+- Improved use of BLAS routines, with built-in chunking to avoid memory explosions
+- Better use of pre-computed terms for single-point inference/MD kernels
+- Low overhead with Pybind11 shims and better aligned memory?
+- Simplified entrypoints that are compatible with RDKit, ASE, Scikit-learn, etc.
+  - A few high-level functions that do the most common tasks efficiently and correctly
+- Efficient FCHL19 out-of-the-box
+  - Fast training with random Fourier features
+  - With derivatives
+
+
+## Priority list for the next months:
+
+- [x] Finish the inverse-distance kernel and its Jacobian
+- [x] Make Pybind11 interface
+  - [ ] Finalize the C++ interface
+- [x] Finish the Gaussian kernel
+- [x] Notebook with rMD17 example
+- [x] Finish the Jacobian and Hessian kernels
+- [x] Notebook with rMD17 forces example
+- FCHL19 support:
+  - [x] Add FCHL19 descriptors
+  - [x] Add FCHL19 kernels (local/elemental)
+  - [x] Add FCHL19 descriptor with derivatives
+  - [x] Add FCHL19 kernel Jacobian
+  - [x] Add FCHL19 kernel Hessian (GDML-style)
+  - [ ] Improve FCHL19 kernel Jacobian performance (its poor)
+- Finish the random Fourier features kernel and its Jacobian
+  - [ ] Parallel random basis sampler
+  - [ ] RFF kernel for global descriptors
+  - [ ] SVD and QR solvers for rectangular matrices
+  - [ ] RFF kernel for local descriptors (FCHL19)
+  - [ ] RFF kernels with Cholesky solver and chunked DSYRK kernel updates
+  - [ ] RFF kernels with RFP format with chunked DSFRK kernel updates
+  - [ ] RFF kernel Jacobian for global descriptors
+  - [ ] RFF kernel Jacobian for local descriptors (FCHL19)
+- [ ] Notebook with rMD17 random Fourier features examples
+
+- Science:
+  - Benchmark full kernel vs RFF on rMD17 and QM7b and QM9
+  - Both FCHL19 and inverse-distance matrix
+
+#### Todos:
+- Houskeeping:
+  - [x] Pybind11 bindings and CMake build system
+  - [x] Setup CI with GitHub Actions
+  - [x] Rewrite existing kernels to C++ (no Fortran)
+  - [x] Setup GHA to build PyPI wheels
+  - [x] Test Linux build matrices
+  - [x] Test MacOS build matrices
+  - [ ] Test Windows build matrices
+  - [x] Add build for all Python version >=3.11
+  - [ ] Plan structure for saving models for inference as `.npz` files
+- Ensure correct linking with optimized BLAS/LAPACK libraries:
+  - [x] OpenBLAS (Linux) <- also used in wheels
+  - [x] MKL (Linux)
+  - [x] Accelerate (MacOS)
+- Add global kernels:
+  - [x] Gaussian kernel
+  - [x] Jacobian/gradient kernel
+  - [ ] Optimized Jacobian kernel for single inference
+  - [x] Hessian kernel
+  - [x] GDML-like kernel
+  - [ ] Full GPR kernel
+- Add local kernels:
+  - [x] Gaussian kernel
+  - [x] Jacobian/gradient kernel
+  - [x] Optimized Jacobian kernel for single inference
+  - [x] Hessian kernel (GDML-style)
+  - [ ] Full GPR kernel
+  - [ ] Optimized GPR kernel with pre-computed terms for single inference/MD
+- Add random Fourier features kernel code:
+  - [ ] Fourier-basis sampler
+  - [ ] RFF kernel
+  - [ ] RFF gradient kernel
+  - [ ] RFF chunked DSYRK kernel
+  - [ ] Optimized RFF gradient kernel for single inference/MD
+  - The same as above, just for Hadamard features when I find the time?
+- GDML and sGDML kernels:
+  - [x] Inverse-distance matrix descriptor
+  - [ ] Packed Jacobian for inverse-distance matrix
+  - [x] GDML kernel (brute-force implemented)
+  - [ ] sGDML kernel (brute-force implemented)
+  - [ ] Full GPR kernel
+  - [ ] Optimized GPR kernel with pre-computed terms for single inference/MD
+- FCHL18 support:
+  - [ ] Complete rewrite of FCHL18 analytical scalar kernel in C++
+  - [ ] Stretch goal 1: Add new analytical FCHL18 kernel Jacobian
+  - [ ] Stretch goal 2: Add new analytical FCHL18 kernel Hessian (+GPR/GDML-style)
+  - [ ] Stretch goal 3: Attempt to optimize hyperparameters and cut-off functions
+- Add standard solvers:
+  - [x] Cholesky in-place solver
+    - [x] L2-reg kwarg
+    - [x] Toggle destructive vs non-destructive
+  - [ ] QR and/or SVD for non-square matrices
+- Add moleular descriptors with derivatives:
+  - [ ] Coulomb matrix + misc variants without derivatives
+  - [x] FCHL19 + derivatives
+  - [x] GDML-like inverse-distance matrix + derivatives
+#### Stretch goals:
+- [ ] Plan RDKit interface
+- [ ] Plan Scikit-learn interface
+- [ ] Plan ASE interface