Repository: jrenaud90/CyRK (language: python)

Issue:
Version 0.8.6
Major Changes:
- Added support for Python 3.12.
- Converted `CySolver`'s `rk_step` method into a pure-c implementation to allow for further optimizations.
- Changed all files to compile with c rather than c++.
  - Had to change cpp_bools to bints to make this change.

Bug Fixes:
- Fixed issue where CyRK was not installing on MacOS due to issue with LLVM and OpenMP. 
  - Have opted to go to gcc for macOS install due to issues with OpenMP and clang.
- Fixed incorrect type for rk method in CySolver (should eliminate some compile warnings).
- Fixed issue in benchmark where incorrect results were being displayed for CySolver.


Discussion / hints:

Fix patch:
diff --git a/.github/workflows/build_wheels_main_pypi.yml b/.github/workflows/build_wheels_main_pypi.yml
index f7fd489..0f72691 100644
--- a/.github/workflows/build_wheels_main_pypi.yml
+++ b/.github/workflows/build_wheels_main_pypi.yml
@@ -11,16 +11,17 @@ jobs:
     name: Make SDist
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
         submodules: true  # Optional, use if you have submodules
 
     - name: Build SDist
       run: pipx run build --sdist
 
-    - uses: actions/upload-artifact@v3
+    - uses: actions/upload-artifact@v4
       with:
         path: dist/*.tar.gz
+        name: artifact_sdist        
 
   build_macos_wheel:
     name: Build MacOS wheel for Python ${{ matrix.python }}
@@ -34,12 +35,13 @@ jobs:
           - "3.9"
           - "3.10"
           - "3.11"
+          - "3.12"
     steps:
       - name: Checkout CyRK
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Install Anaconda
-        uses: conda-incubator/setup-miniconda@v2
+        uses: conda-incubator/setup-miniconda@v3
         with:
           activate-environment: cyrk_test
           auto-update-conda: true
@@ -50,32 +52,24 @@ jobs:
         shell: bash -el {0}
         run: conda info
 
-      - name: Install llvm and libomp
+      - name: install gcc-13  # openMP does not play nice with clang on MacOS; also some versions of macos use older gcc so there is a need to install latest.
         shell: bash -el {0}
         run: |
-          brew reinstall llvm libomp
-
-      - name: Install Dependencies
-        shell: bash -el {0}
-        run: |
-          conda install numpy scipy cython llvm-openmp pytest
-          python -m pip install --upgrade build
+          brew install gcc@13
 
       - name: Install package
         shell: bash -el {0}
         run: |
-          export CC=/usr/bin/clang
-          export CXX=/usr/bin/clang++
-          export PATH="/usr/local/opt/llvm/bin:$PATH"
-          export CPPFLAGS="$CPPFLAGS -Xpreprocessor -fopenmp -I/usr/local/opt/llvm/include"
-          export CFLAGS="$CFLAGS -I/usr/local/opt/libomp/include"
-          export CXXFLAGS="$CXXFLAGS -I/usr/local/opt/libomp/include"
-          export LDFLAGS="$LDFLAGS -Wl,-rpath,/usr/local/opt/libomp/lib -L/usr/local/opt/libomp/lib -lomp -L/usr/local/opt/llvm/lib"
+          conda install pytest matplotlib numba numpy scipy cython
+          python -m pip install --upgrade build
+          export CC='gcc-13'
+          export CPPFLAGS="$CPPFLAGS -Xpreprocessor -fopenmp -lgomp"
           python -m build --wheel --outdir ./wheelhouse/
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           path: ./wheelhouse/*.whl
+          name: artifact_Macos_${{ matrix.python }}_whl
 
   build_other_wheels:
     name: Build ${{ matrix.platform }} wheels
@@ -89,41 +83,41 @@ jobs:
           - ubuntu-20.04
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
       - name: Build wheels
-        uses: pypa/cibuildwheel@v2.14.1
+        uses: pypa/cibuildwheel@v2.16.5
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           path: ./wheelhouse/*.whl
+          name: artifact_${{ matrix.platform }}_whls
 
   check_dist:
-    name: Check dist
+    name: Check sdist
     needs: [make_sdist, build_macos_wheel, build_other_wheels]
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
-          name: artifact
-          path: dist
+          name: artifact_sdist
+          path: sdist
 
-      - run: pipx run twine check --strict dist/*
+      - run: pipx run twine check --strict sdist/*
 
   upload_all:
     name: Upload wheels to PyPI
     needs: [build_macos_wheel, build_other_wheels, make_sdist, check_dist]
     runs-on: ubuntu-latest
-    if: github.event_name == 'release' && github.event.action == 'published'
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
-          name: artifact
+          merge-multiple: true
           path: dist
 
-      - uses: pypa/gh-action-pypi-publish@v1.8.8
+      - uses: pypa/gh-action-pypi-publish@v1.8.11
         with:
           user: __token__
           password: ${{ secrets.PYPI_API_TOKEN }}
diff --git a/.gitignore b/.gitignore
index 5aaba5e..83d67b8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,6 +5,7 @@
 
 # Include non-generated c files
 !CyRK/array/interp_common.c
+!CyRK/cy/rk_step.c
 
 # Ignore coverage files
 .coverage
@@ -17,6 +18,7 @@ __pycache__/
 # Objext files
 *.so
 *.o
+*.exe
 
 # Distribution / packaging
 .Python
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000..fb26150
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,58 @@
+{
+    "files.associations": {
+        "iterator": "c",
+        "xmemory": "c",
+        "xutility": "c",
+        "atomic": "c",
+        "bit": "c",
+        "cctype": "c",
+        "charconv": "c",
+        "clocale": "c",
+        "cmath": "c",
+        "compare": "c",
+        "complex": "c",
+        "concepts": "c",
+        "cstddef": "c",
+        "cstdint": "c",
+        "cstdio": "c",
+        "cstdlib": "c",
+        "cstring": "c",
+        "ctime": "c",
+        "cwchar": "c",
+        "exception": "c",
+        "format": "c",
+        "initializer_list": "c",
+        "ios": "c",
+        "iosfwd": "c",
+        "istream": "c",
+        "limits": "c",
+        "locale": "c",
+        "memory": "c",
+        "mutex": "c",
+        "new": "c",
+        "ostream": "c",
+        "ratio": "c",
+        "sstream": "c",
+        "stdexcept": "c",
+        "stop_token": "c",
+        "streambuf": "c",
+        "string": "c",
+        "system_error": "c",
+        "thread": "c",
+        "tuple": "c",
+        "type_traits": "c",
+        "typeinfo": "c",
+        "utility": "c",
+        "xfacet": "c",
+        "xiosbase": "c",
+        "xlocale": "c",
+        "xlocbuf": "c",
+        "xlocinfo": "c",
+        "xlocmes": "c",
+        "xlocmon": "c",
+        "xlocnum": "c",
+        "xloctime": "c",
+        "xstring": "c",
+        "xtr1common": "c"
+    }
+}
\ No newline at end of file
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
new file mode 100644
index 0000000..cbf1a6a
--- /dev/null
+++ b/.vscode/tasks.json
@@ -0,0 +1,28 @@
+{
+    "tasks": [
+        {
+            "type": "cppbuild",
+            "label": "C/C++: gcc.exe build active file",
+            "command": "C:\\Software\\mingw64\\bin\\gcc.exe",
+            "args": [
+                "-fdiagnostics-color=always",
+                "-g",
+                "${file}",
+                "-o",
+                "${fileDirname}\\${fileBasenameNoExtension}.exe"
+            ],
+            "options": {
+                "cwd": "${fileDirname}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "detail": "Task generated by Debugger."
+        }
+    ],
+    "version": "2.0.0"
+}
\ No newline at end of file
diff --git a/Benchmarks/CyRK - SciPy Comparison.ipynb b/Benchmarks/CyRK - SciPy Comparison.ipynb
index ffa20d4..434d755 100644
--- a/Benchmarks/CyRK - SciPy Comparison.ipynb
+++ b/Benchmarks/CyRK - SciPy Comparison.ipynb
@@ -18,7 +18,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0.8.4\n"
+      "0.9.0a0.dev1\n"
      ]
     }
    ],
@@ -256,7 +256,7 @@
     "# CyRK - Cython CySolver\n",
     "CySolverTesterInst = CySolverTester(time_span, initial_conds, rk_method=1, args=args, rtol=rtol, atol=atol, auto_solve=True)\n",
     "print('CyRK (Cython - CySolver) Solution')\n",
-    "diff_plot(time_domain, y_results, fig_name='CyRK_CySolver')"
+    "diff_plot(CySolverTesterInst.t, CySolverTesterInst.y, fig_name='CyRK_CySolver')"
    ]
   },
   {
@@ -271,9 +271,7 @@
    "cell_type": "code",
    "execution_count": 7,
    "id": "5c43792b",
-   "metadata": {
-    "scrolled": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -470,7 +468,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -541,9 +539,7 @@
    "cell_type": "code",
    "execution_count": 9,
    "id": "697a88bd",
-   "metadata": {
-    "scrolled": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -551,41 +547,41 @@
      "text": [
       "How much faster X is vs. Y\n",
       "End Time: 1.0e-03\n",
-      "\t nbrk_ode =  11.0x solve_ivp\t cyrk_ode =  16.8x solve_ivp\n",
-      "\t CySolver =  21.7x solve_ivp\t nbrk_ode =   0.7x cyrk_ode\n",
-      "\t CySolver =   2.0x nbrk_ode\t CySolver =   1.3x cyrk_ode\n",
+      "\t nbrk_ode =  10.6x solve_ivp\t cyrk_ode =  16.9x solve_ivp\n",
+      "\t CySolver =  65.4x solve_ivp\t nbrk_ode =   0.6x cyrk_ode\n",
+      "\t CySolver =   6.2x nbrk_ode\t CySolver =   3.9x cyrk_ode\n",
       "End Time: 1.0e-02\n",
-      "\t nbrk_ode =  10.9x solve_ivp\t cyrk_ode =  17.1x solve_ivp\n",
-      "\t CySolver =  21.9x solve_ivp\t nbrk_ode =   0.6x cyrk_ode\n",
-      "\t CySolver =   2.0x nbrk_ode\t CySolver =   1.3x cyrk_ode\n",
+      "\t nbrk_ode =  10.6x solve_ivp\t cyrk_ode =  16.8x solve_ivp\n",
+      "\t CySolver =  65.8x solve_ivp\t nbrk_ode =   0.6x cyrk_ode\n",
+      "\t CySolver =   6.2x nbrk_ode\t CySolver =   3.9x cyrk_ode\n",
       "End Time: 1.0e-01\n",
-      "\t nbrk_ode =  16.0x solve_ivp\t cyrk_ode =  20.4x solve_ivp\n",
-      "\t CySolver =  32.0x solve_ivp\t nbrk_ode =   0.8x cyrk_ode\n",
-      "\t CySolver =   2.0x nbrk_ode\t CySolver =   1.6x cyrk_ode\n",
+      "\t nbrk_ode =  14.7x solve_ivp\t cyrk_ode =  20.0x solve_ivp\n",
+      "\t CySolver =  88.4x solve_ivp\t nbrk_ode =   0.7x cyrk_ode\n",
+      "\t CySolver =   6.0x nbrk_ode\t CySolver =   4.4x cyrk_ode\n",
       "End Time: 1.0e+00\n",
-      "\t nbrk_ode =  30.2x solve_ivp\t cyrk_ode =  28.0x solve_ivp\n",
-      "\t CySolver =  66.0x solve_ivp\t nbrk_ode =   1.1x cyrk_ode\n",
-      "\t CySolver =   2.2x nbrk_ode\t CySolver =   2.4x cyrk_ode\n",
+      "\t nbrk_ode =  29.3x solve_ivp\t cyrk_ode =  26.8x solve_ivp\n",
+      "\t CySolver = 161.1x solve_ivp\t nbrk_ode =   1.1x cyrk_ode\n",
+      "\t CySolver =   5.5x nbrk_ode\t CySolver =   6.0x cyrk_ode\n",
       "End Time: 1.0e+01\n",
-      "\t nbrk_ode =  93.5x solve_ivp\t cyrk_ode =  36.8x solve_ivp\n",
-      "\t CySolver = 296.3x solve_ivp\t nbrk_ode =   2.5x cyrk_ode\n",
-      "\t CySolver =   3.2x nbrk_ode\t CySolver =   8.0x cyrk_ode\n",
+      "\t nbrk_ode =  94.2x solve_ivp\t cyrk_ode =  35.7x solve_ivp\n",
+      "\t CySolver = 397.4x solve_ivp\t nbrk_ode =   2.6x cyrk_ode\n",
+      "\t CySolver =   4.2x nbrk_ode\t CySolver =  11.1x cyrk_ode\n",
       "End Time: 1.0e+02\n",
-      "\t nbrk_ode = 122.5x solve_ivp\t cyrk_ode =  37.7x solve_ivp\n",
-      "\t CySolver = 466.5x solve_ivp\t nbrk_ode =   3.2x cyrk_ode\n",
-      "\t CySolver =   3.8x nbrk_ode\t CySolver =  12.4x cyrk_ode\n",
+      "\t nbrk_ode = 108.5x solve_ivp\t cyrk_ode =  34.8x solve_ivp\n",
+      "\t CySolver = 450.8x solve_ivp\t nbrk_ode =   3.1x cyrk_ode\n",
+      "\t CySolver =   4.2x nbrk_ode\t CySolver =  12.9x cyrk_ode\n",
       "End Time: 1.0e+03\n",
-      "\t nbrk_ode = 113.8x solve_ivp\t cyrk_ode =  35.5x solve_ivp\n",
-      "\t CySolver = 446.3x solve_ivp\t nbrk_ode =   3.2x cyrk_ode\n",
-      "\t CySolver =   3.9x nbrk_ode\t CySolver =  12.6x cyrk_ode\n",
+      "\t nbrk_ode = 113.6x solve_ivp\t cyrk_ode =  36.1x solve_ivp\n",
+      "\t CySolver = 444.4x solve_ivp\t nbrk_ode =   3.1x cyrk_ode\n",
+      "\t CySolver =   3.9x nbrk_ode\t CySolver =  12.3x cyrk_ode\n",
       "End Time: 1.0e+04\n",
-      "\t nbrk_ode = 103.0x solve_ivp\t cyrk_ode =  37.4x solve_ivp\n",
-      "\t CySolver = 465.8x solve_ivp\t nbrk_ode =   2.8x cyrk_ode\n",
-      "\t CySolver =   4.5x nbrk_ode\t CySolver =  12.5x cyrk_ode\n",
+      "\t nbrk_ode = 104.9x solve_ivp\t cyrk_ode =  37.5x solve_ivp\n",
+      "\t CySolver = 455.6x solve_ivp\t nbrk_ode =   2.8x cyrk_ode\n",
+      "\t CySolver =   4.3x nbrk_ode\t CySolver =  12.2x cyrk_ode\n",
       "End Time: 1.0e+05\n",
-      "\t nbrk_ode =  96.9x solve_ivp\t cyrk_ode =  37.5x solve_ivp\n",
-      "\t CySolver = 426.3x solve_ivp\t nbrk_ode =   2.6x cyrk_ode\n",
-      "\t CySolver =   4.4x nbrk_ode\t CySolver =  11.4x cyrk_ode\n"
+      "\t nbrk_ode =  98.6x solve_ivp\t cyrk_ode =  36.9x solve_ivp\n",
+      "\t CySolver = 427.0x solve_ivp\t nbrk_ode =   2.7x cyrk_ode\n",
+      "\t CySolver =   4.3x nbrk_ode\t CySolver =  11.6x cyrk_ode\n"
      ]
     }
    ],
diff --git a/Benchmarks/CyRK_CySolver.pdf b/Benchmarks/CyRK_CySolver.pdf
index db79627..def4daf 100644
Binary files a/Benchmarks/CyRK_CySolver.pdf and b/Benchmarks/CyRK_CySolver.pdf differ
diff --git a/Benchmarks/CyRK_SciPy_Compare_predprey_v0-8-6.png b/Benchmarks/CyRK_SciPy_Compare_predprey_v0-8-6.png
new file mode 100644
index 0000000..d9167c2
Binary files /dev/null and b/Benchmarks/CyRK_SciPy_Compare_predprey_v0-8-6.png differ
diff --git a/Benchmarks/CyRK_SciPy_Compare_predprey_v0-9-0a0-dev1.png b/Benchmarks/CyRK_SciPy_Compare_predprey_v0-9-0a0-dev1.png
new file mode 100644
index 0000000..f505f64
Binary files /dev/null and b/Benchmarks/CyRK_SciPy_Compare_predprey_v0-9-0a0-dev1.png differ
diff --git a/Benchmarks/CyRK_cyrk_ode.pdf b/Benchmarks/CyRK_cyrk_ode.pdf
index db79627..def4daf 100644
Binary files a/Benchmarks/CyRK_cyrk_ode.pdf and b/Benchmarks/CyRK_cyrk_ode.pdf differ
diff --git a/Benchmarks/CyRK_numba.pdf b/Benchmarks/CyRK_numba.pdf
index 0d9ad7d..4664038 100644
Binary files a/Benchmarks/CyRK_numba.pdf and b/Benchmarks/CyRK_numba.pdf differ
diff --git a/Benchmarks/SciPy.pdf b/Benchmarks/SciPy.pdf
index f23ab24..8d6a362 100644
Binary files a/Benchmarks/SciPy.pdf and b/Benchmarks/SciPy.pdf differ
diff --git a/CHANGES.md b/CHANGES.md
index 726de9d..c01bb19 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,32 @@
 # CyRK - Change Log
 
+## 2024
+
+### v0.9.0 (2024-05-22)
+
+Major Changes:
+- Shifted from using the Python-based `PyMem_Alloc`, `PyMem_Free` to c-based `malloc`, `free`. 
+- CySolver `_solve` method is now gil-free.
+  - This has led to a 35%--230% speed boost at low values of steps (faster start up).
+
+#### v0.8.7 (2024-02-13)
+
+Updated manifest and rebuilt wheels.
+
+#### v0.8.6 (2024-02-13)
+
+Major Changes:
+- Added support for Python 3.12.
+- Converted `CySolver`'s `rk_step` method into a pure-c implementation to allow for further optimizations.
+- Changed all files to compile with c rather than c++.
+  - Had to change cpp_bools to bints to make this change.
+
+Bug Fixes:
+- Fixed issue where CyRK was not installing on MacOS due to issue with LLVM and OpenMP. 
+  - Have opted to go to gcc for macOS install due to issues with OpenMP and clang.
+- Fixed incorrect type for rk method in CySolver (should eliminate some compile warnings).
+- Fixed issue in benchmark where incorrect results were being displayed for CySolver.
+
 ## 2023
 
 #### v0.8.5 (2023-10-27)
diff --git a/CyRK/array/interp.pyx b/CyRK/array/interp.pyx
index 07920d1..fb63238 100644
--- a/CyRK/array/interp.pyx
+++ b/CyRK/array/interp.pyx
@@ -1,4 +1,4 @@
-# distutils: language = c++
+# distutils: language = c
 # cython: boundscheck=False, wraparound=False, nonecheck=False, cdivision=True, initializedcheck=False
 from cython.parallel import prange
 
diff --git a/CyRK/cy/common.pxd b/CyRK/cy/common.pxd
index abe8b6d..79af6b6 100644
--- a/CyRK/cy/common.pxd
+++ b/CyRK/cy/common.pxd
@@ -1,10 +1,8 @@
-# distutils: language = c++
+
 ctypedef fused double_numeric:
     double
     double complex
 
-from libcpp cimport bool as bool_cpp_t
-
 cdef double SAFETY
 cdef double MIN_FACTOR
 cdef double MAX_FACTOR
@@ -33,16 +31,16 @@ cdef void interpolate(
         size_t t_len_full,
         size_t t_len_reduced,
         size_t target_len,
-        bool_cpp_t is_complex
-        ) noexcept
+        bint is_complex
+        ) noexcept nogil
 
 cdef size_t find_expected_size(
         size_t y_size,
         size_t num_extra,
         double t_delta_abs,
         double rtol_min,
-        bool_cpp_t capture_extra,
-        bool_cpp_t is_complex
+        bint capture_extra,
+        bint is_complex
         ) noexcept nogil
 
 
@@ -51,7 +49,7 @@ cdef void find_max_num_steps(
         size_t num_extra,
         size_t max_num_steps,
         size_t max_ram_MB,
-        bool_cpp_t capture_extra,
-        bool_cpp_t is_complex,
-        bool_cpp_t* user_provided_max_num_steps,
+        bint capture_extra,
+        bint is_complex,
+        bint* user_provided_max_num_steps,
         size_t* max_num_steps_touse) noexcept nogil
\ No newline at end of file
diff --git a/CyRK/cy/common.pyx b/CyRK/cy/common.pyx
index 98ccbab..c2a9343 100644
--- a/CyRK/cy/common.pyx
+++ b/CyRK/cy/common.pyx
@@ -1,4 +1,4 @@
-# distutils: language = c++
+# distutils: language = c
 # cython: boundscheck=False, wraparound=False, nonecheck=False, cdivision=True, initializedcheck=False
 import cython
 
@@ -6,7 +6,7 @@ from libc.math cimport fmax, fmin, floor
 from libc.math cimport INFINITY as INF
 from libc.float cimport DBL_EPSILON as EPS
 from libc.stdint cimport SIZE_MAX, INT32_MAX
-from cpython.mem cimport PyMem_Free
+from libc.stdlib cimport free
 
 from CyRK.utils.utils cimport allocate_mem, reallocate_mem
 from CyRK.array.interp cimport interp_array_ptr, interp_complex_array_ptr
@@ -46,8 +46,8 @@ cdef void interpolate(
         size_t t_len_full,
         size_t t_len_reduced,
         size_t target_len,
-        bool_cpp_t is_complex
-        ) noexcept:
+        bint is_complex
+        ) noexcept nogil:
     """ Interpolate the results of a successful integration over the user provided time domain, `time_domain_full`. """
 
     # Setup loop variables
@@ -96,10 +96,10 @@ cdef void interpolate(
     finally:
         # Release memory of any temporary variables
         if not (array_slice_ptr is NULL):
-            PyMem_Free(array_slice_ptr)
+            free(array_slice_ptr)
             array_slice_ptr = NULL
         if not (interpolated_array_slice_ptr is NULL):
-            PyMem_Free(interpolated_array_slice_ptr)
+            free(interpolated_array_slice_ptr)
             interpolated_array_slice_ptr = NULL
 
 cdef size_t find_expected_size(
@@ -107,8 +107,8 @@ cdef size_t find_expected_size(
         size_t num_extra,
         double t_delta_abs,
         double rtol_min,
-        bool_cpp_t capture_extra,
-        bool_cpp_t is_complex) noexcept nogil:
+        bint capture_extra,
+        bint is_complex) noexcept nogil:
 
     cdef double temp_expected_size
     # Pick starting value that works with most problems
@@ -145,9 +145,9 @@ cdef void find_max_num_steps(
         size_t num_extra,
         size_t max_num_steps,
         size_t max_ram_MB,
-        bool_cpp_t capture_extra,
-        bool_cpp_t is_complex,
-        bool_cpp_t* user_provided_max_num_steps,
+        bint capture_extra,
+        bint is_complex,
+        bint* user_provided_max_num_steps,
         size_t* max_num_steps_touse) noexcept nogil:
 
     # Determine max number of steps
diff --git a/CyRK/cy/cyrk.pyx b/CyRK/cy/cyrk.pyx
index 6a8d65b..5ed33c5 100644
--- a/CyRK/cy/cyrk.pyx
+++ b/CyRK/cy/cyrk.pyx
@@ -1,15 +1,13 @@
-# distutils: language = c++
+# distutils: language = c
 # cython: boundscheck=False, wraparound=False, nonecheck=False, cdivision=True, initializedcheck=False
 
 import cython
 
-from cpython.mem cimport PyMem_Free
+from libc.stdlib cimport free
 
 import numpy as np
 cimport numpy as np
-np.import_array()
 
-from libcpp cimport bool as bool_cpp_t
 from libc.math cimport sqrt, fabs, nextafter, NAN, floor
 
 from CyRK.utils.utils cimport allocate_mem, reallocate_mem
@@ -80,9 +78,9 @@ def cyrk_ode(
         double first_step = 0.,
         unsigned char rk_method = 1,
         double[:] t_eval = None,
-        bool_cpp_t capture_extra = False,
+        bint capture_extra = False,
         size_t num_extra = 0,
-        bool_cpp_t interpolate_extra = False,
+        bint interpolate_extra = False,
         size_t expected_size = 0,
         size_t max_num_steps = 0,
         size_t max_ram_MB = 2000
@@ -148,7 +146,7 @@ def cyrk_ode(
             ```
     num_extra : int = 0
         The number of extra outputs the integrator should expect. With the previous example there is 1 extra output.
-    interpolate_extra : bool_cpp_t, default=False
+    interpolate_extra : bint, default=False
         Flag if interpolation should be run on extra parameters.
         If set to False when `run_interpolation=True`, then interpolation will be run on solution's y, t. These will
         then be used to recalculate extra parameters rather than an interpolation on the extra parameters captured
@@ -181,7 +179,7 @@ def cyrk_ode(
     # Determine information about the differential equation based on its initial conditions
     cdef size_t y_size
     cdef double y_size_dbl, y_size_sqrt
-    cdef bool_cpp_t y_is_complex
+    cdef bint y_is_complex
     y_size       = y0.size
     y_is_complex = False
     y_size_dbl   = <double>y_size
@@ -201,7 +199,7 @@ def cyrk_ode(
 
     # Build time domain
     cdef double t_start, t_end, t_delta, t_delta_check, t_delta_abs, direction_inf, t_old, t_now, time_
-    cdef bool_cpp_t direction_flag
+    cdef bint direction_flag
     t_start       = t_span[0]
     t_end         = t_span[1]
     t_delta       = t_end - t_start
@@ -218,7 +216,7 @@ def cyrk_ode(
         direction_inf = -INF
 
     # Pull out information on args
-    cdef bool_cpp_t use_args
+    cdef bint use_args
     if args is None:
         use_args = False
     else:
@@ -271,7 +269,7 @@ def cyrk_ode(
     
     # Determine max number of steps
     cdef size_t max_num_steps_touse
-    cdef bool_cpp_t user_provided_max_num_steps
+    cdef bint user_provided_max_num_steps
     find_max_num_steps(
         y_size,
         num_extra,
@@ -363,7 +361,7 @@ def cyrk_ode(
     cdef double_numeric[::1] diffeq_out_view = diffeq_out_array
 
     # Determine interpolation information
-    cdef bool_cpp_t run_interpolation
+    cdef bint run_interpolation
     cdef size_t len_t_eval
     if t_eval is None:
         run_interpolation = False
@@ -486,7 +484,7 @@ def cyrk_ode(
     cdef double step, step_size, min_step, step_factor
 
     # Integration flags and variables
-    cdef bool_cpp_t success, step_accepted, step_rejected, step_error
+    cdef bint success, step_accepted, step_rejected, step_error
     cdef size_t len_t
 
     # Integration completion variables
@@ -666,7 +664,7 @@ def cyrk_ode(
                                     # Initialize
                                     y_view[i] = y_old_ptr[i]
 
-                                y_view[i] += K_ptr[j * y_size + i] * A_at_sj
+                                y_view[i] = y_view[i] + K_ptr[j * y_size + i] * A_at_sj
 
                     if use_args:
                         diffeq(time_, y_array, diffeq_out_array, *args)
@@ -686,7 +684,7 @@ def cyrk_ode(
                             # Initialize
                             y_view[i] = y_old_ptr[i]
 
-                        y_view[i] += K_ptr[j * y_size + i] * B_at_j
+                        y_view[i] = y_view[i] + K_ptr[j * y_size + i] * B_at_j
 
                 # Find final dydt for this timestep
                 if use_args:
@@ -871,14 +869,14 @@ def cyrk_ode(
         else:
             # Clear the storage arrays used during the step loop
             if not (time_domain_array_ptr is NULL):
-                PyMem_Free(time_domain_array_ptr)
+                free(time_domain_array_ptr)
                 time_domain_array_ptr = NULL
             if not (y_results_array_ptr is NULL):
-                PyMem_Free(y_results_array_ptr)
+                free(y_results_array_ptr)
                 y_results_array_ptr = NULL
             if capture_extra:
                 if not (extra_array_ptr is NULL):
-                    PyMem_Free(extra_array_ptr)
+                    free(extra_array_ptr)
                     extra_array_ptr = NULL
 
             # Integration was not successful. Leave the solution pointers as length 1 nan arrays.
@@ -969,17 +967,17 @@ def cyrk_ode(
 
                 # Replace old pointers with new interpolated pointers and release the memory for the old stuff
                 if not (solution_extra_ptr is NULL):
-                    PyMem_Free(solution_extra_ptr)
+                    free(solution_extra_ptr)
                 solution_extra_ptr = interpolated_solution_extra_ptr
                 interpolated_solution_extra_ptr = NULL
 
             # Replace old pointers with new interpolated pointers and release the memory for the old stuff
             if not (solution_t_ptr is NULL):
-                PyMem_Free(solution_t_ptr)
+                free(solution_t_ptr)
             solution_t_ptr = interpolated_solution_t_ptr
             interpolated_solution_t_ptr = NULL
             if not (solution_y_ptr is NULL):
-                PyMem_Free(solution_y_ptr)
+                free(solution_y_ptr)
             solution_y_ptr = interpolated_solution_y_ptr
             interpolated_solution_y_ptr = NULL
 
@@ -1002,14 +1000,14 @@ def cyrk_ode(
                     solution_y_view[extra_start + j, i] = solution_extra_ptr[i * num_extra + j]
         # Free solution arrays
         if not (solution_t_ptr is NULL):
-            PyMem_Free(solution_t_ptr)
+            free(solution_t_ptr)
             solution_t_ptr = NULL
         if not (solution_y_ptr is NULL):
-            PyMem_Free(solution_y_ptr)
+            free(solution_y_ptr)
             solution_y_ptr = NULL
         if capture_extra:
             if not (solution_extra_ptr is NULL):
-                PyMem_Free(solution_extra_ptr)
+                free(solution_extra_ptr)
                 solution_extra_ptr = NULL
 
         # Update integration message
@@ -1031,55 +1029,55 @@ def cyrk_ode(
     finally:
         # Free pointers made from user inputs
         if not (tol_ptrs is NULL):
-            PyMem_Free(tol_ptrs)
+            free(tol_ptrs)
             tol_ptrs = NULL
         if not (t_eval_ptr is NULL):
-            PyMem_Free(t_eval_ptr)
+            free(t_eval_ptr)
             t_eval_ptr = NULL
 
         # Free pointers used to track y, dydt, and any extra outputs
         if not (y_storage_ptrs is NULL):
-            PyMem_Free(y_storage_ptrs)
+            free(y_storage_ptrs)
             y_storage_ptrs = NULL
         if not (extra_output_init_ptr is NULL):
-            PyMem_Free(extra_output_init_ptr)
+            free(extra_output_init_ptr)
             extra_output_init_ptr = NULL
         if not (extra_output_ptr is NULL):
-            PyMem_Free(extra_output_ptr)
+            free(extra_output_ptr)
             extra_output_ptr = NULL
 
         # Free RK Temp Storage Array
         if not (K_ptr is NULL):
-            PyMem_Free(K_ptr)
+            free(K_ptr)
             K_ptr = NULL
 
         # Free other pointers that should have been freed in main loop, but in case of an exception they were missed.
         if not (solution_t_ptr is NULL):
-            PyMem_Free(solution_t_ptr)
+            free(solution_t_ptr)
             solution_t_ptr = NULL
         if not (solution_y_ptr is NULL):
-            PyMem_Free(solution_y_ptr)
+            free(solution_y_ptr)
             solution_y_ptr = NULL
         if not (solution_extra_ptr is NULL):
-            PyMem_Free(solution_extra_ptr)
+            free(solution_extra_ptr)
             solution_extra_ptr = NULL
         if not (interpolated_solution_t_ptr is NULL):
-            PyMem_Free(interpolated_solution_t_ptr)
+            free(interpolated_solution_t_ptr)
             interpolated_solution_t_ptr= NULL
         if not (interpolated_solution_y_ptr is NULL):
-            PyMem_Free(interpolated_solution_y_ptr)
+            free(interpolated_solution_y_ptr)
             interpolated_solution_y_ptr = NULL
         if not (interpolated_solution_extra_ptr is NULL):
-            PyMem_Free(interpolated_solution_extra_ptr)
+            free(interpolated_solution_extra_ptr)
             interpolated_solution_extra_ptr = NULL
         if not (time_domain_array_ptr is NULL):
-            PyMem_Free(time_domain_array_ptr)
+            free(time_domain_array_ptr)
             time_domain_array_ptr = NULL
         if not (y_results_array_ptr is NULL):
-            PyMem_Free(y_results_array_ptr)
+            free(y_results_array_ptr)
             y_results_array_ptr = NULL
         if not (extra_array_ptr is NULL):
-            PyMem_Free(extra_array_ptr)
+            free(extra_array_ptr)
             extra_array_ptr = NULL
 
     return solution_t, solution_y, success, message
diff --git a/CyRK/cy/cysolver.pxd b/CyRK/cy/cysolver.pxd
index 80388b3..e282fbe 100644
--- a/CyRK/cy/cysolver.pxd
+++ b/CyRK/cy/cysolver.pxd
@@ -1,6 +1,3 @@
-from libcpp cimport bool as bool_cpp_t
-
-
 cdef class CySolver:
 
     # Class attributes
@@ -8,9 +5,6 @@ cdef class CySolver:
     cdef double* solution_y_ptr
     cdef double* solution_t_ptr
     cdef double* solution_extra_ptr
-    cdef double[::1] solution_t_view
-    cdef double[::1] solution_y_view
-    cdef double[::1] solution_extra_view
 
     # -- Dependent (y0) variable information
     cdef size_t y_size
@@ -19,39 +13,40 @@ cdef class CySolver:
 
     # -- Time information
     cdef double t_start, t_end, t_delta, t_delta_abs, direction_inf
-    cdef bool_cpp_t direction_flag
+    cdef bint direction_flag
 
     # -- Optional args info
     cdef size_t num_args
     cdef double* args_ptr
-    cdef bool_cpp_t use_args
+    cdef bint use_args
 
     # -- Extra output info
-    cdef bool_cpp_t capture_extra
+    cdef bint capture_extra
     cdef size_t num_extra
 
     # -- Integration information
     cdef readonly char status
-    cdef readonly str message
-    cdef public bool_cpp_t success
+    cdef readonly char* _message
+    cdef public bint success
     cdef double* tol_ptrs
     cdef double* rtols_ptr
     cdef double* atols_ptr
     cdef double first_step, max_step
-    cdef bool_cpp_t user_provided_max_num_steps
+    cdef bint user_provided_max_num_steps
     cdef size_t max_num_steps
     cdef size_t expected_size, current_size, num_concats
-    cdef bool_cpp_t recalc_first_step
-    cdef bool_cpp_t force_fail
+    cdef bint recalc_first_step
+    cdef bint force_fail
 
     # -- Interpolation info
-    cdef bool_cpp_t run_interpolation
-    cdef bool_cpp_t interpolate_extra
+    cdef bint run_interpolation
+    cdef bint interpolate_extra
     cdef size_t len_t_eval
     cdef double* t_eval_ptr
 
     # -- RK method information
-    cdef size_t rk_method, rk_order, error_order, rk_n_stages, rk_n_stages_plus1
+    cdef unsigned char rk_method
+    cdef size_t rk_order, error_order, rk_n_stages, rk_n_stages_plus1
     cdef double error_expo
     cdef size_t len_C, len_Arows, len_Acols
     cdef double* A_ptr
@@ -86,54 +81,45 @@ cdef class CySolver:
     cdef double* _interpolate_solution_extra_ptr
 
     # Class functions
-    cpdef void reset_state(
-            self
-            )
-
-    cdef double calc_first_step(
+    cdef void _reset_state(
             self
             ) noexcept nogil
 
-    cdef void rk_step(
+    cdef double calc_first_step(
             self
             ) noexcept nogil
 
-    cpdef void solve(
-            self,
-            bool_cpp_t reset = *
-            )
-
     cdef void _solve(
             self,
-            bool_cpp_t reset = *
-            )
+            bint reset
+            ) noexcept nogil
 
     cdef void interpolate(
             self
-            )
+            ) noexcept nogil
 
     cpdef void change_t_span(
             self,
             (double, double) t_span,
-            bool_cpp_t auto_reset_state = *
+            bint auto_reset_state = *
             )
 
     cpdef void change_y0(
             self,
             const double[::1] y0,
-            bool_cpp_t auto_reset_state = *
+            bint auto_reset_state = *
             )
 
     cdef void change_y0_pointer(
             self,
             double * y0_ptr,
-            bool_cpp_t auto_reset_state = *
-            )
+            bint auto_reset_state = *
+            ) noexcept nogil
 
     cpdef void change_args(
             self,
             tuple args,
-            bool_cpp_t auto_reset_state = *
+            bint auto_reset_state = *
             )
 
     cpdef void change_tols(
@@ -142,32 +128,32 @@ cdef class CySolver:
             double atol = *,
             const double[::1] rtols = *,
             const double[::1] atols = *,
-            bool_cpp_t auto_reset_state = *
+            bint auto_reset_state = *
             )
 
     cpdef void change_max_step(
             self,
             double max_step,
-            bool_cpp_t auto_reset_state = *
+            bint auto_reset_state = *
             )
 
     cpdef void change_first_step(
             self,
             double first_step,
-            bool_cpp_t auto_reset_state = *
+            bint auto_reset_state = *
             )
 
     cpdef void change_t_eval(
             self,
             const double[::1] t_eval,
-            bool_cpp_t auto_reset_state = *
+            bint auto_reset_state = *
             )
 
     cdef void change_t_eval_pointer(
             self,
             double* new_t_eval_ptr,
             size_t new_len_t_eval,
-            bool_cpp_t auto_reset_state = *
+            bint auto_reset_state = *
             )
 
     cpdef void change_parameters(
@@ -182,8 +168,8 @@ cdef class CySolver:
             double max_step = *,
             double first_step = *,
             const double[::1] t_eval = *,
-            bool_cpp_t auto_reset_state = *,
-            bool_cpp_t auto_solve = *
+            bint auto_reset_state = *,
+            bint auto_solve = *
             )
 
     cdef void update_constants(
@@ -193,3 +179,56 @@ cdef class CySolver:
     cdef void diffeq(
             self
             ) noexcept nogil
+
+ctypedef void (*DiffeqType)(CySolver)
+
+cdef extern from "rk_step.c":
+    int rk_step_cf(
+        # Pointer to differential equation
+        DiffeqType diffeq_ptr,
+        # Pointer to the CySolver instance
+        CySolver cysolver_inst,
+
+        # t-related variables
+        double t_end,
+        bint direction_flag,
+        double direction_inf,
+
+        # y-related variables
+        size_t y_size,
+        double y_size_dbl,
+        double y_size_sqrt,
+
+        # Pointers to class attributes that can change during rk_step call.
+        double* t_now_ptr,
+        double* y_ptr,
+        double* dy_ptr,
+        double* t_old_ptr,
+        double* y_old_ptr,
+        double* dy_old_ptr,
+        double* step_size_ptr,
+        char* status_ptr,
+
+        # Integration tolerance variables and pointers
+        double* atols_ptr,
+        double* rtols_ptr,
+        double max_step,
+
+        # RK specific variables and pointers
+        unsigned char rk_method,
+        size_t rk_n_stages,
+        size_t rk_n_stages_plus1,
+        size_t len_Acols,
+        size_t len_C,
+        double* A_ptr,
+        double* B_ptr,
+        double* C_ptr,
+        double* K_ptr,
+        double* E_ptr,
+        double* E3_ptr,
+        double* E5_ptr,
+        double error_expo,
+        double min_step_factor,
+        double max_step_factor,
+        double error_safety
+        ) noexcept nogil
\ No newline at end of file
diff --git a/CyRK/cy/cysolver.pyx b/CyRK/cy/cysolver.pyx
index 347027c..e833756 100644
--- a/CyRK/cy/cysolver.pyx
+++ b/CyRK/cy/cysolver.pyx
@@ -1,16 +1,13 @@
-# distutils: language = c++
+# distutils: language = c
 # cython: boundscheck=False, wraparound=False, nonecheck=False, cdivision=True, initializedcheck=False
 
-from libcpp cimport bool as bool_cpp_t
-from libc.math cimport sqrt, fabs, nextafter, fmax, fmin, isnan, NAN, pow, floor
+from libc.math cimport sqrt, fabs, nextafter, fmax, fmin, isnan, NAN, floor
 
-from cpython.mem cimport PyMem_Free
+from libc.stdlib cimport free
 
 import numpy as np
 cimport numpy as np
 
-np.import_array()
-
 from CyRK.utils.utils cimport allocate_mem, reallocate_mem
 from CyRK.rk.rk cimport find_rk_properties
 from CyRK.cy.common cimport interpolate, SAFETY, MIN_FACTOR, MAX_FACTOR, MAX_STEP, INF, EPS_100, \
@@ -69,22 +66,22 @@ cdef class CySolver:
         Absolute value of t_delta.
     direction_inf : double
         Direction of integration. If forward then this = +Inf; -Inf otherwise.
-    direction_flag : bool_cpp_t
+    direction_flag : bint
         If True, then integration is in the forward direction.
     num_args : size_t
         Number of additional arguments that the `diffeq` method requires.
     args_ptr : double*
         Pointer of additional arguments used in the `diffeq` method.
-    capture_extra bool_cpp_t
+    capture_extra bint
         Flag used if extra parameters should be captured during integration.
     num_extra size_t
         Number of extra parameters that should be captured during integration.
     status : char; public
         Numerical flag to indicate status of integrator.
         See "Status and Error Codes.md" in the documentation for more information.
-    message : str; public
-        Verbal message to accompany `self.status` explaining the state (and potential errors) of the integrator.
-    success : bool_cpp_t; public
+    _message : str; public
+        Verbal _message to accompany `self.status` explaining the state (and potential errors) of the integrator.
+    success : bint; public
         Flag indicating if the integration was successful or not.
     rtols_ptr : double*
         Pointer of relative tolerances for each dependent y variable.
@@ -104,12 +101,12 @@ cdef class CySolver:
         If `expected_size` is too small then it will be expanded as needed. This variable tracks how many expansions
         were required.
         See Also: `CySolver.growths`
-    recalc_first_step : bool_cpp_t
+    recalc_first_step : bint
         If True, then the `first_step` size is recalculated when `reset_state` is called.
         Flag used when parameters are changed without reinitializing CySolver.
-    run_interpolation : bool_cpp_t
+    run_interpolation : bint
         Flag if a final interpolation should be run once integration is completed successfully.
-    interpolate_extra : bool_cpp_t
+    interpolate_extra : bint
         Flag if interpolation should be run on extra parameters.
         If set to False when `run_interpolation=True`, then interpolation will be run on solution's y, t. These will
         then be used to recalculate extra parameters rather than an interpolation on the extra parameters captured
@@ -231,14 +228,14 @@ cdef class CySolver:
             double first_step = 0.,
             size_t max_num_steps = 0,
             const double[::1] t_eval = None,
-            bool_cpp_t capture_extra = False,
+            bint capture_extra = False,
             size_t num_extra = 0,
-            bool_cpp_t interpolate_extra = False,
+            bint interpolate_extra = False,
             size_t expected_size = 0,
             size_t max_ram_MB = 2000,
-            bool_cpp_t call_first_reset = True,
-            bool_cpp_t auto_solve = True,
-            bool_cpp_t force_fail = False):
+            bint call_first_reset = True,
+            bint auto_solve = True,
+            bint force_fail = False):
         """
         Initialize new CySolver instance.
 
@@ -292,7 +289,7 @@ cdef class CySolver:
                 ```
         num_extra : int = 0
             The number of extra outputs the integrator should expect. With the previous example there is 1 extra output.
-        interpolate_extra : bool_cpp_t, default=False
+        interpolate_extra : bint, default=False
             Flag if interpolation should be run on extra parameters.
             If set to False when `run_interpolation=True`, then interpolation will be run on solution's y, t. These will
             then be used to recalculate extra parameters rather than an interpolation on the extra parameters captured
@@ -305,7 +302,7 @@ cdef class CySolver:
         call_first_reset : bool, default=True
             If set to True, then the solver will call its `reset_state` method at the end of initialization. This flag
             is overridden by the `auto_solve` flag.
-        auto_solve : bool_cpp_t, default=True
+        auto_solve : bint, default=True
             If set to True, then the solver's `solve` method will be called at the end of initialization.
             Otherwise, the user will have to call `solver_instance = CySolver(...); solver_instance.solve()`
             to perform integration.
@@ -348,7 +345,7 @@ cdef class CySolver:
 
         # Set integration information
         self.status  = -4  # Status code to indicate that integration has not started.
-        self.message = 'Integration has not started.'
+        self._message = 'Integration has not started.'
         self.success = False
         self.recalc_first_step = False
         self.force_fail = force_fail
@@ -503,11 +500,6 @@ cdef class CySolver:
         for i in range(self.num_extra):
             self.solution_extra_ptr[i] = NAN
 
-        # Have solution memoryviews point to these addresses
-        self.solution_t_view     = <double[:1]> self.solution_t_ptr
-        self.solution_y_view     = <double[:self.y_size]> self.solution_y_ptr
-        self.solution_extra_view = <double[:self.num_extra]> self.solution_extra_ptr
-
         # Determine interpolation information
         if t_eval is None:
             self.run_interpolation = False
@@ -560,7 +552,7 @@ cdef class CySolver:
         # Parameters are initialized but may not be set to correct values.
         # Call reset state to ensure everything is ready.
         if call_first_reset or auto_solve:
-            self.reset_state()
+            self._reset_state()
 
         # Run solver if requested
         if auto_solve:
@@ -568,7 +560,7 @@ cdef class CySolver:
             # So we can safely tell the solve method not to reset.
             self._solve(reset=False)
 
-    cpdef void reset_state(self):
+    cdef void _reset_state(self) noexcept nogil:
         """ Resets the class' state variables so that integration can be rerun. """
         cdef size_t i, j
         cdef double temp_double
@@ -612,11 +604,11 @@ cdef class CySolver:
         else:
             if self.first_step <= 0.:
                 self.status = -8
-                self.message = "Attribute error."
+                self._message = "Attribute error."
                 raise AttributeError('Error in user-provided step size: Step size must be a positive number.')
             elif self.first_step > self.t_delta_abs:
                 self.status = -8
-                self.message = "Attribute error."
+                self._message = "Attribute error."
                 raise AttributeError('Error in user-provided step size: Step size can not exceed bounds.')
             self.step_size = self.first_step
 
@@ -631,15 +623,13 @@ cdef class CySolver:
         for i in range(self.num_extra):
             self.solution_extra_ptr[i] = NAN
 
-        # Have solution memoryviews point to these addresses
-        self.solution_t_view     = <double[:1]> self.solution_t_ptr
-        self.solution_y_view     = <double[:self.y_size]> self.solution_y_ptr
-        self.solution_extra_view = <double[:self.num_extra]> self.solution_extra_ptr
-
-        # Other integration flags and messages
+        # Other integration flags and _messages
         self.success = False
         self.status = -5  # status == -5 means that reset has been called but solve has not yet been called.
-        self.message = "CySolver has been reset."
+        self._message = "CySolver has been reset."
+    
+    def reset_state(self):
+        self._reset_state()
 
     cdef double calc_first_step(self) noexcept nogil:
         """
@@ -707,248 +697,40 @@ cdef class CySolver:
 
         return step_size
 
-    cdef void rk_step(self) noexcept nogil:
-        """ Performs a Runge-Kutta step calculation including local error determination. """
-
-        # Initialize step variables
-        cdef size_t s, i, j
-        cdef double min_step, step, step_factor, time_tmp, t_delta_check
-        cdef double scale, temp_double
-        cdef double error_norm3, error_norm5, error_norm, error_dot_1, error_dot_2, error_denom, error_pow
-        cdef bool_cpp_t step_accepted, step_rejected, step_error
-
-        # Run RK integration step
-        # Determine step size based on previous loop
-        # Find minimum step size based on the value of t (less floating point numbers between numbers when t is large)
-        min_step = 10. * fabs(nextafter(self.t_old, self.direction_inf) - self.t_old)
-        # Look for over/undershoots in previous step size
-        if self.step_size > self.max_step:
-            self.step_size = self.max_step
-        elif self.step_size < min_step:
-            self.step_size = min_step
-
-        # Determine new step size
-        step_accepted = False
-        step_rejected = False
-        step_error    = False
-
-        # Optimization variables
-        cdef double A_at_10
-        # Define a very specific A (Row 1; Col 0) now since it is called consistently and does not change.
-        A_at_10 = self.A_ptr[1 * self.len_Acols + 0]
-
-        # # Step Loop
-        while not step_accepted:
-            if self.step_size < min_step:
-                step_error  = True
-                self.status = -1
-                break
-
-            # Move time forward for this particular step size
-            if self.direction_flag:
-                step          = self.step_size
-                self.t_now    = self.t_old + step
-                t_delta_check = self.t_now - self.t_end
-            else:
-                step          = -self.step_size
-                self.t_now    = self.t_old + step
-                t_delta_check = self.t_end - self.t_now
-
-            # Check that we are not at the end of integration with that move
-            if t_delta_check > 0.:
-                self.t_now = self.t_end
-
-                # If we are, correct the step so that it just hits the end of integration.
-                step = self.t_now - self.t_old
-                if self.direction_flag:
-                    self.step_size = step
-                else:
-                    self.step_size = -step
-
-            # # Calculate derivative using RK method
-
-            # t_now must be updated for each loop of s in order to make the diffeq calls.
-            # But we need to return to its original value later on. Store in temp variable.
-            time_tmp = self.t_now
-
-            for s in range(1, self.len_C):
-                # Update t_now so it can be used in the diffeq call.
-                self.t_now = self.t_old + self.C_ptr[s] * step
-
-                # Dot Product (K, a) * step
-                if s == 1:
-                    for i in range(self.y_size):
-                        # Set the first column of K
-                        temp_double = self.dy_old_ptr[i]
-                        # K[0, :] == first part of the array
-                        self.K_ptr[i] = temp_double
-
-                        # Calculate y_new for s==1
-                        self.y_ptr[i] = self.y_old_ptr[i] + (temp_double * A_at_10 * step)
-                else:
-                    for j in range(s):
-                        temp_double = self.A_ptr[s * self.len_Acols + j] * step
-                        for i in range(self.y_size):
-                            if j == 0:
-                                # Initialize
-                                self.y_ptr[i] = self.y_old_ptr[i]
-
-                            self.y_ptr[i] += self.K_ptr[j * self.y_size + i] * temp_double
-
-                # Call diffeq to update K with the new dydt
-                self.diffeq()
-
-                for i in range(self.y_size):
-                    self.K_ptr[s * self.y_size + i] = self.dy_ptr[i]
-
-            # Restore t_now to its previous value.
-            self.t_now = time_tmp
-
-            # Dot Product (K, B) * step
-            for j in range(self.rk_n_stages):
-                temp_double = self.B_ptr[j] * step
-                # We do not use rk_n_stages_plus1 here because we are chopping off the last row of K to match
-                #  the shape of B.
-                for i in range(self.y_size):
-                    if j == 0:
-                        # Initialize
-                        self.y_ptr[i] = self.y_old_ptr[i]
-
-                    self.y_ptr[i] += self.K_ptr[j * self.y_size + i] * temp_double
-
-            # Find final dydt for this timestep
-            self.diffeq()
-
-            # Check how well this step performed by calculating its error
-            if self.rk_method == 2:
-                # Calculate Error for DOP853
-                # Dot Product (K, E5) / scale and Dot Product (K, E3) * step / scale
-                error_norm3 = 0.
-                error_norm5 = 0.
-                for i in range(self.y_size):
-                    # Find scale of y for error calculations
-                    scale = (self.atols_ptr[i] +
-                             max(fabs(self.y_old_ptr[i]), fabs(self.y_ptr[i])) * self.rtols_ptr[i])
-
-                    # Set last array of K equal to dydt
-                    self.K_ptr[self.rk_n_stages * self.y_size + i] = self.dy_ptr[i]
-                    # Initialize
-                    error_dot_1 = 0.
-                    error_dot_2 = 0.
-                    for j in range(self.rk_n_stages_plus1):
-
-                        temp_double = self.K_ptr[j * self.y_size + i]
-                        error_dot_1 += temp_double * self.E3_ptr[j]
-                        error_dot_2 += temp_double * self.E5_ptr[j]
-
-                    # We need the absolute value but since we are taking the square, it is guaranteed to be positive.
-                    # TODO: This will need to change if CySolver ever accepts complex numbers
-                    # error_norm3_abs = fabs(error_dot_1)
-                    # error_norm5_abs = fabs(error_dot_2)
-                    error_dot_1 /= scale
-                    error_dot_2 /= scale
-
-                    error_norm3 += (error_dot_1 * error_dot_1)
-                    error_norm5 += (error_dot_2 * error_dot_2)
-
-                # Check if errors are zero
-                if (error_norm5 == 0.) and (error_norm3 == 0.):
-                    error_norm = 0.
-                else:
-                    error_denom = error_norm5 + 0.01 * error_norm3
-                    error_norm = self.step_size * error_norm5 / sqrt(error_denom * self.y_size_dbl)
-
-            else:
-                # Calculate Error for RK23 and RK45
-                # Dot Product (K, E) * step / scale
-                error_norm = 0.
-                for i in range(self.y_size):
-                    # Find scale of y for error calculations
-                    scale = (self.atols_ptr[i] +
-                             max(fabs(self.y_old_ptr[i]), fabs(self.y_ptr[i])) * self.rtols_ptr[i])
-
-                    # Set last array of K equal to dydt
-                    self.K_ptr[self.rk_n_stages * self.y_size + i] = self.dy_ptr[i]
-                    # Initialize
-                    error_dot_1 = 0.
-                    for j in range(self.rk_n_stages_plus1):
-
-                        error_dot_1 += self.K_ptr[j * self.y_size + i] * self.E_ptr[j]
-
-                    # We need the absolute value but since we are taking the square, it is guaranteed to be positive.
-                    # TODO: This will need to change if CySolver ever accepts complex numbers
-                    # error_norm_abs = fabs(error_dot_1)
-                    error_dot_1 *= (step / scale)
-
-                    error_norm += (error_dot_1 * error_dot_1)
-                error_norm = sqrt(error_norm) / self.y_size_sqrt
-
-            if error_norm < 1.:
-                # The error is low! Let's update this step for the next time loop
-                if error_norm == 0.:
-                    step_factor = MAX_FACTOR
-                else:
-                    error_pow = pow(error_norm, -self.error_expo)
-                    step_factor = fmin(MAX_FACTOR, SAFETY * error_pow)
-
-                if step_rejected:
-                    # There were problems with this step size on the previous step loop. Make sure factor does
-                    #    not exasperate them.
-                    step_factor = fmin(step_factor, 1.)
-
-                self.step_size = self.step_size * step_factor
-                step_accepted = True
-            else:
-                error_pow = pow(error_norm, -self.error_expo)
-                self.step_size = self.step_size * fmax(MIN_FACTOR, SAFETY * error_pow)
-                step_rejected = True
-
-        if step_error:
-            # Issue with step convergence
-            self.status = -1
-        elif not step_accepted:
-            # Issue with step convergence
-            self.status = -7
-
-        # End of step loop. Update the 'old' variables
-        self.t_old = self.t_now
-        for i in range(self.y_size):
-            self.y_old_ptr[i]  = self.y_ptr[i]
-            self.dy_old_ptr[i] = self.dy_ptr[i]
-
-    cpdef void solve(
+    def solve(
             self,
-            bool_cpp_t reset = True
+            bint reset = True
             ):
         """
         Public wrapper to the private solve method which calculates the integral of the user-provided system of ODEs.
         
         Parameters
         ----------
-        reset : bool_cpp_t, default=True
+        reset : bint, default=True
             If True, `reset_state()` will be called before integration starts.
         """
-        self._solve(reset=reset)
+        self._solve(reset)
 
     cdef void _solve(
             self,
-            bool_cpp_t reset = True
-            ):
+            bint reset
+            ) noexcept nogil:
         """
         Calculates the integral of the user-provided system of ODEs.
         
         Parameters
         ----------
-        reset : bool_cpp_t, default=True
+        reset : bint, default=True
             If True, `reset_state()` will be called before integration starts.
         """
 
         # Reset the solver's state (avoid issues if solve() is called multiple times).
         if reset:
-            self.reset_state()
+            self._reset_state()
 
         # Setup loop variables
         cdef size_t i
+        cdef int rk_step_output
 
         # Setup storage arrays
         # These arrays are built to fit a number of points equal to `self.expected_size`
@@ -1015,7 +797,43 @@ cdef class CySolver:
                 break
 
             # # Perform RK Step
-            self.rk_step()
+            rk_step_output = rk_step_cf(
+                self.diffeq,
+                self,
+                self.t_end,
+                self.direction_flag,
+                self.direction_inf,
+                self.y_size,
+                self.y_size_dbl,
+                self.y_size_sqrt,
+                &self.t_now,
+                self.y_ptr,
+                self.dy_ptr,
+                &self.t_old,
+                self.y_old_ptr,
+                self.dy_old_ptr,
+                &self.step_size,
+                &self.status,
+                self.atols_ptr,
+                self.rtols_ptr,
+                self.max_step,
+                self.rk_method,
+                self.rk_n_stages,
+                self.rk_n_stages_plus1,
+                self.len_Acols,
+                self.len_C,
+                self.A_ptr,
+                self.B_ptr,
+                self.C_ptr,
+                self.K_ptr,
+                self.E_ptr,
+                self.E3_ptr,
+                self.E5_ptr,
+                self.error_expo,
+                MIN_FACTOR,
+                MAX_FACTOR,
+                SAFETY
+                )
 
             # Check if an error occurred during step calculations before storing data.
             if self.status != 0:
@@ -1069,14 +887,14 @@ cdef class CySolver:
             # Solution was successful.
             # Free any data stored in solution arrays so that we can repopulate them with the new solution
             if not (self.solution_t_ptr is NULL):
-                PyMem_Free(self.solution_t_ptr)
+                free(self.solution_t_ptr)
                 self.solution_t_ptr = NULL
             if not (self.solution_y_ptr is NULL):
-                PyMem_Free(self.solution_y_ptr)
+                free(self.solution_y_ptr)
                 self.solution_y_ptr = NULL
             if self.capture_extra:
                 if not (self.solution_extra_ptr is NULL):
-                    PyMem_Free(self.solution_extra_ptr)
+                    free(self.solution_extra_ptr)
                     self.solution_extra_ptr = NULL
 
             # Load values into solution arrays.
@@ -1106,14 +924,14 @@ cdef class CySolver:
             # Integration was not successful. Make solution pointers length 1 nan arrays.
             # Clear the storage arrays used during the step loop
             if not (self._solve_time_domain_array_ptr is NULL):
-                PyMem_Free(self._solve_time_domain_array_ptr)
+                free(self._solve_time_domain_array_ptr)
                 self._solve_time_domain_array_ptr = NULL
             if not (self._solve_y_results_array_ptr is NULL):
-                PyMem_Free(self._solve_y_results_array_ptr)
+                free(self._solve_y_results_array_ptr)
                 self._solve_y_results_array_ptr = NULL
             if self.capture_extra:
                 if not (self._solve_extra_array_ptr is NULL):
-                    PyMem_Free(self._solve_extra_array_ptr)
+                    free(self._solve_extra_array_ptr)
                     self._solve_extra_array_ptr = NULL
 
             # We still need to build solution arrays so that accessing the solution will not cause access violations.
@@ -1150,44 +968,34 @@ cdef class CySolver:
             # If integration was not successful use t_len = 1 to allow for nan arrays
             self.len_t_touse = 1
 
-        # Convert solution pointers to a more user-friendly memoryview format.
-        # Define post-run variables
-        cdef size_t y_size_touse, extra_size_touse
-        y_size_touse     = self.y_size * self.len_t_touse
-        extra_size_touse = self.num_extra * self.len_t_touse
-
-        self.solution_t_view     = <double[:self.len_t_touse]> self.solution_t_ptr
-        self.solution_y_view     = <double[:y_size_touse]> self.solution_y_ptr
-        self.solution_extra_view = <double[:extra_size_touse]> self.solution_extra_ptr
-
-        # Update integration message
+        # Update integration _message
         if self.status == 1:
-            self.message = "Integration completed without issue."
+            self._message = "Integration completed without issue."
         elif self.status == 0:
-            self.message = "Integration is/was ongoing (perhaps it was interrupted?)."
+            self._message = "Integration is/was ongoing (perhaps it was interrupted?)."
         elif self.status == -1:
-            self.message = "Error in step size calculation:\n\tRequired step size is less than spacing between numbers."
+            self._message = "Error in step size calculation:\n\tRequired step size is less than spacing between numbers."
         elif self.status == -2:
-            self.message = "Maximum number of steps (set by user) exceeded during integration."
+            self._message = "Maximum number of steps (set by user) exceeded during integration."
         elif self.status == -3:
-            self.message = "Maximum number of steps (set by system architecture) exceeded during integration."
+            self._message = "Maximum number of steps (set by system architecture) exceeded during integration."
         elif self.status == -6:
-            self.message = "Integration never started: y-size is zero."
+            self._message = "Integration never started: y-size is zero."
         elif self.status == -7:
-            self.message = "Error in step size calculation:\n\tError in step size acceptance."
+            self._message = "Error in step size calculation:\n\tError in step size acceptance."
 
         # Release any memory that may still be alive due to exceptions being raised.
         if not (self._solve_time_domain_array_ptr is NULL):
-            PyMem_Free(self._solve_time_domain_array_ptr)
+            free(self._solve_time_domain_array_ptr)
             self._solve_time_domain_array_ptr = NULL
         if not (self._solve_y_results_array_ptr is NULL):
-            PyMem_Free(self._solve_y_results_array_ptr)
+            free(self._solve_y_results_array_ptr)
             self._solve_y_results_array_ptr = NULL
         if not (self._solve_extra_array_ptr is NULL):
-            PyMem_Free(self._solve_extra_array_ptr)
+            free(self._solve_extra_array_ptr)
             self._solve_extra_array_ptr = NULL
 
-    cdef void interpolate(self):
+    cdef void interpolate(self) noexcept nogil:
         """ Interpolate the results of a successful integration over the user provided time domain, `t_eval`. """
         # User only wants data at specific points.
         cdef char old_status
@@ -1272,17 +1080,17 @@ cdef class CySolver:
 
             # Replace old pointers with new interpolated pointers and release the memory for the old stuff
             if not (self.solution_extra_ptr is NULL):
-                PyMem_Free(self.solution_extra_ptr)
+                free(self.solution_extra_ptr)
             self.solution_extra_ptr = self._interpolate_solution_extra_ptr
             self._interpolate_solution_extra_ptr = NULL
 
         # Replace old pointers with new interpolated pointers and release the memory for the old stuff
         if not (self.solution_t_ptr is NULL):
-            PyMem_Free(self.solution_t_ptr)
+            free(self.solution_t_ptr)
         self.solution_t_ptr = self._interpolate_solution_t_ptr
         self._interpolate_solution_t_ptr = NULL
         if not (self.solution_y_ptr is NULL):
-            PyMem_Free(self.solution_y_ptr)
+            free(self.solution_y_ptr)
         self.solution_y_ptr = self._interpolate_solution_y_ptr
         self._interpolate_solution_y_ptr = NULL
 
@@ -1291,19 +1099,19 @@ cdef class CySolver:
 
         # Free any memory that may still be alive if exceptions were raised.
         if not (self._interpolate_solution_t_ptr is NULL):
-            PyMem_Free(self._interpolate_solution_t_ptr)
+            free(self._interpolate_solution_t_ptr)
             self._interpolate_solution_t_ptr = NULL
         if not (self._interpolate_solution_y_ptr is NULL):
-            PyMem_Free(self._interpolate_solution_y_ptr)
+            free(self._interpolate_solution_y_ptr)
             self._interpolate_solution_y_ptr = NULL
         if not (self._interpolate_solution_extra_ptr is NULL):
-            PyMem_Free(self._interpolate_solution_extra_ptr)
+            free(self._interpolate_solution_extra_ptr)
             self._interpolate_solution_extra_ptr = NULL
 
     cpdef void change_t_span(
             self,
             (double, double) t_span,
-            bool_cpp_t auto_reset_state = False
+            bint auto_reset_state = False
             ):
         """
         Public method to change the independent variable limits (start and stop points of integration).
@@ -1312,7 +1120,7 @@ cdef class CySolver:
         ----------
         t_span : (double, double)
             New t_span to use during integration.
-        auto_reset_state : bool_cpp_t, default=False
+        auto_reset_state : bint, default=False
             If True, then the `reset_state` method will be called once parameter is changed.
         """
 
@@ -1333,12 +1141,12 @@ cdef class CySolver:
         self.recalc_first_step = True
 
         if auto_reset_state:
-            self.reset_state()
+            self._reset_state()
 
     cpdef void change_y0(
             self,
             const double[::1] y0,
-            bool_cpp_t auto_reset_state = False
+            bint auto_reset_state = False
             ):
         """
         Public method to change the initial conditions.
@@ -1350,7 +1158,7 @@ cdef class CySolver:
         y0 : double[::1]
             New dependent variable initial conditions.
             Must be the same size as the original y0.
-        auto_reset_state : bool_cpp_t, default=False
+        auto_reset_state : bint, default=False
             If True, then the `reset_state` method will be called once parameter is changed.
         """
 
@@ -1361,7 +1169,7 @@ cdef class CySolver:
         if self.y_size != y_size_new:
             # So many things need to update if ysize changes that the user should just create a new class instance.
             self.status = -8
-            self.message = "Attribute error."
+            self._message = "Attribute error."
             raise AttributeError('New y0 must be the same size as the original y0 used to create CySolver class.'
                                  'Create new CySolver instance instead.')
 
@@ -1373,13 +1181,13 @@ cdef class CySolver:
         self.recalc_first_step = True
 
         if auto_reset_state:
-            self.reset_state()
+            self._reset_state()
 
     cdef void change_y0_pointer(
                 self,
                 double* y0_ptr,
-                bool_cpp_t auto_reset_state = False
-                ):
+                bint auto_reset_state = False
+                ) noexcept nogil:
             """
             Public method to change the initial conditions.
 
@@ -1390,7 +1198,7 @@ cdef class CySolver:
             y0 : double*
                 New pointer to dependent variable initial conditions.
                 Must be the same size as the original y0.
-            auto_reset_state : bool_cpp_t, default=False
+            auto_reset_state : bint, default=False
                 If True, then the `reset_state` method will be called once parameter is changed.
             """
 
@@ -1407,12 +1215,12 @@ cdef class CySolver:
             self.recalc_first_step = True
 
             if auto_reset_state:
-                self.reset_state()
+                self._reset_state()
 
     cpdef void change_args(
             self,
             tuple args,
-            bool_cpp_t auto_reset_state = False
+            bint auto_reset_state = False
             ):
         """
         Public method to change additional arguments used during integration.
@@ -1421,7 +1229,7 @@ cdef class CySolver:
         ----------
         args : tuple
             New tuple of additional arguments.
-        auto_reset_state : bool_cpp_t, default=False
+        auto_reset_state : bint, default=False
             If True, then the `reset_state` method will be called once parameter is changed.
         """
 
@@ -1454,7 +1262,7 @@ cdef class CySolver:
         self.recalc_first_step = True
 
         if auto_reset_state:
-            self.reset_state()
+            self._reset_state()
 
     cpdef void change_tols(
             self,
@@ -1462,7 +1270,7 @@ cdef class CySolver:
             double atol = NAN,
             const double[::1] rtols = None,
             const double[::1] atols = None,
-            bool_cpp_t auto_reset_state = False
+            bint auto_reset_state = False
             ):
         """
         Public method to change relative and absolute tolerances and/or their arrays.
@@ -1481,13 +1289,13 @@ cdef class CySolver:
         atols : const double[::1]
             Numpy ndarray of absolute tolerances, one for each dependent y variable.
             if None (the default), then no change will be made.
-        auto_reset_state : bool_cpp_t, default=False
+        auto_reset_state : bint, default=False
             If True, then the `reset_state` method will be called once parameter is changed.
         """
 
         # This is one of the few change functions where nothing might change.
         # Track if updates need to be made
-        cdef bool_cpp_t something_changed = False
+        cdef bint something_changed = False
 
         # Update tolerances
         cdef double rtol_tmp
@@ -1532,12 +1340,12 @@ cdef class CySolver:
             self.recalc_first_step = True
 
             if auto_reset_state:
-                self.reset_state()
+                self._reset_state()
 
     cpdef void change_max_step(
             self,
             double max_step,
-            bool_cpp_t auto_reset_state = False
+            bint auto_reset_state = False
             ):
         """
         Public method to change maximum allowed step size.
@@ -1546,19 +1354,19 @@ cdef class CySolver:
         ----------
         max_step : double
             New maximum step size used during integration.
-        auto_reset_state : bool_cpp_t, default=False
+        auto_reset_state : bint, default=False
             If True, then the `reset_state` method will be called once parameter is changed.
         """
 
         self.max_step = fabs(max_step)
 
         if auto_reset_state:
-            self.reset_state()
+            self._reset_state()
 
     cpdef void change_first_step(
             self,
             double first_step,
-            bool_cpp_t auto_reset_state = False
+            bint auto_reset_state = False
             ):
         """
         Public method to change first step's size.
@@ -1567,7 +1375,7 @@ cdef class CySolver:
         ----------
         first_step : double
             New first step's size.
-        auto_reset_state : bool_cpp_t, default=False
+        auto_reset_state : bint, default=False
             If True, then the `reset_state` method will be called once parameter is changed.
         """
 
@@ -1577,11 +1385,11 @@ cdef class CySolver:
         else:
             if self.first_step <= 0.:
                 self.status = -8
-                self.message = "Attribute error."
+                self._message = "Attribute error."
                 raise AttributeError('Error in user-provided step size: Step size must be a positive number.')
             elif self.first_step > self.t_delta_abs:
                 self.status = -8
-                self.message = "Attribute error."
+                self._message = "Attribute error."
                 raise AttributeError('Error in user-provided step size: Step size can not exceed bounds.')
             self.step_size = self.first_step
 
@@ -1589,12 +1397,12 @@ cdef class CySolver:
         self.recalc_first_step = False
 
         if auto_reset_state:
-            self.reset_state()
+            self._reset_state()
 
     cpdef void change_t_eval(
             self,
             const double[::1] t_eval,
-            bool_cpp_t auto_reset_state = False
+            bint auto_reset_state = False
             ):
         """
         Public method to change user requested independent domain, `t_eval`.
@@ -1603,7 +1411,7 @@ cdef class CySolver:
         ----------
         t_eval : double[:]
             New independent domain at which solution will be interpolated.
-        auto_reset_state : bool_cpp_t, default=False
+        auto_reset_state : bint, default=False
             If True, then the `reset_state` method will be called once parameter is changed.
         """
 
@@ -1628,13 +1436,13 @@ cdef class CySolver:
                 self.t_eval_ptr[i] = t_eval[i]
 
         if auto_reset_state:
-            self.reset_state()
+            self._reset_state()
 
     cdef void change_t_eval_pointer(
             self,
             double* new_t_eval_ptr,
             size_t new_len_t_eval,
-            bool_cpp_t auto_reset_state = False
+            bint auto_reset_state = False
             ):
         """
         Public method to change user requested independent domain, `t_eval`.
@@ -1643,7 +1451,7 @@ cdef class CySolver:
         ----------
         t_eval_ptr : double[:]
             New pointer to independent domain at which solution will be interpolated.
-        auto_reset_state : bool_cpp_t, default=False
+        auto_reset_state : bint, default=False
             If True, then the `reset_state` method will be called once parameter is changed.
         """
 
@@ -1666,7 +1474,7 @@ cdef class CySolver:
                 self.t_eval_ptr[i] = new_t_eval_ptr[i]
 
         if auto_reset_state:
-            self.reset_state()
+            self._reset_state()
 
     cpdef void change_parameters(
             self,
@@ -1680,8 +1488,8 @@ cdef class CySolver:
             double max_step = NAN,
             double first_step = NAN,
             const double[::1] t_eval = None,
-            bool_cpp_t auto_reset_state = True,
-            bool_cpp_t auto_solve = False
+            bint auto_reset_state = True,
+            bint auto_solve = False
             ):
         """
         Public method to change one or more parameters which have their own `change_*` method.
@@ -1700,15 +1508,15 @@ cdef class CySolver:
         max_step
         first_step
         t_eval
-        auto_reset_state : bool_cpp_t, default=True
+        auto_reset_state : bint, default=True
             If True, then the `reset_state` method will be called once parameter is changed.
-        auto_solve : bool_cpp_t, default=False
+        auto_solve : bint, default=False
             If True, then the `solve` method will be called after all parameters have been changed and the state reset.
         """
 
         # This is one of the few change functions where nothing might change.
         # Track if updates need to be made
-        cdef bool_cpp_t something_changed
+        cdef bint something_changed
         something_changed = False
 
         if not isnan(t_span[0]):
@@ -1746,7 +1554,7 @@ cdef class CySolver:
                 self.recalc_first_step = False
 
             if auto_reset_state:
-                self.reset_state()
+                self._reset_state()
 
         # User can choose to go ahead and rerun the solver with the new setup
         if auto_solve:
@@ -1841,6 +1649,30 @@ cdef class CySolver:
 
 
     # Public accessed properties
+    @property
+    def message(self):
+        return str(self._message, 'UTF-8')
+
+    @property
+    def solution_t_view(self):
+        return <double[:self.len_t_touse]> self.solution_t_ptr
+    
+    @property
+    def solution_y_view(self):
+        # Convert solution pointers to a more user-friendly memoryview format.
+        # Define post-run variables
+        cdef size_t y_size_touse
+        y_size_touse = self.y_size * self.len_t_touse
+        return <double[:y_size_touse]> self.solution_y_ptr
+
+    @property
+    def solution_extra_view(self):
+        # Convert solution pointers to a more user-friendly memoryview format.
+        # Define post-run variables
+        cdef size_t extra_size_touse
+        extra_size_touse = self.num_extra * self.len_t_touse
+        return <double[:extra_size_touse]> self.solution_extra_ptr
+
     @property
     def t(self):
         # Need to convert the memory view back into a numpy array
@@ -1866,60 +1698,60 @@ cdef class CySolver:
     def __dealloc__(self):
         # Free pointers made from user inputs
         if not (self.y0_ptr is NULL):
-            PyMem_Free(self.y0_ptr)
+            free(self.y0_ptr)
             self.y0_ptr = NULL
         if not (self.tol_ptrs is NULL):
-            PyMem_Free(self.tol_ptrs)
+            free(self.tol_ptrs)
             self.tol_ptrs = NULL
         if not (self.args_ptr is NULL):
-            PyMem_Free(self.args_ptr)
+            free(self.args_ptr)
             self.args_ptr = NULL
         if not (self.t_eval_ptr is NULL):
-            PyMem_Free(self.t_eval_ptr)
+            free(self.t_eval_ptr)
             self.t_eval_ptr = NULL
 
         # Free pointers used to track y, dydt, and any extra outputs
         if not (self.temporary_y_ptrs is NULL):
-            PyMem_Free(self.temporary_y_ptrs)
+            free(self.temporary_y_ptrs)
             self.temporary_y_ptrs = NULL
         if not (self.extra_output_ptrs is NULL):
-            PyMem_Free(self.extra_output_ptrs)
+            free(self.extra_output_ptrs)
             self.extra_output_ptrs = NULL
 
         # Free final solution pointers
         if not (self.solution_t_ptr is NULL):
-            PyMem_Free(self.solution_t_ptr)
+            free(self.solution_t_ptr)
             self.solution_t_ptr = NULL
         if not (self.solution_y_ptr is NULL):
-            PyMem_Free(self.solution_y_ptr)
+            free(self.solution_y_ptr)
             self.solution_y_ptr = NULL
         if not (self.solution_extra_ptr is NULL):
-            PyMem_Free(self.solution_extra_ptr)
+            free(self.solution_extra_ptr)
             self.solution_extra_ptr = NULL
         
         # Free pointers used during the solve method
         if not (self._solve_time_domain_array_ptr is NULL):
-            PyMem_Free(self._solve_time_domain_array_ptr)
+            free(self._solve_time_domain_array_ptr)
             self._solve_time_domain_array_ptr = NULL
         if not (self._solve_y_results_array_ptr is NULL):
-            PyMem_Free(self._solve_y_results_array_ptr)
+            free(self._solve_y_results_array_ptr)
             self._solve_y_results_array_ptr = NULL
         if not (self._solve_extra_array_ptr is NULL):
-            PyMem_Free(self._solve_extra_array_ptr)
+            free(self._solve_extra_array_ptr)
             self._solve_extra_array_ptr = NULL
         
         # Free pointers used during interpolation
         if not (self._interpolate_solution_t_ptr is NULL):
-            PyMem_Free(self._interpolate_solution_t_ptr)
+            free(self._interpolate_solution_t_ptr)
             self._interpolate_solution_t_ptr = NULL
         if not (self._interpolate_solution_y_ptr is NULL):
-            PyMem_Free(self._interpolate_solution_y_ptr)
+            free(self._interpolate_solution_y_ptr)
             self._interpolate_solution_y_ptr = NULL
         if not (self._interpolate_solution_extra_ptr is NULL):
-            PyMem_Free(self._interpolate_solution_extra_ptr)
+            free(self._interpolate_solution_extra_ptr)
             self._interpolate_solution_extra_ptr = NULL
 
         # Free RK Temp Storage Array
         if not (self.K_ptr is NULL):
-            PyMem_Free(self.K_ptr)
+            free(self.K_ptr)
             self.K_ptr = NULL
diff --git a/CyRK/cy/rk_step.c b/CyRK/cy/rk_step.c
new file mode 100644
index 0000000..563942b
--- /dev/null
+++ b/CyRK/cy/rk_step.c
@@ -0,0 +1,315 @@
+#include <stddef.h>   // `size_t`
+#include <stdbool.h>  // `bool`
+#include <math.h>     // `fmin`, `fmax`, `fabs`
+#include <stdio.h>
+// Create a fake struct to trick C into accepting the CySolver class (which contains the diffeq method)
+struct CySolverStruct {
+    char empty;
+};
+
+
+int rk_step_cf(
+        // Pointer to differential equation
+        void (*diffeq_ptr)(struct CySolverStruct*),
+        // Pointer to the CySolver instance
+        struct CySolverStruct* cysolver_inst,
+
+        // t-related variables
+        double t_end,
+        bool direction_flag,
+        double direction_inf,
+
+        // y-related variables
+        size_t y_size,
+        double y_size_dbl,
+        double y_size_sqrt,
+
+        // Pointers to class attributes that can change during rk_step call.
+        double* restrict t_now_ptr,
+        double* restrict y_ptr,
+        double* restrict dy_ptr,
+        double* restrict t_old_ptr,
+        double* restrict y_old_ptr,
+        double* restrict dy_old_ptr,
+        double* restrict step_size_ptr,
+        char* restrict status_ptr,
+
+        // Integration tolerance variables and pointers
+        double* restrict atols_ptr,
+        double* restrict rtols_ptr,
+        double max_step,
+
+        // RK specific variables and pointers
+        unsigned char rk_method,
+        size_t rk_n_stages,
+        size_t rk_n_stages_plus1,
+        size_t len_Acols,
+        size_t len_C,
+        double* restrict A_ptr,
+        double* restrict B_ptr,
+        double* restrict C_ptr,
+        double* restrict K_ptr,
+        double* restrict E_ptr,
+        double* restrict E3_ptr,
+        double* restrict E5_ptr,
+        double error_expo,
+        double min_step_factor,
+        double max_step_factor,
+        double error_safety
+        ){
+    /**
+     * Performs a Runge-Kutta step calculation including local error determination. 
+    */
+
+    // Initialize step variables
+    double min_step, step, step_factor, time_tmp, t_delta_check;
+    double scale, temp_double;
+    double error_norm, error_dot_1, error_pow;
+    bool step_accepted, step_rejected, step_error;
+
+    // Store values from pointers so that they do not have to be dereferenced multiple times
+    double t_now = *t_now_ptr;
+    double t_old = *t_old_ptr;
+    double step_size = *step_size_ptr;
+
+    // Run RK integration step
+    // Determine step size based on previous loop
+    // Find minimum step size based on the value of t (less floating point numbers between numbers when t is large)
+    min_step = 10. * fabs(nextafter(t_old, direction_inf) - t_old);
+    // Look for over/undershoots in previous step size
+    if (step_size > max_step) {
+        step_size = max_step;
+    } else if (step_size < min_step) {
+        step_size = min_step;
+    }
+
+    // Determine new step size
+    step_accepted = false;
+    step_rejected = false;
+    step_error    = false;
+
+    // Optimization variables
+    // Define a very specific A (Row 1; Col 0) now since it is called consistently and does not change.
+    double A_at_10 = A_ptr[1 * len_Acols + 0];
+
+    // !! Step Loop
+    while (!step_accepted) {
+
+        // Check if step size is too small
+        // This will cause integration to fail: step size smaller than spacing between numbers
+        if (step_size < min_step) {
+            step_error  = true;
+            *status_ptr = -1;
+            break;
+        }
+
+        // Move time forward for this particular step size
+        if (direction_flag) {
+            step          = step_size;
+            t_now         = t_old + step;
+            t_delta_check = t_now - t_end;
+        } else {
+            step          = -step_size;
+            t_now         = t_old + step;
+            t_delta_check = t_end - t_now;
+        }
+
+        // Check that we are not at the end of integration with that move
+        if (t_delta_check > 0.0) {
+            t_now = t_end;
+
+            // If we are, correct the step so that it just hits the end of integration.
+            step = t_now - t_old;
+            if (direction_flag){
+                step_size = step;
+            } else {
+                step_size = -step;
+            }
+        }
+
+        // !! Calculate derivative using RK method
+
+        // t_now must be updated for each loop of s in order to make the diffeq method calls.
+        // But we need to return to its original value later on. Store in temp variable.
+        time_tmp = t_now;
+
+        for (size_t s = 1; s < len_C; s++) {
+            // Find the current time based on the old time and the step size.
+            t_now = t_old + C_ptr[s] * step;
+            // Update the value stored at the t_now pointer so it can be used in the diffeq method.
+            *t_now_ptr = t_now;
+
+            // Dot Product (K, a) * step
+            if (s == 1) {
+                for (size_t i = 0; i < y_size; i++) {
+                    // Set the first column of K
+                    temp_double = dy_old_ptr[i];
+                    // K[0, :] == first part of the array
+                    K_ptr[i] = temp_double;
+
+                    // Calculate y_new for s==1
+                    y_ptr[i] = y_old_ptr[i] + (temp_double * A_at_10 * step);
+                }
+            } else {
+                for (size_t j = 0; j < s; j++) {
+                    temp_double = A_ptr[s * len_Acols + j] * step;
+                    for (size_t i = 0; i < y_size; i++) {
+                        if (j == 0){
+                            // Initialize
+                            y_ptr[i] = y_old_ptr[i];
+                        }
+                        y_ptr[i] += K_ptr[j * y_size + i] * temp_double;
+                    }
+                }
+            }
+            // Call diffeq method to update K with the new dydt
+            // This will use the now updated values at y_ptr and t_now_ptr. It will update values at dy_ptr.
+            diffeq_ptr(cysolver_inst);
+
+            // Update K based on the new dy values.
+            for (size_t i = 0; i < y_size; i++) {
+                K_ptr[s * y_size + i] = dy_ptr[i];
+            }
+        }
+
+        // Restore t_now to its previous value.
+        t_now = time_tmp;
+        // Update the pointer.
+        *t_now_ptr = t_now;
+        
+        // Dot Product (K, B) * step
+        for (size_t j = 0; j < rk_n_stages; j++) {
+            temp_double = B_ptr[j] * step;
+            // We do not use rk_n_stages_plus1 here because we are chopping off the last row of K to match
+            //  the shape of B.
+            for (size_t i = 0; i < y_size; i++) {
+                if (j == 0) {
+                    // Initialize
+                    y_ptr[i] = y_old_ptr[i];
+                }
+                y_ptr[i] += K_ptr[j * y_size + i] * temp_double;
+            }
+        }
+        
+        // Find final dydt for this timestep
+        // This will use the now final values at y_ptr and t_now_ptr. It will update values at dy_ptr.
+        diffeq_ptr(cysolver_inst);
+
+        // Check how well this step performed by calculating its error.
+        if (rk_method == 2) {
+             double error_norm3, error_norm5, error_dot_2, error_denom; 
+            // Calculate Error for DOP853
+            // Dot Product (K, E5) / scale and Dot Product (K, E3) * step / scale
+            error_norm3 = 0.0;
+            error_norm5 = 0.0;
+            for (size_t i = 0; i < y_size; i++) {
+                // Find scale of y for error calculations
+                scale = (atols_ptr[i] + fmax(fabs(y_old_ptr[i]), fabs(y_ptr[i])) * rtols_ptr[i]);
+
+                // Set last array of K equal to dydt
+                K_ptr[rk_n_stages * y_size + i] = dy_ptr[i];
+
+                // Initialize
+                error_dot_1 = 0.0;
+                error_dot_2 = 0.0;
+                
+                for (size_t j = 0; j < rk_n_stages_plus1; j++) {
+                    temp_double = K_ptr[j * y_size + i];
+                    error_dot_1 += temp_double * E3_ptr[j];
+                    error_dot_2 += temp_double * E5_ptr[j];
+                }
+                // We need the absolute value but since we are taking the square, it is guaranteed to be positive.
+                // TODO: This will need to change if CySolver ever accepts complex numbers
+                // error_norm3_abs = fabs(error_dot_1)
+                // error_norm5_abs = fabs(error_dot_2)
+                error_dot_1 /= scale;
+                error_dot_2 /= scale;
+
+                error_norm3 += (error_dot_1 * error_dot_1);
+                error_norm5 += (error_dot_2 * error_dot_2);
+            }
+            // Check if errors are zero
+            if ((error_norm5 == 0.0) && (error_norm3) == 0.0) {
+                error_norm = 0.0;
+            } else {
+                error_denom = error_norm5 + 0.01 * error_norm3;
+                error_norm = step_size * error_norm5 / sqrt(error_denom * y_size_dbl);
+            }
+        } else {
+            // Calculate Error for RK23 and RK45
+            // Dot Product (K, E) * step / scale
+            error_norm = 0.0;
+            for (size_t i = 0; i < y_size; i++) {
+                // Find scale of y for error calculations
+                scale = (atols_ptr[i] + fmax(fabs(y_old_ptr[i]), fabs(y_ptr[i])) * rtols_ptr[i]);
+
+                // Set last array of K equal to dydt
+                K_ptr[rk_n_stages * y_size + i] = dy_ptr[i];
+                
+                // Initialize
+                error_dot_1 = 0.0;
+
+                for (size_t j = 0; j < rk_n_stages_plus1; j++) {
+                    error_dot_1 += K_ptr[j * y_size + i] * E_ptr[j];
+                }
+
+                // We need the absolute value but since we are taking the square, it is guaranteed to be positive.
+                // TODO: This will need to change if CySolver ever accepts complex numbers
+                // error_norm_abs = fabs(error_dot_1)
+                error_dot_1 *= (step / scale);
+
+                error_norm += (error_dot_1 * error_dot_1);
+            }
+            error_norm = sqrt(error_norm) / y_size_sqrt;
+        }
+
+        // Check the size of the error
+        if (error_norm < 1.0) {
+            // We found our step size because the error is low!
+            // Update this step for the next time loop
+            if (error_norm == 0.0) {
+                step_factor = max_step_factor;
+            } else {
+                error_pow = pow(error_norm, -error_expo);
+                step_factor = fmin(max_step_factor, error_safety * error_pow);
+            }
+
+            if (step_rejected) {
+                // There were problems with this step size on the previous step loop. Make sure factor does
+                //   not exasperate them.
+                step_factor = fmin(step_factor, 1.);
+            }
+
+            // Update step size
+            step_size *= step_factor;
+            step_accepted = true;
+        } else {
+            // Error is still large. Keep searching for a better step size.
+            error_pow = pow(error_norm, -error_expo);
+            step_size *= fmax(min_step_factor, error_safety * error_pow);
+            step_rejected = true;
+        }
+    }
+
+    // Update status depending if there were any errors.
+    if (step_error) {
+        // Issue with step convergence
+        *status_ptr = -1;
+    } else if (!step_accepted) {
+        // Issue with step convergence
+        *status_ptr = -7;
+    }
+
+    // End of RK step. 
+    // Update "old" pointers
+    *t_old_ptr = t_now;
+    for (size_t i = 0; i < y_size; i++) {
+        y_old_ptr[i]  = y_ptr[i];
+        dy_old_ptr[i] = dy_ptr[i];
+    }
+
+    // Update any other pointers
+    *step_size_ptr = step_size;
+
+    return 0;
+}
diff --git a/CyRK/rk/rk.pyx b/CyRK/rk/rk.pyx
index 1543db6..4ad80f1 100644
--- a/CyRK/rk/rk.pyx
+++ b/CyRK/rk/rk.pyx
@@ -1,3 +1,4 @@
+# distutils: language = c
 # cython: boundscheck=False, wraparound=False, nonecheck=False, cdivision=True, initializedcheck=False
 
 from CyRK.rk.rk_constants cimport \
diff --git a/CyRK/rk/rk_constants.pyx b/CyRK/rk/rk_constants.pyx
index 5e5f231..4c149d2 100644
--- a/CyRK/rk/rk_constants.pyx
+++ b/CyRK/rk/rk_constants.pyx
@@ -1,3 +1,4 @@
+# distutils: language = c
 # cython: boundscheck=False, wraparound=False, nonecheck=False, cdivision=True, initializedcheck=False
 """ Constants for Runge-Kutta Integration Methods.
 
diff --git a/CyRK/utils/utils.pxd b/CyRK/utils/utils.pxd
index 8fcc420..7176cda 100644
--- a/CyRK/utils/utils.pxd
+++ b/CyRK/utils/utils.pxd
@@ -1,3 +1,3 @@
-cdef void* allocate_mem(size_t size, char* var_name)
+cdef void* allocate_mem(size_t size, char* var_name) noexcept nogil
 
-cdef void* reallocate_mem(void* old_pointer, size_t new_size, char* var_name)
+cdef void* reallocate_mem(void* old_pointer, size_t new_size, char* var_name) noexcept nogil
diff --git a/CyRK/utils/utils.pyx b/CyRK/utils/utils.pyx
index b28f9ea..543a29b 100644
--- a/CyRK/utils/utils.pyx
+++ b/CyRK/utils/utils.pyx
@@ -1,17 +1,20 @@
-# distutils: language = c++
+# distutils: language = c
 # cython: boundscheck=False, wraparound=False, nonecheck=False, cdivision=True, initializedcheck=False
-from cpython.mem cimport PyMem_Malloc, PyMem_Realloc
+from libc.stdlib cimport malloc, realloc, exit
+from libc.stdio cimport printf
 
 
-cdef inline void* allocate_mem(size_t size, char* var_name):
-    cdef void* new_memory = PyMem_Malloc(size)
+cdef inline void* allocate_mem(size_t size, char* var_name) noexcept nogil:
+    cdef void* new_memory = malloc(size)
     if not new_memory:
-        raise MemoryError(f'Failed to allocate memory for {var_name}\n\tRequested size = {size}.')
+        printf('Memory Error: Failed to allocate memory for %s \n\tRequested size = %d.', var_name, size)
+        exit(-1)
     return new_memory
 
 
-cdef inline void* reallocate_mem(void* old_pointer, size_t new_size, char* var_name):
-    cdef void* new_memory = PyMem_Realloc(old_pointer, new_size)
+cdef inline void* reallocate_mem(void* old_pointer, size_t new_size, char* var_name) noexcept nogil:
+    cdef void* new_memory = realloc(old_pointer, new_size)
     if not new_memory:
-        raise MemoryError(f'Failed to *re*allocate memory for {var_name}\n\tRequested size = {new_size}.')
+        printf('Failed to *re*allocate memory for %s \n\tRequested size = %d.', var_name, new_size)
+        exit(-1)
     return new_memory
diff --git a/MANIFEST.in b/MANIFEST.in
index a9903e7..21e5069 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,2 +1,6 @@
+# MANIFEST.in
+
+# Include Cython pyx and pxd files
 global-include *.pxd
-global-include *.pyx
\ No newline at end of file
+global-include *.pyx
+include cython_extensions.json
\ No newline at end of file
diff --git a/Performance/cyrk_performance-DOP853.csv b/Performance/cyrk_performance-DOP853.csv
index 792d2fc..ebfaf22 100644
--- a/Performance/cyrk_performance-DOP853.csv
+++ b/Performance/cyrk_performance-DOP853.csv
@@ -18,3 +18,5 @@ CyRK Version, Run-on Date, cython (avg), cython (std),CySolver (avg),CySolver (s
 0.8.0, 06/09/2023 15:03:15, 0.9615, 0.0011, 0.0561, 0.0001, 0.1602, 0.0004, 9.8846, 0.1049, 0.4796, 0.0010, 1.4545, 0.0154, 0.4413, 0.0005, 0.0376, 0.0001, 0.0953, 0.0001, 4.3959, 0.0170, 0.2890, 0.0007, 0.7862, 0.0168, 1.4213, 0.0046, 0.0937, 0.0005, 0.2464, 0.0012, 19.5317, 0.0414, 1.1684, 0.0054, 3.1531, 0.0143, 1.6563, 0.0055, 0.0989, 0.0018, 0.4797, 0.0064, 22.9818, 0.1217, 1.2122, 0.0250, 6.4178, 0.0221
 0.8.3, 07/10/2023 02:40:03, 0.9727, 0.0033, 0.0587, 0.0014, 0.1625, 0.0006, 9.9439, 0.0246, 0.4990, 0.0070, 2.6214, 0.0527, 0.4393, 0.0008, 0.0400, 0.0006, 0.1034, 0.0063, 4.4720, 0.1096, 0.3114, 0.0025, 1.1428, 0.0021, 1.4298, 0.0046, 0.0987, 0.0009, 0.2440, 0.0019, 21.2338, 0.3276, 1.7444, 0.0077, 4.3900, 0.0738, 1.6848, 0.0280, 0.1039, 0.0003, 0.4644, 0.0006, 25.3711, 0.1346, 2.2809, 0.0329, 7.3621, 0.0222
 0.8.4, 18/10/2023 12:49:04, 0.9453, 0.0036, 0.0574, 0.0012, 0.1718, 0.0070, 9.9086, 0.1287, 0.4833, 0.0013, 1.4208, 0.0060, 0.4293, 0.0016, 0.0383, 0.0001, 0.0956, 0.0006, 4.2518, 0.0123, 0.2944, 0.0001, 0.7605, 0.0005, 1.3829, 0.0014, 0.0931, 0.0001, 0.2438, 0.0003, 19.2126, 0.0622, 1.1729, 0.0003, 3.1186, 0.0861, 1.6221, 0.0111, 0.0957, 0.0000, 0.4634, 0.0006, 22.3320, 0.0879, 1.2067, 0.0012, 6.1291, 0.0053
+0.8.6, 13/02/2024 17:08:45, 0.9814, 0.0156, 0.0611, 0.0001, 0.1640, 0.0017, 10.2798, 0.4311, 0.5307, 0.0079, 1.4800, 0.0021, 0.4434, 0.0036, 0.0420, 0.0005, 0.0991, 0.0000, 4.4219, 0.0575, 0.3169, 0.0014, 0.7947, 0.0034, 1.4053, 0.0155, 0.0973, 0.0004, 0.2517, 0.0009, 19.6548, 0.3540, 1.2133, 0.0019, 3.1887, 0.0088, 1.6764, 0.0156, 0.1001, 0.0001, 0.5250, 0.0036, 23.9277, 0.3592, 1.2488, 0.0017, 7.2941, 0.1608
+0.9.0a0.dev1, 28/04/2024 16:35:40, 1.0821, 0.0759, 0.0542, 0.0005, 0.1718, 0.0085, 10.7475, 0.1318, 0.5200, 0.0034, 1.5308, 0.0297, 0.4628, 0.0038, 0.0338, 0.0001, 0.1002, 0.0012, 4.6868, 0.0765, 0.3107, 0.0036, 0.8255, 0.0217, 1.4887, 0.0342, 0.0911, 0.0010, 0.2890, 0.0163, 21.0884, 0.6085, 1.2186, 0.0099, 3.3427, 0.0986, 1.7910, 0.0446, 0.0930, 0.0006, 0.4984, 0.0052, 24.2231, 0.5540, 1.2622, 0.0102, 6.7969, 0.1273
diff --git a/Performance/cyrk_performance-RK23.csv b/Performance/cyrk_performance-RK23.csv
index f4e5eed..eefb1eb 100644
--- a/Performance/cyrk_performance-RK23.csv
+++ b/Performance/cyrk_performance-RK23.csv
@@ -18,3 +18,5 @@ CyRK Version, Run-on Date, cython (avg), cython (std),CySolver (avg),CySolver (s
 0.8.0, 06/09/2023 15:00:58, 4.4794, 0.0786, 0.2262, 0.0003, 0.8199, 0.0021, 43.1476, 0.0854, 2.1466, 0.0018, 10.1946, 0.1933, 2.7552, 0.0105, 0.1866, 0.0004, 0.5903, 0.0024, 26.9694, 0.1524, 1.7797, 0.0257, 5.9678, 0.0812, 4.7003, 0.0324, 0.2855, 0.0005, 0.9508, 0.0055, 80.1011, 0.3480, 4.8504, 0.0219, 20.8530, 0.2461, 5.5239, 0.0051, 0.3178, 0.0014, 1270.6912, 2197.9259, 95.6354, 0.1723, 5.4006, 0.0797, 35.0990, 0.8415
 0.8.3, 07/10/2023 02:37:45, 4.5212, 0.1075, 0.2681, 0.0021, 0.7992, 0.0038, 43.9629, 0.3217, 2.5955, 0.0502, 9.2842, 0.4116, 2.7602, 0.0088, 0.2146, 0.0037, 0.5896, 0.0074, 27.1210, 0.1858, 2.0566, 0.0327, 5.7936, 0.0150, 4.8923, 0.0594, 0.3719, 0.0011, 0.9807, 0.0023, 82.6179, 0.6252, 6.0628, 0.0336, 20.2684, 0.2082, 5.6639, 0.0115, 0.9587, 0.2834, 1525.4251, 2635.4115, 105.9372, 0.3232, 14.0169, 0.0614, 45.0599, 0.8249
 0.8.4, 18/10/2023 12:46:46, 4.4202, 0.0673, 0.2500, 0.0004, 0.8115, 0.0034, 43.1191, 0.0775, 2.4081, 0.0282, 10.0251, 0.7074, 2.7552, 0.0436, 0.2110, 0.0039, 0.5987, 0.0058, 26.5597, 0.2133, 1.9887, 0.0201, 5.8675, 0.1112, 4.7007, 0.0078, 0.3080, 0.0014, 0.9944, 0.0238, 81.1241, 0.3424, 5.5864, 0.7125, 19.9567, 0.1538, 5.4119, 0.0106, 0.3208, 0.0010, 1322.6941, 2287.9898, 96.8733, 2.3521, 5.5968, 0.1162, 36.6713, 0.3267
+0.8.6, 13/02/2024 17:06:17, 4.5290, 0.0708, 0.2875, 0.0033, 0.9640, 0.1354, 43.6531, 0.0926, 2.8374, 0.0722, 8.9517, 0.2453, 2.7551, 0.0064, 0.2243, 0.0006, 0.6140, 0.0013, 27.0492, 0.2018, 2.1363, 0.0025, 5.9659, 0.0384, 4.6135, 0.0079, 0.3487, 0.0003, 0.9485, 0.0007, 79.4872, 0.4035, 5.9439, 0.1090, 19.9015, 0.1388, 5.6296, 0.0271, 0.3621, 0.0012, 1454.8195, 2516.6233, 96.8326, 0.5951, 6.1248, 0.0257, 38.7549, 0.4298
+0.9.0a0.dev1, 28/04/2024 16:33:18, 4.7953, 0.1380, 0.2774, 0.0022, 0.9154, 0.0921, 48.2304, 2.3404, 2.7864, 0.0900, 9.5501, 0.0960, 2.9073, 0.0365, 0.2226, 0.0090, 0.6248, 0.0041, 29.2903, 0.3552, 2.1533, 0.0246, 7.5314, 1.7160, 4.9601, 0.0650, 0.3488, 0.0068, 1.3128, 0.4091, 84.7193, 0.6367, 6.0557, 0.2830, 22.2041, 0.4342, 6.0133, 0.2861, 0.3729, 0.0200, 1454.6659, 2515.9971, 101.1687, 1.5611, 6.3772, 0.0996, 39.6568, 0.8971
diff --git a/Performance/cyrk_performance-RK45.csv b/Performance/cyrk_performance-RK45.csv
index 8b9cfba..4197d76 100644
--- a/Performance/cyrk_performance-RK45.csv
+++ b/Performance/cyrk_performance-RK45.csv
@@ -18,3 +18,5 @@ CyRK Version, Run-on Date, cython (avg), cython (std),CySolver (avg),CySolver (s
 0.8.0, 06/09/2023 15:02:20, 1.2080, 0.0171, 0.0582, 0.0001, 0.2023, 0.0008, 11.8032, 0.0256, 0.4807, 0.0012, 1.8475, 0.0119, 0.8318, 0.0034, 0.0569, 0.0002, 0.1659, 0.0003, 8.1177, 0.0578, 0.4684, 0.0018, 1.4517, 0.0058, 1.6145, 0.0023, 0.0921, 0.0005, 0.2928, 0.0011, 23.6490, 0.0748, 1.2090, 0.0118, 4.0150, 0.0179, 1.8902, 0.0034, 0.0969, 0.0009, 0.5533, 0.0009, 27.6976, 0.0946, 1.2947, 0.0416, 7.9394, 0.0140
 0.8.3, 07/10/2023 02:39:08, 1.2268, 0.0292, 0.0670, 0.0002, 0.2042, 0.0002, 13.0410, 0.0369, 1.0062, 0.0659, 2.6633, 0.0087, 0.8234, 0.0038, 0.0631, 0.0002, 0.1648, 0.0001, 8.8861, 0.0427, 0.7835, 0.0085, 2.1426, 0.0023, 1.6358, 0.0049, 0.1139, 0.0050, 0.6746, 0.0009, 26.8571, 0.1145, 3.0055, 0.0209, 6.6462, 0.1028, 1.9187, 0.0032, 0.1280, 0.0045, 0.9513, 0.0050, 32.9776, 0.3770, 4.3772, 0.1087, 10.9500, 0.0345
 0.8.4, 18/10/2023 12:48:10, 1.1825, 0.0070, 0.0622, 0.0001, 0.2012, 0.0008, 11.7285, 0.0223, 0.5412, 0.0092, 1.8985, 0.0613, 0.8106, 0.0029, 0.0601, 0.0012, 0.1661, 0.0004, 7.9235, 0.0105, 0.4982, 0.0007, 1.4473, 0.0029, 1.6015, 0.0058, 0.0981, 0.0003, 0.2963, 0.0039, 23.5090, 0.0487, 1.3260, 0.0138, 4.0189, 0.0470, 1.8400, 0.0072, 0.1011, 0.0002, 0.5443, 0.0013, 27.1240, 0.0951, 1.3706, 0.0024, 7.7848, 0.0081
+0.8.6, 13/02/2024 17:07:48, 1.1940, 0.0018, 0.0656, 0.0001, 0.2073, 0.0006, 12.0870, 0.1605, 0.5541, 0.0014, 1.8434, 0.0014, 0.8268, 0.0006, 0.0641, 0.0001, 0.1746, 0.0037, 8.1272, 0.0545, 0.5381, 0.0006, 1.4994, 0.0056, 1.5900, 0.0112, 0.0984, 0.0001, 0.2944, 0.0007, 23.5061, 0.1064, 1.2961, 0.0085, 3.9463, 0.0073, 1.8949, 0.0107, 0.1017, 0.0001, 0.6063, 0.0029, 28.0150, 0.1407, 1.3543, 0.0045, 8.5997, 0.0030
+0.9.0a0.dev1, 28/04/2024 16:34:44, 1.2746, 0.0125, 0.0583, 0.0006, 0.2196, 0.0085, 12.9048, 0.1873, 0.5548, 0.0054, 2.0504, 0.0367, 0.8850, 0.0070, 0.0574, 0.0009, 0.1762, 0.0024, 8.6755, 0.0900, 0.5403, 0.0077, 1.5383, 0.0141, 1.6504, 0.0116, 0.0915, 0.0009, 0.3107, 0.0095, 25.0740, 0.0879, 1.3099, 0.0083, 4.3287, 0.1021, 2.0066, 0.0236, 0.0966, 0.0009, 0.5818, 0.0113, 29.3030, 0.5569, 1.3654, 0.0209, 8.6343, 0.2734
diff --git a/README.md b/README.md
index 4a89018..b1d6979 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 # CyRK
 <div style="text-align: center;">
 <a href="https://doi.org/10.5281/zenodo.7093266"><img src="https://zenodo.org/badge/DOI/10.5281/zenodo.7093266.svg" alt="DOI"></a>
-<a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/Python-3.8|3.9|3.10|3.11-blue" alt="Python Version 3.8-3.11" /></a>
+<a href="https://www.python.org/downloads/"><img src="https://img.shields.io/badge/Python-3.8|3.9|3.10|3.11|3.12-blue" alt="Python Version 3.8-3.12" /></a>
 <a href="https://codecov.io/gh/jrenaud90/CyRK" ><img src="https://codecov.io/gh/jrenaud90/CyRK/branch/main/graph/badge.svg?token=MK2PqcNGET" alt="Code Coverage"/></a>
 <br />
 <a href="https://github.com/jrenaud90/CyRK/actions/workflows/push_tests_win.yml"><img src="https://github.com/jrenaud90/CyRK/actions/workflows/push_tests_win.yml/badge.svg?branch=main" alt="Windows Tests" /></a>
@@ -11,7 +11,7 @@
 
 ---
 
-<a href="https://github.com/jrenaud90/CyRK/releases"><img src="https://img.shields.io/badge/CyRK-0.8.5 Alpha-orange" alt="CyRK Version 0.8.5 Alpha" /></a>
+<a href="https://github.com/jrenaud90/CyRK/releases"><img src="https://img.shields.io/badge/CyRK-0.8.8 Alpha-orange" alt="CyRK Version 0.8.8 Alpha" /></a>
 
 
 **Runge-Kutta ODE Integrator Implemented in Cython and Numba**
@@ -28,7 +28,7 @@ The [cython](https://cython.org/) `CySolver` class that works with cython-based
 An additional benefit of the two cython implementations is that they are pre-compiled. This avoids most of the start-up performance hit experienced by just-in-time compilers like numba.
 
 
-<img style="text-align: center" src="https://github.com/jrenaud90/CyRK/blob/main/Benchmarks/CyRK_SciPy_Compare_predprey_v0-8-4.png" alt="CyRK Performance Graphic" />
+<img style="text-align: center" src="https://github.com/jrenaud90/CyRK/blob/main/Benchmarks/CyRK_SciPy_Compare_predprey_v0-8-6.png" alt="CyRK Performance Graphic" />
 
 ## Installation
 
diff --git a/Tests/Cython Experiments.ipynb b/Tests/Cython Experiments.ipynb
index d9a42d6..0c8ceb2 100644
--- a/Tests/Cython Experiments.ipynb
+++ b/Tests/Cython Experiments.ipynb
@@ -10,7 +10,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0.8.4\n"
+      "0.9.0a0.dev1\n"
      ]
     }
    ],
@@ -34,450 +34,256 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 6,
    "id": "fa7de26d",
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
+     "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Content of stdout:\n",
-      "_cython_magic_8faab9cb4e44b9cd04e9e84e905d7642718ed40a.cpp\r\n",
-      "   Creating library C:\\Users\\joepr\\.ipython\\cython\\Users\\joepr\\.ipython\\cython\\_cython_magic_8faab9cb4e44b9cd04e9e84e905d7642718ed40a.cp311-win_amd64.lib and object C:\\Users\\joepr\\.ipython\\cython\\Users\\joepr\\.ipython\\cython\\_cython_magic_8faab9cb4e44b9cd04e9e84e905d7642718ed40a.cp311-win_amd64.exp\r\n",
-      "Generating code\r\n",
-      "Finished generating code\n",
       "\n",
-      "YES\n"
+      "Error compiling Cython file:\n",
+      "------------------------------------------------------------\n",
+      "...\n",
+      "    t_start = 0.\n",
+      "    t_end = 5.\n",
+      "    \n",
+      "    for i in prange(100, nogil=True):\n",
+      "        \n",
+      "        solver = CySolverTester((t_start, t_end), initial_conds)\n",
+      "        ^\n",
+      "------------------------------------------------------------\n",
+      "\n",
+      "C:\\Users\\joepr\\.ipython\\cython\\_cython_magic_3c471ab9d30cb4a8725592bc2121370e81cbd5b5.pyx:80:8: Assignment of Python object not allowed without gil\n",
+      "\n",
+      "Error compiling Cython file:\n",
+      "------------------------------------------------------------\n",
+      "...\n",
+      "    t_start = 0.\n",
+      "    t_end = 5.\n",
+      "    \n",
+      "    for i in prange(100, nogil=True):\n",
+      "        \n",
+      "        solver = CySolverTester((t_start, t_end), initial_conds)\n",
+      "                               ^\n",
+      "------------------------------------------------------------\n",
+      "\n",
+      "C:\\Users\\joepr\\.ipython\\cython\\_cython_magic_3c471ab9d30cb4a8725592bc2121370e81cbd5b5.pyx:80:31: Calling gil-requiring function not allowed without gil\n",
+      "\n",
+      "Error compiling Cython file:\n",
+      "------------------------------------------------------------\n",
+      "...\n",
+      "    t_start = 0.\n",
+      "    t_end = 5.\n",
+      "    \n",
+      "    for i in prange(100, nogil=True):\n",
+      "        \n",
+      "        solver = CySolverTester((t_start, t_end), initial_conds)\n",
+      "                               ^\n",
+      "------------------------------------------------------------\n",
+      "\n",
+      "C:\\Users\\joepr\\.ipython\\cython\\_cython_magic_3c471ab9d30cb4a8725592bc2121370e81cbd5b5.pyx:80:31: Constructing Python tuple not allowed without gil\n",
+      "\n",
+      "Error compiling Cython file:\n",
+      "------------------------------------------------------------\n",
+      "...\n",
+      "    t_start = 0.\n",
+      "    t_end = 5.\n",
+      "    \n",
+      "    for i in prange(100, nogil=True):\n",
+      "        \n",
+      "        solver = CySolverTester((t_start, t_end), initial_conds)\n",
+      "                                 ^\n",
+      "------------------------------------------------------------\n",
+      "\n",
+      "C:\\Users\\joepr\\.ipython\\cython\\_cython_magic_3c471ab9d30cb4a8725592bc2121370e81cbd5b5.pyx:80:33: Constructing Python tuple not allowed without gil\n",
+      "\n",
+      "Error compiling Cython file:\n",
+      "------------------------------------------------------------\n",
+      "...\n",
+      "    t_start = 0.\n",
+      "    t_end = 5.\n",
+      "    \n",
+      "    for i in prange(100, nogil=True):\n",
+      "        \n",
+      "        solver = CySolverTester((t_start, t_end), initial_conds)\n",
+      "                                 ^\n",
+      "------------------------------------------------------------\n",
+      "\n",
+      "C:\\Users\\joepr\\.ipython\\cython\\_cython_magic_3c471ab9d30cb4a8725592bc2121370e81cbd5b5.pyx:80:33: Converting to Python object not allowed without gil\n",
+      "\n",
+      "Error compiling Cython file:\n",
+      "------------------------------------------------------------\n",
+      "...\n",
+      "    t_start = 0.\n",
+      "    t_end = 5.\n",
+      "    \n",
+      "    for i in prange(100, nogil=True):\n",
+      "        \n",
+      "        solver = CySolverTester((t_start, t_end), initial_conds)\n",
+      "                                          ^\n",
+      "------------------------------------------------------------\n",
+      "\n",
+      "C:\\Users\\joepr\\.ipython\\cython\\_cython_magic_3c471ab9d30cb4a8725592bc2121370e81cbd5b5.pyx:80:42: Converting to Python object not allowed without gil\n",
+      "\n",
+      "Error compiling Cython file:\n",
+      "------------------------------------------------------------\n",
+      "...\n",
+      "    t_start = 0.\n",
+      "    t_end = 5.\n",
+      "    \n",
+      "    for i in prange(100, nogil=True):\n",
+      "        \n",
+      "        solver = CySolverTester((t_start, t_end), initial_conds)\n",
+      "                                                  ^\n",
+      "------------------------------------------------------------\n",
+      "\n",
+      "C:\\Users\\joepr\\.ipython\\cython\\_cython_magic_3c471ab9d30cb4a8725592bc2121370e81cbd5b5.pyx:80:50: Converting to Python object not allowed without gil\n"
      ]
-    },
-    {
-     "data": {
-      "text/html": [
-       "<!DOCTYPE html>\n",
-       "<!-- Generated by Cython 3.0.2 -->\n",
-       "<html>\n",
-       "<head>\n",
-       "    <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />\n",
-       "    <title>Cython: _cython_magic_8faab9cb4e44b9cd04e9e84e905d7642718ed40a.pyx</title>\n",
-       "    <style type=\"text/css\">\n",
-       "    \n",
-       "body.cython { font-family: courier; font-size: 12; }\n",
-       "\n",
-       ".cython.tag  {  }\n",
-       ".cython.line { color: #000000; margin: 0em }\n",
-       ".cython.code { font-size: 9; color: #444444; display: none; margin: 0px 0px 0px 8px; border-left: 8px none; }\n",
-       "\n",
-       ".cython.line .run { background-color: #B0FFB0; }\n",
-       ".cython.line .mis { background-color: #FFB0B0; }\n",
-       ".cython.code.run  { border-left: 8px solid #B0FFB0; }\n",
-       ".cython.code.mis  { border-left: 8px solid #FFB0B0; }\n",
-       "\n",
-       ".cython.code .py_c_api  { color: red; }\n",
-       ".cython.code .py_macro_api  { color: #FF7000; }\n",
-       ".cython.code .pyx_c_api  { color: #FF3000; }\n",
-       ".cython.code .pyx_macro_api  { color: #FF7000; }\n",
-       ".cython.code .refnanny  { color: #FFA000; }\n",
-       ".cython.code .trace  { color: #FFA000; }\n",
-       ".cython.code .error_goto  { color: #FFA000; }\n",
-       "\n",
-       ".cython.code .coerce  { color: #008000; border: 1px dotted #008000 }\n",
-       ".cython.code .py_attr { color: #FF0000; font-weight: bold; }\n",
-       ".cython.code .c_attr  { color: #0000FF; }\n",
-       ".cython.code .py_call { color: #FF0000; font-weight: bold; }\n",
-       ".cython.code .c_call  { color: #0000FF; }\n",
-       "\n",
-       ".cython.score-0 {background-color: #FFFFff;}\n",
-       ".cython.score-1 {background-color: #FFFFe7;}\n",
-       ".cython.score-2 {background-color: #FFFFd4;}\n",
-       ".cython.score-3 {background-color: #FFFFc4;}\n",
-       ".cython.score-4 {background-color: #FFFFb6;}\n",
-       ".cython.score-5 {background-color: #FFFFaa;}\n",
-       ".cython.score-6 {background-color: #FFFF9f;}\n",
-       ".cython.score-7 {background-color: #FFFF96;}\n",
-       ".cython.score-8 {background-color: #FFFF8d;}\n",
-       ".cython.score-9 {background-color: #FFFF86;}\n",
-       ".cython.score-10 {background-color: #FFFF7f;}\n",
-       ".cython.score-11 {background-color: #FFFF79;}\n",
-       ".cython.score-12 {background-color: #FFFF73;}\n",
-       ".cython.score-13 {background-color: #FFFF6e;}\n",
-       ".cython.score-14 {background-color: #FFFF6a;}\n",
-       ".cython.score-15 {background-color: #FFFF66;}\n",
-       ".cython.score-16 {background-color: #FFFF62;}\n",
-       ".cython.score-17 {background-color: #FFFF5e;}\n",
-       ".cython.score-18 {background-color: #FFFF5b;}\n",
-       ".cython.score-19 {background-color: #FFFF57;}\n",
-       ".cython.score-20 {background-color: #FFFF55;}\n",
-       ".cython.score-21 {background-color: #FFFF52;}\n",
-       ".cython.score-22 {background-color: #FFFF4f;}\n",
-       ".cython.score-23 {background-color: #FFFF4d;}\n",
-       ".cython.score-24 {background-color: #FFFF4b;}\n",
-       ".cython.score-25 {background-color: #FFFF48;}\n",
-       ".cython.score-26 {background-color: #FFFF46;}\n",
-       ".cython.score-27 {background-color: #FFFF44;}\n",
-       ".cython.score-28 {background-color: #FFFF43;}\n",
-       ".cython.score-29 {background-color: #FFFF41;}\n",
-       ".cython.score-30 {background-color: #FFFF3f;}\n",
-       ".cython.score-31 {background-color: #FFFF3e;}\n",
-       ".cython.score-32 {background-color: #FFFF3c;}\n",
-       ".cython.score-33 {background-color: #FFFF3b;}\n",
-       ".cython.score-34 {background-color: #FFFF39;}\n",
-       ".cython.score-35 {background-color: #FFFF38;}\n",
-       ".cython.score-36 {background-color: #FFFF37;}\n",
-       ".cython.score-37 {background-color: #FFFF36;}\n",
-       ".cython.score-38 {background-color: #FFFF35;}\n",
-       ".cython.score-39 {background-color: #FFFF34;}\n",
-       ".cython.score-40 {background-color: #FFFF33;}\n",
-       ".cython.score-41 {background-color: #FFFF32;}\n",
-       ".cython.score-42 {background-color: #FFFF31;}\n",
-       ".cython.score-43 {background-color: #FFFF30;}\n",
-       ".cython.score-44 {background-color: #FFFF2f;}\n",
-       ".cython.score-45 {background-color: #FFFF2e;}\n",
-       ".cython.score-46 {background-color: #FFFF2d;}\n",
-       ".cython.score-47 {background-color: #FFFF2c;}\n",
-       ".cython.score-48 {background-color: #FFFF2b;}\n",
-       ".cython.score-49 {background-color: #FFFF2b;}\n",
-       ".cython.score-50 {background-color: #FFFF2a;}\n",
-       ".cython.score-51 {background-color: #FFFF29;}\n",
-       ".cython.score-52 {background-color: #FFFF29;}\n",
-       ".cython.score-53 {background-color: #FFFF28;}\n",
-       ".cython.score-54 {background-color: #FFFF27;}\n",
-       ".cython.score-55 {background-color: #FFFF27;}\n",
-       ".cython.score-56 {background-color: #FFFF26;}\n",
-       ".cython.score-57 {background-color: #FFFF26;}\n",
-       ".cython.score-58 {background-color: #FFFF25;}\n",
-       ".cython.score-59 {background-color: #FFFF24;}\n",
-       ".cython.score-60 {background-color: #FFFF24;}\n",
-       ".cython.score-61 {background-color: #FFFF23;}\n",
-       ".cython.score-62 {background-color: #FFFF23;}\n",
-       ".cython.score-63 {background-color: #FFFF22;}\n",
-       ".cython.score-64 {background-color: #FFFF22;}\n",
-       ".cython.score-65 {background-color: #FFFF22;}\n",
-       ".cython.score-66 {background-color: #FFFF21;}\n",
-       ".cython.score-67 {background-color: #FFFF21;}\n",
-       ".cython.score-68 {background-color: #FFFF20;}\n",
-       ".cython.score-69 {background-color: #FFFF20;}\n",
-       ".cython.score-70 {background-color: #FFFF1f;}\n",
-       ".cython.score-71 {background-color: #FFFF1f;}\n",
-       ".cython.score-72 {background-color: #FFFF1f;}\n",
-       ".cython.score-73 {background-color: #FFFF1e;}\n",
-       ".cython.score-74 {background-color: #FFFF1e;}\n",
-       ".cython.score-75 {background-color: #FFFF1e;}\n",
-       ".cython.score-76 {background-color: #FFFF1d;}\n",
-       ".cython.score-77 {background-color: #FFFF1d;}\n",
-       ".cython.score-78 {background-color: #FFFF1c;}\n",
-       ".cython.score-79 {background-color: #FFFF1c;}\n",
-       ".cython.score-80 {background-color: #FFFF1c;}\n",
-       ".cython.score-81 {background-color: #FFFF1c;}\n",
-       ".cython.score-82 {background-color: #FFFF1b;}\n",
-       ".cython.score-83 {background-color: #FFFF1b;}\n",
-       ".cython.score-84 {background-color: #FFFF1b;}\n",
-       ".cython.score-85 {background-color: #FFFF1a;}\n",
-       ".cython.score-86 {background-color: #FFFF1a;}\n",
-       ".cython.score-87 {background-color: #FFFF1a;}\n",
-       ".cython.score-88 {background-color: #FFFF1a;}\n",
-       ".cython.score-89 {background-color: #FFFF19;}\n",
-       ".cython.score-90 {background-color: #FFFF19;}\n",
-       ".cython.score-91 {background-color: #FFFF19;}\n",
-       ".cython.score-92 {background-color: #FFFF19;}\n",
-       ".cython.score-93 {background-color: #FFFF18;}\n",
-       ".cython.score-94 {background-color: #FFFF18;}\n",
-       ".cython.score-95 {background-color: #FFFF18;}\n",
-       ".cython.score-96 {background-color: #FFFF18;}\n",
-       ".cython.score-97 {background-color: #FFFF17;}\n",
-       ".cython.score-98 {background-color: #FFFF17;}\n",
-       ".cython.score-99 {background-color: #FFFF17;}\n",
-       ".cython.score-100 {background-color: #FFFF17;}\n",
-       ".cython.score-101 {background-color: #FFFF16;}\n",
-       ".cython.score-102 {background-color: #FFFF16;}\n",
-       ".cython.score-103 {background-color: #FFFF16;}\n",
-       ".cython.score-104 {background-color: #FFFF16;}\n",
-       ".cython.score-105 {background-color: #FFFF16;}\n",
-       ".cython.score-106 {background-color: #FFFF15;}\n",
-       ".cython.score-107 {background-color: #FFFF15;}\n",
-       ".cython.score-108 {background-color: #FFFF15;}\n",
-       ".cython.score-109 {background-color: #FFFF15;}\n",
-       ".cython.score-110 {background-color: #FFFF15;}\n",
-       ".cython.score-111 {background-color: #FFFF15;}\n",
-       ".cython.score-112 {background-color: #FFFF14;}\n",
-       ".cython.score-113 {background-color: #FFFF14;}\n",
-       ".cython.score-114 {background-color: #FFFF14;}\n",
-       ".cython.score-115 {background-color: #FFFF14;}\n",
-       ".cython.score-116 {background-color: #FFFF14;}\n",
-       ".cython.score-117 {background-color: #FFFF14;}\n",
-       ".cython.score-118 {background-color: #FFFF13;}\n",
-       ".cython.score-119 {background-color: #FFFF13;}\n",
-       ".cython.score-120 {background-color: #FFFF13;}\n",
-       ".cython.score-121 {background-color: #FFFF13;}\n",
-       ".cython.score-122 {background-color: #FFFF13;}\n",
-       ".cython.score-123 {background-color: #FFFF13;}\n",
-       ".cython.score-124 {background-color: #FFFF13;}\n",
-       ".cython.score-125 {background-color: #FFFF12;}\n",
-       ".cython.score-126 {background-color: #FFFF12;}\n",
-       ".cython.score-127 {background-color: #FFFF12;}\n",
-       ".cython.score-128 {background-color: #FFFF12;}\n",
-       ".cython.score-129 {background-color: #FFFF12;}\n",
-       ".cython.score-130 {background-color: #FFFF12;}\n",
-       ".cython.score-131 {background-color: #FFFF12;}\n",
-       ".cython.score-132 {background-color: #FFFF11;}\n",
-       ".cython.score-133 {background-color: #FFFF11;}\n",
-       ".cython.score-134 {background-color: #FFFF11;}\n",
-       ".cython.score-135 {background-color: #FFFF11;}\n",
-       ".cython.score-136 {background-color: #FFFF11;}\n",
-       ".cython.score-137 {background-color: #FFFF11;}\n",
-       ".cython.score-138 {background-color: #FFFF11;}\n",
-       ".cython.score-139 {background-color: #FFFF11;}\n",
-       ".cython.score-140 {background-color: #FFFF11;}\n",
-       ".cython.score-141 {background-color: #FFFF10;}\n",
-       ".cython.score-142 {background-color: #FFFF10;}\n",
-       ".cython.score-143 {background-color: #FFFF10;}\n",
-       ".cython.score-144 {background-color: #FFFF10;}\n",
-       ".cython.score-145 {background-color: #FFFF10;}\n",
-       ".cython.score-146 {background-color: #FFFF10;}\n",
-       ".cython.score-147 {background-color: #FFFF10;}\n",
-       ".cython.score-148 {background-color: #FFFF10;}\n",
-       ".cython.score-149 {background-color: #FFFF10;}\n",
-       ".cython.score-150 {background-color: #FFFF0f;}\n",
-       ".cython.score-151 {background-color: #FFFF0f;}\n",
-       ".cython.score-152 {background-color: #FFFF0f;}\n",
-       ".cython.score-153 {background-color: #FFFF0f;}\n",
-       ".cython.score-154 {background-color: #FFFF0f;}\n",
-       ".cython.score-155 {background-color: #FFFF0f;}\n",
-       ".cython.score-156 {background-color: #FFFF0f;}\n",
-       ".cython.score-157 {background-color: #FFFF0f;}\n",
-       ".cython.score-158 {background-color: #FFFF0f;}\n",
-       ".cython.score-159 {background-color: #FFFF0f;}\n",
-       ".cython.score-160 {background-color: #FFFF0f;}\n",
-       ".cython.score-161 {background-color: #FFFF0e;}\n",
-       ".cython.score-162 {background-color: #FFFF0e;}\n",
-       ".cython.score-163 {background-color: #FFFF0e;}\n",
-       ".cython.score-164 {background-color: #FFFF0e;}\n",
-       ".cython.score-165 {background-color: #FFFF0e;}\n",
-       ".cython.score-166 {background-color: #FFFF0e;}\n",
-       ".cython.score-167 {background-color: #FFFF0e;}\n",
-       ".cython.score-168 {background-color: #FFFF0e;}\n",
-       ".cython.score-169 {background-color: #FFFF0e;}\n",
-       ".cython.score-170 {background-color: #FFFF0e;}\n",
-       ".cython.score-171 {background-color: #FFFF0e;}\n",
-       ".cython.score-172 {background-color: #FFFF0e;}\n",
-       ".cython.score-173 {background-color: #FFFF0d;}\n",
-       ".cython.score-174 {background-color: #FFFF0d;}\n",
-       ".cython.score-175 {background-color: #FFFF0d;}\n",
-       ".cython.score-176 {background-color: #FFFF0d;}\n",
-       ".cython.score-177 {background-color: #FFFF0d;}\n",
-       ".cython.score-178 {background-color: #FFFF0d;}\n",
-       ".cython.score-179 {background-color: #FFFF0d;}\n",
-       ".cython.score-180 {background-color: #FFFF0d;}\n",
-       ".cython.score-181 {background-color: #FFFF0d;}\n",
-       ".cython.score-182 {background-color: #FFFF0d;}\n",
-       ".cython.score-183 {background-color: #FFFF0d;}\n",
-       ".cython.score-184 {background-color: #FFFF0d;}\n",
-       ".cython.score-185 {background-color: #FFFF0d;}\n",
-       ".cython.score-186 {background-color: #FFFF0d;}\n",
-       ".cython.score-187 {background-color: #FFFF0c;}\n",
-       ".cython.score-188 {background-color: #FFFF0c;}\n",
-       ".cython.score-189 {background-color: #FFFF0c;}\n",
-       ".cython.score-190 {background-color: #FFFF0c;}\n",
-       ".cython.score-191 {background-color: #FFFF0c;}\n",
-       ".cython.score-192 {background-color: #FFFF0c;}\n",
-       ".cython.score-193 {background-color: #FFFF0c;}\n",
-       ".cython.score-194 {background-color: #FFFF0c;}\n",
-       ".cython.score-195 {background-color: #FFFF0c;}\n",
-       ".cython.score-196 {background-color: #FFFF0c;}\n",
-       ".cython.score-197 {background-color: #FFFF0c;}\n",
-       ".cython.score-198 {background-color: #FFFF0c;}\n",
-       ".cython.score-199 {background-color: #FFFF0c;}\n",
-       ".cython.score-200 {background-color: #FFFF0c;}\n",
-       ".cython.score-201 {background-color: #FFFF0c;}\n",
-       ".cython.score-202 {background-color: #FFFF0c;}\n",
-       ".cython.score-203 {background-color: #FFFF0b;}\n",
-       ".cython.score-204 {background-color: #FFFF0b;}\n",
-       ".cython.score-205 {background-color: #FFFF0b;}\n",
-       ".cython.score-206 {background-color: #FFFF0b;}\n",
-       ".cython.score-207 {background-color: #FFFF0b;}\n",
-       ".cython.score-208 {background-color: #FFFF0b;}\n",
-       ".cython.score-209 {background-color: #FFFF0b;}\n",
-       ".cython.score-210 {background-color: #FFFF0b;}\n",
-       ".cython.score-211 {background-color: #FFFF0b;}\n",
-       ".cython.score-212 {background-color: #FFFF0b;}\n",
-       ".cython.score-213 {background-color: #FFFF0b;}\n",
-       ".cython.score-214 {background-color: #FFFF0b;}\n",
-       ".cython.score-215 {background-color: #FFFF0b;}\n",
-       ".cython.score-216 {background-color: #FFFF0b;}\n",
-       ".cython.score-217 {background-color: #FFFF0b;}\n",
-       ".cython.score-218 {background-color: #FFFF0b;}\n",
-       ".cython.score-219 {background-color: #FFFF0b;}\n",
-       ".cython.score-220 {background-color: #FFFF0b;}\n",
-       ".cython.score-221 {background-color: #FFFF0b;}\n",
-       ".cython.score-222 {background-color: #FFFF0a;}\n",
-       ".cython.score-223 {background-color: #FFFF0a;}\n",
-       ".cython.score-224 {background-color: #FFFF0a;}\n",
-       ".cython.score-225 {background-color: #FFFF0a;}\n",
-       ".cython.score-226 {background-color: #FFFF0a;}\n",
-       ".cython.score-227 {background-color: #FFFF0a;}\n",
-       ".cython.score-228 {background-color: #FFFF0a;}\n",
-       ".cython.score-229 {background-color: #FFFF0a;}\n",
-       ".cython.score-230 {background-color: #FFFF0a;}\n",
-       ".cython.score-231 {background-color: #FFFF0a;}\n",
-       ".cython.score-232 {background-color: #FFFF0a;}\n",
-       ".cython.score-233 {background-color: #FFFF0a;}\n",
-       ".cython.score-234 {background-color: #FFFF0a;}\n",
-       ".cython.score-235 {background-color: #FFFF0a;}\n",
-       ".cython.score-236 {background-color: #FFFF0a;}\n",
-       ".cython.score-237 {background-color: #FFFF0a;}\n",
-       ".cython.score-238 {background-color: #FFFF0a;}\n",
-       ".cython.score-239 {background-color: #FFFF0a;}\n",
-       ".cython.score-240 {background-color: #FFFF0a;}\n",
-       ".cython.score-241 {background-color: #FFFF0a;}\n",
-       ".cython.score-242 {background-color: #FFFF0a;}\n",
-       ".cython.score-243 {background-color: #FFFF0a;}\n",
-       ".cython.score-244 {background-color: #FFFF0a;}\n",
-       ".cython.score-245 {background-color: #FFFF0a;}\n",
-       ".cython.score-246 {background-color: #FFFF09;}\n",
-       ".cython.score-247 {background-color: #FFFF09;}\n",
-       ".cython.score-248 {background-color: #FFFF09;}\n",
-       ".cython.score-249 {background-color: #FFFF09;}\n",
-       ".cython.score-250 {background-color: #FFFF09;}\n",
-       ".cython.score-251 {background-color: #FFFF09;}\n",
-       ".cython.score-252 {background-color: #FFFF09;}\n",
-       ".cython.score-253 {background-color: #FFFF09;}\n",
-       ".cython.score-254 {background-color: #FFFF09;}\n",
-       "pre { line-height: 125%; }\n",
-       "td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
-       "td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       "span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
-       ".cython .hll { background-color: #ffffcc }\n",
-       ".cython { background: #f8f8f8; }\n",
-       ".cython .c { color: #3D7B7B; font-style: italic } /* Comment */\n",
-       ".cython .err { border: 1px solid #FF0000 } /* Error */\n",
-       ".cython .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       ".cython .o { color: #666666 } /* Operator */\n",
-       ".cython .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */\n",
-       ".cython .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */\n",
-       ".cython .cp { color: #9C6500 } /* Comment.Preproc */\n",
-       ".cython .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */\n",
-       ".cython .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */\n",
-       ".cython .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */\n",
-       ".cython .gd { color: #A00000 } /* Generic.Deleted */\n",
-       ".cython .ge { font-style: italic } /* Generic.Emph */\n",
-       ".cython .gr { color: #E40000 } /* Generic.Error */\n",
-       ".cython .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       ".cython .gi { color: #008400 } /* Generic.Inserted */\n",
-       ".cython .go { color: #717171 } /* Generic.Output */\n",
-       ".cython .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       ".cython .gs { font-weight: bold } /* Generic.Strong */\n",
-       ".cython .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       ".cython .gt { color: #0044DD } /* Generic.Traceback */\n",
-       ".cython .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       ".cython .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       ".cython .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       ".cython .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       ".cython .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       ".cython .kt { color: #B00040 } /* Keyword.Type */\n",
-       ".cython .m { color: #666666 } /* Literal.Number */\n",
-       ".cython .s { color: #BA2121 } /* Literal.String */\n",
-       ".cython .na { color: #687822 } /* Name.Attribute */\n",
-       ".cython .nb { color: #008000 } /* Name.Builtin */\n",
-       ".cython .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       ".cython .no { color: #880000 } /* Name.Constant */\n",
-       ".cython .nd { color: #AA22FF } /* Name.Decorator */\n",
-       ".cython .ni { color: #717171; font-weight: bold } /* Name.Entity */\n",
-       ".cython .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */\n",
-       ".cython .nf { color: #0000FF } /* Name.Function */\n",
-       ".cython .nl { color: #767600 } /* Name.Label */\n",
-       ".cython .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       ".cython .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       ".cython .nv { color: #19177C } /* Name.Variable */\n",
-       ".cython .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       ".cython .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       ".cython .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       ".cython .mf { color: #666666 } /* Literal.Number.Float */\n",
-       ".cython .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       ".cython .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       ".cython .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       ".cython .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       ".cython .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       ".cython .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       ".cython .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       ".cython .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       ".cython .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       ".cython .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */\n",
-       ".cython .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       ".cython .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */\n",
-       ".cython .sx { color: #008000 } /* Literal.String.Other */\n",
-       ".cython .sr { color: #A45A77 } /* Literal.String.Regex */\n",
-       ".cython .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       ".cython .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       ".cython .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       ".cython .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       ".cython .vc { color: #19177C } /* Name.Variable.Class */\n",
-       ".cython .vg { color: #19177C } /* Name.Variable.Global */\n",
-       ".cython .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       ".cython .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       ".cython .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
-       "    </style>\n",
-       "</head>\n",
-       "<body class=\"cython\">\n",
-       "<p><span style=\"border-bottom: solid 1px grey;\">Generated by Cython 3.0.2</span></p>\n",
-       "<p>\n",
-       "    <span style=\"background-color: #FFFF00\">Yellow lines</span> hint at Python interaction.<br />\n",
-       "    Click on a line that starts with a \"<code>+</code>\" to see the C code that Cython generated for it.\n",
-       "</p>\n",
-       "<div class=\"cython\"><pre class=\"cython line score-8\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">1</span>: <span class=\"c\"># distutils: language = c++</span></pre>\n",
-       "<pre class='cython code score-8 '>  __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyDict_NewPresized</span>(0);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error)</span>\n",
-       "  <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
-       "  if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_test, __pyx_t_3) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 1, __pyx_L1_error)</span>\n",
-       "  <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
-       "</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">2</span>: <span class=\"c\"># cython: boundscheck=False, wraparound=False, nonecheck=False, cdivision=True, initializedcheck=False</span></pre>\n",
-       "<pre class=\"cython line score-0\">&#xA0;<span class=\"\">3</span>: </pre>\n",
-       "<pre class=\"cython line score-0\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">4</span>: <span class=\"k\">cdef</span> <span class=\"kt\">double</span>* <span class=\"nf\">x</span> <span class=\"o\">=</span> <span class=\"bp\">NULL</span></pre>\n",
-       "<pre class='cython code score-0 '>  __pyx_v_54_cython_magic_8faab9cb4e44b9cd04e9e84e905d7642718ed40a_x = NULL;\n",
-       "</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">5</span>: </pre>\n",
-       "<pre class=\"cython line score-0\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">6</span>: <span class=\"k\">if</span> <span class=\"p\">(</span><span class=\"n\">x</span> <span class=\"ow\">is</span> <span class=\"bp\">NULL</span><span class=\"p\">):</span></pre>\n",
-       "<pre class='cython code score-0 '>  __pyx_t_2 = (__pyx_v_54_cython_magic_8faab9cb4e44b9cd04e9e84e905d7642718ed40a_x == NULL);\n",
-       "  if (__pyx_t_2) {\n",
-       "/* … */\n",
-       "    goto __pyx_L2;\n",
-       "  }\n",
-       "</pre><pre class=\"cython line score-8\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">7</span>:     <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s\">&#39;</span><span class=\"se\">\\n\\n</span><span class=\"s\">YES&#39;</span><span class=\"p\">)</span></pre>\n",
-       "<pre class='cython code score-8 '>    __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_Call</span>(__pyx_builtin_print, __pyx_tuple_, NULL);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7, __pyx_L1_error)</span>\n",
-       "    <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
-       "    <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
-       "/* … */\n",
-       "  __pyx_tuple_ = <span class='py_c_api'>PyTuple_Pack</span>(1, __pyx_kp_u_YES);<span class='error_goto'> if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 7, __pyx_L1_error)</span>\n",
-       "  <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_tuple_);\n",
-       "  <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_tuple_);\n",
-       "</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">8</span>: <span class=\"k\">else</span><span class=\"p\">:</span></pre>\n",
-       "<pre class=\"cython line score-3\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">9</span>:     <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s\">&#39;</span><span class=\"se\">\\n\\n</span><span class=\"s\">NO&#39;</span><span class=\"p\">)</span></pre>\n",
-       "<pre class='cython code score-3 '>  /*else*/ {\n",
-       "    __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_Call</span>(__pyx_builtin_print, __pyx_tuple__2, NULL);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 9, __pyx_L1_error)</span>\n",
-       "    <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
-       "    <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
-       "  }\n",
-       "  __pyx_L2:;\n",
-       "</pre></div></body></html>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
     }
    ],
    "source": [
-    "%%cython --annotate --force\n",
-    "# distutils: language = c++\n",
+    "%%cython --annotate --force --compile-args=/openmp --link-args=/openmp -a\n",
+    "# distutils: language = c\n",
     "# cython: boundscheck=False, wraparound=False, nonecheck=False, cdivision=True, initializedcheck=False\n",
     "\n",
-    "cdef double* x = NULL\n",
     "\n",
-    "if (x is NULL):\n",
-    "    print('\\n\\nYES')\n",
-    "else:\n",
-    "    print('\\n\\nNO')"
+    "from libc.stdio cimport printf\n",
+    "\n",
+    "import numpy as np\n",
+    "cimport numpy as np\n",
+    "\n",
+    "from cython.parallel import prange\n",
+    "\n",
+    "from CyRK.cy.cysolver cimport CySolver\n",
+    "\n",
+    "cdef class CySolverTester(CySolver):\n",
+    "\n",
+    "    cdef void diffeq(self) noexcept nogil:\n",
+    "        \n",
+    "        # Unpack y\n",
+    "        cdef double y0, y1\n",
+    "        y0 = self.y_ptr[0]\n",
+    "        y1 = self.y_ptr[1]\n",
+    "\n",
+    "        self.dy_ptr[0] = (1. - 0.01 * y1) * y0\n",
+    "        self.dy_ptr[1] = (0.02 * y0 - 1.) * y1\n",
+    "\n",
+    "\n",
+    "def run_1():\n",
+    "    \n",
+    "    cdef double t_start, t_end\n",
+    "    cdef double[::1] initial_conds = np.asarray((20., 20.), dtype=np.float64, order='C')\n",
+    "    \n",
+    "    t_start = 0.\n",
+    "    t_end = 5.\n",
+    "    \n",
+    "    for i in range(100):\n",
+    "        \n",
+    "        initial_conds[0] = <double>i\n",
+    "        \n",
+    "        solver = CySolverTester((t_start, t_end), initial_conds)\n",
+    "        solver._solve(False)\n",
+    "        \n",
+    "        assert solver.success\n",
+    "    \n",
+    "def run_2():\n",
+    "    \n",
+    "    cdef double t_start, t_end\n",
+    "    cdef double[::1] initial_conds = np.asarray((20., 20.), dtype=np.float64, order='C')\n",
+    "    \n",
+    "    t_start = 0.\n",
+    "    t_end = 5.\n",
+    "    solver = CySolverTester((t_start, t_end), initial_conds)\n",
+    "    \n",
+    "    for i in range(100):\n",
+    "        \n",
+    "        initial_conds = np.asarray((i, 20.), dtype=np.float64, order='C')\n",
+    "        \n",
+    "        solver.change_y0_pointer(&initial_conds[0])\n",
+    "        solver._solve(True)\n",
+    "        \n",
+    "        assert solver.success\n",
+    "        \n",
+    "def run_parallel_1():\n",
+    "    \n",
+    "    cdef ssize_t i\n",
+    "    cdef double t_start, t_end\n",
+    "    cdef double[::1] initial_conds = np.asarray((20., 20.), dtype=np.float64, order='C')\n",
+    "    cdef double* initial_conds_ptrs[100]\n",
+    "    \n",
+    "    cdef CySolverTester solver\n",
+    "    \n",
+    "    for i in range(100):\n",
+    "        initial_conds = np.asarray((20., 20.), dtype=np.float64, order='C')\n",
+    "        initial_conds_ptrs[i] = &initial_conds[0]\n",
+    "        \n",
+    "    t_start = 0.\n",
+    "    t_end = 5.\n",
+    "    \n",
+    "    for i in prange(100, nogil=True):\n",
+    "        \n",
+    "        solver = CySolverTester((t_start, t_end), initial_conds)\n",
+    "        solver._solve(False)\n",
+    "        \n",
+    "        if not solver.success:\n",
+    "            printf(\"FAIL AT %d\", i)\n",
+    "    \n",
+    "def run_parallel_2():\n",
+    "    \n",
+    "    cdef ssize_t i\n",
+    "    cdef double t_start, t_end\n",
+    "    cdef double[::1] initial_conds = np.asarray((20., 20.), dtype=np.float64, order='C')\n",
+    "    cdef double* initial_conds_ptrs[100]\n",
+    "    \n",
+    "    t_start = 0.\n",
+    "    t_end = 5.\n",
+    "    cdef CySolverTester solver\n",
+    "    solver = CySolverTester((t_start, t_end), initial_conds)\n",
+    "    \n",
+    "    for i in range(100):\n",
+    "        initial_conds = np.asarray((20., 20.), dtype=np.float64, order='C')\n",
+    "        initial_conds_ptrs[i] = &initial_conds[0]\n",
+    "    \n",
+    "    for i in prange(100, nogil=True):\n",
+    "        \n",
+    "        solver.change_y0_pointer(initial_conds_ptrs[i])\n",
+    "        solver._solve(True)\n",
+    "        \n",
+    "        if not solver.success:\n",
+    "            printf(\"FAIL AT %d\", i)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cf7c6558",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "604 µs ± 13.8 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n",
+      "539 µs ± 7.62 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Run 1:\n",
+    "# 910us\n",
+    "# 597us\n",
+    "%timeit run_1()\n",
+    "\n",
+    "# Run 2:\n",
+    "# 554us\n",
+    "# 550us\n",
+    "%timeit run_2()\n",
+    "\n",
+    "# run_parallel_2\n",
+    "# \n",
+    "%timeit run_parallel_2()"
    ]
   },
   {
@@ -9096,7 +8902,7 @@
     "from libcpp cimport bool as bool_cpp_t\n",
     "from libc.math cimport sqrt, fabs, nextafter, fmax, fmin, isnan, NAN, pow, floor\n",
     "\n",
-    "from cpython.mem cimport PyMem_Free\n",
+    "from libc.stdlib cimport free\n",
     "\n",
     "import numpy as np\n",
     "cimport numpy as np\n",
@@ -10080,18 +9886,18 @@
     "            # Free any data stored in solution arrays so that we can repopulate them with the new solution\n",
     "            if not (self.solution_t_ptr is NULL):\n",
     "                printf('FREE SOL-t\\n')\n",
-    "                PyMem_Free(self.solution_t_ptr)\n",
+    "                free(self.solution_t_ptr)\n",
     "                self.solution_t_ptr = NULL\n",
     "                printf('\\tSuccess.\\n')\n",
     "            if not (self.solution_y_ptr is NULL):\n",
     "                printf('FREE SOL-y\\n')\n",
-    "                PyMem_Free(self.solution_y_ptr)\n",
+    "                free(self.solution_y_ptr)\n",
     "                self.solution_y_ptr = NULL\n",
     "                printf('\\tSuccess.\\n')\n",
     "            if self.capture_extra:\n",
     "                if not (self.solution_extra_ptr is NULL):\n",
     "                    printf('FREE SOL-ex\\n')\n",
-    "                    PyMem_Free(self.solution_extra_ptr)\n",
+    "                    free(self.solution_extra_ptr)\n",
     "                    self.solution_extra_ptr = NULL\n",
     "                    printf('\\tSuccess.\\n')\n",
     "\n",
@@ -10132,14 +9938,14 @@
     "            # Integration was not successful. Make solution pointers length 1 nan arrays.\n",
     "            # Clear the storage arrays used during the step loop\n",
     "            if not (self._solve_time_domain_array_ptr is NULL):\n",
-    "                PyMem_Free(self._solve_time_domain_array_ptr)\n",
+    "                free(self._solve_time_domain_array_ptr)\n",
     "                self._solve_time_domain_array_ptr = NULL\n",
     "            if not (self._solve_y_results_array_ptr is NULL):\n",
-    "                PyMem_Free(self._solve_y_results_array_ptr)\n",
+    "                free(self._solve_y_results_array_ptr)\n",
     "                self._solve_y_results_array_ptr = NULL\n",
     "            if self.capture_extra:\n",
     "                if not (self._solve_extra_array_ptr is NULL):\n",
-    "                    PyMem_Free(self._solve_extra_array_ptr)\n",
+    "                    free(self._solve_extra_array_ptr)\n",
     "                    self._solve_extra_array_ptr = NULL\n",
     "\n",
     "            # We still need to build solution arrays so that accessing the solution will not cause access violations.\n",
@@ -10206,13 +10012,13 @@
     "\n",
     "        # Release any memory that may still be alive due to exceptions being raised.\n",
     "        if not (self._solve_time_domain_array_ptr is NULL):\n",
-    "            PyMem_Free(self._solve_time_domain_array_ptr)\n",
+    "            free(self._solve_time_domain_array_ptr)\n",
     "            self._solve_time_domain_array_ptr = NULL\n",
     "        if not (self._solve_y_results_array_ptr is NULL):\n",
-    "            PyMem_Free(self._solve_y_results_array_ptr)\n",
+    "            free(self._solve_y_results_array_ptr)\n",
     "            self._solve_y_results_array_ptr = NULL\n",
     "        if not (self._solve_extra_array_ptr is NULL):\n",
-    "            PyMem_Free(self._solve_extra_array_ptr)\n",
+    "            free(self._solve_extra_array_ptr)\n",
     "            self._solve_extra_array_ptr = NULL\n",
     "        \n",
     "        printf('END SOLVE\\n')\n",
@@ -10301,17 +10107,17 @@
     "\n",
     "            # Replace old pointers with new interpolated pointers and release the memory for the old stuff\n",
     "            if not (self.solution_extra_ptr is NULL):\n",
-    "                PyMem_Free(self.solution_extra_ptr)\n",
+    "                free(self.solution_extra_ptr)\n",
     "            self.solution_extra_ptr = self._interpolate_solution_extra_ptr\n",
     "            self._interpolate_solution_extra_ptr = NULL\n",
     "\n",
     "        # Replace old pointers with new interpolated pointers and release the memory for the old stuff\n",
     "        if not (self.solution_t_ptr is NULL):\n",
-    "            PyMem_Free(self.solution_t_ptr)\n",
+    "            free(self.solution_t_ptr)\n",
     "        self.solution_t_ptr = self._interpolate_solution_t_ptr\n",
     "        self._interpolate_solution_t_ptr = NULL\n",
     "        if not (self.solution_y_ptr is NULL):\n",
-    "            PyMem_Free(self.solution_y_ptr)\n",
+    "            free(self.solution_y_ptr)\n",
     "        self.solution_y_ptr = self._interpolate_solution_y_ptr\n",
     "        self._interpolate_solution_y_ptr = NULL\n",
     "\n",
@@ -10320,13 +10126,13 @@
     "\n",
     "        # Free any memory that may still be alive if exceptions were raised.\n",
     "        if not (self._interpolate_solution_t_ptr is NULL):\n",
-    "            PyMem_Free(self._interpolate_solution_t_ptr)\n",
+    "            free(self._interpolate_solution_t_ptr)\n",
     "            self._interpolate_solution_t_ptr = NULL\n",
     "        if not (self._interpolate_solution_y_ptr is NULL):\n",
-    "            PyMem_Free(self._interpolate_solution_y_ptr)\n",
+    "            free(self._interpolate_solution_y_ptr)\n",
     "            self._interpolate_solution_y_ptr = NULL\n",
     "        if not (self._interpolate_solution_extra_ptr is NULL):\n",
-    "            PyMem_Free(self._interpolate_solution_extra_ptr)\n",
+    "            free(self._interpolate_solution_extra_ptr)\n",
     "            self._interpolate_solution_extra_ptr = NULL\n",
     "        \n",
     "        printf('END INTERPOLATE\\n')\n",
@@ -10902,62 +10708,62 @@
     "        printf('DEALLOC-1\\n')\n",
     "        # Free pointers made from user inputs\n",
     "        if not (self.y0_ptr is NULL):\n",
-    "            PyMem_Free(self.y0_ptr)\n",
+    "            free(self.y0_ptr)\n",
     "            self.y0_ptr = NULL\n",
     "        if not (self.tol_ptrs is NULL):\n",
-    "            PyMem_Free(self.tol_ptrs)\n",
+    "            free(self.tol_ptrs)\n",
     "            self.tol_ptrs = NULL\n",
     "        if not (self.args_ptr is NULL):\n",
-    "            PyMem_Free(self.args_ptr)\n",
+    "            free(self.args_ptr)\n",
     "            self.args_ptr = NULL\n",
     "        if not (self.t_eval_ptr is NULL):\n",
-    "            PyMem_Free(self.t_eval_ptr)\n",
+    "            free(self.t_eval_ptr)\n",
     "            self.t_eval_ptr = NULL\n",
     "        printf('DEALLOC-2\\n')\n",
     "        # Free pointers used to track y, dydt, and any extra outputs\n",
     "        if not (self.temporary_y_ptrs is NULL):\n",
-    "            PyMem_Free(self.temporary_y_ptrs)\n",
+    "            free(self.temporary_y_ptrs)\n",
     "            self.temporary_y_ptrs = NULL\n",
     "        if not (self.extra_output_ptrs is NULL):\n",
-    "            PyMem_Free(self.extra_output_ptrs)\n",
+    "            free(self.extra_output_ptrs)\n",
     "            self.extra_output_ptrs = NULL\n",
     "        printf('DEALLOC-3\\n')\n",
     "        # Free final solution pointers\n",
     "        if not (self.solution_t_ptr is NULL):\n",
-    "            PyMem_Free(self.solution_t_ptr)\n",
+    "            free(self.solution_t_ptr)\n",
     "            self.solution_t_ptr = NULL\n",
     "        if not (self.solution_y_ptr is NULL):\n",
-    "            PyMem_Free(self.solution_y_ptr)\n",
+    "            free(self.solution_y_ptr)\n",
     "            self.solution_y_ptr = NULL\n",
     "        if not (self.solution_extra_ptr is NULL):\n",
-    "            PyMem_Free(self.solution_extra_ptr)\n",
+    "            free(self.solution_extra_ptr)\n",
     "            self.solution_extra_ptr = NULL\n",
     "        printf('DEALLOC-4\\n')\n",
     "        # Free pointers used during the solve method\n",
     "        if not (self._solve_time_domain_array_ptr is NULL):\n",
-    "            PyMem_Free(self._solve_time_domain_array_ptr)\n",
+    "            free(self._solve_time_domain_array_ptr)\n",
     "            self._solve_time_domain_array_ptr = NULL\n",
     "        if not (self._solve_y_results_array_ptr is NULL):\n",
-    "            PyMem_Free(self._solve_y_results_array_ptr)\n",
+    "            free(self._solve_y_results_array_ptr)\n",
     "            self._solve_y_results_array_ptr = NULL\n",
     "        if not (self._solve_extra_array_ptr is NULL):\n",
-    "            PyMem_Free(self._solve_extra_array_ptr)\n",
+    "            free(self._solve_extra_array_ptr)\n",
     "            self._solve_extra_array_ptr = NULL\n",
     "        printf('DEALLOC-5\\n')\n",
     "        # Free pointers used during interpolation\n",
     "        if not (self._interpolate_solution_t_ptr is NULL):\n",
-    "            PyMem_Free(self._interpolate_solution_t_ptr)\n",
+    "            free(self._interpolate_solution_t_ptr)\n",
     "            self._interpolate_solution_t_ptr = NULL\n",
     "        if not (self._interpolate_solution_y_ptr is NULL):\n",
-    "            PyMem_Free(self._interpolate_solution_y_ptr)\n",
+    "            free(self._interpolate_solution_y_ptr)\n",
     "            self._interpolate_solution_y_ptr = NULL\n",
     "        if not (self._interpolate_solution_extra_ptr is NULL):\n",
-    "            PyMem_Free(self._interpolate_solution_extra_ptr)\n",
+    "            free(self._interpolate_solution_extra_ptr)\n",
     "            self._interpolate_solution_extra_ptr = NULL\n",
     "        printf('DEALLOC-6\\n')\n",
     "        # Free RK Temp Storage Array\n",
     "        if not (self.K_ptr is NULL):\n",
-    "            PyMem_Free(self.K_ptr)\n",
+    "            free(self.K_ptr)\n",
     "            self.K_ptr = NULL\n",
     "        printf('End DEALLOC\\n')\n",
     "\n",
@@ -11077,7 +10883,7 @@
     "cimport numpy as np\n",
     "np.import_array()\n",
     "\n",
-    "from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free\n",
+    "from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, free\n",
     "\n",
     "from libcpp cimport bool as bool_cpp_t\n",
     "from libc.math cimport sqrt, fabs, nextafter, fmax, fmin, NAN\n",
@@ -11955,8 +11761,8 @@
     "    if success:\n",
     "        # Solution was successful.\n",
     "        # Release storage arrays so they can be reset\n",
-    "        PyMem_Free(solution_t_ptr)\n",
-    "        PyMem_Free(solution_y_ptr)\n",
+    "        free(solution_t_ptr)\n",
+    "        free(solution_y_ptr)\n",
     "\n",
     "        # Load values into output arrays.\n",
     "        # The arrays built during integration likely have a bunch of unused junk at the end due to overbuilding their size.\n",
@@ -11974,7 +11780,7 @@
     "            raise MemoryError()\n",
     "\n",
     "        if capture_extra:\n",
-    "            PyMem_Free(solution_extra_ptr)\n",
+    "            free(solution_extra_ptr)\n",
     "            solution_extra_ptr = <double_numeric *> PyMem_Realloc(extra_array_ptr,\n",
     "                                                                  num_extra * len_t * sizeof(double_numeric))\n",
     "            if not solution_extra_ptr:\n",
@@ -11982,10 +11788,10 @@
     "    else:\n",
     "        # Integration was not successful. Leave the solution pointers as length 1 nan arrays.\n",
     "        # Clear the storage arrays used during the step loop\n",
-    "        PyMem_Free(time_domain_array_ptr)\n",
-    "        PyMem_Free(y_results_array_ptr)\n",
+    "        free(time_domain_array_ptr)\n",
+    "        free(y_results_array_ptr)\n",
     "        if capture_extra:\n",
-    "            PyMem_Free(extra_array_ptr)\n",
+    "            free(extra_array_ptr)\n",
     "\n",
     "    # Integration is complete. Check if interpolation was requested.\n",
     "    cdef Py_ssize_t len_t_touse\n",
@@ -12062,12 +11868,12 @@
     "                        interpolated_solution_extra_ptr[i * num_extra + j] = diffeq_out_view[extra_start + j]\n",
     "\n",
     "            # Replace old pointers with new interpolated pointers and release the memory for the old stuff\n",
-    "            PyMem_Free(solution_extra_ptr)\n",
+    "            free(solution_extra_ptr)\n",
     "            solution_extra_ptr = interpolated_solution_extra_ptr\n",
     "\n",
     "        # Replace old pointers with new interpolated pointers and release the memory for the old stuff\n",
-    "        PyMem_Free(solution_t_ptr)\n",
-    "        PyMem_Free(solution_y_ptr)\n",
+    "        free(solution_t_ptr)\n",
+    "        free(solution_y_ptr)\n",
     "        solution_t_ptr = interpolated_solution_t_ptr\n",
     "        solution_y_ptr = interpolated_solution_y_ptr\n",
     "\n",
@@ -12112,32 +11918,32 @@
     "        message = \"Error in step size calculation:\\n\\tError in step size acceptance.\"\n",
     "\n",
     "    # Free pointers made from user inputs\n",
-    "    PyMem_Free(rtols_ptr)\n",
-    "    PyMem_Free(atols_ptr)\n",
-    "    PyMem_Free(t_eval_ptr)\n",
+    "    free(rtols_ptr)\n",
+    "    free(atols_ptr)\n",
+    "    free(t_eval_ptr)\n",
     "\n",
     "    # Free pointers used to track y, dydt, and any extra outputs\n",
-    "    PyMem_Free(y_old_ptr)\n",
-    "    PyMem_Free(dy_ptr)\n",
-    "    PyMem_Free(dy_old_ptr)\n",
-    "    PyMem_Free(extra_output_init_ptr)\n",
-    "    PyMem_Free(extra_output_ptr)\n",
+    "    free(y_old_ptr)\n",
+    "    free(dy_ptr)\n",
+    "    free(dy_old_ptr)\n",
+    "    free(extra_output_init_ptr)\n",
+    "    free(extra_output_ptr)\n",
     "\n",
     "    # Free final solution pointers\n",
-    "    PyMem_Free(solution_y_ptr)\n",
-    "    PyMem_Free(solution_t_ptr)\n",
-    "    PyMem_Free(solution_extra_ptr)\n",
+    "    free(solution_y_ptr)\n",
+    "    free(solution_t_ptr)\n",
+    "    free(solution_extra_ptr)\n",
     "\n",
     "    # Free RK Constants\n",
-    "    PyMem_Free(A_ptr)\n",
-    "    PyMem_Free(B_ptr)\n",
-    "    PyMem_Free(C_ptr)\n",
-    "    PyMem_Free(E_ptr)\n",
-    "    PyMem_Free(E3_ptr)\n",
-    "    PyMem_Free(E5_ptr)\n",
+    "    free(A_ptr)\n",
+    "    free(B_ptr)\n",
+    "    free(C_ptr)\n",
+    "    free(E_ptr)\n",
+    "    free(E3_ptr)\n",
+    "    free(E5_ptr)\n",
     "\n",
     "    # Free RK Temp Storage Array\n",
-    "    PyMem_Free(K_ptr)\n",
+    "    free(K_ptr)\n",
     "\n",
     "    return solution_t, solution_y, success, message\n"
    ]
@@ -12158,7 +11964,7 @@
     "from libcpp cimport bool as bool_cpp_t\n",
     "from libc.math cimport sqrt, fabs, nextafter, fmax, fmin, isnan, NAN, pow\n",
     "\n",
-    "from cpython.mem cimport PyMem_Free\n",
+    "from cpython.mem cimport free\n",
     "\n",
     "import numpy as np\n",
     "cimport numpy as np\n",
@@ -13245,12 +13051,12 @@
     "        if self.success:\n",
     "            # Solution was successful.\n",
     "            # Free any data stored in solution arrays so that we can repopulate them with the new solution\n",
-    "            PyMem_Free(self.solution_t_ptr)\n",
+    "            free(self.solution_t_ptr)\n",
     "            self.solution_t_ptr = NULL\n",
-    "            PyMem_Free(self.solution_y_ptr)\n",
+    "            free(self.solution_y_ptr)\n",
     "            self.solution_y_ptr = NULL\n",
     "            if self.capture_extra:\n",
-    "                PyMem_Free(self.solution_extra_ptr)\n",
+    "                free(self.solution_extra_ptr)\n",
     "                self.solution_extra_ptr = NULL\n",
     "\n",
     "            # Load values into solution arrays.\n",
@@ -13280,12 +13086,12 @@
     "            # Integration was not successful. Make solution pointers length 1 nan arrays.\n",
     "\n",
     "            # Clear the storage arrays used during the step loop\n",
-    "            PyMem_Free(time_domain_array_ptr)\n",
+    "            free(time_domain_array_ptr)\n",
     "            time_domain_array_ptr = NULL\n",
-    "            PyMem_Free(y_results_array_ptr)\n",
+    "            free(y_results_array_ptr)\n",
     "            y_results_array_ptr = NULL\n",
     "            if self.capture_extra:\n",
-    "                PyMem_Free(extra_array_ptr)\n",
+    "                free(extra_array_ptr)\n",
     "                extra_array_ptr = NULL\n",
     "\n",
     "            # We still need to build solution arrays so that accessing the solution will not cause access violations.\n",
@@ -13350,13 +13156,13 @@
     "\n",
     "        # Release any memory that may still be alive due to exceptions being raised.\n",
     "        if not (time_domain_array_ptr is NULL):\n",
-    "            PyMem_Free(time_domain_array_ptr)\n",
+    "            free(time_domain_array_ptr)\n",
     "            time_domain_array_ptr = NULL\n",
     "        if not (y_results_array_ptr is NULL):\n",
-    "            PyMem_Free(y_results_array_ptr)\n",
+    "            free(y_results_array_ptr)\n",
     "            y_results_array_ptr = NULL\n",
     "        if not (extra_array_ptr is NULL):\n",
-    "            PyMem_Free(extra_array_ptr)\n",
+    "            free(extra_array_ptr)\n",
     "            extra_array_ptr = NULL\n",
     "\n",
     "\n",
@@ -13430,15 +13236,15 @@
     "                        interpolated_solution_extra_ptr[i * self.num_extra + j] = self.extra_output_ptr[j]\n",
     "\n",
     "            # Replace old pointers with new interpolated pointers and release the memory for the old stuff\n",
-    "            PyMem_Free(self.solution_extra_ptr)\n",
+    "            free(self.solution_extra_ptr)\n",
     "            self.solution_extra_ptr = interpolated_solution_extra_ptr\n",
     "            interpolated_solution_extra_ptr = NULL\n",
     "\n",
     "        # Replace old pointers with new interpolated pointers and release the memory for the old stuff\n",
-    "        PyMem_Free(self.solution_t_ptr)\n",
+    "        free(self.solution_t_ptr)\n",
     "        self.solution_t_ptr = interpolated_solution_t_ptr\n",
     "        interpolated_solution_t_ptr = NULL\n",
-    "        PyMem_Free(self.solution_y_ptr)\n",
+    "        free(self.solution_y_ptr)\n",
     "        self.solution_y_ptr = interpolated_solution_y_ptr\n",
     "        interpolated_solution_y_ptr = NULL\n",
     "\n",
@@ -13447,13 +13253,13 @@
     "\n",
     "        # Free any memory that may still be alive if exceptions were raised.\n",
     "        if not (interpolated_solution_t_ptr is NULL):\n",
-    "            PyMem_Free(interpolated_solution_t_ptr)\n",
+    "            free(interpolated_solution_t_ptr)\n",
     "            interpolated_solution_t_ptr = NULL\n",
     "        if not (interpolated_solution_y_ptr is NULL):\n",
-    "            PyMem_Free(interpolated_solution_y_ptr)\n",
+    "            free(interpolated_solution_y_ptr)\n",
     "            interpolated_solution_y_ptr = NULL\n",
     "        if not (interpolated_solution_extra_ptr is NULL):\n",
-    "            PyMem_Free(interpolated_solution_extra_ptr)\n",
+    "            free(interpolated_solution_extra_ptr)\n",
     "            interpolated_solution_extra_ptr = NULL\n",
     "\n",
     "    cpdef void change_t_span(\n",
@@ -14016,40 +13822,40 @@
     "    def __dealloc__(self):\n",
     "        # Free pointers made from user inputs\n",
     "        if not (self.y0_ptr is NULL):\n",
-    "            PyMem_Free(self.y0_ptr)\n",
+    "            free(self.y0_ptr)\n",
     "            self.y0_ptr = NULL\n",
     "        if not (self.tol_ptrs):\n",
-    "            PyMem_Free(self.tol_ptrs)\n",
+    "            free(self.tol_ptrs)\n",
     "            self.tol_ptrs = NULL\n",
     "        if not (self.args_ptr):\n",
-    "            PyMem_Free(self.args_ptr)\n",
+    "            free(self.args_ptr)\n",
     "            self.args_ptr = NULL\n",
     "        if not (self.t_eval_ptr):\n",
-    "            PyMem_Free(self.t_eval_ptr)\n",
+    "            free(self.t_eval_ptr)\n",
     "            self.t_eval_ptr = NULL\n",
     "\n",
     "        # Free pointers used to track y, dydt, and any extra outputs\n",
     "        if not (self.temporary_y_ptrs):\n",
-    "            PyMem_Free(self.temporary_y_ptrs)\n",
+    "            free(self.temporary_y_ptrs)\n",
     "            self.temporary_y_ptrs = NULL\n",
     "        if not (self.extra_output_ptrs):\n",
-    "            PyMem_Free(self.extra_output_ptrs)\n",
+    "            free(self.extra_output_ptrs)\n",
     "            self.extra_output_ptrs = NULL\n",
     "\n",
     "        # Free final solution pointers\n",
     "        if not (self.solution_t_ptr):\n",
-    "            PyMem_Free(self.solution_t_ptr)\n",
+    "            free(self.solution_t_ptr)\n",
     "            self.solution_t_ptr = NULL\n",
     "        if not (self.solution_y_ptr):\n",
-    "            PyMem_Free(self.solution_y_ptr)\n",
+    "            free(self.solution_y_ptr)\n",
     "            self.solution_y_ptr = NULL\n",
     "        if not (self.solution_extra_ptr):\n",
-    "            PyMem_Free(self.solution_extra_ptr)\n",
+    "            free(self.solution_extra_ptr)\n",
     "            self.solution_extra_ptr = NULL\n",
     "\n",
     "        # Free RK Temp Storage Array\n",
     "        if not (self.K_ptr):\n",
-    "            PyMem_Free(self.K_ptr)\n",
+    "            free(self.K_ptr)\n",
     "            self.K_ptr = NULL\n",
     "\n",
     "cdef class CySolverLotkavolterra(CySolver):\n",
diff --git a/_build_cyrk.py b/_build_cyrk.py
index 8413363..01bb420 100644
--- a/_build_cyrk.py
+++ b/_build_cyrk.py
@@ -19,14 +19,14 @@
     extra_link_args = []
 elif install_platform.lower() == 'darwin':
     # OpenMP is installed via llvm. See https://stackoverflow.com/questions/60005176/how-to-deal-with-clang-error-unsupported-option-fopenmp-on-travis
-    extra_compile_args = []
+    extra_compile_args = ['-O3']
     extra_link_args = []
 else:
-    extra_compile_args = ['-fopenmp']
-    extra_link_args = ['-fopenmp']
+    extra_compile_args = ['-fopenmp', '-O3']
+    extra_link_args = ['-fopenmp', '-O3']
 macro_list = [("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")]
 
-# Load TidalPy's cython extensions
+# Load CyRK's cython extensions
 absolute_path = os.path.dirname(__file__)
 cython_ext_path = os.path.join(absolute_path, 'cython_extensions.json')
 with open(cython_ext_path, 'r') as cython_ext_file:
diff --git a/cython_extensions.json b/cython_extensions.json
index 535c0f8..86486df 100644
--- a/cython_extensions.json
+++ b/cython_extensions.json
@@ -8,7 +8,7 @@
   },
   "interp": {
     "name": "CyRK.array.interp",
-    "sources": [["CyRK", "array", "interp.pyx"], ["CyRK", "array", "interp_common.c"]],
+    "sources": [["CyRK", "array", "interp.pyx"]],
     "include_dirs": [["CyRK", "array"]],
     "compile_args": [],
     "link_args": []
@@ -43,7 +43,9 @@
   },
   "cysolver": {
     "name": "CyRK.cy.cysolver",
-    "sources": [["CyRK", "cy", "cysolver.pyx"]],
+    "sources": [
+      ["CyRK", "cy", "cysolver.pyx"]
+    ],
     "include_dirs": [["CyRK", "cy"]],
     "compile_args": [],
     "link_args": []
diff --git a/pyproject.toml b/pyproject.toml
index 9d72547..de97be9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,14 +1,14 @@
 [project]
 name='CyRK'
-version = '0.8.5'
+version = '0.9.0a0.dev1'
 description='Runge-Kutta ODE Integrator Implemented in Cython and Numba.'
 authors= [
     {name = 'Joe P. Renaud', email = 'joe.p.renaud@gmail.com'}
     ]
-requires-python = ">=3.8,<3.12"
+requires-python = ">=3.8,<3.13"
 dependencies = [
     'numba >= 0.54.1',
-    'numpy >= 1.22, <1.26',
+    'numpy >= 1.22, <1.27',
     'scipy >= 1.9.3'
 ]
 license = {file = "LICENSE.md"}
@@ -59,7 +59,7 @@ dev = [
 [build-system]
 requires = [
     'setuptools>=64.0.0',
-    'numpy >= 1.22, <1.26',
+    'numpy >= 1.22, <1.27',
     'cython>=3.0.0',
     'wheel>=0.38'
 ]
@@ -85,3 +85,5 @@ testpaths = [
 
 [tool.cibuildwheel]
 build = "*"
+# Disable building PyPy wheels on all platforms
+skip = "pp*"
diff --git a/setup.py b/setup.py
index 77d453c..1b8bb9e 100644
--- a/setup.py
+++ b/setup.py
@@ -13,14 +13,14 @@
     extra_link_args = []
 elif install_platform.lower() == 'darwin':
     # OpenMP is installed via llvm. See https://stackoverflow.com/questions/60005176/how-to-deal-with-clang-error-unsupported-option-fopenmp-on-travis
-    extra_compile_args = []
+    extra_compile_args = ['-O3']
     extra_link_args = []
 else:
-    extra_compile_args = ['-fopenmp']
-    extra_link_args = ['-fopenmp']
+    extra_compile_args = ['-fopenmp', '-O3']
+    extra_link_args = ['-fopenmp', '-O3']
 macro_list = [("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")]
 
-# Load TidalPy's cython extensions
+# Load CyRK's cython extensions
 absolute_path = os.path.dirname(__file__)
 cython_ext_path = os.path.join(absolute_path, 'cython_extensions.json')
 with open(cython_ext_path, 'r') as cython_ext_file:


Test patch:
diff --git a/.github/workflows/build_wheels_test_pypi.yml b/.github/workflows/build_wheels_test_pypi.yml
index b205281..75f8d7d 100644
--- a/.github/workflows/build_wheels_test_pypi.yml
+++ b/.github/workflows/build_wheels_test_pypi.yml
@@ -8,14 +8,14 @@ jobs:
     name: Make SDist
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
         submodules: true  # Optional, use if you have submodules
 
     - name: Build SDist
       run: pipx run build --sdist
 
-    - uses: actions/upload-artifact@v3
+    - uses: actions/upload-artifact@v4
       with:
         path: dist/*.tar.gz
 
@@ -31,14 +31,14 @@ jobs:
               - ubuntu-20.04
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
       - name: Build wheels
-        uses: pypa/cibuildwheel@v2.11.4
+        uses: pypa/cibuildwheel@v2.16.5
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           path: ./wheelhouse/*.whl
 
@@ -47,7 +47,7 @@ jobs:
     needs: [make_sdist, build_wheels]
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: artifact
           path: dist
@@ -60,7 +60,7 @@ jobs:
     runs-on: ubuntu-latest
     # if: github.event_name == 'release' && github.event.action == 'published'
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: artifact
           path: dist
diff --git a/.github/workflows/push_tests_mac.yml b/.github/workflows/push_tests_mac.yml
index 776404e..d77d9ec 100644
--- a/.github/workflows/push_tests_mac.yml
+++ b/.github/workflows/push_tests_mac.yml
@@ -11,46 +11,43 @@ jobs:
     defaults:
       run:
         shell: bash -el {0}
-
     name: Test CyRK on MacOS
     runs-on: macos-latest
     strategy:
+      fail-fast: false
       matrix:
         python-version:
           - "3.8"
           - "3.9"
           - "3.10"
           - "3.11"
+          - "3.12"
     steps:
-      - uses: actions/checkout@v3
-      - uses: conda-incubator/setup-miniconda@v2
+      - uses: actions/checkout@v4
+      - uses: conda-incubator/setup-miniconda@v3
         with:
           activate-environment: cyrk_test
           auto-update-conda: true
           python-version: ${{ matrix.python-version }}
           auto-activate-base: false
+        
       - name: Conda info
         shell: bash -el {0}
         run: conda info
-      - name: install libomp
-        shell: bash -el {0}
-        run: |
-          brew reinstall llvm libomp
-      - name: Install Dependencies
+        
+      - name: install gcc-13 # openMP does not play nice with clang on MacOS; also some versions of macos use older gcc so there is a need to install latest.
         shell: bash -el {0}
         run: |
-          conda install numpy scipy cython llvm-openmp pytest
+          brew install gcc@13
+
       - name: Install package
         shell: bash -el {0}
         run: |
-          export CC=/usr/bin/clang
-          export CXX=/usr/bin/clang++
-          export PATH="/usr/local/opt/llvm/bin:$PATH"
-          export CPPFLAGS="$CPPFLAGS -Xpreprocessor -fopenmp -I/usr/local/opt/llvm/include"
-          export CFLAGS="$CFLAGS -I/usr/local/opt/libomp/include"
-          export CXXFLAGS="$CXXFLAGS -I/usr/local/opt/libomp/include"
-          export LDFLAGS="$LDFLAGS -Wl,-rpath,/usr/local/opt/libomp/lib -L/usr/local/opt/libomp/lib -lomp -L/usr/local/opt/llvm/lib"
-          python -m pip install . -v
+          conda install pytest matplotlib numba numpy scipy cython
+          export CC="gcc-13"
+          export CPPFLAGS="$CPPFLAGS -Xpreprocessor -fopenmp -lgomp"
+          python -m pip install -v .
+        
       - name: Run pytest
         shell: bash -el {0}
         run: pytest --capture=sys -v Tests/
diff --git a/.github/workflows/push_tests_ubun.yml b/.github/workflows/push_tests_ubun.yml
index 99c43c7..6761dbe 100644
--- a/.github/workflows/push_tests_ubun.yml
+++ b/.github/workflows/push_tests_ubun.yml
@@ -7,16 +7,18 @@ jobs:
     name: Test CyRK on Ubuntu
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: false
       matrix:
         python-version:
           - "3.8"
           - "3.9"
           - "3.10"
           - "3.11"
+          - "3.12"
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install Dependencies
@@ -34,9 +36,9 @@ jobs:
     name: Test Python 3.9 and Upload Coverage Report
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Set up Python 3.9
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: 3.9
       - name: Install Dependencies
diff --git a/.github/workflows/push_tests_win.yml b/.github/workflows/push_tests_win.yml
index 82428ab..372268f 100644
--- a/.github/workflows/push_tests_win.yml
+++ b/.github/workflows/push_tests_win.yml
@@ -10,16 +10,18 @@ jobs:
     name: Test CyRK on Windows
     runs-on: windows-latest
     strategy:
+      fail-fast: false
       matrix:
         python-version:
           - "3.8"
           - "3.9"
           - "3.10"
           - "3.11"
+          - "3.12"
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install Dependencies
diff --git a/CyRK/cy/cysolvertest.pyx b/CyRK/cy/cysolvertest.pyx
index 5fbb099..ca2bbd6 100644
--- a/CyRK/cy/cysolvertest.pyx
+++ b/CyRK/cy/cysolvertest.pyx
@@ -1,4 +1,4 @@
-# distutils: language = c++
+# distutils: language = c
 # cython: boundscheck=False, wraparound=False, nonecheck=False, cdivision=True, initializedcheck=False
 
 from libc.math cimport sin, cos